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

koi_net/config.py

@@ -29,6 +29,7 @@ class KoiNetConfig(BaseModel):
     cache_directory_path: str = ".rid_cache"
     event_queues_path: str = "event_queues.json"
     private_key_pem_path: str = "priv_key.pem"
+    polling_interval: int = 5
     
     first_contact: NodeContact = Field(default_factory=NodeContact)
     

koi_net/core.py

@@ -1,5 +1,5 @@
 import logging
-import httpx
+from typing import Generic, TypeVar
 from rid_lib.ext import Cache
 from .network.resolver import NetworkResolver
 from .network.event_queue import NetworkEventQueue
@@ -17,14 +17,18 @@ from .secure import Secure
 from .config import NodeConfig
 from .context import HandlerContext, ActionContext
 from .effector import Effector
+from .server import NodeServer
+from .lifecycle import NodeLifecycle
+from .poller import NodePoller
 from . import default_actions
 
 logger = logging.getLogger(__name__)
 
 
+T = TypeVar("T", bound=NodeConfig)
 
-class NodeInterface:
-    config: NodeConfig
+class NodeInterface(Generic[T]):
+    config: T
     cache: Cache
     identity: NodeIdentity
     resolver: NetworkResolver
@@ -32,66 +36,81 @@ class NodeInterface:
     graph: NetworkGraph
     processor: ProcessorInterface
     secure: Secure
+    server: NodeServer
     
     use_kobj_processor_thread: bool
     
     def __init__(
-        self, 
-        config: NodeConfig,
+        self,
+        config: T,
         use_kobj_processor_thread: bool = False,
-        
         handlers: list[KnowledgeHandler] | None = None,
         
-        cache: Cache | None = None,
-        processor: ProcessorInterface | None = None
+        CacheOverride: type[Cache] | None = None,
+        NodeIdentityOverride: type[NodeIdentity] | None = None,
+        EffectorOverride: type[Effector] | None = None,
+        NetworkGraphOverride: type[NetworkGraph] | None = None,
+        SecureOverride: type[Secure] | None = None,
+        RequestHandlerOverride: type[RequestHandler] | None = None,
+        ResponseHandlerOverride: type[ResponseHandler] | None = None,
+        NetworkResolverOverride: type[NetworkResolver] | None = None,
+        NetworkEventQueueOverride: type[NetworkEventQueue] | None = None,
+        ActorOverride: type[Actor] | None = None,
+        ActionContextOverride: type[ActionContext] | None = None,
+        HandlerContextOverride: type[HandlerContext] | None = None,
+        KnowledgePipelineOverride: type[KnowledgePipeline] | None = None,
+        ProcessorInterfaceOverride: type[ProcessorInterface] | None = None,
+        ErrorHandlerOverride: type[ErrorHandler] | None = None,
+        NodeLifecycleOverride: type[NodeLifecycle] | None = None,
+        NodeServerOverride: type[NodeServer] | None = None,
+        NodePollerOverride: type[NodePoller] | None = None,        
     ):
         self.config = config
