effecton 0.2.0__py3-none-any.whl

effecton/std/pretty_logger.py

@@ -0,0 +1,119 @@
+import logging
+import sys
+from collections.abc import Mapping
+from datetime import datetime
+from pprint import pformat
+from typing import assert_never, final
+
+from effecton.std.logger import (
+    EffectonLogger,
+    LogData,
+    LogLevel,
+    Severity,
+    _to_python_logger_level,
+)
+
+_ANSI_RESET = "\x1b[0m"
+_ANSI_DIM = "\x1b[2m"
+
+
+def _severity_ansi(level: Severity) -> str:
+    match level:
+        case LogLevel.TRACE:
+            return "\x1b[90m"
+        case LogLevel.DEBUG:
+            return "\x1b[34m"
+        case LogLevel.INFO:
+            return "\x1b[32m"
+        case LogLevel.WARN:
+            return "\x1b[33m"
+        case LogLevel.ERROR:
+            return "\x1b[31m"
+        case LogLevel.FATAL:
+            return "\x1b[41;97m"
+        case _:
+            assert_never(level)
+
+
+def _severity_for_levelno(levelno: int) -> Severity:
+    """Nearest effecton severity for a stdlib level.
+
+    The inverse of _to_python_logger_level.
+    """
+    if levelno >= logging.CRITICAL:
+        return LogLevel.FATAL
+    if levelno >= logging.ERROR:
+        return LogLevel.ERROR
+    if levelno >= logging.WARNING:
+        return LogLevel.WARN
+    if levelno >= logging.INFO:
+        return LogLevel.INFO
+    if levelno >= logging.DEBUG:
+        return LogLevel.DEBUG
+    return LogLevel.TRACE
+
+
+@final
+class PrettyFormatter(logging.Formatter):
+    """Formats records as ``[HH:MM:SS.mmm] LEVEL message``.
+
+    Levels render in effecton's severity vocabulary (WARN, FATAL) with a
+    color per level; colors=None detects whether stderr is a terminal.
+    effecton annotations travel on the record as the effecton_annotations
+    attribute (through ``extra``) and each renders as one indented
+    ``key: value`` line.
+    """
+
+    def __init__(self, *, colors: bool | None = None) -> None:
+        super().__init__()
+        self._colors = colors
+
+    def format(self, record: logging.LogRecord) -> str:
+        use_color = sys.stderr.isatty() if self._colors is None else self._colors
+
+        def paint(code: str, text: str) -> str:
+            return f"{code}{text}{_ANSI_RESET}" if use_color else text
+
+        severity = _severity_for_levelno(record.levelno)
+        date = datetime.fromtimestamp(record.created)
+        stamp = f"{date:%H:%M:%S}.{int(record.msecs):03d}"
+        header = (
+            f"{paint(_ANSI_DIM, f'[{stamp}]')} "
+            f"{paint(_severity_ansi(severity), severity.name)}"
+        )
+        first, *rest = record.getMessage().split("\n")
+        lines = [f"{header} {first}"]
+        lines += [f"  {line}" for line in rest]
+        annotations = record.__dict__.get("effecton_annotations")
+        if isinstance(annotations, Mapping):
+            lines += [
+                f"  {paint(_ANSI_DIM, f'{key}:')} {value}"
+                for key, value in annotations.items()
+            ]
+        if record.exc_info:
+            lines.append(self.formatException(record.exc_info))
+        return "\n".join(lines)
+
+
+_pretty_python_logger = logging.getLogger("effecton.pretty")
+# effecton owns filtering, so this logger must pass everything.
+_pretty_python_logger.setLevel(1)
+_pretty_python_logger.propagate = False
+_pretty_handler = logging.StreamHandler()
+_pretty_handler.setFormatter(PrettyFormatter())
+_pretty_python_logger.addHandler(_pretty_handler)
+
+
+def _pretty_log(options: LogData) -> None:
+    text = " ".join(
+        part if isinstance(part, str) else pformat(part, width=80, sort_dicts=False)
+        for part in options.message
+    )
+    _pretty_python_logger.log(
+        _to_python_logger_level(options.log_level),
+        text,
+        extra={"effecton_annotations": options.annotations},
+    )
+
+
+pretty_logger = EffectonLogger(log=_pretty_log)

