affective-py 0.1.0__py3-none-any.whl

affective/__init__.py

@@ -0,0 +1,13 @@
+from affective.core.effects import Effect as Effect
+from affective.core.effects import Raise as Raise
+from affective.core.effects import Async as Async
+from affective.core.effects import Affects as Affects
+from affective.core.handlers import catch as catch
+from affective.core.effects import operation as operation
+from affective.core.continuation import \
+    RunningContinuation as RunningContinuation
+from affective.core.continuation import Continuation as Continuation
+from affective.core.handlers import handler as handler
+from affective.core.loop import UnhandledEffect as UnhandledEffect
+from affective.core.loop import run as run
+from affective.core.loop import handle as handle

affective/core/continuation.py

@@ -0,0 +1,8 @@
+from collections.abc import Callable, Generator
+from typing import Any, ParamSpec, TypeAlias
+
+# bcz mkdocstrings does not understand PEP695
+
+RunningContinuation: TypeAlias = Generator[Any, Any, Any]
+_ExpectsInput = ParamSpec("_ExpectsInput")
+Continuation: TypeAlias = Callable[_ExpectsInput, RunningContinuation]

affective/core/effects.py

@@ -0,0 +1,55 @@
+from collections.abc import Generator, Callable
+from dataclasses import dataclass
+from functools import wraps
+from typing import (
+    Annotated, Any, Awaitable, Sequence,
+    Mapping, final, cast, TypeVar
+)
+
+
+@dataclass
+@final
+class Perform:
+    effect_type: Any
+    effect_args: Sequence[Any]
+    effect_kwargs: Mapping[str, Any]
+
+
+class Effect:
+    ...
+
+
+class _StaticGeneratorMethod[T]:
+    # This is some black magic by mypy & Gemini
+    def __get__(self, instance: Any, owner: type | None = None) -> T:
+        raise NotImplementedError
+
+
+def operation[**P, R](f: Callable[P, Affects[R]]) -> _StaticGeneratorMethod[
+    Callable[P, Generator[Perform, Any, R]]
+]:
+    @wraps(f)
+    def wrapper(
+        *args: P.args, **kwargs: P.kwargs
+    ) -> Generator[Perform, R | Perform, R]:
+        ret = yield Perform(wrapper, args, kwargs)
+        while ret.__class__ is Perform:
+            ret = yield ret
+        return cast(R, ret)
+
+    return wrapper  # type: ignore
+
+
+class Raise[ExcT: Exception](Effect):
+    @operation
+    def error[_ExcT: Exception](err: _ExcT) -> Affects[None]: ...
+
+
+class Async(Effect):
+    @operation
+    def wait[T](coro: Awaitable[T]) -> Affects[T, Raise[Exception]]: ...
+
+
+type Affects[ReturnT, Effects = None] = Annotated[
+    Generator[Perform, Any, ReturnT], Effects
+]

affective/core/handlers.py

