koi-net 1.2.0b1__py3-none-any.whl → 1.2.0b3__py3-none-any.whl

koi_net/network/poll_event_buffer.py

@@ -0,0 +1,26 @@
+from rid_lib.types import KoiNetNode
+
+from koi_net.protocol.event import Event
+
+
+class PollEventBuffer:
+    buffers: dict[KoiNetNode, list[Event]]
+    
+    def __init__(self):
+        self.buffers = dict()
+        
+    def push(self, node: KoiNetNode, event: Event):
+        event_buf = self.buffers.setdefault(node, [])
+        event_buf.append(event)
+        
+    def flush(self, node: KoiNetNode, limit: int = 0):
+        event_buf = self.buffers.get(node, [])
+        
+        if limit and len(event_buf) > limit:
+            to_return = event_buf[:limit]
+            self.buffers[node] = event_buf[limit:]
+        else:
+            to_return = event_buf.copy()
+            self.buffers[node] = []
+        
+        return to_return

koi_net/network/request_handler.py

@@ -1,9 +1,11 @@
-import logging
+import structlog
 import httpx
 from rid_lib import RID
 from rid_lib.ext import Cache
 from rid_lib.types.koi_net_node import KoiNetNode
 
+from koi_net.protocol.model_map import API_MODEL_MAP
+
 from ..identity import NodeIdentity
 from ..protocol.api_models import (
     RidsPayload,
@@ -30,8 +32,7 @@ from ..protocol.node import NodeProfile, NodeType
 from ..secure import Secure
 from .error_handler import ErrorHandler
 
-
-logger = logging.getLogger(__name__)
+log = structlog.stdlib.get_logger()
 
 
 # Custom error types for request handling
@@ -74,7 +75,7 @@ class RequestHandler:
     def get_url(self, node_rid: KoiNetNode) -> str:
         """Retrieves URL of a node from its RID."""
         
-        logger.debug(f"Getting URL for {node_rid!r}")
+        log.debug(f"Getting URL for {node_rid!r}")
         node_url = None
         
         if node_rid == self.identity.rid:
@@ -84,20 +85,20 @@ class RequestHandler:
                 
         if node_bundle:
             node_profile = node_bundle.validate_contents(NodeProfile)
-            logger.debug(f"Found node profile: {node_profile}")
+            log.debug(f"Found node profile: {node_profile}")
             if node_profile.node_type != NodeType.FULL:
                 raise PartialNodeQueryError("Can't query partial node")
             node_url = node_profile.base_url
         
         else:
             if node_rid == self.identity.config.koi_net.first_contact.rid:
-                logger.debug("Found URL of first contact")
+                log.debug("Found URL of first contact")
                 node_url = self.identity.config.koi_net.first_contact.url
         
         if not node_url:
             raise NodeNotFoundError("Node not found")
         
-        logger.debug(f"Resolved {node_rid!r} to {node_url}")
+        log.debug(f"Resolved {node_rid!r} to {node_url}")
         return node_url
     
     def make_request(
@@ -108,7 +109,7 @@ class RequestHandler:
     ) -> ResponseModels | None:
         """Makes a request to a node."""
         url = self.get_url(node) + path
-        logger.info(f"Making request to {url}")
+        log.info(f"Making request to {url}")
     
         signed_envelope = self.secure.create_envelope(
             payload=request,
@@ -116,9 +117,12 @@ class RequestHandler:
         )
         
         try:
-            result = httpx.post(url, data=signed_envelope.model_dump_json(exclude_none=True))
+            result = httpx.post(
+                url, 
+                data=signed_envelope.model_dump_json(exclude_none=True)
+            )
         except httpx.ConnectError as err:
-            logger.debug("Failed to connect")
+            log.debug("Failed to connect")
             self.error_handler.handle_connection_error(node)
             raise err
         
@@ -127,20 +131,11 @@ class RequestHandler:
             self.error_handler.handle_protocol_error(resp.error, node)
             return resp
         
-        if path == BROADCAST_EVENTS_PATH:
-            return None
-        elif path == POLL_EVENTS_PATH:
-            EnvelopeModel = SignedEnvelope[EventsPayload]
-        elif path == FETCH_RIDS_PATH:
-            EnvelopeModel = SignedEnvelope[RidsPayload]
-        elif path == FETCH_MANIFESTS_PATH:
-            EnvelopeModel = SignedEnvelope[ManifestsPayload]
-        elif path == FETCH_BUNDLES_PATH:
-            EnvelopeModel = SignedEnvelope[BundlesPayload]
-        else:
-            raise UnknownPathError(f"Unknown path '{path}'")
+        resp_env_model = API_MODEL_MAP[path].response_envelope
+        if resp_env_model is None:
+            return
         
-        resp_envelope = EnvelopeModel.model_validate_json(result.text)
+        resp_envelope = resp_env_model.model_validate_json(result.text)
         self.secure.validate_envelope(resp_envelope)
         
         return resp_envelope.payload
@@ -157,7 +152,7 @@ class RequestHandler:
         """
         request = req or EventsPayload.model_validate(kwargs)
         self.make_request(node, BROADCAST_EVENTS_PATH, request)
-        logger.info(f"Broadcasted {len(request.events)} event(s) to {node!r}")
+        log.info(f"Broadcasted {len(request.events)} event(s) to {node!r}")
         
     def poll_events(
         self, 
@@ -172,7 +167,7 @@ class RequestHandler:
         request = req or PollEvents.model_validate(kwargs)
         resp = self.make_request(node, POLL_EVENTS_PATH, request)
         if type(resp) != ErrorResponse:
-            logger.info(f"Polled {len(resp.events)} events from {node!r}")
+            log.info(f"Polled {len(resp.events)} events from {node!r}")
         return resp
         
     def fetch_rids(
@@ -188,7 +183,7 @@ class RequestHandler:
         request = req or FetchRids.model_validate(kwargs)
         resp = self.make_request(node, FETCH_RIDS_PATH, request)
         if type(resp) != ErrorResponse:
-            logger.info(f"Fetched {len(resp.rids)} RID(s) from {node!r}")
+            log.info(f"Fetched {len(resp.rids)} RID(s) from {node!r}")
         return resp
                 
     def fetch_manifests(
@@ -204,7 +199,7 @@ class RequestHandler:
         request = req or FetchManifests.model_validate(kwargs)
         resp = self.make_request(node, FETCH_MANIFESTS_PATH, request)
         if type(resp) != ErrorResponse:
-            logger.info(f"Fetched {len(resp.manifests)} manifest(s) from {node!r}")
+            log.info(f"Fetched {len(resp.manifests)} manifest(s) from {node!r}")
         return resp
                 
     def fetch_bundles(
@@ -220,5 +215,5 @@ class RequestHandler:
         request = req or FetchBundles.model_validate(kwargs)
         resp = self.make_request(node, FETCH_BUNDLES_PATH, request)
         if type(resp) != ErrorResponse:
-            logger.info(f"Fetched {len(resp.bundles)} bundle(s) from {node!r}")
+            log.info(f"Fetched {len(resp.bundles)} bundle(s) from {node!r}")
         return resp

koi_net/network/resolver.py

@@ -1,4 +1,4 @@
-import logging
+import structlog
 import httpx
 from rid_lib import RID
 from rid_lib.core import RIDType
@@ -11,9 +11,9 @@ from ..protocol.node import NodeProfile, NodeType
 from ..protocol.event import Event
 from ..protocol.api_models import ErrorResponse
 from ..identity import NodeIdentity
-from ..config import NodeConfig
+from ..config.core import NodeConfig
 
-logger = logging.getLogger(__name__)
+log = structlog.stdlib.get_logger()
 
 
 class NetworkResolver:
@@ -45,7 +45,7 @@ class NetworkResolver:
     def get_state_providers(self, rid_type: RIDType) -> list[KoiNetNode]:
         """Returns list of node RIDs which provide state for specified RID type."""
         
-        logger.debug(f"Looking for state providers of {rid_type}")
+        log.debug(f"Looking for state providers of {rid_type}")
         provider_nodes = []
         for node_rid in self.cache.list_rids(rid_types=[KoiNetNode]):
             if node_rid == self.identity.rid:
@@ -56,17 +56,17 @@ class NetworkResolver:
             node_profile = node_bundle.validate_contents(NodeProfile)
             
             if (node_profile.node_type == NodeType.FULL) and (rid_type in node_profile.provides.state):
-                logger.debug(f"Found provider {node_rid!r}")
+                log.debug(f"Found provider {node_rid!r}")
                 provider_nodes.append(node_rid)
         
         if not provider_nodes:
-            logger.debug("Failed to find providers")
+            log.debug("Failed to find providers")
         return provider_nodes
             
     def fetch_remote_bundle(self, rid: RID) -> tuple[Bundle | None, KoiNetNode | None]:
         """Attempts to fetch a bundle by RID from known peer nodes."""
         
-        logger.debug(f"Fetching remote bundle {rid!r}")
+        log.debug(f"Fetching remote bundle {rid!r}")
         remote_bundle, node_rid = None, None
         for node_rid in self.get_state_providers(type(rid)):
             payload = self.request_handler.fetch_bundles(
@@ -74,18 +74,18 @@ class NetworkResolver:
             
             if payload.bundles:
                 remote_bundle = payload.bundles[0]
-                logger.debug(f"Got bundle from {node_rid!r}")
+                log.debug(f"Got bundle from {node_rid!r}")
                 break
         
         if not remote_bundle:
-            logger.warning("Failed to fetch remote bundle")
+            log.warning("Failed to fetch remote bundle")
             
         return remote_bundle, node_rid
     
     def fetch_remote_manifest(self, rid: RID) -> tuple[Bundle | None, KoiNetNode | None]:
         """Attempts to fetch a manifest by RID from known peer nodes."""
         
-        logger.debug(f"Fetching remote manifest {rid!r}")
+        log.debug(f"Fetching remote manifest {rid!r}")
         remote_manifest, node_rid = None, None
         for node_rid in self.get_state_providers(type(rid)):
             payload = self.request_handler.fetch_manifests(
@@ -93,11 +93,11 @@ class NetworkResolver:
             
             if payload.manifests:
                 remote_manifest = payload.manifests[0]
-                logger.debug(f"Got bundle from {node_rid!r}")
+                log.debug(f"Got bundle from {node_rid!r}")
                 break
         
         if not remote_manifest:
-            logger.warning("Failed to fetch remote bundle")
+            log.warning("Failed to fetch remote bundle")
             
         return remote_manifest, node_rid
     
@@ -136,12 +136,12 @@ class NetworkResolver:
                     continue
                     
                 if payload.events:
-                    logger.debug(f"Received {len(payload.events)} events from {node_rid!r}")
+                    log.debug(f"Received {len(payload.events)} events from {node_rid!r}")
                     
                     event_dict[node_rid] = payload.events
                     
             except httpx.ConnectError:
-                logger.debug(f"Failed to reach node {node_rid!r}")
+                log.debug(f"Failed to reach node {node_rid!r}")
                 continue
         
         return event_dict

koi_net/network/response_handler.py

@@ -1,10 +1,20 @@
-import logging
+import structlog
 from rid_lib import RID
 from rid_lib.types import KoiNetNode
 from rid_lib.ext import Manifest, Cache
 from rid_lib.ext.bundle import Bundle
 
+from koi_net.network.poll_event_buffer import PollEventBuffer
+from koi_net.processor.kobj_queue import KobjQueue
+from koi_net.protocol.consts import BROADCAST_EVENTS_PATH, FETCH_BUNDLES_PATH, FETCH_MANIFESTS_PATH, FETCH_RIDS_PATH, POLL_EVENTS_PATH
+from koi_net.protocol.envelope import SignedEnvelope
+from koi_net.protocol.model_map import API_MODEL_MAP
+from koi_net.secure import Secure
+
 from ..protocol.api_models import (
+    ApiModels,
+    EventsPayload,
+    PollEvents,
     RidsPayload,
     ManifestsPayload,
     BundlesPayload,
@@ -13,30 +23,81 @@ from ..protocol.api_models import (
     FetchBundles,
 )
 
-logger = logging.getLogger(__name__)
+log = structlog.stdlib.get_logger()
 
 
 class ResponseHandler:
     """Handles generating responses to requests from other KOI nodes."""
     
     cache: Cache
+    kobj_queue: KobjQueue
+    poll_event_buf: PollEventBuffer
     
     def __init__(
         self, 
-        cache: Cache, 
+        cache: Cache,
+        kobj_queue: KobjQueue,
+        poll_event_buf: PollEventBuffer,
+        secure: Secure
     ):
         self.cache = cache
+        self.kobj_queue = kobj_queue
+        self.poll_event_buf = poll_event_buf
+        self.secure = secure
+    
+    def handle_response(self, path: str, req: SignedEnvelope):
+        self.secure.validate_envelope(req)
+        
+        response_map = {
+            BROADCAST_EVENTS_PATH: self.broadcast_events_handler,
+            POLL_EVENTS_PATH: self.poll_events_handler,
+            FETCH_RIDS_PATH: self.fetch_rids_handler,
+            FETCH_MANIFESTS_PATH: self.fetch_manifests_handler,
+            FETCH_BUNDLES_PATH: self.fetch_bundles_handler
+        }
+        
+        response = response_map[path](req.payload, req.source_node)
+        
+        if response is None:
+            return
+        
+        return self.secure.create_envelope(
+            payload=response,
+            target=req.source_node
+        )
         
-    def fetch_rids(self, req: FetchRids, source: KoiNetNode) -> RidsPayload:
+    def broadcast_events_handler(self, req: EventsPayload, source: KoiNetNode):
+        log.info(f"Request to broadcast events, received {len(req.events)} event(s)")
+        
+        for event in req.events:
+            self.kobj_queue.push(event=event, source=source)
+        
+    def poll_events_handler(
+        self, 
+        req: PollEvents, 
+        source: KoiNetNode
+    ) -> EventsPayload:
+        log.info(f"Request to poll events")
+        events = self.poll_event_buf.flush(source, limit=req.limit)
+        return EventsPayload(events=events)
+        
+    def fetch_rids_handler(
+        self, 
+        req: FetchRids, 
+        source: KoiNetNode
+    ) -> RidsPayload:
         """Returns response to fetch RIDs request."""
-        logger.info(f"Request to fetch rids, allowed types {req.rid_types}")
+        log.info(f"Request to fetch rids, allowed types {req.rid_types}")
         rids = self.cache.list_rids(req.rid_types)
         
         return RidsPayload(rids=rids)
         
-    def fetch_manifests(self, req: FetchManifests, source: KoiNetNode) -> ManifestsPayload:
+    def fetch_manifests_handler(self, 
+        req: FetchManifests, 
+        source: KoiNetNode
+    ) -> ManifestsPayload:
         """Returns response to fetch manifests request."""
-        logger.info(f"Request to fetch manifests, allowed types {req.rid_types}, rids {req.rids}")
+        log.info(f"Request to fetch manifests, allowed types {req.rid_types}, rids {req.rids}")
         
         manifests: list[Manifest] = []
         not_found: list[RID] = []
@@ -50,9 +111,13 @@ class ResponseHandler:
         
         return ManifestsPayload(manifests=manifests, not_found=not_found)
         
-    def fetch_bundles(self, req: FetchBundles, source: KoiNetNode) -> BundlesPayload:
+    def fetch_bundles_handler(
+        self, 
+        req: FetchBundles, 
+        source: KoiNetNode
+    ) -> BundlesPayload:
         """Returns response to fetch bundles request."""
-        logger.info(f"Request to fetch bundles, requested rids {req.rids}")
+        log.info(f"Request to fetch bundles, requested rids {req.rids}")
         
         bundles: list[Bundle] = []
         not_found: list[RID] = []

koi_net/{context.py → processor/context.py}

@@ -1,26 +1,15 @@
 from rid_lib.ext import Cache
 
+from koi_net.effector import Effector
 from koi_net.network.resolver import NetworkResolver
-from .config import NodeConfig
-from .network.graph import NetworkGraph
-from .network.event_queue import EventQueue
-from .network.request_handler import RequestHandler
-from .identity import NodeIdentity
-from .processor.kobj_queue import KobjQueue
+from ..config.core import NodeConfig
+from ..network.graph import NetworkGraph
+from ..network.event_queue import EventQueue
+from ..network.request_handler import RequestHandler
+from ..identity import NodeIdentity
+from .kobj_queue import KobjQueue
 
 
-class ActionContext:
-    """Provides action handlers access to other subsystems."""
-    
-    identity: NodeIdentity
-
-    def __init__(
-        self,
-        identity: NodeIdentity,
-    ):
-        self.identity = identity
-    
-
 class HandlerContext:
     """Provides knowledge handlers access to other subsystems."""
     
@@ -32,6 +21,7 @@ class HandlerContext:
     graph: NetworkGraph
     request_handler: RequestHandler
     resolver: NetworkResolver
+    effector: Effector
     
     def __init__(
         self,
@@ -43,6 +33,7 @@ class HandlerContext:
         graph: NetworkGraph,
         request_handler: RequestHandler,
         resolver: NetworkResolver,
+        effector: Effector
     ):
         self.identity = identity
         self.config = config
@@ -51,4 +42,5 @@ class HandlerContext:
         self.kobj_queue = kobj_queue
         self.graph = graph
         self.request_handler = request_handler
-        self.resolver = resolver
+        self.resolver = resolver
+        self.effector = effector

koi_net/processor/handler.py

@@ -2,7 +2,10 @@ from dataclasses import dataclass
 from enum import StrEnum
 from typing import Callable
 from rid_lib import RIDType
+
 from ..protocol.event import EventType
+from .knowledge_object import KnowledgeObject
+from .context import HandlerContext
 
 
 class StopChain:
@@ -32,7 +35,7 @@ class HandlerType(StrEnum):
 class KnowledgeHandler:
     """Handles knowledge processing events of the provided types."""
     
-    func: Callable
+    func: Callable[[HandlerContext, KnowledgeObject], None | KnowledgeObject | StopChain]
     handler_type: HandlerType
     rid_types: list[RIDType] | None
     event_types: list[EventType | None] | None = None

koi_net/processor/{default_handlers.py → knowledge_handlers.py}

@@ -1,18 +1,19 @@
 """Implementation of default knowledge handlers."""
 
-import logging
+import structlog
 from rid_lib.ext import Bundle
 from rid_lib.ext.utils import sha256_hash
 from rid_lib.types import KoiNetNode, KoiNetEdge
 from koi_net.protocol.node import NodeType
 from .handler import KnowledgeHandler, HandlerType, STOP_CHAIN
 from .knowledge_object import KnowledgeObject
-from ..context import HandlerContext
+from .context import HandlerContext
 from ..protocol.event import Event, EventType
-from ..protocol.edge import EdgeProfile, EdgeStatus, EdgeType, generate_edge_bundle
+from ..protocol.edge import EdgeProfile, EdgeStatus, EdgeType
 from ..protocol.node import NodeProfile
 
-logger = logging.getLogger(__name__)
+log = structlog.stdlib.get_logger()
+
 
 # RID handlers
 
@@ -24,7 +25,7 @@ def basic_rid_handler(ctx: HandlerContext, kobj: KnowledgeObject):
     RID is known to this node.
     """
     if (kobj.rid == ctx.identity.rid and kobj.source):
-        logger.debug("Don't let anyone else tell me who I am!")
+        log.debug("Don't let anyone else tell me who I am!")
         return STOP_CHAIN
     
     if kobj.event_type == EventType.FORGET:
@@ -45,17 +46,17 @@ def basic_manifest_handler(ctx: HandlerContext, kobj: KnowledgeObject):
 
     if prev_bundle:
         if kobj.manifest.sha256_hash == prev_bundle.manifest.sha256_hash:
-            logger.debug("Hash of incoming manifest is same as existing knowledge, ignoring")
+            log.debug("Hash of incoming manifest is same as existing knowledge, ignoring")
             return STOP_CHAIN
         if kobj.manifest.timestamp <= prev_bundle.manifest.timestamp:
-            logger.debug("Timestamp of incoming manifest is the same or older than existing knowledge, ignoring")
+            log.debug("Timestamp of incoming manifest is the same or older than existing knowledge, ignoring")
             return STOP_CHAIN
         
-        logger.debug("RID previously known to me, labeling as 'UPDATE'")
+        log.debug("RID previously known to me, labeling as 'UPDATE'")
         kobj.normalized_event_type = EventType.UPDATE
 
     else:
-        logger.debug("RID previously unknown to me, labeling as 'NEW'")
+        log.debug("RID previously unknown to me, labeling as 'NEW'")
         kobj.normalized_event_type = EventType.NEW
         
     return kobj
@@ -78,7 +79,7 @@ def secure_profile_handler(ctx: HandlerContext, kobj: KnowledgeObject):
     node_rid: KoiNetNode = kobj.rid
     
     if sha256_hash(node_profile.public_key) != node_rid.hash:
-        logger.warning(f"Public key hash mismatch for {node_rid!r}!")
+        log.warning(f"Public key hash mismatch for {node_rid!r}!")
         return STOP_CHAIN
 
 @KnowledgeHandler.create(
@@ -104,13 +105,13 @@ def edge_negotiation_handler(ctx: HandlerContext, kobj: KnowledgeObject):
         if edge_profile.status != EdgeStatus.PROPOSED:
             return
         
-        logger.debug("Handling edge negotiation")
+        log.debug("Handling edge negotiation")
         
         peer_rid = edge_profile.target
         peer_bundle = ctx.cache.read(peer_rid)
         
         if not peer_bundle:
-            logger.warning(f"Peer {peer_rid!r} unknown to me")
+            log.warning(f"Peer {peer_rid!r} unknown to me")
             return STOP_CHAIN
         
         peer_profile = peer_bundle.validate_contents(NodeProfile)
@@ -125,30 +126,30 @@ def edge_negotiation_handler(ctx: HandlerContext, kobj: KnowledgeObject):
         abort = False
         if (edge_profile.edge_type == EdgeType.WEBHOOK and 
             peer_profile.node_type == NodeType.PARTIAL):
-            logger.debug("Partial nodes cannot use webhooks")
+            log.debug("Partial nodes cannot use webhooks")
             abort = True
         
         if not set(edge_profile.rid_types).issubset(provided_events):
-            logger.debug("Requested RID types not provided by this node")
+            log.debug("Requested RID types not provided by this node")
             abort = True
         
         if abort:
             event = Event.from_rid(EventType.FORGET, kobj.rid)
-            ctx.event_queue.push_event_to(event, peer_rid, flush=True)
+            ctx.event_queue.push(event, peer_rid, flush=True)
             return STOP_CHAIN
 
         else:
             # approve edge profile
-            logger.debug("Approving proposed edge")
+            log.debug("Approving proposed edge")
             edge_profile.status = EdgeStatus.APPROVED
             updated_bundle = Bundle.generate(kobj.rid, edge_profile.model_dump())
       
-            ctx.kobj_queue.put_kobj(bundle=updated_bundle, event_type=EventType.UPDATE)
+            ctx.kobj_queue.push(bundle=updated_bundle, event_type=EventType.UPDATE)
             return
               
     elif edge_profile.target == ctx.identity.rid:
         if edge_profile.status == EdgeStatus.APPROVED:
-            logger.debug("Edge approved by other node!")
+            log.debug("Edge approved by other node!")
 
 
 # Network handlers
@@ -176,8 +177,8 @@ def node_contact_handler(ctx: HandlerContext, kobj: KnowledgeObject):
     if not available_rid_types:
         return
     
-    logger.info("Identified a coordinator!")
-    logger.info("Proposing new edge")
+    log.info("Identified a coordinator!")
+    log.info("Proposing new edge")
     
     # already have an edge established
     edge_rid = ctx.graph.get_edge(
@@ -215,9 +216,9 @@ def node_contact_handler(ctx: HandlerContext, kobj: KnowledgeObject):
     
     # queued for processing
     edge_bundle = Bundle.generate(edge_rid, edge_profile.model_dump())
-    ctx.kobj_queue.put_kobj(bundle=edge_bundle)
+    ctx.kobj_queue.push(bundle=edge_bundle)
     
-    logger.info("Catching up on network state")
+    log.info("Catching up on network state")
     
     payload = ctx.request_handler.fetch_rids(
         node=kobj.rid, 
@@ -225,16 +226,16 @@ def node_contact_handler(ctx: HandlerContext, kobj: KnowledgeObject):
     )
     for rid in payload.rids:
         if rid == ctx.identity.rid:
-            logger.info("Skipping myself")
+            log.info("Skipping myself")
             continue
         if ctx.cache.exists(rid):
-            logger.info(f"Skipping known RID {rid!r}")
+            log.info(f"Skipping known RID {rid!r}")
             continue
         
         # marked as external since we are handling RIDs from another node
         # will fetch remotely instead of checking local cache
-        ctx.kobj_queue.put_kobj(rid=rid, source=kobj.rid)
-    logger.info("Done")
+        ctx.kobj_queue.push(rid=rid, source=kobj.rid)
+    log.info("Done")
     
 
 @KnowledgeHandler.create(HandlerType.Network)
@@ -260,12 +261,12 @@ def basic_network_output_filter(ctx: HandlerContext, kobj: KnowledgeObject):
             edge_profile = kobj.bundle.validate_contents(EdgeProfile)
             
             if edge_profile.source == ctx.identity.rid:
-                logger.debug(f"Adding edge target '{edge_profile.target!r}' to network targets")
+                log.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 == ctx.identity.rid:
-                logger.debug(f"Adding edge source '{edge_profile.source!r}' to network targets")
+                log.debug(f"Adding edge source '{edge_profile.source!r}' to network targets")
                 kobj.network_targets.update([edge_profile.source])
                 involves_me = True
     
@@ -276,7 +277,7 @@ def basic_network_output_filter(ctx: HandlerContext, kobj: KnowledgeObject):
             allowed_type=type(kobj.rid)
         )
         
-        logger.debug(f"Updating network targets with '{type(kobj.rid)}' subscribers: {subscribers}")
+        log.debug(f"Updating network targets with '{type(kobj.rid)}' subscribers: {subscribers}")
         kobj.network_targets.update(subscribers)
         
     return kobj
@@ -294,5 +295,5 @@ def forget_edge_on_node_deletion(ctx: HandlerContext, kobj: KnowledgeObject):
         edge_profile = edge_bundle.validate_contents(EdgeProfile)
         
         if kobj.rid in (edge_profile.source, edge_profile.target):
-            logger.debug("Identified edge with forgotten node")
-            ctx.kobj_queue.put_kobj(rid=edge_rid, event_type=EventType.FORGET)
+            log.debug("Identified edge with forgotten node")
+            ctx.kobj_queue.push(rid=edge_rid, event_type=EventType.FORGET)

koi_net/processor/knowledge_object.py

@@ -1,8 +1,7 @@
 from pydantic import BaseModel
 from rid_lib import RID
-from rid_lib.ext import Manifest
-from rid_lib.ext.bundle import Bundle
-from rid_lib.types.koi_net_node import KoiNetNode
+from rid_lib.ext import Manifest, Bundle
+from rid_lib.types import KoiNetNode
 from ..protocol.event import Event, EventType