nodnod 1.0.0__tar.gz

nodnod-1.0.0/.claude/settings.local.json

@@ -0,0 +1,14 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(cat:*)",
+      "Bash(python -m pytest --version)",
+      "Bash(uv add:*)",
+      "Bash(uv remove:*)",
+      "Bash(ls:*)",
+      "Bash(uv run:*)",
+      "Bash(find:*)"
+    ],
+    "deny": []
+  }
+}

nodnod-1.0.0/.codecov.yml

@@ -0,0 +1,9 @@
+comment: false
+
+coverage:
+  status:
+    project:
+      default:
+        target: auto
+        threshold: 1%
+    patch: off

nodnod-1.0.0/.github/actions/install-dependencies/action.yml

@@ -0,0 +1,21 @@
+name: Install uv and dependencies
+
+inputs:
+  python-version:
+    description: "Python version."
+    required: false
+    default: "3.13"
+
+runs:
+  using: composite
+  steps:
+    - uses: hynek/setup-cached-uv@v2
+      with:
+        cache-suffix: -${{ inputs.python-version }}-cache
+        cache-dependency-path: "**/uv.lock"
+
+    - name: "Install dependencies"
+      run: |
+        uv venv --python ${{ inputs.python-version }}
+        uv sync --all-groups --dev
+      shell: bash

nodnod-1.0.0/.github/workflows/tests.yml

@@ -0,0 +1,50 @@
+name: tests and coverage
+
+on:
+  push:
+
+jobs:
+  lock-file:
+    name: "Lock uv"
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version:
+          - "3.13"
+          - "3.14"
+
+    steps:
+      - uses: asottile/workflows/.github/actions/fast-checkout@v1.10.0
+
+      - uses: ./.github/actions/install-dependencies
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - run: uv lock --locked
+
+  tests:
+    name: "Tests"
+    needs: lock-file
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version:
+          - "3.13"
+          - "3.14"
+
+    steps:
+      - uses: asottile/workflows/.github/actions/fast-checkout@v1.10.0
+
+      - uses: ./.github/actions/install-dependencies
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Run tests with coverage
+        run: |
+          uv run pytest --cov --cov-report=xml --cov-report=term-missing
+
+      - name: Upload coverage to Codecov
+        uses: codecov/codecov-action@v5
+        with:
+          files: ./coverage.xml
+          token: ${{ secrets.CODECOV_TOKEN }}

nodnod-1.0.0/.gitignore

@@ -0,0 +1,6 @@
+__pycache__
+.venv
+.coverage
+.ruff_cache
+.pytest_cache
+.DS_Store

nodnod-1.0.0/PKG-INFO