@@ -0,0 +1,85 @@
+from collections.abc import Callable, Generator
+from dataclasses import dataclass
+from typing import Any, Concatenate
+
+from affective import Raise
+from affective.core.effects import Perform
+from affective.core.continuation import Continuation
+
+
+@dataclass
+class OperationHandlerCollection:
+    handlers: dict[Any, Callable[
+        ...,
+        Generator[Perform, Any, Any]
+    ]]
+
+    def __add__(
+        self, other: Any
+    ) -> "OperationHandlerCollection":
+        match other:
+            case OperationHandler(op, func):
+                return OperationHandlerCollection(self.handlers | {op: func})
+            case OperationHandlerCollection(handlers):
+                return OperationHandlerCollection(handlers | self.handlers)
+            case _:
+                return NotImplemented
+
+    def __radd__(self, other: Any) -> "OperationHandlerCollection":
+        return self.__add__(other)
+
+
+@dataclass
+class OperationHandler[**P = ..., R = Any]:
+    operation: Any
+    func: Callable[
+        Concatenate[Continuation[[R]], P],
+        Generator[Perform, Any, R]
+    ]
+
+    def __add__(self, other: Any) -> "OperationHandlerCollection":
+        match other:
+            case OperationHandler(op, func):
+                return OperationHandlerCollection(
+                    {op: func, self.operation: self.func}
+                )
+            case _:
+                return NotImplemented
+
+
+def handler[**P, R](
+    eff_op: Callable[P, Generator[Perform, Any, R]]
+) -> Callable[
+    [
+        Callable[
+            Concatenate[Continuation[[R]], P],
+            Generator[Perform, Any, R]
+        ]
+    ],
+    OperationHandler
+]:
+    def wrapper(
+        function: Callable[
+            Concatenate[Continuation[[R]], P],
+            Generator[Perform, Any, R]
+        ]
+    ) -> OperationHandler:
+        return OperationHandler(eff_op, function)
+
+    return wrapper
+
+
+def catch[
+    R,
+    ThenContT: Continuation[...]
+](
+    on_catch: Continuation[[ThenContT, Exception]]
+) -> OperationHandler:
+    @handler(Raise.error)  # type: ignore
+    def _handler(
+        cont: ThenContT, exc: Exception
+    ) -> Generator[Perform, R, R]:
+        ret: R = yield from on_catch(cont, exc)
+        return ret
+
+    return _handler

affective/core/loop.py

@@ -0,0 +1,97 @@
+from typing import Any
+
+from affective.core.effects import Async, Raise, Perform
+from affective.core.handlers import (
+    OperationHandlerCollection,
+    OperationHandler,
+)
+from affective.core.continuation import RunningContinuation
+
+
+class UnhandledEffect(Exception):
+    def __init__(self, effect: Perform):
+        super().__init__(
+            f"Effect handler for {effect.effect_type.__qualname__} not found"
+        )
+        self.effect = effect
+
+
+def handle(
+    ctx: OperationHandlerCollection | OperationHandler,
+    cont: RunningContinuation,
+    effect: Perform | None = None,
+) -> Any:
+    if isinstance(ctx, OperationHandler):
+        ctx = OperationHandlerCollection({ctx.operation: ctx.func})
+    if effect is None:
+        try:
+            effect = next(cont)
+        except StopIteration as stop:
+            return stop.value
+    while True:
+        if not isinstance(effect, Perform):
+            raise TypeError(f"Unknown yield: {effect}")
+        if effect.effect_type in ctx.handlers:
+            def after(effect_result: Any) -> Any:
+                try:
+                    eff = cont.send(effect_result)
+                except StopIteration as stop:
+                    return stop.value
+                return_value = yield from handle(ctx, cont, eff)
+                return return_value
+
+            ret = yield from handle(
+                ctx, ctx.handlers[effect.effect_type](
+                    after, *effect.effect_args, **effect.effect_kwargs
+                )
+            )
+            return ret
+        else:
+            effect_result = yield effect
+            try:
+                effect = cont.send(effect_result)
+            except StopIteration as stop:
+                return stop.value
+            return_value = yield from handle(ctx, cont, effect)
+            return return_value
+
+
+def run(cont: RunningContinuation) -> Any:
+    try:
+        effect = next(cont)
+        while True:
+            if not isinstance(effect, Perform):
+                raise TypeError(f"Unknown yield: {effect}")
+            if effect.effect_type == Raise.error:
+                raise effect.effect_args[0]
+            else:
+                raise UnhandledEffect(effect)
+    except StopIteration as stop:
+        return stop.value
+
+
+async def arun(cont: RunningContinuation) -> Any:
+    try:
+        effect = next(cont)
+        while True:
+            if not isinstance(effect, Perform):
+                raise TypeError(f"Unknown yield: {effect}")
+            if effect.effect_type == Raise.error:
+                raise effect.effect_args[0]
+            elif effect.effect_type == Async.wait:
+                try:
+                    result = await effect.effect_args[0]
+                except Exception as exc:
+                    try:
+                        effect = cont.send(Perform(Raise.error, [exc], {}))
+                    except StopIteration as stop:
+                        return stop.value
+                else:
+                    try:
+                        effect = cont.send(result)
+                    except StopIteration as stop:
+                        return stop
+            else:
+                raise UnhandledEffect(effect)
+    except StopIteration as stop:
+        return stop.value

