Merge pull request #28 from BlockScience/dev

v1.3.0

Author: lukvmil

examples/coordinator.py

@@ -1,27 +1,30 @@
+from dataclasses import dataclass
+
 from rid_lib.types import KoiNetNode, KoiNetEdge
-import structlog
-from koi_net.config.full_node import (
+from koi_net.core import FullNode
+from koi_net.config import (
     FullNodeConfig, 
     ServerConfig, 
     KoiNetConfig, 
-    NodeProfile, 
+    FullNodeProfile, 
     NodeProvides
 )
-from koi_net.core import FullNode
-from koi_net.processor.context import HandlerContext
-from koi_net.processor.handler import HandlerType, KnowledgeHandler
-from koi_net.processor.knowledge_object import KnowledgeObject
-from koi_net.protocol.event import Event, EventType
-from koi_net.protocol.edge import EdgeType, generate_edge_bundle
-
-log = structlog.stdlib.get_logger()
 
+from koi_net.components.interfaces import HandlerType, KnowledgeHandler
+from koi_net.components import NodeIdentity, Cache, EventQueue, KobjQueue
+from koi_net.protocol import (
+    KnowledgeObject, 
+    Event, 
+    EventType, 
+    EdgeType, 
+    generate_edge_bundle
+)
 
 class CoordinatorConfig(FullNodeConfig):
     server: ServerConfig = ServerConfig(port=8080)
     koi_net: KoiNetConfig = KoiNetConfig(
         node_name="coordinator",
-        node_profile=NodeProfile(
+        node_profile=FullNodeProfile(
             provides=NodeProvides(
                 event=[KoiNetNode, KoiNetEdge],
                 state=[KoiNetNode, KoiNetEdge]
@@ -30,39 +33,48 @@ class CoordinatorConfig(FullNodeConfig):
         rid_types_of_interest=[KoiNetNode, KoiNetEdge]
     )
 
-@KnowledgeHandler.create(
-    HandlerType.Network, 
-    rid_types=[KoiNetNode])
-def handshake_handler(ctx: HandlerContext, kobj: KnowledgeObject):
-    log.info("Handling node handshake")
-
-    # only respond if node declares itself as NEW
-    if kobj.event_type != EventType.NEW:
-        return
-        
-    log.info("Sharing this node's bundle with peer")
-    identity_bundle = ctx.cache.read(ctx.identity.rid)
-    ctx.event_queue.push(
-        event=Event.from_bundle(EventType.NEW, identity_bundle),
-        target=kobj.rid
-    )
+@dataclass
+class HandshakeHandler(KnowledgeHandler):
+    identity: NodeIdentity
+    cache: Cache
+    event_queue: EventQueue
+    kobj_queue: KobjQueue
 
-    log.info("Proposing new edge")    
-    # defer handling of proposed edge
+    handler_type = HandlerType.Network
+    rid_types = (KoiNetNode,)
 
-    edge_bundle = generate_edge_bundle(
-        source=kobj.rid,
-        target=ctx.identity.rid,
-        edge_type=EdgeType.WEBHOOK,
-        rid_types=[KoiNetNode, KoiNetEdge]
-    )
+    def handle(self, kobj: KnowledgeObject):
+        # only respond if node declares itself as NEW
+        if not (kobj.event_type == EventType.NEW and kobj.source == kobj.rid):
+            return
+        
+        self.log.info("Handling node handshake")
+            
+        self.log.info("Sharing this node's bundle with peer")
+        identity_bundle = self.cache.read(self.identity.rid)
+        self.event_queue.push(
+            event=Event.from_bundle(
+                event_type=EventType.NEW, 
+                bundle=identity_bundle),
+            target=kobj.rid
+        )
+        
+        self.log.info("Proposing new edge")
+        # defer handling of proposed edge
 
-    ctx.kobj_queue.push(rid=edge_bundle.rid, event_type=EventType.FORGET)
-    ctx.kobj_queue.push(bundle=edge_bundle)
+        edge_bundle = generate_edge_bundle(
+            source=kobj.rid,
+            target=self.identity.rid,
+            edge_type=EdgeType.WEBHOOK,
+            rid_types=[KoiNetNode, KoiNetEdge]
+        )
+            
+        self.kobj_queue.push(rid=edge_bundle.rid, event_type=EventType.FORGET)
+        self.kobj_queue.push(bundle=edge_bundle)
 
 class CoordinatorNode(FullNode):
     config_schema = CoordinatorConfig
-    knowledge_handlers = FullNode.knowledge_handlers + [handshake_handler]
+    handshake_handler = HandshakeHandler
 
 if __name__ == "__main__":
     CoordinatorNode().run()

examples/partial.py

@@ -1,11 +1,11 @@
-from koi_net.config.partial_node import PartialNodeConfig, KoiNetConfig, NodeProfile
+from koi_net.config import PartialNodeConfig, KoiNetConfig, PartialNodeProfile
 from koi_net.core import PartialNode
 
 
 class MyPartialNodeConfig(PartialNodeConfig):
     koi_net: KoiNetConfig = KoiNetConfig(
         node_name="partial",
-        node_profile=NodeProfile()
+        node_profile=PartialNodeProfile()
     )
 
 class MyPartialNode(PartialNode):

koi-net.config.json

@@ -22,6 +22,14 @@
                 "suffix": "]"
             },
             " ",
+            {
+                "field": "thread",
+                "auto-width": true,
+                "default-value": "",
+                "prefix": "(",
+                "suffix": ")"
+            },
+            " ",
             {
                 "field": "module",
                 "min-width": 15,
@@ -43,6 +51,9 @@
             },
             "module": {
                 "kind": "string"
+            },
+            "thread": {
+                "kind": "string"
             }
         },
         "highlights": {

pyproject.toml

@@ -1,10 +1,6 @@
-[build-system]
-requires = ["hatchling"]
-build-backend = "hatchling.build"
-
 [project]
 name = "koi-net"
-version = "1.2.5"
+version = "1.3.0"
 description = "Implementation of KOI-net protocol in Python"
 authors = [
     {name = "Luke Miller", email = "luke@block.science"}
@@ -18,21 +14,26 @@ dependencies = [
     "httpx>=0.28.1",
     "pydantic>=2.10.6",
     "ruamel.yaml>=0.18.10",
-    "python-dotenv>=1.1.0",
     "cryptography>=45.0.3",
     "fastapi>=0.115.12",
     "uvicorn>=0.34.2",
+    "rich>=14.1.0",
     "structlog>=25.4.0",
+    "pydantic-settings>=2.12.0",
+    "jsonpointer>=3.0.0",
+    "colorama>=0.4.6",
 ]
 
 [project.optional-dependencies]
-dev = ["twine>=6.0", "build"]
 docs = [
     "sphinx",
     "sphinx-autoapi>=3.6.0",
     "sphinx-autodoc-typehints>=3.0.1",
     "sphinx-rtd-theme>=3.0.2",
 ]
 
+[project.scripts]
+koi-sh = "koi_net.interfaces.shell:run"
+
 [project.urls]
 Homepage = "https://github.com/BlockScience/koi-net/"

src/koi_net/__init__.py

@@ -1 +0,0 @@
-from . import log_system

src/koi_net/base.py

@@ -0,0 +1,25 @@
+import threading
+from logging import Logger
+from pathlib import Path
+from queue import Queue
+
+import structlog
+from structlog.contextvars import bound_contextvars
+
+from .infra import Assembler
+from .components import LoggingContext
+
+
+class BaseAssembly(Assembler):
+    root_dir: Path
+    
+    shutdown_signal: threading.Event = threading.Event
+    exception_queue: Queue[Exception] = lambda: Queue()
+
+    log: Logger = lambda root_dir: structlog.stdlib.get_logger().bind(log_dir=root_dir)
+    logging_context: LoggingContext = LoggingContext
+    
+    def __new__(cls, *args, root_dir: Path, **kwargs):
+        cls.root_dir = root_dir
+        with bound_contextvars(log_dir=root_dir):
+            return super().__new__(cls, *args, **kwargs)