arkitekt-runtime 1.0.1__tar.gz

arkitekt_runtime-1.0.1/.gitignore

@@ -0,0 +1,7 @@
+.venv/
+dist/
+__pycache__/
+*.py[cod]
+.pytest_cache/
+.ruff_cache/
+.coverage

arkitekt_runtime-1.0.1/PKG-INFO

@@ -0,0 +1,29 @@
+Metadata-Version: 2.5
+Name: arkitekt-runtime
+Version: 1.0.1
+Summary: the execution core of an Arkitekt app: agent, actors, tasks, journal, state and structure serialization, shared by every runtime
+Author-email: jhnnsrs <jhnnsrs@gmail.com>
+License-Expression: MIT
+Requires-Python: >=3.11
+Requires-Dist: arkitekt-spec>=1.1
+Requires-Dist: janus>=2.0.0
+Requires-Dist: jsonpatch>=1.33
+Requires-Dist: koil>=3.3.3
+Requires-Dist: pydantic>=2.11
+Provides-Extra: qt
+Requires-Dist: qtpy>=2.4; extra == 'qt'
+Description-Content-Type: text/markdown
+
+# arkitekt-runtime
+
+The execution core of an Arkitekt app: what every runtime needs to *run* a declared app.
+
+An app is declared with [arkitekt-spec](../arkitekt-spec). A runtime executes it:
+[rekuest](../rekuest) in distributed mode (a socket agent registered with a rekuest server),
+[arkitekt-fastapi](../arkitekt-fastapi) in server mode (an HTTP service). Both build on this
+package: the agent's assignment handling, actors, `Task`, the journal, state, locks, hook
+runners and structure serialization.
+
+It carries no transport and no client -- no websockets, rath or graphql-core. A runtime plugs
+in its transport (`agents.transport.base.AgentTransport`), its caller (to call other actions)
+and its task scope (e.g. rath's, so service clients attribute requests to the running task).

arkitekt_runtime-1.0.1/README.md

@@ -0,0 +1,13 @@
+# arkitekt-runtime
+
+The execution core of an Arkitekt app: what every runtime needs to *run* a declared app.
+
+An app is declared with [arkitekt-spec](../arkitekt-spec). A runtime executes it:
+[rekuest](../rekuest) in distributed mode (a socket agent registered with a rekuest server),
+[arkitekt-fastapi](../arkitekt-fastapi) in server mode (an HTTP service). Both build on this
+package: the agent's assignment handling, actors, `Task`, the journal, state, locks, hook
+runners and structure serialization.
+
+It carries no transport and no client -- no websockets, rath or graphql-core. A runtime plugs
+in its transport (`agents.transport.base.AgentTransport`), its caller (to call other actions)
+and its task scope (e.g. rath's, so service clients attribute requests to the running task).

arkitekt_runtime-1.0.1/arkitekt_runtime/__init__.py

@@ -0,0 +1,8 @@
+"""arkitekt-runtime: the execution core every runtime of an Arkitekt app shares.
+
+A declared app (:mod:`arkitekt_spec.declare`) is run by a runtime: rekuest in
+distributed mode, arkitekt-fastapi in server mode. Both are built on this package --
+the agent (:mod:`arkitekt_runtime.agents.base`), actors, :class:`~arkitekt_runtime.task.Task`,
+the journal, state, locks, hook runners and structure serialization. A runtime plugs
+in its transport, its caller and its task scope; this package has none of its own.
+"""

arkitekt_runtime-1.0.1/arkitekt_runtime/actors/__init__.py

@@ -0,0 +1,6 @@
+"""The actors: what runs one assignment of an action.
+
+Nothing is re-exported here -- an actor, a builder or a strategy is imported
+from the module that defines it (``actors.base``, ``actors.functional``,
+``actors.actify``).
+"""

arkitekt_runtime-1.0.1/arkitekt_runtime/actors/actify.py

@@ -0,0 +1,91 @@
+"""Actifier
+
+This module contains the actify function, which is used to convert a function
+into an actor.
+"""
+
+import inspect
+from functools import partial
+from typing import Any
+
+from arkitekt_runtime.actors.functional import (
+    FUNC,
+    GEN,
+    THREADED_FUNC,
+    THREADED_GEN,
+    FunctionalActor,
+)
+from arkitekt_spec.declare.protocol.types import AnyFunction
+from arkitekt_spec.declare.actors.types import (
+    ImplementationDetails,
+    RegisterConfig,
+)
+from arkitekt_runtime.actors.types import ActorBuilder
+from arkitekt_spec.actions import DefinitionInput
+from arkitekt_spec.declare.structures.registry import StructureRegistry
+from arkitekt_spec.declare.actors.actify import (
+    derive_implementation_details,
+    prepare_definition_from_config,
+)
+
+
+
+
+
+
+def reactify(
+    function: AnyFunction,
+    structure_registry: StructureRegistry,
+    config: RegisterConfig | None = None,
+) -> tuple[DefinitionInput, ImplementationDetails, ActorBuilder]:
+    """Reactify a function
+
+    This function takes a callable (of type async or sync function or generator) and
+    returns a builder function that creates an actor that makes the function callable
+    from the rekuest server.
+
+    All registration options are read from the bundled ``config``
+    (:class:`~rekuest.actors.types.RegisterConfig`); ``config`` defaults to an
+    empty config so ``reactify(func, registry)`` keeps working.
+    """
+    config = config or RegisterConfig()
+
+    implementation_details = derive_implementation_details(function, config, structure_registry)
+    definition = prepare_definition_from_config(
+        function, structure_registry, config, implementation_details
+    )
+
+    is_coroutine = inspect.iscoroutinefunction(function)
+    is_asyncgen = inspect.isasyncgenfunction(function)
+    is_method = inspect.ismethod(function)
+
+    is_generatorfunction = inspect.isgeneratorfunction(function)
+    is_function = inspect.isfunction(function)
+
+    actor_attributes: dict[str, Any] = {
+        "assign": function,
+        "expand_inputs": not config.bypass_expand,
+        "shrink_outputs": not config.bypass_shrink,
+        "structure_registry": structure_registry,
+        "definition": definition,
+        **implementation_details.actor_kwargs(),
+        "concurrency": config.concurrency,
+        "policy": config.policy,
+    }
+
+    if is_coroutine:
+        iterator = FUNC
+    elif is_asyncgen:
+        iterator = GEN
+    elif is_generatorfunction and not config.in_process:
+        iterator = THREADED_GEN
+    elif (is_function or is_method) and not config.in_process:
+        iterator = THREADED_FUNC
+    else:
+        raise NotImplementedError("No way of converting this to a function")
+
+    return (
+        definition,
+        implementation_details,
+        partial(FunctionalActor, iterator=iterator, **actor_attributes),
+    )