koi-net 1.1.0b8__py3-none-any.whl → 1.2.0b2__py3-none-any.whl

koi_net/__init__.py

@@ -1 +1,2 @@
-from .core import NodeInterface
+from . import logger
+from . import sentry

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/cli/__init__.py

@@ -0,0 +1 @@
+from .commands import app

koi_net/cli/commands.py

@@ -0,0 +1,99 @@
+import os
+import typer
+from typing import Callable
+from rich.console import Console
+from rich.table import Table
+
+from importlib.metadata import entry_points
+
+from koi_net.cli.models import KoiNetworkConfig
+from koi_net.core import NodeInterface
+import shutil
+
+app = typer.Typer()
+console = Console()
+
+installed_nodes = entry_points(group='koi_net.node')
+
+net_config = KoiNetworkConfig.load_from_yaml()
+
+@app.command()
+def list_node_types():
+    table = Table(title="installed node types")
+    table.add_column("name", style="cyan")
+    table.add_column("module", style="magenta")
+
+    for node in installed_nodes:
+        table.add_row(node.name, node.module)
+    console.print(table)
+    
+@app.command()
+def list_nodes():
+    table = Table(title="created nodes")
+    table.add_column("name", style="cyan")
+    table.add_column("rid", style="magenta")
+
+    for dir in os.listdir('.'):
+        if not os.path.isdir(dir):
+            continue
+        for file in os.listdir(dir):
+            file_path = os.path.join(dir, file)
+            if not (os.path.isfile(file_path) and file == "config.yaml"):
+                continue
+            
+            print(os.getcwd())
+            os.chdir(dir)
+            print(os.getcwd())
+                        
+            node_type = net_config.nodes.get(dir)
+            
+            ep = list(installed_nodes.select(name=node_type))[0]
+            create_node: Callable[[], NodeInterface] = ep.load()
+            
+            node = create_node()
+            
+            print(ep)
+            print(dir)
+            print(node.identity.rid)
+            
+            table.add_row(dir, str(node.identity.rid))
+            
+            os.chdir('..')
+            print(os.getcwd())
+    
+    console.print(table)
+
+@app.command()
+def create(type: str, name: str):
+    # if name not in installed_nodes:
+    #     console.print(f"[bold red]Error:[/bold red] node type '{name}' doesn't exist")
+    #     raise typer.Exit(code=1)
+
+    eps = installed_nodes.select(name=type)
+    if eps:
+        ep = list(eps)[0]
+    
+    os.mkdir(name)
+    os.chdir(name)
+    
+    ep.load()
+    
+    os.chdir('..')
+    
+    net_config.nodes[name] = type
+    net_config.save_to_yaml()
+    
+@app.command()
+def remove(name: str):
+    shutil.rmtree(name)
+    net_config.nodes.pop(name, None)
+    net_config.save_to_yaml()
+    
+@app.command()
+def start(name: str):
+    os.chdir(name)
+    node_type = net_config.nodes.get(name)
+    ep = list(installed_nodes.select(name=node_type))[0]
+    create_node: Callable[[], NodeInterface] = ep.load()
+    
+    create_node().server.run()

koi_net/cli/models.py

@@ -0,0 +1,41 @@
+from pydantic import BaseModel, Field, PrivateAttr
+from ruamel.yaml import YAML
+
+
+class KoiNetworkConfig(BaseModel):
+    nodes: dict[str, str] = Field(default_factory=dict)
+    _file_path: str = PrivateAttr(default="koi-net-config.yaml")
+
+    @classmethod
+    def load_from_yaml(
+        cls, 
+        file_path: str = "koi-net-config.yaml", 
+    ):
+        yaml = YAML()
+        
+        try:
+            with open(file_path, "r") as f:
+                file_content = f.read()
+            config_data = yaml.load(file_content)
+            config = cls.model_validate(config_data)
+            
+        except FileNotFoundError:
+            config = cls()
+        
+        config._file_path = file_path
+        config.save_to_yaml()
+        return config
+    
+    def save_to_yaml(self):
+        yaml = YAML()
+        
+        with open(self._file_path, "w") as f:
+            try:
+                config_data = self.model_dump(mode="json")
+                yaml.dump(config_data, f)
+            except Exception as e:
+                if self._file_content:
+                    f.seek(0)
+                    f.truncate()
+                    f.write(self._file_content)
+                raise e

koi_net/config.py

@@ -1,4 +1,5 @@
 import os
+from rid_lib import RIDType
 from ruamel.yaml import YAML
 from pydantic import BaseModel, Field, PrivateAttr
 from dotenv import load_dotenv
@@ -9,6 +10,8 @@ from .protocol.node import NodeProfile, NodeType
 
 
 class ServerConfig(BaseModel):
+    """Config for the node server (full node only)."""
+    
     host: str = "127.0.0.1"
     port: int = 8000
     path: str | None = "/koi-net"
@@ -22,10 +25,15 @@ class NodeContact(BaseModel):
     url: str | None = None
 
 class KoiNetConfig(BaseModel):
+    """Config for KOI-net."""
+    
     node_name: str
     node_rid: KoiNetNode | None = None
     node_profile: NodeProfile
     
