io-adapters 0.1.0__tar.gz → 0.2.2__tar.gz

io_adapters-0.2.2/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Ed Cuss and any other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software 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 Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

io_adapters-0.2.2/PKG-INFO

@@ -0,0 +1,150 @@
+Metadata-Version: 2.4
+Name: io-adapters
+Version: 0.2.2
+Summary: Dependency Injection Adapters
+Author: ed cuss
+Author-email: ed cuss <edcussmusic@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Requires-Dist: attrs>=25.4.0
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+
+# io-adapters
+A small utility library for decoupling I/O from business logic by combining
+dependency injection with lightweight, automatically generated fakes.
+
+### Install
+```shell
+uv add io-adapters
+```
+
+### API Reference
+
+[io-adapters API docs](https://second-ed.github.io/io-adapters/)
+
+Testing use cases that involve I/O is inherently difficult because they depend on:
+
+- external state (filesystems, databases, services)
+
+- side effects that are hard to observe directly
+
+- slow or flaky infrastructure
+
+A common mitigation is to combine:
+
+- Dependency Injection (DI)
+
+- The Repository / Adapter pattern
+
+This allows business logic to depend on an abstract interface rather than concrete I/O.
+
+However, in practice this usually requires:
+
+- writing and maintaining bespoke fake implementations
+
+- keeping fake behaviour in sync with real implementations
+
+- duplicating boilerplate across domains
+
+For small or medium-sized projects, this overhead can outweigh the benefits.
+
+ Simply register each I/O function with one of the register decorators and the functionality will be added to the `RealAdapter` object, on top of that a stub will be added to the `FakeAdapter` object too so you can pass in either to your usecase and the functionality will work.
+
+### Example
+
+```python
+from enum import Enum
+from pathlib import Path
+
+from io_adapters import (
+    IoAdapter,
+    RealAdapter,
+    add_domain,
+    get_fake_adapter,
+    get_real_adapter,
+    register_domain_read_fn,
+    register_domain_write_fn,
+)
+
+
+# you can use any hashable object to register an I/O function
+class FileFormat(Enum):
+    JSON = "json"
+
+
+add_domain("orders")
+add_domain("payment")
+
+
+@register_domain_read_fn("orders", "str")
+def read_str(path: str | Path, **kwargs: dict) -> str: ...
+
+
+# stack decorators to register the same function to multiple domains
+@register_domain_read_fn("orders", FileFormat.JSON)
+@register_domain_read_fn("payment", FileFormat.JSON)
+def read_json(path: str | Path, **kwargs: dict) -> dict: ...
+
+
+@register_domain_write_fn("orders", "str")
+def write_str(data: dict, path: str | Path, **kwargs: dict) -> None: ...
+
+
+@register_domain_write_fn("orders", FileFormat.JSON)
+@register_domain_write_fn("payment", FileFormat.JSON)
+def write_json(data: dict, path: str | Path, **kwargs: dict) -> None: ...
+
+
+def some_usecase(adapter: IoAdapter, path: str) -> None:
+    adapter.read(path, "str")
+    # Some business logic
+    new_path = f"{path}_new.json"
+
+    adapter.write({"a": 1}, new_path, FileFormat.JSON)
+
+
+# in production inject the real adapter
+orders_adapter: RealAdapter = get_real_adapter("orders")
+some_usecase(orders_adapter, "some/path/to/file.json")
+
+
+# in testing inject the fake which has all the same funcitonality as the
+# `RealAdapter` and assert that the fakes end state is as expected
+fake = get_fake_adapter("orders")
+some_usecase(fake, "some/path/to/file.json")
+assert fake.files["some/path/to/file.json"] == {"a": 1}
+```
+
+
+# Repo map
+```
+├── .github
+│   └── workflows
+│       ├── ci_tests.yaml
+│       └── publish.yaml
+├── .pytest_cache
+│   └── README.md
+├── docs
+│   └── source
+│       └── conf.py
+├── src
+│   └── io_adapters
+│       ├── __init__.py
+│       ├── _adapters.py
+│       ├── _clock.py
+│       ├── _container.py
+│       ├── _io_funcs.py
+│       └── _registries.py
+├── tests
+│   ├── __init__.py
+│   ├── test_adapters.py
+│   ├── test_adapters_apis.py
+│   └── test_container.py
+├── .pre-commit-config.yaml
+├── README.md
+├── pyproject.toml
+├── ruff.toml
+└── uv.lock
+::
+```

io_adapters-0.2.2/README.md

@@ -0,0 +1,138 @@
+# io-adapters
+A small utility library for decoupling I/O from business logic by combining
+dependency injection with lightweight, automatically generated fakes.
+
+### Install
+```shell
+uv add io-adapters
+```
+
+### API Reference
+
+[io-adapters API docs](https://second-ed.github.io/io-adapters/)
+
+Testing use cases that involve I/O is inherently difficult because they depend on:
+
+- external state (filesystems, databases, services)
+
+- side effects that are hard to observe directly
+
+- slow or flaky infrastructure
+
+A common mitigation is to combine:
+
+- Dependency Injection (DI)
+
+- The Repository / Adapter pattern
+
+This allows business logic to depend on an abstract interface rather than concrete I/O.
+
+However, in practice this usually requires:
+
+- writing and maintaining bespoke fake implementations
+
+- keeping fake behaviour in sync with real implementations
+
+- duplicating boilerplate across domains
+
+For small or medium-sized projects, this overhead can outweigh the benefits.
+
+ Simply register each I/O function with one of the register decorators and the functionality will be added to the `RealAdapter` object, on top of that a stub will be added to the `FakeAdapter` object too so you can pass in either to your usecase and the functionality will work.
+
+### Example
+
+```python
+from enum import Enum
+from pathlib import Path
+
+from io_adapters import (
+    IoAdapter,
+    RealAdapter,
+    add_domain,
+    get_fake_adapter,
+    get_real_adapter,
+    register_domain_read_fn,
+    register_domain_write_fn,
+)
+
+
+# you can use any hashable object to register an I/O function
+class FileFormat(Enum):
+    JSON = "json"
+
+
+add_domain("orders")
+add_domain("payment")
+
+
+@register_domain_read_fn("orders", "str")
+def read_str(path: str | Path, **kwargs: dict) -> str: ...
+
+
+# stack decorators to register the same function to multiple domains
+@register_domain_read_fn("orders", FileFormat.JSON)
+@register_domain_read_fn("payment", FileFormat.JSON)
+def read_json(path: str | Path, **kwargs: dict) -> dict: ...
+
+
+@register_domain_write_fn("orders", "str")
+def write_str(data: dict, path: str | Path, **kwargs: dict) -> None: ...
+
+
+@register_domain_write_fn("orders", FileFormat.JSON)
+@register_domain_write_fn("payment", FileFormat.JSON)
+def write_json(data: dict, path: str | Path, **kwargs: dict) -> None: ...
+
+
+def some_usecase(adapter: IoAdapter, path: str) -> None:
+    adapter.read(path, "str")
+    # Some business logic
+    new_path = f"{path}_new.json"
+
+    adapter.write({"a": 1}, new_path, FileFormat.JSON)
+
+
+# in production inject the real adapter
+orders_adapter: RealAdapter = get_real_adapter("orders")
+some_usecase(orders_adapter, "some/path/to/file.json")
+
+
+# in testing inject the fake which has all the same funcitonality as the
+# `RealAdapter` and assert that the fakes end state is as expected
+fake = get_fake_adapter("orders")
+some_usecase(fake, "some/path/to/file.json")
+assert fake.files["some/path/to/file.json"] == {"a": 1}
+```
+
+
+# Repo map
+```
+├── .github
+│   └── workflows
+│       ├── ci_tests.yaml
+│       └── publish.yaml
+├── .pytest_cache
+│   └── README.md
+├── docs
+│   └── source
+│       └── conf.py
+├── src
+│   └── io_adapters
+│       ├── __init__.py
+│       ├── _adapters.py
+│       ├── _clock.py
+│       ├── _container.py
+│       ├── _io_funcs.py
+│       └── _registries.py
+├── tests
+│   ├── __init__.py
+│   ├── test_adapters.py
+│   ├── test_adapters_apis.py
+│   └── test_container.py
+├── .pre-commit-config.yaml
+├── README.md
+├── pyproject.toml
+├── ruff.toml
+└── uv.lock
+::
+```

{io_adapters-0.1.0 → io_adapters-0.2.2}/pyproject.toml

@@ -1,11 +1,13 @@
 [project]
 name = "io-adapters"
-version = "0.1.0"
-description = "Add your description here"
+version = "0.2.2"
+description = "Dependency Injection Adapters"
 readme = "README.md"
 authors = [
     { name = "ed cuss", email = "edcussmusic@gmail.com" }
 ]
+license = "MIT"
+license-files = ["LICENSE"]
 requires-python = ">=3.11"
 dependencies = [
     "attrs>=25.4.0",
@@ -24,4 +26,9 @@ dev = [
     "repo-mapper-rs>=0.3.0",
     "ruff>=0.14.9",
     "sphinx>=9.0.4",
+    "ty>=0.0.9",
 ]
+
+[tool.ty.src]
+include = ["src", "tests"]
+exclude = ["src/io_adapters/_io_funcs.py"]

{io_adapters-0.1.0 → io_adapters-0.2.2}/src/io_adapters/__init__.py

@@ -8,6 +8,7 @@ from io_adapters._container import (
     register_domain_write_fn,
 )
 from io_adapters._io_funcs import read_json, write_json  # noqa: F401
+from io_adapters._registries import register_read_fn, register_write_fn
 
 __all__ = [
     "Container",
@@ -19,4 +20,6 @@ __all__ = [
     "get_real_adapter",
     "register_domain_read_fn",
     "register_domain_write_fn",
+    "register_read_fn",
+    "register_write_fn",
 ]

{io_adapters-0.1.0 → io_adapters-0.2.2}/src/io_adapters/_adapters.py

@@ -2,23 +2,22 @@ from __future__ import annotations
 
 import datetime
 import logging
-from abc import ABC, abstractmethod
-from collections.abc import Hashable
+from collections.abc import Callable, Hashable
 from pathlib import Path
 from types import MappingProxyType
-from uuid import uuid4
 
 import attrs
-from attrs.validators import deep_mapping, instance_of, is_callable
+from attrs.validators import deep_mapping, instance_of, is_callable, optional
 
-from io_adapters._registries import READ_FNS, WRITE_FNS, Data, standardise_key
+from io_adapters._clock import default_datetime, default_guid, fake_datetime, fake_guid
+from io_adapters._registries import READ_FNS, WRITE_FNS, Data, ReadFn, WriteFn, standardise_key
 
 logger = logging.getLogger(__name__)
 
 
 @attrs.define
-class IoAdapter(ABC):
-    read_fns: MappingProxyType = attrs.field(
+class IoAdapter:
+    read_fns: MappingProxyType[Hashable, ReadFn] = attrs.field(
         default=READ_FNS,
         validator=[
             deep_mapping(
@@ -29,7 +28,7 @@ class IoAdapter(ABC):
         ],
         converter=MappingProxyType,
     )
-    write_fns: MappingProxyType = attrs.field(
+    write_fns: MappingProxyType[Hashable, WriteFn] = attrs.field(
         default=WRITE_FNS,
         validator=[
             deep_mapping(
@@ -40,8 +39,12 @@ class IoAdapter(ABC):
         ],
         converter=MappingProxyType,
     )
+    guid_fn: Callable[[], str] = attrs.field(default=None, validator=optional(is_callable()))
+    datetime_fn: Callable[[], datetime.datetime] = attrs.field(
+        default=None, validator=optional(is_callable())
+    )
 
-    def read(self, path: str | Path, file_type: str, **kwargs: dict) -> Data:
+    def read(self, path: str | Path, file_type: Hashable, **kwargs: dict) -> Data:
         """Read `path` using the registered function for `file_type`.
 
         Raises:
@@ -77,7 +80,7 @@ class IoAdapter(ABC):
             raise NotImplementedError(msg)
         return self.read_fns[file_type](path, **kwargs)
 
-    def write(self, data: Data, path: str | Path, file_type: str, **kwargs: dict) -> None:
+    def write(self, data: Data, path: str | Path, file_type: Hashable, **kwargs: dict) -> None:
         """Write `data` to `path` using the registered function for `file_type`.
 
         Raises:
@@ -118,7 +121,7 @@ class IoAdapter(ABC):
             def some_usecase(adapter: IoAdapter, path: str) -> None:
                 # Some business logic
 
-                adapter.write({"a": 1}, , WriteFormat.JSON)
+                adapter.write({"a": 1}, path, WriteFormat.JSON)
 
             # in production inject the real adapter
             some_usecase(RealAdapter(), "some/path/to/file.json")
@@ -138,20 +141,18 @@ class IoAdapter(ABC):
             raise NotImplementedError(msg)
         return self.write_fns[file_type](data, path, **kwargs)
 
-    @abstractmethod
-    def get_guid(self) -> str: ...
+    def get_guid(self) -> str:
+        return self.guid_fn()
 
-    @abstractmethod
-    def get_datetime(self) -> datetime.datetime: ...
+    def get_datetime(self) -> datetime.datetime:
+        return self.datetime_fn()
 
 
 @attrs.define
 class RealAdapter(IoAdapter):
-    def get_guid(self) -> str:
-        return str(uuid4())
-
-    def get_datetime(self) -> datetime.datetime:
-        return datetime.datetime.now(datetime.UTC)
+    def __attrs_post_init__(self) -> None:
+        self.guid_fn = self.guid_fn or default_guid
+        self.datetime_fn = self.datetime_fn or default_datetime
 
 
 @attrs.define
@@ -161,18 +162,20 @@ class FakeAdapter(IoAdapter):
     def __attrs_post_init__(self) -> None:
         self.read_fns = MappingProxyType(dict.fromkeys(self.read_fns.keys(), self._read_fn))
         self.write_fns = MappingProxyType(dict.fromkeys(self.write_fns.keys(), self._write_fn))
+        self.guid_fn = self.guid_fn or fake_guid
+        self.datetime_fn = self.datetime_fn or fake_datetime
 
-    def _read_fn(self, path: str) -> Data:
+    def _read_fn(self, path: str | Path) -> Data:
         try:
-            return self.files[path]
+            return self.files[str(path)]
         except KeyError as e:
             raise FileNotFoundError(f"{path = } {self.files = }") from e
 
-    def _write_fn(self, data: Data, path: str) -> None:
+    def _write_fn(self, data: Data, path: str | Path) -> None:
         self.files[str(path)] = data
 
     def get_guid(self) -> str:
-        return "abc-123"
+        return self.guid_fn()
 
     def get_datetime(self) -> datetime.datetime:
-        return datetime.datetime(2025, 1, 1, 12, tzinfo=datetime.UTC)
+        return self.datetime_fn()

io_adapters-0.2.2/src/io_adapters/_clock.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+import datetime
+from uuid import uuid4
+
+
+def default_guid() -> str:
+    return str(uuid4())
+
+
+def fake_guid() -> str:
+    return "abc-123"
+
+
+def default_datetime() -> datetime.datetime:
+    return datetime.datetime.now(datetime.UTC)
+
+
+def fake_datetime() -> datetime.datetime:
+    return datetime.datetime(2025, 1, 1, 12, tzinfo=datetime.UTC)

{io_adapters-0.1.0 → io_adapters-0.2.2}/src/io_adapters/_container.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import logging
 from collections.abc import Callable, Hashable, Iterable
 from enum import Enum, auto
+from typing import TypeAlias
 
 import attrs
 from attrs.validators import deep_iterable, instance_of
@@ -18,6 +19,9 @@ class _FnType(Enum):
     WRITE = auto()
 
 
+DomainFns: TypeAlias = dict[Hashable, dict[Hashable, Callable]]
+
+
 @attrs.define
 class Container:
     """Registry and factory for domain-scoped I/O adapters.
@@ -92,10 +96,12 @@ class Container:
     """
 
     domains: Iterable = attrs.field(validator=deep_iterable(member_validator=instance_of(Hashable)))
-    domain_fns: dict[Hashable, dict[Hashable, Callable]] = attrs.field(init=False)
+    domain_fns: DomainFns = attrs.field(init=False)
 
     def __attrs_post_init__(self) -> None:
-        self.domain_fns = {domain: {_FnType.READ: {}, _FnType.WRITE: {}} for domain in self.domains}
+        self.domain_fns: DomainFns = {
+            domain: {_FnType.READ: {}, _FnType.WRITE: {}} for domain in self.domains
+        }
 
     def add_domain(self, domain: Hashable) -> None:
         """Add a domain to a ``Container``
@@ -203,7 +209,7 @@ class Container:
             write_fns=self.domain_fns[domain][_FnType.WRITE],
         )
 
-    def get_fake_adapter(self, domain: Hashable, files: dict | None = None) -> RealAdapter:
+    def get_fake_adapter(self, domain: Hashable, files: dict | None = None) -> FakeAdapter:
         """Get a ``FakeAdapter`` for the given domain.
 
         The returned adapter will have all of the functions registered to that domain.

{io_adapters-0.1.0 → io_adapters-0.2.2}/src/io_adapters/_io_funcs.py

@@ -2,17 +2,18 @@ from __future__ import annotations
 
 import json
 from pathlib import Path
+from typing import Any
 
 from io_adapters._registries import register_read_fn, register_write_fn
 
 
 @register_read_fn("json")
-def read_json(path: str | Path, **kwargs: dict) -> dict:
+def read_json(path: str | Path, **kwargs: dict[str, Any]) -> dict:
     return json.loads(Path(path).read_text(), **kwargs)
 
 
 @register_write_fn("json")
-def write_json(data: dict, path: str | Path, **kwargs: dict) -> None:
+def write_json(data: dict, path: str | Path, **kwargs: dict[str, Any]) -> None:
     path = Path(path)
     path.parent.mkdir(parents=True, exist_ok=True)
     path.write_text(json.dumps(data, **kwargs))

io_adapters-0.2.2/src/io_adapters/_registries.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+import logging
+from collections.abc import Callable, Hashable
+from pathlib import Path
+from typing import Concatenate, ParamSpec, TypeAlias
+
+logger = logging.getLogger(__name__)
+
+Data: TypeAlias = "Data"
+P = ParamSpec("P")
+
+ReadFn = Callable[Concatenate[str | Path, P], Data]
+WriteFn = Callable[Concatenate[Data, str | Path, P], None]
+
+
+READ_FNS: dict[Hashable, ReadFn] = {}
+WRITE_FNS: dict[Hashable, WriteFn] = {}
+
+
+def register_read_fn(key: Hashable) -> Callable:
+    """Register a read function to the read functions constant.
+
+    This is useful for smaller projects where domain isolation isn't required.
+
+    .. code-block:: python
+
+        from io_adapters import RealAdapter, register_read_fn
+
+        @register_read_fn("json")
+        def read_json(path: str | Path, **kwargs: dict) -> dict:
+            ...
+
+    This function will be accessible when you initialise a ``RealAdapter``
+     and a stub of the functionality will be added to a ``FakeAdapter``.
+    """
+    key = standardise_key(key)
+
+    def wrapper(func: Callable) -> Callable:
+        logger.info(f"registering read fn {key = } {func = }")
+        READ_FNS[key] = func
+        return func
+
+    return wrapper
+
+
+def register_write_fn(key: Hashable) -> Callable:
+    """Register a write function to the write functions constant.
+
+    This is useful for smaller projects where domain isolation isn't required.
+
+    .. code-block:: python
+
+        from enum import Enum
+        from io_adapters import RealAdapter, register_write_fn
+
+        class WriteFormat(Enum):
+            JSON = "json"
+
+        @register_write_fn(WriteFormat.JSON)
+        def write_json(data: dict, path: str | Path, **kwargs: dict) -> None:
+            ...
+
+    This function will be accessible when you initialise a ``RealAdapter``
+     and a stub of the functionality will be added to a ``FakeAdapter``.
+    """
+    key = standardise_key(key)
+
+    def wrapper(func: Callable) -> Callable:
+        logger.info(f"registering write fn {key = } {func = }")
+        WRITE_FNS[key] = func
+        return func
+
+    return wrapper
+
+
+def standardise_key(key: Hashable) -> Hashable:
+    return key.strip().lower() if isinstance(key, str) else key

io_adapters-0.1.0/PKG-INFO

@@ -1,55 +0,0 @@
-Metadata-Version: 2.3
-Name: io-adapters
-Version: 0.1.0
-Summary: Add your description here
-Author: ed cuss
-Author-email: ed cuss <edcussmusic@gmail.com>
-Requires-Dist: attrs>=25.4.0
-Requires-Python: >=3.11
-Description-Content-Type: text/markdown
-
-# io-adapters
-### API Reference
-
-[io-adapters API docs](https://second-ed.github.io/io-adapters/)
-
-Testing use cases that involve I/O is inherently difficult because they depend on external state and side effects. However, combining Dependency Injection (DI) with the Repository pattern significantly reduces this complexity.
-
-By substituting real I/O implementations with fakes that simulate their behaviour, stateful interactions can be captured entirely in memory. This allows changes to the external world to be accumulated deterministically and the final state to be asserted directly, without relying on real filesystems, networks, or services.
-
-The result is faster, more reliable tests that focus on behaviour rather than infrastructure.
-
-However, creating these fakes can be time consuming and result in a maintenance burden that may not outweigh the benefit. 
-
-This is where `io-adapters` can help. Simply register each I/O function with one of the register decorators and the functionality will be added to the `RealAdapter` object, on top of that a stub will be added to the `FakeAdapter` object too so you can pass in either to your usecase and the functionality will work.
-
-# Repo map
-```
-├── .github
-│   └── workflows
-│       ├── ci_tests.yaml
-│       └── publish.yaml
-├── .pytest_cache
-│   └── README.md
-├── docs
-│   └── source
-│       └── conf.py
-├── src
-│   └── io_adapters
-│       ├── __init__.py
-│       ├── _adapters.py
-│       ├── _container.py
-│       ├── _io_funcs.py
-│       └── _registries.py
-├── tests
-│   ├── __init__.py
-│   ├── test_adapters.py
-│   ├── test_adapters_apis.py
-│   └── test_container.py
-├── .pre-commit-config.yaml
-├── README.md
-├── pyproject.toml
-├── ruff.toml
-└── uv.lock
-::
-```

io_adapters-0.1.0/README.md

@@ -1,45 +0,0 @@
-# io-adapters
-### API Reference
-
-[io-adapters API docs](https://second-ed.github.io/io-adapters/)
-
-Testing use cases that involve I/O is inherently difficult because they depend on external state and side effects. However, combining Dependency Injection (DI) with the Repository pattern significantly reduces this complexity.
-
-By substituting real I/O implementations with fakes that simulate their behaviour, stateful interactions can be captured entirely in memory. This allows changes to the external world to be accumulated deterministically and the final state to be asserted directly, without relying on real filesystems, networks, or services.
-
-The result is faster, more reliable tests that focus on behaviour rather than infrastructure.
-
-However, creating these fakes can be time consuming and result in a maintenance burden that may not outweigh the benefit. 
-
-This is where `io-adapters` can help. Simply register each I/O function with one of the register decorators and the functionality will be added to the `RealAdapter` object, on top of that a stub will be added to the `FakeAdapter` object too so you can pass in either to your usecase and the functionality will work.
-
-# Repo map
-```
-├── .github
-│   └── workflows
-│       ├── ci_tests.yaml
-│       └── publish.yaml
-├── .pytest_cache
-│   └── README.md
-├── docs
-│   └── source
-│       └── conf.py
-├── src
-│   └── io_adapters
-│       ├── __init__.py
-│       ├── _adapters.py
-│       ├── _container.py
-│       ├── _io_funcs.py
-│       └── _registries.py
-├── tests
-│   ├── __init__.py
-│   ├── test_adapters.py
-│   ├── test_adapters_apis.py
-│   └── test_container.py
-├── .pre-commit-config.yaml
-├── README.md
-├── pyproject.toml
-├── ruff.toml
-└── uv.lock
-::
-```

io_adapters-0.1.0/src/io_adapters/_registries.py

@@ -1,44 +0,0 @@
-from __future__ import annotations
-
-import logging
-from collections.abc import Callable, Hashable
-from pathlib import Path
-from typing import Concatenate, ParamSpec, TypeAlias
-
-logger = logging.getLogger(__name__)
-
-Data: TypeAlias = "Data"
-P = ParamSpec("P")
-
-ReadFn = Callable[Concatenate[str | Path, P], Data]
-WriteFn = Callable[Concatenate[Data, str | Path, P], None]
-
-
-READ_FNS: dict[str, ReadFn] = {}
-WRITE_FNS: dict[str, WriteFn] = {}
-
-
-def register_read_fn(key: Hashable) -> Callable:
-    key = standardise_key(key)
-
-    def wrapper(func: Callable) -> Callable:
-        logger.info(f"registering read fn {key = } {func = }")
-        READ_FNS[key] = func
-        return func
-
-    return wrapper
-
-
-def register_write_fn(key: Hashable) -> Callable:
-    key = standardise_key(key)
-
-    def wrapper(func: Callable) -> Callable:
-        logger.info(f"registering write fn {key = } {func = }")
-        WRITE_FNS[key] = func
-        return func
-
-    return wrapper
-
-
-def standardise_key(key: Hashable) -> Hashable:
-    return key.strip().lower() if isinstance(key, str) else key