-        self.cache = cache or Cache(
+        self.cache = (CacheOverride or Cache)(
             directory_path=self.config.koi_net.cache_directory_path
         )
-        
-        self.identity = NodeIdentity(config=self.config)
-        
-        self.effector = Effector(cache=self.cache)
 
-        self.graph = NetworkGraph(
-            cache=self.cache, 
+        self.identity = (NodeIdentityOverride or NodeIdentity)(config=self.config)
+        self.effector = (EffectorOverride or Effector)(cache=self.cache)
+
+        self.graph = (NetworkGraphOverride or NetworkGraph)(
+            cache=self.cache,
             identity=self.identity
         )
-        
-        self.secure = Secure(
-            identity=self.identity, 
-            effector=self.effector, 
+
+        self.secure = (SecureOverride or Secure)(
+            identity=self.identity,
+            effector=self.effector,
             config=self.config
         )
-        
-        self.request_handler = RequestHandler(
-            effector=self.effector, 
+
+        self.request_handler = (RequestHandlerOverride or RequestHandler)(
+            effector=self.effector,
             identity=self.identity,
             secure=self.secure
         )
-        
-        self.response_handler = ResponseHandler(self.cache, self.effector)
-        
-        self.resolver = NetworkResolver(
+
+        self.response_handler = (ResponseHandlerOverride or ResponseHandler)(self.cache, self.effector)
+
+        self.resolver = (NetworkResolverOverride or NetworkResolver)(
             config=self.config,
-            cache=self.cache, 
+            cache=self.cache,
             identity=self.identity,
             graph=self.graph,
             request_handler=self.request_handler,
             effector=self.effector
         )
-        
-        self.event_queue = NetworkEventQueue(
+
+        self.event_queue = (NetworkEventQueueOverride or NetworkEventQueue)(
             config=self.config,
-            cache=self.cache, 
+            cache=self.cache,
             identity=self.identity,
             graph=self.graph,
             request_handler=self.request_handler,
             effector=self.effector
         )
         
-        self.actor = Actor(
+        self.actor = (ActorOverride or Actor)(
             identity=self.identity,
             effector=self.effector,
             event_queue=self.event_queue
@@ -106,12 +125,12 @@ class NodeInterface:
 
         self.use_kobj_processor_thread = use_kobj_processor_thread
         
-        self.action_context = ActionContext(
+        self.action_context = (ActionContextOverride or ActionContext)(
             identity=self.identity,
             effector=self.effector
         )
         
-        self.handler_context = HandlerContext(
+        self.handler_context = (HandlerContextOverride or HandlerContext)(
             identity=self.identity,
             cache=self.cache,
             event_queue=self.event_queue,
@@ -120,7 +139,7 @@ class NodeInterface:
             effector=self.effector
         )
         
-        self.pipeline = KnowledgePipeline(
+        self.pipeline = (KnowledgePipelineOverride or KnowledgePipeline)(
             handler_context=self.handler_context,
             cache=self.cache,
             request_handler=self.request_handler,
@@ -129,12 +148,12 @@ class NodeInterface:
             default_handlers=handlers
         )
         
-        self.processor = processor or ProcessorInterface(
+        self.processor = (ProcessorInterfaceOverride or ProcessorInterface)(
             pipeline=self.pipeline,
             use_kobj_processor_thread=self.use_kobj_processor_thread
         )
         
-        self.error_handler = ErrorHandler(
+        self.error_handler = (ErrorHandlerOverride or ErrorHandler)(
             processor=self.processor,
             actor=self.actor
         )
@@ -146,47 +165,30 @@ class NodeInterface:
         self.effector.set_processor(self.processor)
         self.effector.set_resolver(self.resolver)
         self.effector.set_action_context(self.action_context)
-         
-            
-    def start(self) -> None:
-        """Starts a node, call this method first.
-        
-        Starts the processor thread (if enabled). Loads event queues into memory. Generates network graph from nodes and edges in cache. Processes any state changes of node bundle. Initiates handshake with first contact (if provided) if node doesn't have any neighbors.
-        """
-        if self.use_kobj_processor_thread:
-            logger.info("Starting processor worker thread")
-            self.processor.worker_thread.start()
-        
-        # self.network._load_event_queues()
-        self.graph.generate()
-        
-        # refresh to reflect changes (if any) in config.yaml
-        self.effector.deref(self.identity.rid, refresh_cache=True)
-                
-        logger.debug("Waiting for kobj queue to empty")
-        if self.use_kobj_processor_thread:
-            self.processor.kobj_queue.join()
-        else:
-            self.processor.flush_kobj_queue()
-        logger.debug("Done")
-    
-        if not self.graph.get_neighbors() and self.config.koi_net.first_contact.rid:
-            logger.debug(f"I don't have any neighbors, reaching out to first contact {self.config.koi_net.first_contact.rid!r}")
-            
-            self.actor.handshake_with(self.config.koi_net.first_contact.rid)
-            
-                        
-    def stop(self):
-        """Stops a node, call this method last.
         
-        Finishes processing knowledge object queue. Saves event queues to storage.
-        """
-        logger.info("Stopping node...")
+        self.lifecycle = (NodeLifecycleOverride or NodeLifecycle)(
+            config=self.config,
+            identity=self.identity,
+            graph=self.graph,
+            processor=self.processor,
+            effector=self.effector,
+            actor=self.actor,
+            use_kobj_processor_thread=use_kobj_processor_thread
+        )
         
-        if self.use_kobj_processor_thread:
-            logger.info(f"Waiting for kobj queue to empty ({self.processor.kobj_queue.unfinished_tasks} tasks remaining)")
-            self.processor.kobj_queue.join()
-        else:
-            self.processor.flush_kobj_queue()
+        # if self.config.koi_net.node_profile.node_type == NodeType.FULL:
+        self.server = (NodeServerOverride or NodeServer)(
+            config=self.config,
+            lifecycle=self.lifecycle,
+            secure=self.secure,
+            processor=self.processor,
+            event_queue=self.event_queue,
+            response_handler=self.response_handler
+        )
         
-        # self.network._save_event_queues()
+        self.poller = (NodePollerOverride or NodePoller)(
+            processor=self.processor,
+            lifecycle=self.lifecycle,
+            resolver=self.resolver,
+            config=self.config
+        )

koi_net/lifecycle.py

@@ -0,0 +1,76 @@
+import logging
+
+from .network.behavior import Actor
+from .effector import Effector
+from .config import NodeConfig
+from .processor.interface import ProcessorInterface
+from .network.graph import NetworkGraph
+from .identity import NodeIdentity
+
+logger = logging.getLogger(__name__)
+
+
+class NodeLifecycle:
+    config: NodeConfig
+    graph: NetworkGraph
+    processor: ProcessorInterface
+    effector: Effector
+    actor: Actor
+    
+    def __init__(
+        self,
+        config: NodeConfig,
+        identity: NodeIdentity,
+        graph: NetworkGraph,
+        processor: ProcessorInterface,
+        effector: Effector,
+        actor: Actor,
+        use_kobj_processor_thread: bool
+    ):
+        self.config = config
+        self.identity = identity
+        self.graph = graph
+        self.processor = processor
+        self.effector = effector
+        self.actor = actor
+        self.use_kobj_processor_thread = use_kobj_processor_thread
+    
+    def start(self) -> None:
+        """Starts a node, call this method first.
+        
+        Starts the processor thread (if enabled). Loads event queues into memory. Generates network graph from nodes and edges in cache. Processes any state changes of node bundle. Initiates handshake with first contact (if provided) if node doesn't have any neighbors.
+        """
+        if self.use_kobj_processor_thread:
+            logger.info("Starting processor worker thread")
+            self.processor.worker_thread.start()
+        
+        self.graph.generate()
+        
+        # refresh to reflect changes (if any) in config.yaml
+        self.effector.deref(self.identity.rid, refresh_cache=True)
+                
+        logger.debug("Waiting for kobj queue to empty")
+        if self.use_kobj_processor_thread:
+            self.processor.kobj_queue.join()
+        else:
+            self.processor.flush_kobj_queue()
+        logger.debug("Done")
+    
+        if not self.graph.get_neighbors() and self.config.koi_net.first_contact.rid:
+            logger.debug(f"I don't have any neighbors, reaching out to first contact {self.config.koi_net.first_contact.rid!r}")
+            
+            self.actor.handshake_with(self.config.koi_net.first_contact.rid)
+            
+                        
+    def stop(self):
+        """Stops a node, call this method last.
+        
+        Finishes processing knowledge object queue. Saves event queues to storage.
+        """
+        logger.info("Stopping node...")
+        
+        if self.use_kobj_processor_thread:
+            logger.info(f"Waiting for kobj queue to empty ({self.processor.kobj_queue.unfinished_tasks} tasks remaining)")
+            self.processor.kobj_queue.join()
+        else:
+            self.processor.flush_kobj_queue()

koi_net/network/response_handler.py

@@ -1,5 +1,6 @@
 import logging
 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
 
@@ -30,13 +31,13 @@ class ResponseHandler:
         self.cache = cache
         self.effector = effector
         
-    def fetch_rids(self, req: FetchRids) -> RidsPayload:
+    def fetch_rids(self, req: FetchRids, source: KoiNetNode) -> RidsPayload:
         logger.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) -> ManifestsPayload:
+    def fetch_manifests(self, req: FetchManifests, source: KoiNetNode) -> ManifestsPayload:
         logger.info(f"Request to fetch manifests, allowed types {req.rid_types}, rids {req.rids}")
         
         manifests: list[Manifest] = []
@@ -51,7 +52,7 @@ class ResponseHandler:
         
         return ManifestsPayload(manifests=manifests, not_found=not_found)
         
-    def fetch_bundles(self, req: FetchBundles) -> BundlesPayload:
+    def fetch_bundles(self, req: FetchBundles, source: KoiNetNode) -> BundlesPayload:
         logger.info(f"Request to fetch bundles, requested rids {req.rids}")
         
         bundles: list[Bundle] = []

koi_net/poller.py

@@ -0,0 +1,47 @@
+
+import time
+import logging
+from .processor.interface import ProcessorInterface
+from .lifecycle import NodeLifecycle
+from .network.resolver import NetworkResolver
+from .config import NodeConfig
+
+logger = logging.getLogger(__name__)
+
+
+class NodePoller:
+    def __init__(
+        self,
+        processor: ProcessorInterface,
+        lifecycle: NodeLifecycle,
+        resolver: NetworkResolver,
+        config: NodeConfig
+    ):
+        self.processor = processor
+        self.lifecycle = lifecycle
+        self.resolver = resolver
+        self.config = config
+
+    def poll(self):
+        neighbors = self.resolver.poll_neighbors()
+        for node_rid in neighbors:
+            for event in neighbors[node_rid]:
+                self.processor.handle(event=event, source=node_rid)
+        self.processor.flush_kobj_queue()
+
+    def run(self):
+        try:
+            self.lifecycle.start()
+            while True:
+                start_time = time.time()
+                self.poll()
+                elapsed = time.time() - start_time
+                sleep_time = self.config.koi_net.polling_interval - elapsed
+                if sleep_time > 0:
+                    time.sleep(sleep_time)
+                    
+        except KeyboardInterrupt:
+            logger.info("Polling interrupted by user.")
+            
+        finally:
+            self.lifecycle.stop()

koi_net/server.py

@@ -0,0 +1,128 @@
+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):
+        self.app = FastAPI(
+            lifespan=self.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"]
+            )
+        
+        _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
+        )
+        
+    @asynccontextmanager
+    async def lifespan(self, app: FastAPI):
+        self.lifecycle.start()
+        yield
+        self.lifecycle.stop()
+
+    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.1.0b1.dist-info → koi_net-1.1.0b3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: koi-net
-Version: 1.1.0b1
+Version: 1.1.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>
@@ -28,19 +28,19 @@ License: MIT License
 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.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.0b1.dist-info → koi_net-1.1.0b3.dist-info}/RECORD

@@ -1,11 +1,14 @@
 koi_net/__init__.py,sha256=b0Ze0pZmJAuygpWUFHM6Kvqo3DkU_uzmkptv1EpAArw,31
-koi_net/config.py,sha256=Zu6iVPQ1yar9OMZQp-Ez0eYRIoCeDq69eTQyYplQqQc,4057
+koi_net/config.py,sha256=47XbQ59GRYFi4rlsoWKlnzMQATcnK70i3qmKTZAGOQk,4087
 koi_net/context.py,sha256=JmbpCzusXFq_NCXiUp5Z56N6vpBdYMUK8eOs7ogO68A,1428
-koi_net/core.py,sha256=QIYRlvi5BFxaQKYrbI8CGs2yZxf-U6PeJlYBaG6HsLQ,6474
+koi_net/core.py,sha256=jF3xhIhaKrClutmumHO6MjOlA_L5UNU1BUOsxFuHQAI,7068
 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=-J5y4i0JdernatLTed8hQbkK26Cs6rm1kZqlx3aQzZA,2727
+koi_net/poller.py,sha256=ZvQcZ0RQhViXVhbIpdTZb7_ql3nG0mTcdBamneZKLpA,1361
 koi_net/secure.py,sha256=cGNF2assqCaYq0i0fhQBm7aREoAdpY-XVypDsE1ALaU,3970
+koi_net/server.py,sha256=5BVVrgn69r_HMC3c4npWywPsjBDqUnHFWLKdtnfRTbA,4250
 koi_net/network/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 koi_net/network/behavior.py,sha256=NZLvWlrxR0uWriE3ZzCXmocUVccQthy7Xx8E_8KBwsg,1208
 koi_net/network/error_handler.py,sha256=CrmCpBY2oj4nl7uXrIYusUHDKxPZ1HDuQAtiBSZarRI,1623
@@ -13,7 +16,7 @@ koi_net/network/event_queue.py,sha256=QV1dLOe-H85fNJVkc-e0ZRsUpHTkFcMLMbp3WU5gRN
 koi_net/network/graph.py,sha256=NLstBsPa9By0luxcTjThnqVd3hxfQdFwn8tWgJ6u4l4,4144
 koi_net/network/request_handler.py,sha256=77SHLO92gVHTusUXWo89KgjRnxU9vLG_Qi8HxTFtFBg,6376
 koi_net/network/resolver.py,sha256=coIp4M6k0-8sUfAy4h2NMx_7zCNroWlCHKOj3AXZVhc,5412
-koi_net/network/response_handler.py,sha256=tEfzSZWXKCRwUlXhM8Qp3Y6BKTQ4abfi-MrSaatlITI,1980
+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=SX1eP740W9LeG-IEoBOmsNrKJfOEDDuEQUSwnJEG_8w,8954
 koi_net/processor/handler.py,sha256=_loaHjgVGVUxtCQdvAY9dQ0iqiq5co7wB2tK-usuv3Y,2355
@@ -29,7 +32,7 @@ koi_net/protocol/errors.py,sha256=A83QiYe_fJdxW2lsNsLCujWxDr5sk1UmYYd3TGbSNJA,60
 koi_net/protocol/event.py,sha256=eGgihEj1gliLoQRk8pVB2q_was0AGo-PbT3Hqnpn3oU,1379
 koi_net/protocol/node.py,sha256=7GQzHORFr9cP4BqJgir6EGSWCskL-yqmvJksIiLfcWU,409
 koi_net/protocol/secure.py,sha256=Reem9Z4le4uWXM9uczNOdmgVBg8p4YQav-7_c3pZ1CQ,3366
-koi_net-1.1.0b1.dist-info/METADATA,sha256=pHwaqM6wXoQpOUINUBlLlmCnSv3nEHF-EbL5x42jf3s,37142
-koi_net-1.1.0b1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-koi_net-1.1.0b1.dist-info/licenses/LICENSE,sha256=03mgCL5qth2aD9C3F3qNVs4sFJSpK9kjtYCyOwdSp7s,1069
-koi_net-1.1.0b1.dist-info/RECORD,,
+koi_net-1.1.0b3.dist-info/METADATA,sha256=LEE8Js4IHoORcyZ7Hoy6kgggQxwbaYCurbs0AEmnQUs,37118
+koi_net-1.1.0b3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+koi_net-1.1.0b3.dist-info/licenses/LICENSE,sha256=03mgCL5qth2aD9C3F3qNVs4sFJSpK9kjtYCyOwdSp7s,1069
+koi_net-1.1.0b3.dist-info/RECORD,,