pyfect-dev 0.1.0__py3-none-any.whl

pyfect/cluster/test_runner.py

@@ -0,0 +1,23 @@
+"""A single runner in memory, for tests (Effect's ``TestRunner``):
+sharding with no other runners, message storage in memory and default
+settings."""
+
+from __future__ import annotations
+
+from pyfect import layer as layer_
+from pyfect.cluster import message_storage, runner_health, runner_storage, runners, sharding
+from pyfect.cluster import sharding_config as sharding_config_
+from pyfect.cluster.message_storage import MemoryDriver, MessageStorage
+from pyfect.cluster.runners import Runners
+from pyfect.cluster.sharding import Sharding
+from pyfect.layer import Layer
+
+layer: Layer[Sharding | Runners | MessageStorage | MemoryDriver] = (
+    sharding.layer.pipe(layer_.provide_merge(runners.layer_noop))
+    .pipe(layer_.provide_merge(message_storage.layer_memory))
+    .pipe(layer_.provide(layer_.merge(runner_storage.layer_memory, runner_health.layer_noop)))
+    .pipe(layer_.provide(sharding_config_.layer()))
+)
+"""Sharding, runners and message storage of one runner in memory."""
+
+__all__ = ["layer"]

pyfect/config/__init__.py

@@ -0,0 +1,93 @@
+"""Typed configuration (Effect's ``Config``).
+
+A ``Config[A]`` says which keys to read from the ``CurrentConfigProvider``
+and how to decode them. It is an effect, failing with ``ConfigError``::
+
+    @fx.gen
+    def main():
+        port = yield from config.port("PORT").with_default(8080)
+        ...
+
+Each read resolves in two channels: data that is not there is *absent*
+(``with_default`` and ``option`` recover it), data that is there but
+invalid *fails* (only ``or_else`` recovers it). Constructors read one string
+(``string``, ``integer``, ``port``, ``boolean``, ``duration``, ``literal``,
+``url``, ``log_level``, ``byte_size``, ``redacted``, ...) or a container
+(``list_of``, ``dict_of``); ``all`` / ``all_dict`` group configs, ``gen``
+builds one from a generator, and the methods ``map``, ``flat_map``,
+``map_effect``, ``or_else``, ``with_default`` and ``nested`` transform one.
+``schema(codec, path)`` reads any shape a schema describes (Effect's
+``Config.schema``).
+"""
+
+from pyfect._public import publish
+from pyfect.config._all import all, all_dict
+from pyfect.config._collections import dict_of, list_of
+from pyfect.config._config import Config, gen, option, unwrap
+from pyfect.config._config import fail_config as fail
+from pyfect.config._config import succeed_config as succeed
+from pyfect.config._constructors import (
+    boolean,
+    byte_size,
+    date_time,
+    duration,
+    finite,
+    integer,
+    literal,
+    log_level,
+    non_empty_string,
+    number,
+    port,
+    redacted,
+    string,
+    url,
+)
+from pyfect.config._error import ConfigError
+from pyfect.config._schema import schema
+from pyfect.schema import SchemaError
+from pyfect.schema.issue import (
+    Composite,
+    Forbidden,
+    InvalidType,
+    InvalidValue,
+    Issue,
+    Pointer,
+)
+
+__all__ = [
+    "Composite",
+    "Config",
+    "ConfigError",
+    "Forbidden",
+    "InvalidType",
+    "InvalidValue",
+    "Issue",
+    "Pointer",
+    "SchemaError",
+    "all",
+    "all_dict",
+    "boolean",
+    "byte_size",
+    "date_time",
+    "dict_of",
+    "duration",
+    "fail",
+    "finite",
+    "gen",
+    "integer",
+    "list_of",
+    "literal",
+    "log_level",
+    "non_empty_string",
+    "number",
+    "option",
+    "port",
+    "redacted",
+    "schema",
+    "string",
+    "succeed",
+    "unwrap",
+    "url",
+]
+
+publish(globals())

