# API Reference

Auto-generated from the source docstrings. For task-writing guidance start with the [Guide](<https://docs.oryxflow.dev/docs/tasks/index.md>); this page is the exhaustive symbol reference.

## Top-level API

The public API re-exported from `oryxflow` — `run`, `preview`, `Workflow`, `WorkflowMulti`, the `requires` / `inherits` decorators, the `Parameter` types, and the `invalidate_*` / `enable_*` helpers.

## Engine — `oryxflow.core`

### oryxflow.core

Mini-engine: a small, self-contained execution engine for oryxflow. Provides the `Task` base class, target bases, `flatten`/`getpaths`, deterministic task ids, the `inherits`/`requires` decorators, `find_deps` and a sequential `build`.

The execution engine is **sequential**: the DAG is run in dependency order in-process. The `workers` argument is accepted for API compatibility but ignored.

#### Register

Bases: `type`

Minimal metaclass providing a class-level `task_family` property and instance memoization.

A property defined directly on 🇵🇾class:`Task` is only invoked for instances; reading `SomeTaskClass.task_family` needs this metaclass property (used eg by `WorkflowMulti`).

`__call__` memoizes instances so two `Cls(**same_params)` calls return the identical object (and `__init__` runs only on the first), preserving the instance identity that `Workflow`'s path/flow propagation depends on.

#### Task

Base class for all oryxflow tasks.

Subclasses declare 🇵🇾class:`~oryxflow.parameter.Parameter` members and override 🇵🇾meth:`run`, 🇵🇾meth:`requires` and 🇵🇾meth:`output`.

##### task\_family

```
task_family
```

The task family (class name) of this task instance.

##### logger

```
logger
```

Contextual logger for task authors; auto-tagged with task identity.

Lives in the `oryxflow` namespace, so it is silent until `oryxflow.enable_logging()` is called.

##### get\_params

```
get_params()
```

Return all `(name, Parameter)` pairs for this task, in declaration order.

##### get\_param\_names

```
get_param_names(include_significant=False)
```

Return parameter names. `include_significant=True` returns all params.

##### get\_param\_values

```
get_param_values(params, args, kwargs)
```

Resolve parameter values from positional args, kwargs and defaults.

:param params: list of `(param_name, Parameter)` :param args: positional arguments :param kwargs: keyword arguments :returns: list of `(name, value)` tuples, one per parameter

##### get\_task\_family

```
get_task_family()
```

The task family (class name) for this class.

##### to\_str\_params

```
to_str_params(only_significant=False, only_public=False)
```

Convert parameters to a `{name: serialized_value}` dict.

:param bool only\_significant: only include parameters marked significant. :param bool only\_public: accepted for API compatibility; visibility is not modeled.

##### clone

```
clone(cls=None, **kwargs)
```

Create a new task instance from this one, overriding some args.

Parameters common to this task and `cls` are carried over; `kwargs` take precedence. Parameters `cls` has bound (an imported task: its exported defaults, or `bind()`) are not carried over -- only `kwargs` override them.

##### requires\_grid

```
requires_grid(cls=None, derive=None, **grid)
```

Build the `requires()` dict for depending on `cls` once per value -- the runtime form of the `@requires_each` decorator, for when the values are only known here (computed from this task's own parameters).

Each keyword is a parameter name mapped to the **list** of values to fan out over; the cartesian product of those lists is taken. Every task returned is a 🇵🇾meth:`clone`, so the parameters this task and `cls` have in common -- everything the flow passed down -- reach every branch without being listed here.

Dict keys are the value itself for a single parameter, or `name_value` pairs joined with `_` for several; they are what `inputLoad(task=key)` selects on.

A value may also be a callable taking this task and returning the list, for a grid computed from this task's own **parameters**. It may not read this task's inputs -- `input()` is defined as `getpaths(self.requires())`, so that recurses forever.

`derive={'name': fn}` sets a FURTHER parameter per branch, computed from that branch's fanned values: `derive={'source': lambda v: URLS[v['region']]}`. It lands in the branch's parameters, and therefore in its `task_id` -- so editing the lookup invalidates exactly the branches it changes. The derived name stays OUT of the dict key (the key remains the fanned value, which the derived value is a function of).

::

```
def requires(self):
    return self.requires_grid(ProcessState, state=STATES[self.country])
```

##### complete

```
complete()
```

`True` if all of this task's outputs exist.

Note: `TaskData` OVERRIDES this to ALSO require the stored code fingerprint to match the current one (`TaskData._code_ok`), so a `code_version` bump makes a task incomplete and forces a rerun -- the fingerprint is authoritative here, not merely advisory. The AST source-hash is a SEPARATE, warn-only advisory (fires when code changed but `code_version` did not); it does not gate completeness.

##### output

```
output()
```

The output Target(s) this task produces. Default: none.

##### requires

```
requires()
```

The Task(s) this task depends on. Default: none.

##### input

```
input()
```

The outputs of the tasks returned by 🇵🇾meth:`requires`.

##### deps

```
deps()
```

Flattened list of required tasks.

##### run

```
run()
```

The task computation, to be overridden in a subclass.

#### Target

Minimal abstract target base.

#### LocalTarget

Bases: `Target`

Tiny local target base.

`self.path` is stored as-is (NOT coerced to `str`); subclasses (`CacheTarget`/`_LocalPathTarget`) override the rest and normalize the path.

#### inherits

Copy parameters (and nothing else) from one or more task classes onto the decorated task, and add `clone_parent`/`clone_parents` helpers. Avoids pythonic inheritance.

Supports positional tasks (`clone_parents` returns a list) or named tasks via keyword arguments (`clone_parents` returns a dict).

#### requires\_each

Fan out over ONE task: copies its parameters **except** the ones being fanned out, and defines `requires()` as a 🇵🇾meth:`Task.requires_grid` over them.

The decorated task is the point the branches converge into, so it must NOT carry the fanned-out parameter itself -- that is why those names are skipped when the parameters are copied across.

Stacks with `@requires`/`@inherits`/other `@requires_each` decorators. Pass a single-entry `{name: Cls}` dict to name the group; it defaults to the dependency's task family. A grid value may be a callable taking the task, resolved at `requires()` time against its parameters.

`derive={'name': fn}` sets a further parameter per branch from that branch's fanned values (see 🇵🇾meth:`Task.requires_grid`); derived names are excluded from the decorated task's parameters for the same reason fanned ones are.

#### requires

Same as 🇵🇾class:`inherits`, but also auto-defines the `requires` method.

#### TaskFailure

One failed task: the task instance plus why it failed.

#### RunResult

What happened to the DAG in one build: identities, status, failure context.

##### summary

```
summary()
```

Return the execution summary text (`print(result.summary())`).

#### MultiRunResult

Bases: `dict`

Return value of `WorkflowMulti.run()`: a `{flow_name: RunResult}` dict that also carries `.summary()`/`.success` so `print(result.summary())` works the same as for a single `Workflow` (whose `run()` returns a plain 🇵🇾class:`RunResult`).

##### summary

```
summary()
```

Per-flow execution summaries, each under a `===== <flow> =====` header.

#### flatten

```
flatten(struct)
```

Create a flat list of all items in a structured object (dicts, lists, items)::

```
>>> sorted(flatten({'a': 'foo', 'b': 'bar'}))
['bar', 'foo']
>>> sorted(flatten(['foo', ['bar', 'troll']]))
['bar', 'foo', 'troll']
>>> flatten('foo')
['foo']
>>> flatten(42)
[42]
```

#### getpaths

```
getpaths(struct)
```

Map all Tasks in a structured object to their `.output()`.

#### traversal\_scope

```
traversal_scope()
```

Memoize completeness, resolved dependencies and code fingerprints for the duration of one traversal -- a build, a preview, a `Workflow.complete()`, `accept_code()`, the upstream/downstream walks behind the invalidate helpers.

Nested scopes share one memo and only the outermost drops it, so a task's `run()` calling `oryxflow.run()` (flow-within-a-flow) needs no special case: that nested build clears the shared volatile memo whenever it materializes something.

#### traversal\_stats

```
traversal_stats()
```

Memo counters for the traversal in flight, else the most recent one.

Internal. The regression tests assert on the MISS counts: one miss per unique task is the invariant this whole section exists to hold, and unlike wall-clock it is deterministic.

#### traversal\_memo\_clear

```
traversal_memo_clear()
```

Drop the volatile memo: something changed what is complete (a task materialized, an output was invalidated). The structural memos are untouched -- neither the code nor the DAG shape changes mid-traversal.

#### complete\_cached

```
complete_cached(task, cascade, compute)
```

Evaluate a cascading `complete()` at most once per task per traversal.

`cascade=False` is never memoized: it does no recursion, so there is nothing to save, and it is what the load paths ask right after a save.

#### task\_id\_str

```
task_id_str(task_family, params)
```

Return a canonical, deterministic string identifying a task.

The id is `{family}_{param_summary}_{md5(sorted_json)[:10]}` so that `task_id.split('_')[0]` yields the task family (the directory convention). `param_summary` is only the readable part, capped at `TASK_ID_TRUNCATE_SUMMARY` chars; uniqueness comes from the hash, which covers the full params.

:param task\_family: the task family (class name) :param params: dict mapping parameter names to serialized (str) values

#### dfs\_paths

```
dfs_paths(start_task, goal_task_family, path=None)
```

Back-compat generator: yield tasks on paths from `start_task` to `goal_task_family` (`goal_task_family=None` yields the whole upstream DAG). Superseded by `find_paths` (ordered paths) and `find_deps` (deduped set); both are memoized.

#### find\_deps

```
find_deps(task, upstream_task_family)
```

Set of all tasks on all paths between `task` (the downstream root) and `upstream_task_family`. `upstream_task_family=None` returns the whole upstream DAG.

#### find\_paths

```
find_paths(task, upstream_task_family)
```

Ordered dependency paths (`task` -\> ... -\> `upstream_task_family`), deduped, root first. Returns a list of lists of task instances; empty if the family is unreachable.

#### build

```
build(tasks, workers=1, detailed_summary=False, flow=None, **ignored)
```

Run `tasks` and their dependencies sequentially, in dependency order.

All state is local to this call, so a task's `run()` may itself call `oryxflow.run` / `flow.run` (the flow-within-a-flow pattern) without corrupting the outer build.

External tasks (`external=True` or `run is None`) are never executed; if still incomplete after their dependencies, they are marked failed.

:param flow: flow name when launched via `Workflow`/`WorkflowMulti`; stamped into this build's event envelopes. :returns: a 🇵🇾class:`RunResult` with `.ran`/`.complete`/`.failed` task identities, `.success`, `.run_id`, per-task `.reasons` and code-change `.warnings`.

## Parameters — `oryxflow.parameter`

### oryxflow.parameter

Self-contained, trimmed set of parameter types used by oryxflow.

There is no command-line / config-file value resolution, parameter visibility, `date_interval`, freezing (`FrozenOrderedDict`) or `jsonschema` support. Values are resolved from the constructor argument or the `default` only.

Only the parameter types oryxflow actually uses are kept: `Parameter`, `IntParameter`, `FloatParameter`, `BoolParameter`, `DateParameter`, `DictParameter`, `ListParameter`, `ChoiceParameter` and `EnumParameter`.

#### ParameterException

Bases: `Exception`

Base parameter exception.

#### MissingParameterException

Bases: `ParameterException`

Raised when a required parameter has no value and no default.

#### UnknownParameterException

Bases: `ParameterException`

Raised when an unknown parameter is supplied to a task.

#### DuplicateParameterException

Bases: `ParameterException`

Raised when a parameter is supplied both positionally and as a keyword.

#### Parameter

Parameter whose value is a `str`, and the base class for the other parameter types.

Parameters are set on the Task class to parameterize tasks::

```
class MyTask(oryxflow.tasks.TaskData):
    foo = oryxflow.Parameter()
```

When a value is not provided at instantiation, the `default` is used.

##### has\_task\_value

```
has_task_value()
```

Whether a default value is available.

##### task\_value

```
task_value()
```

The normalized default value. Raises if no default is set.

##### parse

```
parse(x)
```

Parse an individual value from a string. Identity by default.

##### serialize

```
serialize(x)
```

Convert the value `x` to a string. Opposite of 🇵🇾meth:`parse`.

##### normalize

```
normalize(x)
```

Normalize a parsed/default/constructor value. Identity by default.

#### IntParameter

Bases: `Parameter`

Parameter whose value is an `int`.

#### FloatParameter

Bases: `Parameter`

Parameter whose value is a `float`.

#### BoolParameter

Bases: `Parameter`

A Parameter whose value is a `bool`. Has an implicit default of `False`.

##### parse

```
parse(val)
```

Parse a `bool` from the string, matching 'true'/'false' case-insensitively.

#### DateParameter

Bases: `Parameter`

Parameter whose value is a 🇵🇾class:`~datetime.date`, formatted `YYYY-MM-DD`.

#### DictParameter

Bases: `Parameter`

Parameter whose value is a `dict`.

The value is stored as-is (no freezing); it is serialized with sorted keys so that the task id stays deterministic.

#### ListParameter

Bases: `Parameter`

Parameter whose value is a `list`.

The value is stored as-is (no freezing); it is serialized as JSON so that the task id stays deterministic.

#### ChoiceParameter

Bases: `Parameter`

A string-valued parameter restricted to a fixed set of `choices`::

```
class MyTask(oryxflow.tasks.TaskData):
    model = oryxflow.ChoiceParameter(choices=['rf', 'lgbm'], default='rf')
```

Values stay plain strings (no `enum.Enum` ceremony, unlike :class:`EnumParameter`); a value outside `choices` raises immediately at task construction (or when the default is resolved), so typos fail fast instead of dying deep in downstream code.

#### EnumParameter

Bases: `Parameter`

A parameter whose value is an :class:`~enum.Enum`. Pass the enum class via `enum=`::

```
class Model(enum.Enum):
    Honda = 1
    Volvo = 2

class MyTask(oryxflow.tasks.TaskData):
    my_param = oryxflow.EnumParameter(enum=Model)
```

## Tasks — `oryxflow.tasks`

### oryxflow.tasks

#### TaskData

Bases: `Task`

Task which has data as input and output

Attributes:

| Name | Type | Description |
| --- | --- | --- |
| `target_class` | `obj` | target data format |
| `target_ext` | `str` | file extension |
| `persists` | `list` | list of strings naming the outputs this task saves. Declare it on your task class, e.g. `persists = ['x', 'y']`. `persist` (singular) is a backwards-compatible alias for the same thing; prefer `persists`. |
| `data` | `dict` | data container for all outputs |

##### reset

```
reset(confirm=False)
```

Reset a task, eg by deleting output file

##### invalidate

```
invalidate(confirm=False)
```

Reset a task, eg by deleting output file

##### complete

```
complete(cascade=True)
```

Check if a task is complete: output exists AND the stored code fingerprint matches the current one (`_code_ok` -- a `code_version` bump makes the task incomplete and forces a rerun; authoritative, unlike the warn-only AST source-hash advisory). With `check_dependencies`, cascades upstream.

The cascading form is evaluated once per task per engine traversal (see `core.traversal_scope`); `cascade=False` is never memoized.

##### output

```
output()
```

Output target(s) this task produces

##### inputLoad

```
inputLoad(keys=None, task=None, cached=False, as_dict=False, flatten=True)
```

Load all or several outputs from task

Parameters:

| Name | Type | Description | Default |
| --- | --- | --- | --- |
| `keys` | `list` | list of data to load | `None` |
| `task` | `str, class` | if requires multiple tasks load that task 'input1' for eg `def requires: {'input1':Task1(), 'input2':Task2()}`. For a fan-out, name the group to get just its branches — pass the dependency **class** (`task=RegionNarrative`) rather than its name and a rename can't break it. | `None` |
| `cached` | `bool` | cache data in memory | `False` |
| `as_dict` | `bool` | if the inputs were saved as a dictionary. use this to return them as dictionary. | `False` |
| `flatten` | `bool` | False groups a fan-out's branches under one key, so a task that mixes a fan-out with shared inputs can tell them apart | `True` |

Returns: list or dict of all task output

##### inputLoadConcat

```
inputLoadConcat(keys=None, tag=True, tagkeys=None, as_dict=False, concat_fn=None, cached=False, task=None, flatten=True)
```

Load every dependency and concatenate into one DataFrame. Works for the dict form of requires() ({key: Task(...)}) and the list/positional form. By default each dependency's significant params are added as columns. concat\_fn(identifier, params, df)-\>df overrides.

task: concatenate only one fan-out group (the group name, or the dependency class -- pass the class and a rename can't break it), or only one dependency. flatten: False returns {name: DataFrame} -- each fan-out group concatenated within itself, every other dependency its own entry.

##### outputLoad

```
outputLoad(keys=None, as_dict=False, cached=False)
```

Load all or several outputs from task

Parameters:

| Name | Type | Description | Default |
| --- | --- | --- | --- |
| `keys` | `list` | list of data to load | `None` |
| `as_dict` | `bool` | cache data in memory | `False` |
| `cached` | `bool` | cache data in memory | `False` |

Returns: list or dict of all task output

##### save

```
save(data, from_list=False, **kwargs)
```

Persist data to target

Parameters:

| Name | Type | Description | Default |
| --- | --- | --- | --- |
| `data` | `dict` | data to save. keys are the self.persist keys and values is data | *required* |

#### TaskCache

Bases: `TaskData`

Task which saves to cache

#### TaskCachePandas

Bases: `TaskData`

Task which saves to cache pandas dataframes

#### TaskJson

Bases: `TaskData`

Task which saves to json

#### TaskPickle

Bases: `TaskData`

Task which saves to pickle

#### TaskCSVPandas

Bases: `TaskData`

Task which saves to CSV

#### TaskCSVGZPandas

Bases: `TaskData`

Task which saves to CSV

#### TaskExcelPandasSingle

Bases: `TaskData`

Task which saves each persist key as a separate Excel file

#### TaskExcelPandas

Bases: `TaskData`

Task which saves multiple dataframes as sheets in a single Excel file

#### TaskPqPandas

Bases: `TaskData`

Task which saves to parquet

#### TaskMarkdown

Bases: `TaskData`

Task which saves to markdown and HTML

#### TaskAggregator

Bases: `Task`

Task which groups other tasks, without saving an output of its own

Declare the group in `requires()` (or with `@oryxflow.requires`) and leave `run()` empty. The group is complete when every task it requires is complete.

example::

```
@oryxflow.requires({'ols': TaskTrainOLS, 'gbm': TaskTrainGBM})
class TaskTrainAll(oryxflow.tasks.TaskAggregator):
    pass

oryxflow.Workflow(TaskTrainAll).run()
```

For a one-off group that needs no task of its own, pass a list instead: `oryxflow.run([TaskTrainOLS(), TaskTrainGBM()])`.

## Targets — `oryxflow.targets`

### oryxflow.targets

#### CacheTarget

Bases: `LocalTarget`

Saves to in-memory cache, loads to python object

##### load

```
load(cached=True)
```

Load from in-memory cache

Returns: python object

##### save

```
save(df)
```

Save dataframe to in-memory cache

Parameters:

| Name | Type | Description | Default |
| --- | --- | --- | --- |
| `df` | `obj` | pandas dataframe | *required* |

Returns: filename

#### DataTarget

Bases: `_LocalPathTarget`

Local target which saves in-memory data (eg dataframes) to persistent storage (eg files) and loads from storage to memory

This is an abstract class that you should extend.

##### load

```
load(fun, cached=False, **kwargs)
```

Runs a function to load data from storage into memory

Parameters:

| Name | Type | Description | Default |
| --- | --- | --- | --- |
| `fun` | `function` | loading function | *required* |
| `cached` | `bool` | keep data cached in memory | `False` |
| `**kwargs` |  | arguments to pass to `fun` | `{}` |

Returns: data object

##### save

```
save(df, fun, **kwargs)
```

Runs a function to save data from memory into storage

Parameters:

| Name | Type | Description | Default |
| --- | --- | --- | --- |
| `df` | `obj` | data to save | *required* |
| `fun` | `function` | saving function | *required* |
| `**kwargs` |  | arguments to pass to `fun` | `{}` |

Returns: filename

#### CSVPandasTarget

Bases: `DataTarget`

Saves to CSV, loads to pandas dataframe

##### load

```
load(cached=False, **kwargs)
```

Load from csv to pandas dataframe

Parameters:

| Name | Type | Description | Default |
| --- | --- | --- | --- |
| `cached` | `bool` | keep data cached in memory | `False` |
| `**kwargs` |  | arguments to pass to pd.read\_csv | `{}` |

Returns: pandas dataframe

##### save

```
save(df, **kwargs)
```

Save dataframe to csv

Parameters:

| Name | Type | Description | Default |
| --- | --- | --- | --- |
| `df` | `obj` | pandas dataframe | *required* |
| `**kwargs` | `dict` | additional arguments to pass to df.to\_csv | `{}` |

Returns: filename

#### CSVGZPandasTarget

Bases: `CSVPandasTarget`

Saves to CSV gzip, loads to pandas dataframe

##### save

```
save(df, **kwargs)
```

Save dataframe to csv gzip

Parameters:

| Name | Type | Description | Default |
| --- | --- | --- | --- |
| `df` | `obj` | pandas dataframe | *required* |
| `**kwargs` | `dict` | additional arguments to pass to df.to\_csv | `{}` |

Returns: filename

#### ExcelPandasTarget

Bases: `DataTarget`

Saves to Excel, loads to pandas dataframe

##### load

```
load(cached=False, **kwargs)
```

Load from Excel to pandas dataframe

Parameters:

| Name | Type | Description | Default |
| --- | --- | --- | --- |
| `cached` | `bool` | keep data cached in memory | `False` |
| `**kwargs` |  | arguments to pass to pd.read\_excel | `{}` |

Returns: pandas dataframe

##### save

```
save(df, formatted=False, **kwargs)
```

Save dataframe to Excel

Parameters:

| Name | Type | Description | Default |
| --- | --- | --- | --- |
| `df` | `obj` | pandas dataframe | *required* |
| `formatted` | `bool` | write a formatted sheet 'Sheet1' via oryxflow.utils.excel\_write | `False` |
| `**kwargs` | `dict` | df.to\_excel arguments, or excel\_write options if formatted | `{}` |

Returns: filename

#### ExcelPandasSheetsTarget

Bases: `_LocalPathTarget`

Saves dict of dataframes as sheets in a single Excel file, loads selectively by sheet

##### load

```
load(keys=None, cached=False, **kwargs)
```

Load sheets from Excel file

Parameters:

| Name | Type | Description | Default |
| --- | --- | --- | --- |
| `keys` | `str / list` | sheet name(s) to load. None loads all sheets | `None` |
| `cached` | `bool` | keep data cached in memory | `False` |
| `**kwargs` |  | arguments to pass to pd.read\_excel | `{}` |

Returns: dict of dataframes, single dataframe, or filtered dict

##### save

```
save(data, formatted=False, **kwargs)
```

Save dict of dataframes as sheets in a single Excel file

Parameters:

| Name | Type | Description | Default |
| --- | --- | --- | --- |
| `data` | `dict` | {sheet\_name: dataframe}, or {sheet\_name: spec dict} if formatted | *required* |
| `formatted` | `bool` | write formatted sheets via oryxflow.utils.excel\_write | `False` |
| `kwargs` |  | additional arguments to pass to df.to\_excel, or excel\_write options if formatted | `{}` |

Returns: filename

#### PqPandasTarget

Bases: `DataTarget`

Saves to parquet, loads to pandas dataframe

##### load

```
load(cached=False, **kwargs)
```

Load from parquet to pandas dataframe

Parameters:

| Name | Type | Description | Default |
| --- | --- | --- | --- |
| `cached` | `bool` | keep data cached in memory | `False` |
| `**kwargs` |  | arguments to pass to pd.read\_parquet | `{}` |

Returns: pandas dataframe

##### save

```
save(df, **kwargs)
```

Save dataframe to parquet

Parameters:

| Name | Type | Description | Default |
| --- | --- | --- | --- |
| `df` | `obj` | pandas dataframe | *required* |
| `**kwargs` | `dict` | additional arguments to pass to df.to\_parquet | `{}` |

Returns: filename

#### JsonTarget

Bases: `DataTarget`

Saves to json, loads to dict

##### load

```
load(cached=False, **kwargs)
```

Load from json to dict

Parameters:

| Name | Type | Description | Default |
| --- | --- | --- | --- |
| `cached` | `bool` | keep data cached in memory | `False` |
| `**kwargs` |  | arguments to pass to json.load | `{}` |

Returns: dict

##### save

```
save(dict_, **kwargs)
```

Save dict to json

Parameters:

| Name | Type | Description | Default |
| --- | --- | --- | --- |
| `dict_` | `dict` | python dict | *required* |
| `**kwargs` | `dict` | additional arguments to pass to json.dump | `{}` |

Returns: filename

#### MarkdownTarget

Bases: `DataTarget`

Saves to markdown (.md) and HTML (.html), loads markdown string

##### load

```
load(cached=False, **kwargs)
```

Load from markdown file to string

Parameters:

| Name | Type | Description | Default |
| --- | --- | --- | --- |
| `cached` | `bool` | keep data cached in memory | `False` |
| `**kwargs` |  | arguments to pass to read function | `{}` |

Returns: markdown string

##### save

```
save(md_string, **kwargs)
```

Save markdown string to .md and .html files

Parameters:

| Name | Type | Description | Default |
| --- | --- | --- | --- |
| `md_string` | `str` | markdown string | *required* |
| `**kwargs` | `dict` | additional arguments to pass to markdown.markdown | `{}` |

Returns: filename

#### PickleTarget

Bases: `DataTarget`

Saves to pickle, loads to python obj

##### load

```
load(cached=False, **kwargs)
```

Load from pickle to obj

Parameters:

| Name | Type | Description | Default |
| --- | --- | --- | --- |
| `cached` | `bool` | keep data cached in memory | `False` |
| `**kwargs` |  | arguments to pass to pickle.load | `{}` |

Returns: dict

##### save

```
save(obj, **kwargs)
```

Save obj to pickle

Parameters:

| Name | Type | Description | Default |
| --- | --- | --- | --- |
| `obj` | `obj` | python object | *required* |
| `**kwargs` | `dict` | additional arguments to pass to pickle.dump | `{}` |

Returns: filename