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

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,55 @@
+
+from koi_net.effector import Effector
+from rid_lib.ext import Cache
+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
+    cache: Cache
+    event_queue: NetworkEventQueue
+    graph: NetworkGraph
+    request_handler: RequestHandler
+    effector: Effector
+    _processor: ProcessorInterface | None
+    
+    def __init__(
+        self,
+        identity: NodeIdentity,
+        cache: Cache,
+        event_queue: NetworkEventQueue,
+        graph: NetworkGraph,
+        request_handler: RequestHandler,
+        effector: Effector
+    ):
+        self.identity = identity
+        self.cache = cache
+        self.event_queue = event_queue
+        self.graph = graph
+        self.request_handler = request_handler
+        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,51 +1,101 @@
 import logging
-from typing import Generic
-import httpx
-from rid_lib.ext import Cache, Bundle
-from .network import NetworkInterface
-from .processor import ProcessorInterface
+from koi_net.protocol.node import NodeType
+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 .network.behavior 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__)
 
 
 
-class NodeInterface(Generic[ConfigType]):
-    config: ConfigType
+class NodeInterface:
+    config: NodeConfig
     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: NodeConfig,
         use_kobj_processor_thread: bool = False,
-        
         handlers: list[KnowledgeHandler] | None = None,
-        
         cache: Cache | None = None,
-        network: NetworkInterface | None = None,
         processor: ProcessorInterface | None = None
     ):
-        self.config: ConfigType = config
+        self.config = config
         self.cache = cache or Cache(
-            self.config.koi_net.cache_directory_path)
+            directory_path=self.config.koi_net.cache_directory_path
+        )
+
+        self.identity = NodeIdentity(config=self.config)
+        self.effector = Effector(cache=self.cache)
+
+        self.graph = NetworkGraph(
+            cache=self.cache, 
+            identity=self.identity
+        )
+        
+        self.secure = Secure(
+            identity=self.identity, 
+            effector=self.effector, 
+            config=self.config
+        )
         
-        self.identity = NodeIdentity(
+        self.request_handler = RequestHandler(
+            effector=self.effector, 
+            identity=self.identity,
+            secure=self.secure
+        )
+        
+        self.response_handler = ResponseHandler(self.cache, self.effector)
+        
+        self.resolver = NetworkResolver(
             config=self.config,
-            cache=self.cache)
+            cache=self.cache, 
+            identity=self.identity,
+            graph=self.graph,
+            request_handler=self.request_handler,
+            effector=self.effector
+        )
         
-        self.network = network or NetworkInterface(
+        self.event_queue = NetworkEventQueue(
             config=self.config,
             cache=self.cache, 
-            identity=self.identity
+            identity=self.identity,
+            graph=self.graph,
+            request_handler=self.request_handler,
+            effector=self.effector
+        )
+        
+        self.actor = Actor(
+            identity=self.identity,
+            effector=self.effector,
+            event_queue=self.event_queue
         )
         
         # pull all handlers defined in default_handlers module
@@ -56,71 +106,71 @@ class NodeInterface(Generic[ConfigType]):
             ]
 
         self.use_kobj_processor_thread = use_kobj_processor_thread
+        
+        self.action_context = ActionContext(
+            identity=self.identity,
+            effector=self.effector
+        )
+        
+        self.handler_context = HandlerContext(
+            identity=self.identity,
+            cache=self.cache,
+            event_queue=self.event_queue,
+            graph=self.graph,
+            request_handler=self.request_handler,
+            effector=self.effector
+        )
+        
+        self.pipeline = 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 = processor or ProcessorInterface(
+            pipeline=self.pipeline,
+            use_kobj_processor_thread=self.use_kobj_processor_thread
+        )
+        
+        self.error_handler = 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.lifecycle = NodeLifecycle(
             config=self.config,
-            cache=self.cache, 
-            network=self.network, 
-            identity=self.identity, 
-            use_kobj_processor_thread=self.use_kobj_processor_thread,
-            default_handlers=handlers
+            identity=self.identity,
+            graph=self.graph,
+            processor=self.processor,
+            effector=self.effector,
+            actor=self.actor,
+            use_kobj_processor_thread=use_kobj_processor_thread
         )
