mycorrhizal 0.2.1__py3-none-any.whl → 0.2.2__py3-none-any.whl

mycorrhizal/_version.py

@@ -1 +1 @@
-version = "0.2.1"
+version = "0.2.2"

mycorrhizal/hypha/core/runtime.py

@@ -285,51 +285,64 @@ class TransitionRuntime:
             if result is not None:
                 await self._process_yield(result)
 
-    def _resolve_place_ref(self, place_ref) -> Optional[Tuple[str, ...]]:
+    def _resolve_place_ref(self, place_ref) -> Tuple[str, ...]:
         """Resolve a PlaceRef to runtime place parts.
 
-        Attempts multiple resolution strategies in order:
+        Requires exact match or parent-relative mapping for subnet instances.
+
+        Resolution strategies in order:
         1. Exact match using PlaceRef.get_parts()
         2. Parent-relative mapping (for subnet instances)
-        3. Suffix fallback (match by local name)
 
         Returns:
-            Tuple of place parts if found, None otherwise
+            Tuple of place parts if found
+
+        Raises:
+            ValueError: If reference cannot be resolved
         """
+        # Extract local_name from place_ref (handles PlaceRef objects and strings)
+        if isinstance(place_ref, str):
+            local_name = place_ref
+        elif hasattr(place_ref, 'local_name'):
+            local_name = place_ref.local_name
+        else:
+            local_name = str(place_ref)
+
         # Try to get parts from the PlaceRef API
         try:
             parts = tuple(place_ref.get_parts())
         except Exception:
             parts = None
 
-        logger.debug("[resolve] place_ref=%r parts=%s", place_ref, parts)
+        logger.debug("[resolve] place_ref=%r parts=%s local_name=%s",
+                     place_ref, parts, local_name)
 
+        # Strategy 1: Exact match
         if parts:
             key = tuple(parts)
             if key in self.net.places:
                 logger.debug("[resolve] exact match parts=%s", parts)
                 return key
 
-        # Map relative to this transition's parent parts
+        # Strategy 2: Parent-relative mapping (for subnet instances)
         trans_parts = tuple(self.fqn.split('.'))
         if len(trans_parts) > 1:
             parent_prefix = trans_parts[:-1]
-            candidate = tuple(list(parent_prefix) + [place_ref.local_name])
+            candidate = tuple(list(parent_prefix) + [local_name])
             if candidate in self.net.places:
-                logger.debug("[resolve] mapped %s -> %s using parent_prefix", parts, candidate)
+                logger.debug("[resolve] mapped %s -> %s using parent_prefix",
+                           local_name, candidate)
                 return candidate
 
