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

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,28 +169,28 @@ 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)

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/secure.py

@@ -1,4 +1,4 @@
-import logging
+import structlog
 from base64 import b64decode, b64encode
 from cryptography.hazmat.primitives import hashes
 from cryptography.hazmat.primitives.asymmetric import ec
@@ -9,7 +9,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 +91,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
                 
@@ -144,9 +144,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,4 +1,4 @@
-import logging
+import structlog
 from functools import wraps
 
 import cryptography.exceptions
@@ -20,7 +20,7 @@ from .protocol.errors import (
 )
 from .config import NodeConfig
 
-logger = logging.getLogger(__name__)
+log = structlog.stdlib.get_logger()
 
 
 class Secure:
@@ -120,15 +120,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/sentry.py

@@ -0,0 +1,13 @@
+# import sentry_sdk
+# from sentry_sdk.integrations.logging import LoggingIntegration
+
+# sentry_sdk.init(
+#     dsn="https://7bbafef3c7dbd652506db3cb2aca9f98@o4510149352357888.ingest.us.sentry.io/4510149355765760",
+#     # Add data like request headers and IP for users,
+#     # see https://docs.sentry.io/platforms/python/data-management/data-collected/ for more info
+#     send_default_pii=True,
+#     enable_logs=True,
+#     integrations=[
+#         LoggingIntegration(sentry_logs_level=None)
+#     ]
+# )

koi_net/server.py

@@ -1,46 +1,25 @@
-import logging
+import structlog
 import uvicorn
 from contextlib import asynccontextmanager
 from fastapi import FastAPI, APIRouter
 from fastapi.responses import JSONResponse
 
-from koi_net.poll_event_buffer import PollEventBuffer
+from koi_net.interfaces.entrypoint import EntryPoint
+
 from .network.response_handler import ResponseHandler
-from .processor.kobj_queue import KobjQueue
-from .protocol.api_models import (
-    PollEvents,
-    FetchRids,
-    FetchManifests,
-    FetchBundles,
-    EventsPayload,
-    RidsPayload,
-    ManifestsPayload,
-    BundlesPayload,
-    ErrorResponse
-)
+from .protocol.model_map import API_MODEL_MAP
+from .protocol.api_models import 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__)
+log = structlog.stdlib.get_logger()
 
 
-class NodeServer:
+class NodeServer(EntryPoint):
     """Manages FastAPI server and event handling for full nodes."""
     config: NodeConfig
     lifecycle: NodeLifecycle
-    secure: Secure
-    kobj_queue: KobjQueue
-    poll_event_buf: PollEventBuffer
     response_handler: ResponseHandler
     app: FastAPI
     router: APIRouter
@@ -49,16 +28,10 @@ class NodeServer:
         self,
         config: NodeConfig,
         lifecycle: NodeLifecycle,
-        secure: Secure,
-        kobj_queue: KobjQueue,
-        poll_event_buf: PollEventBuffer,
-        response_handler: ResponseHandler
+        response_handler: ResponseHandler,
     ):
         self.config = config
         self.lifecycle = lifecycle
-        self.secure = secure
-        self.kobj_queue = kobj_queue
-        self.poll_event_buf = poll_event_buf
         self.response_handler = response_handler
         self._build_app()
         
@@ -75,71 +48,48 @@ class NodeServer:
             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 = APIRouter(prefix="/koi-net")
+        
+        for path, models in API_MODEL_MAP.items():
+            def create_endpoint(path: str):
+                async def endpoint(req):
+                    return self.response_handler.handle_response(path, req)
+                
+                # programmatically setting type hint annotations for FastAPI's model validation 
+                endpoint.__annotations__ = {
+                    "req": models.request_envelope,
+                    "return": models.response_envelope
+                }
+                
+                return endpoint
+            
             self.router.add_api_route(
                 path=path,
-                endpoint=self.secure.envelope_handler(func),
+                endpoint=create_endpoint(path),
                 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):
-        """Starts FastAPI server and event handler."""
-        uvicorn.run(
-            app=self.app,
-            host=self.config.server.host,
-            port=self.config.server.port
-        )
         
     def protocol_error_handler(self, request, exc: ProtocolError):
         """Catches `ProtocolError` and returns as `ErrorResponse`."""
-        logger.info(f"caught protocol error: {exc}")
+        log.info(f"caught protocol error: {exc}")
         resp = ErrorResponse(error=exc.error_type)
