koi-net 1.0.0b19__py3-none-any.whl → 1.1.0__py3-none-any.whl

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/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/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/core.py

@@ -1,53 +1,117 @@
 import logging
-from typing import Generic
-import httpx
-from rid_lib.ext import Cache, Bundle
-from .network import NetworkInterface
-from .processor import ProcessorInterface
+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 .protocol.event import Event, EventType
-from .config import ConfigType
+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[ConfigType]):
-    config: ConfigType
+class NodeInterface(Generic[T]):
+    config: T
     cache: Cache
     identity: NodeIdentity
-    network: NetworkInterface
+    resolver: NetworkResolver
+    event_queue: NetworkEventQueue
+    graph: NetworkGraph
     processor: ProcessorInterface
+    secure: Secure
+    server: NodeServer
     
     use_kobj_processor_thread: bool
     
     def __init__(
-        self, 
-        config: ConfigType,
+        self,
+        config: T,
         use_kobj_processor_thread: bool = False,
-        
         handlers: list[KnowledgeHandler] | None = None,
         
-        cache: Cache | None = None,
-        network: NetworkInterface | None = None,
-        processor: ProcessorInterface | 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: ConfigType = config
-        self.cache = cache or Cache(
-            self.config.koi_net.cache_directory_path)
-        
-        self.identity = NodeIdentity(
+        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)
-        
-        self.network = network or NetworkInterface(
+            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
+            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 = [
@@ -56,71 +120,75 @@ class NodeInterface(Generic[ConfigType]):
             ]
 
         self.use_kobj_processor_thread = use_kobj_processor_thread
-        self.processor = processor or ProcessorInterface(
+        
+        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, 
-            network=self.network, 
-            identity=self.identity, 
-            use_kobj_processor_thread=self.use_kobj_processor_thread,
-            default_handlers=handlers
+            cache=self.cache,
+            event_queue=self.event_queue,
+            graph=self.graph,
+            request_handler=self.request_handler,
+            resolver=self.resolver,
+            effector=self.effector
         )
-            
-    def start(self) -> None:
-        """Starts a node, call this method first.
         
-        Starts the processor thread (if enabled). Loads event queues into memory. Generates network graph from nodes and edges in cache. Processes any state changes of node bundle. Initiates handshake with first contact (if provided) if node doesn't have any neighbors.
-        """
-        if self.use_kobj_processor_thread:
-            logger.info("Starting processor worker thread")
-            self.processor.worker_thread.start()
+        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.network._load_event_queues()
-        self.network.graph.generate()
+        self.processor = (ProcessorInterfaceOverride or ProcessorInterface)(
+            pipeline=self.pipeline,
+            use_kobj_processor_thread=self.use_kobj_processor_thread
+        )
         
-        self.processor.handle(
-            bundle=Bundle.generate(
-                rid=self.identity.rid, 
-                contents=self.identity.profile.model_dump()
-            )
+        self.error_handler = (ErrorHandlerOverride or ErrorHandler)(
+            processor=self.processor,
+            actor=self.actor
         )
         
-        logger.debug("Waiting for kobj queue to empty")
-        if self.use_kobj_processor_thread:
-            self.processor.kobj_queue.join()
-        else:
-            self.processor.flush_kobj_queue()
-        logger.debug("Done")
-    
-        if not self.network.graph.get_neighbors() and self.config.koi_net.first_contact:
-            logger.debug(f"I don't have any neighbors, reaching out to first contact {self.config.koi_net.first_contact}")
-            
-            events = [
-                Event.from_rid(EventType.FORGET, self.identity.rid),
-                Event.from_bundle(EventType.NEW, self.identity.bundle)
-            ]
-            
-            try:
-                self.network.request_handler.broadcast_events(
-                    url=self.config.koi_net.first_contact,
-                    events=events
-                )
-                
-            except httpx.ConnectError:
-                logger.warning("Failed to reach first contact")
-                return
-            
-                        
-    def stop(self):
-        """Stops a node, call this method last.
+        self.request_handler.set_error_handler(self.error_handler)
         
-        Finishes processing knowledge object queue. Saves event queues to storage.
-        """
-        logger.info("Stopping node...")
+        self.handler_context.set_processor(self.processor)
         
-        if self.use_kobj_processor_thread:
-            logger.info(f"Waiting for kobj queue to empty ({self.processor.kobj_queue.unfinished_tasks} tasks remaining)")
-            self.processor.kobj_queue.join()
-        else:
-            self.processor.flush_kobj_queue()
+        self.effector.set_processor(self.processor)
+        self.effector.set_resolver(self.resolver)
+        self.effector.set_action_context(self.action_context)
         
-        self.network._save_event_queues()
+        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/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()
+    )

koi_net/effector.py

@@ -0,0 +1,139 @@
+import logging
+from typing import Callable
+from enum import StrEnum
+from rid_lib.ext import Cache, Bundle
+from rid_lib.core import RID, RIDType
+from rid_lib.types import KoiNetNode
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .network.resolver import NetworkResolver
+    from .processor.interface import ProcessorInterface
+    from .context import ActionContext
+
+logger = logging.getLogger(__name__)
+
+
+class BundleSource(StrEnum):
+    CACHE = "CACHE"
+    ACTION = "ACTION"
+
+class Effector:
+    cache: Cache
+    resolver: "NetworkResolver | None"
+    processor: "ProcessorInterface | None"
+    action_context: "ActionContext | None"
+    _action_table: dict[
+        type[RID], 
+        Callable[
+            ["ActionContext", RID], 
+            Bundle | None
+        ]
+    ] = dict()
+    
+    def __init__(
+        self, 
+        cache: Cache,
+    ):
+        self.cache = cache
+        self.resolver = None
+        self.processor = None
+        self.action_context = None
+        self._action_table = self.__class__._action_table.copy()
+        
+    def set_processor(self, processor: "ProcessorInterface"):
+        self.processor = processor
+        
+    def set_resolver(self, resolver: "NetworkResolver"):
+        self.resolver = resolver
+        
+    def set_action_context(self, action_context: "ActionContext"):
+        self.action_context = action_context
+        
+    @classmethod
+    def register_default_action(cls, rid_type: RIDType):
+        def decorator(func: Callable) -> Callable:
+            cls._action_table[rid_type] = func
+            return func
+        return decorator
+        
+    def register_action(self, rid_type: RIDType):
+        def decorator(func: Callable) -> Callable:
+            self._action_table[rid_type] = func
+            return func
+        return decorator
+    
+    def _try_cache(self, rid: RID) -> tuple[Bundle, BundleSource] | None:
+        bundle = self.cache.read(rid)
+        
+        if bundle:
+            logger.debug("Cache hit")
+            return bundle, BundleSource.CACHE
+        else:
+            logger.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")
+            return None
+        
+        logger.debug("Action available")
+        func = self._action_table[type(rid)]
+        bundle = func(
+            ctx=self.action_context, 
+            rid=rid
+        )
+        
+        if bundle:
+            logger.debug("Action hit")
+            return bundle, BundleSource.ACTION
+        else:
+            logger.debug("Action miss")
+            return None
+
+        
+    def _try_network(self, rid: RID) -> tuple[Bundle, KoiNetNode] | None:
+        bundle, source = self.resolver.fetch_remote_bundle(rid)
+        
+        if bundle:
+            logger.debug("Network hit")
+            return bundle, source
+        else:
+            logger.debug("Network miss")
+            return None
+        
+    
+    def deref(
+        self, 
+        rid: RID,
+        refresh_cache: bool = False,
+        use_network: bool = False,
+        handle_result: bool = True
+    ) -> Bundle | None:
+        logger.debug(f"Dereferencing {rid!r}")
+        
+        bundle, source = (
+            # if `refresh_cache`, skip try cache
+            not refresh_cache and self._try_cache(rid) or 
+            self._try_action(rid) or
+            use_network and self._try_network(rid) or
+            # if not found, bundle and source set to None
+            (None, None) 
+        )
+        
+        if (
+            handle_result 
+            and bundle is not None 
+            and source != BundleSource.CACHE
+        ):            
+            self.processor.handle(
+                bundle=bundle, 
+                source=source if type(source) is KoiNetNode else None
+            )
+
+            # TODO: refactor for general solution, param to write through to cache before continuing
+            # like `self.processor.kobj_queue.join()``
+
+        return bundle