koi-net 1.1.0b7__tar.gz → 1.2.0b1__tar.gz

{koi_net-1.1.0b7 → koi_net-1.2.0b1}/.gitignore

@@ -1,10 +1,12 @@
 rid-lib
 __pycache__
-*.json
 *.pem
 *.yaml
 venv
 .env
 prototypes
 .vscode
-dist/
+dist/
+docs/
+tests/
+.rid_cache/

{koi_net-1.1.0b7 → koi_net-1.2.0b1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: koi-net
-Version: 1.1.0b7
+Version: 1.2.0b1
 Summary: Implementation of KOI-net protocol in Python
 Project-URL: Homepage, https://github.com/BlockScience/koi-net/
 Author-email: Luke Miller <luke@block.science>
@@ -33,14 +33,18 @@ 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: rich>=14.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: rich; extra == 'examples'
+Provides-Extra: docs
+Requires-Dist: sphinx; extra == 'docs'
+Requires-Dist: sphinx-autoapi>=3.6.0; extra == 'docs'
+Requires-Dist: sphinx-autodoc-typehints>=3.0.1; extra == 'docs'
+Requires-Dist: sphinx-rtd-theme>=3.0.2; extra == 'docs'
 Description-Content-Type: text/markdown
 
 # KOI-net

{koi_net-1.1.0b7 → koi_net-1.2.0b1}/examples/coordinator.py

@@ -2,11 +2,11 @@ import logging
 from rich.logging import RichHandler
 from pydantic import Field
 from rid_lib.types import KoiNetNode, KoiNetEdge
-from koi_net.config import NodeConfig, KoiNetConfig
+from koi_net.config import NodeConfig, KoiNetConfig, ServerConfig
+from koi_net.core import NodeAssembler
 from koi_net.protocol.node import NodeProfile, NodeProvides, NodeType
-from koi_net import NodeInterface
 from koi_net.context import HandlerContext
-from koi_net.processor.handler import HandlerType
+from koi_net.processor.handler import HandlerType, KnowledgeHandler
 from koi_net.processor.knowledge_object import KnowledgeObject
 from koi_net.protocol.event import Event, EventType
 from koi_net.protocol.edge import EdgeType, generate_edge_bundle
@@ -21,7 +21,11 @@ logging.basicConfig(
 logging.getLogger("koi_net").setLevel(logging.DEBUG)
 logger = logging.getLogger(__name__)
 
+
 class CoordinatorConfig(NodeConfig):
+    server: ServerConfig = Field(default_factory=lambda: 
+        ServerConfig(port=8080)
+    )
     koi_net: KoiNetConfig = Field(default_factory = lambda:
         KoiNetConfig(
             node_name="coordinator",
@@ -32,18 +36,13 @@ class CoordinatorConfig(NodeConfig):
                     state=[KoiNetNode, KoiNetEdge]
                 )
             ),
-            cache_directory_path=".coordinator_rid_cache",
-            event_queues_path="coordinator_event_queues.json",
-            private_key_pem_path="coordinator_priv_key.pem"
+            rid_types_of_interest=[KoiNetNode, KoiNetEdge]
         )
     )
-    
-node = NodeInterface(
-    config=CoordinatorConfig.load_from_yaml("coordinator_config.yaml"),
-    use_kobj_processor_thread=True
-)
 
-@node.processor.pipeline.register_handler(HandlerType.Network, rid_types=[KoiNetNode])
+@KnowledgeHandler.create(
+    HandlerType.Network, 
+    rid_types=[KoiNetNode])
 def handshake_handler(ctx: HandlerContext, kobj: KnowledgeObject):
     logger.info("Handling node handshake")
 
@@ -52,11 +51,10 @@ def handshake_handler(ctx: HandlerContext, kobj: KnowledgeObject):
         return
         
     logger.info("Sharing this node's bundle with peer")
