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

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
+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()
+        
         self.network._save_event_queues()

koi_net/identity.py

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

koi_net/network/graph.py

@@ -1,127 +1,127 @@
-import logging
-from typing import Literal
-import networkx as nx
-from rid_lib import RIDType
-from rid_lib.ext import Cache
-from rid_lib.types import KoiNetEdge, KoiNetNode
-from ..identity import NodeIdentity
-from ..protocol.edge import EdgeProfile, EdgeStatus
-from ..protocol.node import NodeProfile
-
-logger = logging.getLogger(__name__)
-
-
-class NetworkGraph:
-    """Graph functions for this node's view of its network."""
-    
-    cache: Cache
-    identity: NodeIdentity
-    dg: nx.DiGraph
-    
-    def __init__(self, cache: Cache, identity: NodeIdentity):
-        self.cache = cache
-        self.dg = nx.DiGraph()
-        self.identity = identity
-        
-    def generate(self):
-        """Generates directed graph from cached KOI nodes and edges."""
-        logger.debug("Generating network graph")
-        self.dg.clear()
-        for rid in self.cache.list_rids():
-            if type(rid) == KoiNetNode:                
-                self.dg.add_node(rid)
-                logger.debug(f"Added node {rid}")
-                
-            elif type(rid) == KoiNetEdge:
-                edge_profile = self.get_edge_profile(rid)
-                if not edge_profile:
-                    logger.warning(f"Failed to load {rid!r}")
-                    continue
-                self.dg.add_edge(edge_profile.source, edge_profile.target, rid=rid)
-                logger.debug(f"Added edge {rid} ({edge_profile.source} -> {edge_profile.target})")
-        logger.debug("Done")
-        
-    def get_node_profile(self, rid: KoiNetNode) -> NodeProfile | None:
-        """Returns node profile given its RID."""
-        bundle = self.cache.read(rid)
-        if bundle:
-            return bundle.validate_contents(NodeProfile)
-        
-    def get_edge_profile(
-        self, 
-        rid: KoiNetEdge | None = None,
-        source: KoiNetNode | None = None, 
-        target: KoiNetNode | None = None,
-    ) -> EdgeProfile | None:
-        """Returns edge profile given its RID, or source and target node RIDs."""
-        if source and target:
-            if (source, target) not in self.dg.edges: return
-            edge_data = self.dg.get_edge_data(source, target)
-            if not edge_data: return
-            rid = edge_data.get("rid")
-            if not rid: return
-        elif not rid:
-            raise ValueError("Either 'rid' or 'source' and 'target' must be provided")
-        
-        bundle = self.cache.read(rid)
-        if bundle:
-            return bundle.validate_contents(EdgeProfile)
-        
-    def get_edges(
-        self,
-        direction: Literal["in", "out"] | None = None,
-    ) -> list[KoiNetEdge]:
-        """Returns edges this node belongs to.
-        
-        All edges returned by default, specify `direction` to restrict to incoming or outgoing edges only."""
-                
-        edges = []
-        if direction != "in" and self.dg.out_edges:
-            out_edges = self.dg.out_edges(self.identity.rid)
-            edges.extend([e for e in out_edges])
-                
-        if direction != "out" and self.dg.in_edges:
-            in_edges = self.dg.in_edges(self.identity.rid)
-            edges.extend([e for e in in_edges])
-                    
-        edge_rids = []
-        for edge in edges:
-            edge_data = self.dg.get_edge_data(*edge)
-            if not edge_data: continue
-            edge_rid = edge_data.get("rid")
-            if not edge_rid: continue
-            edge_rids.append(edge_rid)
-       
-        return edge_rids
-    
-    def get_neighbors(
-        self,
-        direction: Literal["in", "out"] | None = None,
-        status: EdgeStatus | None = None,
-        allowed_type: RIDType | None = None
-    ) -> list[KoiNetNode]:
-        """Returns neighboring nodes this node shares an edge with.
-        
-        All neighboring nodes returned by default, specify `direction` to restrict to neighbors connected by incoming or outgoing edges only."""
-        
-        neighbors = []
-        for edge_rid in self.get_edges(direction):
-            edge_profile = self.get_edge_profile(edge_rid)
-            
-            if not edge_profile: 
-                logger.warning(f"Failed to find edge {edge_rid!r} in cache")
-                continue
-                        
-            if status and edge_profile.status != status:
-                continue
-            
-            if allowed_type and allowed_type not in edge_profile.rid_types:
-                continue
-            
-            if edge_profile.target == self.identity.rid:
-                neighbors.append(edge_profile.source)
-            elif edge_profile.source == self.identity.rid:
-                neighbors.append(edge_profile.target)
-                
-        return list(neighbors)
-        
+import logging
+from typing import Literal
+import networkx as nx
+from rid_lib import RIDType
+from rid_lib.ext import Cache
+from rid_lib.types import KoiNetEdge, KoiNetNode
+from ..identity import NodeIdentity
+from ..protocol.edge import EdgeProfile, EdgeStatus
+from ..protocol.node import NodeProfile
+
+logger = logging.getLogger(__name__)
+
+
+class NetworkGraph:
+    """Graph functions for this node's view of its network."""
+    
+    cache: Cache
+    identity: NodeIdentity
+    dg: nx.DiGraph
+    
+    def __init__(self, cache: Cache, identity: NodeIdentity):
+        self.cache = cache
+        self.dg = nx.DiGraph()
+        self.identity = identity
+        
+    def generate(self):
+        """Generates directed graph from cached KOI nodes and edges."""
+        logger.debug("Generating network graph")
+        self.dg.clear()
+        for rid in self.cache.list_rids():
+            if type(rid) == KoiNetNode:                
+                self.dg.add_node(rid)
+                logger.debug(f"Added node {rid}")
+                
+            elif type(rid) == KoiNetEdge:
+                edge_profile = self.get_edge_profile(rid)
+                if not edge_profile:
+                    logger.warning(f"Failed to load {rid!r}")
+                    continue
+                self.dg.add_edge(edge_profile.source, edge_profile.target, rid=rid)
+                logger.debug(f"Added edge {rid} ({edge_profile.source} -> {edge_profile.target})")
+        logger.debug("Done")
+        
+    def get_node_profile(self, rid: KoiNetNode) -> NodeProfile | None:
+        """Returns node profile given its RID."""
+        bundle = self.cache.read(rid)
+        if bundle:
+            return bundle.validate_contents(NodeProfile)
+        
+    def get_edge_profile(
+        self, 
+        rid: KoiNetEdge | None = None,
+        source: KoiNetNode | None = None, 
+        target: KoiNetNode | None = None,
+    ) -> EdgeProfile | None:
+        """Returns edge profile given its RID, or source and target node RIDs."""
+        if source and target:
+            if (source, target) not in self.dg.edges: return
+            edge_data = self.dg.get_edge_data(source, target)
+            if not edge_data: return
+            rid = edge_data.get("rid")
+            if not rid: return
+        elif not rid:
+            raise ValueError("Either 'rid' or 'source' and 'target' must be provided")
+        
+        bundle = self.cache.read(rid)
+        if bundle:
+            return bundle.validate_contents(EdgeProfile)
+        
+    def get_edges(
+        self,
+        direction: Literal["in", "out"] | None = None,
+    ) -> list[KoiNetEdge]:
+        """Returns edges this node belongs to.
+        
+        All edges returned by default, specify `direction` to restrict to incoming or outgoing edges only."""
+                
+        edges = []
+        if direction != "in" and self.dg.out_edges:
+            out_edges = self.dg.out_edges(self.identity.rid)
+            edges.extend([e for e in out_edges])
+                
+        if direction != "out" and self.dg.in_edges:
+            in_edges = self.dg.in_edges(self.identity.rid)
+            edges.extend([e for e in in_edges])
+                    
+        edge_rids = []
+        for edge in edges:
+            edge_data = self.dg.get_edge_data(*edge)
+            if not edge_data: continue
+            edge_rid = edge_data.get("rid")
+            if not edge_rid: continue
+            edge_rids.append(edge_rid)
+       
+        return edge_rids
+    
+    def get_neighbors(
+        self,
+        direction: Literal["in", "out"] | None = None,
+        status: EdgeStatus | None = None,
+        allowed_type: RIDType | None = None
+    ) -> list[KoiNetNode]:
+        """Returns neighboring nodes this node shares an edge with.
+        
+        All neighboring nodes returned by default, specify `direction` to restrict to neighbors connected by incoming or outgoing edges only."""
+        
+        neighbors = []
+        for edge_rid in self.get_edges(direction):
+            edge_profile = self.get_edge_profile(edge_rid)
+            
+            if not edge_profile: 
+                logger.warning(f"Failed to find edge {edge_rid!r} in cache")
+                continue
+                        
+            if status and edge_profile.status != status:
+                continue
+            
+            if allowed_type and allowed_type not in edge_profile.rid_types:
+                continue
+            
+            if edge_profile.target == self.identity.rid:
+                neighbors.append(edge_profile.source)
+            elif edge_profile.source == self.identity.rid:
+                neighbors.append(edge_profile.target)
+                
+        return list(neighbors)
+