koi-net 1.0.0b8__py3-none-any.whl → 1.0.0b10__py3-none-any.whl

koi_net/core.py

@@ -84,15 +84,15 @@ class NodeInterface:
             )
         )
         
-        logger.info("Waiting for kobj queue to empty")
+        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.info("Done")
+        logger.debug("Done")
     
         if not self.network.graph.get_neighbors() and self.first_contact:
-            logger.info(f"I don't have any neighbors, reaching out to first contact {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),
@@ -106,7 +106,7 @@ class NodeInterface:
                 )
                 
             except httpx.ConnectError:
-                logger.info("Failed to reach first contact")
+                logger.warning("Failed to reach first contact")
                 return
             
                         
@@ -118,7 +118,7 @@ class NodeInterface:
         logger.info("Stopping node...")
         
         if self.use_kobj_processor_thread:
-            logger.info("Waiting for kobj queue to empty")
+            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()

koi_net/network/graph.py

@@ -25,12 +25,12 @@ class NetworkGraph:
         
     def generate(self):
         """Generates directed graph from cached KOI nodes and edges."""
-        logger.info("Generating network graph")
+        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.info(f"Added node {rid}")
+                logger.debug(f"Added node {rid}")
                 
             elif type(rid) == KoiNetEdge:
                 edge_profile = self.get_edge_profile(rid)
@@ -38,8 +38,8 @@ class NetworkGraph:
                     logger.warning(f"Failed to load {rid!r}")
                     continue
                 self.dg.add_edge(edge_profile.source, edge_profile.target, rid=rid)
-                logger.info(f"Added edge {rid} ({edge_profile.source} -> {edge_profile.target})")
-        logger.info("Done")
+                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."""

koi_net/network/interface.py

@@ -100,7 +100,7 @@ class NetworkInterface:
         
         Event will be sent to webhook or poll queue depending on the node type and edge type of the specified node. If `flush` is set to `True`, the webhook queued will be flushed after pushing the event.
         """
-        logger.info(f"Pushing event {event.event_type} {event.rid} to {node}")
+        logger.debug(f"Pushing event {event.event_type} {event.rid} to {node}")
             
         node_profile = self.graph.get_node_profile(node)
         if not node_profile:
@@ -136,14 +136,14 @@ class NetworkInterface:
         if queue:
             while not queue.empty():
                 event = queue.get()
-                logger.info(f"Dequeued {event.event_type} '{event.rid}'")
+                logger.debug(f"Dequeued {event.event_type} '{event.rid}'")
                 events.append(event)
         
         return events
     
     def flush_poll_queue(self, node: KoiNetNode) -> list[Event]:
         """Flushes a node's poll queue, returning list of events."""
-        logger.info(f"Flushing poll queue for {node}")
+        logger.debug(f"Flushing poll queue for {node}")
         return self._flush_queue(self.poll_event_queue, node)
     
     def flush_webhook_queue(self, node: KoiNetNode):