-    identity_bundle = ctx.effector.deref(ctx.identity.rid)
+    identity_bundle = ctx.cache.read(ctx.identity.rid)
     ctx.event_queue.push_event_to(
         event=Event.from_bundle(EventType.NEW, identity_bundle),
-        node=kobj.rid,
-        flush=True
+        target=kobj.rid
     )
     
     logger.info("Proposing new edge")    
@@ -69,8 +67,17 @@ def handshake_handler(ctx: HandlerContext, kobj: KnowledgeObject):
         rid_types=[KoiNetNode, KoiNetEdge]
     )
         
-    ctx.handle(rid=edge_bundle.rid, event_type=EventType.FORGET)
-    ctx.handle(bundle=edge_bundle)
-    
+    ctx.kobj_queue.put_kobj(rid=edge_bundle.rid, event_type=EventType.FORGET)
+    ctx.kobj_queue.put_kobj(bundle=edge_bundle)
+
+class CoordinatorNodeAssembler(NodeAssembler):
+    config = CoordinatorConfig
+    knowledge_handlers = [
+        *NodeAssembler.knowledge_handlers,
+        handshake_handler
+    ]
+
+
 if __name__ == "__main__":
+    node = CoordinatorNodeAssembler.create()
     node.server.run()

{koi_net-1.1.0b7 → koi_net-1.2.0b1}/examples/partial.py

@@ -1,7 +1,7 @@
 import logging
 from pydantic import Field
 from rich.logging import RichHandler
-from koi_net import NodeInterface
+from koi_net.core import NodeAssembler
 from koi_net.protocol.node import NodeProfile, NodeType
 from koi_net.config import NodeConfig, KoiNetConfig
 
@@ -22,16 +22,14 @@ class PartialNodeConfig(NodeConfig):
             node_name="partial",
             node_profile=NodeProfile(
                 node_type=NodeType.PARTIAL
-            ),
-            cache_directory_path=".partial_rid_cache",
-            event_queues_path="partial_event_queues.json",
-            private_key_pem_path="partial_priv_key.pem"
+            )
         )
     )
 
-node = NodeInterface(
-    config=PartialNodeConfig.load_from_yaml("partial_config.yaml")
-)
+class PartialNodeAssembler(NodeAssembler):
+    config = PartialNodeConfig
+
 
 if __name__ == "__main__":
+    node = PartialNodeAssembler.create()
     node.poller.run()

koi_net-1.2.0b1/koi-net-protocol-openapi.json

