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

mycorrhizal/{enoki → septum}/testing_utils.py

@@ -1,8 +1,8 @@
 #!/usr/bin/env python3
 """
-Enoki Testing Utilities
+Septum Testing Utilities
 
-Testing infrastructure for the class-method-based Enoki architecture.
+Testing infrastructure for the class-method-based Septum architecture.
 """
 
 import unittest
@@ -13,8 +13,8 @@ import gevent
 from gevent import sleep
 import traceback
 
-# Import the Enoki modules
-from mycorrhizal.enoki import (
+# Import the Septum modules
+from mycorrhizal.septum import (
     State,
     StateMachine,
     StateConfiguration,
@@ -151,8 +151,8 @@ def simulate_state_lifecycle(
     return results
 
 
-class EnokiTestCase(unittest.TestCase):
-    """Base test case class with assertion methods for Enoki FSM testing."""
+class SeptumTestCase(unittest.TestCase):
+    """Base test case class with assertion methods for Septum FSM testing."""
 
     def assertStateTransition(
         self, state_class, expected_transition, context=None, **context_kwargs
@@ -328,7 +328,7 @@ class EnokiTestCase(unittest.TestCase):
         self.assertIsNotNone(timeout_result, "on_timeout should return a transition")
 
 
-class StateMachineTestCase(EnokiTestCase):
+class StateMachineTestCase(SeptumTestCase):
     """Extended test case for testing full StateMachine behavior."""
 
     def assertFSMTransition(

mycorrhizal/{enoki → septum}/util.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 """
-Enoki State Machine Utilities
+Septum State Machine Utilities
 
 Utility functions for FSM operations like Mermaid diagram generation.
 """
@@ -16,6 +16,24 @@ class _TransitionInfo:
     transition_type: str  # "normal", "push", "pop", "again", "retry", etc.
 
 
+def _short_state_name(state_name: str) -> str:
+    """
+    Extract short state name from full qualified name.
+
+    Converts 'examples.septum.network_protocol_fsm.IdleState' to 'IdleState'.
+    Handles edge cases like '<string>.IdleState' gracefully.
+
+    Args:
+        state_name: Full state name with module path
+
+    Returns:
+        Short state name (just the class name)
+    """
+    if "." in state_name:
+        return state_name.rsplit(".", 1)[-1]
+    return state_name
+
+
 def to_mermaid(fsm) -> str:
     """
     Generate Mermaid diagram from a StateMachine instance.
@@ -24,15 +42,15 @@ def to_mermaid(fsm) -> str:
     including special handling for Push/Pop transitions.
 
     Args:
-        fsm: A StateMachine instance (from mycorrhizal.enoki.core)
+        fsm: A StateMachine instance (from mycorrhizal.septum.core)
 
     Returns:
         Mermaid diagram as a string
 
     Example:
         ```python
-        from mycorrhizal.enoki.core import StateMachine
-        from mycorrhizal.enoki.util import to_mermaid
+        from mycorrhizal.septum.core import StateMachine
+        from mycorrhizal.septum.util import to_mermaid
 
         fsm = StateMachine(initial_state=MyState)
         await fsm.initialize()
@@ -43,7 +61,7 @@ def to_mermaid(fsm) -> str:
         ```
     """
     # Import here to avoid circular imports
-    from mycorrhizal.enoki.core import (
+    from mycorrhizal.septum.core import (
         StateSpec,
         StateRef,
         LabeledTransition,
@@ -77,12 +95,12 @@ def to_mermaid(fsm) -> str:
 
     # Add initial state marker
     initial_name = fsm.initial_state.name if isinstance(fsm.initial_state, StateSpec) else str(fsm.initial_state)
-    lines.append(f"    start((start)) --> {nid(initial_name)}")
+    lines.append(f'    start((start)) --> {nid(initial_name)}')
 
     # Add error state if exists
     if fsm.error_state:
         error_name = fsm.error_state.name if isinstance(fsm.error_state, StateSpec) else str(fsm.error_state)
-        lines.append(f"    {nid(error_name)}(((ERROR)))")
+        lines.append(f'    {nid(error_name)}{{"ERROR"}}')
 
     # Collect all transitions
     transitions: Dict[str, List[_TransitionInfo]] = {}
@@ -135,8 +153,9 @@ def to_mermaid(fsm) -> str:
                             # Push transitions - show all states being pushed
                             for push_state in p.push_states:
                                 push_name = push_state.name if isinstance(push_state, StateSpec) else str(push_state)
+                                # Use -> instead of unicode arrow for better compatibility
                                 transitions[state_name].append(
-                                    _TransitionInfo(f"{label.name} → push", push_name, "push")
+                                    _TransitionInfo(f"{label.name}->push", push_name, "push")
                                 )
                         case StateSpec() as target_state:
                             transitions[state_name].append(
@@ -182,39 +201,43 @@ def to_mermaid(fsm) -> str:
             continue
 
         state_id = nid(state_name)
+        short_name = _short_state_name(state_name)
 
         # Determine node shape based on state properties
+        # All nodes use quotes to handle special characters
         if state.config.terminal:
-            shape = f'[{state_name} (**terminal**)]'
+            # Terminal state: use double parentheses and note terminal status
+            lines.append(f'    {state_id}[["{short_name}<br/>terminal"]]')
         elif state_name == initial_name:
-            shape = f'[{state_name}]'
+            # Initial state: normal shape
+            lines.append(f'    {state_id}["{short_name}"]')
         elif fsm.error_state and state_name == (fsm.error_state.name if isinstance(fsm.error_state, StateSpec) else str(fsm.error_state)):
-            shape = f'[{state_name}]'
+            # Error state: use rhombus shape
+            lines.append(f'    {state_id}{{"{short_name}"}}')
         else:
-            shape = f'[{state_name}]'
-
-        lines.append(f"    {state_id}{shape}")
+            # Normal state
+            lines.append(f'    {state_id}["{short_name}"]')
 
         # Add transitions
         for trans in transitions.get(state_name, []):
             if trans.transition_type in ("again", "retry", "repeat", "restart", "unhandled"):
-                # Self-loop
-                label = f'"{trans.transition_type}"' if trans.transition_type else ""
-                lines.append(f"    {state_id} -->|{label}| {state_id}")
+                # Self-loop with transition type
+                lines.append(f'    {state_id} -->|"{trans.transition_type}"| {state_id}')
             elif trans.transition_type == "pop":
                 # Pop goes to a special pop node
-                lines.append(f"    {state_id} -->|\"{trans.label or 'pop'}\"| pop((pop))")
+                label = trans.label if trans.label else "pop"
+                lines.append(f'    {state_id} -->|"{label}"| pop((pop))')
             elif trans.transition_type == "push":
                 # Push transition
                 target_id = nid(trans.target)
-                lines.append(f"    {state_id} -->|\"{trans.label}\"| {target_id}")
+                lines.append(f'    {state_id} -->|"{trans.label}"| {target_id}')
             else:
                 # Normal transition
                 target_id = nid(trans.target)
-                lines.append(f"    {state_id} -->|\"{trans.label}\"| {target_id}")
+                lines.append(f'    {state_id} -->|"{trans.label}"| {target_id}')
 
     # Add pop node if any pop transitions exist
     if any(t.transition_type == "pop" for transs in transitions.values() for t in transs):
-        lines.append("    pop((pop))")
+        lines.append('    pop((pop))')
 
     return "\n".join(lines)

mycorrhizal/spores/__init__.py

@@ -61,7 +61,7 @@ Usage (DSL Adapters):
 DSL Adapters:
     HyphaAdapter - Log Petri net transitions with token relationships
     RhizomorphAdapter - Log behavior tree node execution with status
-    EnokiAdapter - Log state machine execution and lifecycle events
+    SeptumAdapter - Log state machine execution and lifecycle events
 
 Annotation Types:
     EventAttr - Mark blackboard fields for automatic event attribute extraction (DSL adapters)
@@ -117,7 +117,7 @@ from .transport import SyncTransport, AsyncTransport, Transport, SyncFileTranspo
 from .dsl import (
     HyphaAdapter,
     RhizomorphAdapter,
-    EnokiAdapter,
+    SeptumAdapter,
 )
 
 
@@ -173,5 +173,5 @@ __all__ = [
     # DSL Adapters
     'HyphaAdapter',
     'RhizomorphAdapter',
-    'EnokiAdapter',
+    'SeptumAdapter',
 ]

mycorrhizal/spores/core.py

@@ -266,11 +266,7 @@ class AsyncEventLogger(EventLogger):
 
         attr_values = {}
         for key, value in kwargs.items():
-            attr_values[key] = EventAttributeValue(
-                name=key,
-                value=str(value),
-                time=timestamp
-            )
+            attr_values[key] = attribute_value_from_python(value)
 
         event = Event(
             id=generate_event_id(),
@@ -293,11 +289,7 @@ class AsyncEventLogger(EventLogger):
 
         attr_values = {}
         for key, value in kwargs.items():
-            attr_values[key] = ObjectAttributeValue(
-                name=key,
-                value=str(value),
-                time=timestamp
-            )
+            attr_values[key] = object_attribute_from_python(value, time=timestamp)
 
         obj = Object(
             id=obj_id,
@@ -346,7 +338,7 @@ class AsyncEventLogger(EventLogger):
                             source, obj_type, attrs = rel_spec
 
                         # Resolve object from source
-                        obj = self._resolve_source(source, context)
+                        obj = self._resolve_source(source, context, obj_type)
                         if obj is None:
                             continue
 
@@ -392,14 +384,84 @@ class AsyncEventLogger(EventLogger):
 
         return context
 
-    def _resolve_source(self, source: str, context: Dict[str, Any]) -> Any:
-        """Resolve source for async version."""
+    def _resolve_source(self, source: str, context: Dict[str, Any], obj_type: str | None = None) -> Any:
+        """Resolve source for async version.
+
+        If source is "bb" (blackboard) and obj_type is provided, extract the field
+        of that type from the blackboard instead of returning the entire blackboard.
+        """
         if source == "return" or source == "ret":
             return context.get("return")
         elif source == "self":
             return context.get("self")
         else:
-            return context.get(source)
+            obj = context.get(source)
+
+            # If source is blackboard and we need a specific type, extract that field
+            if obj_type and source == "bb" and hasattr(obj, '__annotations__'):
+                return self._find_object_by_type(obj, obj_type)
+
+            return obj
+
+    def _find_object_by_type(self, blackboard: Any, obj_type: str) -> Any:
+        """Find a field in the blackboard that matches the requested object type.
+
+        Scans the blackboard's fields and returns the first field whose type
+        annotation matches obj_type.
+        """
+        # Get the class to check annotations
+        obj_class = blackboard if isinstance(blackboard, type) else type(blackboard)
+
+        if not hasattr(obj_class, '__annotations__'):
+            return blackboard
+
+        # Check each field's type annotation
+        for field_name, field_type in obj_class.__annotations__.items():
+            # Handle Annotated types
+            if get_origin(field_type) is Annotated:
+                args = get_args(field_type)
+                if args:
+                    actual_type = args[0]
+                    # Check if type name matches (handle both str and type)
+                    type_name = actual_type if isinstance(actual_type, str) else actual_type.__name__
+                    if type_name == obj_type:
+                        field_value = getattr(blackboard, field_name, None)
+                        # Return the actual value, not None
+                        if field_value is not None:
+                            return field_value
+            # Handle Union types (e.g., Sample | None)
+            elif get_origin(field_type) is Union:
+                args = get_args(field_type)
+                for arg in args:
+                    # Skip None
+                    if arg is type(None):
+                        continue
+                    # Check if this arg matches our target type
+                    if get_origin(arg) is Annotated:
+                        annotated_args = get_args(arg)
+                        if annotated_args:
+                            actual_type = annotated_args[0]
+                            type_name = actual_type if isinstance(actual_type, str) else actual_type.__name__
+                            if type_name == obj_type:
+                                field_value = getattr(blackboard, field_name, None)
+                                if field_value is not None:
+                                    return field_value
+                    else:
+                        type_name = arg if isinstance(arg, str) else arg.__name__
+                        if type_name == obj_type:
+                            field_value = getattr(blackboard, field_name, None)
+                            if field_value is not None:
+                                return field_value
+            else:
+                # Check if type name matches
+                type_name = field_type if isinstance(field_type, str) else field_type.__name__
+                if type_name == obj_type:
+                    field_value = getattr(blackboard, field_name, None)
+                    if field_value is not None:
+                        return field_value
+
+        # Fallback: return blackboard if no matching field found
+        return blackboard
 
     def _get_object_id(self, obj: Any) -> str | None:
         """Extract object ID for async version."""
@@ -518,11 +580,7 @@ class SyncEventLogger(EventLogger):
 
             attr_values = {}
             for key, value in kwargs.items():
-                attr_values[key] = EventAttributeValue(
-                    name=key,
-                    value=str(value),
-                    time=timestamp
-                )
+                attr_values[key] = attribute_value_from_python(value)
 
             event = Event(
                 id=generate_event_id(),
@@ -550,11 +608,7 @@ class SyncEventLogger(EventLogger):
 
             attr_values = {}
             for key, value in kwargs.items():
-                attr_values[key] = ObjectAttributeValue(
-                    name=key,
-                    value=str(value),
-                    time=timestamp
-                )
+                attr_values[key] = object_attribute_from_python(value, time=timestamp)
 
             obj = Object(
                 id=obj_id,
@@ -624,7 +678,7 @@ class SyncEventLogger(EventLogger):
                             source, obj_type, attrs = rel_spec
 
                         # Resolve object from source
-                        obj = self._resolve_source(source, context)
+                        obj = self._resolve_source(source, context, obj_type)
                         if obj is None:
                             continue
 
@@ -678,7 +732,7 @@ class SyncEventLogger(EventLogger):
 
         return context
 
-    def _resolve_source(self, source: str, context: Dict[str, Any]) -> Any:
+    def _resolve_source(self, source: str, context: Dict[str, Any], obj_type: str | None = None) -> Any:
         """
         Resolve an object from a source expression.
 
@@ -686,13 +740,80 @@ class SyncEventLogger(EventLogger):
             - "return" or "ret": Return value
             - "self": For methods
             - Any other string: Parameter name from context
+            - If source is "bb" (blackboard) and obj_type is provided, extract the field of that type
         """
         if source == "return" or source == "ret":
             return context.get("return")
         elif source == "self":
             return context.get("self")
         else:
-            return context.get(source)
+            obj = context.get(source)
+
+            # If source is blackboard and we need a specific type, extract that field
+            if obj_type and source == "bb" and hasattr(obj, '__annotations__'):
+                return self._find_object_by_type(obj, obj_type)
+
+            return obj
+
+    def _find_object_by_type(self, blackboard: Any, obj_type: str) -> Any:
+        """Find a field in the blackboard that matches the requested object type.
+
+        Scans the blackboard's fields and returns the first field whose type
+        annotation matches obj_type.
+        """
+        # Get the class to check annotations
+        obj_class = blackboard if isinstance(blackboard, type) else type(blackboard)
+
+        if not hasattr(obj_class, '__annotations__'):
+            return blackboard
+
+        # Check each field's type annotation
+        for field_name, field_type in obj_class.__annotations__.items():
+            # Handle Annotated types
+            if get_origin(field_type) is Annotated:
+                args = get_args(field_type)
+                if args:
+                    actual_type = args[0]
+                    # Check if type name matches (handle both str and type)
+                    type_name = actual_type if isinstance(actual_type, str) else actual_type.__name__
+                    if type_name == obj_type:
+                        field_value = getattr(blackboard, field_name, None)
+                        # Return the actual value, not None
+                        if field_value is not None:
+                            return field_value
+            # Handle Union types (e.g., Sample | None)
+            elif get_origin(field_type) is Union:
+                args = get_args(field_type)
+                for arg in args:
+                    # Skip None
+                    if arg is type(None):
+                        continue
+                    # Check if this arg matches our target type
+                    if get_origin(arg) is Annotated:
+                        annotated_args = get_args(arg)
+                        if annotated_args:
+                            actual_type = annotated_args[0]
+                            type_name = actual_type if isinstance(actual_type, str) else actual_type.__name__
+                            if type_name == obj_type:
+                                field_value = getattr(blackboard, field_name, None)
+                                if field_value is not None:
+                                    return field_value
+                    else:
+                        type_name = arg if isinstance(arg, str) else arg.__name__
+                        if type_name == obj_type:
+                            field_value = getattr(blackboard, field_name, None)
+                            if field_value is not None:
+                                return field_value
+            else:
+                # Check if type name matches
+                type_name = field_type if isinstance(field_type, str) else field_type.__name__
+                if type_name == obj_type:
+                    field_value = getattr(blackboard, field_name, None)
+                    if field_value is not None:
+                        return field_value
+
+        # Fallback: return blackboard if no matching field found
+        return blackboard
 
     def _get_object_id(self, obj: Any) -> str | None:
         """
@@ -1031,7 +1152,7 @@ class SporeDecorator:
                 type=event_type,
                 time=timestamp,
                 attributes={
-                    k: EventAttributeValue(name=k, value=str(v), time=timestamp)
+                    k: attribute_value_from_python(v)
                     for k, v in event_attrs.items()
                 },
                 relationships={

mycorrhizal/spores/dsl/__init__.py

@@ -5,11 +5,11 @@ Spores DSL Adapters
 DSL-specific adapters for integrating spores logging with:
 - Hypha (Petri nets)
 - Rhizomorph (Behavior trees)
-- Enoki (State machines)
+- Septum (State machines)
 
 Usage:
     ```python
-    from mycorrhizal.spores.dsl import HyphaAdapter, RhizomorphAdapter, EnokiAdapter
+    from mycorrhizal.spores.dsl import HyphaAdapter, RhizomorphAdapter, SeptumAdapter
 
     # For Hypha (Petri nets)
     hypha_adapter = HyphaAdapter()
@@ -27,11 +27,11 @@ Usage:
     async def check(bb: Blackboard) -> Status:
         return Status.SUCCESS
 
-    # For Enoki (State machines)
-    enoki_adapter = EnokiAdapter()
+    # For Septum (State machines)
+    septum_adapter = SeptumAdapter()
 
-    @enoki.on_state
-    @enoki_adapter.log_state(event_type="state_execute")
+    @septum.on_state
+    @septum_adapter.log_state(event_type="state_execute")
     async def on_state(ctx: SharedContext):
         return Events.DONE
     ```
@@ -39,10 +39,10 @@ Usage:
 
 from .hypha import HyphaAdapter
 from .rhizomorph import RhizomorphAdapter
-from .enoki import EnokiAdapter
+from .septum import SeptumAdapter
 
 __all__ = [
     'HyphaAdapter',
     'RhizomorphAdapter',
-    'EnokiAdapter',
+    'SeptumAdapter',
 ]

mycorrhizal/spores/dsl/hypha.py

@@ -237,18 +237,10 @@ async def _log_transition_event(
         event_attrs = {}
 
         # Add token count
-        event_attrs["token_count"] = EventAttributeValue(
-            name="token_count",
-            value=str(len(consumed)),
-            time=timestamp
-        )
+        event_attrs["token_count"] = attribute_value_from_python(len(consumed))
 
         # Add transition name
-        event_attrs["transition_name"] = EventAttributeValue(
-            name="transition_name",
-            value=func.__name__,
-            time=timestamp
-        )
+        event_attrs["transition_name"] = attribute_value_from_python(func.__name__)
 
         # Extract from blackboard
         bb_attrs = extract_attributes_from_blackboard(bb, timestamp)
@@ -358,11 +350,7 @@ async def _log_place_event(
 
         # Build event attributes
         event_attrs = {
-            "place_name": EventAttributeValue(
-                name="place_name",
-                value=func.__name__,
-                time=timestamp
-            )
+            "place_name": attribute_value_from_python(func.__name__)
         }
 
         # Extract from blackboard

mycorrhizal/spores/dsl/rhizomorph.py

@@ -20,7 +20,7 @@ from ...spores import (
     Event,
     LogRecord,
     Relationship,
-    EventAttributeValue,
+    attribute_value_from_python,
     generate_event_id,
 )
 from ...spores.extraction import (
@@ -167,19 +167,11 @@ async def _log_node_event(
         event_attrs = {}
 
         # Add node name
-        event_attrs["node_name"] = EventAttributeValue(
-            name="node_name",
-            value=func.__name__,
-            time=timestamp
-        )
+        event_attrs["node_name"] = attribute_value_from_python(func.__name__)
 
         # Add status if requested and result is a Status
         if log_status and isinstance(result, Status):
-            event_attrs["status"] = EventAttributeValue(
-                name="status",
-                value=result.name,
-                time=timestamp
-            )
+            event_attrs["status"] = attribute_value_from_python(result.name)
 
         # Extract from blackboard
         bb_attrs = extract_attributes_from_blackboard(bb, timestamp)