koi-net 1.0.0b19__py3-none-any.whl → 1.1.0__py3-none-any.whl

koi_net/secure.py

@@ -0,0 +1,117 @@
+import logging
+from functools import wraps
+
+import cryptography.exceptions
+from rid_lib.ext import Bundle
+from rid_lib.ext.utils import sha256_hash
+from .identity import NodeIdentity
+from .protocol.envelope import UnsignedEnvelope, SignedEnvelope
+from .protocol.secure import PublicKey
+from .protocol.api_models import EventsPayload
+from .protocol.event import EventType
+from .protocol.node import NodeProfile
+from .protocol.secure import PrivateKey
+from .protocol.errors import (
+    UnknownNodeError,
+    InvalidKeyError,
+    InvalidSignatureError,
+    InvalidTargetError
+)
+from .effector import Effector
+from .config import NodeConfig
+
+logger = logging.getLogger(__name__)
+
+
+class Secure:
+    identity: NodeIdentity
+    effector: Effector
+    config: NodeConfig
+    priv_key: PrivateKey
+    
+    def __init__(
+        self, 
+        identity: NodeIdentity, 
+        effector: Effector,
+        config: NodeConfig
+    ):
+        self.identity = identity
+        self.effector = effector
+        self.config = config
+
+        self.priv_key = self._load_priv_key()
+        
+    def _load_priv_key(self) -> PrivateKey:
+        with open(self.config.koi_net.private_key_pem_path, "r") as f:
+            priv_key_pem = f.read()
+        
+        return PrivateKey.from_pem(
+            priv_key_pem=priv_key_pem,
+            password=self.config.env.priv_key_password
+        )
+        
+    def _handle_unknown_node(self, envelope: SignedEnvelope) -> Bundle | None:
+        if type(envelope.payload) != EventsPayload:
+            return None
+            
+        for event in envelope.payload.events:
+            # must be NEW event for bundle of source node's profile
+            if event.rid != envelope.source_node:
+                continue
+            if event.event_type != EventType.NEW:
+                continue            
+            
+            return event.bundle
+        return None
+        
+    def create_envelope(self, payload, target) -> SignedEnvelope:
+        return UnsignedEnvelope(
+            payload=payload,
+            source_node=self.identity.rid,
+            target_node=target
+        ).sign_with(self.priv_key)
+        
+    def validate_envelope(self, envelope: SignedEnvelope):
+        node_bundle = (
+            self.effector.deref(envelope.source_node) or
+            self._handle_unknown_node(envelope)
+        )
+        
+        if not node_bundle:
+            raise UnknownNodeError(f"Couldn't resolve {envelope.source_node}")
+        
+        node_profile = node_bundle.validate_contents(NodeProfile)
+        
+        # check that public key matches source node RID
+        if envelope.source_node.hash != sha256_hash(node_profile.public_key):
+            raise InvalidKeyError("Invalid public key on new node!")
+        
+        # check envelope signed by validated public key
+        pub_key = PublicKey.from_der(node_profile.public_key)
+        try:
+            envelope.verify_with(pub_key)
+        except cryptography.exceptions.InvalidSignature as err:
+            raise InvalidSignatureError(f"Signature {envelope.signature} is invalid.")
+        
+        # check that this node is the target of the envelope
+        if envelope.target_node != self.identity.rid:
+            raise InvalidTargetError(f"Envelope target {envelope.target_node!r} is not me")
+        
+    def envelope_handler(self, func):
+        @wraps(func)
+        async def wrapper(req: SignedEnvelope, *args, **kwargs) -> SignedEnvelope | None:
+            logger.info("Validating envelope")
+            
+            self.validate_envelope(req)            
+            logger.info("Calling endpoint handler")
+            
+            result = await func(req, *args, **kwargs)            
+            
+            if result is not None:
+                logger.info("Creating response envelope")
+                return self.create_envelope(
+                    payload=result,
+                    target=req.source_node
+                )
+        return wrapper
+

koi_net/server.py

