without-configmap 0.0.1__tar.gz

without_configmap-0.0.1/PKG-INFO

@@ -0,0 +1,61 @@
+Metadata-Version: 2.4
+Name: without-configmap
+Version: 0.0.1
+Summary: A without behavior source backed by a Kubernetes ConfigMap mount, reloaded with watchfiles.
+Author: Josh Karpel
+Author-email: Josh Karpel <josh.karpel@gmail.com>
+License-Expression: MIT
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Framework :: AsyncIO
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Typing :: Typed
+Requires-Dist: without-core==0.0.1
+Requires-Dist: watchfiles>=0.21
+Requires-Dist: pydantic>=2
+Requires-Dist: pyyaml>=6
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+
+# without-configmap
+
+A `without` behavior source backed by a Kubernetes ConfigMap mount: the first
+context that actually *changes*, proving the context-updated-by-a-stream half of
+the model end to end. Where [`without-env`](../without-env) loads a static value
+once, this one re-parses on every mount change.
+
+`watch_config(mount, parse)` is a `Stream` that yields the parsed config now and a
+freshly parsed value every time the mount changes. It watches the mount
+*directory*, not the file, so it catches the atomic `..data` symlink swap that
+[projected ConfigMaps](https://kubernetes.io/docs/concepts/configuration/configmap/#mounted-configmaps-are-updated-automatically)
+use. Feed the stream through `without.sample` to read the latest value as a
+`Context`:
+
+```python
+from pathlib import Path
+
+from pydantic import BaseModel
+from without import sample
+from without_configmap import read_yaml_file, watch_config
+
+
+class MyConfig(BaseModel):
+    model_config = {"frozen": True}
+    default_mode: str
+    max_bytes: int
+
+
+source = watch_config(Path("/etc/config"), read_yaml_file(MyConfig, "config.yaml"))
+async with sample(source) as config:
+    config.current()       # always the latest reloaded value, never blocks
+    await config.updated() # block until the next reload lands, then return it
+```
+
+See the
+[`without-configmap` guide](https://without.help/guides/without-configmap/)
+(with the [API reference](https://without.help/reference/without_configmap/))
+for the full surface.

without_configmap-0.0.1/README.md

@@ -0,0 +1,38 @@
+# without-configmap
+
+A `without` behavior source backed by a Kubernetes ConfigMap mount: the first
+context that actually *changes*, proving the context-updated-by-a-stream half of
+the model end to end. Where [`without-env`](../without-env) loads a static value
+once, this one re-parses on every mount change.
+
+`watch_config(mount, parse)` is a `Stream` that yields the parsed config now and a
+freshly parsed value every time the mount changes. It watches the mount
+*directory*, not the file, so it catches the atomic `..data` symlink swap that
+[projected ConfigMaps](https://kubernetes.io/docs/concepts/configuration/configmap/#mounted-configmaps-are-updated-automatically)
+use. Feed the stream through `without.sample` to read the latest value as a
+`Context`:
+
+```python
+from pathlib import Path
+
+from pydantic import BaseModel
+from without import sample
+from without_configmap import read_yaml_file, watch_config
+
+
+class MyConfig(BaseModel):
+    model_config = {"frozen": True}
+    default_mode: str
+    max_bytes: int
+
+
+source = watch_config(Path("/etc/config"), read_yaml_file(MyConfig, "config.yaml"))
+async with sample(source) as config:
+    config.current()       # always the latest reloaded value, never blocks
+    await config.updated() # block until the next reload lands, then return it
+```
+
+See the
+[`without-configmap` guide](https://without.help/guides/without-configmap/)
+(with the [API reference](https://without.help/reference/without_configmap/))
+for the full surface.

without_configmap-0.0.1/pyproject.toml

@@ -0,0 +1,34 @@
+[build-system]
+requires = ["uv_build>=0.11.25,<0.12"]
+build-backend = "uv_build"
+
+[project]
+name = "without-configmap"
+version = "0.0.1"
+description = "A without behavior source backed by a Kubernetes ConfigMap mount, reloaded with watchfiles."
+readme = "README.md"
+license = "MIT"
+authors = [
+    { name = "Josh Karpel", email = "josh.karpel@gmail.com" },
+]
+requires-python = ">=3.14"
+classifiers = [
+    "Development Status :: 2 - Pre-Alpha",
+    "Framework :: AsyncIO",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.14",
+    "Topic :: Software Development :: Libraries",
+    "Typing :: Typed",
+]
+dependencies = [
+    "without-core==0.0.1",
+    "watchfiles>=0.21",
+    "pydantic>=2",
+    "pyyaml>=6",
+]
+
+[tool.uv.sources]
+without-core = { workspace = true }

without_configmap-0.0.1/src/without_configmap/__init__.py

@@ -0,0 +1,7 @@
+from without_configmap.parse import read_yaml_file
+from without_configmap.source import watch_config
+
+__all__ = [
+    "read_yaml_file",
+    "watch_config",
+]

without_configmap-0.0.1/src/without_configmap/parse.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from pathlib import Path
+
+import yaml
+from pydantic import BaseModel
+
+
+def read_yaml_file[ModelT: BaseModel](model_type: type[ModelT], file_name: str) -> Callable[[Path], ModelT]:
+    """
+    Parse a single YAML file from the mount into a validated model.
+
+    The ConfigMap is mounted with one file (e.g. `config.yaml`) holding a YAML
+    mapping. This reads `mount / file_name`, loads it, and validates it into
+    `model_type` at the boundary, so missing keys fall back to declared model
+    defaults and the rest of the system sees an already-valid value.
+    """
+
+    def parse(mount: Path) -> ModelT:
+        contents = yaml.safe_load((mount / file_name).read_text())
+        return model_type.model_validate(contents)
+
+    return parse

without_configmap-0.0.1/src/without_configmap/source.py

@@ -0,0 +1,44 @@
+# A behavior source backed by a Kubernetes ConfigMap mount. Watches the mount
+# directory (not a file) because a projected ConfigMap swaps an atomic ..data
+# symlink rather than rewriting files in place, so a per-file watch can miss
+# updates. On each change the whole mount is reparsed to its desired state
+# (declarative) instead of applying deltas. Feed the result to without.sample.
+
+from __future__ import annotations
+
+from collections.abc import AsyncIterator
+from collections.abc import Callable
+from pathlib import Path
+
+from watchfiles import awatch
+from without.contracts import Stream
+
+type Changes = Callable[[Path], AsyncIterator[object]]
+
+
+async def _awatch_changes(mount: Path) -> AsyncIterator[object]:
+    async for batch in awatch(mount):  # pragma: no cover - default I/O adapter; tests drive the `changes` seam
+        yield batch
+
+
+def watch_config[T](
+    mount: Path,
+    parse: Callable[[Path], T],
+    *,
+    changes: Changes = _awatch_changes,
+) -> Stream[T]:
+    """
+    The parsed config now, and a freshly parsed value on every mount change.
+
+    `parse` is the boundary: it turns the mount directory into a validated
+    value. `changes` is the source of reload signals, injectable so tests can
+    drive reloads deterministically without real filesystem events; it defaults
+    to watching the mount directory with `watchfiles`.
+    """
+
+    async def source() -> AsyncIterator[T]:
+        yield parse(mount)
+        async for _change in changes(mount):
+            yield parse(mount)
+
+    return source()