koi-net 1.2.0b1__tar.gz → 1.2.0b2__tar.gz

{koi_net-1.2.0b1 → koi_net-1.2.0b2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: koi-net
-Version: 1.2.0b1
+Version: 1.2.0b2
 Summary: Implementation of KOI-net protocol in Python
 Project-URL: Homepage, https://github.com/BlockScience/koi-net/
 Author-email: Luke Miller <luke@block.science>
@@ -36,6 +36,7 @@ Requires-Dist: python-dotenv>=1.1.0
 Requires-Dist: rich>=14.1.0
 Requires-Dist: rid-lib>=3.2.7
 Requires-Dist: ruamel-yaml>=0.18.10
+Requires-Dist: structlog>=25.4.0
 Requires-Dist: uvicorn>=0.34.2
 Provides-Extra: dev
 Requires-Dist: build; extra == 'dev'

{koi_net-1.2.0b1 → koi_net-1.2.0b2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "koi-net"
-version = "1.2.0b1"
+version = "1.2.0b2"
 description = "Implementation of KOI-net protocol in Python"
 authors = [
     {name = "Luke Miller", email = "luke@block.science"}
@@ -23,6 +23,7 @@ dependencies = [
     "fastapi>=0.115.12",
     "uvicorn>=0.34.2",
     "rich>=14.1.0",
+    "structlog>=25.4.0",
 ]
 
 [project.optional-dependencies]

koi_net-1.2.0b2/src/koi_net/__init__.py

@@ -0,0 +1,2 @@
+from . import logger
+from . import sentry

koi_net-1.2.0b2/src/koi_net/assembler.py

@@ -0,0 +1,82 @@
+import inspect
+from typing import Protocol
+from dataclasses import make_dataclass
+
+import structlog
+
+from .interfaces.entrypoint import EntryPoint
+
+log = structlog.stdlib.get_logger()
+
+
+class BuildOrderer(type):
+    def __new__(cls, name: str, bases: tuple, dct: dict[str]):
+        """Sets `cls._build_order` from component order in class definition."""
+        cls = super().__new__(cls, name, bases, dct)
+        
+        if "_build_order" not in dct:
+            components = {}
+            # adds components from base classes (including cls)
+            for base in reversed(inspect.getmro(cls)[:-1]):
+                for k, v in vars(base).items():
+                    # excludes built in and private attributes
+                    if not k.startswith("_"):
+                        components[k] = v
+                        
+            # recipe list constructed from names of non-None components
+            cls._build_order = [
+                name for name, _type in components.items()
+                if _type is not None
+            ]
+            
+        return cls
+
+class NodeContainer(Protocol):
+    entrypoint = EntryPoint
+
+class NodeAssembler(metaclass=BuildOrderer):    
+    def __new__(self) -> NodeContainer:
+        return self._build()
+    
+    @classmethod
+    def _build(cls) -> NodeContainer:
+        components = {}
+        for comp_name in cls._build_order:            
+            comp_factory = getattr(cls, comp_name, None)
+            
+            if comp_factory is None:
+                raise Exception(f"Couldn't find factory for component '{comp_name}'")
+            
+            sig = inspect.signature(comp_factory)
+            
+            required_comps = []
+            for name, param in sig.parameters.items():
+                required_comps.append((name, param.annotation))
+            
+            if len(required_comps) == 0:
+                s = comp_name
+            else:
+                s = f"{comp_name} -> {', '.join([name for name, _type in required_comps])}"
+            
+            print(s.replace("graph", "_graph"), end=";\n")
+            
+            dependencies = {}
+            for req_comp_name, req_comp_type in required_comps:
+                if req_comp_name not in components:
+                    raise Exception(f"Couldn't find required component '{req_comp_name}'")
+                    
+                dependencies[req_comp_name] = components[req_comp_name]
+                
+            components[comp_name] = comp_factory(**dependencies)
+        
+        NodeContainer = make_dataclass(
+            cls_name="NodeContainer",
+            fields=[
+                (name, type(component)) 
+                for name, component
+                in components.items()
+            ],
+            frozen=True
+        )
+        
+        return NodeContainer(**components)

{koi_net-1.2.0b1 → koi_net-1.2.0b2}/src/koi_net/context.py

@@ -1,5 +1,6 @@
 from rid_lib.ext import Cache
 
+from koi_net.effector import Effector
 from koi_net.network.resolver import NetworkResolver
 from .config import NodeConfig
 from .network.graph import NetworkGraph
@@ -9,18 +10,6 @@ from .identity import NodeIdentity
 from .processor.kobj_queue import KobjQueue
 
 
-class ActionContext:
-    """Provides action handlers access to other subsystems."""
-    
-    identity: NodeIdentity
-
-    def __init__(
-        self,
-        identity: NodeIdentity,
-    ):
-        self.identity = identity
-    
-
 class HandlerContext:
     """Provides knowledge handlers access to other subsystems."""
     
@@ -32,6 +21,7 @@ class HandlerContext:
     graph: NetworkGraph
     request_handler: RequestHandler
     resolver: NetworkResolver
+    effector: Effector
     
     def __init__(
         self,
@@ -43,6 +33,7 @@ class HandlerContext:
         graph: NetworkGraph,
         request_handler: RequestHandler,
         resolver: NetworkResolver,
+        effector: Effector
     ):
         self.identity = identity
         self.config = config
@@ -51,4 +42,5 @@ class HandlerContext:
         self.kobj_queue = kobj_queue
         self.graph = graph
         self.request_handler = request_handler
-        self.resolver = resolver
+        self.resolver = resolver
+        self.effector = effector

koi_net-1.2.0b2/src/koi_net/core.py

@@ -0,0 +1,78 @@
+from rid_lib.ext import Cache
+from .assembler import NodeAssembler
+from .config.base import BaseConfig
+from .context import HandlerContext
+from .effector import Effector
+from .handshaker import Handshaker
+from .identity import NodeIdentity
+from .processor.kobj_worker import KnowledgeProcessingWorker
+from .lifecycle import NodeLifecycle
+from .network.error_handler import ErrorHandler
+from .network.event_queue import EventQueue
+from .network.graph import NetworkGraph
+from .network.request_handler import RequestHandler
+from .network.resolver import NetworkResolver
+from .network.response_handler import ResponseHandler
+from .network.poll_event_buffer import PollEventBuffer
+from .poller import NodePoller
+from .processor.handlers import (
+    basic_manifest_handler, 
+    basic_network_output_filter, 
+    basic_rid_handler, 
+    node_contact_handler, 
+    edge_negotiation_handler, 
+    forget_edge_on_node_deletion, 
+    secure_profile_handler
+)
+from .processor.event_worker import EventProcessingWorker
+from .processor.pipeline import KnowledgePipeline
+from .processor.kobj_queue import KobjQueue
+from .secure import Secure
+from .server import NodeServer
+
+
+# factory functions for components with non standard initializiation
+
+def make_config() -> BaseConfig:
+    return BaseConfig.load_from_yaml()
+
+def make_cache(config: BaseConfig) -> Cache:
+    return Cache(directory_path=config.koi_net.cache_directory_path)
+
+
+class BaseNode(NodeAssembler):
+    config = lambda: None
+    kobj_queue = KobjQueue
+    event_queue = EventQueue
+    poll_event_buf = PollEventBuffer
+    knowledge_handlers = lambda: [
+        basic_rid_handler,
+        basic_manifest_handler,
+        secure_profile_handler,
+        edge_negotiation_handler,
+        node_contact_handler,
+        basic_network_output_filter,
+        forget_edge_on_node_deletion
+    ]
+    cache = make_cache
+    identity = NodeIdentity
+    graph = NetworkGraph
+    secure = Secure
+    handshaker = Handshaker
+    error_handler = ErrorHandler
+    request_handler = RequestHandler
+    response_handler = ResponseHandler
+    resolver = NetworkResolver
+    effector = Effector
+    handler_context = HandlerContext
+    pipeline = KnowledgePipeline
+    kobj_worker = KnowledgeProcessingWorker
+    event_worker = EventProcessingWorker
+    lifecycle = NodeLifecycle
+
+
+class FullNode(BaseNode):
+    entrypoint = NodeServer
+
+class PartialNode(BaseNode):
+    entrypoint = NodePoller

{koi_net-1.2.0b1 → koi_net-1.2.0b2}/src/koi_net/effector.py

@@ -1,4 +1,4 @@
-import logging
+import structlog
 from typing import Callable
 from enum import StrEnum
 from rid_lib.ext import Cache, Bundle
@@ -6,11 +6,23 @@ from rid_lib.core import RID, RIDType
 from rid_lib.types import KoiNetNode
 from .network.resolver import NetworkResolver
 from .processor.kobj_queue import KobjQueue
-from .context import ActionContext
+from .identity import NodeIdentity
 
-logger = logging.getLogger(__name__)
+log = structlog.stdlib.get_logger()
 
 
+class ActionContext:
+    """Provides action handlers access to other subsystems."""
+    
+    identity: NodeIdentity
+
+    def __init__(
+        self,
+        identity: NodeIdentity,
+    ):
+        self.identity = identity
+    
+
 class BundleSource(StrEnum):
     CACHE = "CACHE"
     ACTION = "ACTION"
@@ -35,12 +47,12 @@ class Effector:
         cache: Cache,
         resolver: NetworkResolver,
         kobj_queue: KobjQueue,
-        action_context: ActionContext
+        identity: NodeIdentity
     ):
         self.cache = cache
         self.resolver = resolver
         self.kobj_queue = kobj_queue
-        self.action_context = action_context
+        self.action_context = ActionContext(identity)
         self._action_table = self.__class__._action_table.copy()
     
     @classmethod
@@ -70,18 +82,18 @@ class Effector:
         bundle = self.cache.read(rid)
         
         if bundle:
-            logger.debug("Cache hit")
+            log.debug("Cache hit")
             return bundle, BundleSource.CACHE
         else:
-            logger.debug("Cache miss")
+            log.debug("Cache miss")
             return None
                     
     def _try_action(self, rid: RID) -> tuple[Bundle, BundleSource] | None:
         if type(rid) not in self._action_table:
-            logger.debug("No action available")
+            log.debug("No action available")
             return None
         
-        logger.debug("Action available")
+        log.debug("Action available")
         func = self._action_table[type(rid)]
         bundle = func(
             ctx=self.action_context, 
@@ -89,10 +101,10 @@ class Effector:
         )
         
         if bundle:
-            logger.debug("Action hit")
+            log.debug("Action hit")
             return bundle, BundleSource.ACTION
         else:
-            logger.debug("Action miss")
+            log.debug("Action miss")
             return None
 
         
@@ -100,10 +112,10 @@ class Effector:
         bundle, source = self.resolver.fetch_remote_bundle(rid)
         
         if bundle:
-            logger.debug("Network hit")
+            log.debug("Network hit")
             return bundle, source
         else:
-            logger.debug("Network miss")
+            log.debug("Network miss")
             return None
         
     
@@ -127,7 +139,7 @@ class Effector:
             handle_result: handles resulting bundle with knowledge pipeline when `True`
         """
         
-        logger.debug(f"Dereferencing {rid!r}")
+        log.debug(f"Dereferencing {rid!r}")
         
         bundle, source = (
             # if `refresh_cache`, skip try cache

{koi_net-1.2.0b1 → koi_net-1.2.0b2}/src/koi_net/handshaker.py

@@ -1,11 +1,11 @@
-from logging import getLogger
+import structlog
 from rid_lib.ext import Cache
 from rid_lib.types import KoiNetNode
 from koi_net.identity import NodeIdentity
 from koi_net.network.event_queue import EventQueue
 from .protocol.event import Event, EventType
 
-logger = getLogger(__name__)
+log = structlog.stdlib.get_logger()
 
 
 class Handshaker:
@@ -24,7 +24,7 @@ class Handshaker:
         Pushes successive `FORGET` and `NEW` events to target node to
         reset the target's cache in case it already knew this node. 
         """
-        logger.debug(f"Initiating handshake with {target}")
+        log.debug(f"Initiating handshake with {target}")
         self.event_queue.push_event_to(
             Event.from_rid(
                 event_type=EventType.FORGET, 

{koi_net-1.2.0b1 → koi_net-1.2.0b2}/src/koi_net/identity.py

@@ -1,10 +1,9 @@
-import logging
+import structlog
 from rid_lib.types.koi_net_node import KoiNetNode
 from .config import NodeConfig
 from .protocol.node import NodeProfile
 
-
-logger = logging.getLogger(__name__)
+log = structlog.stdlib.get_logger()
 
     
 class NodeIdentity:

koi_net-1.2.0b2/src/koi_net/interfaces/entrypoint.py

@@ -0,0 +1,5 @@
+from typing import Protocol
+
+
+class EntryPoint(Protocol):
+    def run(self): ...

{koi_net-1.2.0b1/src/koi_net → koi_net-1.2.0b2/src/koi_net/interfaces}/worker.py

@@ -1,5 +1,12 @@
 import threading
 
+
+class End:
+    """Class for a sentinel value by knowledge handlers."""
+    pass
+
+STOP_WORKER = End()
+
 class ThreadWorker:
     thread: threading.Thread
     

{koi_net-1.2.0b1 → koi_net-1.2.0b2}/src/koi_net/lifecycle.py

@@ -1,22 +1,22 @@
-import logging
+import structlog
 from contextlib import contextmanager, asynccontextmanager
 
 from rid_lib.ext import Bundle, Cache
 from rid_lib.types import KoiNetNode
 
-from koi_net.behaviors import Behaviors
-from koi_net.handshaker import Handshaker
-from koi_net.kobj_worker import KnowledgeProcessingWorker
-from koi_net.models import END
-from koi_net.network.event_queue import EventQueue
-from koi_net.processor.event_worker import EventProcessingWorker
-
+from .handshaker import Handshaker
+from .network.request_handler import RequestHandler
+from .processor.kobj_worker import KnowledgeProcessingWorker
+from .network.event_queue import EventQueue
+from .processor.event_worker import EventProcessingWorker
+from .protocol.api_models import ErrorResponse
+from .interfaces.worker import STOP_WORKER
 from .config import NodeConfig
 from .processor.kobj_queue import KobjQueue
 from .network.graph import NetworkGraph
 from .identity import NodeIdentity
 
-logger = logging.getLogger(__name__)
+log = structlog.stdlib.get_logger()
 
 
 class NodeLifecycle:
@@ -31,7 +31,7 @@ class NodeLifecycle:
     event_worker: EventProcessingWorker
     cache: Cache
     handshaker: Handshaker
-    behaviors: Behaviors
+    request_handler: RequestHandler
     
     def __init__(
         self,
@@ -44,7 +44,7 @@ class NodeLifecycle:
         event_worker: EventProcessingWorker,
         cache: Cache,
         handshaker: Handshaker,
-        behaviors: Behaviors
+        request_handler: RequestHandler
     ):
         self.config = config
         self.identity = identity
@@ -55,32 +55,32 @@ class NodeLifecycle:
         self.event_worker = event_worker
         self.cache = cache
         self.handshaker = handshaker
-        self.behaviors = behaviors
+        self.request_handler = request_handler
         
     @contextmanager
     def run(self):
         """Synchronous context manager for node startup and shutdown."""
         try:
-            logger.info("Starting node lifecycle...")
+            log.info("Starting node lifecycle...")
             self.start()
             yield
         except KeyboardInterrupt:
-            logger.info("Keyboard interrupt!")
+            log.info("Keyboard interrupt!")
         finally:
-            logger.info("Stopping node lifecycle...")
+            log.info("Stopping node lifecycle...")
             self.stop()
 
     @asynccontextmanager
     async def async_run(self):
         """Asynchronous context manager for node startup and shutdown."""
         try:
-            logger.info("Starting async node lifecycle...")
+            log.info("Starting async node lifecycle...")
             self.start()
             yield
         except KeyboardInterrupt:
-            logger.info("Keyboard interrupt!")
+            log.info("Keyboard interrupt!")
         finally:
-            logger.info("Stopping async node lifecycle...")
+            log.info("Stopping async node lifecycle...")
             self.stop()
     
     def start(self):
@@ -91,7 +91,7 @@ class NodeLifecycle:
         of node bundle. Initiates handshake with first contact if node 
         doesn't have any neighbors. Catches up with coordinator state.
         """
-        logger.info("Starting processor worker thread")
+        log.info("Starting processor worker thread")
         
         self.kobj_worker.thread.start()
         self.event_worker.thread.start()
@@ -104,30 +104,38 @@ class NodeLifecycle:
             contents=self.identity.profile.model_dump()
         ))
         
-        logger.debug("Waiting for kobj queue to empty")
+        log.debug("Waiting for kobj queue to empty")
         self.kobj_queue.q.join()
         
-        # TODO: FACTOR OUT BEHAVIOR
-        
         coordinators = self.graph.get_neighbors(direction="in", allowed_type=KoiNetNode)
         
-        if len(coordinators) == 0 and self.config.koi_net.first_contact.rid:
-            logger.debug(f"I don't have any edges with coordinators, reaching out to first contact {self.config.koi_net.first_contact.rid!r}")
+        if len(coordinators) > 0:
+            for coordinator in coordinators:
+                payload = self.request_handler.fetch_manifests(
+                    node=coordinator,
+                    rid_types=[KoiNetNode]
+                )
+                if type(payload) is ErrorResponse:
+                    continue
+                
+                for manifest in payload.manifests:
+                    self.kobj_queue.put_kobj(
+                        manifest=manifest,
+                        source=coordinator
+                    )
+                    
+        elif self.config.koi_net.first_contact.rid:
+            log.debug(f"I don't have any edges with coordinators, reaching out to first contact {self.config.koi_net.first_contact.rid!r}")
             
             self.handshaker.handshake_with(self.config.koi_net.first_contact.rid)
         
-        
-        
-        for coordinator in self.behaviors.identify_coordinators():
-            self.behaviors.catch_up_with(coordinator, rid_types=[KoiNetNode])
-        
 
     def stop(self):
         """Stops a node.
         
         Finishes processing knowledge object queue.
         """        
-        logger.info(f"Waiting for kobj queue to empty ({self.kobj_queue.q.unfinished_tasks} tasks remaining)")
+        log.info(f"Waiting for kobj queue to empty ({self.kobj_queue.q.unfinished_tasks} tasks remaining)")
         
-        self.kobj_queue.q.put(END)
-        self.event_queue.q.put(END)
+        self.kobj_queue.q.put(STOP_WORKER)
+        self.event_queue.q.put(STOP_WORKER)