@@ -0,0 +1,15 @@
+Metadata-Version: 2.4
+Name: nodnod
+Version: 1.0.0
+Summary: Programming in Python empowered with Nodes DI, implements efficient nodes computation agents and dependency scoping
+Author: timoniq
+Requires-Python: <4.0,>=3.13
+Requires-Dist: kungfu-fp>=1.0.0
+Requires-Dist: typing-extensions>=4.15.0
+Description-Content-Type: text/markdown
+
+# NodNod
+
+🧑‍🧑‍🧒‍🧒 Programming in Python enhanced with Nodes
+
+[![codecov](https://codecov.io/gh/luwqz1/nodnod/branch/fix/graph/badge.svg)](https://codecov.io/gh/luwqz1/nodnod)

nodnod-1.0.0/bug.py

@@ -0,0 +1,26 @@
+import asyncio
+
+from nodnod.interface.node_from_function import Scope, create_node_from_function, inject_externals
+from nodnod.interface.node_from_function import create_agent_from_node
+
+
+def func(a: int | None, b: int) -> None:
+    print(a)
+    print(b)
+
+
+async def main():
+    node = create_node_from_function(func)
+    agent = create_agent_from_node(node)
+    print(node.__dependencies__)
+    print(node.__externals__)
+    node.__dependencies__ = set()
+    scope = Scope(detail="test")
+
+    async with scope:
+        inject_externals(scope, dict(a=1, b=2))
+        await agent.run(scope, mapped_scopes={})
+        print(scope)
+
+
+asyncio.run(main())

nodnod-1.0.0/bug2.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from nodnod.node import initialize_forward_refs
+from nodnod.interface.node_from_function import create_node_from_function
+
+
+def func(a: A) -> None: ...  # ForwardRef(A)
+
+
+class A:
+    pass
+
+
+
+create_node_from_function(func)

nodnod-1.0.0/main.py

@@ -0,0 +1,172 @@
+import asyncio
+import dataclasses
+import typing
+
+import kungfu
+
+from nodnod import (
+    DataNode,
+    EventLoopAgent,
+    Node,
+    NodeConstructor,
+    NodeError,
+    Scalar,
+    Scope,
+    SequentialEither,
+    Value,
+    case,
+    generic_node,
+    polymorphic,
+    scalar_node,
+)
+from nodnod.utils.prepare_values import prepare_values
+
+
+@generic_node
+#@dataclasses.dataclass
+class Lolik[T: (str, int), *Ts, X: str | int](DataNode, abstract=True):
+    def __init__(self, t: T, x: X):
+        self.t = t
+        self.x = x
+
+    @classmethod
+    async def __compose__(cls, t: type[T], y: type[X]) -> typing.Self:
+        return cls(t("11"), y("22"))
+
+
+@generic_node
+class TypeArgs[*Ts]:
+    def __init__(self, type_args: tuple[typing.Unpack[Ts]]) -> None:
+        self.type_args = type_args
+
+    @classmethod
+    def __compose__(cls, type_args: tuple[typing.Unpack[Ts]]) -> typing.Self:
+        return cls(type_args)
+
+
+class Interface:
+    def get_lol(self) -> str:
+        ...
+
+
+class MyInterface:
+    def get_lol(self) -> str:
+        return "megalol"
+
+
+@scalar_node
+class A:
+    @classmethod
+    async def __compose__(cls):
+        yield int(11)
+
+@scalar_node
+class Bitchnode:
+    @classmethod
+    async def __compose__(cls):
+        raise NodeError("dang")
+
+
+@scalar_node
+class B(Node[int]):
+    @classmethod
+    async def __compose__(cls):
+        yield 5
+
+
+class AorB(SequentialEither):
+    __either__ = (A, B)
+
+
+@scalar_node
+@polymorphic[int]
+class MyInt:
+    @case
+    def from_a(cls, a: A) -> int:
+        return a + 8
+
+    @case
+    def from_b(cls, b: B) -> int:
+        return b
+
+
+@dataclasses.dataclass
+class C(DataNode):
+    x: float
+    y: float
+
+    @classmethod
+    def __compose__(cls, aorb: AorB):
+        print(aorb)
+        print("calculating c")
+        print(aorb.value)
+        return cls(1.2, aorb.value / 2)
+
+
+@scalar_node
+class Lol:
+    @classmethod
+    def __compose__(cls, i: Interface) -> str:
+        return i.get_lol()
+
+
+class MyNode(Node):
+    def __init__(self):
+        self.bro = 3
+
+
+@scalar_node
+class LOL:
+    @classmethod
+    def __compose__(
+        cls,
+        x: Lol,
+        mi: MyInt,
+        opt: kungfu.Option[A],
+        ar: kungfu.Result[Bitchnode, Exception],
+    ) -> str:
+        return x.upper() * mi + "d"
+
+
+@scalar_node
+class Jackpot:
+    @classmethod
+    def __compose__(cls) -> int:
+        return 777
+
+
+class MultiplyBy(NodeConstructor):
+    def __init__(self, multiplier: int = 5) -> None:
+        self.multiplier = multiplier
+
+    def __compose__(self, jackpot: Jackpot) -> int:
+        return 123 * self.multiplier + jackpot
+
+
+@scalar_node
+class Sum:
+    @classmethod
+    def __compose__(cls, a: Scalar[int, MultiplyBy], b: Scalar[int, MultiplyBy[10]]) -> int:
+        return a + b
+
+
+async def main():
+    agent = EventLoopAgent.build({TypeArgs[int, str], LOL, C, Lolik[str, float, str], Lolik[int, str, int], Sum})  # type: ignore
+
+    global_scope = Scope(detail="global")
+    global_scope.push(Value(Interface, MyInterface()))
+
+    async with global_scope.create_child("local") as scope:
+        await agent.run(
+            local_scope=scope,
+            mapped_scopes={A: global_scope},
+        )
+        print(prepare_values(scope.merge()))
+
+    await global_scope.close()
+
+    # Firstly closes C
+    # then A and B (any order because they are from the same layer of parallels)
+
+
+asyncio.run(main())

nodnod-1.0.0/main2.py

@@ -0,0 +1,79 @@
+import asyncio
+import typing
+import kungfu
+
+from nodnod import Node
+from nodnod.agent import EventLoopAgent
+from nodnod.interface.scalar import scalar_node
+from nodnod.node import is_type
+from nodnod.scope import Scope
+
+
+def self_hook(cls: type[Node], dep_name: str, dep_type: type[typing.Any]) -> kungfu.Pulse[str]:
+    if is_type(dep_type, typing.Self):
+        print(cls, dep_name, dep_type)
+        return kungfu.Ok()
+    return kungfu.Error("cannot process")
+
+
+class NodeConstructor(Node, abstract=True):
+    __args__ = ()
+
+    @classmethod
+    def __construct__(cls, *args: typing.Any) -> typing.Self:
+        raise NotImplementedError
+
+    def __class_getitem__(cls, item: typing.Any | tuple[typing.Any, ...], /) -> typing.Any:
+        data = cls.__construct__(*((item,) if not isinstance(item, tuple) else item))
+        node = type(
+            cls.__name__, 
+            (cls,), 
+            dict(
+                __module__=cls.__module__, 
+                __args__=data,
+            )
+        )
+        setattr(node, "__type__", node)
+        return node
+
+
+@scalar_node
+class A(Node):
+    @classmethod
+    def __compose__(cls) -> int:
+        return 123
+
+
+class Lolik(NodeConstructor):
+    def __init__(self, x: type[str | int]) -> None:
+        self.x = x
+
+    @classmethod
+    def __construct__(cls, x: type[str | int] = str) -> typing.Self:
+        return cls(x)
+
+    def __compose__(self, a: A):
+        print(a)
+        return self.x
+
+
+@scalar_node
+class Boba:
+    @classmethod
+    def __compose__(cls, lolik: Lolik[int], lolik2: Lolik[str]) -> int:
+        print("lolik", lolik.x, "lolik2", lolik2.x)
+        return lolik
+
+
+async def main():
+    agent = EventLoopAgent.build({Boba})
+    scope = Scope(detail="test")
+
+    async with scope:
+        await agent.run(scope, {})
+
+
+asyncio.run(main())
+
+
+__all__ = ("NodeConstructor",)

nodnod-1.0.0/main3.py

@@ -0,0 +1,107 @@
+import asyncio
+import dataclasses
+import datetime
+import typing
+
+import kungfu
+
+from nodnod import (
+    EventLoopAgent,
+    Externals,
+    NodeError,
+    Scope,
+    create_agent_from_node,
+    create_node_from_function,
+    inject_externals,
+    scalar_node,
+)
+from nodnod.interface.compose_one import compose_one
+
+
+@dataclasses.dataclass
+class User:
+    id: int
+    email: kungfu.Option[str]
+    last_active: datetime.datetime
+
+
+@scalar_node
+class UserId:
+    @classmethod
+    def __compose__(cls, user: User) -> int:
+        return user.id
+
+
+@scalar_node
+class Email(str):
+    def validate_email(self):
+        if "@" not in self:
+            raise NodeError("Email is in wrong format")
+
+    @classmethod
+    def __compose__(cls, user: User) -> str:
+        email = cls(user.email.expect(NodeError("User has no email")))
+        email.validate_email()
+        return email
+
+
+@dataclasses.dataclass
+class UserSource:
+    user: User
+
+    @classmethod
+    def __compose__(cls, user: User) -> typing.Self:
+        return cls(user)
+
+
+@scalar_node
+class EmailProvider:
+    @classmethod
+    def __compose__(cls, email: Email) -> str:
+        _, provider = email.split("@", 1)
+        if not provider:
+            raise NodeError("Email has no provider")
+        return provider
+
+
+@scalar_node
+class SinceActive:
+    @classmethod
+    def __compose__(cls, user: User) -> datetime.timedelta:
+        return datetime.datetime.now() - user.last_active
+
+
+async def handler(email_provider: EmailProvider, boba: str, lol: str, since_active: SinceActive, user: UserSource):
+    print(email_provider, boba, lol, since_active, user.user)
+    return "handler result"
+
+
+async def main():
+    # Compile time
+    handler_node = create_node_from_function(handler)
+    agent = create_agent_from_node(handler_node, EventLoopAgent)
+
+    user = User(1, kungfu.Some("lol@skibidi.org"), datetime.datetime.now())
+
+    # Run time
+    async with Scope() as scope:
+        scope.inject(User, user)
+        inject_externals(scope, {"boba": "ahah", "lol": "omg"})
+        await agent.run(scope, {})
+
+    print(
+        await compose_one(
+            SinceActive,
+            {User: User(2, kungfu.Nothing(), datetime.datetime.now())},
+        )
+    )
+
+    print(
+        await compose_one(
+            create_node_from_function(handler),
+            {User: user, Externals: {"boba": "tea", "lol": "0"}},
+        )
+    )
+
+
+asyncio.run(main())

nodnod-1.0.0/nodnod/__init__.py

@@ -0,0 +1,31 @@
+from .agent import Agent, EventLoopAgent
+from .error import NodeError
+from .interface import *
+from .node import Injection, Node, Scalar
+from .scope import Scope
+from .value import Value
+
+__all__ = (
+    "Agent",
+    "ConcurrentEither",
+    "DataNode",
+    "Externals",
+    "EventLoopAgent",
+    "Injection",
+    "NodeConstructor",
+    "Node",
+    "NodeError",
+    "Scalar",
+    "ResultNode",
+    "Scope",
+    "SequentialEither",
+    "Value",
+    "create_node_from_function",
+    "compose_one",
+    "inject_externals",
+    "inject_internals",
+    "generic_node",
+    "case",
+    "polymorphic",
+    "scalar_node",
+)

nodnod-1.0.0/nodnod/agent/__init__.py

@@ -0,0 +1,4 @@
+from .base import Agent
+from .event_loop.agent import EventLoopAgent
+
+__all__ = ("Agent", "EventLoopAgent")

nodnod-1.0.0/nodnod/agent/base.py

@@ -0,0 +1,15 @@
+from nodnod.node import Node
+from nodnod.scope import Scope
+import typing
+
+
+class Agent:
+    @classmethod
+    def build(cls, nodes: set[type[Node]]) -> typing.Self:
+        ...
+
+    def run(self, local_scope: Scope, mapped_scopes: dict[type[Node], Scope]) -> typing.Any:
+        ...
+
+
+__all__ = ("Agent",)