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

koi_net/processor/kobj_queue.py

@@ -1,4 +1,4 @@
-import logging
+import structlog
 from queue import Queue
 from rid_lib.core import RID
 from rid_lib.ext import Bundle, Manifest
@@ -6,7 +6,7 @@ from rid_lib.types import KoiNetNode
 from ..protocol.event import Event, EventType
 from .knowledge_object import KnowledgeObject
 
-logger = logging.getLogger(__name__)
+log = structlog.stdlib.get_logger()
 
 
 class KobjQueue:
@@ -16,7 +16,7 @@ class KobjQueue:
     def __init__(self):
         self.q = Queue()
                 
-    def put_kobj(
+    def push(
         self,
         rid: RID | None = None,
         manifest: Manifest | None = None,
@@ -48,4 +48,4 @@ class KobjQueue:
             raise ValueError("One of 'rid', 'manifest', 'bundle', 'event', or 'kobj' must be provided")
         
         self.q.put(_kobj)
-        logger.debug(f"Queued {_kobj!r}")
+        log.debug(f"Queued {_kobj!r}")

koi_net/processor/{knowledge_pipeline.py → pipeline.py}

@@ -1,4 +1,4 @@
-import logging
+import structlog
 from rid_lib.types import KoiNetEdge, KoiNetNode
 from rid_lib.ext import Cache
 from ..protocol.event import EventType
@@ -13,16 +13,13 @@ from .handler import (
     StopChain
 )
 from .knowledge_object import KnowledgeObject
+from .context import HandlerContext
 
-from typing import TYPE_CHECKING
-if TYPE_CHECKING:
-    from ..context import HandlerContext
-
-logger = logging.getLogger(__name__)
+log = structlog.stdlib.get_logger()
 
 
 class KnowledgePipeline:
-    handler_context: "HandlerContext"
+    handler_context: HandlerContext
     cache: Cache
     identity: NodeIdentity
     request_handler: RequestHandler
@@ -32,7 +29,7 @@ class KnowledgePipeline:
     
     def __init__(
         self, 
-        handler_context: "HandlerContext",
+        handler_context: HandlerContext,
         cache: Cache, 
         request_handler: RequestHandler,
         event_queue: EventQueue,
@@ -71,7 +68,7 @@ class KnowledgePipeline:
             if handler.event_types and kobj.event_type not in handler.event_types:
                 continue
             
-            logger.debug(f"Calling {handler_type} handler '{handler.func.__name__}'")
+            log.debug(f"Calling {handler_type} handler '{handler.func.__name__}'")
             
             resp = handler.func(
                 ctx=self.handler_context,
@@ -80,7 +77,7 @@ class KnowledgePipeline:
             
             # stops handler chain execution
             if resp is STOP_CHAIN:
-                logger.debug(f"Handler chain stopped by {handler.func.__name__}")
+                log.debug(f"Handler chain stopped by {handler.func.__name__}")
                 return STOP_CHAIN
             # kobj unmodified
             elif resp is None:
@@ -88,7 +85,7 @@ class KnowledgePipeline:
             # kobj modified by handler
             elif isinstance(resp, KnowledgeObject):
                 kobj = resp
-                logger.debug(f"Knowledge object modified by {handler.func.__name__}")
+                log.debug(f"Knowledge object modified by {handler.func.__name__}")
             else:
                 raise ValueError(f"Handler {handler.func.__name__} returned invalid response '{resp}'")
                     
@@ -107,36 +104,36 @@ class KnowledgePipeline:
         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.debug(f"Handling {kobj!r}")
+        log.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.debug("Local bundle not found")
+                log.debug("Local bundle not found")
                 return
             
             # the bundle (to be deleted) attached to kobj for downstream analysis
-            logger.debug("Adding local bundle (to be deleted) to knowledge object")
+            log.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")
+                log.debug("Manifest not found")
                 if not kobj.source:
                     return
             
-                logger.debug("Attempting to fetch remote manifest from source")
+                log.debug("Attempting to fetch remote manifest from source")
                 payload = self.request_handler.fetch_manifests(
                     node=kobj.source,
                     rids=[kobj.rid]
                 )
                     
                 if not payload.manifests:
-                    logger.debug("Failed to find manifest")
+                    log.debug("Failed to find manifest")
                     return
                 
                 kobj.manifest = payload.manifests[0]
@@ -146,24 +143,24 @@ class KnowledgePipeline:
             
             # attempt to retrieve bundle
             if not kobj.bundle:
-                logger.debug("Bundle not found")
+                log.debug("Bundle not found")
                 if kobj.source is None:
                     return
                 
-                logger.debug("Attempting to fetch remote bundle from source")
+                log.debug("Attempting to fetch remote bundle from source")
                 payload = self.request_handler.fetch_bundles(
                     node=kobj.source,
                     rids=[kobj.rid]
                 )
                 
                 if not payload.bundles:
-                    logger.debug("Failed to find bundle")
+                    log.debug("Failed to find bundle")
                     return
                 
                 bundle = payload.bundles[0]                    
                 
                 if kobj.manifest != bundle.manifest:
-                    logger.warning("Retrieved bundle contains a different manifest")
+                    log.warning("Retrieved bundle contains a different manifest")
                 
                 kobj.manifest = bundle.manifest
                 kobj.contents = bundle.contents                
@@ -172,30 +169,30 @@ class KnowledgePipeline:
         if kobj is STOP_CHAIN: return
             
         if kobj.normalized_event_type in (EventType.UPDATE, EventType.NEW):
-            logger.info(f"Writing to cache: {kobj!r}")
+            log.info(f"Writing to cache: {kobj!r}")
             self.cache.write(kobj.bundle)
             
         elif kobj.normalized_event_type == EventType.FORGET:
-            logger.info(f"Deleting from cache: {kobj!r}")
+            log.info(f"Deleting from cache: {kobj!r}")
             self.cache.delete(kobj.rid)
             
         else:
-            logger.debug("Normalized event type was never set, no cache or network operations will occur")
+            log.debug("Normalized event type was never set, no cache or network operations will occur")
             return
         
         if type(kobj.rid) in (KoiNetNode, KoiNetEdge):
-            logger.debug("Change to node or edge, regenerating network graph")
+            log.debug("Change to node or edge, regenerating network graph")
             self.graph.generate()
         
         kobj = self.call_handler_chain(HandlerType.Network, kobj)
         if kobj is STOP_CHAIN: return
         
         if kobj.network_targets:
-            logger.debug(f"Broadcasting event to {len(kobj.network_targets)} network target(s)")
+            log.debug(f"Broadcasting event to {len(kobj.network_targets)} network target(s)")
         else:
-            logger.debug("No network targets set")
+            log.debug("No network targets set")
         
         for node in kobj.network_targets:
-            self.event_queue.push_event_to(kobj.normalized_event, node)
+            self.event_queue.push(kobj.normalized_event, node)
         
         kobj = self.call_handler_chain(HandlerType.Final, kobj)

koi_net/protocol/api_models.py

@@ -1,6 +1,6 @@
 """Pydantic models for request and response objects in the KOI-net API."""
 
-from typing import Literal
+from typing import Annotated, Literal
 from pydantic import BaseModel, Field
 from rid_lib import RID, RIDType
 from rid_lib.ext import Bundle, Manifest
@@ -60,4 +60,7 @@ class ErrorResponse(BaseModel):
 
 type RequestModels = EventsPayload | PollEvents | FetchRids | FetchManifests | FetchBundles
 type ResponseModels = RidsPayload | ManifestsPayload | BundlesPayload | EventsPayload | ErrorResponse
-type ApiModels = RequestModels | ResponseModels
+type ApiModels = Annotated[
+    RequestModels | ResponseModels,
+    Field(discriminator="type")
+]

koi_net/protocol/envelope.py

@@ -1,4 +1,4 @@
-import logging
+import structlog
 from typing import Generic, TypeVar
 from pydantic import BaseModel, ConfigDict
 from rid_lib.types import KoiNetNode
@@ -6,8 +6,7 @@ from rid_lib.types import KoiNetNode
 from .secure import PrivateKey, PublicKey
 from .api_models import RequestModels, ResponseModels
 
-
-logger = logging.getLogger(__name__)
+log = structlog.stdlib.get_logger()
 
 
 T = TypeVar("T", bound=RequestModels | ResponseModels)
@@ -28,7 +27,7 @@ class SignedEnvelope(BaseModel, Generic[T]):
             target_node=self.target_node 
         )
         
-        logger.debug(f"Verifying envelope: {unsigned_envelope.model_dump_json(exclude_none=True)}")
+        log.debug(f"Verifying envelope: {unsigned_envelope.model_dump_json(exclude_none=True)}")
                 
         pub_key.verify(
             self.signature,
@@ -43,8 +42,8 @@ class UnsignedEnvelope(BaseModel, Generic[T]):
     target_node: KoiNetNode
     
     def sign_with(self, priv_key: PrivateKey) -> SignedEnvelope[T]:
-        logger.debug(f"Signing envelope: {self.model_dump_json(exclude_none=True)}")
-        logger.debug(f"Type: [{type(self.payload)}]")
+        log.debug(f"Signing envelope: {self.model_dump_json(exclude_none=True)}")
+        log.debug(f"Type: [{type(self.payload)}]")
         
         signature = priv_key.sign(
             self.model_dump_json(exclude_none=True).encode()

koi_net/protocol/model_map.py

@@ -0,0 +1,61 @@
+from typing import NamedTuple
+from pydantic import BaseModel
+from .envelope import SignedEnvelope
+from .consts import (
+    BROADCAST_EVENTS_PATH, 
+    POLL_EVENTS_PATH,
+    FETCH_BUNDLES_PATH, 
+    FETCH_MANIFESTS_PATH, 
+    FETCH_RIDS_PATH
+)
+from .api_models import (
+    EventsPayload,
+    PollEvents,
+    FetchBundles,
+    BundlesPayload,
+    FetchManifests,
+    ManifestsPayload,
+    FetchRids,
+    RidsPayload
+)
+
+
+class Models(NamedTuple):
+    request: type[BaseModel]
+    response: type[BaseModel] | None
+    request_envelope: type[SignedEnvelope]
+    response_envelope: type[SignedEnvelope] | None
+
+
+API_MODEL_MAP: dict[str, Models] = {
+    BROADCAST_EVENTS_PATH: Models(
+        request=EventsPayload,
+        response=None,
+        request_envelope=SignedEnvelope[EventsPayload],
+        response_envelope=None
+    ),
+    POLL_EVENTS_PATH: Models(
+        request=PollEvents,
+        response=EventsPayload,
+        request_envelope=SignedEnvelope[PollEvents],
+        response_envelope=SignedEnvelope[EventsPayload]
+    ),
+    FETCH_BUNDLES_PATH: Models(
+        request=FetchBundles,
+        response=BundlesPayload,
+        request_envelope=SignedEnvelope[FetchBundles],
+        response_envelope=SignedEnvelope[BundlesPayload]
+    ),
+    FETCH_MANIFESTS_PATH: Models(
+        request=FetchManifests,
+        response=ManifestsPayload,
+        request_envelope=SignedEnvelope[FetchManifests],
+        response_envelope=SignedEnvelope[ManifestsPayload]
+    ),
+    FETCH_RIDS_PATH: Models(
+        request=FetchRids,
+        response=RidsPayload,
+        request_envelope=SignedEnvelope[FetchRids],
+        response_envelope=SignedEnvelope[RidsPayload]
+    )
+}

koi_net/protocol/node.py

@@ -1,5 +1,5 @@
 from enum import StrEnum
-from pydantic import BaseModel, Field
+from pydantic import BaseModel
 from rid_lib import RIDType
 
 
@@ -8,8 +8,8 @@ class NodeType(StrEnum):
     PARTIAL = "PARTIAL"
 
 class NodeProvides(BaseModel):
-    event: list[RIDType] = Field(default_factory=list)
-    state: list[RIDType] = Field(default_factory=list)
+    event: list[RIDType] = []
+    state: list[RIDType] = []
 
 class NodeProfile(BaseModel):
     base_url: str | None = None

koi_net/protocol/secure.py

@@ -1,4 +1,5 @@
-import logging
+from rid_lib.types import KoiNetNode
+import structlog
 from base64 import b64decode, b64encode
 from cryptography.hazmat.primitives import hashes
 from cryptography.hazmat.primitives.asymmetric import ec
@@ -9,7 +10,7 @@ from cryptography.hazmat.primitives.asymmetric.utils import (
     encode_dss_signature
 )
 
-logger = logging.getLogger(__name__)
+log = structlog.stdlib.get_logger()
 
 
 def der_to_raw_signature(der_signature: bytes, curve=ec.SECP256R1()) -> bytes:
@@ -91,9 +92,9 @@ class PrivateKey:
         
         signature = b64encode(raw_signature_bytes).decode()
         
-        logger.debug(f"Signing message with [{self.public_key().to_der()}]")
-        logger.debug(f"hash: {hashed_message}")
-        logger.debug(f"signature: {signature}")
+        log.debug(f"Signing message with [{self.public_key().to_der()}]")
+        log.debug(f"hash: {hashed_message}")
+        log.debug(f"signature: {signature}")
         
         return signature
                 
@@ -134,6 +135,11 @@ class PublicKey:
             )
         ).decode()
         
+    def to_node_rid(self, name) -> KoiNetNode:
+        return KoiNetNode(
+            name=name,
+            hash=sha256_hash(self.to_der())
+        )
         
     def verify(self, signature: str, message: bytes) -> bool:
         # hashed_message = sha256_hash(message.decode())
@@ -144,9 +150,9 @@ class PublicKey:
         # print()
         # print(message.decode())
 
-        # logger.debug(f"Verifying message with [{self.to_der()}]")
-        # logger.debug(f"hash: {hashed_message}")
-        # logger.debug(f"signature: {signature}")
+        # log.debug(f"Verifying message with [{self.to_der()}]")
+        # log.debug(f"hash: {hashed_message}")
+        # log.debug(f"signature: {signature}")
         
         raw_signature_bytes = b64decode(signature)
         der_signature_bytes = raw_to_der_signature(raw_signature_bytes)

koi_net/secure.py

@@ -1,6 +1,5 @@
-import logging
+import structlog
 from functools import wraps
-
 import cryptography.exceptions
 from rid_lib.ext import Bundle, Cache
 from rid_lib.ext.utils import sha256_hash
@@ -18,9 +17,9 @@ from .protocol.errors import (
     InvalidSignatureError,
     InvalidTargetError
 )
-from .config import NodeConfig
+from .config.core import NodeConfig
 
-logger = logging.getLogger(__name__)
+log = structlog.stdlib.get_logger()
 
 
 class Secure:
@@ -120,15 +119,15 @@ class Secure:
         """
         @wraps(func)
         async def wrapper(req: SignedEnvelope, *args, **kwargs) -> SignedEnvelope | None:
-            logger.info("Validating envelope")
+            log.info("Validating envelope")
             
             self.validate_envelope(req)            
-            logger.info("Calling endpoint handler")
+            log.info("Calling endpoint handler")
             
             result = await func(req, *args, **kwargs)            
             
             if result is not None:
-                logger.info("Creating response envelope")
+                log.info("Creating response envelope")
                 return self.create_envelope(
                     payload=result,
                     target=req.source_node

koi_net/workers/__init__.py

@@ -0,0 +1,2 @@
+from .event_worker import EventProcessingWorker
+from .kobj_worker import KnowledgeProcessingWorker

koi_net/{worker.py → workers/base.py}

@@ -1,5 +1,12 @@
 import threading
 
+
+class End:
+    """Class for a sentinel value by knowledge handlers."""
+    pass
+
+STOP_WORKER = End()
+
 class ThreadWorker:
     thread: threading.Thread
     

koi_net/{processor → workers}/event_worker.py

@@ -1,21 +1,20 @@
 import queue
 import traceback
 import time
-import logging
+import structlog
 
 from rid_lib.ext import Cache
 from rid_lib.types import KoiNetNode
 
-from koi_net.config import NodeConfig
-from koi_net.models import END, QueuedEvent
-from koi_net.network.event_queue import EventQueue
-from koi_net.network.request_handler import RequestHandler
-from koi_net.poll_event_buffer import PollEventBuffer
-from koi_net.protocol.event import Event
-from koi_net.protocol.node import NodeProfile, NodeType
-from koi_net.worker import ThreadWorker
+from ..config.core import NodeConfig
+from ..network.event_queue import EventQueue, QueuedEvent
+from ..network.request_handler import RequestHandler
+from ..network.poll_event_buffer import PollEventBuffer
+from ..protocol.event import Event
+from ..protocol.node import NodeProfile, NodeType
+from .base import ThreadWorker, STOP_WORKER
 
-logger = logging.getLogger(__name__)
+log = structlog.stdlib.get_logger()
 
 
 class EventProcessingWorker(ThreadWorker):
@@ -28,10 +27,7 @@ class EventProcessingWorker(ThreadWorker):
         request_handler: RequestHandler,
         config: NodeConfig,
         cache: Cache,
-        poll_event_buf: PollEventBuffer,
-        queue_timeout: float = 0.1,
-        max_buf_len: int = 5,
-        max_wait_time: float = 1.0
+        poll_event_buf: PollEventBuffer
     ):
         self.event_queue = event_queue
         self.request_handler = request_handler
@@ -40,9 +36,9 @@ class EventProcessingWorker(ThreadWorker):
         self.cache = cache
         self.poll_event_buf = poll_event_buf
         
-        self.timeout = queue_timeout 
-        self.max_buf_len = max_buf_len
-        self.max_wait_time = max_wait_time
+        self.timeout: float = 0.1
+        self.max_buf_len: int = 5
+        self.max_wait_time: float = 1.0
         
         self.event_buffer = dict()
         self.buffer_times = dict()
@@ -67,32 +63,32 @@ class EventProcessingWorker(ThreadWorker):
                 return True
         
             elif node_profile.node_type == NodeType.PARTIAL:
-                self.poll_event_buf.put(item.target, item.event)
+                self.poll_event_buf.push(item.target, item.event)
                 return False
         
         elif item.target == self.config.koi_net.first_contact.rid:
             return True
         
         else:
-            logger.warning(f"Couldn't handle event {item.event!r} in queue, node {item.target!r} unknown to me")
+            log.warning(f"Couldn't handle event {item.event!r} in queue, node {item.target!r} unknown to me")
             return False
         
 
     def run(self):
-        logger.info("Started event worker")
+        log.info("Started event worker")
         while True:
             now = time.time()
             try:
                 item = self.event_queue.q.get(timeout=self.timeout)
                 
                 try:
-                    if item is END:
-                        logger.info("Received 'END' signal, flushing buffer...")
+                    if item is STOP_WORKER:
+                        log.info(f"Received 'STOP_WORKER' signal, flushing buffer...")
                         for target in self.event_buffer.keys():
                             self.flush_buffer(target, self.event_buffer[target])
                         return
                     
-                    logger.info(f"Dequeued {item.event!r} -> {item.target!r}")
+                    log.info(f"Dequeued {item.event!r} -> {item.target!r}")
                     
                     if not self.decide_event(item):
                         continue

koi_net/{kobj_worker.py → workers/kobj_worker.py}

@@ -1,38 +1,37 @@
 import queue
 import traceback
-import logging
+import structlog
 
-from koi_net.models import END
-from koi_net.processor.knowledge_pipeline import KnowledgePipeline
-from koi_net.processor.kobj_queue import KobjQueue
-from koi_net.worker import ThreadWorker
+from ..processor.pipeline import KnowledgePipeline
+from ..processor.kobj_queue import KobjQueue
+from .base import ThreadWorker, STOP_WORKER
 
-logger = logging.getLogger(__name__)
+log = structlog.stdlib.get_logger()
 
 
 class KnowledgeProcessingWorker(ThreadWorker):
     def __init__(
         self,
         kobj_queue: KobjQueue,
-        pipeline: KnowledgePipeline,
-        timeout: float = 0.1
+        pipeline: KnowledgePipeline
     ):
         self.kobj_queue = kobj_queue
         self.pipeline = pipeline
-        self.timeout = timeout
+        self.timeout: float = 0.1
+
         super().__init__()
         
     def run(self):
-        logger.info("Started kobj worker")
+        log.info("Started kobj worker")
         while True:
             try:
                 item = self.kobj_queue.q.get(timeout=self.timeout)
                 try:
-                    if item is END:
-                        logger.info("Received 'END' signal, shutting down...")
+                    if item is STOP_WORKER:
+                        log.info("Received 'STOP_WORKER' signal, shutting down...")
                         return
                     
-                    logger.info(f"Dequeued {item!r}")
+                    log.info(f"Dequeued {item!r}")
                     
                     self.pipeline.process(item)
                 finally:

{koi_net-1.2.0b1.dist-info → koi_net-1.2.0b3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: koi-net
-Version: 1.2.0b1
+Version: 1.2.0b3
 Summary: Implementation of KOI-net protocol in Python
 Project-URL: Homepage, https://github.com/BlockScience/koi-net/
 Author-email: Luke Miller <luke@block.science>
@@ -36,6 +36,7 @@ Requires-Dist: python-dotenv>=1.1.0
 Requires-Dist: rich>=14.1.0
 Requires-Dist: rid-lib>=3.2.7
 Requires-Dist: ruamel-yaml>=0.18.10
+Requires-Dist: structlog>=25.4.0
 Requires-Dist: uvicorn>=0.34.2
 Provides-Extra: dev
 Requires-Dist: build; extra == 'dev'

koi_net-1.2.0b3.dist-info/RECORD

@@ -0,0 +1,56 @@
+koi_net/__init__.py,sha256=9z9lpKDuE7KF-evTBkAZechSvL9eQL4p0-ksmwZwMMU,21
+koi_net/assembler.py,sha256=XR-e0-XHlrbXrZPJoO0tKaPH2xJ80KckfcjOeu9qr4o,3229
+koi_net/core.py,sha256=gnR7moGHYkXHUxoV-mJRxi-tKZuPqvG9lg0jiVfAjXg,2257
+koi_net/default_actions.py,sha256=2y7f9rUaENYRO8traTZbEQ7ySFZP_P8pUqf82bZj8Gk,602
+koi_net/effector.py,sha256=fZEIBtvQQZmJx6HIcRB0jjP_EE00GREWuMQJ5m0uXOc,4937
+koi_net/handshaker.py,sha256=d6s2R2eYxbOfpvRafKHNb_dD7LRdTkF4IsqFu7jQ-sQ,1211
+koi_net/identity.py,sha256=-5YYda4xQ78EeGBspN9whWTuWttsUhZ8gxT2oLDEkpI,574
+koi_net/lifecycle.py,sha256=axmr9KfEXzDT5HMVTVC6komMm9pdPQcODkudp7xVZ1k,4750
+koi_net/logger.py,sha256=EzpQNvNrbi5LmMCobyuN1_wOz5VuMDeaPbLcyMrLKGI,6172
+koi_net/secure.py,sha256=SUJqXScoSXgBs5PeeKtRKyDqGf35tGeNhXhwFa61IXE,4915
+koi_net/utils.py,sha256=4K6BqtifExDUfPP8zJAICgPV1mcabz_MaFB0P0fSnic,411
+koi_net/cli/__init__.py,sha256=Vpq0yLN0ROyF0qQYsyiuWFbjs-zsa90G1DpAv13qaiw,25
+koi_net/cli/commands.py,sha256=5eVsvJAnHjwJdt8MNYrk5zSzWWm1ooiP35bJeQxYIq4,2592
+koi_net/cli/models.py,sha256=9x66SSmIezw61KFbdk7VNoPQTi9JQGxtIlfWMNt5ZfU,1158
+koi_net/config/core.py,sha256=RogkUeDHoQzpvZugqqk_8BkJiGVJX8ekLAZwYXtmsxs,2256
+koi_net/config/full_node.py,sha256=sVxraN_fyM_jFHBhG7LEALHOlYbRvPIONuci8ws_bcA,945
+koi_net/config/loader.py,sha256=3vFVz0V8pv6Ohq9pSMTpa40stYOlFB2do-aBKo7Wr8c,1311
+koi_net/config/partial_node.py,sha256=ALfYXJ4lrMFhKt1nAr-Zn8HBVw9YLBSbN9ykEdwc91E,497
+koi_net/entrypoints/__init__.py,sha256=DdKtM7uXYYZLDaHkzYVOVQh-g2S3bG0xdGAFXok6tj8,61
+koi_net/entrypoints/base.py,sha256=nuaWRD4_0u5Cmieq4MiiJ2NrwOnoC4iaP4ulXXiInmI,85
+koi_net/entrypoints/poller.py,sha256=5oo5Zj2fD43qkE7ai1M_PQi9vxDGbXPoZ4pAjL2H8X4,1472
+koi_net/entrypoints/server.py,sha256=gbmRnSPo-OEaK2TyzTJ_1t-DlmtyARNSiqb07tq74bE,3090
+koi_net/network/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+koi_net/network/error_handler.py,sha256=ZH0Py-XuSsnQiSB6rVZ2pywvMcKHr_VywnAiTI8RKEw,1780
+koi_net/network/event_queue.py,sha256=vPrC5-QS0s57ALjdt2ddhNcSMwbvGakCvCKBMx4U6pw,734
+koi_net/network/graph.py,sha256=ZJ1CY-SnYhnZAMm3e9YCbBflk80ZDETnoQKaBk5kLgo,4161
+koi_net/network/poll_event_buffer.py,sha256=Wh4JcGnFaTHbveCzLWcqOzXAU_yk9EkUsukX5hI3pn8,735
+koi_net/network/request_handler.py,sha256=XSX-JAqRua42YOakmia--9NnKcT32Fpoc-7aYfjDpwg,6752
+koi_net/network/resolver.py,sha256=wg9yyJkZbS1G251u4tVav9SeIpH_Aq7FE0rLPvExn3g,5282
+koi_net/network/response_handler.py,sha256=6GewpouDqMl1Ozgfkro_EcUqeJZEfY7msi1U7TQigCY,4212
+koi_net/processor/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+koi_net/processor/context.py,sha256=64rUQ6Oy3wbA5CtH40hqW7_ZPVDj4Wzw7dtVC0yIxkY,1323
+koi_net/processor/handler.py,sha256=3z1PreLRH_48HU6o9lUD_5CAOgA8O9PuSB9iAusVa_c,2510
+koi_net/processor/knowledge_handlers.py,sha256=H0DTHg2JI4_FvpafHjTMFC2mjjtgTCAew1s7V_fzajE,10908
+koi_net/processor/knowledge_object.py,sha256=NJBNxzYdt_JNYpA71E1vaOuZNIKrkxRpK8l459mjbnc,4129
+koi_net/processor/kobj_queue.py,sha256=tM_ssv2t_2t2A0w_X6rq-Gfxzl0NGCjt387dqTGxKxM,1833
+koi_net/processor/pipeline.py,sha256=4CkOMOXyJ4J17Y5ulnlqJVnINjYqCGI1MBRz2oKylRM,8658
+koi_net/protocol/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+koi_net/protocol/api_models.py,sha256=lPd_w-sncyrQlTQ__iae9Li1lFARu8nKiMMlXu7-Hls,1856
+koi_net/protocol/consts.py,sha256=bisbVEojPIHlLhkLafBzfIhH25TjNfvTORF1g6YXzIM,243
+koi_net/protocol/edge.py,sha256=PzdEhC43T1KO5iMSEu7I4tiz-7sZxtz41dJfWf-oHA0,1034
+koi_net/protocol/envelope.py,sha256=4SKF4tP1P1ex7UEmYOJt7IP9_8fCWsa_o6ZBOu8SOKk,1877
+koi_net/protocol/errors.py,sha256=uKPQ-TGLouZuK0xd2pXuCQoRTyu_JFsydSCLml13Cz8,595
+koi_net/protocol/event.py,sha256=HxzLN-iCXPyr2YzrswMIkgZYeUdFbBpa5v98dAB06lQ,1328
+koi_net/protocol/model_map.py,sha256=W0quo25HqVkzp8HQ7l_FNTtN4ZX0u7MIqp68Ir81fuk,1671
+koi_net/protocol/node.py,sha256=7GQzHORFr9cP4BqJgir6EGSWCskL-yqmvJksIiLfcWU,409
+koi_net/protocol/secure.py,sha256=_JRwPLLqifQQG_Z8QGeHfICX-pvOsppGvDy6_q8U8I8,5298
+koi_net/workers/__init__.py,sha256=cTCXr4X_ONobHJxN0H8x3hvMgDpQnt7AeDbvcWzyz6Y,98
+koi_net/workers/base.py,sha256=IvtXBTVmthUrURmB9Cn9wffeVv9_Cphsk97_GCLb5NQ,294
+koi_net/workers/event_worker.py,sha256=Z-sShvc0jY3bNqN_P3INhAXFNKWP02YAyhzIFX984lk,4140
+koi_net/workers/kobj_worker.py,sha256=VKGZZZMzSjp1NtuNGCUMmOxRFL0YwbLpTd6XlkQWfF0,1239
+koi_net-1.2.0b3.dist-info/METADATA,sha256=PM-J7K9mH88xHgSeuDpcawOAQU8J8W3BqUJJ90cTUGY,37347
+koi_net-1.2.0b3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+koi_net-1.2.0b3.dist-info/entry_points.txt,sha256=l7He_JTyXrfKIHkttnPWXHI717v8WpLLfCduL5QcEWA,40
+koi_net-1.2.0b3.dist-info/licenses/LICENSE,sha256=03mgCL5qth2aD9C3F3qNVs4sFJSpK9kjtYCyOwdSp7s,1069
+koi_net-1.2.0b3.dist-info/RECORD,,