affective/mypy_ext/__init__.py

@@ -0,0 +1,9 @@
+from mypy.plugin import Plugin
+
+from affective.mypy_ext.plugin import AffectivePlugin
+
+
+def plugin(version: str) -> type[Plugin]:
+    if not version.startswith("2."):
+        raise ValueError("Cannot run Affective with mypy < 2.0.0")
+    return AffectivePlugin

affective/mypy_ext/plugin.py

@@ -0,0 +1,19 @@
+from typing import Callable, Optional
+
+from mypy.plugin import Plugin, ClassDefContext
+from mypy.nodes import Decorator
+
+
+def abstractise_effects(ctx: ClassDefContext) -> None:
+    for stmt in ctx.cls.defs.body:
+        if isinstance(stmt, Decorator):
+            stmt.func.abstract_status = 1
+
+
+class AffectivePlugin(Plugin):
+    def get_base_class_hook(self, fullname: str) -> Optional[
+        Callable[[ClassDefContext], None]
+    ]:
+        if fullname == "affective.core.effects.Effect":
+            return abstractise_effects
+        return None

affective/std/files.py

@@ -0,0 +1,48 @@
+from typing import Any
+
+from affective import Effect, Affects, Raise, operation, Continuation, handler
+
+
+class Files(Effect):
+    @operation
+    def write(path: str, contents: bytes) -> Affects[
+        None, Raise[PermissionError]
+    ]: ...
+
+    @operation
+    def read(path: str) -> Affects[
+        bytes, Raise[PermissionError] | Raise[FileNotFoundError]
+    ]: ...
+
+
+@handler(Files.write)
+def _handle_default_write(
+    then: Continuation[[None]],
+    path: str,
+    contents: bytes
+) -> Affects[Any]:
+    try:
+        with open(path, "wb") as f:
+            f.write(contents)
+    except PermissionError as exc:
+        yield from Raise.error(exc)
+    ret = yield from then(None)
+    return ret
+
+
+@handler(Files.read)
+def _handle_default_read(
+    then: Continuation[[bytes]],
+    path: str,
+) -> Affects[Any]:
+    try:
+        with open(path, "rb") as f:
+            contents = f.read()
+    except PermissionError as exc:
+        yield from Raise.error(exc)
+    else:
+        ret = yield from then(contents)
+        return ret
+
+
+default_files_handler = _handle_default_read + _handle_default_write

affective/std/http.py

@@ -0,0 +1,75 @@
+from dataclasses import dataclass
+from logging import Handler
+from typing import Any
+
+try:
+    from aiohttp.web_response import Response
+    from aiohttp import ClientSession, ClientTimeout
+except ImportError as exc:
+    raise ImportError(
+        "Cannot use Http effects without [aiohttp] extra"
+    ) from exc
+
+from affective import Async, Effect, handler, operation, Continuation, Affects
+
+
+@dataclass
+class HttpResponse:
+    status_code: int
+    data: bytes
+    headers: dict[str, str]
+
+
+class Http(Effect):
+    @operation
+    def request(
+        method: str,
+        url: str,
+        params: str | dict[str, Any] | None = None,
+        data: Any | None = None,
+        headers: dict[str, str] | None = None,
+        timeout_s: float | None = None,
+    ) -> Affects[HttpResponse]:
+        ...
+
+
+@handler(Http.request)
+def _async_request_handler(
+    then: Continuation[[HttpResponse]],
+    method: str,
+    url: str,
+    params: str | dict[str, Any] | None = None,
+    data: Any | None = None,
+    headers: dict[str, str] | None = None,
+    timeout_s: float | None = None,
+) -> Affects[Any, Async]:
+    async def _do() -> HttpResponse:
+        async with (
+            ClientSession() as session,
+            session.request(
+                method=method,
+                url=url,
+                params=params,
+                data=data,
+                headers=headers,
+                timeout=ClientTimeout(timeout_s)
+                if timeout_s is not None else None,
+                raise_for_status=False,
+            ) as response
+        ):
+            response_data = await response.read()
+            return HttpResponse(
+                status_code=response.status,
+                data=response_data,
+                headers={
+                    header: value
+                    for header, value in response.headers.items()
+                },
+            )
+
+    result = yield from Async.wait(_do())
+    ret = yield from then(result)
+    return ret
+
+
+async_http_handler = _async_request_handler