-            
-    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.network._load_event_queues()
-        self.network.graph.generate()
-        
-        self.processor.handle(
-            bundle=Bundle.generate(
-                rid=self.identity.rid, 
-                contents=self.identity.profile.model_dump()
-            )
+        
+        # if self.config.koi_net.node_profile.node_type == NodeType.FULL:
+        self.server = NodeServer(
+            config=self.config,
+            lifecycle=self.lifecycle,
+            secure=self.secure,
+            processor=self.processor,
+            event_queue=self.event_queue,
+            response_handler=self.response_handler
         )
         
-        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.
-        
-        Finishes processing knowledge object queue. Saves event queues to storage.
-        """
-        logger.info("Stopping node...")
-        
-        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.network._save_event_queues()
+        self.poller = 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

koi_net/identity.py

@@ -1,33 +1,19 @@
 import logging
-from rid_lib.ext.bundle import Bundle
-from rid_lib.ext.cache import Cache
 from rid_lib.types.koi_net_node import KoiNetNode
-
 from .config import NodeConfig
 from .protocol.node import NodeProfile
 
+
 logger = logging.getLogger(__name__)
 
     
 class NodeIdentity:
-    """Represents a node's identity (RID, profile, bundle)."""
+    """Represents a node's identity (RID, profile)."""
     
     config: NodeConfig    
-    cache: Cache
     
-    def __init__(
-        self,
-        config: NodeConfig,
-        cache: Cache
-    ):
-        """Initializes node identity from a name and profile.
-        
-        Attempts to read identity from storage. If it doesn't already exist, a new RID is generated from the provided name, and that RID and profile are written to storage. Changes to the name or profile will update the stored identity.
-        
-        WARNING: If the name is changed, the RID will be overwritten which will have consequences for the rest of the network.
-        """
+    def __init__(self, config: NodeConfig):
         self.config = config
-        self.cache = cache
         
     @property
     def rid(self) -> KoiNetNode:
@@ -35,8 +21,4 @@ class NodeIdentity:
     
     @property
     def profile(self) -> NodeProfile:
-        return self.config.koi_net.node_profile 
-    
-    @property
-    def bundle(self) -> Bundle:
-        return self.cache.read(self.rid)
+        return self.config.koi_net.node_profile

koi_net/lifecycle.py

@@ -0,0 +1,76 @@
+import logging
+
+from .network.behavior import Actor
+from .effector import Effector
+from .config import NodeConfig
+from .processor.interface import ProcessorInterface
+from .network.graph import NetworkGraph
+from .identity import NodeIdentity
+
+logger = logging.getLogger(__name__)
+
+
+class NodeLifecycle:
+    config: NodeConfig
+    graph: NetworkGraph
+    processor: ProcessorInterface
+    effector: Effector
+    actor: Actor
+    
+    def __init__(
+        self,
+        config: NodeConfig,
+        identity: NodeIdentity,
+        graph: NetworkGraph,
+        processor: ProcessorInterface,
+        effector: Effector,
+        actor: Actor,
+        use_kobj_processor_thread: bool
+    ):
+        self.config = config
+        self.identity = identity
+        self.graph = graph
+        self.processor = processor
+        self.effector = effector
+        self.actor = actor
+        self.use_kobj_processor_thread = use_kobj_processor_thread
+    
+    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.graph.generate()
+        
+        # refresh to reflect changes (if any) in config.yaml
+        self.effector.deref(self.identity.rid, refresh_cache=True)
+                
+        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.graph.get_neighbors() and self.config.koi_net.first_contact.rid:
+            logger.debug(f"I don't have any neighbors, reaching out to first contact {self.config.koi_net.first_contact.rid!r}")
+            
+            self.actor.handshake_with(self.config.koi_net.first_contact.rid)
+            
+                        
+    def stop(self):
+        """Stops a node, call this method last.
+        
+        Finishes processing knowledge object queue. Saves event queues to storage.
+        """
+        logger.info("Stopping node...")
+        
+        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()