codeupipe 0.1.0__tar.gz

codeupipe-0.1.0/LICENSE

@@ -0,0 +1,190 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity granting the License,
+      including any individual or entity that controls, is controlled by, or is
+      under common control with such entity. For the purposes of this License,
+      "control" means (i) the power, direct or indirect, to cause the direction
+      or management of such entity, whether by contract or otherwise, or (ii)
+      ownership of fifty percent (50%) or more of the outstanding shares, or
+      (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or legal entity exercising
+      permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation source,
+      and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical transformation
+      or translation of a Source form, including but not limited to compiled
+      object code, generated documentation, and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or Object form,
+      made available under the terms of this License, as indicated by a copyright
+      notice that is included in or attached to the work (which, for the purposes
+      of this License, shall not be modified except as required by this License).
+
+      "Derivative Works" shall mean any work, whether in Source or Object form,
+      that is based upon (or derived from) the Work and for which the editorial
+      revisions, annotations, elaborations, or other modifications represent, as
+      a whole, an original work of authorship. For the purposes of this License,
+      Derivative Works shall not include works that remain separable from, or
+      merely link (or bind by name) to the interfaces of, the Work and derivative
+      works thereof.
+
+      "Contribution" shall mean any work of authorship, including the original
+      version of the Work and any modifications or additions to that Work or
+      Derivative Works thereof, that is intentionally submitted to Licensor for
+      inclusion in the Work by the copyright owner or by an individual or legal
+      entity authorized to submit on behalf of the copyright owner. For the
+      purposes of this definition, "submitted" means any form of electronic,
+      verbal, or written communication sent to the Licensor or its
+      representatives, including but not limited to communication on electronic
+      mailing lists, source code control systems, and issue tracking systems that
+      are managed by, or on behalf of, the Licensor for the purpose of discussing
+      and improving the Work, but excluding communication that is conspicuously
+      marked or otherwise designated in writing by the copyright owner as "Not a
+      Contribution."
+
+      "Contributor" shall mean Licensor and any individual or legal entity on
+      behalf of whom a Contribution has been received by Licensor and subsequently
+      incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of this
+      License, each Contributor hereby grants to You a perpetual, worldwide,
+      non-exclusive, no-charge, royalty-free, irrevocable copyright license to
+      use, reproduce, modify, merge, publish, distribute, sublicense, and/or
+      sell copies of the Work, and to permit persons to whom the Work is
+      furnished to do so, subject to the following conditions:
+
+      The above copyright notice and this permission notice shall be included in
+      all copies or substantial portions of the Work.
+
+   3. Grant of Patent License. Subject to the terms and conditions of this
+      License, each Contributor hereby grants to You a perpetual, worldwide,
+      non-exclusive, no-charge, royalty-free, irrevocable (except as stated in
+      this section) patent license to make, have made, use, offer to sell, sell,
+      import, and otherwise transfer the Work, where such license applies only to
+      those patent claims licensable by such Contributor that are necessarily
+      infringed by their Contribution(s) alone or by combination of their
+      Contribution(s) with the Work to which such Contribution(s) was submitted.
+      If You institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work or a
+      Contribution incorporated within the Work constitutes direct or
+      contributory patent infringement, then any patent licenses granted to You
+      under this License for that Work shall terminate as of the date such
+      litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the Work or
+      Derivative Works thereof in any medium, with or without modifications, and
+      in Source or Object form, provided that You meet the following conditions:
+
+      (a) You must give any other recipients of the Work or Derivative Works a
+          copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices stating
+          that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works that You
+          distribute, all copyright, trademark, patent, attribution and other
+          notices from the Source form of the Work, excluding those notices that
+          do not pertain to any part of the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" file as part of its distribution, then
+          any Derivative Works that You distribute must include a readable copy
+          of the attribution notices contained within such NOTICE file, excluding
+          those notices that do not pertain to any part of the Derivative Works,
+          in at least one of the following places: within a NOTICE file
+          distributed as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or, within
+          a display generated by the Derivative Works, if and wherever such
+          third-party notices normally appear. The contents of the NOTICE file
+          are for informational purposes only and do not modify the License. You
+          may add Your own attribution notices within Derivative Works that You
+          distribute, alongside or as an addendum to the NOTICE text from the
+          Work, provided that such additional attribution notices cannot be
+          construed as modifying the License.
+
+      You may add Your own copyright notice to Your modifications and may provide
+      additional or different license terms and conditions for use, reproduction,
+      or distribution of Your modifications, or for any such Derivative Works as a
+      whole, provided Your use, reproduction, and distribution of the Work
+      otherwise complies with the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise, any
+      Contribution intentionally submitted for inclusion in the Work by You to
+      the Licensor shall be under the terms and conditions of this License,
+      without any additional terms or conditions. Notwithstanding the above,
+      nothing herein shall supersede or modify the terms of any separate license
+      agreement you may have executed with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade names,
+      trademarks, service marks, or product names of the Licensor, except as
+      required for reasonable and customary use in describing the origin of the
+      Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or agreed to in
+      writing, Licensor provides the Work (and each Contributor provides its
+      Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+      KIND, either express or implied, including, without limitation, any
+      warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or
+      FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for
+      determining the appropriateness of using or redistributing the Work and
+      assume any risks associated with Your exercise of permissions under this
+      License.
+
+   8. Limitation of Liability. In no event and under no legal theory, whether in
+      tort (including negligence), contract, or otherwise, unless required by
+      applicable law (such as deliberate and grossly negligent acts) or agreed
+      to in writing, shall any Contributor be liable to You for damages,
+      including any direct, indirect, special, incidental, or consequential
+      damages of any character arising as a result of this License or out of the
+      use or inability to use the Work (including but not limited to damages for
+      loss of goodwill, work stoppage, computer failure or malfunction, or any
+      and all other commercial damages or losses), even if such Contributor has
+      been advised of the possibility of such damages.
+
+   9. Accepting Support, Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer, and charge
+      a fee for, acceptance of support, warranty, indemnity, or other liability
+      obligations and/or rights consistent with this License. However, in
+      accepting such obligations, You may act only on Your own behalf and on Your
+      sole responsibility, not on behalf of any other Contributor, and only if
+      You agree to indemnify, defend, and hold each Contributor harmless for any
+      liability incurred by, or claims asserted against, such Contributor by
+      reason of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following boilerplate
+      notice, with the fields enclosed by brackets "[]" replaced with your own
+      identifying information. (Don't include the brackets!) The text should be
+      enclosed in the appropriate comment syntax for the file format. We also
+      recommend that a file or class name and description of purpose be included
+      on the same "page" as the copyright notice for easier identification within
+      third-party archives.
+
+   Copyright 2025 Orchestrate LLC (Joshua @orchestrate.solutions)
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

codeupipe-0.1.0/PKG-INFO

@@ -0,0 +1,216 @@
+Metadata-Version: 2.4
+Name: codeupipe
+Version: 0.1.0
+Summary: Python pipeline framework — composable Payload-Filter-Pipeline pattern
+Author: Joshua Wink
+License: Apache-2.0
+Project-URL: Homepage, https://github.com/codeuchain/codeupipe
+Project-URL: Repository, https://github.com/codeuchain/codeupipe
+Project-URL: Issues, https://github.com/codeuchain/codeupipe/issues
+Keywords: pipeline,filter,payload,etl,workflow,streaming
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# codeupipe
+
+<!-- cup:ref file=codeupipe/__init__.py hash=afd4ab5 -->
+
+Python pipeline framework — composable **Payload → Filter → Pipeline** pattern with streaming support. Zero external dependencies.
+
+Experimental successor to [codeuchain](https://github.com/codeuchain/codeuchain) (Python only).
+
+<!-- /cup:ref -->
+
+## Core Concepts
+
+<!-- cup:ref file=codeupipe/core/__init__.py hash=e3e2418 -->
+| Concept | Role |
+|---|---|
+| **Payload** | Immutable data container flowing through the pipeline |
+| **MutablePayload** | Mutable sibling for performance-critical bulk edits |
+| **Filter** | Processing unit — takes a Payload in, returns a transformed Payload out (sync or async) |
+| **StreamFilter** | Streaming processing unit — receives one chunk, yields 0, 1, or N output chunks |
+| **Pipeline** | Orchestrator — `.run()` for batch, `.stream()` for streaming |
+| **Valve** | Conditional flow control — gates a Filter with a predicate |
+| **Tap** | Non-modifying observation point — inspect without changing (sync or async) |
+| **State** | Pipeline execution metadata — tracks what ran, what was skipped, errors, chunk counts |
+| **Hook** | Lifecycle hooks — before/after/on_error for pipeline execution (sync or async) |
+| **RetryFilter** | Resilience wrapper — retries a Filter up to N times before giving up |
+<!-- /cup:ref -->
+
+## Install
+
+```bash
+pip install -e .
+```
+
+## Quick Start
+
+```python
+import asyncio
+from codeupipe import Payload, Pipeline
+
+# Filters can be sync or async — both work
+class CleanInput:
+    def call(self, payload):
+        return payload.insert("text", payload.get("text", "").strip())
+
+class Validate:
+    def call(self, payload):
+        if not payload.get("text"):
+            raise ValueError("Empty input")
+        return payload
+
+# Build and run
+pipeline = Pipeline()
+pipeline.add_filter(CleanInput(), name="clean")
+pipeline.add_filter(Validate(), name="validate")
+
+result = asyncio.run(pipeline.run(Payload({"text": "  hello  "})))
+print(result.get("text"))  # "hello"
+```
+
+## Valve (Conditional Flow)
+
+```python
+from codeupipe import Valve
+
+class DiscountFilter:
+    def call(self, payload):
+        price = payload.get("price", 0)
+        return payload.insert("price", price * 0.9)
+
+# Only applies when predicate returns True
+pipeline.add_filter(
+    Valve("discount", DiscountFilter(), lambda p: p.get("tier") == "premium"),
+    name="discount",
+)
+```
+
+## Tap (Observation)
+
+```python
+class AuditTap:
+    async def observe(self, payload):
+        print(f"Payload at this point: {payload.to_dict()}")
+
+pipeline.add_tap(AuditTap(), name="audit")
+```
+
+## Streaming
+
+Process an async stream of chunks through the same pipeline at constant memory.
+
+```python
+from codeupipe import Payload, Pipeline
+
+class UppercaseFilter:
+    def call(self, payload):
+        return payload.insert("name", payload.get("name", "").upper())
+
+async def names():
+    for n in ["alice", "bob", "charlie"]:
+        yield Payload({"name": n})
+
+async def main():
+    pipeline = Pipeline()
+    pipeline.add_filter(UppercaseFilter(), name="upper")
+
+    async for result in pipeline.stream(names()):
+        print(result.get("name"))  # ALICE, BOB, CHARLIE
+
+asyncio.run(main())
+```
+
+Use `StreamFilter` to drop, fan-out, or batch:
+
+```python
+from typing import AsyncIterator
+
+class DropEmpty:
+    async def stream(self, chunk: Payload) -> AsyncIterator[Payload]:
+        if chunk.get("line", "").strip():
+            yield chunk
+
+class SplitWords:
+    async def stream(self, chunk: Payload) -> AsyncIterator[Payload]:
+        for word in chunk.get("text", "").split():
+            yield Payload({"word": word})
+```
+
+## Execution State
+
+```python
+result = await pipeline.run(payload)
+print(pipeline.state.executed)           # ['clean', 'validate']
+print(pipeline.state.skipped)            # ['admin_only']
+print(pipeline.state.chunks_processed)   # {'upper': 3}  (streaming mode)
+```
+
+## Docs
+
+| Document | Purpose |
+|----------|---------|
+| [INDEX.md](INDEX.md) | Project structure map (verified by `cup doc-check`) |
+| [CONCEPTS.md](CONCEPTS.md) | Full API reference with runnable examples |
+| [BEST_PRACTICES.md](BEST_PRACTICES.md) | Project structure, naming, testing strategy |
+| [SKILL.md](SKILL.md) | Agent skill reference — types, patterns, conversion |
+
+## CLI (`cup`)
+
+<!-- cup:ref file=codeupipe/cli.py symbols=main,scaffold,bundle,lint,coverage,report,doc_check hash=1e63d0e -->
+The `cup` command-line tool scaffolds, lints, and analyzes CUP projects:
+
+```bash
+cup new filter validate_email src/signup   # Scaffold a filter + test
+cup new pipeline signup src/signup --steps validate_email hash_password
+cup list                                   # Show available component types
+cup bundle src/signup                      # Generate __init__.py re-exports
+cup lint src/signup                        # Check CUP conventions (CUP000–CUP008)
+cup coverage src/signup                    # Map component↔test coverage gaps
+cup report src/signup                      # Health report with scores, orphans, staleness
+cup doc-check .                            # Verify doc freshness (cup:ref markers)
+```
+<!-- /cup:ref -->
+
+## Testing Utilities
+
+<!-- cup:ref file=codeupipe/testing.py symbols=run_filter,assert_payload,mock_filter hash=c119f9c -->
+`codeupipe.testing` provides zero-boilerplate test helpers:
+
+```python
+from codeupipe.testing import run_filter, assert_payload, mock_filter
+
+def test_my_filter():
+    result = run_filter(MyFilter(), {"input": "data"})
+    assert_payload(result, output="expected")
+
+def test_with_mock():
+    f = mock_filter(status="ok")
+    result = run_filter(f, {"x": 1})
+    assert f.call_count == 1
+```
+<!-- /cup:ref -->
+
+## Test
+
+```bash
+pytest  # 909 tests
+```
+
+## License
+
+Apache 2.0

codeupipe-0.1.0/README.md

@@ -0,0 +1,190 @@
+# codeupipe
+
+<!-- cup:ref file=codeupipe/__init__.py hash=afd4ab5 -->
+
+Python pipeline framework — composable **Payload → Filter → Pipeline** pattern with streaming support. Zero external dependencies.
+
+Experimental successor to [codeuchain](https://github.com/codeuchain/codeuchain) (Python only).
+
+<!-- /cup:ref -->
+
+## Core Concepts
+
+<!-- cup:ref file=codeupipe/core/__init__.py hash=e3e2418 -->
+| Concept | Role |
+|---|---|
+| **Payload** | Immutable data container flowing through the pipeline |
+| **MutablePayload** | Mutable sibling for performance-critical bulk edits |
+| **Filter** | Processing unit — takes a Payload in, returns a transformed Payload out (sync or async) |
+| **StreamFilter** | Streaming processing unit — receives one chunk, yields 0, 1, or N output chunks |
+| **Pipeline** | Orchestrator — `.run()` for batch, `.stream()` for streaming |
+| **Valve** | Conditional flow control — gates a Filter with a predicate |
+| **Tap** | Non-modifying observation point — inspect without changing (sync or async) |
+| **State** | Pipeline execution metadata — tracks what ran, what was skipped, errors, chunk counts |
+| **Hook** | Lifecycle hooks — before/after/on_error for pipeline execution (sync or async) |
+| **RetryFilter** | Resilience wrapper — retries a Filter up to N times before giving up |
+<!-- /cup:ref -->
+
+## Install
+
+```bash
+pip install -e .
+```
+
+## Quick Start
+
+```python
+import asyncio
+from codeupipe import Payload, Pipeline
+
+# Filters can be sync or async — both work
+class CleanInput:
+    def call(self, payload):
+        return payload.insert("text", payload.get("text", "").strip())
+
+class Validate:
+    def call(self, payload):
+        if not payload.get("text"):
+            raise ValueError("Empty input")
+        return payload
+
+# Build and run
+pipeline = Pipeline()
+pipeline.add_filter(CleanInput(), name="clean")
+pipeline.add_filter(Validate(), name="validate")
+
+result = asyncio.run(pipeline.run(Payload({"text": "  hello  "})))
+print(result.get("text"))  # "hello"
+```
+
+## Valve (Conditional Flow)
+
+```python
+from codeupipe import Valve
+
+class DiscountFilter:
+    def call(self, payload):
+        price = payload.get("price", 0)
+        return payload.insert("price", price * 0.9)
+
+# Only applies when predicate returns True
+pipeline.add_filter(
+    Valve("discount", DiscountFilter(), lambda p: p.get("tier") == "premium"),
+    name="discount",
+)
+```
+
+## Tap (Observation)
+
+```python
+class AuditTap:
+    async def observe(self, payload):
+        print(f"Payload at this point: {payload.to_dict()}")
+
+pipeline.add_tap(AuditTap(), name="audit")
+```
+
+## Streaming
+
+Process an async stream of chunks through the same pipeline at constant memory.
+
+```python
+from codeupipe import Payload, Pipeline
+
+class UppercaseFilter:
+    def call(self, payload):
+        return payload.insert("name", payload.get("name", "").upper())
+
+async def names():
+    for n in ["alice", "bob", "charlie"]:
+        yield Payload({"name": n})
+
+async def main():
+    pipeline = Pipeline()
+    pipeline.add_filter(UppercaseFilter(), name="upper")
+
+    async for result in pipeline.stream(names()):
+        print(result.get("name"))  # ALICE, BOB, CHARLIE
+
+asyncio.run(main())
+```
+
+Use `StreamFilter` to drop, fan-out, or batch:
+
+```python
+from typing import AsyncIterator
+
+class DropEmpty:
+    async def stream(self, chunk: Payload) -> AsyncIterator[Payload]:
+        if chunk.get("line", "").strip():
+            yield chunk
+
+class SplitWords:
+    async def stream(self, chunk: Payload) -> AsyncIterator[Payload]:
+        for word in chunk.get("text", "").split():
+            yield Payload({"word": word})
+```
+
+## Execution State
+
+```python
+result = await pipeline.run(payload)
+print(pipeline.state.executed)           # ['clean', 'validate']
+print(pipeline.state.skipped)            # ['admin_only']
+print(pipeline.state.chunks_processed)   # {'upper': 3}  (streaming mode)
+```
+
+## Docs
+
+| Document | Purpose |
+|----------|---------|
+| [INDEX.md](INDEX.md) | Project structure map (verified by `cup doc-check`) |
+| [CONCEPTS.md](CONCEPTS.md) | Full API reference with runnable examples |
+| [BEST_PRACTICES.md](BEST_PRACTICES.md) | Project structure, naming, testing strategy |
+| [SKILL.md](SKILL.md) | Agent skill reference — types, patterns, conversion |
+
+## CLI (`cup`)
+
+<!-- cup:ref file=codeupipe/cli.py symbols=main,scaffold,bundle,lint,coverage,report,doc_check hash=1e63d0e -->
+The `cup` command-line tool scaffolds, lints, and analyzes CUP projects:
+
+```bash
+cup new filter validate_email src/signup   # Scaffold a filter + test
+cup new pipeline signup src/signup --steps validate_email hash_password
+cup list                                   # Show available component types
+cup bundle src/signup                      # Generate __init__.py re-exports
+cup lint src/signup                        # Check CUP conventions (CUP000–CUP008)
+cup coverage src/signup                    # Map component↔test coverage gaps
+cup report src/signup                      # Health report with scores, orphans, staleness
+cup doc-check .                            # Verify doc freshness (cup:ref markers)
+```
+<!-- /cup:ref -->
+
+## Testing Utilities
+
+<!-- cup:ref file=codeupipe/testing.py symbols=run_filter,assert_payload,mock_filter hash=c119f9c -->
+`codeupipe.testing` provides zero-boilerplate test helpers:
+
+```python
+from codeupipe.testing import run_filter, assert_payload, mock_filter
+
+def test_my_filter():
+    result = run_filter(MyFilter(), {"input": "data"})
+    assert_payload(result, output="expected")
+
+def test_with_mock():
+    f = mock_filter(status="ok")
+    result = run_filter(f, {"x": 1})
+    assert f.call_count == 1
+```
+<!-- /cup:ref -->
+
+## Test
+
+```bash
+pytest  # 909 tests
+```
+
+## License
+
+Apache 2.0

codeupipe-0.1.0/codeupipe/__init__.py

@@ -0,0 +1,39 @@
+"""
+codeupipe: Pipeline framework for Python
+
+Composable Payload-Filter-Pipeline pattern with Valves, Taps, Hooks, and Streaming.
+Filters and Taps can be sync or async. Zero external dependencies.
+
+Core concepts:
+- Payload: Immutable data container flowing through the pipeline
+- MutablePayload: Mutable sibling for performance-critical bulk edits
+- Filter: Processing unit that transforms payloads (sync or async)
+- StreamFilter: Streaming unit — yields 0, 1, or N output chunks per input
+- Pipeline: Orchestrator — .run() for batch, .stream() for streaming
+- Valve: Conditional flow control — gates a filter with a predicate
+- Tap: Non-modifying observation point (sync or async)
+- State: Pipeline execution metadata — tracks executed, skipped, errors, chunk counts
+- Hook: Lifecycle hooks — before / after / on_error (sync or async)
+"""
+
+from .core import Payload, MutablePayload, Filter, StreamFilter, Pipeline, Valve, Tap, State, Hook
+from .utils import ErrorHandlingMixin, RetryFilter
+from .converter import load_config, DEFAULT_CONFIG, PATTERN_DEFAULTS
+from .converter.pipelines import build_export_pipeline, build_import_pipeline
+
+from importlib.metadata import version as _pkg_version, PackageNotFoundError
+try:
+    __version__ = _pkg_version("codeupipe")
+except PackageNotFoundError:
+    __version__ = "0.1.0"  # fallback for editable / non-installed usage
+__all__ = [
+    # Core
+    "Payload", "MutablePayload",
+    "Filter", "StreamFilter", "Pipeline", "Valve", "Tap",
+    "State", "Hook",
+    # Utils
+    "ErrorHandlingMixin", "RetryFilter",
+    # Converter
+    "load_config", "DEFAULT_CONFIG", "PATTERN_DEFAULTS",
+    "build_export_pipeline", "build_import_pipeline",
+]