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

koi_net/__init__.py

@@ -1 +1 @@
-from .core import NodeInterface
+from .core import NodeContainer

koi_net/behaviors.py

@@ -0,0 +1,51 @@
+from logging import getLogger
+from rid_lib.ext import Cache
+from rid_lib.types import KoiNetNode
+from rid_lib import RIDType
+from koi_net.identity import NodeIdentity
+from koi_net.network.event_queue import EventQueue
+from koi_net.network.request_handler import RequestHandler
+from koi_net.network.resolver import NetworkResolver
+from koi_net.processor.kobj_queue import KobjQueue
+from koi_net.protocol.api_models import ErrorResponse
+from .protocol.event import Event, EventType
+
+
+logger = getLogger(__name__)
+
+
+
+class Behaviors:
+    def __init__(self, cache: Cache, identity: NodeIdentity, event_queue: EventQueue, resolver: NetworkResolver, request_handler: RequestHandler, kobj_queue: KobjQueue):
+        self.cache = cache
+        self.identity = identity
+        self.event_queue = event_queue
+        self.resolver = resolver
+        self.request_handler = request_handler
+        self.kobj_queue = kobj_queue
+
+    def identify_coordinators(self) -> list[KoiNetNode]:
+        """Returns node's providing state for `orn:koi-net.node`."""
+        return self.resolver.get_state_providers(KoiNetNode)
+
+    def catch_up_with(self, target: KoiNetNode, rid_types: list[RIDType] = []):
+        """Fetches and processes knowledge objects from target node.
+        Args:
+            target: Node to catch up with
+            rid_types: RID types to fetch from target (all types if list is empty)
+        """
+        logger.debug(f"catching up with {target} on {rid_types or 'all types'}")
+        payload = self.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.identity.rid:
+                continue
+            self.kobj_queue.put_kobj(
+                manifest=manifest,
+                source=target
+            )

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

@@ -2,62 +2,53 @@ 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.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:
+    """Provides action handlers access to other subsystems."""
+    
     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,
-        effector: Effector
     ):
         self.identity = identity
         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.resolver = resolver