koi-net 1.0.0b19__tar.gz → 1.1.0__tar.gz

{koi_net-1.0.0b19 → koi_net-1.1.0}/.gitignore

@@ -1,6 +1,8 @@
 rid-lib
 __pycache__
 *.json
+*.pem
+*.yaml
 venv
 .env
 prototypes

{koi_net-1.0.0b19 → koi_net-1.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: koi-net
-Version: 1.0.0b19
+Version: 1.1.0
 Summary: Implementation of KOI-net protocol in Python
 Project-URL: Homepage, https://github.com/BlockScience/koi-net/
 Author-email: Luke Miller <luke@block.science>
@@ -27,19 +27,20 @@ License: MIT License
         SOFTWARE.
 License-File: LICENSE
 Requires-Python: >=3.10
+Requires-Dist: cryptography>=45.0.3
+Requires-Dist: fastapi>=0.115.12
 Requires-Dist: httpx>=0.28.1
 Requires-Dist: networkx>=3.4.2
 Requires-Dist: pydantic>=2.10.6
 Requires-Dist: python-dotenv>=1.1.0
-Requires-Dist: rid-lib>=3.2.3
+Requires-Dist: rid-lib>=3.2.7
 Requires-Dist: ruamel-yaml>=0.18.10
+Requires-Dist: uvicorn>=0.34.2
 Provides-Extra: dev
 Requires-Dist: build; extra == 'dev'
 Requires-Dist: twine>=6.0; extra == 'dev'
 Provides-Extra: examples
-Requires-Dist: fastapi; extra == 'examples'
 Requires-Dist: rich; extra == 'examples'
-Requires-Dist: uvicorn; extra == 'examples'
 Description-Content-Type: text/markdown
 
 # KOI-net

koi_net-1.1.0/examples/coordinator.py

@@ -0,0 +1,76 @@
+import logging
+from rich.logging import RichHandler
+from pydantic import Field
+from rid_lib.types import KoiNetNode, KoiNetEdge
+from koi_net.config import NodeConfig, KoiNetConfig
+from koi_net.protocol.node import NodeProfile, NodeProvides, NodeType
+from koi_net import NodeInterface
+from koi_net.context import HandlerContext
+from koi_net.processor.handler import HandlerType
+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
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+    datefmt="%Y-%m-%d %H:%M:%S",
+    handlers=[RichHandler()]
+)
+
+logging.getLogger("koi_net").setLevel(logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+class CoordinatorConfig(NodeConfig):
+    koi_net: KoiNetConfig = Field(default_factory = lambda:
+        KoiNetConfig(
+            node_name="coordinator",
+            node_profile=NodeProfile(
+                node_type=NodeType.FULL,
+                provides=NodeProvides(
+                    event=[KoiNetNode, KoiNetEdge],
+                    state=[KoiNetNode, KoiNetEdge]
+                )
+            ),
+            cache_directory_path=".coordinator_rid_cache",
+            event_queues_path="coordinator_event_queues.json",
+            private_key_pem_path="coordinator_priv_key.pem"
+        )
+    )
+    
+node = NodeInterface(
+    config=CoordinatorConfig.load_from_yaml("coordinator_config.yaml"),
+    use_kobj_processor_thread=True
+)
+
+@node.processor.pipeline.register_handler(HandlerType.Network, rid_types=[KoiNetNode])
+def handshake_handler(ctx: HandlerContext, kobj: KnowledgeObject):
+    logger.info("Handling node handshake")
+
+    # only respond if node declares itself as NEW
+    if kobj.event_type != EventType.NEW:
+        return
+        
+    logger.info("Sharing this node's bundle with peer")
+    identity_bundle = ctx.effector.deref(ctx.identity.rid)
+    ctx.event_queue.push_event_to(
+        event=Event.from_bundle(EventType.NEW, identity_bundle),
+        node=kobj.rid,
+        flush=True
+    )
+    
+    logger.info("Proposing new edge")    
+    # defer handling of proposed edge
+    
+    edge_bundle = generate_edge_bundle(
+        source=kobj.rid,
+        target=ctx.identity.rid,
+        edge_type=EdgeType.WEBHOOK,
+        rid_types=[KoiNetNode, KoiNetEdge]
+    )
+        
+    ctx.handle(rid=edge_bundle.rid, event_type=EventType.FORGET)
+    ctx.handle(bundle=edge_bundle)
+    
+if __name__ == "__main__":
+    node.server.run()

koi_net-1.1.0/examples/partial.py

@@ -0,0 +1,37 @@
+import logging
+from pydantic import Field
+from rich.logging import RichHandler
+from koi_net import NodeInterface
+from koi_net.protocol.node import NodeProfile, NodeType
+from koi_net.config import NodeConfig, KoiNetConfig
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+    datefmt="%Y-%m-%d %H:%M:%S",
+    handlers=[RichHandler()]
+)
+
+logging.getLogger("koi_net").setLevel(logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+
+class PartialNodeConfig(NodeConfig):
+    koi_net: KoiNetConfig = Field(default_factory = lambda:
+        KoiNetConfig(
+            node_name="partial",
+            node_profile=NodeProfile(
+                node_type=NodeType.PARTIAL
+            ),
+            cache_directory_path=".partial_rid_cache",
+            event_queues_path="partial_event_queues.json",
+            private_key_pem_path="partial_priv_key.pem"
+        )
+    )
+
+node = NodeInterface(
+    config=PartialNodeConfig.load_from_yaml("partial_config.yaml")
+)
+
+if __name__ == "__main__":
+    node.poller.run()

{koi_net-1.0.0b19 → koi_net-1.1.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "koi-net"
-version = "1.0.0-beta.19"
+version = "1.1.0"
 description = "Implementation of KOI-net protocol in Python"
 authors = [
     {name = "Luke Miller", email = "luke@block.science"}
@@ -13,20 +13,21 @@ readme = "README.md"
 requires-python = ">=3.10"
 license = {file = "LICENSE"}
 dependencies = [
-    "rid-lib>=3.2.3",
+    "rid-lib>=3.2.7",
     "networkx>=3.4.2",
     "httpx>=0.28.1",
     "pydantic>=2.10.6",
     "ruamel.yaml>=0.18.10",
-    "python-dotenv>=1.1.0"
+    "python-dotenv>=1.1.0",
+    "cryptography>=45.0.3",
+    "fastapi>=0.115.12",
+    "uvicorn>=0.34.2"
 ]
 
 [project.optional-dependencies]
 dev = ["twine>=6.0", "build"]
 examples = [
     "rich",
-    "fastapi",
-    "uvicorn"
 ]
 
 [project.urls]

koi_net-1.1.0/src/koi_net/actor.py

@@ -0,0 +1,60 @@
+from logging import getLogger
+from rid_lib.types import KoiNetNode
+from rid_lib import RIDType
+from koi_net.context import HandlerContext
+from koi_net.protocol.api_models import ErrorResponse
+from .protocol.event import Event, EventType
+
+
+logger = getLogger(__name__)
+
+
+class Actor:
+    ctx: HandlerContext
+    
+    def __init__(self):
+        pass
+    
+    def set_ctx(self, ctx: HandlerContext):
+        self.ctx = ctx
+    
+    def handshake_with(self, target: KoiNetNode):
+        logger.debug(f"Initiating handshake with {target}")
+        self.ctx.event_queue.push_event_to(
+            Event.from_rid(
+                event_type=EventType.FORGET, 
+                rid=self.ctx.identity.rid),
+            node=target
+        )
+            
+        self.ctx.event_queue.push_event_to(
+            event=Event.from_bundle(
+                event_type=EventType.NEW, 
+                bundle=self.ctx.effector.deref(self.ctx.identity.rid)),
+            node=target
+        )
+        
+        self.ctx.event_queue.flush_webhook_queue(target)
+        
+    def identify_coordinators(self):
+        return self.ctx.resolver.get_state_providers(KoiNetNode)
+        
+    def catch_up_with(self, target: KoiNetNode, rid_types: list[RIDType] = []):
+        logger.debug(f"catching up with {target} on {rid_types or 'all types'}")
+        
+        payload = self.ctx.request_handler.fetch_manifests(
+            node=target,
+            rid_types=rid_types
+        )
+        if type(payload) == ErrorResponse:
+            logger.debug("failed to reach node")
+            return
+        
+        for manifest in payload.manifests:
+            if manifest.rid == self.ctx.identity.rid:
+                continue
+            
+            self.ctx.handle(
+                manifest=manifest,
+                source=target
+            )

{koi_net-1.0.0b19 → koi_net-1.1.0}/src/koi_net/config.py

@@ -1,32 +1,43 @@
 import os
-from typing import TypeVar
 from ruamel.yaml import YAML
-from koi_net.protocol.node import NodeProfile
-from rid_lib.types import KoiNetNode
 from pydantic import BaseModel, Field, PrivateAttr
 from dotenv import load_dotenv
+from rid_lib.ext.utils import sha256_hash
+from rid_lib.types import KoiNetNode
+from .protocol.secure import PrivateKey
+from .protocol.node import NodeProfile, NodeType
 
 
 class ServerConfig(BaseModel):
-    host: str | None = "127.0.0.1"
-    port: int | None = 8000
+    host: str = "127.0.0.1"
+    port: int = 8000
     path: str | None = "/koi-net"
     
     @property
     def url(self) -> str:
         return f"http://{self.host}:{self.port}{self.path or ''}"
 
+class NodeContact(BaseModel):
+    rid: KoiNetNode | None = None
+    url: str | None = None
+
 class KoiNetConfig(BaseModel):
     node_name: str
     node_rid: KoiNetNode | None = None
     node_profile: NodeProfile
     
-    cache_directory_path: str | None = ".rid_cache"
-    event_queues_path: str | None = "event_queues.json"
-
-    first_contact: str | None = None
+    cache_directory_path: str = ".rid_cache"
+    event_queues_path: str = "event_queues.json"
+    private_key_pem_path: str = "priv_key.pem"
+    polling_interval: int = 5
+    
+    first_contact: NodeContact = Field(default_factory=NodeContact)
+    
+    _priv_key: PrivateKey | None = PrivateAttr(default=None)
 
 class EnvConfig(BaseModel):
+    priv_key_password: str | None = "PRIV_KEY_PASSWORD"
+    
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
         load_dotenv()
@@ -41,8 +52,10 @@ class EnvConfig(BaseModel):
         return value
 
 class NodeConfig(BaseModel):
-    server: ServerConfig | None = Field(default_factory=ServerConfig)
+    server: ServerConfig = Field(default_factory=ServerConfig)
     koi_net: KoiNetConfig
+    env: EnvConfig = Field(default_factory=EnvConfig)
+    
     _file_path: str = PrivateAttr(default="config.yaml")
     _file_content: str | None = PrivateAttr(default=None)
     
@@ -72,13 +85,27 @@ class NodeConfig(BaseModel):
             
         config._file_path = file_path
         
-        if generate_missing:            
-            config.koi_net.node_rid = (
-                config.koi_net.node_rid or KoiNetNode.generate(config.koi_net.node_name)
-            )   
-            config.koi_net.node_profile.base_url = (
-                config.koi_net.node_profile.base_url or config.server.url
-            )
+        if generate_missing:
+            if not config.koi_net.node_rid:
+                priv_key = PrivateKey.generate()
+                pub_key = priv_key.public_key()
+                
+                config.koi_net.node_rid = KoiNetNode(
+                    config.koi_net.node_name,
+                    sha256_hash(pub_key.to_der())
+                )
+                
+                with open(config.koi_net.private_key_pem_path, "w") as f:
+                    f.write(
+                        priv_key.to_pem(config.env.priv_key_password)
+                    )
+                
+                config.koi_net.node_profile.public_key = pub_key.to_der()
+            
+            if config.koi_net.node_profile.node_type == NodeType.FULL:
+                config.koi_net.node_profile.base_url = (
+                    config.koi_net.node_profile.base_url or config.server.url
+                )
                 
             config.save_to_yaml()
                     
@@ -98,4 +125,3 @@ class NodeConfig(BaseModel):
                     f.write(self._file_content)
                 raise e
                 
-ConfigType = TypeVar("ConfigType", bound=NodeConfig)

koi_net-1.1.0/src/koi_net/context.py

@@ -0,0 +1,63 @@
+from rid_lib.ext import Cache
+
+from koi_net.network.resolver import NetworkResolver
+from .config import NodeConfig
+from .effector import Effector
+from .network.graph import NetworkGraph
+from .network.event_queue import NetworkEventQueue
+from .network.request_handler import RequestHandler
+from .identity import NodeIdentity
+from .processor.interface import ProcessorInterface
+
+
+class ActionContext:
+    identity: NodeIdentity
+    effector: Effector
+
+    def __init__(
+        self,
+        identity: NodeIdentity,
+        effector: Effector
+    ):
+        self.identity = identity
+        self.effector = effector
+    
+
+class HandlerContext:
+    identity: NodeIdentity
+    config: NodeConfig
+    cache: Cache
+    event_queue: NetworkEventQueue
+    graph: NetworkGraph
+    request_handler: RequestHandler
+    resolver: NetworkResolver
+    effector: Effector
+    _processor: ProcessorInterface | None
+    
+    def __init__(
+        self,
+        identity: NodeIdentity,
+        config: NodeConfig,
+        cache: Cache,
+        event_queue: NetworkEventQueue,
+        graph: NetworkGraph,
+        request_handler: RequestHandler,
+        resolver: NetworkResolver,
+        effector: Effector
+    ):
+        self.identity = identity
+        self.config = config
+        self.cache = cache
+        self.event_queue = event_queue
+        self.graph = graph
+        self.request_handler = request_handler
+        self.resolver = resolver
+        self.effector = effector
+        self._processor = None
+        
+    def set_processor(self, processor: ProcessorInterface):
+        self._processor = processor
+        
+    @property
+    def handle(self):
+        return self._processor.handle

koi_net-1.1.0/src/koi_net/core.py

@@ -0,0 +1,194 @@
+import logging
+from typing import Generic, TypeVar
+from rid_lib.ext import Cache
+from .network.resolver import NetworkResolver
+from .network.event_queue import NetworkEventQueue
+from .network.graph import NetworkGraph
+from .network.request_handler import RequestHandler
+from .network.response_handler import ResponseHandler
+from .network.error_handler import ErrorHandler
+from .actor import Actor
+from .processor.interface import ProcessorInterface
+from .processor import default_handlers
+from .processor.handler import KnowledgeHandler
+from .processor.knowledge_pipeline import KnowledgePipeline
+from .identity import NodeIdentity
+from .secure import Secure
+from .config import NodeConfig
+from .context import HandlerContext, ActionContext
+from .effector import Effector
+from .server import NodeServer
+from .lifecycle import NodeLifecycle
+from .poller import NodePoller
+from . import default_actions
+
+logger = logging.getLogger(__name__)
+
+
+T = TypeVar("T", bound=NodeConfig)
+
+class NodeInterface(Generic[T]):
+    config: T
+    cache: Cache
+    identity: NodeIdentity
+    resolver: NetworkResolver
+    event_queue: NetworkEventQueue
+    graph: NetworkGraph
+    processor: ProcessorInterface
+    secure: Secure
+    server: NodeServer
+    
+    use_kobj_processor_thread: bool
+    
+    def __init__(
+        self,
+        config: T,
+        use_kobj_processor_thread: bool = False,
+        handlers: list[KnowledgeHandler] | None = None,
+        
+        CacheOverride: type[Cache] | None = None,
+        NodeIdentityOverride: type[NodeIdentity] | None = None,
+        EffectorOverride: type[Effector] | None = None,
+        NetworkGraphOverride: type[NetworkGraph] | None = None,
+        SecureOverride: type[Secure] | None = None,
+        RequestHandlerOverride: type[RequestHandler] | None = None,
+        ResponseHandlerOverride: type[ResponseHandler] | None = None,
+        NetworkResolverOverride: type[NetworkResolver] | None = None,
+        NetworkEventQueueOverride: type[NetworkEventQueue] | None = None,
+        ActorOverride: type[Actor] | None = None,
+        ActionContextOverride: type[ActionContext] | None = None,
+        HandlerContextOverride: type[HandlerContext] | None = None,
+        KnowledgePipelineOverride: type[KnowledgePipeline] | None = None,
+        ProcessorInterfaceOverride: type[ProcessorInterface] | None = None,
+        ErrorHandlerOverride: type[ErrorHandler] | None = None,
+        NodeLifecycleOverride: type[NodeLifecycle] | None = None,
+        NodeServerOverride: type[NodeServer] | None = None,
+        NodePollerOverride: type[NodePoller] | None = None,        
+    ):
+        self.config = config
+        self.cache = (CacheOverride or Cache)(
+            directory_path=self.config.koi_net.cache_directory_path
+        )
+
+        self.identity = (NodeIdentityOverride or NodeIdentity)(config=self.config)
+        self.effector = (EffectorOverride or Effector)(cache=self.cache)
+
+        self.graph = (NetworkGraphOverride or NetworkGraph)(
+            cache=self.cache,
+            identity=self.identity
+        )
+
+        self.secure = (SecureOverride or Secure)(
+            identity=self.identity,
+            effector=self.effector,
+            config=self.config
+        )
+
+        self.request_handler = (RequestHandlerOverride or RequestHandler)(
+            effector=self.effector,
+            identity=self.identity,
+            secure=self.secure
+        )
+
+        self.response_handler = (ResponseHandlerOverride or ResponseHandler)(self.cache, self.effector)
+
+        self.resolver = (NetworkResolverOverride or NetworkResolver)(
+            config=self.config,
+            cache=self.cache,
+            identity=self.identity,
+            graph=self.graph,
+            request_handler=self.request_handler,
+            effector=self.effector
+        )
+
+        self.event_queue = (NetworkEventQueueOverride or NetworkEventQueue)(
+            config=self.config,
+            cache=self.cache,
+            identity=self.identity,
+            graph=self.graph,
+            request_handler=self.request_handler,
+            effector=self.effector
+        )
+        
+        self.actor = (ActorOverride or Actor)()
+        
+        # pull all handlers defined in default_handlers module
+        if handlers is None:
+            handlers = [
+                obj for obj in vars(default_handlers).values() 
+                if isinstance(obj, KnowledgeHandler)
+            ]
+
+        self.use_kobj_processor_thread = use_kobj_processor_thread
+        
+        self.action_context = (ActionContextOverride or ActionContext)(
+            identity=self.identity,
+            effector=self.effector
+        )
+        
+        self.handler_context = (HandlerContextOverride or HandlerContext)(
+            identity=self.identity,
+            config=self.config,
+            cache=self.cache,
+            event_queue=self.event_queue,
+            graph=self.graph,
+            request_handler=self.request_handler,
+            resolver=self.resolver,
+            effector=self.effector
+        )
+        
+        self.pipeline = (KnowledgePipelineOverride or KnowledgePipeline)(
+            handler_context=self.handler_context,
+            cache=self.cache,
+            request_handler=self.request_handler,
+            event_queue=self.event_queue,
+            graph=self.graph,
+            default_handlers=handlers
+        )
+        
+        self.processor = (ProcessorInterfaceOverride or ProcessorInterface)(
+            pipeline=self.pipeline,
+            use_kobj_processor_thread=self.use_kobj_processor_thread
+        )
+        
+        self.error_handler = (ErrorHandlerOverride or ErrorHandler)(
+            processor=self.processor,
+            actor=self.actor
+        )
+        
+        self.request_handler.set_error_handler(self.error_handler)
+        
+        self.handler_context.set_processor(self.processor)
+        
+        self.effector.set_processor(self.processor)
+        self.effector.set_resolver(self.resolver)
+        self.effector.set_action_context(self.action_context)
+        
+        self.actor.set_ctx(self.handler_context)
+        
+        self.lifecycle = (NodeLifecycleOverride or NodeLifecycle)(
+            config=self.config,
+            identity=self.identity,
+            graph=self.graph,
+            processor=self.processor,
+            effector=self.effector,
+            actor=self.actor,
+            use_kobj_processor_thread=use_kobj_processor_thread
+        )
+        
+        # if self.config.koi_net.node_profile.node_type == NodeType.FULL:
+        self.server = (NodeServerOverride or NodeServer)(
+            config=self.config,
+            lifecycle=self.lifecycle,
+            secure=self.secure,
+            processor=self.processor,
+            event_queue=self.event_queue,
+            response_handler=self.response_handler
+        )
+        
+        self.poller = (NodePollerOverride or NodePoller)(
+            processor=self.processor,
+            lifecycle=self.lifecycle,
+            resolver=self.resolver,
+            config=self.config
+        )

koi_net-1.1.0/src/koi_net/default_actions.py

@@ -0,0 +1,15 @@
+from .context import ActionContext
+from rid_lib.types import KoiNetNode
+from rid_lib.ext import Bundle
+from .effector import Effector
+
+
+@Effector.register_default_action(KoiNetNode)
+def dereference_koi_node(ctx: ActionContext, rid: KoiNetNode) -> Bundle:
+    if rid != ctx.identity.rid:
+        return
+    
+    return Bundle.generate(
+        rid=ctx.identity.rid,
+        contents=ctx.identity.profile.model_dump()
+    )