pyfect/config/_all.py

@@ -0,0 +1,96 @@
+"""``all`` and ``all_dict``: several configs read as one.
+
+The children are read in order. A group fails as soon as a child fails
+(invalid data or a source error), even after an absent child; otherwise it
+is absent when any child is, with the first absent child's error.
+"""
+# pyright: reportPrivateUsage=false
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, Never, overload
+
+from pyfect._concurrency import for_each
+from pyfect._core import Effect
+from pyfect.config._config import Config, Resolution, require_config
+from pyfect.config._error import ConfigError
+from pyfect.config_provider import ConfigProvider, Path
+from pyfect.result import Err, Ok
+
+
+@overload
+def all() -> Config[tuple[()]]: ...
+@overload
+def all[A1](c1: Config[A1], /) -> Config[tuple[A1]]: ...
+@overload
+def all[A1, A2](c1: Config[A1], c2: Config[A2], /) -> Config[tuple[A1, A2]]: ...
+@overload
+def all[A1, A2, A3](
+    c1: Config[A1], c2: Config[A2], c3: Config[A3], /
+) -> Config[tuple[A1, A2, A3]]: ...
+@overload
+def all[A1, A2, A3, A4](
+    c1: Config[A1], c2: Config[A2], c3: Config[A3], c4: Config[A4], /
+) -> Config[tuple[A1, A2, A3, A4]]: ...
+@overload
+def all[A1, A2, A3, A4, A5](
+    c1: Config[A1], c2: Config[A2], c3: Config[A3], c4: Config[A4], c5: Config[A5], /
+) -> Config[tuple[A1, A2, A3, A4, A5]]: ...
+@overload
+def all(*configs: Config[Never]) -> Config[tuple[Never, ...]]: ...
+@overload
+def all[A](*configs: Config[A]) -> Config[tuple[A, ...]]: ...
+def all(*configs: Config[Any]) -> Config[tuple[Any, ...]]:
+    """The configs' values as a tuple, in order (Effect's ``Config.all``
+    of a tuple or an iterable: pass ``*configs``)."""
+    for i, c in enumerate(configs):
+        require_config(c, f"configs[{i}]")
+    return Config(lambda provider, prefix: _collect(configs, provider, prefix).map(_tuple))
+
+
+@overload
+def all_dict(configs: Mapping[Never, Config[Never]]) -> Config[dict[Never, Never]]: ...
+@overload
+def all_dict[K, A](configs: Mapping[K, Config[A]]) -> Config[dict[K, A]]: ...
+def all_dict[K, A](configs: Mapping[K, Config[A]]) -> Config[dict[K, A]]:
+    """The configs' values under the same keys (Effect's ``Config.all`` of a
+    record). The mapping is copied when the config is made."""
+    keys = tuple(configs)
+    values = tuple(configs[k] for k in keys)
+    for k, c in zip(keys, values, strict=True):
+        require_config(c, f"configs[{k!r}]")
+
+    def to_dict(resolution: Resolution[list[A]]) -> Resolution[dict[K, A]]:
+        match resolution:
+            case Ok(items):
+                return Ok(dict(zip(keys, items, strict=True)))
+            case Err():
+                return resolution
+
+    return Config(lambda provider, prefix: _collect(values, provider, prefix).map(to_dict))
+
+
+def _collect[A](
+    configs: tuple[Config[A], ...], provider: ConfigProvider, prefix: Path
+) -> Effect[Resolution[list[A]], ConfigError]:
+    return for_each(configs, lambda c: c._evaluate(provider, prefix)).map(_first_absent)
+
+
+def _first_absent[A](resolutions: list[Resolution[A]]) -> Resolution[list[A]]:
+    values: list[A] = []
+    for resolution in resolutions:
+        match resolution:
+            case Ok(value):
+                values.append(value)
+            case Err():
+                return resolution
+    return Ok(values)
+
+
+def _tuple[A](resolution: Resolution[list[A]]) -> Resolution[tuple[A, ...]]:
+    match resolution:
+        case Ok(items):
+            return Ok(tuple(items))
+        case Err():
+            return resolution

