koi-net 1.0.0b11__py3-none-any.whl → 1.0.0b13__py3-none-any.whl

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 = None
+    
+    @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/core.py

@@ -1,126 +1,126 @@
-import logging
-import httpx
-from rid_lib.ext import Cache, Bundle
-from .network import NetworkInterface
-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
-
-logger = logging.getLogger(__name__)
-
-
-class NodeInterface:
-    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",
-        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.identity = NodeIdentity(
-            name=name,
-            profile=profile,
-            cache=self.cache,
-            file_path=identity_file_path
-        )
-        self.first_contact = first_contact
-        self.network = network or NetworkInterface(
-            file_path=event_queues_file_path, 
-            first_contact=self.first_contact,
-            cache=self.cache, 
-            identity=self.identity
-        )
-        
-        # 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)
-            ]
-
-        self.use_kobj_processor_thread = use_kobj_processor_thread
-        self.processor = processor or ProcessorInterface(
-            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.
-        
-        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()
-            )
-        )
-        
-        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.first_contact:
-            logger.debug(f"I don't have any neighbors, reaching out to first contact {self.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.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()
-        
+import logging
+from typing import Generic
+import httpx
+from rid_lib.ext import Cache, Bundle
+from .network import NetworkInterface
+from .processor import ProcessorInterface
+from .processor import default_handlers
+from .processor.handler import KnowledgeHandler
+from .identity import NodeIdentity
+from .protocol.event import Event, EventType
+from .config import ConfigType
+
+logger = logging.getLogger(__name__)
+
+
+
+class NodeInterface(Generic[ConfigType]):
+    config: ConfigType
+    cache: Cache
+    identity: NodeIdentity
+    network: NetworkInterface
+    processor: ProcessorInterface
+    
+    use_kobj_processor_thread: bool
+    
+    def __init__(
+        self, 
+        config: ConfigType,
+        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.cache = cache or Cache(
+            self.config.koi_net.cache_directory_path)
+        
+        self.identity = NodeIdentity(
+            config=self.config,
+            cache=self.cache)
+        
+        self.network = network or NetworkInterface(
+            config=self.config,
+            cache=self.cache, 
+            identity=self.identity
+        )
+        
+        # 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)
+            ]
+
+        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.
+        
+        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()
+            )
+        )
+        
+        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()

koi_net/identity.py

@@ -1,70 +1,42 @@
-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:
+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)