@@ -0,0 +1,129 @@
+import logging
+import uvicorn
+from contextlib import asynccontextmanager
+from fastapi import FastAPI, APIRouter
+from fastapi.responses import JSONResponse
+from .network.event_queue import NetworkEventQueue
+from .network.response_handler import ResponseHandler
+from .processor.interface import ProcessorInterface
+from .protocol.api_models import (
+    PollEvents,
+    FetchRids,
+    FetchManifests,
+    FetchBundles,
+    EventsPayload,
+    RidsPayload,
+    ManifestsPayload,
+    BundlesPayload,
+    ErrorResponse
+)
+from .protocol.errors import ProtocolError
+from .protocol.envelope import SignedEnvelope
+from .protocol.consts import (
+    BROADCAST_EVENTS_PATH,
+    POLL_EVENTS_PATH,
+    FETCH_RIDS_PATH,
+    FETCH_MANIFESTS_PATH,
+    FETCH_BUNDLES_PATH
+)
+from .secure import Secure
+from .lifecycle import NodeLifecycle
+from .config import NodeConfig
+
+logger = logging.getLogger(__name__)
+
+
+class NodeServer:
+    lifecycle: NodeLifecycle
+    
+    def __init__(
+        self,
+        config: NodeConfig,
+        lifecycle: NodeLifecycle,
+        secure: Secure,
+        processor: ProcessorInterface,
+        event_queue: NetworkEventQueue,
+        response_handler: ResponseHandler
+    ):
+        self.config = config
+        self.lifecycle = lifecycle
+        self.secure = secure
+        self.processor = processor
+        self.event_queue = event_queue
+        self.response_handler = response_handler
+        self._build_app()
+        
+    def _build_app(self):
+        
+        @asynccontextmanager
+        async def lifespan(*args, **kwargs):
+            async with self.lifecycle.async_run():
+                yield
+        
+        self.app = FastAPI(
+            lifespan=lifespan, 
+            title="KOI-net Protocol API",
+            version="1.0.0"
+        )
+        
+        self.router = APIRouter(prefix="/koi-net")
+        self.app.add_exception_handler(ProtocolError, self.protocol_error_handler)
+        
+        def _add_endpoint(path, func):
+            self.router.add_api_route(
+                path=path,
+                endpoint=self.secure.envelope_handler(func),
+                methods=["POST"],
+                response_model_exclude_none=True
+            )
+        
+        _add_endpoint(BROADCAST_EVENTS_PATH, self.broadcast_events)
+        _add_endpoint(POLL_EVENTS_PATH, self.poll_events)
+        _add_endpoint(FETCH_RIDS_PATH, self.fetch_rids)
+        _add_endpoint(FETCH_MANIFESTS_PATH, self.fetch_manifests)
+        _add_endpoint(FETCH_BUNDLES_PATH, self.fetch_bundles)
+        
+        self.app.include_router(self.router)
+    
+    def run(self):
+        uvicorn.run(
+            app=self.app,
+            host=self.config.server.host,
+            port=self.config.server.port
+        )
+        
+    def protocol_error_handler(self, request, exc: ProtocolError):
+        logger.info(f"caught protocol error: {exc}")
+        resp = ErrorResponse(error=exc.error_type)
+        logger.info(f"returning error response: {resp}")
+        return JSONResponse(
+            status_code=400,
+            content=resp.model_dump(mode="json")
+        )
+
+    async def broadcast_events(self, req: SignedEnvelope[EventsPayload]):
+        logger.info(f"Request to {BROADCAST_EVENTS_PATH}, received {len(req.payload.events)} event(s)")
+        for event in req.payload.events:
+            self.processor.handle(event=event, source=req.source_node)
+        
+    async def poll_events(
+        self, req: SignedEnvelope[PollEvents]
+    ) -> SignedEnvelope[EventsPayload] | ErrorResponse:
+        logger.info(f"Request to {POLL_EVENTS_PATH}")
+        events = self.event_queue.flush_poll_queue(req.source_node)
+        return EventsPayload(events=events)
+
+    async def fetch_rids(
+        self, req: SignedEnvelope[FetchRids]
+    ) -> SignedEnvelope[RidsPayload] | ErrorResponse:
+        return self.response_handler.fetch_rids(req.payload, req.source_node)
+
+    async def fetch_manifests(
+        self, req: SignedEnvelope[FetchManifests]
+    ) -> SignedEnvelope[ManifestsPayload] | ErrorResponse:
+        return self.response_handler.fetch_manifests(req.payload, req.source_node)
+
+    async def fetch_bundles(
+        self, req: SignedEnvelope[FetchBundles]
+    ) -> SignedEnvelope[BundlesPayload] | ErrorResponse:
+        return self.response_handler.fetch_bundles(req.payload, req.source_node)