@@ -152,7 +152,7 @@ class NetworkInterface:
         If node profile is unknown, or node type is not `FULL`, this operation will fail silently. If the remote node cannot be reached, all events will be requeued.
         """
         
-        logger.info(f"Flushing webhook queue for {node}")
+        logger.debug(f"Flushing webhook queue for {node}")
         
         node_profile = self.graph.get_node_profile(node)
         
@@ -167,7 +167,7 @@ class NetworkInterface:
         events = self._flush_queue(self.webhook_event_queue, node)
         if not events: return
         
-        logger.info(f"Broadcasting {len(events)} events")
+        logger.debug(f"Broadcasting {len(events)} events")
         
         try:  
             self.request_handler.broadcast_events(node, events=events)
@@ -179,23 +179,23 @@ class NetworkInterface:
     def get_state_providers(self, rid_type: RIDType) -> list[KoiNetNode]:
         """Returns list of node RIDs which provide state for the specified RID type."""
         
-        logger.info(f"Looking for state providers of '{rid_type}'")
+        logger.debug(f"Looking for state providers of '{rid_type}'")
         provider_nodes = []
         for node_rid in self.cache.list_rids(rid_types=[KoiNetNode]):
             node = self.graph.get_node_profile(node_rid)
                         
             if node.node_type == NodeType.FULL and rid_type in node.provides.state:
-                logger.info(f"Found provider '{node_rid}'")
+                logger.debug(f"Found provider '{node_rid}'")
                 provider_nodes.append(node_rid)
         
         if not provider_nodes:
-            logger.info("Failed to find providers")
+            logger.debug("Failed to find providers")
         return provider_nodes
             
     def fetch_remote_bundle(self, rid: RID):
         """Attempts to fetch a bundle by RID from known peer nodes."""
         
-        logger.info(f"Fetching remote bundle '{rid}'")
+        logger.debug(f"Fetching remote bundle '{rid}'")
         remote_bundle = None
         for node_rid in self.get_state_providers(type(rid)):
             payload = self.request_handler.fetch_bundles(
@@ -203,7 +203,7 @@ class NetworkInterface:
             
             if payload.bundles:
                 remote_bundle = payload.bundles[0]
-                logger.info(f"Got bundle from '{node_rid}'")
+                logger.debug(f"Got bundle from '{node_rid}'")
                 break
         
         if not remote_bundle:
@@ -214,7 +214,7 @@ class NetworkInterface:
     def fetch_remote_manifest(self, rid: RID):
         """Attempts to fetch a manifest by RID from known peer nodes."""
         
-        logger.info(f"Fetching remote manifest '{rid}'")
+        logger.debug(f"Fetching remote manifest '{rid}'")
         remote_manifest = None
         for node_rid in self.get_state_providers(type(rid)):
             payload = self.request_handler.fetch_manifests(
@@ -222,7 +222,7 @@ class NetworkInterface:
             
             if payload.manifests:
                 remote_manifest = payload.manifests[0]
-                logger.info(f"Got bundle from '{node_rid}'")
+                logger.debug(f"Got bundle from '{node_rid}'")
                 break
         
         if not remote_manifest:
@@ -239,17 +239,17 @@ class NetworkInterface:
         neighbors = self.graph.get_neighbors()
         
         if not neighbors and self.first_contact:
-            logger.info("No neighbors found, polling first contact")
+            logger.debug("No neighbors found, polling first contact")
             try:
                 payload = self.request_handler.poll_events(
                     url=self.first_contact, 
                     rid=self.identity.rid
                 )
                 if payload.events:
-                    logger.info(f"Received {len(payload.events)} events from '{self.first_contact}'")
+                    logger.debug(f"Received {len(payload.events)} events from '{self.first_contact}'")
                 return payload.events
             except httpx.ConnectError:
-                logger.info(f"Failed to reach first contact '{self.first_contact}'")
+                logger.debug(f"Failed to reach first contact '{self.first_contact}'")
         
         events = []
         for node_rid in neighbors:
@@ -263,10 +263,10 @@ class NetworkInterface:
                     rid=self.identity.rid
                 )
                 if payload.events:
-                    logger.info(f"Received {len(payload.events)} events from {node_rid!r}")
+                    logger.debug(f"Received {len(payload.events)} events from {node_rid!r}")
                 events.extend(payload.events)
             except httpx.ConnectError:
-                logger.info(f"Failed to reach node '{node_rid}'")
+                logger.debug(f"Failed to reach node '{node_rid}'")
                 continue
             
         return events                

koi_net/network/request_handler.py

@@ -1,6 +1,5 @@
 import logging
 import httpx
-from pydantic import BaseModel
 from rid_lib import RID
 from rid_lib.ext import Cache
 from rid_lib.types.koi_net_node import KoiNetNode
@@ -46,7 +45,7 @@ class RequestHandler:
         request: RequestModels,
         response_model: type[ResponseModels] | None = None
     ) -> ResponseModels | None:
-        logger.info(f"Making request to {url}")
+        logger.debug(f"Making request to {url}")
         resp = httpx.post(
             url=url,
             data=request.model_dump_json()
@@ -66,7 +65,7 @@ class RequestHandler:
                 raise Exception("Node not found")
             if node_profile.node_type != NodeType.FULL:
                 raise Exception("Can't query partial node")
-            logger.info(f"Resolved {node_rid!r} to {node_profile.base_url}")
+            logger.debug(f"Resolved {node_rid!r} to {node_profile.base_url}")
             return node_profile.base_url
         else:
             return url
@@ -79,10 +78,11 @@ class RequestHandler:
         **kwargs
     ) -> None:
         """See protocol.api_models.EventsPayload for available kwargs."""
+        request = req or EventsPayload.model_validate(kwargs)
         self.make_request(
-            self.get_url(node, url) + BROADCAST_EVENTS_PATH,
-            req or EventsPayload.model_validate(kwargs)
+            self.get_url(node, url) + BROADCAST_EVENTS_PATH, request
         )
+        logger.info(f"Broadcasted {len(request.events)} event(s) to {node or url!r}")
         
     def poll_events(
         self, 
@@ -92,12 +92,14 @@ class RequestHandler:
         **kwargs
     ) -> EventsPayload:
         """See protocol.api_models.PollEvents for available kwargs."""
-        return self.make_request(
-            self.get_url(node, url) + POLL_EVENTS_PATH,
-            req or PollEvents.model_validate(kwargs),
+        request = req or PollEvents.model_validate(kwargs)
+        resp = self.make_request(
+            self.get_url(node, url) + POLL_EVENTS_PATH, request,
             response_model=EventsPayload
         )
-            
+        logger.info(f"Polled {len(resp.events)} events from {node or url!r}")
+        return resp
+        
     def fetch_rids(
         self, 
         node: RID = None, 
@@ -106,11 +108,13 @@ class RequestHandler:
         **kwargs
     ) -> RidsPayload:
         """See protocol.api_models.FetchRids for available kwargs."""
-        return self.make_request(
-            self.get_url(node, url) + FETCH_RIDS_PATH,
-            req or FetchRids.model_validate(kwargs),
+        request = req or FetchRids.model_validate(kwargs)
+        resp = self.make_request(
+            self.get_url(node, url) + FETCH_RIDS_PATH, request,
             response_model=RidsPayload
         )
+        logger.info(f"Fetched {len(resp.rids)} RID(s) from {node or url!r}")
+        return resp
                 
     def fetch_manifests(
         self, 
@@ -120,11 +124,13 @@ class RequestHandler:
         **kwargs
     ) -> ManifestsPayload:
         """See protocol.api_models.FetchManifests for available kwargs."""
-        return self.make_request(
-            self.get_url(node, url) + FETCH_MANIFESTS_PATH,
-            req or FetchManifests.model_validate(kwargs),
+        request = req or FetchManifests.model_validate(kwargs)
+        resp = self.make_request(
+            self.get_url(node, url) + FETCH_MANIFESTS_PATH, request,
             response_model=ManifestsPayload
         )
+        logger.info(f"Fetched {len(resp.manifests)} manifest(s) from {node or url!r}")
+        return resp
                 
     def fetch_bundles(
         self, 
@@ -134,8 +140,10 @@ class RequestHandler:
         **kwargs
     ) -> BundlesPayload:
         """See protocol.api_models.FetchBundles for available kwargs."""
-        return self.make_request(
-            self.get_url(node, url) + FETCH_BUNDLES_PATH,
-            req or FetchBundles.model_validate(kwargs),
+        request = req or FetchBundles.model_validate(kwargs)
+        resp = self.make_request(
+            self.get_url(node, url) + FETCH_BUNDLES_PATH, request,
             response_model=BundlesPayload
-        )
+        )
+        logger.info(f"Fetched {len(resp.bundles)} bundle(s) from {node or url!r}")
+        return resp

koi_net/processor/default_handlers.py

@@ -22,24 +22,17 @@ def basic_rid_handler(processor: ProcessorInterface, kobj: KnowledgeObject):
     """
     if (kobj.rid == processor.identity.rid and 
         kobj.source == KnowledgeSource.External):
-        logger.info("Don't let anyone else tell me who I am!")
+        logger.debug("Don't let anyone else tell me who I am!")
         return STOP_CHAIN
     
     if kobj.event_type == EventType.FORGET:
-        if processor.cache.exists(kobj.rid):
-            logger.info("Allowing cache forget")
-            kobj.normalized_event_type = EventType.FORGET
-            return kobj
-        
-        else:
-            # can't forget something I don't know about
-            return STOP_CHAIN
-
+        kobj.normalized_event_type = EventType.FORGET
+        return kobj
 
 # Manifest handlers
 
 @KnowledgeHandler.create(HandlerType.Manifest)