effecton/std/scope.py

@@ -0,0 +1,58 @@
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from functools import reduce
+from typing import Any, Never, final
+
+from effecton.effect import Effect, EffectonError, ProvideRequirement, require, success
+from effecton.suspend import suspend
+
+
+@final
+@dataclass(frozen=True)
+class Scope:
+    _finalizers: list[Effect[Any]] = field(default_factory=list)
+
+    def add_finalizer(self, finalizer: Effect[Any]) -> None:
+        self._finalizers.append(finalizer)
+
+    @suspend
+    def close(self) -> Effect[None]:
+        # Draining makes a second close a no-op; folding with on_exit
+        # keeps a dying finalizer from skipping earlier-registered ones.
+        finalizers = list(self._finalizers)
+        self._finalizers.clear()
+        return reduce(
+            lambda acc, f: acc.on_exit(f),
+            reversed(finalizers),
+            success(None),
+        )
+
+
+def add_finalizer(finalizer: Effect[Any]) -> Effect[None, Never, Scope]:
+    return require(Scope).map(lambda s: s.add_finalizer(finalizer))
+
+
+@suspend
+def scoped[A, E: EffectonError, R = Never](
+    effect: Effect[A, E, Scope | R],
+) -> Effect[A, E, R]:
+    scope = Scope()
+
+    return ProvideRequirement(
+        first=effect, requirement_type=Scope, requirement_impl=scope
+    ).on_exit(scope.close())
+
+
+def acquire_and_release[A, E: EffectonError, R](
+    acquire: Effect[A, E, R], release: Callable[[A], Effect[Any]]
+) -> Effect[A, E, R | Scope]:
+    """Acquire a resource whose release the enclosing scope guarantees.
+
+    The release is registered only after acquire succeeds; a failed or
+    dying acquire registers nothing. suspend defers the release effect's
+    construction, so a release function that raises does so at close time
+    as a finalizer defect that cannot skip other finalizers.
+    """
+    return acquire.flat_map(
+        lambda a: add_finalizer(suspend(lambda: release(a))).map(lambda _: a)
+    )

effecton/suspend.py

@@ -0,0 +1,47 @@
+"""Lazily defer effect construction.
+
+``suspend`` has two forms, resolved by the callable's signature. The
+thunk form, ``suspend(thunk)``, returns an ``Effect`` that rebuilds the
+thunk's effect on every interpretation. The decorator form, ``@suspend``
+on a function that takes arguments, wraps it so each call captures its
+arguments and defers the body the same way: it runs only when the
+returned effect is interpreted. A zero-argument function resolves to the
+thunk form, so decorating one yields the effect itself.
+"""
+
+from collections.abc import Callable
+from functools import wraps
+from inspect import signature
+from typing import Any, overload
+
+from effecton.effect import Effect, EffectonError, sync
+
+
+@overload
+def suspend[A, E: EffectonError, R](
+    f: Callable[[], Effect[A, E, R]],
+) -> Effect[A, E, R]: ...
+
+
+@overload
+def suspend[**P, A, E: EffectonError, R](
+    f: Callable[P, Effect[A, E, R]],
+) -> Callable[P, Effect[A, E, R]]: ...
+
+
+def suspend(f: Callable[..., Effect[Any, Any, Any]]) -> Any:
+    def defer(thunk: Callable[[], Effect[Any, Any, Any]]) -> Effect[Any, Any, Any]:
+        return sync(thunk).flat_map(lambda x: x)
+
+    # bind() succeeds exactly when f is callable with no arguments, which
+    # mirrors the static dispatch: such callables match the thunk overload.
+    try:
+        signature(f).bind()
+    except TypeError:
+
+        @wraps(f)
+        def wrapper(*args: object, **kwargs: object) -> Effect[Any, Any, Any]:
+            return defer(lambda: f(*args, **kwargs))
+
+        return wrapper
+    return defer(f)

effecton-0.2.0.dist-info/METADATA

