koi-net 1.0.0b19__py3-none-any.whl → 1.1.0__py3-none-any.whl

koi_net/processor/default_handlers.py

@@ -1,29 +1,28 @@
 """Provides implementations of default knowledge handlers."""
 
 import logging
-from rid_lib.ext.bundle import Bundle
+from rid_lib.ext import Bundle
+from rid_lib.ext.utils import sha256_hash
 from rid_lib.types import KoiNetNode, KoiNetEdge
 from koi_net.protocol.node import NodeType
-from .interface import ProcessorInterface
 from .handler import KnowledgeHandler, HandlerType, STOP_CHAIN
-from .knowledge_object import KnowledgeObject, KnowledgeSource
+from .knowledge_object import KnowledgeObject
+from ..context import HandlerContext
 from ..protocol.event import Event, EventType
-from ..protocol.edge import EdgeProfile, EdgeStatus, EdgeType
+from ..protocol.edge import EdgeProfile, EdgeStatus, EdgeType, generate_edge_bundle
 from ..protocol.node import NodeProfile
-from ..protocol.helpers import generate_edge_bundle
 
 logger = logging.getLogger(__name__)
 
 # RID handlers
 
 @KnowledgeHandler.create(HandlerType.RID)
-def basic_rid_handler(processor: ProcessorInterface, kobj: KnowledgeObject):
+def basic_rid_handler(ctx: HandlerContext, kobj: KnowledgeObject):
     """Default RID handler.
     
     Blocks external events about this node. Allows `FORGET` events if RID is known to this node.
     """
-    if (kobj.rid == processor.identity.rid and 
-        kobj.source == KnowledgeSource.External):
+    if (kobj.rid == ctx.identity.rid and kobj.source):
         logger.debug("Don't let anyone else tell me who I am!")
         return STOP_CHAIN
     
@@ -34,12 +33,12 @@ def basic_rid_handler(processor: ProcessorInterface, kobj: KnowledgeObject):
 # Manifest handlers
 
 @KnowledgeHandler.create(HandlerType.Manifest)
-def basic_manifest_handler(processor: ProcessorInterface, kobj: KnowledgeObject):
+def basic_manifest_handler(ctx: HandlerContext, kobj: KnowledgeObject):
     """Default manifest handler.
     
     Blocks manifests with the same hash, or aren't newer than the cached version. Sets the normalized event type to `NEW` or `UPDATE` depending on whether the RID was previously known to this node.
     """
-    prev_bundle = processor.cache.read(kobj.rid)
+    prev_bundle = ctx.cache.read(kobj.rid)
 
     if prev_bundle:
         if kobj.manifest.sha256_hash == prev_bundle.manifest.sha256_hash:
@@ -61,36 +60,53 @@ def basic_manifest_handler(processor: ProcessorInterface, kobj: KnowledgeObject)
 
 # Bundle handlers
 
+@KnowledgeHandler.create(
+    handler_type=HandlerType.Bundle,
+    rid_types=[KoiNetNode],
+    event_types=[EventType.NEW, EventType.UPDATE]
+)
+def secure_profile_handler(ctx: HandlerContext, kobj: KnowledgeObject):
+    node_profile = kobj.bundle.validate_contents(NodeProfile)
+    node_rid: KoiNetNode = kobj.rid
+    
+    if sha256_hash(node_profile.public_key) != node_rid.hash:
+        logger.warning(f"Public key hash mismatch for {node_rid!r}!")
+        return STOP_CHAIN
+
 @KnowledgeHandler.create(
     handler_type=HandlerType.Bundle, 
     rid_types=[KoiNetEdge], 
-    source=KnowledgeSource.External,
     event_types=[EventType.NEW, EventType.UPDATE])
-def edge_negotiation_handler(processor: ProcessorInterface, kobj: KnowledgeObject):
+def edge_negotiation_handler(ctx: HandlerContext, kobj: KnowledgeObject):
     """Handles basic edge negotiation process.
     
     Automatically approves proposed edges if they request RID types this node can provide (or KOI nodes/edges). Validates the edge type is allowed for the node type (partial nodes cannot use webhooks). If edge is invalid, a `FORGET` event is sent to the other node.
     """
+
+    # only respond when source is another node
+    if kobj.source is None: return
     