-def basic_state_handler(processor: ProcessorInterface, kobj: KnowledgeObject):
+def basic_manifest_handler(processor: ProcessorInterface, kobj: KnowledgeObject):
     """Default manifest handler.
     
     Blocks manifests with the same hash, or aren't newer than the cached version. Sets the normalized event type to `NEW` or `UPDATE` depending on whether the RID was previously known to this node.
@@ -48,17 +41,17 @@ def basic_state_handler(processor: ProcessorInterface, kobj: KnowledgeObject):
 
     if prev_bundle:
         if kobj.manifest.sha256_hash == prev_bundle.manifest.sha256_hash:
-            logger.info("Hash of incoming manifest is same as existing knowledge, ignoring")
+            logger.debug("Hash of incoming manifest is same as existing knowledge, ignoring")
             return STOP_CHAIN
         if kobj.manifest.timestamp <= prev_bundle.manifest.timestamp:
-            logger.info("Timestamp of incoming manifest is the same or older than existing knowledge, ignoring")
+            logger.debug("Timestamp of incoming manifest is the same or older than existing knowledge, ignoring")
             return STOP_CHAIN
         
-        logger.info("RID previously known to me, labeling as 'UPDATE'")
+        logger.debug("RID previously known to me, labeling as 'UPDATE'")
         kobj.normalized_event_type = EventType.UPDATE
 
     else:
-        logger.info("RID previously unknown to me, labeling as 'NEW'")
+        logger.debug("RID previously unknown to me, labeling as 'NEW'")
         kobj.normalized_event_type = EventType.NEW
         
     return kobj
@@ -66,7 +59,11 @@ def basic_state_handler(processor: ProcessorInterface, kobj: KnowledgeObject):
 
 # Bundle handlers
 
-@KnowledgeHandler.create(HandlerType.Bundle, rid_types=[KoiNetEdge])
+@KnowledgeHandler.create(
+    handler_type=HandlerType.Bundle, 
+    rid_types=[KoiNetEdge], 
+    source=KnowledgeSource.External,
+    event_types=[EventType.NEW, EventType.UPDATE])
 def edge_negotiation_handler(processor: ProcessorInterface, kobj: KnowledgeObject):
     """Handles basic edge negotiation process.
     