@@ -0,0 +1,389 @@
+Metadata-Version: 2.5
+Name: effecton
+Version: 0.2.0
+Summary: A typed effect system for Python, inspired by Effect-TS
+Project-URL: Repository, https://github.com/krzkaczor/effecton
+Author-email: Krzysztof Kaczor <chris@kaczor.io>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: dependency-injection,effect-system,effect-ts,functional,typed
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Typing :: Typed
+Requires-Python: >=3.14
+Requires-Dist: typing-extensions>=4.16.0
+Description-Content-Type: text/markdown
+
+# Effecton
+
+[![PyPI](https://img.shields.io/pypi/v/effecton?logo=pypi&logoColor=white)](https://pypi.org/project/effecton/)
+[![Discord](https://img.shields.io/badge/Discord-join%20chat-5865F2?logo=discord&logoColor=white)](https://discord.gg/fNhY7AxMyh)
+
+A typed effect system for Python, inspired by [Effect-TS](https://effect.website/). Early stage and experimental.
+
+An `Effect[A, E, R]` is a description of a computation that succeeds with `A`, fails with a typed error `E` and requires `R` dependencies.
+
+```python
+from dataclasses import dataclass
+from typing import final
+
+import effecton as E
+
+
+# Custom errors extend EffectonError and are final: one leaf class per cause
+@final
+@dataclass(frozen=True)
+class SecretInvalidError(E.EffectonError):
+    actual: str
+
+
+# signature means that it succeeds with str, fails with SecretInvalidError or HttpError and it requires HttpClient
+@E.gen
+def check_secret() -> E.EffectGen[
+    str, SecretInvalidError | HttpError, HttpClient.Protocol
+]:
+    http = yield from E.require(HttpClient.Protocol)  # requires HttpClient.Protocol
+
+    secret = yield from http.get_text(
+        "https://example.com/secret"
+    )  # secret is a str; HttpError joins the error channel
+    if secret != "hunter2":
+        yield from E.fail(
+            SecretInvalidError(secret)
+        )  # SecretInvalidError joins the error channel
+    return secret
+
+
+# program can be executed only after its requirements are provided
+program = check_secret().provide(HttpClient.Protocol)(HttpClient.Live())
+
+match E.run_sync_exit(program):
+    case E.Succeeded(value):
+        print(value)  # "hunter2"
+    case E.Failure(cause):
+        print(cause)  # Fail(SecretInvalidError(...)) or Fail(HttpStatusError(...))
+```
+
+## Installation
+
+Requires Python 3.14 or later.
+
+```sh
+uv add effecton
+# or
+pip install effecton
+```
+
+## Features
+
+* *Type-safe errors* -- stop guessing what a given function throws; implement surgical error handling to build reliable systems.
+* *Dependency injection* -- with requirements, dependencies become visible. In tests, another implementation can be trivially injected. Forgetting to do so is a type error.
+* *Finalizers* -- granular resource management.
+* *Ergonomic* -- generator-based syntax with `@E.gen` and functional-style `flat_map`, `map`, and friends.
+
+
+## Motivation
+
+Effect based systems provide programmers with building blocks that might be difficult at first but yield benefits in the future. Handling edge cases and thorough testing might be optional in the prototype stage but becomes critical in production.
+
+Furthermore, *agents love* strict type systems and building blocks.
+
+*Full example*: [skills-cli](https://github.com/krzkaczor/effecton/tree/main/packages/examples/skills-cli), a small CLI for installing agent skills built entirely on effecton services.
+
+## Overview
+
+### Building effects
+
+```python
+E.success(21).map(lambda x: x * 2)  # Effect[int]
+
+E.sync(lambda: print("hi"))  # Effect[None] — defers a side effect until the effect runs
+
+
+# Custom errors extend EffectonError and are final: one leaf class per cause
+@final
+@dataclass(frozen=True)
+class OopsError(E.EffectonError):
+    msg: str
+
+
+E.fail(OopsError(msg="oops"))  # Effect[Never, OopsError]
+```
+
+`suspend` defers building an effect. The thunk form wraps one effect; as a decorator on a function with parameters, each call captures its arguments and defers the body until the effect runs:
+
+```python
+E.suspend(lambda: E.fail(OopsError(msg="later")))  # Effect[Never, OopsError]
+
+
+@E.suspend
+def find_user(user_id: int) -> E.Effect[str, OopsError]:
+    print("runs only when the effect is interpreted")
+    return E.success(f"user-{user_id}")
+
+
+find_user(1)  # Effect[str, OopsError] — nothing printed yet
+```
+
+More examples: [`test_run_sync.py`](https://github.com/krzkaczor/effecton/blob/main/packages/effecton/src/effecton/test_run_sync.py), [`test_suspend.py`](https://github.com/krzkaczor/effecton/blob/main/packages/effecton/src/effecton/test_suspend.py).
+
+### Running effects
+
+Effects are inert values; a runner interprets one. Each runner comes in a throwing form that returns the value and an `_exit` form that returns an `Exit`:
+
+| Runner | Runs | Returns |
+|---|---|---|
+| `run_sync(effect)` | synchronously | the value, raising on failure |
+| `run_sync_exit(effect)` | synchronously | `Exit[A, E]` |
+| `run_async(effect)` | on a fresh asyncio loop (`asyncio.run` inside) | the value, raising on failure |
+| `run_async_exit(effect)` | on a fresh asyncio loop (`asyncio.run` inside) | `Exit[A, E]` |
+| `await run_async_coroutine(effect)` | inside a loop you already own | `Exit[A, E]` |
+
+The throwing forms raise a typed failure as the error itself (every `EffectonError` is an `Exception`), re-raise an exception defect as it is, wrap any other defect in `UnhandledDefect`, and re-raise the exception carried by an interruption:
+
+```python
+try:
+    value = E.run_sync(effect)  # A
+except HttpStatusError as e:  # a typed failure
+    ...
+```
+
+The `_exit` forms never raise; they return an `Exit` to match on:
+
+```python
+match E.run_sync_exit(effect):  # Exit[A, E] = Succeeded[A] | Failure[E]
+    case E.Succeeded(value):
+        ...
+    case E.Failure(cause):
+        ...  # cause is Fail(error) for typed failures, Die(defect) for unexpected exceptions, Interrupt(exception) for cancellations
+```
+
+`run_async` and `run_async_exit` interpret the same effect under asyncio, awaiting every `coroutine` effect they reach. They own the event loop through `asyncio.run`, so they cannot be called from a running loop; `run_async_coroutine` is the coroutine underneath, for a caller that already has one:
+
+```python
+exit = await E.run_async_coroutine(
+    effect
+)  # Exit[A, E], awaiting coroutine effects along the way
+```
+
+Running an effect that contains a `coroutine` effect synchronously doesn't await it: `run_sync_exit` settles as `Failure(Die(AsyncEffectInSyncRun()))`, `run_sync` raises `AsyncEffectInSyncRun`, and finalizers still run in both cases.
+
+More examples: [`test_run_sync.py`](https://github.com/krzkaczor/effecton/blob/main/packages/effecton/src/effecton/test_run_sync.py), [`test_run_async.py`](https://github.com/krzkaczor/effecton/blob/main/packages/effecton/src/effecton/test_run_async.py).
+
+### Error handling
+
+Use `catch_all` to handle errors:
+
+```python
+p = E.fail(OopsError(msg="oops")).catch_all(
+    lambda e: E.success(f"recovered from {e.msg}")
+)  # Effect[str] — the error channel is now Never
+
+E.run_sync(p)  # "recovered from oops"
+```
+
+Use `catch` to handle one error type and leave the rest in the error channel. The handler receives the narrowed error, and defects (`Die`) pass through untouched:
+
+```python
+n = random.randint(1, 4)
+
+p = E.success(n).flat_map(
+    lambda r: E.fail(FatalError()) if r == 2 else E.fail(RecoverableError())
+)  # Effect[Never, FatalError | RecoverableError]
+
+p2 = p.catch(RecoverableError)(lambda e: E.success(42))  # Effect[int, FatalError]
+```
+
+`catch` is curried like `provide`: the error class is bound first so the type checker can subtract it from the union. Catching a class the effect cannot fail with is a well-typed no-op.
+
+Error classes are leaves: mark every error `@final` and never subclass one. `catch` matches by class, and `@final` keeps its runtime `isinstance` check and the static subtraction in agreement, because the type checker cannot distinguish a subclass from its base when subtracting from a union.
+
+More examples: [`test_run_sync.py`](https://github.com/krzkaczor/effecton/blob/main/packages/effecton/src/effecton/test_run_sync.py).
+
+### Requirements and providing them
+
+`require(T)` reads a dependency and records it in the `R` channel; composing effects unions their requirements, exactly like errors. the runners only accept `Effect[A, E]`, so running an effect with unmet requirements is a type error, not a runtime surprise.
+
+```python
+@dataclass(frozen=True)
+class Db:
+    url: str
+
+
+needs_db = E.require(Db).map(lambda db: db.url)  # Effect[str, Never, Db]
+
+program = needs_db.provide(Db)(Db("postgres://x"))  # Effect[str] — runnable
+
+E.run_sync(program)  # "postgres://x"
+```
+
+`provide(T)(impl)` subtracts the provided type from `R`, so requirements can be provided one at a time, anywhere in the program — a partially provided effect is an ordinary value carrying the remainder in `R`, and the runners accept it only once `R` reaches `Never`.
+
+More examples: [`test_run_sync.py`](https://github.com/krzkaczor/effecton/blob/main/packages/effecton/src/effecton/test_run_sync.py).
+
+### Implicit requirements
+
+Some dependencies, such as a logger or a log level, should work out of the box yet stay overridable. An implicit requirement is a class that extends the `ImplicitRequirement` protocol with a `default()` classmethod. Reading one with `require_implicit(X)` types as `Effect[X]`: it never enters `R`, so a program that only uses implicit requirements runs bare. If the lookup misses, the interpreter falls back to `X.default()`, computed once per process and memoized, so defaults must be immutable values.
+
+```python
+@final
+@dataclass(frozen=True)
+class Greeting(E.ImplicitRequirement):
+    text: str
+
+    @classmethod
+    def default(cls) -> Greeting:
+        return Greeting("hello")
+
+
+E.run_sync(E.require_implicit(Greeting))  # Greeting("hello") — nothing provided
+
+# override for a sub-effect only; the env is restored when it settles
+E.run_sync(E.provide_implicit(E.require_implicit(Greeting), Greeting("hi")))
+```
+
+`provide_implicit(effect, value)` is keyed by `type(value)`, so mark implicit requirement classes `@final`. Overrides also compose in a `provide` chain: `effect.provide(Greeting)(Greeting("hi"))`. `require_implicit` is a separate accessor rather than an overload on `require` because the overload pair silently drops requirements from `R` in some inference positions (pinned in `test_types_implicit_requirement.py`). One footgun: the runtime check only tests that a `default` attribute exists, so a plain requirement class that defines one gets the default fallback instead of a `MissingRequirement` defect.
+
+More examples: [`test_implicit_requirement.py`](https://github.com/krzkaczor/effecton/blob/main/packages/effecton/src/effecton/test_implicit_requirement.py).
+
+### Resource management with `on_exit` and Scope
+
+`on_exit` attaches a finalizer that runs when the effect settles, on success and failure alike. A `Scope` collects finalizers from a whole sub-tree: `acquire_and_release` registers a release for an acquired resource, and `.scoped()` provides the `Scope` and runs the collected finalizers in reverse order when the wrapped effect settles. It composes with `provide` chains — `program.provide(Db)(db).scoped()` — and is a no-op on effects that never acquired a `Scope`, so it can uniformly terminate a chain.
+
+```python
+E.success(21).on_exit(E.log_info("done"))  # finalizer runs on success and failure alike
+
+conn = E.acquire_and_release(
+    E.sync(lambda: pool.connect()),  # acquire
+    lambda c: E.sync(c.close),  # release, guaranteed by the enclosing scope
+)  # Effect[Connection, Never, Scope]
+
+program = conn.flat_map(
+    run_queries
+).scoped()  # Scope discharged; close() runs when program settles
+```
+
+A finalizer that dies doesn't skip the remaining finalizers; its defect surfaces in the final `Exit`.
+
+More examples: [`test_scope.py`](https://github.com/krzkaczor/effecton/blob/main/packages/effecton/src/effecton/std/test_scope.py).
+
+### Generator syntax
+
+`@E.gen` turns a generator function into a factory of effects: the interpreter runs each yielded effect and sends its success value back into the generator, and the generator's return value becomes the effect's success value. Write `x = yield from effect`, not `x = yield effect` — `Effect.__iter__` is typed so `yield from` gives `x` the effect's success type, while a bare `yield` types as `Any`.
+
+```python
+@E.gen
+def total(n: int) -> E.EffectGen[int, OopsError]:
+    a = yield from E.success(20)  # a: int — yield from types the sent-back value
+
+    if n < 0:
+        yield from E.fail(
+            OopsError(msg="negative")
+        )  # OopsError joins the error channel
+    return a + n
+
+
+E.run_sync(total(22))  # 42
+```
+
+A failing yielded effect abandons the generator, so `try/except` around a `yield` never observes effect failures — use `catch` or `catch_all` on the resulting effect instead.
+
+More examples: [`test_gen.py`](https://github.com/krzkaczor/effecton/blob/main/packages/effecton/src/effecton/test_gen.py).
+
+### Wrapping third party code
+
+`attempt` runs an exception-throwing thunk lazily and maps expected exceptions into the typed error channel. Re-raise unexpected exceptions from the mapper so they stay defects:
+
+```python
+@final
+@dataclass(frozen=True)
+class InvalidJson(E.EffectonError):
+    text: str
+
+
+def parse_json(text: str) -> E.Effect[Any, InvalidJson]:
+    def to_error(e: Exception) -> InvalidJson:
+        if isinstance(e, json.JSONDecodeError):
+            return InvalidJson(text)
+        raise e  # anything else stays a defect
+
+    return E.attempt(lambda: json.loads(text), to_error)
+```
+
+More examples: [`test_attempt.py`](https://github.com/krzkaczor/effecton/blob/main/packages/effecton/src/effecton/test_attempt.py).
+
+### Wrapping async code
+
+`coroutine` defers an awaitable the way `sync` defers a thunk: the thunk builds a fresh awaitable on every run, because a coroutine object can be awaited only once. Exceptions become defects. `attempt_async` is the `attempt` counterpart that maps expected exceptions into the error channel. Only the `run_async` family can interpret either:
+
+```python
+client = httpx.AsyncClient()
+
+E.coroutine(lambda: client.get(url))  # Effect[httpx.Response] — nothing awaited yet
+
+
+def get_text(url: str) -> E.Effect[str, HttpStatusError]:
+    async def go() -> str:
+        response = await client.get(url)
+        response.raise_for_status()
+        return response.text
+
+    def to_error(e: Exception) -> HttpStatusError:
+        if isinstance(e, httpx.HTTPStatusError):
+            return HttpStatusError(url=url, status_code=e.response.status_code)
+        raise e  # anything else stays a defect
+
+    return E.attempt_async(go, to_error)
+
+
+E.run_async(get_text("https://example.com"))  # text, or raises HttpStatusError
+
+E.run_async_exit(
+    get_text("https://example.com")
+)  # Succeeded(text) or Failure(Fail(HttpStatusError(...)))
+```
+
+Inside `@E.gen` bodies, `yield from E.coroutine(...)` works like any other effect; the generator itself stays synchronous. If the task running `run_async_coroutine` is cancelled, the effect unwinds with an `Interrupt` cause, which `catch_all` and `catch` skip like a `Die`: finalizers and scope releases run, and the run settles as `Failure(Interrupt(exception))`, so an `asyncio.timeout` around `run_async_coroutine` doesn't leak resources and completes normally with that `Exit`. The cancellation is consumed by `run_async_coroutine`; a caller whose task should stop re-raises the carried exception. A finalizer that is mid-await when the cancellation arrives is shielded and runs to completion, and a cancellation raised from a synchronous thunk or callback, such as a cancelled future's `result()`, unwinds the same way.
+
+More examples: [`test_run_async.py`](https://github.com/krzkaczor/effecton/blob/main/packages/effecton/src/effecton/test_run_async.py).
+
+## Standard library
+
+### Logger
+
+Effecton comes with pretty logger out of the box.
+
+```python
+E.run_sync(E.log_info("user created", 42))  # pretty-printed to stderr, no setup needed
+
+program = E.annotate_logs(
+    handle_request(), request_id="r-1"
+)  # every log inside carries request_id=r-1
+
+captured: list[E.LogData] = []
+E.run_sync(
+    E.provide_implicit(
+        program, E.CurrentLoggers((E.EffectonLogger(log=captured.append),))
+    )
+)
+```
+
+More examples: [`test_logger.py`](https://github.com/krzkaczor/effecton/blob/main/packages/effecton/src/effecton/std/test_logger.py), [`test_pretty_logger.py`](https://github.com/krzkaczor/effecton/blob/main/packages/effecton/src/effecton/std/test_pretty_logger.py).
+
+## Roadmap
+
+- [x] `ty` support
+- [x] Support for async/sync code
+- [ ] Retries
+- [ ] Timeouts
+- [ ] `Random` implicit service
+- [ ] More examples of integrations with existing ecosystem (fastapi, pydantic etc.)
+
+## Inspirations
+
+* Effect-TS/ZIO
+* stateless
+
+## Contributing
+
+See [CONTRIBUTING.md](https://github.com/krzkaczor/effecton/blob/main/CONTRIBUTING.md) for repo setup and development commands.

effecton-0.2.0.dist-info/RECORD

@@ -0,0 +1,20 @@
+effecton/__init__.py,sha256=1AoMW-SRutmWP1fRdcSEzEryQ81KQJx6-gc4s902Cek,2124
+effecton/attempt.py,sha256=TBSocEZTGPInRvpLAnox9F8As9PEAJQ2Nuv1nU-IKEU,1521
+effecton/catch.py,sha256=TpGKIZ9dd4uJOxTwyfNmcBoavuSbIysVW0K2uwPjfiw,1200
+effecton/effect.py,sha256=jS2TQ2p9P94PIiXDU4gS-YsrTG0V26yndzTTvCnXuGE,5699
+effecton/exit.py,sha256=BfUfcNf6K4EM4IXeBI-FNQ1TlfoZbJgU-8TgHwFaNDs,1816
+effecton/gen.py,sha256=20GkDvF_YrACbZmNka_NnjTpQdSFpNNvQWI-YhrRSm8,1706
+effecton/implicit_requirement.py,sha256=N0XIin5cJe3RtJL9int9_0OpJBwZwnvm48H_nX7A7Io,1279
+effecton/provide.py,sha256=QYZffxMzatw-uXNmPd68pQLEkgt501tZlWRG-39SF4c,1134
+effecton/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+effecton/run_async.py,sha256=43sMg4117nfZc8s4ZrrG7m1gWzA-VJw-J8Z4SJwtRzk,8772
+effecton/run_sync.py,sha256=WZw9nGRRYZc_pI0aFBjG52IFxqaocLR6Smu0jKIuYK8,6468
+effecton/suspend.py,sha256=Qde8d6ECfAP76iahpEwRP5XNrsnS-ZcsfcGlqobdrhA,1552
+effecton/std/__init__.py,sha256=dxyXTqusP00HWIbwB7Y-p5KH-zhu-9cXpfW8QML07a4,61
+effecton/std/logger.py,sha256=YEJkBIs0rZrIA2z2ymLzNR-eqiibCu4M2TdyFO98PLg,5281
+effecton/std/pretty_logger.py,sha256=tbFpQkcMFfhDv94jxfDKkQhDJgw9Su38JVB9ptFQrM8,3699
+effecton/std/scope.py,sha256=ypYGqBBJWv8v8mP54vPY_8j9oXDuoXfzksGTMYmrY88,1921
+effecton-0.2.0.dist-info/METADATA,sha256=YF3lS88lCHKqe4z9mDIfRrdoqDegqXgsAhKYtdYTaW8,17073
+effecton-0.2.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+effecton-0.2.0.dist-info/licenses/LICENSE,sha256=3B7uzSf5952ICD7olNeRci6CqDdhRKYoXzVXc8VnAyk,1080
+effecton-0.2.0.dist-info/RECORD,,

effecton-0.2.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py3-none-any

effecton-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2026 Krzysztof Kaczor
+
+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.