-        # Fallback: find any place whose last segment matches local_name
-        for p in self.net.places.keys():
-            if isinstance(p, tuple):
-                segs = list(p)
-            else:
-                segs = p.split('.')
-            if segs and segs[-1] == place_ref.local_name:
-                logger.debug("[resolve] suffix match %s -> %s", place_ref.local_name, p)
-                return tuple(segs)
-
-        return None
+        # No match found - raise helpful error
+        available_places = [p[-1] if isinstance(p, tuple) else p.split('.')[-1]
+                           for p in self.net.places.keys()]
+        raise ValueError(
+            f"Cannot resolve place reference '{local_name}' "
+            f"in transition '{self.fqn}'. Available places: {available_places}. "
+            f"Attempted resolution: {parts}. "
+            f"Use explicit place references (e.g., subnet.place)."
+        )
 
     def _normalize_to_parts(self, key) -> Tuple[str, ...]:
         """Normalize a place key to tuple of parts for runtime lookup.
@@ -387,9 +400,6 @@ class TransitionRuntime:
                 continue
 
             place_parts = self._resolve_place_ref(key)
-            if place_parts is None:
-                continue
-
             key_normalized = self._normalize_to_parts(place_parts)
             explicit_targets.add(key_normalized)
             await self._add_token_to_place(key_normalized, token)
@@ -420,10 +430,6 @@ class TransitionRuntime:
         """Process a single (place_ref, token) tuple yield."""
         place_ref, token = yielded
         place_parts = self._resolve_place_ref(place_ref)
-
-        if place_parts is None:
-            return
-
         key = self._normalize_to_parts(place_parts)
         await self._add_token_to_place(key, token)
     
@@ -521,6 +527,8 @@ class TransitionRuntime:
 
         except asyncio.CancelledError:
             pass
+        except ValueError:
+            raise
         except Exception:
             logger.exception("[%s] Transition error", self.fqn)
     
@@ -969,20 +977,24 @@ class NetRuntime:
 
 class Runner:
     """High-level runner for executing a Petri net"""
-    
+
     def __init__(self, net_func: Any, blackboard: Any):
         if not hasattr(net_func, '_spec'):
             raise ValueError(f"{net_func} is not a valid net")
-        
+
         self.spec = net_func._spec
         self.blackboard = blackboard
         self.timebase = None
         self.runtime: Optional[NetRuntime] = None
-    
+
     async def start(self, timebase: Any):
         """Start the net with given timebase"""
         self.timebase = timebase
-        self.runtime = NetRuntime(self.spec, self.blackboard, self.timebase)
+        self.runtime = NetRuntime(
+            self.spec,
+            self.blackboard,
+            self.timebase
+        )
         await self.runtime.start()
     
     async def stop(self, timeout: float = 5.0):

mycorrhizal/rhizomorph/core.py

@@ -452,7 +452,35 @@ class Condition(Action[BB]):
 
 
 class Sequence(Node[BB]):
-    """Sequence (AND): fail/err fast; RUNNING bubbles; all SUCCESS → SUCCESS."""
+    """Sequence (AND): fail/err fast; RUNNING bubbles; all SUCCESS → SUCCESS.
+
+    Memory Behavior:
+        When memory=True (default), the sequence remembers its position across ticks.
+        This allows the sequence to progress through its children incrementally.
+
+        When memory=False, the sequence restarts from the beginning on every tick.
+        This is useful for reactive sequences that should always start from the first child.
+
+    Important Note on do_while Loops:
+        If a sequence is used as the child of a do_while loop, it typically needs
+        memory=True to make progress. Without memory, the sequence will restart from
+        its first child on each tick, preventing it from completing all children.
+
+        Example:
+            @bt.sequence(memory=True)  # Required for progress
+            def image_samples():
+                yield bt.subtree(MoveToSample)
+                yield send_image_request
+                yield bt.subtree(IncrementSampleCounter)
+
+            @bt.sequence(memory=True)
+            def happy_path():
+                yield bt.do_while(samples_remain)(image_samples)
+                yield set_pod_to_grow
+
+        Without memory=True on image_samples, the do_while loop would never
+        progress past MoveToSample because the sequence would restart each tick.
+    """
 
     def __init__(
         self,
@@ -492,7 +520,20 @@ class Sequence(Node[BB]):
 
 
 class Selector(Node[BB]):
-    """Selector (Fallback): first SUCCESS wins; RUNNING bubbles; else FAILURE."""
+    """Selector (Fallback): first SUCCESS wins; RUNNING bubbles; else FAILURE.
+
+    Memory Behavior:
+        When memory=True (default), the selector remembers its position across ticks.
+        This allows the selector to continue trying children from where it left off.
+
+        When memory=False, the selector restarts from the beginning on every tick.
+        This is useful for reactive selectors that should always re-evaluate from the first child.
+
+    Important Note on do_while Loops:
+        Similar to Sequence, if a selector is used as the child of a do_while loop,
+        it typically needs memory=True to make progress. Without memory, the selector
+        will restart from its first child on each tick.
+    """
 
     def __init__(
         self,
@@ -849,20 +890,72 @@ class Gate(Node[BB]):
         return await self._finish(bb, st, tb)
 
 
+class When(Node[BB]):
+    """
+    Conditionally execute a child, returning SUCCESS if the condition fails.
+
+    Unlike gate(), when() does NOT fail the parent when the condition is false.
+    This is useful for optional steps or feature flags in sequences.
+
+    Behavior:
+      - If condition returns SUCCESS → execute child, return child's status
+      - If condition returns RUNNING → return RUNNING
+      - Otherwise → return SUCCESS (skip but don't fail parent)
+
+    Example:
+        yield bt.when(feature_enabled)(optional_action)
+        # If feature_enabled is false, returns SUCCESS and sequence continues
+    """
+
+    def __init__(
+        self,
+        condition: Node[BB],
+        child: Node[BB],
+        name: Optional[str] = None,
+        exception_policy: ExceptionPolicy = ExceptionPolicy.LOG_AND_CONTINUE,
+    ) -> None:
+        super().__init__(
+            name or f"When(cond={_name_of(condition)}, child={_name_of(child)})",
+            exception_policy=exception_policy,
+        )
+        self.condition = condition
+        self.child = child
+        self.condition.parent = self
+        self.child.parent = self
+
+    def reset(self) -> None:
+        super().reset()
+        self.condition.reset()
+        self.child.reset()
+
+    async def tick(self, bb: BB, tb: Timebase) -> Status:
+        await self._ensure_entered(bb, tb)
+        c = await self.condition.tick(bb, tb)
+        if c is Status.RUNNING:
+            return Status.RUNNING
+        if c is not Status.SUCCESS:
+            # Condition failed - return SUCCESS to skip but don't block parent
+            return await self._finish(bb, Status.SUCCESS, tb)
+        st = await self.child.tick(bb, tb)
+        if st is Status.RUNNING:
+            return Status.RUNNING
+        return await self._finish(bb, st, tb)
+
+
 class Match(Node[BB]):
     """
     Pattern-matching dispatch node.
-    
+
     Evaluates a key function against the blackboard, then checks each case
     in order. The first matching case's child is executed. If the child
     completes (SUCCESS or FAILURE), that status is returned immediately.
-    
+
     Cases can match by:
       - Type: isinstance(value, case_type)
       - Predicate: case_predicate(value) returns True
       - Value: value == case_value
       - Default: always matches (should be last)
-    
+
     If no case matches and there's no default, returns FAILURE.
     """
 
@@ -1003,6 +1096,68 @@ class DoWhile(Node[BB]):
         return await self._finish(bb, Status.FAILURE, tb)
 
 
+class TryCatch(Node[BB]):
+    """
+    Try-catch error handling node.
+
+    Executes the try block first. If it returns SUCCESS, that status is returned.
+    If the try block returns FAILURE, the catch block is executed instead.
+    Returns SUCCESS if either block succeeds, FAILURE if both fail.
+
+    This is semantically equivalent to a selector with two children, but provides
+    clearer intent and better visualization with labeled edges.
+    """
+
+    def __init__(
+        self,
+        try_block: Node[BB],
+        catch_block: Node[BB],
+        name: Optional[str] = None,
+        exception_policy: ExceptionPolicy = ExceptionPolicy.LOG_AND_CONTINUE,
+    ) -> None:
+        super().__init__(
+            name or f"TryCatch(try={_name_of(try_block)}, catch={_name_of(catch_block)})",
+            exception_policy=exception_policy,
+        )
+        self.try_block = try_block
+        self.catch_block = catch_block
+        self.try_block.parent = self
+        self.catch_block.parent = self
+        self._use_catch = False
+
+    def reset(self) -> None:
+        super().reset()
+        self.try_block.reset()
+        self.catch_block.reset()
+        self._use_catch = False
+
+    async def tick(self, bb: BB, tb: Timebase) -> Status:
+        await self._ensure_entered(bb, tb)
+
+        # If we're in catch mode, continue executing catch block
+        if self._use_catch:
+            st = await self.catch_block.tick(bb, tb)
+            if st is Status.RUNNING:
+                return Status.RUNNING
+            self._use_catch = False
+            return await self._finish(bb, st, tb)
+
+        # Try the try block
+        st = await self.try_block.tick(bb, tb)
+        if st is Status.RUNNING:
+            return Status.RUNNING
+        if st is Status.SUCCESS:
+            return await self._finish(bb, Status.SUCCESS, tb)
+
+        # Try block failed, switch to catch
+        self._use_catch = True
+        st = await self.catch_block.tick(bb, tb)
+        if st is Status.RUNNING:
+            return Status.RUNNING
+        self._use_catch = False
+        return await self._finish(bb, st, tb)
+
+
 # ======================================================================================
 # Authoring DSL (NodeSpec + bt namespace)
 # ======================================================================================
@@ -1018,6 +1173,7 @@ class NodeSpecKind(Enum):
     SUBTREE = "subtree"
     MATCH = "match"
     DO_WHILE = "do_while"
+    TRY_CATCH = "try_catch"
 
 
 class _DefaultCase:
@@ -1128,6 +1284,16 @@ class NodeSpec:
                     exception_policy=exception_policy,
                 )
 
+            case NodeSpecKind.TRY_CATCH:
+                try_spec = self.payload["try"]
+                catch_spec = self.payload["catch"]
+                return TryCatch(
+                    try_spec.to_node(exception_policy),
+                    catch_spec.to_node(exception_policy),
+                    name=self.name,
+                    exception_policy=exception_policy,
+                )
+
             case _:
                 raise ValueError(f"Unknown spec kind: {self.kind}")
 
@@ -1271,6 +1437,31 @@ class _WrapperChain:
             lambda ch: Gate(cond_spec.to_node(), ch),
         )
 
+    def when(
+        self, condition_spec_or_fn: Union["NodeSpec", Callable[[Any], Any]]
+    ) -> "_WrapperChain":
+        """
+        Add a conditional wrapper that executes the child only when condition is true.
+
+        Unlike gate(), when() returns SUCCESS (not FAILURE) when the condition fails.
+        This allows sequences to continue when optional steps are skipped.
+
+        Args:
+            condition_spec_or_fn: A node spec or callable that returns True/False
+
+        Returns:
+            The chain for further wrapping
+
+        Example:
+            yield bt.when(is_enabled)(optional_action)
+            # If is_enabled is False, returns SUCCESS and sequence continues
+        """
+        cond_spec = bt.as_spec(condition_spec_or_fn)
+        return self._append(
+            f"When(cond={_name_of(cond_spec)})",
+            lambda ch: When(cond_spec.to_node(), ch),
+        )
+
     def __call__(self, inner: Union["NodeSpec", Callable[[Any], Any]]) -> "NodeSpec":
         """
         Apply the chain to a child spec → nested decorator NodeSpecs.
@@ -1342,10 +1533,10 @@ class _MatchBuilder:
 
 class _DoWhileBuilder:
     """Builder for do_while loops."""
-    
+
     def __init__(self, condition_spec: NodeSpec) -> None:
         self._condition_spec = condition_spec
-    
+
     def __call__(self, child: Union["NodeSpec", Callable[[Any], Any]]) -> NodeSpec:
         child_spec = bt.as_spec(child)
         return NodeSpec(
@@ -1404,6 +1595,33 @@ class _BT:
 
             3. Direct call with child nodes:
                 bt.sequence(action1, action2, action3)
+
+        Memory Parameter:
+            The memory parameter controls whether the sequence remembers its position
+            across ticks:
+
+            - memory=None (default): Use the Runner's memory setting
+            - memory=True: Remember position, allowing incremental progress
+            - memory=False: Restart from beginning each tick (reactive behavior)
+
+            IMPORTANT: If a sequence is inside a do_while loop and needs to execute
+            all its children incrementally, use memory=True. Otherwise, the sequence
+            will restart from the first child on every tick and never complete.
+
+            Example:
+                # CORRECT - sequence progresses through children
+                @bt.sequence(memory=True)
+                def process_samples():
+                    yield move_to_sample
+                    yield capture_image
+                yield bt.do_while(samples_remain)(process_samples)
+
+                # WRONG - sequence restarts at move_to_sample every tick
+                @bt.sequence(memory=False)
+                def process_samples():
+                    yield move_to_sample
+                    yield capture_image  # Never reached!
+                yield bt.do_while(samples_remain)(process_samples)
         """
         # Case 3: Direct call with children - bt.sequence(node1, node2, ...)
         # This is detected when we have multiple args, or a single arg that's not a generator function
@@ -1488,6 +1706,9 @@ class _BT:
 
             3. Direct call with child nodes:
                 bt.selector(option1, option2, option3)
+
+        The memory parameter defaults to None, which means use the Runner's memory setting.
+        Explicitly set to True or False to override the Runner's setting.
         """
         # Case 3: Direct call with children - bt.selector(node1, node2, ...)
         # This is detected when we have multiple args, or a single arg that's not a generator function
@@ -1604,6 +1825,28 @@ class _BT:
         cond_spec = self.as_spec(condition)
         return _WrapperChain().gate(cond_spec)
 
+    def when(self, condition: Union[NodeSpec, Callable[[Any], Any]]) -> _WrapperChain:
+        """
+        Create a conditional wrapper that executes the child only when condition is true.
+
+        Unlike gate(), when() returns SUCCESS (not FAILURE) when the condition fails.
+        This is useful for optional steps or feature flags in sequences.
+
+        Args:
+            condition: A node spec or callable that returns True/False
+
+        Returns:
+            A wrapper chain that can be applied to a child node
+
+        Example:
+            @bt.sequence
+            def my_sequence():
+                yield bt.when(feature_enabled)(optional_feature)
+                yield next_step  # Always reached, even if flag is disabled
+        """
+        cond_spec = self.as_spec(condition)
+        return _WrapperChain().when(cond_spec)
+
     def match(
         self, key_fn: Callable[[Any], Any], name: Optional[str] = None
     ) -> "_MatchBuilder":
@@ -1685,6 +1928,62 @@ class _BT:
         cond_spec = self.as_spec(condition)
         return _DoWhileBuilder(cond_spec)
 
+    def try_catch(
+        self, try_block: Union[NodeSpec, Callable[[Any], Any]]
+    ) -> Callable[[Union[NodeSpec, Callable[[Any], Any]]], NodeSpec]:
+        """
+        Create a try-catch error handling pattern.
+
+        Usage:
+            # Define try and catch blocks with explicit memory settings
+            @bt.sequence(memory=True)
+            def try_block():
+                yield action1
+                yield action2
+
+            @bt.sequence(memory=True)
+            def catch_block():
+                yield cleanup
+
+            # Use in the tree
+            @bt.root
+            @bt.sequence
+            def root():
+                yield bt.try_catch(try_block)(catch_block)
+
+        Behavior:
+            1. Execute try block
+            2. If try block returns SUCCESS → return SUCCESS
+            3. If try block returns FAILURE → execute catch block
+            4. Return SUCCESS if either block succeeds, FAILURE if both fail
+
+        This is semantically equivalent to a selector with two children:
+            - First child (try) runs first
+            - Second child (catch) runs only if try fails
+            - Returns SUCCESS if either succeeds
+
+        Args:
+            try_block: The node to try first (pre-defined sequence/selector/etc with explicit memory settings)
+
+        Returns:
+            A callable that accepts a catch block (pre-defined sequence/selector/etc with explicit memory settings)
+        """
+        try_spec = self.as_spec(try_block)
+
+        def catcher(catch_block: Union[NodeSpec, Callable[[Any], Any]]) -> NodeSpec:
+            catch_spec = self.as_spec(catch_block)
+            return NodeSpec(
+                kind=NodeSpecKind.TRY_CATCH,
+                name=f"TryCatch(try={_name_of(try_spec)}, catch={_name_of(catch_spec)})",
+                payload={
+                    "try": try_spec,
+                    "catch": catch_spec,
+                },
+                children=[try_spec, catch_spec],
+            )
+
+        return catcher
+
     def subtree(self, tree: SimpleNamespace) -> NodeSpec:
         """
         Mount another tree's root spec as a subtree.
@@ -1813,6 +2112,8 @@ def _generate_mermaid(tree: SimpleNamespace) -> str:
                 return f"Match<br/>{spec.name}"
             case NodeSpecKind.DO_WHILE:
                 return f"DoWhile<br/>{spec.name}"
+            case NodeSpecKind.TRY_CATCH:
+                return f"TryCatch<br/>{spec.name}"
             case _:
                 return spec.name
 
@@ -1831,6 +2132,9 @@ def _generate_mermaid(tree: SimpleNamespace) -> str:
                 # Children already set (just the body), but we also want to show condition
                 cond_spec = spec.payload["condition"]
                 spec.children = [cond_spec] + spec.children
+            case NodeSpecKind.TRY_CATCH:
+                # Children already set in _TryCatchBuilder
+                pass
         return spec.children
 
     def walk(spec: NodeSpec) -> None:
@@ -1860,10 +2164,24 @@ def _generate_mermaid(tree: SimpleNamespace) -> str:
                 body_id = nid(children[1])
                 lines.append(f'  {this_id} -->|"body"| {body_id}')
                 walk(children[1])
+        elif spec.kind == NodeSpecKind.TRY_CATCH:
+            # First child is try, second is catch
+            try_id = nid(children[0])
+            lines.append(f'  {this_id} -->|"try"| {try_id}')
+            walk(children[0])
+            if len(children) > 1:
+                catch_id = nid(children[1])
+                lines.append(f'  {this_id} -->|"catch"| {catch_id}')
+                walk(children[1])
         else:
-            for child in children:
+            for i, child in enumerate(children, start=1):
                 child_id = nid(child)
-                lines.append(f"  {this_id} --> {child_id}")
+                if spec.kind == NodeSpecKind.PARALLEL:
+                    lines.append(f'  {this_id} -->|"P"| {child_id}')
+                elif spec.kind in (NodeSpecKind.SEQUENCE, NodeSpecKind.SELECTOR):
+                    lines.append(f'  {this_id} -->|"{i}"| {child_id}')
+                else:
+                    lines.append(f"  {this_id} --> {child_id}")
                 walk(child)
 
     walk(tree.root)

mycorrhizal/spores/__init__.py

@@ -82,10 +82,14 @@ from .core import (
     configure,
     get_config,
     get_object_cache,
+    flush_object_cache,
+    get_cache_metrics,
     get_spore_sync,
     get_spore_async,
     spore,
     SporesConfig,
+    EvictionPolicy,
+    CacheMetrics,
     EventLogger,
     AsyncEventLogger,
     SyncEventLogger,
@@ -132,6 +136,8 @@ __all__ = [
     'configure',
     'get_config',
     'get_object_cache',
+    'flush_object_cache',
+    'get_cache_metrics',
     'get_spore_sync',
     'get_spore_async',
     'EventLogger',
@@ -139,6 +145,8 @@ __all__ = [
     'SyncEventLogger',
     'spore',  # For DSL adapters and @spore.object() decorator
     'SporesConfig',
+    'EvictionPolicy',
+    'CacheMetrics',
 
     # Models
     'Event',

mycorrhizal/spores/cache.py

@@ -8,11 +8,14 @@ LRU cache for tracking seen objects and logging them on eviction.
 from __future__ import annotations
 
 from collections import OrderedDict
-from typing import Dict, Callable, Optional, TypeVar, Generic
+from typing import Dict, Callable, Optional, TypeVar, Generic, TYPE_CHECKING
 from dataclasses import dataclass
 
 from .models import Object
 
+if TYPE_CHECKING:
+    from .core import CacheMetrics
+
 
 # Generic types for cache
 K = TypeVar('K')  # Key type (object ID)
@@ -28,61 +31,90 @@ class CacheEntry:
         object: The OCEL Object
         sight_count: How many times we've seen this object
         first_sight_time: When we first saw the object
+        attributes_hash: Hash of object attributes for change detection
     """
     object: Object
     sight_count: int = 1
     first_sight_time: Optional[float] = None
+    attributes_hash: Optional[int] = None
+
+
+def _compute_attributes_hash(obj: Object) -> Optional[int]:
+    """
+    Compute hash of object attributes for change detection.
+
+    Args:
+        obj: The OCEL Object
+
+    Returns:
+        Hash of attributes, or None if object has no attributes
+    """
+    if not obj.attributes:
+        return None
+    # Hash frozenset of (attr_name, attr_value) tuples
+    # ObjectAttributeValue.value holds the actual Python value
+    attrs = {k: v.value for k, v in obj.attributes.items()}
+    return hash(frozenset(attrs.items()))
 
 
 class ObjectLRUCache(Generic[K, V]):
     """
-    LRU cache with eviction callback for object tracking.
+    LRU cache with unified callback for object logging.
 
-    When an object is first seen, it should be logged via on_first_sight.
-    When an object is evicted from the cache, it's logged via on_evict.
+    The cache fires the `needs_logged` callback when an object needs to be logged:
+    - On first sight (new object added to cache)
+    - On eviction (object removed from cache to make room)
+    - When attributes change (detected via hash comparison)
+    - Every N touches (configurable via `touch_resend_n`)
 
     This ensures OCEL consumers see object evolution:
     - First sight: Initial object state
+    - Attribute changes: Updated state
     - Eviction: Final state before being removed from cache
+    - Periodic resend: Long-lived objects are re-logged periodically
 
     Example:
         ```python
-        def on_evict(object_id: str, obj: Object):
+        def needs_logged(object_id: str, obj: Object):
             # Send object to transport
             transport.send(LogRecord(object=obj))
 
-        cache = ObjectLRUCache(maxsize=128, on_evict=on_evict)
+        cache = ObjectLRUCache(maxsize=128, needs_logged=needs_logged, touch_resend_n=100)
 
         # Check if object exists, add if not
         if not cache.contains_or_add(object_id, object):
-            # Object not in cache, already logged by on_first_sight
+            # Object not in cache, already logged by needs_logged
             pass
         ```
 
     Args:
         maxsize: Maximum number of objects to cache
-        on_evict: Callback when object is evicted (object_id, object) -> None
-        on_first_sight: Optional callback when object is first seen (object_id, object) -> None
+        needs_logged: Callback when object needs logging (object_id, object) -> None
+        touch_resend_n: Resend object every N touches (0 to disable periodic resend)
     """
 
     def __init__(
         self,
         maxsize: int = 128,
-        on_evict: Optional[Callable[[K, Object], None]] = None,
-        on_first_sight: Optional[Callable[[K, Object], None]] = None
+        needs_logged: Optional[Callable[[K, Object], None]] = None,
+        touch_resend_n: int = 100,
+        metrics: Optional["CacheMetrics"] = None
     ):
         self.maxsize = maxsize
-        self.on_evict = on_evict
-        self.on_first_sight = on_first_sight
+        self.needs_logged = needs_logged
+        self.touch_resend_n = touch_resend_n
+        self.metrics = metrics
         self._cache: OrderedDict[K, CacheEntry] = OrderedDict()
 
     def _evict_if_needed(self) -> None:
         """Evict oldest entry if cache is full."""
-        if len(self._cache) >= self.maxsize:
+        while len(self._cache) >= self.maxsize:
             # FIFO from OrderedDict (oldest first)
             object_id, entry = self._cache.popitem(last=False)
-            if self.on_evict:
-                self.on_evict(object_id, entry.object)
+            if self.metrics is not None:
+                self.metrics.evictions += 1
+            if self.needs_logged:
+                self.needs_logged(object_id, entry.object)
 
     def get(self, key: K) -> Optional[Object]:
         """
@@ -119,8 +151,13 @@ class ObjectLRUCache(Generic[K, V]):
         Check if key exists, add if not.
 
         This is the primary method for object tracking:
-        - If key exists: mark as recently used, return True
-        - If key doesn't exist: add object, potentially evict, call on_first_sight, return False
+        - If key exists: check for attribute changes, periodic resend, mark as recently used
+        - If key doesn't exist: add object, potentially evict, log first sight
+
+        The `needs_logged` callback is fired when:
+        - First sight: new object added to cache
+        - Attribute change: object attributes changed (hash comparison)
+        - Every N touches: periodic resend for long-lived objects
 
         Args:
             key: The object ID
@@ -130,27 +167,51 @@ class ObjectLRUCache(Generic[K, V]):
             True if object was already in cache, False if it was just added
         """
         if key in self._cache:
-            # Already seen, mark as recently used
-            self._cache.move_to_end(key)
+            # Object exists - check if we need to log
             entry = self._cache[key]
             entry.sight_count += 1
+
+            # Compute current attribute hash
+            current_hash = _compute_attributes_hash(obj)
+
+            # Check if attributes changed
+            attrs_changed = (entry.attributes_hash is not None and
+                            current_hash != entry.attributes_hash)
+
+            # Update if attributes changed
+            if attrs_changed:
+                entry.object = obj
+                entry.attributes_hash = current_hash
+
+            # Fire callback if ANY condition met
+            should_log = any([
+                attrs_changed,
+                self.touch_resend_n > 0 and entry.sight_count % self.touch_resend_n == 0,
+            ])
+            if should_log and self.needs_logged:
+                self.needs_logged(key, entry.object)
+
+            self._cache.move_to_end(key)
             return True
         else:
-            # First sight
+            # First sight - store hash, fire callback
             self._evict_if_needed()
-
-            entry = CacheEntry(object=obj)
+            if self.metrics is not None:
+                self.metrics.first_sights += 1
+            attr_hash = _compute_attributes_hash(obj)
+            entry = CacheEntry(object=obj, attributes_hash=attr_hash)
             self._cache[key] = entry
-
-            if self.on_first_sight:
-                self.on_first_sight(key, obj)
-
+            if self.needs_logged:
+                self.needs_logged(key, obj)
             return False
 
     def add(self, key: K, obj: Object) -> None:
         """
         Add an object to the cache (or update if exists).
 
+        Note: This method fires needs_logged for new objects, but not for updates.
+        For attribute change detection and periodic resend, use contains_or_add().
+
         Args:
             key: The object ID
             obj: The OCEL Object
@@ -165,11 +226,12 @@ class ObjectLRUCache(Generic[K, V]):
             # New entry
             self._evict_if_needed()
 
-            entry = CacheEntry(object=obj)
+            attr_hash = _compute_attributes_hash(obj)
+            entry = CacheEntry(object=obj, attributes_hash=attr_hash)
             self._cache[key] = entry
 
-            if self.on_first_sight:
-                self.on_first_sight(key, obj)
+            if self.needs_logged:
+                self.needs_logged(key, obj)
 
     def remove(self, key: K) -> Optional[Object]:
         """

mycorrhizal/spores/core.py

@@ -13,11 +13,12 @@ import functools
 import logging
 import threading
 from datetime import datetime
+from enum import Enum
 from typing import (
     Any, Callable, Optional, Union, Dict, List,
     ParamSpec, TypeVar, overload, get_origin, get_args, Annotated
 )
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from abc import ABC, abstractmethod
 
 from .models import (
@@ -44,6 +45,28 @@ R = TypeVar('R')
 # Global Configuration
 # ============================================================================
 
+class EvictionPolicy(str, Enum):
+    """
+    Cache eviction policy for object logging.
+
+    Attributes:
+        EVICT_AND_LOG: Evict from cache when full, log immediately via sync/async path
+        EVICT_AND_BUFFER: Evict from cache, buffer for later logging (future)
+        NO_EVICT: Keep in cache until explicit flush (future)
+    """
+    EVICT_AND_LOG = "evict_and_log"
+    EVICT_AND_BUFFER = "evict_and_buffer"
+    NO_EVICT = "no_evict"
+
+
+@dataclass
+class CacheMetrics:
+    """Track cache eviction statistics."""
+    evictions: int = 0
+    eviction_failures: int = 0
+    first_sights: int = 0
+
+
 @dataclass
 class SporesConfig:
     """
@@ -54,11 +77,15 @@ class SporesConfig:
         object_cache_size: Maximum objects in LRU cache
         encoder: Encoder instance to use
         transport: Transport instance to use (required for logging to work)
+        eviction_policy: Policy for handling cache eviction
+        touch_resend_n: Resend object every N touches (0 to disable periodic resend)
     """
     enabled: bool = True
     object_cache_size: int = 128
     encoder: Optional[Encoder] = None
     transport: Optional[Transport] = None
+    eviction_policy: EvictionPolicy = EvictionPolicy.EVICT_AND_LOG
+    touch_resend_n: int = 100
 
     def __post_init__(self):
         """Set default encoder if not provided."""
@@ -69,24 +96,34 @@ class SporesConfig:
 # Global state
 _config: Optional[SporesConfig] = None
 _object_cache: Optional[ObjectLRUCache[str, Object]] = None
+_config_lock = threading.RLock()  # Reentrant lock for global state initialization
+_config_initialized = False  # Track whether configure() has been called
+_cache_metrics = CacheMetrics()  # Track cache eviction statistics
 
 
 def configure(
     enabled: bool = True,
     object_cache_size: int = 128,
     encoder: Optional[Encoder] = None,
-    transport: Optional[Transport] = None
+    transport: Optional[Transport] = None,
+    eviction_policy: Union[EvictionPolicy, str] = EvictionPolicy.EVICT_AND_LOG,
+    touch_resend_n: int = 100
 ) -> None:
     """
-    Configure the Spores logging system.
+    Configure the Spores logging system (thread-safe).
 
     This should be called once at application startup.
+    If called multiple times, the last call wins.
+
+    Thread-safe: Can be called from multiple threads concurrently.
 
     Args:
         enabled: Whether spores logging is enabled (default: True)
         object_cache_size: Maximum objects in LRU cache (default: 128)
         encoder: Encoder instance (defaults to JSONEncoder)
         transport: Transport instance (required for logging to work)
+        eviction_policy: Policy for cache eviction (default: evict_and_log)
+        touch_resend_n: Resend object every N touches (default: 100, 0 to disable)
 
     Example:
         ```python
@@ -94,72 +131,183 @@ def configure(
 
         spore.configure(
             transport=FileTransport("logs/ocel.jsonl"),
-            object_cache_size=256
+            object_cache_size=256,
+            touch_resend_n=100,
         )
         ```
     """
-    global _config, _object_cache
-
-    _config = SporesConfig(
-        enabled=enabled,
-        object_cache_size=object_cache_size,
-        encoder=encoder,
-        transport=transport
-    )
-
-    # Create object cache with eviction callback
-    def on_evict(object_id: str, obj: Object):
-        """Send object when evicted from cache."""
-        try:
-            loop = asyncio.get_event_loop()
-            if loop.is_running():
-                asyncio.create_task(_send_log_record(LogRecord(object=obj)))
-            else:
-                # No running loop, schedule the coroutine
-                asyncio.ensure_future(_send_log_record(LogRecord(object=obj)))
-        except RuntimeError:
-            # No event loop at all, ignore for now
-            pass
-
-    def on_first_sight(object_id: str, obj: Object):
-        """Send object when first seen."""
-        try:
-            loop = asyncio.get_event_loop()
-            if loop.is_running():
-                asyncio.create_task(_send_log_record(LogRecord(object=obj)))
-            else:
-                # No running loop, schedule the coroutine
-                asyncio.ensure_future(_send_log_record(LogRecord(object=obj)))
-        except RuntimeError:
-            # No event loop at all, ignore for now
-            pass
+    global _config, _object_cache, _config_initialized, _cache_metrics
+
+    # Convert string to EvictionPolicy if needed
+    if isinstance(eviction_policy, str):
+        eviction_policy = EvictionPolicy(eviction_policy)
+
+    with _config_lock:
+        # Warn if already configured (but allow reconfiguration)
+        if _config_initialized:
+            logger.warning(
+                "Spores already configured. Reconfiguring may cause issues. "
+                "Ensure configure() is called only once at startup."
+            )
+
+        # Create new config (atomic under lock)
+        _config = SporesConfig(
+            enabled=enabled,
+            object_cache_size=object_cache_size,
+            encoder=encoder,
+            transport=transport,
+            eviction_policy=eviction_policy,
+            touch_resend_n=touch_resend_n
+        )
 
-    _object_cache = ObjectLRUCache(
-        maxsize=object_cache_size,
-        on_evict=on_evict,
-        on_first_sight=on_first_sight
-    )
+        # Reset metrics on reconfiguration
+        _cache_metrics = CacheMetrics()
 
-    logger.info(f"Spores configured: enabled={enabled}, cache_size={object_cache_size}")
+        # Create object cache with unified callback
+        def needs_logged(object_id: str, obj: Object):
+            """Log object when it needs to be logged (first sight, eviction, change, or Nth touch)."""
+            global _cache_metrics
+
+            try:
+                loop = asyncio.get_event_loop()
+                if loop.is_running():
+                    # Async context: schedule task
+                    asyncio.create_task(_send_log_record(LogRecord(object=obj)))
+                else:
+                    # No running loop, use sync path
+                    _send_log_record_sync(LogRecord(object=obj))
+            except RuntimeError:
+                # No event loop at all, use sync path
+                try:
+                    _send_log_record_sync(LogRecord(object=obj))
+                except Exception as e:
+                    logger.error(f"Failed to log object {object_id}: {e}")
+
+        _object_cache = ObjectLRUCache(
+            maxsize=object_cache_size,
+            needs_logged=needs_logged,
+            touch_resend_n=touch_resend_n,
+            metrics=_cache_metrics
+        )
+
+        _config_initialized = True
+
+    logger.info(f"Spores configured: enabled={enabled}, cache_size={object_cache_size}, eviction_policy={eviction_policy.value}")
 
 
 def get_config() -> SporesConfig:
-    """Get the current spores configuration."""
-    global _config
-    if _config is None:
-        # Use default configuration
-        _config = SporesConfig()
+    """
+    Get the current spores configuration (thread-safe).
+
+    If no configuration exists, creates a default one.
+    Thread-safe: Can be called from multiple threads concurrently.
+    """
+    global _config, _config_initialized
+
+    # Fast path: read without lock (GIL protects single read)
+    if _config is not None:
+        return _config
+
+    # Slow path: needs initialization
+    with _config_lock:
+        # Double-check: another thread may have initialized while we waited
+        if _config is None:
+            # Initialize with defaults
+            _config = SporesConfig()
+            _config_initialized = True
+
     return _config
 
 
 def get_object_cache() -> ObjectLRUCache[str, Object]:
-    """Get the object cache."""
+    """
+    Get the object cache (thread-safe).
+
+    If no cache exists, initializes with default configuration.
+    Thread-safe: Can be called from multiple threads concurrently.
+    """
     global _object_cache
-    if _object_cache is None:
-        configure()  # Initialize with defaults
+
+    # Fast path: read without lock (GIL protects single read)
+    if _object_cache is not None:
+        return _object_cache
+
+    # Slow path: needs initialization
+    with _config_lock:
+        # Double-check: another thread may have initialized while we waited
+        if _object_cache is None:
+            # Trigger full initialization
+            configure()  # Will acquire lock again, but that's OK (reentrant in same thread)
+
     return _object_cache
 
 
+def flush_object_cache() -> None:
+    """
+    Flush all objects from the cache to the log.
+
+    This forces all cached objects to be written, even if they haven't
+    been evicted yet. Use this before application shutdown to ensure
+    all objects are logged.
+
+    Thread-safe: Can be called from multiple threads concurrently.
+
+    Example:
+        ```python
+        from mycorrhizal.spores import configure, flush_object_cache
+        from mycorrhizal.spores.transport import FileTransport
+
+        configure(transport=FileTransport("logs/ocel.jsonl"))
+
+        # ... application logic ...
+
+        flush_object_cache()  # Ensure all objects logged
+        ```
+    """
+    cache = get_object_cache()
+    config = get_config()
+
+    if not config.enabled:
+        return
+
+    # Get all objects currently in cache
+    all_objects = list(cache._cache.values())
+
+    # Log each object
+    flushed_count = 0
+    for entry in all_objects:
+        try:
+            # Use sync path to ensure it's written
+            _send_log_record_sync(LogRecord(object=entry.object))
+            flushed_count += 1
+        except Exception as e:
+            logger.error(f"Failed to flush object {entry.object.id}: {e}")
+
+    logger.info(f"Flushed {flushed_count} objects from cache")
+
+
+def get_cache_metrics() -> CacheMetrics:
+    """
+    Get cache eviction metrics.
+
+    Returns statistics about cache evictions and failures.
+
+    Returns:
+        CacheMetrics with eviction statistics
+
+    Example:
+        ```python
+        from mycorrhizal.spores import get_cache_metrics
+
+        metrics = get_cache_metrics()
+        print(f"Evictions: {metrics.evictions}")
+        print(f"Failures: {metrics.eviction_failures}")
+        ```
+    """
+    global _cache_metrics
+    return _cache_metrics
+
+
 async def _send_log_record(record: LogRecord) -> None:
     """
     Send a log record via the configured transport (async).
@@ -1236,6 +1384,13 @@ __all__ = [
     'configure',
     'get_config',
     'get_object_cache',
+    'flush_object_cache',
+    'get_cache_metrics',
+
+    # Types
+    'SporesConfig',
+    'EvictionPolicy',
+    'CacheMetrics',
 
     # Spore getters (explicit)
     'get_spore_sync',

mycorrhizal/spores/encoder/json.py

@@ -10,7 +10,7 @@ from __future__ import annotations
 
 import json
 from datetime import datetime
-from typing import Any, Dict
+from typing import Any, Dict, TYPE_CHECKING
 
 from .base import Encoder
 from ..models import LogRecord, Event, Object, Relationship, EventAttributeValue, ObjectAttributeValue
@@ -20,7 +20,7 @@ class JSONEncoder(Encoder):
     """
     JSON encoder for OCEL LogRecords.
 
-    Produces OCEL-compatible JSON.
+    Produces OCEL-compatible JSON with Unix float64 timestamps.
 
     Example output:
         {
@@ -28,9 +28,9 @@ class JSONEncoder(Encoder):
             "id": "evt-123",
             "type": "process_item",
             "activity": null,
-            "time": "2025-01-11T12:34:56.789000000Z",
+            "time": 1705689296.123456,
             "attributes": [
-              {"name": "priority", "value": "high", "type": "string", "time": null}
+              {"name": "priority", "value": "high", "type": "string"}
             ],
             "relationships": [
               {"objectId": "obj-456", "qualifier": "input"}
@@ -46,13 +46,21 @@ class JSONEncoder(Encoder):
             "id": "obj-456",
             "type": "WorkItem",
             "attributes": [
-              {"name": "status", "value": "pending", "type": "string", "time": null}
+              {"name": "status", "value": "pending", "type": "string", "time": 1705689296.123456}
             ],
             "relationships": []
           }
         }
     """
 
+    def __init__(self):
+        """
+        Initialize JSONEncoder.
+
+        Timestamps are always encoded as Unix float64 timestamps.
+        """
+        pass
+
     def encode(self, record: LogRecord) -> bytes:
         """
         Encode a LogRecord to JSON bytes.
@@ -136,33 +144,14 @@ class JSONEncoder(Encoder):
             "qualifier": qualifier
         }
 
-    def _format_datetime(self, dt: datetime) -> str:
+    def _format_datetime(self, dt: datetime) -> float:
         """
-        Format datetime to RFC3339Nano.
+        Format datetime as Unix float64 timestamp.
 
         Args:
             dt: The datetime to format
 
         Returns:
-            ISO format string with nanosecond precision
+            Unix float64 timestamp (seconds since epoch)
         """
-        # Python's isoformat() produces RFC3339-compatible output
-        # For nanosecond precision, we need to ensure it has 9 digits
-        iso = dt.isoformat()
-
-        # Add microseconds if not present (Python 3.11+ has timespec='nanoseconds')
-        if '.' not in iso:
-            iso += '.000000000'
-
-        # Ensure we have 9 digits of fractional seconds
-        if '.' in iso:
-            main, frac = iso.split('.')
-            # Pad or truncate to 9 digits
-            frac = (frac + '0' * 9)[:9]
-            iso = f"{main}.{frac}"
-
-        # Ensure timezone is Z (UTC) or offset
-        if iso.endswith('+00:00'):
-            iso = iso[:-6] + 'Z'
-
-        return iso
+        return dt.timestamp()

{mycorrhizal-0.2.1.dist-info → mycorrhizal-0.2.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mycorrhizal
-Version: 0.2.1
+Version: 0.2.2
 Summary: Utilities and DSLs for modelling and implementing safe, performant, structured systems
 Author-email: Jeff Ciesielski <jeffciesielski@gmail.com>
 Requires-Python: >=3.10

{mycorrhizal-0.2.1.dist-info → mycorrhizal-0.2.2.dist-info}/RECORD

@@ -1,5 +1,5 @@
 mycorrhizal/__init__.py,sha256=ajz1GSNU9xYVrFEDSz6Xwg7amWQ_yvW75tQa1ZvRIWc,3
-mycorrhizal/_version.py,sha256=Ui79YHRxRfg2Yk8f7S1RGQcYuTAo3-YJSMGCUb8i3gI,18
+mycorrhizal/_version.py,sha256=YRbFwheRvZAINxDCCNbF89MTOO3B_-zLEY8eP9-nRbI,18
 mycorrhizal/common/__init__.py,sha256=OwPFyCFW6H6E6EkQIjQfl-h67qfo36geu0ndfXqYEn4,1705
 mycorrhizal/common/cache.py,sha256=D-L9aVG3eXemXKVmhiRONFB0KWobzRHACknMkHgZ3ug,3477
 mycorrhizal/common/compilation.py,sha256=f98aE0Dq6ztgm6SjxYbWKGjhOZ2i9SWLT7bc2Yvvwos,8922
@@ -13,7 +13,7 @@ mycorrhizal/hypha/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU
 mycorrhizal/hypha/util.py,sha256=tpvjWXTdGhtVUycQElcQg4usOy-tSEqwE9KEni8R30s,906
 mycorrhizal/hypha/core/__init__.py,sha256=o6BE3fhRKjVfyIWwtNTO64kPt0udlZGyXr-ZuN_ZzF8,2518
 mycorrhizal/hypha/core/builder.py,sha256=aZ6xvktGVteDBVFf2Uva7-7vsBbpAP3maBfiL6xiJl0,17205
-mycorrhizal/hypha/core/runtime.py,sha256=BTguGT2ku2U70r-5IYVPP3ubrG1QC5_opQ0hbF5162k,40830
+mycorrhizal/hypha/core/runtime.py,sha256=hwaI1fq1Hz6tKL8K6TLt5yVQKHKmaaDWk2h2BPl5L_8,41311
 mycorrhizal/hypha/core/specs.py,sha256=uWvW9x7-bSoSENIUJkYMIkJ3KxsgE9mB9PyRLPrOEjk,8429
 mycorrhizal/mycelium/__init__.py,sha256=MFgh6eZVjE1zSwgDqD2GXneZv-7MWtRoky5Qtmydqdw,4231
 mycorrhizal/mycelium/core.py,sha256=ly3GtHKHHwqoODk3tFWMKoUT3VYPsQHBYyDNSKCmGMY,19583
@@ -27,16 +27,16 @@ mycorrhizal/mycelium/tree_builder.py,sha256=WOxCZgAPmGmFb_t0FghCNgAVdVLEqdbtWN5K
 mycorrhizal/mycelium/tree_spec.py,sha256=0RyZBOJROxWrYdqtNeawWv1vB5ZgwzGR-lWFN8b2-Ro,6919
 mycorrhizal/rhizomorph/README.md,sha256=UrCYyaMUtqa9U2ejMyg9om-1QhFm3S6sFS9Cjp_4jUs,9367
 mycorrhizal/rhizomorph/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mycorrhizal/rhizomorph/core.py,sha256=LThaeieSyQWcv7lxvdIfbWfHCG238uacleurw75hmus,67413
+mycorrhizal/rhizomorph/core.py,sha256=KL2qCLh24jfjeWvNuFYhfefqokrlNNouW7n0VkujErY,79711
 mycorrhizal/rhizomorph/util.py,sha256=dUgKAWX5RNtzFK01mGkz10tJyeTMCqyyfnZ8Mi97LkY,1280
 mycorrhizal/septum/TRANSITION_REFERENCE.md,sha256=4mxDeTbeuqIDJCebXlwxT537Tgk2XLpinssam6I6lNw,10987
 mycorrhizal/septum/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mycorrhizal/septum/core.py,sha256=vGGvhP0TDidu5MGJgxiioQXsE3t-G9uvQKJeEud_18o,64043
 mycorrhizal/septum/testing_utils.py,sha256=ONk9hOm7oc8qSgbOcsWaZvlfP_iOUS7uoo3aS7Pfuis,17314
 mycorrhizal/septum/util.py,sha256=J4D0uBzNkVWDBwrOMhG9x5Y4lkjP8pEDkuc2d4UX7eI,9344
-mycorrhizal/spores/__init__.py,sha256=iePLLnGdKVHKrzoy9gQFARcQG0jmDIUavkJwLv9Mx6w,4766
-mycorrhizal/spores/cache.py,sha256=0FuWHKudgyC7vlrlcJ_kmRKr7OAJuC2gxRURReMlqF4,6119
-mycorrhizal/spores/core.py,sha256=fBklI4pQUd78o8qJ6_MXFmDZN612CDqr3dfS0yAmc_U,45109
+mycorrhizal/spores/__init__.py,sha256=xrp94D3x2pf-qlkK8bcWn6cJkMl4WxetzrbZSB1PtL8,4944
+mycorrhizal/spores/cache.py,sha256=gIHYcawH1JLmEF3iBSW66kt0nS1GuKhoVlfO-WDTYVs,8728
+mycorrhizal/spores/core.py,sha256=4JTN5IIJ2yI_6vURzy2lTtGjRlz0x7A52AOSSr5hvMM,50227
 mycorrhizal/spores/extraction.py,sha256=pCc_bm-MUx7SYGM9xI_m4cOL3X5VjGIr3FQ66fkUW5k,15063
 mycorrhizal/spores/models.py,sha256=nwjSSbSvBMuuE0__nDt2loDRJhJWQBu0Y3jRg4p3wfU,9724
 mycorrhizal/spores/dsl/__init__.py,sha256=DDrLqJ4CjtRsepmzsxkdxu_ugYYpAwaxawau-0t4Bm0,1163
@@ -45,10 +45,10 @@ mycorrhizal/spores/dsl/rhizomorph.py,sha256=JXaZmRyiKVOz2I1uf-96u7Zl9h4YlJCaAtaX
 mycorrhizal/spores/dsl/septum.py,sha256=bG6HPTAWAAoSbps-2hs0oGsyTOEq1pPCIsgDvmfUI6Q,14206
 mycorrhizal/spores/encoder/__init__.py,sha256=hpp1W4xwQUG1N1zdrea0coBPtMf-WYSE77Q780TinP8,204
 mycorrhizal/spores/encoder/base.py,sha256=xFKk-f5_W_HNrOgNXyquUwhcrcz28LmeT5Y5enDVrwU,870
-mycorrhizal/spores/encoder/json.py,sha256=OPezVz-5-to-NmZ_QuVGMPSLn_24GbdG6Y3F4_RXx40,5064
+mycorrhizal/spores/encoder/json.py,sha256=Zz5kNGKLOF8qaJ-iiM2m9lQ-G-TU354iKQ0drLVxUG4,4615
 mycorrhizal/spores/transport/__init__.py,sha256=Tw6glCXsPK2pzsLPbb9vKOCvvT9vh-ql-xUaulKBAw0,407
 mycorrhizal/spores/transport/base.py,sha256=OsyWx1J8Ig7Y7idUoI9oS-LkONwQAxAP47jL_5OVRjA,1668
 mycorrhizal/spores/transport/file.py,sha256=xcMPxAGiv5q-GfcNKsF_3a-2-yxlDkhHusZli1Fsqa0,3833
-mycorrhizal-0.2.1.dist-info/METADATA,sha256=_6Q5ls7HRBVzc0ewoP8V1ARbO7W6TMkY6nGvlabOX1Q,11607
-mycorrhizal-0.2.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-mycorrhizal-0.2.1.dist-info/RECORD,,
+mycorrhizal-0.2.2.dist-info/METADATA,sha256=xDKBhCtW4-zjFunGZSJ-rU3vGGG79GoCNnLrctX1kwg,11607
+mycorrhizal-0.2.2.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+mycorrhizal-0.2.2.dist-info/RECORD,,