-        logger.info(f"returning error response: {resp}")
+        log.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]):
-        """Handles events broadcast endpoint."""
-        logger.info(f"Request to {BROADCAST_EVENTS_PATH}, received {len(req.payload.events)} event(s)")
-        for event in req.payload.events:
-            self.kobj_queue.put_kobj(event=event, source=req.source_node)
-        
-    async def poll_events(
-        self, req: SignedEnvelope[PollEvents]
-    ) -> SignedEnvelope[EventsPayload] | ErrorResponse:
-        """Handles poll events endpoint."""
-        logger.info(f"Request to {POLL_EVENTS_PATH}")
-        events = self.poll_event_buf.flush(req.source_node)
-        return EventsPayload(events=events)
-
-    async def fetch_rids(
-        self, req: SignedEnvelope[FetchRids]
-    ) -> SignedEnvelope[RidsPayload] | ErrorResponse:
-        """Handles fetch RIDs endpoint."""
-        return self.response_handler.fetch_rids(req.payload, req.source_node)
-
-    async def fetch_manifests(
-        self, req: SignedEnvelope[FetchManifests]
-    ) -> SignedEnvelope[ManifestsPayload] | ErrorResponse:
-        """Handles fetch manifests endpoint."""
-        return self.response_handler.fetch_manifests(req.payload, req.source_node)
-
-    async def fetch_bundles(
-        self, req: SignedEnvelope[FetchBundles]
-    ) -> SignedEnvelope[BundlesPayload] | ErrorResponse:
-        """Handles fetch bundles endpoint."""
-        return self.response_handler.fetch_bundles(req.payload, req.source_node)
+    
+    def run(self):
+        """Starts FastAPI server and event handler."""
+        uvicorn.run(
+            app=self.app,
+            host=self.config.server.host,
+            port=self.config.server.port,
+            log_config=None,
+            access_log=False
+        )

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: koi-net
-Version: 1.2.0b1
+Version: 1.2.0b2
 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.0b2.dist-info/RECORD

@@ -0,0 +1,52 @@
+koi_net/__init__.py,sha256=ZJQHfYaMtu3Qv6ZtKxq49N0T1GbVd3dvrjXZdeNYnQw,41
+koi_net/assembler.py,sha256=kV7qB1xnPvAVUrunaNgx4f9lb2qQlvlA4zZs1xKq62Q,2831
+koi_net/config.py,sha256=yV53GFQrJchyKKRs3sOhj27pyM6rwiUhIgDZ81rvZ48,5238
+koi_net/context.py,sha256=mBKMR1o6Tqy_cyhj7_niGkMSMOQeEMPhP9cpNDlML1s,1323
+koi_net/core.py,sha256=owbJYN_kCMwKz3ecWXt_tQXOEECL_q1uq4CcFAuR6EA,2428
+koi_net/default_actions.py,sha256=y9oaDeb3jJGSvVbuonmyGWkKWlzpEX3V32MjgEuYWc8,622
+koi_net/effector.py,sha256=0hW2NnHWjVZyRPXWh_X_0EBxqpCJBBhJCHFvB6uC3SM,4941
+koi_net/handshaker.py,sha256=sd2bYe7Fh5hCTq5q18_knKWAMzvH5a6zHzCcBKbkhWQ,1229
+koi_net/identity.py,sha256=jZjTSlgO8aJhfOx6-ppQVveHih6h0dP2Gtbsw6GGdTI,569
+koi_net/lifecycle.py,sha256=AhJCkXHuBhUHMXXAzI3akz0pTRE77aNEHwjsnbe98TE,4775
+koi_net/logger.py,sha256=EzpQNvNrbi5LmMCobyuN1_wOz5VuMDeaPbLcyMrLKGI,6172
+koi_net/poller.py,sha256=OZLYAMHxXxM75ENetHd_nnNaiiZTSpMgeP3xxAphVEg,1463
+koi_net/secure.py,sha256=qayAzO7xWF8wa33rmNCTupVVaYXwNuimlXpPFWJfQT8,4911
+koi_net/sentry.py,sha256=9UCVMPoEzua3KMUHe4inciqEnqTF_gNSQO2zhpUN8ts,506
+koi_net/server.py,sha256=GJbkHp2BmDhSHWdF6PObLus7f0BiMZuhcZALj7kNiF4,3087
+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=ON-rqMgHDng3J2hbBbGYzkynaWc9Tq4QfOJIu_6pFuA,1190
+koi_net/interfaces/entrypoint.py,sha256=8FEG1r0YIws_1AojTtIPWB-Th3GOS3U2qi89RlyBJYs,80
+koi_net/interfaces/worker.py,sha256=IvtXBTVmthUrURmB9Cn9wffeVv9_Cphsk97_GCLb5NQ,294
+koi_net/network/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+koi_net/network/error_handler.py,sha256=4i_r7EWBW52_bhdmyU-1A_Cnu0Q-jHO9O1EXgO1NGws,1784
+koi_net/network/event_queue.py,sha256=JqSMRk_PvBn5hlnUKF2jl9uxaOCX793fwZsblx-pEKs,743
+koi_net/network/graph.py,sha256=ZJ1CY-SnYhnZAMm3e9YCbBflk80ZDETnoQKaBk5kLgo,4161
+koi_net/network/poll_event_buffer.py,sha256=PO9HnmlhQ0V-uPGOf5b15GhbJtjAzEfMDf6TtsQLtPA,734
+koi_net/network/request_handler.py,sha256=XSX-JAqRua42YOakmia--9NnKcT32Fpoc-7aYfjDpwg,6752
+koi_net/network/resolver.py,sha256=i8YsdIYVo9--YYW5AK9PO-f_lpXIVKZONImJ9wYMySY,5277
+koi_net/network/response_handler.py,sha256=OyEd_5ltQf-sdGDI4QalPuHVLqrSMpAjRQCDtlNR8WU,4216
+koi_net/processor/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+koi_net/processor/event_worker.py,sha256=z6Zef5TFDokwywSNzaMh6oDmEaAoss6m--dRHHmU3YY,4190
+koi_net/processor/handler.py,sha256=PJlQCPfKm3zYsJrwmGIw5xZmc6vArKz_UoeJuXBj16Y,2356
+koi_net/processor/handlers.py,sha256=rGvjrud72szKBM8rhZRrQ2qO8Ng97oGLIfUG9Af-oxw,10934
+koi_net/processor/knowledge_object.py,sha256=0VyBOqkCoINMK3fqYhLlXU-Ri7gKEpJloDHfhaGITxg,4172
+koi_net/processor/kobj_queue.py,sha256=A4jdS0WCrL-fg3Kl8bHPbzIjSfYNGOBBqzCbSJhfMZ4,1837
+koi_net/processor/kobj_worker.py,sha256=26DG8fU3hLbKZmS6mcuOEnUWcVLkq-1fl8AGNLrYFY0,1237
+koi_net/processor/pipeline.py,sha256=FpU3nORIeJxJuX8QHTSqIji8iMU69GuTR4UMeThOzUo,8668
+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=KH_SjHDzW-V4pn2tqpTDhIzfuCgKgM1YqCafyofLN3k,466
+koi_net/protocol/secure.py,sha256=y3-l0ldQ4oQ6ReEmunDy0ncF836kZvLdGFeEgmuJw44,5110
+koi_net-1.2.0b2.dist-info/METADATA,sha256=t4T3T0cGyG24XvptQg6vy10B8_gHCWGW-s0PntA9aX8,37347
+koi_net-1.2.0b2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+koi_net-1.2.0b2.dist-info/entry_points.txt,sha256=l7He_JTyXrfKIHkttnPWXHI717v8WpLLfCduL5QcEWA,40
+koi_net-1.2.0b2.dist-info/licenses/LICENSE,sha256=03mgCL5qth2aD9C3F3qNVs4sFJSpK9kjtYCyOwdSp7s,1069
+koi_net-1.2.0b2.dist-info/RECORD,,