pyfect/config/_collections.py

@@ -0,0 +1,291 @@
+"""``list_of`` and ``dict_of`` (Effect's ``Config.Array`` and ``Config.Record``):
+a container read from structural provider input or from one separated
+string (``"a,b"``, ``"k=v,k2=v2"``).
+
+Each is a first-match choice between the two readings. When neither
+applies, the issues of both are reported, and the config is absent unless
+the node held something either reading could use.
+"""
+# pyright: reportPrivateUsage=false
+
+from __future__ import annotations
+
+from collections.abc import Callable, Sequence
+from typing import Any, Never
+
+from pyfect._concurrency import for_each
+from pyfect._core import Effect
+from pyfect._digits import in_object_order
+from pyfect.cause import Cause, Fail
+from pyfect.config._config import Config, Resolution, require_config
+from pyfect.config._error import ConfigError
+from pyfect.config._leaf import EXPECTED_STRING, at, composite, expected, load
+from pyfect.config._schema import schema
+from pyfect.config_provider import Array, ConfigProvider, Node, Path, Record, Value, make
+from pyfect.effect import fail, fail_cause, succeed
+from pyfect.result import Err, Ok, Result
+from pyfect.schema import Codec, SchemaError, is_schema
+from pyfect.schema.issue import Issue
+
+type Decoded[A] = Result[A, Issue]
+"""A reading's value, or the issue that rules it out."""
+
+type Reading[A] = Callable[[ConfigProvider, Path, Node | None], Effect[Decoded[A], ConfigError]]
+
+
+def list_of[A](
+    element: Config[A] | Codec[A, object, Never, object],
+    name: str | None = None,
+    *,
+    separator: str = ",",
+) -> Config[list[A]]:
+    """A list whose items are read with ``element`` (a config, or a schema
+    read as ``schema(element)``): from a separated string (``"1,2"``;
+    ``""`` is empty), else from an array node (``PORTS_0``, ``PORTS_1`` in
+    ``from_env``)."""
+    element = _as_config(element, "element")
+
+    def from_string(provider: ConfigProvider, path: Path, node: Node | None) -> Effect[Any, Any]:
+        text = None if node is None else node.value
+        if text is None:
+            return succeed(Err(at(path, EXPECTED_STRING)))
+        pieces = _split(text, separator) if text else []
+        return _read_pieces(element, [((*path, i), piece) for i, piece in enumerate(pieces)])
+
+    def from_array(provider: ConfigProvider, path: Path, node: Node | None) -> Effect[Any, Any]:
+        if not isinstance(node, Array):
+            return succeed(Err(at(path, expected("array"))))
+        children = _load_children(provider, [(*path, i) for i in range(node.length)])
+        return children.flat_map(lambda items: _read_children(element, provider, items))
+
+    def has_input(node: Node | None) -> bool:
+        return isinstance(node, Array) or (node is not None and node.value is not None)
+
+    return _container(name, (from_string, from_array), has_input, _as_list)
+
+
+def dict_of[A](
+    value: Config[A] | Codec[A, object, Never, object],
+    name: str | None = None,
+    *,
+    separator: str = ",",
+    key_value_separator: str = "=",
+) -> Config[dict[str, A]]:
+    """A dict whose values are read with ``value`` (a config, or a schema
+    read as ``schema(value)``): from a record node (its keys that hold
+    something), else from a separated string (``"a=1,b=2"``; a pair with
+    no separator, an empty key or an empty value is skipped)."""
+    value = _as_config(value, "value")
+
+    def from_record(provider: ConfigProvider, path: Path, node: Node | None) -> Effect[Any, Any]:
+        if not isinstance(node, Record):
+            return succeed(Err(at(path, expected("object"))))
+        children = _load_children(provider, [(*path, k) for k in node.keys])
+        return children.flat_map(lambda items: _read_present(value, provider, items))
+
+    def from_string(provider: ConfigProvider, path: Path, node: Node | None) -> Effect[Any, Any]:
+        text = None if node is None else node.value
+        if text is None:
+            return succeed(Err(at(path, EXPECTED_STRING)))
+        pairs = _split_key_value(text, separator, key_value_separator)
+        keys = list(pairs)
+        return _read_pieces(value, [((*path, k), pairs[k]) for k in keys]).map(_keyed(keys))
+
+    def has_input(node: Node | None) -> bool:
+        return isinstance(node, Record) or (node is not None and node.value is not None)
+
+    return _container(name, (from_record, from_string), has_input, _as_dict)
+
+
+def _as_config[A](element: Config[A] | Codec[A, object, Never, object], name: str) -> Config[A]:
+    if is_schema(element):
+        return schema(element)
+    require_config(element, name)
+    return element
+
+
+def _keyed[A](keys: list[str]) -> Callable[[Decoded[list[A]]], Decoded[dict[str, A]]]:
+    def to_dict(decoded: Decoded[list[A]]) -> Decoded[dict[str, A]]:
+        match decoded:
+            case Ok(values):
+                return Ok(in_object_order(dict(zip(keys, values, strict=True))))
+            case Err():
+                return decoded
+
+    return to_dict
+
+
+def _as_list(values: Any) -> list[Any]:
+    return list(values)
+
+
+def _as_dict(values: Any) -> dict[str, Any]:
+    return in_object_order(dict(values))
+
+
+def _container[A](
+    name: str | None,
+    readings: tuple[Reading[Any], Reading[Any]],
+    has_input: Callable[[Node | None], bool],
+    build: Callable[[Any], A],
+) -> Config[A]:
+    local: Path = () if name is None else (name,)
+    first, second = readings
+
+    def run(provider: ConfigProvider, prefix: Path) -> Effect[Resolution[A], ConfigError]:
+        path = (*prefix, *local)
+
+        def choose(node: Node | None) -> Effect[Resolution[A], ConfigError]:
+            def try_second(issue: Issue) -> Effect[Resolution[A], ConfigError]:
+                def settle(decoded: Decoded[Any]) -> Effect[Resolution[A], ConfigError]:
+                    match decoded:
+                        case Ok(values):
+                            return succeed(Ok(build(values)))
+                        case Err(second_issue):
+                            error = ConfigError(SchemaError(composite(issue, second_issue)))
+                            return succeed(Err(error)) if not has_input(node) else fail(error)
+
+                return second(provider, path, node).flat_map(settle)
+
+            def after_first(decoded: Decoded[Any]) -> Effect[Resolution[A], ConfigError]:
+                match decoded:
+                    case Ok(values):
+                        return succeed(Ok(build(values)))
+                    case Err(issue):
+                        return try_second(issue)
+
+            return first(provider, path, node).flat_map(after_first)
+
+        return load(provider, path).flat_map(choose)
+
+    return Config(run)
+
+
+type Child = tuple[Path, Node | None]
+"""A container item's path and the node loaded there."""
+
+
+def _load_children(
+    provider: ConfigProvider, paths: Sequence[Path]
+) -> Effect[list[Child], ConfigError]:
+    """Every item's node, loaded before any item is decoded, as Effect
+    materializes a container: a later item's source error wins over an
+    earlier item's invalid value."""
+    return for_each(paths, lambda path: load(provider, path).map(lambda node: (path, node)))
+
+
+def _read_children[A](
+    element: Config[A], provider: ConfigProvider, children: Sequence[Child]
+) -> Effect[Decoded[list[A]], ConfigError]:
+    """Each item read with ``element`` through a provider that already holds
+    its node; the first issue rules the reading out."""
+    return _first_issue(
+        [_read_item(element, _holding(provider, path, node), path) for path, node in children]
+    )
+
+
+def _read_present[A](
+    element: Config[A], provider: ConfigProvider, children: Sequence[Child]
+) -> Effect[Decoded[dict[str, A]], ConfigError]:
+    """A record's entries: keys with no node are left out, as in Effect."""
+    present = [(path, node) for path, node in children if node is not None]
+    keys = [str(path[-1]) for path, _ in present]
+    return _read_children(element, provider, present).map(_keyed(keys))
+
+
+def _read_pieces[A](
+    element: Config[A], pieces: Sequence[tuple[Path, str]]
+) -> Effect[Decoded[list[A]], ConfigError]:
+    """Each piece of a split string read with ``element``, as if the
+    provider held the piece at its item path."""
+    return _read_children(element, _NOTHING, [(path, Value(piece)) for path, piece in pieces])
+
+
+def _holding(provider: ConfigProvider, path: Path, node: Node | None) -> ConfigProvider:
+    return make(lambda p: succeed(node) if p == path else provider.load(p))
+
+
+_NOTHING = make(lambda _path: succeed(None))
+
+
+def _split(text: str, separator: str) -> list[str]:
+    """JavaScript's ``split``: an empty separator splits into characters."""
+    return text.split(separator) if separator else list(text)
+
+
+def _first_issue[A](
+    reads: list[Effect[Decoded[A], ConfigError]],
+) -> Effect[Decoded[list[A]], ConfigError]:
+    def collect(decoded: list[Decoded[A]]) -> Decoded[list[A]]:
+        values: list[A] = []
+        for item in decoded:
+            match item:
+                case Ok(v):
+                    values.append(v)
+                case Err():
+                    return item
+        return Ok(values)
+
+    return _sequence_until_issue(reads).map(collect) if reads else succeed(Ok([]))
+
+
+def _sequence_until_issue[A](
+    reads: list[Effect[Decoded[A], ConfigError]],
+) -> Effect[list[Decoded[A]], ConfigError]:
+    """Run the reads in order, stopping after the first issue (later items
+    are not decoded, as a schema stops at its first error)."""
+
+    def step(i: int, done: list[Decoded[A]]) -> Effect[list[Decoded[A]], ConfigError]:
+        if i == len(reads):
+            return succeed(done)
+
+        def next_read(item: Decoded[A]) -> Effect[list[Decoded[A]], ConfigError]:
+            done.append(item)
+            return succeed(done) if isinstance(item, Err) else step(i + 1, done)
+
+        return reads[i].flat_map(next_read)
+
+    return step(0, [])
+
+
+def _read_item[A](
+    element: Config[A], provider: ConfigProvider, path: Path
+) -> Effect[Decoded[A], ConfigError]:
+    """One item: its value, or the issue that it is absent or invalid.
+    Source errors, defects and interruptions propagate."""
+
+    def on_failure(cause: Cause[ConfigError]) -> Effect[Decoded[A], ConfigError]:
+        match cause.reasons:
+            case (Fail(ConfigError(SchemaError(issue))),):
+                return succeed(Err(issue))
+            case _:
+                return fail_cause(cause)
+
+    def on_success(resolution: Resolution[A]) -> Effect[Decoded[A], ConfigError]:
+        match resolution:
+            case Ok():
+                return succeed(resolution)
+            case Err(ConfigError(SchemaError(issue))):
+                return succeed(Err(issue))
+            case Err(error):
+                return fail(error)
+
+    return element._evaluate(provider, path).match_cause_effect(
+        on_failure=on_failure, on_success=on_success
+    )
+
+
+def _split_key_value(text: str, separator: str, key_value_separator: str) -> dict[str, str]:
+    """Effect's ``splitKeyValue``: a pair splits at its first separator."""
+    pairs: dict[str, str] = {}
+    for pair in _split(text, separator):
+        if key_value_separator == "":
+            key, value = pair[:1], pair[1:2]
+        else:
+            index = pair.find(key_value_separator)
+            if index <= 0:
+                continue
+            key, value = pair[:index], pair[index + len(key_value_separator) :]
+        if key and value:
+            pairs[key] = value
+    return pairs