koi-net 1.0.0b12__tar.gz → 1.0.0b14__tar.gz

{koi_net-1.0.0b12 → koi_net-1.0.0b14}/.gitignore

@@ -2,6 +2,7 @@ rid-lib
 __pycache__
 *.json
 venv
+.env
 prototypes
 .vscode
 dist/

{koi_net-1.0.0b12 → koi_net-1.0.0b14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: koi-net
-Version: 1.0.0b12
+Version: 1.0.0b14
 Summary: Implementation of KOI-net protocol in Python
 Project-URL: Homepage, https://github.com/BlockScience/koi-net/
 Author-email: Luke Miller <luke@block.science>
@@ -30,7 +30,9 @@ Requires-Python: >=3.10
 Requires-Dist: httpx>=0.28.1
 Requires-Dist: networkx>=3.4.2
 Requires-Dist: pydantic>=2.10.6
-Requires-Dist: rid-lib>=3.2.1
+Requires-Dist: python-dotenv>=1.1.0
+Requires-Dist: rid-lib>=3.2.3
+Requires-Dist: ruamel-yaml>=0.18.10
 Provides-Extra: dev
 Requires-Dist: build; extra == 'dev'
 Requires-Dist: twine>=6.0; extra == 'dev'

{koi_net-1.0.0b12 → koi_net-1.0.0b14}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "koi-net"
-version = "1.0.0-beta.12"
+version = "1.0.0-beta.14"
 description = "Implementation of KOI-net protocol in Python"
 authors = [
     {name = "Luke Miller", email = "luke@block.science"}
@@ -13,10 +13,12 @@ readme = "README.md"
 requires-python = ">=3.10"
 license = {file = "LICENSE"}
 dependencies = [
-    "rid-lib>=3.2.1",
+    "rid-lib>=3.2.3",
     "networkx>=3.4.2",
     "httpx>=0.28.1",
-    "pydantic>=2.10.6"
+    "pydantic>=2.10.6",
+    "ruamel.yaml>=0.18.10",
+    "python-dotenv>=1.1.0"
 ]
 
 [project.optional-dependencies]

koi_net-1.0.0b14/src/koi_net/config.py

@@ -0,0 +1,95 @@
+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
+
+
+class ServerConfig(BaseModel):
+    host: str | None = "127.0.0.1"
+    port: int | None = 8000
+    path: str | None = "/koi-net"
+    
+    @property
+    def url(self):
+        return f"http://{self.host}:{self.port}{self.path or ''}"
+
+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
+
+class EnvConfig(BaseModel):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        load_dotenv()
+    
+    def __getattribute__(self, name):
+        value = super().__getattribute__(name)
+        if name in type(self).model_fields:
+            env_val = os.getenv(value)
+            if env_val is None:
+                raise ValueError(f"Required environment variable {value} not set")
+            return env_val
+        return value
+
+class Config(BaseModel):
+    server: ServerConfig | None = Field(default_factory=ServerConfig)
+    koi_net: KoiNetConfig
+    _file_path: str = PrivateAttr(default="config.yaml")
+    _file_content: str | None = PrivateAttr(default=None)
+    
+    @classmethod
+    def load_from_yaml(
+        cls, 
+        file_path: str | None = None, 
+        generate_missing: bool = True
+    ):
+        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)
+            config._file_content = file_content
+            
+        except FileNotFoundError:
+            config = cls()
+            
+        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
+            )
+                
+            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
+                
+ConfigType = TypeVar("ConfigType", bound=Config)

{koi_net-1.0.0b12 → koi_net-1.0.0b14}/src/koi_net/core.py

@@ -1,4 +1,5 @@
 import logging
+from typing import Generic
 import httpx
 from rid_lib.ext import Cache, Bundle
 from .network import NetworkInterface
@@ -6,45 +7,43 @@ from .processor import ProcessorInterface
 from .processor import default_handlers
 from .processor.handler import KnowledgeHandler
 from .identity import NodeIdentity
-from .protocol.node import NodeProfile
 from .protocol.event import Event, EventType
+from .config import ConfigType
 
 logger = logging.getLogger(__name__)
 
 
-class NodeInterface:
+
+class NodeInterface(Generic[ConfigType]):
+    config: ConfigType
     cache: Cache
     identity: NodeIdentity
     network: NetworkInterface
     processor: ProcessorInterface
-    first_contact: str
+    
     use_kobj_processor_thread: bool
     
     def __init__(
         self, 
-        name: str,
-        profile: NodeProfile,
-        identity_file_path: str = "identity.json",
-        event_queues_file_path: str = "event_queues.json",
-        cache_directory_path: str = "rid_cache",
+        config: ConfigType,
         use_kobj_processor_thread: bool = False,
-        first_contact: str | None = None,
+        
         handlers: list[KnowledgeHandler] | None = None,
+        
         cache: Cache | None = None,
         network: NetworkInterface | None = None,
         processor: ProcessorInterface | None = None
     ):
