koi-net 1.0.0b16__tar.gz → 1.0.0b18__tar.gz

{koi_net-1.0.0b16 → koi_net-1.0.0b18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: koi-net
-Version: 1.0.0b16
+Version: 1.0.0b18
 Summary: Implementation of KOI-net protocol in Python
 Project-URL: Homepage, https://github.com/BlockScience/koi-net/
 Author-email: Luke Miller <luke@block.science>
@@ -150,36 +150,56 @@ Your first decision will be whether to setup a partial or full node:
 - Partial nodes only need to indicate their type, and optionally the RID types of events they provide.
 - Full nodes need to indicate their type, the base URL for their KOI-net API, and optionally the RID types of events and state they provide.
 
+Nodes are configured using the provided `NodeConfig` class. Defaults can be set as shown below, and will automatically load from and save to YAML files. See the `koi_net.config` module for more info.
+
 ### Partial Node
 ```python
 from koi_net import NodeInterface
 from koi_net.protocol.node import NodeProfile, NodeProvides, NodeType
-
-node = NodeInterface(
-    name="mypartialnode",
-    profile=NodeProfile(
-        node_type=NodeType.PARTIAL,
-        provides=NodeProvides(
-            event=[]
+from koi_net.config import NodeConfig, KoiNetConfig
+
+class CoordinatorNodeConfig(NodeConfig):
+    koi_net: KoiNetConfig | None = Field(default_factory = lambda:
+        KoiNetConfig(
+            node_name="coordinator",
+            node_profile=NodeProfile(
+                node_type=NodeType.FULL
+            ),
+            cache_directory_path=".basic_partial_rid_cache",
+            event_queues_path="basic_partial_event_queues.json",
+            first_contact="http://127.0.0.1:8000/koi-net"
         )
     )
+
+
+node = NodeInterface(
+    config=CoordinatorNodeConfig.load_from_yaml("basical_partial_config.yaml")
 )
 ```
 ### Full Node
 ```python
 from koi_net import NodeInterface
 from koi_net.protocol.node import NodeProfile, NodeProvides, NodeType
+from koi_net.config import NodeConfig, KoiNetConfig
+
+class CoordinatorNodeConfig(NodeConfig):
+    koi_net: KoiNetConfig | None = Field(default_factory = lambda:
+        KoiNetConfig(
+            node_name="coordinator",
+            node_profile=NodeProfile(
+                node_type=NodeType.FULL,
+                provides=NodeProvides(
+                    event=[KoiNetNode, KoiNetEdge],
+                    state=[KoiNetNode, KoiNetEdge]
+                )
+            ),
+            cache_directory_path=".coordinator_rid_cache",
+            event_queues_path="coordinator_event_queues.json"
+        )
+    )
 
 node = NodeInterface(
-    name="myfullnode",
-    profile=NodeProfile(
-        base_url="http://127.0.0.1:8000",
-        node_type=NodeType.FULL,
-        provides=NodeProvides(
-            event=[],
-            state=[]
-        )
-    ),
+    config=CoordinatorNodeConfig.load_from_yaml("coordinator_config.yaml"),
     use_kobj_processor_thread=True
 )
 ```
@@ -402,6 +422,7 @@ The default configuration provides four default handlers which will take precede
 ```python
 from koi_net import NodeInterface
 from koi_net.protocol.node import NodeProfile, NodeProvides, NodeType
+from koi_net.config import NodeConfig
 from koi_net.processor.default_handlers import (
     basic_rid_handler,
     basic_manifest_handler,
@@ -410,13 +431,7 @@ from koi_net.processor.default_handlers import (
 )
 
 node = NodeInterface(
-    name="mypartialnode",
-    profile=NodeProfile(
-        node_type=NodeType.PARTIAL,
-        provides=NodeProvides(
-            event=[]
-        )
-    ),
+    config=NodeConfig.load_from_yaml(),
     handlers=[
         basic_rid_handler,
         basic_manifest_handler,
@@ -437,23 +452,21 @@ This section provides high level explanations of the Python implementation. More
 The node class mostly acts as a container for other classes with more specialized behavior, with special functions that should be called to start up and shut down a node. We'll take a look at each of these components in turn, but here is the class stub:
 ```python
 class NodeInterface:
+    config: ConfigType
     cache: Cache
     identity: NodeIdentity
     network: NetworkInterface
     processor: ProcessorInterface
-    first_contact: str
+    
     use_kobj_processor_thread: bool
-
+    
     def __init__(
         self, 
-        name: str,
-        profile: NodeProfile,
-        identity_file_path: str = "identity.json",
-        event_queues_file_path: str = "event_queues.json",
-        cache_directory_path: str = "rid_cache",
+        config: ConfigType,
         use_kobj_processor_thread: bool = False,
-        first_contact: str | None = None,
+        
         handlers: list[KnowledgeHandler] | None = None,
+        
         cache: Cache | None = None,
         network: NetworkInterface | None = None,
         processor: ProcessorInterface | None = None
@@ -462,7 +475,58 @@ class NodeInterface:
     def start(self): ...
     def stop(self): ...
 ```
-As you can see, only a name and profile are required. The other fields allow for additional customization if needed.
+As you can see, only a node config is required, all other fields are optional.
+
+## Node Config
+
+The node config class is a mix of configuration groups providing basic shared behavior across nodes through a standard interface. The class is implemented as Pydantic model, but provides functions to load from and save to a YAML file, the expected format within a node repo.
+
+```python
+class ServerConfig(BaseModel):
+    host: str | None = "127.0.0.1"
+    port: int | None = 8000
+    path: str | None = "/koi-net"
+    
+    @property
+    def url(self) -> str: ...
+
+class KoiNetConfig(BaseModel):
+    node_name: str
+    node_rid: KoiNetNode | None = None
+    node_profile: NodeProfile
+    
+    cache_directory_path: str | None = ".rid_cache"
+    event_queues_path: str | None = "event_queues.json"
+
+    first_contact: str | None = None
+
+class EnvConfig(BaseModel):
+    ...
+
+class NodeConfig(BaseModel):
+    server: ServerConfig | None = Field(default_factory=ServerConfig)
+    koi_net: KoiNetConfig
+
+    @classmethod
+    def load_from_yaml(
+        cls, 
+        file_path: str = "config.yaml", 
+        generate_missing: bool = True
+    ): ...
+    
+    def save_to_yaml(self): ...
+```
+
+Nodes are expected to create new node config classes inheriting from `NodeConfig`. You may want to set a default KoiNetConfig (see examples) to allow for a default config to be generated if not provided by the user. Environment variables can be handled by inheriting from the `EnvConfig` class and adding new string fields. The value of this field should be equivalent to the environment variable name, for example:
+
+```python
+class SlackEnvConfig(EnvConfig):
+    slack_bot_token: str | None = "SLACK_BOT_TOKEN"
+    slack_signing_secret: str | None = "SLACK_SIGNING_SECRET"
+    slack_app_token: str | None = "SLACK_APP_TOKEN"
+```
+
+This special config class will automatically load in the variables from the current environment, or local `.env` file. Beyond these base config classes, you are free to add your own config groups. See `config.py` in the [koi-net-slack-sensor-node](https://github.com/BlockScience/koi-net-slack-sensor-node/blob/main/slack_sensor_node/config.py) repo for a more complete example.
 
 ## Node Identity
 The `NodeIdentity` class provides easy access to a node's own RID, profile, and bundle. It provides access to the following properties after initialization, accessed with `node.identity`.
@@ -472,7 +536,7 @@ class NodeIdentity:
     profile: NodeProfile
     bundle: Bundle
 ```
-This it what is initialized from the required `name` and `profile` fields in the `NodeInterface` constructor. Node RIDs take the form of `orn:koi-net.node:<name>+<uuid>`, and are generated on first use to the identity JSON file along with a the node profile.
+This it what is initialized from the required `name` and `profile` fields in the `NodeConfig` class. Node RIDs take the form of `orn:koi-net.node:<name>+<uuid>`, and are generated on first use to the identity JSON file along with a the node profile.
 
 ## Network Interface
 The `NetworkInterface` class provides access to high level network actions, and contains several other network related classes. It is accessed with `node.network`.

{koi_net-1.0.0b16 → koi_net-1.0.0b18}/README.md

@@ -106,36 +106,56 @@ Your first decision will be whether to setup a partial or full node:
 - Partial nodes only need to indicate their type, and optionally the RID types of events they provide.
 - Full nodes need to indicate their type, the base URL for their KOI-net API, and optionally the RID types of events and state they provide.
 
+Nodes are configured using the provided `NodeConfig` class. Defaults can be set as shown below, and will automatically load from and save to YAML files. See the `koi_net.config` module for more info.
+
 ### Partial Node
 ```python
 from koi_net import NodeInterface
 from koi_net.protocol.node import NodeProfile, NodeProvides, NodeType
-
-node = NodeInterface(
-    name="mypartialnode",
-    profile=NodeProfile(
-        node_type=NodeType.PARTIAL,
-        provides=NodeProvides(
-            event=[]
+from koi_net.config import NodeConfig, KoiNetConfig
+
+class CoordinatorNodeConfig(NodeConfig):
+    koi_net: KoiNetConfig | None = Field(default_factory = lambda:
+        KoiNetConfig(
+            node_name="coordinator",
+            node_profile=NodeProfile(
+                node_type=NodeType.FULL
+            ),
+            cache_directory_path=".basic_partial_rid_cache",
+            event_queues_path="basic_partial_event_queues.json",
+            first_contact="http://127.0.0.1:8000/koi-net"
         )
     )
+
+
+node = NodeInterface(
+    config=CoordinatorNodeConfig.load_from_yaml("basical_partial_config.yaml")
 )
 ```
 ### Full Node
 ```python
 from koi_net import NodeInterface
 from koi_net.protocol.node import NodeProfile, NodeProvides, NodeType
+from koi_net.config import NodeConfig, KoiNetConfig
+
+class CoordinatorNodeConfig(NodeConfig):
+    koi_net: KoiNetConfig | None = Field(default_factory = lambda:
+        KoiNetConfig(
+            node_name="coordinator",
+            node_profile=NodeProfile(
+                node_type=NodeType.FULL,
+                provides=NodeProvides(
+                    event=[KoiNetNode, KoiNetEdge],
+                    state=[KoiNetNode, KoiNetEdge]
+                )
+            ),
+            cache_directory_path=".coordinator_rid_cache",
+            event_queues_path="coordinator_event_queues.json"
+        )
+    )
 
 node = NodeInterface(
-    name="myfullnode",
-    profile=NodeProfile(
-        base_url="http://127.0.0.1:8000",
-        node_type=NodeType.FULL,
-        provides=NodeProvides(
-            event=[],
-            state=[]
-        )
-    ),
+    config=CoordinatorNodeConfig.load_from_yaml("coordinator_config.yaml"),
     use_kobj_processor_thread=True
 )
 ```
@@ -358,6 +378,7 @@ The default configuration provides four default handlers which will take precede
 ```python
 from koi_net import NodeInterface
 from koi_net.protocol.node import NodeProfile, NodeProvides, NodeType
+from koi_net.config import NodeConfig
 from koi_net.processor.default_handlers import (
     basic_rid_handler,
     basic_manifest_handler,
@@ -366,13 +387,7 @@ from koi_net.processor.default_handlers import (
 )
 
 node = NodeInterface(
-    name="mypartialnode",
-    profile=NodeProfile(
-        node_type=NodeType.PARTIAL,
-        provides=NodeProvides(
-            event=[]
-        )
-    ),
+    config=NodeConfig.load_from_yaml(),
     handlers=[
         basic_rid_handler,
         basic_manifest_handler,
@@ -393,23 +408,21 @@ This section provides high level explanations of the Python implementation. More
 The node class mostly acts as a container for other classes with more specialized behavior, with special functions that should be called to start up and shut down a node. We'll take a look at each of these components in turn, but here is the class stub:
 ```python
 class NodeInterface:
+    config: ConfigType
     cache: Cache
     identity: NodeIdentity
     network: NetworkInterface
     processor: ProcessorInterface
-    first_contact: str
+    
     use_kobj_processor_thread: bool
-
+    
     def __init__(
         self, 
-        name: str,
-        profile: NodeProfile,
-        identity_file_path: str = "identity.json",
-        event_queues_file_path: str = "event_queues.json",
-        cache_directory_path: str = "rid_cache",
+        config: ConfigType,
         use_kobj_processor_thread: bool = False,
-        first_contact: str | None = None,
+        
         handlers: list[KnowledgeHandler] | None = None,
+        
         cache: Cache | None = None,
         network: NetworkInterface | None = None,
         processor: ProcessorInterface | None = None
@@ -418,7 +431,58 @@ class NodeInterface:
     def start(self): ...
     def stop(self): ...
 ```
-As you can see, only a name and profile are required. The other fields allow for additional customization if needed.
+As you can see, only a node config is required, all other fields are optional.
+
+## Node Config
+
+The node config class is a mix of configuration groups providing basic shared behavior across nodes through a standard interface. The class is implemented as Pydantic model, but provides functions to load from and save to a YAML file, the expected format within a node repo.
+
+```python
+class ServerConfig(BaseModel):
+    host: str | None = "127.0.0.1"
+    port: int | None = 8000
+    path: str | None = "/koi-net"
+    
+    @property
+    def url(self) -> str: ...
+
+class KoiNetConfig(BaseModel):
+    node_name: str
+    node_rid: KoiNetNode | None = None
+    node_profile: NodeProfile
+    
+    cache_directory_path: str | None = ".rid_cache"
+    event_queues_path: str | None = "event_queues.json"
+
+    first_contact: str | None = None
+
+class EnvConfig(BaseModel):
+    ...
+
+class NodeConfig(BaseModel):
+    server: ServerConfig | None = Field(default_factory=ServerConfig)
+    koi_net: KoiNetConfig
+
+    @classmethod
+    def load_from_yaml(
+        cls, 
+        file_path: str = "config.yaml", 
+        generate_missing: bool = True
+    ): ...
+    
+    def save_to_yaml(self): ...
+```
+
+Nodes are expected to create new node config classes inheriting from `NodeConfig`. You may want to set a default KoiNetConfig (see examples) to allow for a default config to be generated if not provided by the user. Environment variables can be handled by inheriting from the `EnvConfig` class and adding new string fields. The value of this field should be equivalent to the environment variable name, for example:
+
+```python
+class SlackEnvConfig(EnvConfig):
+    slack_bot_token: str | None = "SLACK_BOT_TOKEN"
+    slack_signing_secret: str | None = "SLACK_SIGNING_SECRET"
+    slack_app_token: str | None = "SLACK_APP_TOKEN"
+```
+
+This special config class will automatically load in the variables from the current environment, or local `.env` file. Beyond these base config classes, you are free to add your own config groups. See `config.py` in the [koi-net-slack-sensor-node](https://github.com/BlockScience/koi-net-slack-sensor-node/blob/main/slack_sensor_node/config.py) repo for a more complete example.
 
 ## Node Identity
 The `NodeIdentity` class provides easy access to a node's own RID, profile, and bundle. It provides access to the following properties after initialization, accessed with `node.identity`.
@@ -428,7 +492,7 @@ class NodeIdentity:
     profile: NodeProfile
     bundle: Bundle
 ```
-This it what is initialized from the required `name` and `profile` fields in the `NodeInterface` constructor. Node RIDs take the form of `orn:koi-net.node:<name>+<uuid>`, and are generated on first use to the identity JSON file along with a the node profile.
+This it what is initialized from the required `name` and `profile` fields in the `NodeConfig` class. Node RIDs take the form of `orn:koi-net.node:<name>+<uuid>`, and are generated on first use to the identity JSON file along with a the node profile.
 
 ## Network Interface
 The `NetworkInterface` class provides access to high level network actions, and contains several other network related classes. It is accessed with `node.network`.

{koi_net-1.0.0b16 → koi_net-1.0.0b18}/examples/basic_coordinator_node.py

@@ -1,11 +1,13 @@
 import json
 import logging
+from pydantic import Field
 import uvicorn
 from contextlib import asynccontextmanager
 from rich.logging import RichHandler
 from fastapi import FastAPI
 from rid_lib.types import KoiNetNode, KoiNetEdge
 from koi_net import NodeInterface
+from koi_net.config import NodeConfig, KoiNetConfig
 from koi_net.processor.handler import HandlerType
 from koi_net.processor.knowledge_object import KnowledgeObject, KnowledgeSource
 from koi_net.protocol.edge import EdgeType
@@ -41,22 +43,26 @@ logging.basicConfig(
 
 logging.getLogger("koi_net").setLevel(logging.DEBUG)
 
-port = 8000
 
-node = NodeInterface(
-    name="coordinator",
-    profile=NodeProfile(
-        base_url=f"http://127.0.0.1:{port}/koi-net",
-        node_type=NodeType.FULL,
-        provides=NodeProvides(
-            event=[KoiNetNode, KoiNetEdge],
-            state=[KoiNetNode, KoiNetEdge]
+class CoordinatorNodeConfig(NodeConfig):
+    koi_net: KoiNetConfig | None = Field(default_factory = lambda:
+        KoiNetConfig(
+            node_name="coordinator",
+            node_profile=NodeProfile(
+                node_type=NodeType.FULL,
+                provides=NodeProvides(
+                    event=[KoiNetNode, KoiNetEdge],
+                    state=[KoiNetNode, KoiNetEdge]
+                )
+            ),
+            cache_directory_path=".coordinator_rid_cache",
+            event_queues_path="coordinator_event_queues.json"
         )
-    ),
-    use_kobj_processor_thread=True,
-    cache_directory_path="coordinator_node_rid_cache",
-    event_queues_file_path="coordinator_node_event_queus.json",
-    identity_file_path="coordinator_node_identity.json",
+    )
+
+node = NodeInterface(
+    config=CoordinatorNodeConfig.load_from_yaml("coordinator_config.yaml"),
+    use_kobj_processor_thread=True
 )
 
 
@@ -132,4 +138,4 @@ if __name__ == "__main__":
     with open("koi-net-protocol-openapi.json", "w") as f:
         json.dump(openapi_spec, f, indent=2)
     
-    uvicorn.run("examples.basic_coordinator_node:app", port=port)
+    uvicorn.run("examples.basic_coordinator_node:app", port=node.config.server.port)

koi_net-1.0.0b18/examples/basic_partial_node.py

@@ -0,0 +1,46 @@
+import time
+import logging
+from pydantic import Field
+from rich.logging import RichHandler
+from koi_net import NodeInterface
+from koi_net.processor.knowledge_object import KnowledgeSource
+from koi_net.protocol.node import NodeProfile, NodeType
+from koi_net.config import NodeConfig, KoiNetConfig
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+    datefmt="%Y-%m-%d %H:%M:%S",
+    handlers=[RichHandler()]
+)
+
+logging.getLogger("koi_net").setLevel(logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+
+class CoordinatorNodeConfig(NodeConfig):
+    koi_net: KoiNetConfig | None = Field(default_factory = lambda:
+        KoiNetConfig(
+            node_name="coordinator",
+            node_profile=NodeProfile(
+                node_type=NodeType.FULL
+            ),
+            cache_directory_path=".basic_partial_rid_cache",
+            event_queues_path="basic_partial_event_queues.json",
+            first_contact="http://127.0.0.1:8000/koi-net"
+        )
+    )
+
+
+node = NodeInterface(
+    config=CoordinatorNodeConfig.load_from_yaml("basical_partial_config.yaml")
+)
+
+node.start()
+
+while True:
+    for event in node.network.poll_neighbors():
+        node.processor.handle(event=event, source=KnowledgeSource.External)
+    node.processor.flush_kobj_queue()
+    
+    time.sleep(5)

{koi_net-1.0.0b16 → koi_net-1.0.0b18}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "koi-net"
-version = "1.0.0-beta.16"
+version = "1.0.0-beta.18"
 description = "Implementation of KOI-net protocol in Python"
 authors = [
     {name = "Luke Miller", email = "luke@block.science"}

{koi_net-1.0.0b16 → koi_net-1.0.0b18}/src/koi_net/config.py

@@ -13,7 +13,7 @@ class ServerConfig(BaseModel):
     path: str | None = "/koi-net"
     
     @property
-    def url(self):
+    def url(self) -> str:
         return f"http://{self.host}:{self.port}{self.path or ''}"
 
 class KoiNetConfig(BaseModel):

{koi_net-1.0.0b16 → koi_net-1.0.0b18}/src/koi_net/network/interface.py

@@ -173,7 +173,7 @@ class NetworkInterface(Generic[ConfigType]):
             self.request_handler.broadcast_events(node, events=events)
             return True
         except httpx.ConnectError:
-            logger.warning("Broadcast failed, dropping node")
+            logger.warning("Broadcast failed")
             for event in events:
                 self.push_event_to(event, node)
             return False

{koi_net-1.0.0b16 → koi_net-1.0.0b18}/src/koi_net/processor/default_handlers.py

@@ -134,6 +134,10 @@ def coordinator_contact(processor: ProcessorInterface, kobj: KnowledgeObject):
     if KoiNetNode not in node_profile.provides.event:
         return
     
+    # prevents coordinators from attempting to form a self loop
+    if kobj.rid == processor.identity.rid:
+        return
+    
     # already have an edge established
     if processor.network.graph.get_edge_profile(
         source=kobj.rid,

{koi_net-1.0.0b16 → koi_net-1.0.0b18}/src/koi_net/processor/interface.py

@@ -229,9 +229,7 @@ class ProcessorInterface():
         
         for node in kobj.network_targets:
             self.network.push_event_to(kobj.normalized_event, node)
-            if not self.network.flush_webhook_queue(node):
-                logger.warning("Dropping unresponsive node")
-                self.handle(rid=node, event_type=EventType.FORGET)
+            self.network.flush_webhook_queue(node)
         
         kobj = self.call_handler_chain(HandlerType.Final, kobj)
 

koi_net-1.0.0b16/examples/basic_partial_node.py

@@ -1,84 +0,0 @@
-import time
-import logging
-from rich.logging import RichHandler
-from koi_net import NodeInterface
-from koi_net.processor.handler import HandlerType
-from koi_net.processor.knowledge_object import KnowledgeSource, KnowledgeObject
-from koi_net.processor.interface import ProcessorInterface
-from koi_net.protocol.event import EventType
-from koi_net.protocol.edge import EdgeType
-from koi_net.protocol.node import NodeProfile, NodeType
-from koi_net.protocol.helpers import generate_edge_bundle
-from rid_lib.types import KoiNetNode
-
-logging.basicConfig(
-    level=logging.INFO,
-    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
-    datefmt="%Y-%m-%d %H:%M:%S",
-    handlers=[RichHandler()]
-)
-
-logging.getLogger("koi_net").setLevel(logging.DEBUG)
-logger = logging.getLogger(__name__)
-
-
-node = NodeInterface(
-    name="partial",
-    profile=NodeProfile(
-        node_type=NodeType.PARTIAL
-    ),
-    cache_directory_path="partial_node_rid_cache",
-    event_queues_file_path="parital_node_event_queus.json",
-    identity_file_path="partial_node_identity.json",
-    first_contact="http://127.0.0.1:8000/koi-net"
-)
-
-@node.processor.register_handler(HandlerType.Network, rid_types=[KoiNetNode])
-def coordinator_contact(processor: ProcessorInterface, kobj: KnowledgeObject):
-    # when I found out about a new node
-    if kobj.normalized_event_type != EventType.NEW: 
-        return
-    
-    node_profile = kobj.bundle.validate_contents(NodeProfile)
-    
-    # looking for event provider of nodes
-    if KoiNetNode not in node_profile.provides.event:
-        return
-    
-    logger.info("Identified a coordinator!")
-    logger.info("Proposing new edge")
-    
-    # queued for processing
-    processor.handle(bundle=generate_edge_bundle(
-        source=kobj.rid,
-        target=node.identity.rid,
-        edge_type=EdgeType.POLL,
-        rid_types=[KoiNetNode]
-    ))
-    
-    logger.info("Catching up on network state")
-    
-    payload = processor.network.request_handler.fetch_rids(kobj.rid, rid_types=[KoiNetNode])
-    for rid in payload.rids:
-        if rid == processor.identity.rid:
-            logger.info("Skipping myself")
-            continue
-        if processor.cache.exists(rid):
-            logger.info(f"Skipping known RID '{rid}'")
-            continue
-        
-        # marked as external since we are handling RIDs from another node
-        # will fetch remotely instead of checking local cache
-        processor.handle(rid=rid, source=KnowledgeSource.External)
-    logger.info("Done")
-    
-
-
-node.start()
-
-while True:
-    for event in node.network.poll_neighbors():
-        node.processor.handle(event=event, source=KnowledgeSource.External)
-    node.processor.flush_kobj_queue()
-    
-    time.sleep(5)

koi_net-1.0.0b16/examples/full_node_template.py

@@ -1,94 +0,0 @@
-import logging
-import uvicorn
-from contextlib import asynccontextmanager
-from rich.logging import RichHandler
-from fastapi import FastAPI
-from rid_lib.types import KoiNetNode, KoiNetEdge
-from koi_net import NodeInterface
-from koi_net.processor.knowledge_object import KnowledgeSource
-
-from koi_net.protocol.node import NodeProfile, NodeType, NodeProvides
-from koi_net.protocol.api_models import (
-    PollEvents,
-    FetchRids,
-    FetchManifests,
-    FetchBundles,
-    EventsPayload,
-    RidsPayload,
-    ManifestsPayload,
-    BundlesPayload
-)
-from koi_net.protocol.consts import (
-    BROADCAST_EVENTS_PATH,
-    POLL_EVENTS_PATH,
-    FETCH_RIDS_PATH,
-    FETCH_MANIFESTS_PATH,
-    FETCH_BUNDLES_PATH
-)
-
-
-logging.basicConfig(
-    level=logging.INFO,
-    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
-    datefmt="%Y-%m-%d %H:%M:%S",
-    handlers=[RichHandler()]
-)
-
-logger = logging.getLogger(__name__)
-logging.getLogger("koi_net").setLevel(logging.DEBUG)
-
-port = 5000
-coordinator_url = "http://127.0.0.1:8000/koi-net"
-
-node = NodeInterface(
-    name="coordinator",
-    profile=NodeProfile(
-        base_url=f"http://127.0.0.1:{port}/koi-net",
-        node_type=NodeType.FULL,
-        provides=NodeProvides(
-            event=[KoiNetNode, KoiNetEdge],
-            state=[KoiNetNode, KoiNetEdge]
-        )
-    ),
-    use_kobj_processor_thread=True,
-    first_contact=coordinator_url
-)
-
-
-@asynccontextmanager
-async def lifespan(app: FastAPI):
-    node.start()
-    yield
-    node.stop()
-
-
-app = FastAPI(lifespan=lifespan, root_path="/koi-net")
-
-@app.post(BROADCAST_EVENTS_PATH)
-def broadcast_events(req: EventsPayload):
-    logger.info(f"Request to {BROADCAST_EVENTS_PATH}, received {len(req.events)} event(s)")
-    for event in req.events:
-        node.processor.handle(event=event, source=KnowledgeSource.External)
-    
-@app.post(POLL_EVENTS_PATH)
-def poll_events(req: PollEvents) -> EventsPayload:
-    logger.info(f"Request to {POLL_EVENTS_PATH}")
-    events = node.network.flush_poll_queue(req.rid)
-    return EventsPayload(events=events)
-
-@app.post(FETCH_RIDS_PATH)
-def fetch_rids(req: FetchRids) -> RidsPayload:
-    return node.network.response_handler.fetch_rids(req)
-
-@app.post(FETCH_MANIFESTS_PATH)
-def fetch_manifests(req: FetchManifests) -> ManifestsPayload:
-    return node.network.response_handler.fetch_manifests(req)
-
-@app.post(FETCH_BUNDLES_PATH)
-def fetch_bundles(req: FetchBundles) -> BundlesPayload:
-    return node.network.response_handler.fetch_bundles(req)
-    
-    
-if __name__ == "__main__":
-    # update this path to the Python module that defines "app"
-    uvicorn.run("examples.full_node_template:app", port=port)

koi_net-1.0.0b16/examples/partial_node_template.py

@@ -1,41 +0,0 @@
-import time
-import logging
-from rich.logging import RichHandler
-from koi_net import NodeInterface
-from koi_net.processor.knowledge_object import KnowledgeSource
-from koi_net.protocol.node import NodeProfile, NodeType
-
-
-logging.basicConfig(
-    level=logging.INFO,
-    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
-    datefmt="%Y-%m-%d %H:%M:%S",
-    handlers=[RichHandler()]
-)
-
-logger = logging.getLogger(__name__)
-
-
-coordinator_url = "http://127.0.0.1:8000/koi-net"
-
-node = NodeInterface(
-    name="partial",
-    profile=NodeProfile(
-        node_type=NodeType.PARTIAL,
-    ),
-    first_contact=coordinator_url
-)
-
-if __name__ == "__main__":
-    node.start()
-
-    try:
-        while True:
-            for event in node.network.poll_neighbors():
-                node.processor.handle(event=event, source=KnowledgeSource.External)
-            node.processor.flush_kobj_queue()
-            
-            time.sleep(5)
-            
-    finally:
-        node.stop()