@@ -74,17 +71,13 @@ def edge_negotiation_handler(processor: ProcessorInterface, kobj: KnowledgeObjec
     """
     
     edge_profile = EdgeProfile.model_validate(kobj.contents)
-    
-    # only want to handle external knowledge events (not edges this node created)
-    if kobj.source != KnowledgeSource.External:
-        return
 
     # indicates peer subscribing to me
     if edge_profile.source == processor.identity.rid:     
         if edge_profile.status != EdgeStatus.PROPOSED:
             return
         
-        logger.info("Handling edge negotiation")
+        logger.debug("Handling edge negotiation")
         
         peer_rid = edge_profile.target
         peer_profile = processor.network.graph.get_node_profile(peer_rid)
@@ -103,11 +96,11 @@ def edge_negotiation_handler(processor: ProcessorInterface, kobj: KnowledgeObjec
         abort = False
         if (edge_profile.edge_type == EdgeType.WEBHOOK and 
             peer_profile.node_type == NodeType.PARTIAL):
-            logger.info("Partial nodes cannot use webhooks")
+            logger.debug("Partial nodes cannot use webhooks")
             abort = True
         
         if not set(edge_profile.rid_types).issubset(provided_events):
-            logger.info("Requested RID types not provided by this node")
+            logger.debug("Requested RID types not provided by this node")
             abort = True
         
         if abort:
@@ -117,16 +110,16 @@ def edge_negotiation_handler(processor: ProcessorInterface, kobj: KnowledgeObjec
 
         else:
             # approve edge profile
-            logger.info("Approving proposed edge")
+            logger.debug("Approving proposed edge")
             edge_profile.status = EdgeStatus.APPROVED
             updated_bundle = Bundle.generate(kobj.rid, edge_profile.model_dump())
       
-            processor.handle(bundle=updated_bundle)
+            processor.handle(bundle=updated_bundle, event_type=EventType.UPDATE)
             return
               
     elif edge_profile.target == processor.identity.rid:
         if edge_profile.status == EdgeStatus.APPROVED:
-            logger.info("Edge approved by other node!")
+            logger.debug("Edge approved by other node!")
 
 
 # Network handlers
@@ -147,12 +140,12 @@ def basic_network_output_filter(processor: ProcessorInterface, kobj: KnowledgeOb
             edge_profile = kobj.bundle.validate_contents(EdgeProfile)
             
             if edge_profile.source == processor.identity.rid:
-                logger.info(f"Adding edge target '{edge_profile.target!r}' to network targets")
+                logger.debug(f"Adding edge target '{edge_profile.target!r}' to network targets")
                 kobj.network_targets.update([edge_profile.target])
                 involves_me = True
                 
             elif edge_profile.target == processor.identity.rid:
-                logger.info(f"Adding edge source '{edge_profile.source!r}' to network targets")
+                logger.debug(f"Adding edge source '{edge_profile.source!r}' to network targets")
                 kobj.network_targets.update([edge_profile.source])
                 involves_me = True
     
@@ -163,7 +156,7 @@ def basic_network_output_filter(processor: ProcessorInterface, kobj: KnowledgeOb
             allowed_type=type(kobj.rid)
         )
         
-        logger.info(f"Updating network targets with '{type(kobj.rid)}' subscribers: {subscribers}")
+        logger.debug(f"Updating network targets with '{type(kobj.rid)}' subscribers: {subscribers}")
         kobj.network_targets.update(subscribers)
         
     return kobj

koi_net/processor/handler.py

@@ -3,6 +3,9 @@ from enum import StrEnum
 from typing import Callable
 from rid_lib import RIDType
 
+from ..protocol.event import EventType
+from .knowledge_object import KnowledgeSource, KnowledgeEventType
+
 
 class StopChain:
     """Class for a sentinel value by knowledge handlers."""
@@ -34,19 +37,23 @@ class KnowledgeHandler:
     func: Callable
     handler_type: HandlerType
     rid_types: list[RIDType] | None
+    source: KnowledgeSource | None = None
+    event_types: list[KnowledgeEventType] | None = None
     
     @classmethod
     def create(
         cls,
         handler_type: HandlerType,
-        rid_types: list[RIDType] | None = None
+        rid_types: list[RIDType] | None = None,
+        source: KnowledgeSource | None = None,
+        event_types: list[KnowledgeEventType] | None = None
     ):
         """Special decorator that returns a KnowledgeHandler instead of a function.
         
         The function symbol will redefined as a `KnowledgeHandler`, which can be passed into the `ProcessorInterface` constructor. This is used to register default handlers.
         """
         def decorator(func: Callable) -> KnowledgeHandler:
-            handler = cls(func, handler_type, rid_types)
+            handler = cls(func, handler_type, rid_types, source, event_types)
             return handler
         return decorator
 

koi_net/processor/interface.py

@@ -62,11 +62,13 @@ class ProcessorInterface:
     def register_handler(
         self,
         handler_type: HandlerType,
-        rid_types: list[RIDType] | None = None
+        rid_types: list[RIDType] | None = None,
+        source: KnowledgeSource | None = None,
+        event_types: list[KnowledgeEventType] | None = None
     ):
         """Assigns decorated function as handler for this processor."""
         def decorator(func: Callable) -> Callable:
-            handler = KnowledgeHandler(func, handler_type, rid_types)
+            handler = KnowledgeHandler(func, handler_type, rid_types, source, event_types)
             self.add_handler(handler)
             return func
         return decorator
@@ -93,12 +95,18 @@ class ProcessorInterface:
             if handler.rid_types and type(kobj.rid) not in handler.rid_types:
                 continue
             
-            logger.info(f"Calling {handler_type} handler '{handler.func.__name__}'")
+            if handler.source and handler.source != kobj.source:
+                continue
+            
+            if handler.event_types and kobj.event_type not in handler.event_types:
+                continue
+            
+            logger.debug(f"Calling {handler_type} handler '{handler.func.__name__}'")
             resp = handler.func(self, kobj.model_copy())
             
             # stops handler chain execution
             if resp is STOP_CHAIN:
-                logger.info(f"Handler chain stopped by {handler.func.__name__}")
+                logger.debug(f"Handler chain stopped by {handler.func.__name__}")
                 return STOP_CHAIN
             # kobj unmodified
             elif resp is None:
@@ -106,7 +114,7 @@ class ProcessorInterface:
             # kobj modified by handler
             elif isinstance(resp, KnowledgeObject):
                 kobj = resp
-                logger.info(f"Knowledge object modified by {handler.func.__name__}")
+                logger.debug(f"Knowledge object modified by {handler.func.__name__}")
             else:
                 raise ValueError(f"Handler {handler.func.__name__} returned invalid response '{resp}'")
                     
@@ -126,34 +134,41 @@ class ProcessorInterface:
         The pipeline may be stopped by any point by a single handler returning the `STOP_CHAIN` sentinel. In that case, the process will exit immediately. Further handlers of that type and later handler chains will not be called.
         """
         
-        logger.info(f"Handling {kobj!r}")
+        logger.debug(f"Handling {kobj!r}")
         kobj = self.call_handler_chain(HandlerType.RID, kobj)
         if kobj is STOP_CHAIN: return
         
         if kobj.event_type == EventType.FORGET:
             bundle = self.cache.read(kobj.rid)
             if not bundle: 
-                logger.info("Local bundle not found")
+                logger.debug("Local bundle not found")
                 return
             
             # the bundle (to be deleted) attached to kobj for downstream analysis
-            logger.info("Adding local bundle (to be deleted) to knowledge object")
+            logger.debug("Adding local bundle (to be deleted) to knowledge object")
             kobj.manifest = bundle.manifest
             kobj.contents = bundle.contents
             
         else:
             # attempt to retrieve manifest
             if not kobj.manifest:
+                logger.debug("Manifest not found")
                 if kobj.source == KnowledgeSource.External:
-                    logger.info("Manifest not found, attempting to fetch remotely")
+                    logger.debug("Attempting to fetch remote manifest")
                     manifest = self.network.fetch_remote_manifest(kobj.rid)
-                    if not manifest: return
                     
                 elif kobj.source == KnowledgeSource.Internal:
-                    logger.info("Manifest not found, attempting to read cache")
+                    logger.debug("Attempting to read manifest from cache")
                     bundle = self.cache.read(kobj.rid)
-                    if not bundle: return
-                    manifest = bundle.manifest
+                    if bundle: 
+                        manifest = bundle.manifest
+                    else:
+                        manifest = None
+                        return
+                    
+                if not manifest:
+                    logger.debug("Failed to find manifest")
+                    return
                 
                 kobj.manifest = manifest
                 
@@ -162,48 +177,51 @@ class ProcessorInterface:
             
             # attempt to retrieve bundle
             if not kobj.bundle:
+                logger.debug("Bundle not found")
                 if kobj.source == KnowledgeSource.External:
-                    logger.info("Bundle not found, attempting to fetch")
+                    logger.debug("Attempting to fetch remote bundle")
                     bundle = self.network.fetch_remote_bundle(kobj.rid)
-                    # TODO: WARNING MANIFEST MAY BE DIFFERENT
                     
                 elif kobj.source == KnowledgeSource.Internal:
-                    logger.info("Bundle not found, attempting to read cache")
+                    logger.debug("Attempting to read bundle from cache")
                     bundle = self.cache.read(kobj.rid)
                 
                 if kobj.manifest != bundle.manifest:
                     logger.warning("Retrieved bundle contains a different manifest")
                 
-                if not bundle: return
+                if not bundle: 
+                    logger.debug("Failed to find bundle")
+                    return
+                
                 kobj.manifest = bundle.manifest
                 kobj.contents = bundle.contents                
                 
-            kobj = self.call_handler_chain(HandlerType.Bundle, kobj)
-            if kobj is STOP_CHAIN: return
+        kobj = self.call_handler_chain(HandlerType.Bundle, kobj)
+        if kobj is STOP_CHAIN: return
             
         if kobj.normalized_event_type in (EventType.UPDATE, EventType.NEW):
-            logger.info(f"Writing {kobj!r} to cache")
+            logger.info(f"Writing to cache: {kobj!r}")
             self.cache.write(kobj.bundle)
             
         elif kobj.normalized_event_type == EventType.FORGET:
-            logger.info(f"Deleting {kobj!r} from cache")
+            logger.info(f"Deleting from cache: {kobj!r}")
             self.cache.delete(kobj.rid)
             
         else:
-            logger.info("Normalized event type was never set, no cache or network operations will occur")
+            logger.debug("Normalized event type was never set, no cache or network operations will occur")
             return
         
         if type(kobj.rid) in (KoiNetNode, KoiNetEdge):
-            logger.info("Change to node or edge, regenerating network graph")
+            logger.debug("Change to node or edge, regenerating network graph")
             self.network.graph.generate()
         
         kobj = self.call_handler_chain(HandlerType.Network, kobj)
         if kobj is STOP_CHAIN: return
         
         if kobj.network_targets:
-            logger.info(f"Broadcasting event to {len(kobj.network_targets)} network target(s)")
+            logger.debug(f"Broadcasting event to {len(kobj.network_targets)} network target(s)")
         else:
-            logger.info("No network targets set")
+            logger.debug("No network targets set")
         
         for node in kobj.network_targets:
             self.network.push_event_to(kobj.normalized_event, node, flush=True)
@@ -220,18 +238,25 @@ class ProcessorInterface:
         
         while not self.kobj_queue.empty():
             kobj = self.kobj_queue.get()
-            logger.info(f"Dequeued {kobj!r}")
-            self.process_kobj(kobj)
-            self.kobj_queue.task_done()
-            logger.info("Done handling")
+            logger.debug(f"Dequeued {kobj!r}")
+            
+            try:
+                self.process_kobj(kobj)
+            finally:
+                self.kobj_queue.task_done()
+            logger.debug("Done")
     
     def kobj_processor_worker(self, timeout=0.1):
         while True:
             try:
                 kobj = self.kobj_queue.get(timeout=timeout)
-                logger.info(f"Dequeued {kobj!r}")
-                self.process_kobj(kobj)
-                self.kobj_queue.task_done()
+                logger.debug(f"Dequeued {kobj!r}")
+                
+                try:
+                    self.process_kobj(kobj)
+                finally:
+                    self.kobj_queue.task_done()
+                logger.debug("Done")
             
             except queue.Empty:
                 pass
@@ -267,4 +292,4 @@ class ProcessorInterface:
             raise ValueError("One of 'rid', 'manifest', 'bundle', 'event', or 'kobj' must be provided")
         
         self.kobj_queue.put(_kobj)
-        logger.info(f"Queued {_kobj!r}")
+        logger.debug(f"Queued {_kobj!r}")

koi_net/processor/knowledge_object.py

@@ -35,7 +35,7 @@ class KnowledgeObject(BaseModel):
     network_targets: set[KoiNetNode] = set()
     
     def __repr__(self):
-        return f"<Knowledge Object '{self.rid}' ({self.event_type}) -> ({self.normalized_event_type})>"
+        return f"<KObj '{self.rid}' event type: '{self.event_type}' -> '{self.normalized_event_type}', source: '{self.source}'>"
     
     @classmethod
     def from_rid(

koi_net/protocol/event.py

@@ -15,6 +15,9 @@ class Event(BaseModel):
     manifest: Manifest | None = None
     contents: dict | None = None
     
+    def __repr__(self):
+        return f"<Event '{self.rid}' event type: '{self.event_type}'>"
+    
     @classmethod
     def from_bundle(cls, event_type: EventType, bundle: Bundle):
         return cls(

{koi_net-1.0.0b8.dist-info → koi_net-1.0.0b10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: koi-net
-Version: 1.0.0b8
+Version: 1.0.0b10
 Summary: Implementation of KOI-net protocol in Python
 Project-URL: Homepage, https://github.com/BlockScience/koi-net/
 Author-email: Luke Miller <luke@block.science>
@@ -44,6 +44,37 @@ Description-Content-Type: text/markdown
 
 *This specification is the result of several iterations of KOI research, [read more here](https://github.com/BlockScience/koi).*
 
+### Jump to Sections: 
+- [Protocol](#protocol)
+    - [Introduction](#introduction)
+    - [Communication Methods](#communication-methods)
+- [Quickstart](#quickstart)
+    - [Setup](#setup)
+    - [Creating a Node](#creating-a-node)
+    - [Knowledge Processing](#knowledge-processing)
+    - [Try It Out!](#try-it-out)
+- [Advanced](#advanced)
+    - [Knowledge Processing Pipeline](#knowledge-processing-pipeline)
+    - [Knowledge Handlers](#knowledge-handlers)
+        - [RID Handler](#rid-handler)
+        - [Manifest Handler](#manifest-handler)
+        - [Bundle Handler](#bundle-handler)
+        - [Network Handler](#network-handler)
+        - [Final Handler](#final-handler)
+    - [Registering Handlers](#registering-handlers)
+    - [Default Behavior](#default-behavior)
+- [Implementation Reference](#implementation-reference)
+    - [Node Interface](#node-interface)
+    - [Node Identity](#node-identity)
+    - [Network Interface](#network-interface)
+        - [Network Graph](#network-graph)
+        - [Request Handler](#request-handler)
+        - [Response Handler](#response-handler)
+    - [Processor Interface](#processor-interface)
+- [Development](#development)
+    - [Setup](#setup-1)
+    - [Distribution](#distribution)
+
 # Protocol
 ## Introduction
 
@@ -87,10 +118,10 @@ The request and payload JSON objects are composed of the fundamental "knowledge
 }
 ```
 
-This means that events are essentially just an RID, manifest, or bundle with an event type attached. Event types can be one of `FORGET`, `UPDATE`, or `NEW` forming the "FUN" acronym. While these types roughly correspond to delete, update, and create from CRUD operations, but they are not commands, they are signals. A node emits an event to indicate that its internal state has changed:
-- `NEW` - indicates an previously unknown RID was cached
-- `UPDATE` - indicates a previously known RID was cached
-- `FORGET` - indicates a previously known RID was deleted
+This means that events are essentially just an RID, manifest, or bundle with an event type attached. Event types can be one of `"FORGET"`, `"UPDATE"`, or `"NEW"` forming the "FUN" acronym. While these types roughly correspond to delete, update, and create from CRUD operations, but they are not commands, they are signals. A node emits an event to indicate that its internal state has changed:
+- `"NEW"` - indicates an previously unknown RID was cached
+- `"UPDATE"` - indicates a previously known RID was cached
+- `"FORGET"` - indicates a previously known RID was deleted
 
 Nodes may broadcast events to other nodes to indicate their internal state changed. Conversely, nodes may also listen to events from other nodes and as a result decide to change their internal state, take some other action, or do nothing.
 
@@ -149,12 +180,14 @@ node = NodeInterface(
 )
 ```
 
+When creating a node, you optionally enable `use_kobj_processor_thread` which will run the knowledge processing pipeline on a separate thread. This thread will automatically dequeue and process knowledge objects as they are added to the `kobj_queue`, which happenes when you call `node.process.handle(...)`. This is required to prevent race conditions in asynchronous applications, like web servers, therefore it is recommended to enable this feature for all full nodes. 
+
 ## Knowledge Processing
 
 Next we'll set up the knowledge processing flow for our node. This is where most of the node's logic and behavior will come into play. For partial nodes this will be an event loop, and for full nodes we will use webhooks. Make sure to call `node.start()` and `node.stop()` at the beginning and end of your node's life cycle.
 
 ### Partial Node
-Make sure to set `source=KnowledgeSource.External`, this indicates to the knowledge processing pipeline that the incoming knowledge was received from an external source. Where the knowledge is sourced from will impact decisions in the node's knowledge handlers.
+Make sure to set `source=KnowledgeSource.External` when calling `handle` on external knowledge, this indicates to the knowledge processing pipeline that the incoming knowledge was received from another node. Where the knowledge is sourced from will impact decisions in the node's knowledge handlers.
 ```python
 import time
 from koi_net.processor.knowledge_object import KnowledgeSource
@@ -252,6 +285,147 @@ python -m examples.basic_coordinator_node
 python -m examples.basic_partial_node
 ```
 
+# Advanced
+
+## Knowledge Processing Pipeline
+Beyond the `NodeInterface` setup and boiler plate for partial/full nodes, node behavior is mostly controlled through the use of knowledge handlers. Effectively creating your own handlers relies on a solid understanding of the knowledge processing pipeline, so we'll start with that. As a developer, you will interface with the pipeline through the `ProcessorInterface` accessed with `node.processor`. The pipeline handles knowledge objects, from the `KnowledgeObject` class, a container for all knowledge types in the RID / KOI-net ecosystem:
+- RIDs
+- Manifests
+- Bundles
+- Events
+
+Here is the class definition for a knowledge object:
+```python
+type KnowledgeEventType = EventType | None
+
+class KnowledgeSource(StrEnum):
+    Internal = "INTERNAL"
+    External = "EXTERNAL"
+
+class KnowledgeObject(BaseModel):
+    rid: RID
+    manifest: Manifest | None = None
+    contents: dict | None = None
+    event_type: KnowledgeEventType = None
+    source: KnowledgeSource
+    normalized_event_type: KnowledgeEventType = None
+    network_targets: set[KoiNetNode] = set()
+```
+
+In addition to the fields required to represent the knowledge types (`rid`, `manifest`, `contents`, `event_type`), knowledge objects also include a `source` field, indicating whether the knowledge originated from within the node (`KnowledgeSource.Internal`) or from another node (`KnowledgeSource.External`).
+
+The final two fields are not inputs, but are set by handlers as the knowledge object moves through the processing pipeline. The normalized event type indicates the event type normalized to the perspective of the node's cache, and the network targets indicate where the resulting event should be broadcasted to.
+
+Knowledge objects enter the processing pipeline through the `node.processor.handle(...)` method. Using kwargs you can pass any of the knowledge types listed above, a knowledge source, and an optional `event_type` (for non-event knowledge types). The handle function will simply normalize the provided knowledge type into a knowledge object, and put it in the `kobj_queue`, an internal, thread-safe queue of knowledge objects. If you have enabled `use_kobj_processor_thread` then the queue will be automatically processed on the processor thread, otherwise you will need to regularly call `flush_kobj_queue` to process queued knowledge objects (as in the partial node example). Both methods will process knowledge objects sequentially, in the order that they were queued in (FIFO). 
+
+
+## Knowledge Handlers
+
+Processing happens through five distinct phases, corresponding to the handler types: `RID`, `Manifest`, `Bundle`, `Network`, and `Final`. Each handler type can be understood by describing (1) what knowledge object fields are available to the handler, and (2) what action takes place after this phase, which the handler can influence. As knowledge objects pass through the pipeline, fields may be added or updated. 
+
+Handlers are registered in a single handler array within the processor. There is no limit to the number of handlers in use, and multiple handlers can be assigned to the same handler type. At each phase of knowledge processing, we will chain together all of the handlers of the corresponding type and run them in their array order. The order handlers are registered in matters!
+
+Each handler will be passed a knowledge object. They can choose to return one of three types: `None`, `KnowledgeObject`, or `STOP_CHAIN`. Returning `None` will pass the unmodified knowledge object (the same one the handler received) to the next handler in the chain. If a handler modified their knowledge object, they should return it to pass the new version to the next handler. Finally, a handler can return `STOP_CHAIN` to immediately stop processing the knowledge object. No further handlers will be called and it will not enter the next phase of processing.
+
+Summary of processing pipeline:
+```
+RID -> Manifest -> Bundle -> [cache action] -> Network -> [network action] -> Final
+           |
+(skip if event type is "FORGET")
+```
+
+### RID Handler
+The knowledge object passed to handlers of this type are guaranteed to have an RID and knowledge source field. This handler type acts as a filter, if none of the handlers return `STOP_CHAIN` the pipeline will progress to the next phase. The pipeline diverges slightly after this handler chain, based on the event type of the knowledge object.
+
+If the event type is `"NEW"`, `"UPDATE"`, or `None` and the manifest is not already in the knowledge object, the node will attempt to retrieve it from (1) the local cache if the source is internal, or (2) from another node if the source is external. If it fails to retrieves the manifest, the pipeline will end. Next, the manifest handler chain will be called.
+
+If the event type is `"FORGET"`, and the bundle (manifest + contents) is not already in the knowledge object, the node will attempt to retrieve it from the local cache, regardless of the source. In this case the knowledge object represents what we will delete from the cache, not new incoming knowledge. If it fails to retrieve the bundle, the pipeline will end. Next, the bundle handler chain will be called.
+
+### Manifest Handler
+The knowledge object passed to handlers of this type are guaranteed to have an RID, manifest, and knowledge source field. This handler type acts as a filter, if none of the handlers return `STOP_CHAIN` the pipeline will progress to the next phase.
+
+If the bundle (manifest + contents) is not already in the knowledge object, the node will attempt to retrieve it from (1) the local cache if the source is internal, or (2) from another node if the source is external. If it fails to retrieve the bundle, the pipeline will end. Next, the bundle handler chain will be called.
+
+### Bundle Handler
+The knowledge object passed to handlers of this type are guaranteed to have an RID, manifest, bundle (manifest + contents), and knowledge source field. This handler type acts as a decider. In this phase, the knowledge object's normalized event type must be set to `"NEW"` or `"UPDATE"` to write it to cache, or `"FORGET"` to delete it from the cache. If the normalized event type remains unset (`None`), or a handler returns `STOP_CHAIN`, then the pipeline will end without taking any cache action.
+
+The cache action will take place after the handler chain ends, so if multiple handlers set a normalized event type, the final handler will take precedence.
+
+### Network Handler
+The knowledge object passed to handlers of this type are guaranteed to have an RID, manifest, bundle (manifest + contents), normalized event type, and knowledge source field. This handler type acts as a decider. In this phase, handlers decide which nodes to broadcast this knowledge object to by appending KOI-net node RIDs to the knowledge object's `network_targets` field. If a handler returns `STOP_CHAIN`, the pipeline will end without taking any network action.
+
+The network action will take place after the handler chain ends. The node will attempt to broadcast a "normalized event", created from the knowledge object's RID, bundle, and normalized event type, to all of the node's in the network targets array. 
+
+### Final Handler
+The knowledge object passed to handlers of this type are guaranteed to have an RID, manifest, bundle (manifest + contents), normalized event type, and knowledge source field.
+
+This is the final handler chain that is called, it doesn't make any decisions or filter for succesive handler types. Handlers here can be useful if you want to take some action after the network broadcast has ended.
+
+## Registering Handlers
+Knowledge handlers are registered with a node's processor by decorating a handler function. There are two types of decorators, the first way converts the function into a handler object which can be manually added to a processor. This is how the default handlers are defined, and makes them more portable (could be imported from another package). The second automatically registers a handler with your node instance. This is not portable but more convenient. The input of the decorated function will be the processor instance, and a knowledge object.
+
+```python
+from .handler import KnowledgeHandler, HandlerType, STOP_CHAIN
+
+@KnowledgeHandler.create(HandlerType.RID)
+def example_handler(processor: ProcessorInterface, kobj: KnowledgeObject):
+    ...
+
+@node.processor.register_handler(HandlerType.RID)
+def example_handler(processor: ProcessorInterface, kobj: KnowledgeObject):
+    ...
+```
+
+While handler's only require specifying the handler type, you can also specify the RID types, knowledge source, or event types you want to handle. If a knowledge object doesn't match all of the specified parameters, it won't be called. By default, handlers will match all RID types, all event types, and both internal and external sourced knowledge.
+
+```python
+@KnowledgeHandler.create(
+    handler_type=HandlerType.Bundle, 
+    rid_types=[KoiNetEdge], 
+    source=KnowledgeSource.External,
+    event_types=[EventType.NEW, EventType.UPDATE])
+def edge_negotiation_handler(processor: ProcessorInterface, kobj: KnowledgeObject):
+    ...
+```
+
+The processor instance passed to your function should be used to take any necessary node actions (cache, network, etc.). It is also sometimes useful to add new knowledge objects to the queue while processing a different knowledge object. You can simply call `processor.handle(...)` in the same way as you would outside of a handler. It will put at the end of the queue and processed when it is dequeued like any other knowledge object.
+
+
+## Default Behavior
+
+The default configuration provides four default handlers which will take precedence over any handlers you add yourself. To override this behavior, you can set the `handlers` field in the `NodeInterface`:
+
+```python
+from koi_net import NodeInterface
+from koi_net.protocol.node import NodeProfile, NodeProvides, NodeType
+from koi_net.processor.default_handlers import (
+    basic_rid_handler,
+    basic_manifest_handler,
+    edge_negotiation_handler,
+    basic_network_output_filter
+)
+
+node = NodeInterface(
+    name="mypartialnode",
+    profile=NodeProfile(
+        node_type=NodeType.PARTIAL,
+        provides=NodeProvides(
+            event=[]
+        )
+    ),
+    handlers=[
+        basic_rid_handler,
+        basic_manifest_handler,
+        edge_negotiation_handler,
+        basic_network_output_filter
+
+        # include all or none of the default handlers
+    ]
+)
+```
+
+Take a look at `src/koi_net/processor/default_handlers.py` to see some more in depth examples and better understand the default node behavior.
+
 # Implementation Reference
 This section provides high level explanations of the Python implementation. More detailed explanations of methods can be found in the docstrings within the codebase itself.
 
@@ -464,14 +638,13 @@ class ProcessorInterface:
         event: Event | None = None,
         kobj: KnowledgeObject | None = None,
         event_type: KnowledgeEventType = None,
-        source: KnowledgeSource = KnowledgeSource.Internal,
-        flush: bool = False
+        source: KnowledgeSource = KnowledgeSource.Internal
     ): ...
 ```
 
 The `register_handler` method is a decorator which can wrap a function to create a new `KnowledgeHandler` and add it to the processing pipeline in a single step. The `add_handler` method adds an existing `KnowledgeHandler` to the processining pipeline.
 
-The most commonly used functions in this class are `handle` and `flush_kobj_queue`. The `handle` method can be called on RIDs, manifests, bundles, and events to convert them to normalized to `KnowledgeObject` instances which are then added to the processing queue. The `flush` flag can be set to `True` to immediately start processing, or `flush_kobj_queue` can be called after queueing multiple knowledge objects. When calling the `handle` method, knowledge objects are marked as internally source by default. If you are handling RIDs, manifests, bundles, or events sourced from other nodes, `source` should be set to `KnowledgeSource.External`.
+The most commonly used functions in this class are `handle` and `flush_kobj_queue`. The `handle` method can be called on RIDs, manifests, bundles, and events to convert them to normalized to `KnowledgeObject` instances which are then added to the processing queue. If you have enabled `use_kobj_processor_thread` then the queue will be automatically processed, otherwise you will need to regularly call `flush_kobj_queue` to process queued knolwedge objects. When calling the `handle` method, knowledge objects are marked as internally source by default. If you are handling RIDs, manifests, bundles, or events sourced from other nodes, `source` should be set to `KnowledgeSource.External`.
 
 Here is an example of how an event polling loop would be implemented using the knowledge processing pipeline:
 ```python
@@ -511,5 +684,5 @@ python -m build
 ```
 Push new package build to PyPI:
 ```shell
-python -m twine upload dist/*
+python -m twine upload --skip-existing dist/*
 ```

koi_net-1.0.0b10.dist-info/RECORD

@@ -0,0 +1,24 @@
+koi_net/__init__.py,sha256=b0Ze0pZmJAuygpWUFHM6Kvqo3DkU_uzmkptv1EpAArw,31
+koi_net/core.py,sha256=9Paw7GTf3JeE8X73fGgi9K2uoT2A20Ft4m_gA9xAepI,4683
+koi_net/identity.py,sha256=PBgmAx5f3zzQmHASB1TJW2g19n9TLfmSJMXg2eQFg0A,2386
+koi_net/network/__init__.py,sha256=r_RN-q_mDYC-2RAkN-lJoMUX76TXyfEUc_MVKW87z0g,39
+koi_net/network/graph.py,sha256=KyS4Vv94DhHQk12u6rmE8nOIuTxeoJjrnoYEwVMNM74,4837
+koi_net/network/interface.py,sha256=8zO2qBYmyd-MyAX-8RAf1mjL_0fn08-IbVOKHCAwNf8,10660
+koi_net/network/request_handler.py,sha256=dufyJRwKD5w578UM-wzFVT3EU78NMvrh_yNSiI7vgfw,4938
+koi_net/network/response_handler.py,sha256=HaP8Fl0bp_lfMmevhdVY8s9o0Uf8CR1ZaW5g3jsX8gw,1888
+koi_net/processor/__init__.py,sha256=x4fAY0hvQEDcpfdTB3POIzxBQjYAtn0qQazPo1Xm0m4,41
+koi_net/processor/default_handlers.py,sha256=ebFJ_MqvGBAb0SxmreZ9Pvyi0tD7ygDvJKECglw8uAQ,6972
+koi_net/processor/handler.py,sha256=a2wxG3kgux-07YP13HSj_PH5VH_PjbnTS4uZEHjxMw0,2582
+koi_net/processor/interface.py,sha256=8DT7-FFWj2vh-DXtuI9NXicOTSozaMSDTziMC2RMwuQ,13010
+koi_net/processor/knowledge_object.py,sha256=xI1K4lIGJrWbb7yStjpU4eqZGI7t4wFklv72V7TRfXY,4212
+koi_net/protocol/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+koi_net/protocol/api_models.py,sha256=RDwVHAahiWzwzUnlj5MIm9et5WVpQOaG-Uscv1B9coU,1116
+koi_net/protocol/consts.py,sha256=zeWJvRpqcERrqJq39heyNHb6f_9QrvoBZJHd70yE914,249
+koi_net/protocol/edge.py,sha256=G3D9Ie0vbTSMJdoTw9g_oBmFCqzJ1gO7U1PVrw7p3j8,447
+koi_net/protocol/event.py,sha256=YHsLD9HPwib-HiCWv9ep0sPqL2VHQqx_egDmbriChXM,1378
+koi_net/protocol/helpers.py,sha256=9E9PaoIuSNrTBATGCLJ_kSBMZ2z-KIMnLJzGOTqQDC0,719
+koi_net/protocol/node.py,sha256=Ntrx01dbm39ViKGtr4gLmztcMwKpTIweS6rRL-zoU_Y,391
+koi_net-1.0.0b10.dist-info/METADATA,sha256=eQtnFOOH0wpuPMaASpOJJieHhEUadPvVcZ7XdQw0Jh8,33783
+koi_net-1.0.0b10.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+koi_net-1.0.0b10.dist-info/licenses/LICENSE,sha256=XBcvl8yjCAezfuqN1jadQykrX7H2g4nr2WRDmHLW6ik,1090
+koi_net-1.0.0b10.dist-info/RECORD,,

koi_net-1.0.0b8.dist-info/RECORD

@@ -1,24 +0,0 @@
-koi_net/__init__.py,sha256=b0Ze0pZmJAuygpWUFHM6Kvqo3DkU_uzmkptv1EpAArw,31
-koi_net/core.py,sha256=dE4sE2qsoIRUU1zsnrjx7aqYtYdHyCx-Dv4cwbkRjy4,4613
-koi_net/identity.py,sha256=PBgmAx5f3zzQmHASB1TJW2g19n9TLfmSJMXg2eQFg0A,2386
-koi_net/network/__init__.py,sha256=r_RN-q_mDYC-2RAkN-lJoMUX76TXyfEUc_MVKW87z0g,39
-koi_net/network/graph.py,sha256=KMUCU3AweRvivwy7GuWgX2zX74FPgHeVMO5ydvhVyvA,4833
-koi_net/network/interface.py,sha256=4JTeg8Eah0z5YKhcVKJbCVZw_Ghl_6xfG8aa1I5PCWI,10643
-koi_net/network/request_handler.py,sha256=fhuCDsxI8fZ4p5TntcTZR4mnLrLQ61zDy7Oca3ooFCE,4402
-koi_net/network/response_handler.py,sha256=HaP8Fl0bp_lfMmevhdVY8s9o0Uf8CR1ZaW5g3jsX8gw,1888
-koi_net/processor/__init__.py,sha256=x4fAY0hvQEDcpfdTB3POIzxBQjYAtn0qQazPo1Xm0m4,41
-koi_net/processor/default_handlers.py,sha256=Yc7a9n5sAOYMHzzY59VMXYOxQL-6O9zbMQzd61XbIEs,7184
-koi_net/processor/handler.py,sha256=APCECwU7MFcgP7Vu6UTngs0XIjaXSQ_f8rqy8cH5_rM,2242
-koi_net/processor/interface.py,sha256=szLLeDfMgeqU35F2na-LvzytJ0irpCtR9g0empo4JoI,12169
-koi_net/processor/knowledge_object.py,sha256=cGv33fwNZQMylkhlTaQTbk96FVIVbdOUaBsG06u0m4k,4187
-koi_net/protocol/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-koi_net/protocol/api_models.py,sha256=RDwVHAahiWzwzUnlj5MIm9et5WVpQOaG-Uscv1B9coU,1116
-koi_net/protocol/consts.py,sha256=zeWJvRpqcERrqJq39heyNHb6f_9QrvoBZJHd70yE914,249
-koi_net/protocol/edge.py,sha256=G3D9Ie0vbTSMJdoTw9g_oBmFCqzJ1gO7U1PVrw7p3j8,447
-koi_net/protocol/event.py,sha256=dzJmcHbimo7p5NwH2drccF0vMcAj9oQRj3iZ9Bjf7kg,1275
-koi_net/protocol/helpers.py,sha256=9E9PaoIuSNrTBATGCLJ_kSBMZ2z-KIMnLJzGOTqQDC0,719
-koi_net/protocol/node.py,sha256=Ntrx01dbm39ViKGtr4gLmztcMwKpTIweS6rRL-zoU_Y,391
-koi_net-1.0.0b8.dist-info/METADATA,sha256=-oGUkUtRG4biV7yo7WIl2XiDv4k8wVTV_DbyebOiuoI,21352
-koi_net-1.0.0b8.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-koi_net-1.0.0b8.dist-info/licenses/LICENSE,sha256=XBcvl8yjCAezfuqN1jadQykrX7H2g4nr2WRDmHLW6ik,1090
-koi_net-1.0.0b8.dist-info/RECORD,,