-        self.cache = cache or Cache(cache_directory_path)
+        self.config: ConfigType = config
+        self.cache = cache or Cache(
+            self.config.koi_net.cache_directory_path)
+        
         self.identity = NodeIdentity(
-            name=name,
-            profile=profile,
-            cache=self.cache,
-            file_path=identity_file_path
-        )
-        self.first_contact = first_contact
+            config=self.config,
+            cache=self.cache)
+        
         self.network = network or NetworkInterface(
-            file_path=event_queues_file_path, 
-            first_contact=self.first_contact,
+            config=self.config,
             cache=self.cache, 
             identity=self.identity
         )
@@ -58,13 +57,14 @@ class NodeInterface:
 
         self.use_kobj_processor_thread = use_kobj_processor_thread
         self.processor = processor or ProcessorInterface(
+            config=self.config,
             cache=self.cache, 
             network=self.network, 
             identity=self.identity, 
             use_kobj_processor_thread=self.use_kobj_processor_thread,
             default_handlers=handlers
         )
-    
+            
     def start(self) -> None:
         """Starts a node, call this method first.
         
@@ -91,8 +91,8 @@ class NodeInterface:
             self.processor.flush_kobj_queue()
         logger.debug("Done")
     
-        if not self.network.graph.get_neighbors() and self.first_contact:
-            logger.debug(f"I don't have any neighbors, reaching out to first contact {self.first_contact}")
+        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),
@@ -101,7 +101,7 @@ class NodeInterface:
             
             try:
                 self.network.request_handler.broadcast_events(
-                    url=self.first_contact,
+                    url=self.config.koi_net.first_contact,
                     events=events
                 )
                 

koi_net-1.0.0b14/src/koi_net/identity.py

@@ -0,0 +1,42 @@
+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 Config
+from .protocol.node import NodeProfile
+
+logger = logging.getLogger(__name__)
+
+    
+class NodeIdentity:
+    """Represents a node's identity (RID, profile, bundle)."""
+    
+    config: Config    
+    cache: Cache
+    
+    def __init__(
+        self,
+        config: Config,
+        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.
+        """
+        self.config = config
+        self.cache = cache
+        
+    @property
+    def rid(self) -> KoiNetNode:
+        return self.config.koi_net.node_rid
+    
+    @property
+    def profile(self) -> NodeProfile:
+        return self.config.koi_net.node_profile 
+    
+    @property
+    def bundle(self) -> Bundle:
+        return self.cache.read(self.rid)

{koi_net-1.0.0b12 → koi_net-1.0.0b14}/src/koi_net/network/interface.py

@@ -1,11 +1,13 @@
 import logging
 from queue import Queue
+from typing import Generic
 import httpx
 from pydantic import BaseModel
 from rid_lib import RID
 from rid_lib.core import RIDType
 from rid_lib.ext import Cache
 from rid_lib.types import KoiNetNode
+
 from .graph import NetworkGraph
 from .request_handler import RequestHandler
 from .response_handler import ResponseHandler
@@ -13,6 +15,7 @@ from ..protocol.node import NodeType
 from ..protocol.edge import EdgeType
 from ..protocol.event import Event
 from ..identity import NodeIdentity
+from ..config import Config, ConfigType
 
 logger = logging.getLogger(__name__)
 
@@ -23,33 +26,30 @@ class EventQueueModel(BaseModel):
 
 type EventQueue = dict[RID, Queue[Event]]
 
-class NetworkInterface:
+class NetworkInterface(Generic[ConfigType]):
     """A collection of functions and classes to interact with the KOI network."""
     
+    config: ConfigType    
     identity: NodeIdentity
     cache: Cache
-    first_contact: str | None
     graph: NetworkGraph
     request_handler: RequestHandler
     response_handler: ResponseHandler
     poll_event_queue: EventQueue
     webhook_event_queue: EventQueue
-    event_queues_file_path: str
     
     def __init__(
         self, 
-        file_path: str,
-        first_contact: str | None,
+        config: ConfigType,
         cache: Cache, 
         identity: NodeIdentity
     ):
+        self.config = config
         self.identity = identity
         self.cache = cache
-        self.first_contact = first_contact
         self.graph = NetworkGraph(cache, identity)
         self.request_handler = RequestHandler(cache, self.graph)
         self.response_handler = ResponseHandler(cache)
-        self.event_queues_file_path = file_path
         
         self.poll_event_queue = dict()
         self.webhook_event_queue = dict()
@@ -58,7 +58,7 @@ class NetworkInterface:
     def _load_event_queues(self):
         """Loads event queues from storage."""
         try:
-            with open(self.event_queues_file_path, "r") as f:
+            with open(self.config.koi_net.event_queues_path, "r") as f:
                 queues = EventQueueModel.model_validate_json(f.read())
             
             for node in queues.poll.keys():
@@ -92,7 +92,7 @@ class NetworkInterface:
         if len(events_model.poll) == 0 and len(events_model.webhook) == 0:
             return
         
-        with open(self.event_queues_file_path, "w") as f:
+        with open(self.config.koi_net.event_queues_path, "w") as f:
             f.write(events_model.model_dump_json(indent=2))
     
     def push_event_to(self, event: Event, node: KoiNetNode, flush=False):
@@ -171,10 +171,12 @@ class NetworkInterface:
         
         try:  
             self.request_handler.broadcast_events(node, events=events)
+            return True
         except httpx.ConnectError:
-            logger.warning("Broadcast failed, requeuing events")
+            logger.warning("Broadcast failed, dropping node")
             for event in events:
                 self.push_event_to(event, node)
+            return False
             
     def get_state_providers(self, rid_type: RIDType) -> list[KoiNetNode]:
         """Returns list of node RIDs which provide state for the specified RID type."""
@@ -238,18 +240,18 @@ class NetworkInterface:
         
         neighbors = self.graph.get_neighbors()
         
-        if not neighbors and self.first_contact:
+        if not neighbors and self.config.koi_net.first_contact:
             logger.debug("No neighbors found, polling first contact")
             try:
                 payload = self.request_handler.poll_events(
-                    url=self.first_contact, 
+                    url=self.config.koi_net.first_contact, 
                     rid=self.identity.rid
                 )
                 if payload.events:
-                    logger.debug(f"Received {len(payload.events)} events from '{self.first_contact}'")
+                    logger.debug(f"Received {len(payload.events)} events from '{self.config.koi_net.first_contact}'")
                 return payload.events
             except httpx.ConnectError:
-                logger.debug(f"Failed to reach first contact '{self.first_contact}'")
+                logger.debug(f"Failed to reach first contact '{self.config.koi_net.first_contact}'")
         
         events = []
         for node_rid in neighbors:

{koi_net-1.0.0b12 → koi_net-1.0.0b14}/src/koi_net/processor/interface.py

@@ -1,7 +1,7 @@
 import logging
 import queue
 import threading
-from typing import Callable
+from typing import Callable, Generic
 from rid_lib.core import RID, RIDType
 from rid_lib.ext import Bundle, Cache, Manifest
 from rid_lib.types.koi_net_edge import KoiNetEdge
@@ -9,6 +9,7 @@ from rid_lib.types.koi_net_node import KoiNetNode
 from ..identity import NodeIdentity
 from ..network import NetworkInterface
 from ..protocol.event import Event, EventType
+from ..config import Config
 from .handler import (
     KnowledgeHandler, 
     HandlerType, 
@@ -24,9 +25,10 @@ from .knowledge_object import (
 logger = logging.getLogger(__name__)
 
 
-class ProcessorInterface:
+class ProcessorInterface():
     """Provides access to this node's knowledge processing pipeline."""
     
+    config: Config
     cache: Cache
     network: NetworkInterface
     identity: NodeIdentity
@@ -36,13 +38,15 @@ class ProcessorInterface:
     worker_thread: threading.Thread | None = None
     
     def __init__(
-        self, 
+        self,
+        config: Config,
         cache: Cache, 
         network: NetworkInterface,
         identity: NodeIdentity,
         use_kobj_processor_thread: bool,
         default_handlers: list[KnowledgeHandler] = []
     ):
+        self.config = config
         self.cache = cache
         self.network = network
         self.identity = identity

koi_net-1.0.0b12/src/koi_net/identity.py

@@ -1,70 +0,0 @@
-import logging
-from pydantic import BaseModel
-from rid_lib.ext.bundle import Bundle
-from rid_lib.ext.cache import Cache
-from rid_lib.types.koi_net_node import KoiNetNode
-from .protocol.node import NodeProfile
-
-logger = logging.getLogger(__name__)
-
-
-class NodeIdentityModel(BaseModel):
-    rid: KoiNetNode
-    profile: NodeProfile
-    
-class NodeIdentity:
-    """Represents a node's identity (RID, profile, bundle)."""
-    
-    _identity: NodeIdentityModel
-    file_path: str
-    cache: Cache
-    
-    def __init__(
-        self,  
-        name: str,
-        profile: NodeProfile,
-        cache: Cache,
-        file_path: str = "identity.json"
-    ):
-        """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.
-        """
-        self.cache = cache
-        self.file_path = file_path
-        
-        self._identity = None
-        try:
-            with open(file_path, "r") as f:
-                self._identity = NodeIdentityModel.model_validate_json(f.read())
-                    
-        except FileNotFoundError:
-            pass
-        
-        if self._identity:
-            if self._identity.rid.name != name:
-                logger.warning("Node name changed which will change this node's RID, if you really want to do this manually delete the identity JSON file")
-            if self._identity.profile != profile:
-                self._identity.profile = profile
-        else:
-            self._identity = NodeIdentityModel( 
-                rid=KoiNetNode.generate(name), 
-                profile=profile,
-            )
-                    
-        with open(file_path, "w") as f:
-            f.write(self._identity.model_dump_json(indent=2))
-        
-    @property
-    def rid(self) -> KoiNetNode:
-        return self._identity.rid
-    
-    @property
-    def profile(self) -> NodeProfile:
-        return self._identity.profile    
-    
-    @property
-    def bundle(self) -> Bundle:
-        return self.cache.read(self.rid)