+    rid_types_of_interest: list[RIDType] = Field(
+        default_factory=lambda: [KoiNetNode])
+    
     cache_directory_path: str = ".rid_cache"
     event_queues_path: str = "event_queues.json"
     private_key_pem_path: str = "priv_key.pem"
@@ -36,6 +44,15 @@ class KoiNetConfig(BaseModel):
     _priv_key: PrivateKey | None = PrivateAttr(default=None)
 
 class EnvConfig(BaseModel):
+    """Config for environment variables.
+    
+    Values set in the config are the variables names, and are loaded
+    from the environment at runtime. For example, if the config YAML
+    sets `priv_key_password: PRIV_KEY_PASSWORD` accessing 
+    `priv_key_password` would retrieve the value of `PRIV_KEY_PASSWORD`
+    from the environment.
+    """
+    
     priv_key_password: str | None = "PRIV_KEY_PASSWORD"
     
     def __init__(self, **kwargs):
@@ -52,6 +69,12 @@ class EnvConfig(BaseModel):
         return value
 
 class NodeConfig(BaseModel):
+    """Base configuration class for all nodes.
+    
+    Designed to be extensible for custom node implementations. Classes
+    inheriting from `NodeConfig` may add additional config groups.
+    """
+    
     server: ServerConfig = Field(default_factory=ServerConfig)
     koi_net: KoiNetConfig
     env: EnvConfig = Field(default_factory=EnvConfig)
@@ -65,6 +88,12 @@ class NodeConfig(BaseModel):
         file_path: str = "config.yaml", 
         generate_missing: bool = True
     ):
+        """Loads config state from YAML file.
+        
+        Defaults to `config.yaml`. If `generate_missing` is set to 
+        `True`, a private key and RID will be generated if not already
+        present in the config.
+        """
         yaml = YAML()
         
         try:
@@ -112,6 +141,11 @@ class NodeConfig(BaseModel):
         return config
     
     def save_to_yaml(self):
+        """Saves config state to YAML file.
+        
+        File path is set by `load_from_yaml` class method.
+        """
+        
         yaml = YAML()
         
         with open(self._file_path, "w") as f:

koi_net/context.py

@@ -1,45 +1,35 @@
 from rid_lib.ext import Cache
 
+from koi_net.effector import Effector
 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.event_queue import EventQueue
 from .network.request_handler import RequestHandler
 from .identity import NodeIdentity
-from .processor.interface import ProcessorInterface
+from .processor.kobj_queue import KobjQueue
 
 
-class ActionContext:
-    identity: NodeIdentity
-    effector: Effector
-
-    def __init__(
-        self,
-        identity: NodeIdentity,
-        effector: Effector
-    ):
-        self.identity = identity
-        self.effector = effector
-    
-
 class HandlerContext:
+    """Provides knowledge handlers access to other subsystems."""
+    
     identity: NodeIdentity
     config: NodeConfig
     cache: Cache
-    event_queue: NetworkEventQueue
+    event_queue: EventQueue
+    kobj_queue: KobjQueue
     graph: NetworkGraph
     request_handler: RequestHandler
     resolver: NetworkResolver
     effector: Effector
-    _processor: ProcessorInterface | None
     
     def __init__(
         self,
         identity: NodeIdentity,
         config: NodeConfig,
         cache: Cache,
-        event_queue: NetworkEventQueue,
+        event_queue: EventQueue,
+        kobj_queue: KobjQueue,
         graph: NetworkGraph,
         request_handler: RequestHandler,
         resolver: NetworkResolver,
@@ -49,15 +39,8 @@ class HandlerContext:
         self.config = config
         self.cache = cache
         self.event_queue = event_queue
+        self.kobj_queue = kobj_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
+        self.effector = effector

koi_net/core.py

@@ -1,194 +1,78 @@
-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 .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.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 .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 .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)
+# factory functions for components with non standard initializiation
 
-        self.graph = (NetworkGraphOverride or NetworkGraph)(
-            cache=self.cache,
-            identity=self.identity
-        )
+def make_config() -> BaseConfig:
+    return BaseConfig.load_from_yaml()
 
-        self.secure = (SecureOverride or Secure)(
-            identity=self.identity,
-            effector=self.effector,
-            config=self.config
-        )
+def make_cache(config: BaseConfig) -> Cache:
+    return Cache(directory_path=config.koi_net.cache_directory_path)
 
-        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)
+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
 
-        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)
-            ]
+class FullNode(BaseNode):
+    entrypoint = NodeServer
 
-        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
-        )
+class PartialNode(BaseNode):
+    entrypoint = NodePoller

koi_net/default_actions.py

@@ -1,3 +1,5 @@
+"""Implementations of default dereference actions."""
+
 from .context import ActionContext
 from rid_lib.types import KoiNetNode
 from rid_lib.ext import Bundle
@@ -5,7 +7,14 @@ from .effector import Effector
 
 
 @Effector.register_default_action(KoiNetNode)
-def dereference_koi_node(ctx: ActionContext, rid: KoiNetNode) -> Bundle:
+def dereference_koi_node(
+    ctx: ActionContext, rid: KoiNetNode
+) -> Bundle | None:
+    """Dereference function for this KOI node.
+    
+    Generates a bundle from this node's profile data in the config.
+    """
+    
     if rid != ctx.identity.rid:
         return