koi_net/behaviors.py

@@ -1,51 +0,0 @@
-from logging import getLogger
-from rid_lib.ext import Cache
-from rid_lib.types import KoiNetNode
-from rid_lib import RIDType
-from koi_net.identity import NodeIdentity
-from koi_net.network.event_queue import EventQueue
-from koi_net.network.request_handler import RequestHandler
-from koi_net.network.resolver import NetworkResolver
-from koi_net.processor.kobj_queue import KobjQueue
-from koi_net.protocol.api_models import ErrorResponse
-from .protocol.event import Event, EventType
-
-
-logger = getLogger(__name__)
-
-
-
-class Behaviors:
-    def __init__(self, cache: Cache, identity: NodeIdentity, event_queue: EventQueue, resolver: NetworkResolver, request_handler: RequestHandler, kobj_queue: KobjQueue):
-        self.cache = cache
-        self.identity = identity
-        self.event_queue = event_queue
-        self.resolver = resolver
-        self.request_handler = request_handler
-        self.kobj_queue = kobj_queue
-
-    def identify_coordinators(self) -> list[KoiNetNode]:
-        """Returns node's providing state for `orn:koi-net.node`."""
-        return self.resolver.get_state_providers(KoiNetNode)
-
-    def catch_up_with(self, target: KoiNetNode, rid_types: list[RIDType] = []):
-        """Fetches and processes knowledge objects from target node.
-        Args:
-            target: Node to catch up with
-            rid_types: RID types to fetch from target (all types if list is empty)
-        """
-        logger.debug(f"catching up with {target} on {rid_types or 'all types'}")
-        payload = self.request_handler.fetch_manifests(
-            node=target,
-            rid_types=rid_types
-        )
-        if type(payload) == ErrorResponse:
-            logger.debug("failed to reach node")
-            return
-        for manifest in payload.manifests:
-            if manifest.rid == self.identity.rid:
-                continue
-            self.kobj_queue.put_kobj(
-                manifest=manifest,
-                source=target
-            )