affective/std/stdio.py

@@ -0,0 +1,34 @@
+import sys
+from typing import Any
+
+from affective import operation, handler, Effect, Affects
+from affective.core.continuation import Continuation, RunningContinuation
+
+
+class Console(Effect):
+    @operation
+    def read() -> Affects[str]: ...
+
+    @operation
+    def write(text: str) -> Affects[None]: ...
+
+
+@handler(Console.write)
+def default_stdout_writer(
+    then: Continuation[[None]], text: str
+) -> Affects[Any]:
+    sys.stdout.write(text)
+    sys.stdout.flush()
+    ret = yield from then(None)
+    return ret
+
+
+@handler(Console.read)
+def default_stdin_reader(
+    then: Continuation[[str]]
+) -> Affects[Any]:
+    ret = yield from then(sys.stdin.readline().removesuffix("\n"))
+    return ret
+
+
+default_stdio_handler = default_stdout_writer + default_stdin_reader

affective_py-0.1.0.dist-info/METADATA

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: affective-py
+Version: 0.1.0
+Summary: WIP AE in Python
+Requires-Python: >=3.14
+Provides-Extra: aiohttp
+Requires-Dist: aiohttp>=3.13.5; extra == "aiohttp"

affective_py-0.1.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+affective/__init__.py,sha256=N9Qj8r6viO9t9vWGv3qU1PGQ_-3AAmUmY_jLeGd9jZQ,700
+affective/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+affective/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+affective/core/continuation.py,sha256=YhA7xDWOLvA3jyrSVye3D5yA9OMlHo56krI3bpISJO8,321
+affective/core/effects.py,sha256=twF1ow-asfLpmWu57k89Y76fAE8LcJkLrlExFAAXfPA,1358
+affective/core/handlers.py,sha256=re1o3P7hvMOxTSetjbsLspH05KqlVXmQn4xTGoThzyo,2316
+affective/core/loop.py,sha256=m2LUMETFlx7vUHSMBGKUuzjK_qNt2OPBS87WNtyFUns,3337
+affective/mypy_ext/__init__.py,sha256=SEGepM-7TBVSvsXbWOzO4VZD55EJ5d5C4hiycCe60I4,270
+affective/mypy_ext/plugin.py,sha256=bT-cf3BXzu2CCBRAL6HSYdUREt7nSKN4G0Ma7S-EJhM,572
+affective/std/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+affective/std/files.py,sha256=LyGJ0l00JyK5oAyo47DPf6xP3ghyXYIlInLj1idWI5A,1153
+affective/std/http.py,sha256=bDKQX9Ec7YQ00qn-ArPoJv70Cs0abeBTOjdf2rz5kpA,2094
+affective/std/stdio.py,sha256=OC2lyhRRKp7kIq65PPzpVkFaTX_HzK5yyaG7KE5M6Ms,804
+affective_py-0.1.0.dist-info/METADATA,sha256=S5bTU31VlU2gB6FcbWYPqqyz_IT5evEDPO29GJOzX3I,188
+affective_py-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+affective_py-0.1.0.dist-info/top_level.txt,sha256=3PaZbbPjBoUDa-uZoYamcf8haaV2WV1Kh_pVS8YcpwY,10
+affective_py-0.1.0.dist-info/RECORD,,

affective_py-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

affective_py-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+affective