{koi_net-1.0.0b19.dist-info → koi_net-1.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: koi-net
-Version: 1.0.0b19
+Version: 1.1.0
 Summary: Implementation of KOI-net protocol in Python
 Project-URL: Homepage, https://github.com/BlockScience/koi-net/
 Author-email: Luke Miller <luke@block.science>
@@ -27,19 +27,20 @@ License: MIT License
         SOFTWARE.
 License-File: LICENSE
 Requires-Python: >=3.10
+Requires-Dist: cryptography>=45.0.3
+Requires-Dist: fastapi>=0.115.12
 Requires-Dist: httpx>=0.28.1
 Requires-Dist: networkx>=3.4.2
 Requires-Dist: pydantic>=2.10.6
 Requires-Dist: python-dotenv>=1.1.0
-Requires-Dist: rid-lib>=3.2.3
+Requires-Dist: rid-lib>=3.2.7
 Requires-Dist: ruamel-yaml>=0.18.10
+Requires-Dist: uvicorn>=0.34.2
 Provides-Extra: dev
 Requires-Dist: build; extra == 'dev'
 Requires-Dist: twine>=6.0; extra == 'dev'
 Provides-Extra: examples
-Requires-Dist: fastapi; extra == 'examples'
 Requires-Dist: rich; extra == 'examples'
-Requires-Dist: uvicorn; extra == 'examples'
 Description-Content-Type: text/markdown
 
 # KOI-net

koi_net-1.1.0.dist-info/RECORD

@@ -0,0 +1,38 @@
+koi_net/__init__.py,sha256=b0Ze0pZmJAuygpWUFHM6Kvqo3DkU_uzmkptv1EpAArw,31
+koi_net/actor.py,sha256=Gad1Xg8n_-zm6sj0nDkm_B1MwErQJKeUsbGmIDTRqJk,1820
+koi_net/config.py,sha256=47XbQ59GRYFi4rlsoWKlnzMQATcnK70i3qmKTZAGOQk,4087
+koi_net/context.py,sha256=G067ecIJJ5k8aesdyxjZC_vh3zVg9PR_H2U-09YIxXA,1683
+koi_net/core.py,sha256=6nEDAOkMTv-pynU_hLOG4tKVWhopMPIHyZI6oJTdLj8,7061
+koi_net/default_actions.py,sha256=TkQR9oj9CpO37Gb5bZLmFNl-Q8n3OxGiX4dvxQR7SaA,421
+koi_net/effector.py,sha256=gSyZgRxQ91X04UL261e2pXWUfBHnQTGtjSHpc2JufxA,4097
+koi_net/identity.py,sha256=FvIWksGTqwM7HCevIwmo_6l-t-2tnYkaaR4CanZatL4,569
+koi_net/lifecycle.py,sha256=1WCo-VOox0rK3v_lfzhnFMGiyacZJpsaENlyGq7jHJQ,3563
+koi_net/poller.py,sha256=bIrlqdac5vLQYAid35xiQJLDMR85GnOSPCXSTQ07-Mc,1173
+koi_net/secure.py,sha256=cGNF2assqCaYq0i0fhQBm7aREoAdpY-XVypDsE1ALaU,3970
+koi_net/server.py,sha256=PrR_cXQV5YMKa6FXwiJXwMZJ52VQVzLPYYPVl-Miuw8,4315
+koi_net/network/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+koi_net/network/error_handler.py,sha256=09ulFPpSzoI49RFYPxc5TLXslqJQ_78q7TzLJIABeMw,1606
+koi_net/network/event_queue.py,sha256=DWs26C235iYkP4koKcdbhmIOHGZRJ48d072BoNWyiHo,7325
+koi_net/network/graph.py,sha256=neVVVHSyqsQR8hW2-lLC8IkDC2xciBXh3aWYXQpVqZs,4134
+koi_net/network/request_handler.py,sha256=_SM5MuYkS636wGJeFkesapQsW5x_kt_1o9KTXB0wksU,6869
+koi_net/network/resolver.py,sha256=YpQq6HKyfcoqr9TnHRnlQI33IM3tE0ljU02pZ3wWLh8,5410
+koi_net/network/response_handler.py,sha256=__R_EvEpjaMz3PCDvkNgWF_EAHe2nePGk-zK_cT4C4g,2077
+koi_net/processor/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+koi_net/processor/default_handlers.py,sha256=1OTC4p0luTadNm90q6Fr_dbvysFzgRCbltp-YP6cRXo,9562
+koi_net/processor/handler.py,sha256=_loaHjgVGVUxtCQdvAY9dQ0iqiq5co7wB2tK-usuv3Y,2355
+koi_net/processor/interface.py,sha256=ebDwqggznFRfp2PT8-UJPUAvCwX8nZaaQ68FUeWQvmw,3682
+koi_net/processor/knowledge_object.py,sha256=avQnsaeqqiJxy40P1VGljuQMtAGmJB-TBa4pmBXTaIs,3863
+koi_net/processor/knowledge_pipeline.py,sha256=i7FpCFl0UIOwCI5zhP1i8M4PX4A48VN28iV9jruvN5k,9486
+koi_net/protocol/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+koi_net/protocol/api_models.py,sha256=jzRZWW_ZB5YsBAiwCom882-WIbr0rPyelJxExRgHZGc,1755
+koi_net/protocol/consts.py,sha256=bisbVEojPIHlLhkLafBzfIhH25TjNfvTORF1g6YXzIM,243
+koi_net/protocol/edge.py,sha256=PzdEhC43T1KO5iMSEu7I4tiz-7sZxtz41dJfWf-oHA0,1034
+koi_net/protocol/envelope.py,sha256=UVHlO2BDyDiP5eixqx9xD6xUsCfFRi0kZyzC4BC-DOw,1886
+koi_net/protocol/errors.py,sha256=uKPQ-TGLouZuK0xd2pXuCQoRTyu_JFsydSCLml13Cz8,595
+koi_net/protocol/event.py,sha256=HxzLN-iCXPyr2YzrswMIkgZYeUdFbBpa5v98dAB06lQ,1328
+koi_net/protocol/node.py,sha256=7GQzHORFr9cP4BqJgir6EGSWCskL-yqmvJksIiLfcWU,409
+koi_net/protocol/secure.py,sha256=6sRLWxG5EDF0QLBj29gk3hPmZnPXATrTTFdwx39wQfY,5127
+koi_net-1.1.0.dist-info/METADATA,sha256=upjYpZiqyRhDFxl2xN_tNvDZ5Cx6G_Bs8dgnp5f6L0k,37116
+koi_net-1.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+koi_net-1.1.0.dist-info/licenses/LICENSE,sha256=03mgCL5qth2aD9C3F3qNVs4sFJSpK9kjtYCyOwdSp7s,1069
+koi_net-1.1.0.dist-info/RECORD,,

koi_net/network/interface.py

@@ -1,276 +0,0 @@
-import logging
-from queue import Queue
-from typing import Generic
-import httpx
-from pydantic import BaseModel
-from rid_lib import RID
-from rid_lib.core import RIDType
-from rid_lib.ext import Cache
-from rid_lib.types import KoiNetNode
-
-from .graph import NetworkGraph
-from .request_handler import RequestHandler
-from .response_handler import ResponseHandler
-from ..protocol.node import NodeType
-from ..protocol.edge import EdgeType
-from ..protocol.event import Event
-from ..identity import NodeIdentity
-from ..config import ConfigType
-
-logger = logging.getLogger(__name__)
-
-
-class EventQueueModel(BaseModel):
-    webhook: dict[KoiNetNode, list[Event]]
-    poll: dict[KoiNetNode, list[Event]]
-
-type EventQueue = dict[RID, Queue[Event]]
-
-class NetworkInterface(Generic[ConfigType]):
-    """A collection of functions and classes to interact with the KOI network."""
-    
-    config: ConfigType    
-    identity: NodeIdentity
-    cache: Cache
-    graph: NetworkGraph
-    request_handler: RequestHandler
-    response_handler: ResponseHandler
-    poll_event_queue: EventQueue
-    webhook_event_queue: EventQueue
-    
-    def __init__(
-        self, 
-        config: ConfigType,
-        cache: Cache, 
-        identity: NodeIdentity
-    ):
-        self.config = config
-        self.identity = identity
-        self.cache = cache
-        self.graph = NetworkGraph(cache, identity)
-        self.request_handler = RequestHandler(cache, self.graph)
-        self.response_handler = ResponseHandler(cache)
-        
-        self.poll_event_queue = dict()
-        self.webhook_event_queue = dict()
-        self._load_event_queues()
-    
-    def _load_event_queues(self):
-        """Loads event queues from storage."""
-        try:
-            with open(self.config.koi_net.event_queues_path, "r") as f:
-                queues = EventQueueModel.model_validate_json(f.read())
-            
-            for node in queues.poll.keys():
-                for event in queues.poll[node]:
-                    queue = self.poll_event_queue.setdefault(node, Queue())
-                    queue.put(event)
-            
-            for node in queues.webhook.keys():
-                for event in queues.webhook[node]:
-                    queue = self.webhook_event_queue.setdefault(node, Queue())
-                    queue.put(event)
-                                
-        except FileNotFoundError:
-            return
-        
-    def _save_event_queues(self):
-        """Writes event queues to storage."""
-        events_model = EventQueueModel(
-            poll={
-                node: list(queue.queue) 
-                for node, queue in self.poll_event_queue.items()
-                if not queue.empty()
-            },
-            webhook={
-                node: list(queue.queue) 
-                for node, queue in self.webhook_event_queue.items()
-                if not queue.empty()
-            }
-        )
-        
-        if len(events_model.poll) == 0 and len(events_model.webhook) == 0:
-            return
-        
-        with open(self.config.koi_net.event_queues_path, "w") as f:
-            f.write(events_model.model_dump_json(indent=2))
-    
-    def push_event_to(self, event: Event, node: KoiNetNode, flush=False):
-        """Pushes event to queue of specified node.
-        
-        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.debug(f"Pushing event {event.event_type} {event.rid} to {node}")
-            
-        node_profile = self.graph.get_node_profile(node)
-        if not node_profile:
-            logger.warning(f"Node {node!r} unknown to me")
-        
-        # if there's an edge from me to the target node, override broadcast type
-        edge_profile = self.graph.get_edge_profile(
-            source=self.identity.rid,
-            target=node
-        )
-        
-        if edge_profile:
-            if edge_profile.edge_type == EdgeType.WEBHOOK:
-                event_queue = self.webhook_event_queue
-            elif edge_profile.edge_type == EdgeType.POLL:
-                event_queue = self.poll_event_queue
-        else:
-            if node_profile.node_type == NodeType.FULL:
-                event_queue = self.webhook_event_queue
-            elif node_profile.node_type == NodeType.PARTIAL:
-                event_queue = self.poll_event_queue
-        
-        queue = event_queue.setdefault(node, Queue())
-        queue.put(event)
-                
-        if flush and event_queue is self.webhook_event_queue:
-            self.flush_webhook_queue(node)
-            
-    def _flush_queue(self, event_queue: EventQueue, node: KoiNetNode) -> list[Event]:
-        """Flushes a node's queue, returning list of events."""
-        queue = event_queue.get(node)
-        events = list()
-        if queue:
-            while not queue.empty():
-                event = queue.get()
-                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.debug(f"Flushing poll queue for {node}")
-        return self._flush_queue(self.poll_event_queue, node)
-    
-    def flush_webhook_queue(self, node: KoiNetNode):
-        """Flushes a node's webhook queue, and broadcasts events.
-        
-        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.debug(f"Flushing webhook queue for {node}")
-        
-        node_profile = self.graph.get_node_profile(node)
-        
-        if not node_profile:
-            logger.warning(f"{node!r} not found")
-            return
-        
-        if node_profile.node_type != NodeType.FULL:
-            logger.warning(f"{node!r} is a partial node!")
-            return
-        
-        events = self._flush_queue(self.webhook_event_queue, node)
-        if not events: return
-        
-        logger.debug(f"Broadcasting {len(events)} events")
-        
-        try:  
-            self.request_handler.broadcast_events(node, events=events)
-            return True
-        except httpx.ConnectError:
-            logger.warning("Broadcast failed")
-            for event in events:
-                self.push_event_to(event, node)
-            return False
-            
-    def get_state_providers(self, rid_type: RIDType) -> list[KoiNetNode]:
-        """Returns list of node RIDs which provide state for the specified RID type."""
-        
-        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.debug(f"Found provider '{node_rid}'")
-                provider_nodes.append(node_rid)
-        
-        if not provider_nodes:
-            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.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(
-                node=node_rid, rids=[rid])
-            
-            if payload.bundles:
-                remote_bundle = payload.bundles[0]
-                logger.debug(f"Got bundle from '{node_rid}'")
-                break
-        
-        if not remote_bundle:
-            logger.warning("Failed to fetch remote bundle")
-            
-        return remote_bundle
-    
-    def fetch_remote_manifest(self, rid: RID):
-        """Attempts to fetch a manifest by RID from known peer nodes."""
-        
-        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(
-                node=node_rid, rids=[rid])
-            
-            if payload.manifests:
-                remote_manifest = payload.manifests[0]
-                logger.debug(f"Got bundle from '{node_rid}'")
-                break
-        
-        if not remote_manifest:
-            logger.warning("Failed to fetch remote bundle")
-            
-        return remote_manifest
-    
-    def poll_neighbors(self) -> list[Event]:
-        """Polls all neighboring nodes and returns compiled list of events.
-        
-        If this node has no neighbors, it will instead attempt to poll the provided first contact URL.
-        """
-        
-        neighbors = self.graph.get_neighbors()
-        
-        if not neighbors and self.config.koi_net.first_contact:
-            logger.debug("No neighbors found, polling first contact")
-            try:
-                payload = self.request_handler.poll_events(
-                    url=self.config.koi_net.first_contact, 
-                    rid=self.identity.rid
-                )
-                if payload.events:
-                    logger.debug(f"Received {len(payload.events)} events from '{self.config.koi_net.first_contact}'")
-                return payload.events
-            except httpx.ConnectError:
-                logger.debug(f"Failed to reach first contact '{self.config.koi_net.first_contact}'")
-        
-        events = []
-        for node_rid in neighbors:
-            node = self.graph.get_node_profile(node_rid)
-            if not node: continue
-            if node.node_type != NodeType.FULL: continue
-            
-            try:
-                payload = self.request_handler.poll_events(
-                    node=node_rid, 
-                    rid=self.identity.rid
-                )
-                if payload.events:
-                    logger.debug(f"Received {len(payload.events)} events from {node_rid!r}")
-                events.extend(payload.events)
-            except httpx.ConnectError:
-                logger.debug(f"Failed to reach node '{node_rid}'")
-                continue
-            
-        return events                
-        
-        

koi_net/protocol/helpers.py

@@ -1,25 +0,0 @@
-from rid_lib.core import RIDType
-from rid_lib.ext.bundle import Bundle
-from rid_lib.types import KoiNetEdge
-from rid_lib.types.koi_net_node import KoiNetNode
-from .edge import EdgeProfile, EdgeStatus, EdgeType
-
-def generate_edge_bundle(
-    source: KoiNetNode,
-    target: KoiNetNode,
-    rid_types: list[RIDType],
-    edge_type: EdgeType
-) -> Bundle:
-    edge_rid = KoiNetEdge.generate(source, target)
-    edge_profile = EdgeProfile(
-        source=source,
-        target=target,
-        rid_types=rid_types,
-        edge_type=edge_type,
-        status=EdgeStatus.PROPOSED
-    )
-    edge_bundle = Bundle.generate(
-        edge_rid,
-        edge_profile.model_dump()
-    )
-    return edge_bundle

koi_net-1.0.0b19.dist-info/RECORD

@@ -1,25 +0,0 @@
-koi_net/__init__.py,sha256=b0Ze0pZmJAuygpWUFHM6Kvqo3DkU_uzmkptv1EpAArw,31
-koi_net/config.py,sha256=TIKb1kFTcEysqwdHp6yCNpcXeS84dlprcb-f0z2jF0Y,3160
-koi_net/core.py,sha256=IO8kqiNMYVeuNzilq7eHBA7IulsxRjrCbWnIAx6_abA,4406
-koi_net/identity.py,sha256=muc5vuQ8zUOebhwAB3-ql6W2pgQETiYXXQAFBv8bLyg,1288
-koi_net/network/__init__.py,sha256=r_RN-q_mDYC-2RAkN-lJoMUX76TXyfEUc_MVKW87z0g,39
-koi_net/network/graph.py,sha256=dsfPuHUTkCzlj0QeL0e7dgp7-FR5_AGP7eE8EpBPhC0,4710
-koi_net/network/interface.py,sha256=icpl0rzpC5yV86BQBAbjAjK7AWhgCFoyFLm_Fjf1mCI,10451
-koi_net/network/request_handler.py,sha256=66gjX2x4UnBWZYwKLjp_3WkhL-ekhR3VAyfGviHTcUs,4790
-koi_net/network/response_handler.py,sha256=CAwici2Etj9ESndERXdtYkMlc4gWHz_xc7jHgY2Qjcg,1830
-koi_net/processor/__init__.py,sha256=x4fAY0hvQEDcpfdTB3POIzxBQjYAtn0qQazPo1Xm0m4,41
-koi_net/processor/default_handlers.py,sha256=dP64lEJ64BJ7H8PhFK-GZI1pv51tVVINV4jAgcOtOhc,8669
-koi_net/processor/handler.py,sha256=7X6M6PP8m6-xdtsP1y4QO83g_MN5VSszNNikprITK80,2523
-koi_net/processor/interface.py,sha256=Kyw4SQos_1WdcPJJe-j2w4xDIfwtmpF4mfGlkRVRqUI,12876
-koi_net/processor/knowledge_object.py,sha256=RCgzkILsWm1Jw_NkSu4jTRYA9Ugga6mJ4jqKWwketQs,4090
-koi_net/protocol/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-koi_net/protocol/api_models.py,sha256=DYDKCRD2Uja633bBAyTsaxyb1oF9pX9yQ9NpNAbkczo,1070
-koi_net/protocol/consts.py,sha256=bisbVEojPIHlLhkLafBzfIhH25TjNfvTORF1g6YXzIM,243
-koi_net/protocol/edge.py,sha256=CcmvIY4P1HEBdKNJ4wFRDmwYMRMss24Besmbi7ZRFxQ,427
-koi_net/protocol/event.py,sha256=eGgihEj1gliLoQRk8pVB2q_was0AGo-PbT3Hqnpn3oU,1379
-koi_net/protocol/helpers.py,sha256=8ZkQrjb_G0QEaMIKe9wkFOBonl1bkmemx_pwKMwIiLg,695
-koi_net/protocol/node.py,sha256=2HhCh3LdBLlY2Z_kXNmKHzpVLKbP_ODob3HjHayFQtM,375
-koi_net-1.0.0b19.dist-info/METADATA,sha256=uVzxDiRiHRncwfjotk7j_frmm_ka6PEpI-kcA278HoE,37107
-koi_net-1.0.0b19.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-koi_net-1.0.0b19.dist-info/licenses/LICENSE,sha256=03mgCL5qth2aD9C3F3qNVs4sFJSpK9kjtYCyOwdSp7s,1069
-koi_net-1.0.0b19.dist-info/RECORD,,