@@ -0,0 +1,522 @@
+{
+  "openapi": "3.1.0",
+  "info": {
+    "title": "KOI-net Protocol API",
+    "version": "1.0.0"
+  },
+  "paths": {
+    "/events/broadcast": {
+      "post": {
+        "summary": "Broadcast Events",
+        "operationId": "broadcast_events_events_broadcast_post",
+        "requestBody": {
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/EventsPayload-Input"
+              }
+            }
+          },
+          "required": true
+        },
+        "responses": {
+          "200": {
+            "description": "Successful Response",
+            "content": {
+              "application/json": {
+                "schema": {}
+              }
+            }
+          },
+          "422": {
+            "description": "Validation Error",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/HTTPValidationError"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/events/poll": {
+      "post": {
+        "summary": "Poll Events",
+        "operationId": "poll_events_events_poll_post",
+        "requestBody": {
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/PollEvents"
+              }
+            }
+          },
+          "required": true
+        },
+        "responses": {
+          "200": {
+            "description": "Successful Response",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/EventsPayload-Output"
+                }
+              }
+            }
+          },
+          "422": {
+            "description": "Validation Error",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/HTTPValidationError"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/rids/fetch": {
+      "post": {
+        "summary": "Fetch Rids",
+        "operationId": "fetch_rids_rids_fetch_post",
+        "requestBody": {
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/FetchRids"
+              }
+            }
+          },
+          "required": true
+        },
+        "responses": {
+          "200": {
+            "description": "Successful Response",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/RidsPayload"
+                }
+              }
+            }
+          },
+          "422": {
+            "description": "Validation Error",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/HTTPValidationError"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/manifests/fetch": {
+      "post": {
+        "summary": "Fetch Manifests",
+        "operationId": "fetch_manifests_manifests_fetch_post",
+        "requestBody": {
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/FetchManifests"
+              }
+            }
+          },
+          "required": true
+        },
+        "responses": {
+          "200": {
+            "description": "Successful Response",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ManifestsPayload"
+                }
+              }
+            }
+          },
+          "422": {
+            "description": "Validation Error",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/HTTPValidationError"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/bundles/fetch": {
+      "post": {
+        "summary": "Fetch Bundles",
+        "operationId": "fetch_bundles_bundles_fetch_post",
+        "requestBody": {
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/FetchBundles"
+              }
+            }
+          },
+          "required": true
+        },
+        "responses": {
+          "200": {
+            "description": "Successful Response",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/BundlesPayload"
+                }
+              }
+            }
+          },
+          "422": {
+            "description": "Validation Error",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/HTTPValidationError"
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  },
+  "components": {
+    "schemas": {
+      "Bundle": {
+        "properties": {
+          "manifest": {
+            "$ref": "#/components/schemas/Manifest"
+          },
+          "contents": {
+            "type": "object",
+            "title": "Contents"
+          }
+        },
+        "type": "object",
+        "required": [
+          "manifest",
+          "contents"
+        ],
+        "title": "Bundle",
+        "description": "A knowledge bundle composed of a manifest and contents associated with an RIDed object.\n\nActs as a container for the data associated with an RID. It is written to and read from the cache."
+      },
+      "BundlesPayload": {
+        "properties": {
+          "bundles": {
+            "items": {
+              "$ref": "#/components/schemas/Bundle"
+            },
+            "type": "array",
+            "title": "Bundles"
+          },
+          "not_found": {
+            "items": {
+              "type": "string",
+              "format": "rid"
+            },
+            "type": "array",
+            "title": "Not Found",
+            "default": []
+          },
+          "deferred": {
+            "items": {
+              "type": "string",
+              "format": "rid"
+            },
+            "type": "array",
+            "title": "Deferred",
+            "default": []
+          }
+        },
+        "type": "object",
+        "required": [
+          "bundles"
+        ],
+        "title": "BundlesPayload"
+      },
+      "Event": {
+        "properties": {
+          "rid": {
+            "type": "string",
+            "format": "rid",
+            "title": "Rid"
+          },
+          "event_type": {
+            "$ref": "#/components/schemas/EventType"
+          },
+          "manifest": {
+            "anyOf": [
+              {
+                "$ref": "#/components/schemas/Manifest"
+              },
+              {
+                "type": "null"
+              }
+            ]
+          },
+          "contents": {
+            "anyOf": [
+              {
+                "type": "object"
+              },
+              {
+                "type": "null"
+              }
+            ],
+            "title": "Contents"
+          }
+        },
+        "type": "object",
+        "required": [
+          "rid",
+          "event_type"
+        ],
+        "title": "Event"
+      },
+      "EventType": {
+        "type": "string",
+        "enum": [
+          "NEW",
+          "UPDATE",
+          "FORGET"
+        ],
+        "title": "EventType"
+      },
+      "EventsPayload-Input": {
+        "properties": {
+          "events": {
+            "items": {
+              "$ref": "#/components/schemas/Event"
+            },
+            "type": "array",
+            "title": "Events"
+          }
+        },
+        "type": "object",
+        "required": [
+          "events"
+        ],
+        "title": "EventsPayload"
+      },
+      "EventsPayload-Output": {
+        "properties": {
+          "events": {
+            "items": {
+              "$ref": "#/components/schemas/Event"
+            },
+            "type": "array",
+            "title": "Events"
+          }
+        },
+        "type": "object",
+        "required": [
+          "events"
+        ],
+        "title": "EventsPayload"
+      },
+      "FetchBundles": {
+        "properties": {
+          "rids": {
+            "items": {
+              "type": "string",
+              "format": "rid"
+            },
+            "type": "array",
+            "title": "Rids"
+          }
+        },
+        "type": "object",
+        "required": [
+          "rids"
+        ],
+        "title": "FetchBundles"
+      },
+      "FetchManifests": {
+        "properties": {
+          "rid_types": {
+            "items": {
+              "type": "string",
+              "format": "rid-type"
+            },
+            "type": "array",
+            "title": "Rid Types",
+            "default": []
+          },
+          "rids": {
+            "items": {
+              "type": "string",
+              "format": "rid"
+            },
+            "type": "array",
+            "title": "Rids",
+            "default": []
+          }
+        },
+        "type": "object",
+        "title": "FetchManifests"
+      },
+      "FetchRids": {
+        "properties": {
+          "rid_types": {
+            "items": {
+              "type": "string",
+              "format": "rid-type"
+            },
+            "type": "array",
+            "title": "Rid Types",
+            "default": []
+          }
+        },
+        "type": "object",
+        "title": "FetchRids"
+      },
+      "HTTPValidationError": {
+        "properties": {
+          "detail": {
+            "items": {
+              "$ref": "#/components/schemas/ValidationError"
+            },
+            "type": "array",
+            "title": "Detail"
+          }
+        },
+        "type": "object",
+        "title": "HTTPValidationError"
+      },
+      "Manifest": {
+        "properties": {
+          "rid": {
+            "type": "string",
+            "format": "rid",
+            "title": "Rid"
+          },
+          "timestamp": {
+            "type": "string",
+            "format": "date-time",
+            "title": "Timestamp"
+          },
+          "sha256_hash": {
+            "type": "string",
+            "title": "Sha256 Hash"
+          }
+        },
+        "type": "object",
+        "required": [
+          "rid",
+          "timestamp",
+          "sha256_hash"
+        ],
+        "title": "Manifest",
+        "description": "A portable descriptor of a data object associated with an RID.\n\nComposed of an RID, timestamp, and sha256 hash of the data object."
+      },
+      "ManifestsPayload": {
+        "properties": {
+          "manifests": {
+            "items": {
+              "$ref": "#/components/schemas/Manifest"
+            },
+            "type": "array",
+            "title": "Manifests"
+          },
+          "not_found": {
+            "items": {
+              "type": "string",
+              "format": "rid"
+            },
+            "type": "array",
+            "title": "Not Found",
+            "default": []
+          }
+        },
+        "type": "object",
+        "required": [
+          "manifests"
+        ],
+        "title": "ManifestsPayload"
+      },
+      "PollEvents": {
+        "properties": {
+          "rid": {
+            "type": "string",
+            "format": "rid",
+            "title": "Rid"
+          },
+          "limit": {
+            "type": "integer",
+            "title": "Limit",
+            "default": 0
+          }
+        },
+        "type": "object",
+        "required": [
+          "rid"
+        ],
+        "title": "PollEvents"
+      },
+      "RidsPayload": {
+        "properties": {
+          "rids": {
+            "items": {
+              "type": "string",
+              "format": "rid"
+            },
+            "type": "array",
+            "title": "Rids"
+          }
+        },
+        "type": "object",
+        "required": [
+          "rids"
+        ],
+        "title": "RidsPayload"
+      },
+      "ValidationError": {
+        "properties": {
+          "loc": {
+            "items": {
+              "anyOf": [
+                {
+                  "type": "string"
+                },
+                {
+                  "type": "integer"
+                }
+              ]
+            },
+            "type": "array",
+            "title": "Location"
+          },
+          "msg": {
+            "type": "string",
+            "title": "Message"
+          },
+          "type": {
+            "type": "string",
+            "title": "Error Type"
+          }
+        },
+        "type": "object",
+        "required": [
+          "loc",
+          "msg",
+          "type"
+        ],
+        "title": "ValidationError"
+      }
+    }
+  }
+}