-    edge_profile = EdgeProfile.model_validate(kobj.contents)
+    edge_profile = kobj.bundle.validate_contents(EdgeProfile)
 
     # indicates peer subscribing to me
-    if edge_profile.source == processor.identity.rid:     
+    if edge_profile.source == ctx.identity.rid:     
         if edge_profile.status != EdgeStatus.PROPOSED:
             return
         
         logger.debug("Handling edge negotiation")
         
         peer_rid = edge_profile.target
-        peer_profile = processor.network.graph.get_node_profile(peer_rid)
+        peer_bundle = ctx.effector.deref(peer_rid)
         
-        if not peer_profile:
-            logger.warning(f"Peer {peer_rid} unknown to me")
+        if not peer_bundle:
+            logger.warning(f"Peer {peer_rid!r} unknown to me")
             return STOP_CHAIN
         
+        peer_profile = peer_bundle.validate_contents(NodeProfile)
+        
         # explicitly provided event RID types and (self) node + edge objects
         provided_events = (
-            *processor.identity.profile.provides.event,
+            *ctx.identity.profile.provides.event,
             KoiNetNode, KoiNetEdge
         )
         
@@ -107,7 +123,7 @@ def edge_negotiation_handler(processor: ProcessorInterface, kobj: KnowledgeObjec
         
         if abort:
             event = Event.from_rid(EventType.FORGET, kobj.rid)
-            processor.network.push_event_to(event, peer_rid, flush=True)
+            ctx.event_queue.push_event_to(event, peer_rid, flush=True)
             return STOP_CHAIN
 
         else:
@@ -116,10 +132,10 @@ def edge_negotiation_handler(processor: ProcessorInterface, kobj: KnowledgeObjec
             edge_profile.status = EdgeStatus.APPROVED
             updated_bundle = Bundle.generate(kobj.rid, edge_profile.model_dump())
       
-            processor.handle(bundle=updated_bundle, event_type=EventType.UPDATE)
+            ctx.handle(bundle=updated_bundle, event_type=EventType.UPDATE)
             return
               
-    elif edge_profile.target == processor.identity.rid:
+    elif edge_profile.target == ctx.identity.rid:
         if edge_profile.status == EdgeStatus.APPROVED:
             logger.debug("Edge approved by other node!")
 
@@ -127,88 +143,88 @@ def edge_negotiation_handler(processor: ProcessorInterface, kobj: KnowledgeObjec
 # Network handlers
 
 @KnowledgeHandler.create(HandlerType.Network, rid_types=[KoiNetNode])
-def coordinator_contact(processor: ProcessorInterface, kobj: KnowledgeObject):
+def coordinator_contact(ctx: HandlerContext, kobj: KnowledgeObject):
     node_profile = kobj.bundle.validate_contents(NodeProfile)
-    
+            
     # looking for event provider of nodes
     if KoiNetNode not in node_profile.provides.event:
         return
     
     # prevents coordinators from attempting to form a self loop
-    if kobj.rid == processor.identity.rid:
+    if kobj.rid == ctx.identity.rid:
         return
     
     # already have an edge established
-    if processor.network.graph.get_edge_profile(
+    if ctx.graph.get_edge(
         source=kobj.rid,
-        target=processor.identity.rid,
+        target=ctx.identity.rid,
     ) is not None:
         return
     
     logger.info("Identified a coordinator!")
     logger.info("Proposing new edge")
     
-    if processor.identity.profile.node_type == NodeType.FULL:
+    if ctx.identity.profile.node_type == NodeType.FULL:
         edge_type = EdgeType.WEBHOOK
     else:
         edge_type = EdgeType.POLL
     
     # queued for processing
-    processor.handle(bundle=generate_edge_bundle(
+    ctx.handle(bundle=generate_edge_bundle(
         source=kobj.rid,
-        target=processor.identity.rid,
+        target=ctx.identity.rid,
         edge_type=edge_type,
         rid_types=[KoiNetNode]
     ))
     
     logger.info("Catching up on network state")
     
-    payload = processor.network.request_handler.fetch_rids(
+    payload = ctx.request_handler.fetch_rids(
         node=kobj.rid, 
         rid_types=[KoiNetNode]
     )
     for rid in payload.rids:
-        if rid == processor.identity.rid:
+        if rid == ctx.identity.rid:
             logger.info("Skipping myself")
             continue
-        if processor.cache.exists(rid):
-            logger.info(f"Skipping known RID '{rid}'")
+        if ctx.cache.exists(rid):
+            logger.info(f"Skipping known RID {rid!r}")
             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)
+        ctx.handle(rid=rid, source=kobj.rid)
     logger.info("Done")
     
 
 @KnowledgeHandler.create(HandlerType.Network)
-def basic_network_output_filter(processor: ProcessorInterface, kobj: KnowledgeObject):
+def basic_network_output_filter(ctx: HandlerContext, kobj: KnowledgeObject):
     """Default network handler.
     
     Allows broadcasting of all RID types this node is an event provider for (set in node profile), and other nodes have subscribed to. All nodes will also broadcast about their own (internally sourced) KOI node, and KOI edges that they are part of, regardless of their node profile configuration. Finally, nodes will also broadcast about edges to the other node involved (regardless of if they are subscribed)."""
     
     involves_me = False
-    if kobj.source == KnowledgeSource.Internal:
+    if kobj.source is None:
         if (type(kobj.rid) == KoiNetNode):
-            if (kobj.rid == processor.identity.rid):
+            if (kobj.rid == ctx.identity.rid):
                 involves_me = True
         
         elif type(kobj.rid) == KoiNetEdge:
             edge_profile = kobj.bundle.validate_contents(EdgeProfile)
             
-            if edge_profile.source == processor.identity.rid:
+            if edge_profile.source == ctx.identity.rid:
                 logger.debug(f"Adding edge target '{edge_profile.target!r}' to network targets")
                 kobj.network_targets.update([edge_profile.target])
                 involves_me = True
                 
-            elif edge_profile.target == processor.identity.rid:
+            elif edge_profile.target == ctx.identity.rid:
                 logger.debug(f"Adding edge source '{edge_profile.source!r}' to network targets")
                 kobj.network_targets.update([edge_profile.source])
                 involves_me = True
     
-    if (type(kobj.rid) in processor.identity.profile.provides.event or involves_me):
+    if (type(kobj.rid) in ctx.identity.profile.provides.event or involves_me):
         # broadcasts to subscribers if I'm an event provider of this RID type OR it involves me
-        subscribers = processor.network.graph.get_neighbors(
+        subscribers = ctx.graph.get_neighbors(
             direction="out",
             allowed_type=type(kobj.rid)
         )
@@ -217,4 +233,17 @@ def basic_network_output_filter(processor: ProcessorInterface, kobj: KnowledgeOb
         kobj.network_targets.update(subscribers)
         
     return kobj
-            
+
+@KnowledgeHandler.create(HandlerType.Final, rid_types=[KoiNetNode])
+def forget_edge_on_node_deletion(ctx: HandlerContext, kobj: KnowledgeObject):
+    if kobj.normalized_event_type != EventType.FORGET:
+        return
+    
+    for edge_rid in ctx.graph.get_edges():
+        edge_bundle = ctx.cache.read(edge_rid)
+        if not edge_bundle: continue
+        edge_profile = edge_bundle.validate_contents(EdgeProfile)
+        
+        if kobj.rid in (edge_profile.source, edge_profile.target):
+            logger.debug("Identified edge with forgotten node")
+            ctx.handle(rid=edge_rid, event_type=EventType.FORGET)

koi_net/processor/handler.py

@@ -2,9 +2,7 @@ from dataclasses import dataclass
 from enum import StrEnum
 from typing import Callable
 from rid_lib import RIDType
-
 from ..protocol.event import EventType
-from .knowledge_object import KnowledgeSource, KnowledgeEventType
 
 
 class StopChain:
@@ -37,23 +35,21 @@ class KnowledgeHandler:
     func: Callable
     handler_type: HandlerType
     rid_types: list[RIDType] | None
-    source: KnowledgeSource | None = None
-    event_types: list[KnowledgeEventType] | None = None
+    event_types: list[EventType | None] | None = None
     
     @classmethod
     def create(
         cls,
         handler_type: HandlerType,
         rid_types: list[RIDType] | None = None,
-        source: KnowledgeSource | None = None,
-        event_types: list[KnowledgeEventType] | None = None
+        event_types: list[EventType | None] | None = None
     ):
         """Special decorator that returns a KnowledgeHandler instead of a function.
         
         The function symbol will redefined as a `KnowledgeHandler`, which can be passed into the `ProcessorInterface` constructor. This is used to register default handlers.
         """
         def decorator(func: Callable) -> KnowledgeHandler:
-            handler = cls(func, handler_type, rid_types, source, event_types)
+            handler = cls(func, handler_type, rid_types, event_types)
             return handler
         return decorator
 

koi_net/processor/interface.py

@@ -1,57 +1,31 @@
 import logging
 import queue
 import threading
-from typing import Callable, Generic
-from rid_lib.core import RID, RIDType
-from rid_lib.ext import Bundle, Cache, Manifest
-from rid_lib.types.koi_net_edge import KoiNetEdge
-from rid_lib.types.koi_net_node import KoiNetNode
-from ..identity import NodeIdentity
-from ..network import NetworkInterface
+from rid_lib.core import RID
+from rid_lib.ext import Bundle, Manifest
+from rid_lib.types import KoiNetNode
 from ..protocol.event import Event, EventType
-from ..config import NodeConfig
-from .handler import (
-    KnowledgeHandler, 
-    HandlerType, 
-    STOP_CHAIN,
-    StopChain
-)
-from .knowledge_object import (
-    KnowledgeObject,
-    KnowledgeSource, 
-    KnowledgeEventType
-)
+from .knowledge_object import KnowledgeObject
+from .knowledge_pipeline import KnowledgePipeline
+
 
 logger = logging.getLogger(__name__)
 
 
-class ProcessorInterface():
+class ProcessorInterface:
     """Provides access to this node's knowledge processing pipeline."""
-    
-    config: NodeConfig
-    cache: Cache
-    network: NetworkInterface
-    identity: NodeIdentity
-    handlers: list[KnowledgeHandler]
+    pipeline: KnowledgePipeline
     kobj_queue: queue.Queue[KnowledgeObject]
     use_kobj_processor_thread: bool
     worker_thread: threading.Thread | None = None
     
     def __init__(
         self,
-        config: NodeConfig,
-        cache: Cache, 
-        network: NetworkInterface,
-        identity: NodeIdentity,
+        pipeline: KnowledgePipeline,
         use_kobj_processor_thread: bool,
-        default_handlers: list[KnowledgeHandler] = []
     ):
-        self.config = config
-        self.cache = cache
-        self.network = network
-        self.identity = identity
+        self.pipeline = pipeline
         self.use_kobj_processor_thread = use_kobj_processor_thread
-        self.handlers: list[KnowledgeHandler] = default_handlers
         self.kobj_queue = queue.Queue()
         
         if self.use_kobj_processor_thread:
@@ -59,180 +33,7 @@ class ProcessorInterface():
                 target=self.kobj_processor_worker,
                 daemon=True
             )
-        
-    def add_handler(self, handler: KnowledgeHandler):
-        self.handlers.append(handler)
-            
-    def register_handler(
-        self,
-        handler_type: HandlerType,
-        rid_types: list[RIDType] | None = None,
-        source: KnowledgeSource | None = None,
-        event_types: list[KnowledgeEventType] | None = None
-    ):
-        """Assigns decorated function as handler for this processor."""
-        def decorator(func: Callable) -> Callable:
-            handler = KnowledgeHandler(func, handler_type, rid_types, source, event_types)
-            self.add_handler(handler)
-            return func
-        return decorator
-            
-    def call_handler_chain(
-        self, 
-        handler_type: HandlerType,
-        kobj: KnowledgeObject
-    ) -> KnowledgeObject | StopChain:
-        """Calls handlers of provided type, chaining their inputs and outputs together.
-        
-        The knowledge object provided when this function is called will be passed to the first handler. A handler may return one of three types: 
-        - `KnowledgeObject` - to modify the knowledge object for the next handler in the chain
-        - `None` - to keep the same knowledge object for the next handler in the chain
-        - `STOP_CHAIN` - to stop the handler chain and immediately exit the processing pipeline
-        
-        Handlers will only be called in the chain if their handler and RID type match that of the inputted knowledge object. 
-        """
-        
-        for handler in self.handlers:
-            if handler_type != handler.handler_type: 
-                continue
-            
-            if handler.rid_types and type(kobj.rid) not in handler.rid_types:
-                continue
-            
-            if handler.source and handler.source != kobj.source:
-                continue
-            
-            if handler.event_types and kobj.event_type not in handler.event_types:
-                continue
-            
-            logger.debug(f"Calling {handler_type} handler '{handler.func.__name__}'")
-            resp = handler.func(self, kobj.model_copy())
-            
-            # stops handler chain execution
-            if resp is STOP_CHAIN:
-                logger.debug(f"Handler chain stopped by {handler.func.__name__}")
-                return STOP_CHAIN
-            # kobj unmodified
-            elif resp is None:
-                continue
-            # kobj modified by handler
-            elif isinstance(resp, KnowledgeObject):
-                kobj = resp
-                logger.debug(f"Knowledge object modified by {handler.func.__name__}")
-            else:
-                raise ValueError(f"Handler {handler.func.__name__} returned invalid response '{resp}'")
-                    
-        return kobj
-
-        
-    def process_kobj(self, kobj: KnowledgeObject) -> None:
-        """Sends provided knowledge obejct through knowledge processing pipeline.
-        
-        Handler chains are called in between major events in the pipeline, indicated by their handler type. Each handler type is guaranteed to have access to certain knowledge, and may affect a subsequent action in the pipeline. The five handler types are as follows:
-        - RID - provided RID; if event type is `FORGET`, this handler decides whether to delete the knowledge from the cache by setting the normalized event type to `FORGET`, otherwise this handler decides whether to validate the manifest (and fetch it if not provided).
-        - Manifest - provided RID, manifest; decides whether to validate the bundle (and fetch it if not provided).
-        - Bundle - provided RID, manifest, contents (bundle); decides whether to write knowledge to the cache by setting the normalized event type to `NEW` or `UPDATE`.
-        - Network - provided RID, manifest, contents (bundle); decides which nodes (if any) to broadcast an event about this knowledge to. (Note, if event type is `FORGET`, the manifest and contents will be retrieved from the local cache, and indicate the last state of the knowledge before it was deleted.)
-        - Final - provided RID, manifests, contents (bundle); final action taken after network broadcast.
-        
-        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}")
-        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")
-                return
-            
-            # the bundle (to be deleted) attached to kobj for downstream analysis
-            logger.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")
-                if kobj.source == KnowledgeSource.External:
-                    logger.debug("Attempting to fetch remote manifest")
-                    manifest = self.network.fetch_remote_manifest(kobj.rid)
-                    
-                elif kobj.source == KnowledgeSource.Internal:
-                    logger.debug("Attempting to read manifest from cache")
-                    bundle = self.cache.read(kobj.rid)
-                    if bundle: 
-                        manifest = bundle.manifest
-                    else:
-                        manifest = None
-                        return
-                    
-                if not manifest:
-                    logger.debug("Failed to find manifest")
-                    return
-                
-                kobj.manifest = manifest
-                
-            kobj = self.call_handler_chain(HandlerType.Manifest, kobj)
-            if kobj is STOP_CHAIN: return
-            
-            # attempt to retrieve bundle
-            if not kobj.bundle:
-                logger.debug("Bundle not found")
-                if kobj.source == KnowledgeSource.External:
-                    logger.debug("Attempting to fetch remote bundle")
-                    bundle = self.network.fetch_remote_bundle(kobj.rid)
-                    
-                elif kobj.source == KnowledgeSource.Internal:
-                    logger.debug("Attempting to read bundle from cache")
-                    bundle = self.cache.read(kobj.rid)
-                
-                if not bundle: 
-                    logger.debug("Failed to find bundle")
-                    return
-                
-                if kobj.manifest != bundle.manifest:
-                    logger.warning("Retrieved bundle contains a different manifest")
-                
-                kobj.manifest = bundle.manifest
-                kobj.contents = bundle.contents                
-                
-        kobj = self.call_handler_chain(HandlerType.Bundle, kobj)
-        if kobj is STOP_CHAIN: return
-            
-        if kobj.normalized_event_type in (EventType.UPDATE, EventType.NEW):
-            logger.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}")
-            self.cache.delete(kobj.rid)
-            
-        else:
-            logger.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")
-            self.network.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)")
-        else:
-            logger.debug("No network targets set")
-        
-        for node in kobj.network_targets:
-            self.network.push_event_to(kobj.normalized_event, node)
-            self.network.flush_webhook_queue(node)
-        
-        kobj = self.call_handler_chain(HandlerType.Final, kobj)
-
+    
     def flush_kobj_queue(self):
         """Flushes all knowledge objects from queue and processes them.
         
@@ -246,7 +47,7 @@ class ProcessorInterface():
             logger.debug(f"Dequeued {kobj!r}")
             
             try:
-                self.process_kobj(kobj)
+                self.pipeline.process(kobj)
             finally:
                 self.kobj_queue.task_done()
             logger.debug("Done")
@@ -258,7 +59,7 @@ class ProcessorInterface():
                 logger.debug(f"Dequeued {kobj!r}")
                 
                 try:
-                    self.process_kobj(kobj)
+                    self.pipeline.process(kobj)
                 finally:
                     self.kobj_queue.task_done()
                 logger.debug("Done")
@@ -276,8 +77,8 @@ class ProcessorInterface():
         bundle: Bundle | None = None,
         event: Event | None = None,
         kobj: KnowledgeObject | None = None,
-        event_type: KnowledgeEventType = None,
-        source: KnowledgeSource = KnowledgeSource.Internal
+        event_type: EventType | None = None,
+        source: KoiNetNode | None = None
     ):
         """Queues provided knowledge to be handled by processing pipeline.
         

koi_net/processor/knowledge_object.py

@@ -1,4 +1,3 @@
-from enum import StrEnum
 from pydantic import BaseModel
 from rid_lib import RID
 from rid_lib.ext import Manifest
@@ -7,12 +6,6 @@ from rid_lib.types.koi_net_node import KoiNetNode
 from ..protocol.event import Event, EventType
 
 
-type KnowledgeEventType = EventType | None
-
-class KnowledgeSource(StrEnum):
-    Internal = "INTERNAL"
-    External = "EXTERNAL"
-
 class KnowledgeObject(BaseModel):
     """A normalized knowledge representation for internal processing.
     
@@ -29,9 +22,9 @@ class KnowledgeObject(BaseModel):
     rid: RID
     manifest: Manifest | None = None
     contents: dict | None = None
-    event_type: KnowledgeEventType = None
-    normalized_event_type: KnowledgeEventType = None
-    source: KnowledgeSource
+    event_type: EventType | None = None
+    normalized_event_type: EventType | None = None
+    source: KoiNetNode | None = None
     network_targets: set[KoiNetNode] = set()
     
     def __repr__(self):
@@ -41,8 +34,8 @@ class KnowledgeObject(BaseModel):
     def from_rid(
         cls, 
         rid: RID, 
-        event_type: KnowledgeEventType = None, 
-        source: KnowledgeSource = KnowledgeSource.Internal
+        event_type: EventType | None = None, 
+        source: KoiNetNode | None = None
     ) -> "KnowledgeObject":
         return cls(
             rid=rid,
@@ -54,8 +47,8 @@ class KnowledgeObject(BaseModel):
     def from_manifest(
         cls, 
         manifest: Manifest, 
-        event_type: KnowledgeEventType = None, 
-        source: KnowledgeSource = KnowledgeSource.Internal
+        event_type: EventType | None = None, 
+        source: KoiNetNode | None = None
     ) -> "KnowledgeObject":
         return cls(
             rid=manifest.rid,
@@ -68,8 +61,8 @@ class KnowledgeObject(BaseModel):
     def from_bundle(
         cls, 
         bundle: Bundle, 
-        event_type: KnowledgeEventType = None, 
-        source: KnowledgeSource = KnowledgeSource.Internal
+        event_type: EventType | None = None, 
+        source: KoiNetNode | None = None
     ) -> "KnowledgeObject":
         return cls(
             rid=bundle.rid,
@@ -83,7 +76,7 @@ class KnowledgeObject(BaseModel):
     def from_event(
         cls,
         event: Event,
-        source: KnowledgeSource = KnowledgeSource.Internal
+        source: KoiNetNode | None = None
     ) -> "KnowledgeObject":
         return cls(
             rid=event.rid,