mycorrhizal 0.1.0__py3-none-any.whl → 0.2.0__py3-none-any.whl

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)

mycorrhizal/spores/dsl/{enoki.py → septum.py}

@@ -1,8 +1,8 @@
 #!/usr/bin/env python3
 """
-Spores Adapter for Enoki (State Machines)
+Spores Adapter for Septum (State Machines)
 
-Provides logging integration for Enoki state machines.
+Provides logging integration for Septum state machines.
 Extracts context information and automatically creates event/object logs.
 """
 
@@ -22,21 +22,22 @@ from ...spores import (
     Relationship,
     EventAttributeValue,
     generate_event_id,
+    attribute_value_from_python,
 )
 from ...spores.extraction import (
     extract_attributes_from_blackboard,
     extract_objects_from_blackboard,
 )
 from ...spores.core import _send_log_record, get_object_cache
-from ...enoki.core import SharedContext, TransitionType
+from ...septum.core import SharedContext, TransitionType
 
 
 logger = logging.getLogger(__name__)
 
 
-class EnokiAdapter:
+class SeptumAdapter:
     """
-    Adapter for Enoki state machine logging.
+    Adapter for Septum state machine logging.
 
     Provides decorators and helpers for logging:
     - State entry/exit/timeout events
@@ -46,13 +47,13 @@ class EnokiAdapter:
 
     Usage:
         ```python
-        from mycorrhizal.spores.dsl import EnokiAdapter
+        from mycorrhizal.spores.dsl import SeptumAdapter
 
-        adapter = EnokiAdapter()
+        adapter = SeptumAdapter()
 
-        @enoki.state()
+        @septum.state()
         def MyState():
-            @enoki.on_state
+            @septum.on_state
             @adapter.log_state(event_type="state_execute")
             async def on_state(ctx: SharedContext):
                 # Event automatically logged with:
@@ -61,7 +62,7 @@ class EnokiAdapter:
                 # - relationships to objects (with ObjectRef annotations)
                 return Events.DONE
 
-            @enoki.on_enter
+            @septum.on_enter
             @adapter.log_state_lifecycle(event_type="state_enter")
             async def on_enter(ctx: SharedContext):
                 pass
@@ -69,7 +70,7 @@ class EnokiAdapter:
     """
 
     def __init__(self):
-        """Initialize the Enoki adapter."""
+        """Initialize the Septum adapter."""
         self._enabled = True
 
     def enable(self):
@@ -88,7 +89,7 @@ class EnokiAdapter:
         log_transition: bool = True,
     ) -> Callable:
         """
-        Decorator to log Enoki state execution.
+        Decorator to log Septum state execution.
 
         Automatically captures:
         - State name
@@ -214,19 +215,11 @@ async def _log_state_event(
             if hasattr(ctx, 'current_state') and ctx.current_state:
                 state_name = getattr(ctx.current_state, 'name', state_name)
 
-            event_attrs["state_name"] = EventAttributeValue(
-                name="state_name",
-                value=state_name,
-                time=timestamp
-            )
+            event_attrs["state_name"] = attribute_value_from_python(state_name)
 
         # Add transition result if requested
         if log_transition and isinstance(result, TransitionType):
-            event_attrs["transition"] = EventAttributeValue(
-                name="transition",
-                value=result.name,
-                time=timestamp
-            )
+            event_attrs["transition"] = attribute_value_from_python(result.name)
 
         # Extract from ctx.common (blackboard)
         if hasattr(ctx, 'common') and ctx.common:
@@ -235,11 +228,7 @@ async def _log_state_event(
 
         # Add message if present
         if hasattr(ctx, 'msg') and ctx.msg is not None:
-            event_attrs["message_type"] = EventAttributeValue(
-                name="message_type",
-                value=type(ctx.msg).__name__,
-                time=timestamp
-            )
+            event_attrs["message_type"] = attribute_value_from_python(type(ctx.msg).__name__)
 
         # Extract objects from ctx.common
         relationships = {}
@@ -293,16 +282,8 @@ async def _log_lifecycle_event(
 
         # Build event attributes
         event_attrs = {
-            "lifecycle_method": EventAttributeValue(
-                name="lifecycle_method",
-                value=func.__name__,
-                time=timestamp
-            ),
-            "phase": EventAttributeValue(
-                name="phase",
-                value=phase,
-                time=timestamp
-            )
+            "lifecycle_method": attribute_value_from_python(func.__name__),
+            "phase": attribute_value_from_python(phase)
         }
 
         # Add state name
@@ -310,11 +291,7 @@ async def _log_lifecycle_event(
         if hasattr(ctx, 'current_state') and ctx.current_state:
             state_name = getattr(ctx.current_state, 'name', state_name)
 
-        event_attrs["state_name"] = EventAttributeValue(
-            name="state_name",
-            value=state_name,
-            time=timestamp
-        )
+        event_attrs["state_name"] = attribute_value_from_python(state_name)
 
         # Add static attributes
         if attributes:
@@ -322,17 +299,9 @@ async def _log_lifecycle_event(
                 if callable(value):
                     if hasattr(ctx, 'common') and ctx.common:
                         result = value(ctx.common)
-                        event_attrs[key] = EventAttributeValue(
-                            name=key,
-                            value=str(result),
-                            time=timestamp
-                        )
+                        event_attrs[key] = attribute_value_from_python(str(result))
                 else:
-                    event_attrs[key] = EventAttributeValue(
-                        name=key,
-                        value=str(value),
-                        time=timestamp
-                    )
+                    event_attrs[key] = attribute_value_from_python(str(value))
 
         # Extract from ctx.common
         if hasattr(ctx, 'common') and ctx.common:
@@ -435,26 +404,14 @@ async def _log_message_event(
 
         # Build event attributes
         event_attrs = {
-            "message_type": EventAttributeValue(
-                name="message_type",
-                value=type(ctx.msg).__name__,
-                time=timestamp
-            ),
-            "handler": EventAttributeValue(
-                name="handler",
-                value=func.__name__,
-                time=timestamp
-            )
+            "message_type": attribute_value_from_python(type(ctx.msg).__name__),
+            "handler": attribute_value_from_python(func.__name__)
         }
 
         # Add state name
         if hasattr(ctx, 'current_state') and ctx.current_state:
             state_name = getattr(ctx.current_state, 'name', 'unknown')
-            event_attrs["state_name"] = EventAttributeValue(
-                name="state_name",
-                value=state_name,
-                time=timestamp
-            )
+            event_attrs["state_name"] = attribute_value_from_python(state_name)
 
         # Add static attributes
         if attributes:
@@ -462,17 +419,9 @@ async def _log_message_event(
                 if callable(value):
                     if hasattr(ctx, 'common') and ctx.common:
                         result = value(ctx.common)
-                        event_attrs[key] = EventAttributeValue(
-                            name=key,
-                            value=str(result),
-                            time=timestamp
-                        )
+                        event_attrs[key] = attribute_value_from_python(str(result))
                 else:
-                    event_attrs[key] = EventAttributeValue(
-                        name=key,
-                        value=str(value),
-                        time=timestamp
-                    )
+                    event_attrs[key] = attribute_value_from_python(str(value))
 
         # Extract from ctx.common
         if hasattr(ctx, 'common') and ctx.common:

mycorrhizal/spores/encoder/json.py

@@ -27,23 +27,26 @@ class JSONEncoder(Encoder):
           "event": {
             "id": "evt-123",
             "type": "process_item",
-            "time": "2025-01-11T12:34:56.789Z",
+            "activity": null,
+            "time": "2025-01-11T12:34:56.789000000Z",
             "attributes": [
-              {"name": "priority", "value": "high", "time": "2025-01-11T12:34:56.789Z"}
+              {"name": "priority", "value": "high", "type": "string", "time": null}
             ],
             "relationships": [
               {"objectId": "obj-456", "qualifier": "input"}
             ]
-          }
+          },
+          "object": null
         }
 
     Or for objects:
         {
+          "event": null,
           "object": {
             "id": "obj-456",
             "type": "WorkItem",
             "attributes": [
-              {"name": "status", "value": "pending", "time": "2025-01-11T12:34:56.789Z"}
+              {"name": "status", "value": "pending", "type": "string", "time": null}
             ],
             "relationships": []
           }
@@ -60,11 +63,11 @@ class JSONEncoder(Encoder):
         Returns:
             JSON-encoded bytes
         """
-        # Convert LogRecord to dict
+        # Convert LogRecord to dict with union structure (both fields, one null)
         if record.event is not None:
-            data = {"event": self._event_to_dict(record.event)}
+            data = {"event": self._event_to_dict(record.event), "object": None}
         else:
-            data = {"object": self._object_to_dict(record.object)}
+            data = {"event": None, "object": self._object_to_dict(record.object)}
 
         # Encode to JSON
         return json.dumps(data, separators=(',', ':')).encode('utf-8')
@@ -78,6 +81,7 @@ class JSONEncoder(Encoder):
         return {
             "id": event.id,
             "type": event.type,
+            "activity": event.activity,
             "time": self._format_datetime(event.time),
             "attributes": [
                 self._event_attr_to_dict(name, attr)
@@ -104,21 +108,26 @@ class JSONEncoder(Encoder):
             ]
         }
 
-    def _event_attr_to_dict(self, name: str, attr: EventAttributeValue) -> Dict[str, str]:
+    def _event_attr_to_dict(self, name: str, attr: EventAttributeValue) -> Dict[str, Any]:
         """Convert EventAttributeValue to dict."""
         return {
             "name": attr.name or name,
             "value": attr.value,
-            "time": self._format_datetime(attr.time)
+            "type": attr.type
         }
 
-    def _object_attr_to_dict(self, name: str, attr: ObjectAttributeValue) -> Dict[str, str]:
+    def _object_attr_to_dict(self, name: str, attr: ObjectAttributeValue) -> Dict[str, Any]:
         """Convert ObjectAttributeValue to dict."""
-        return {
+        result = {
             "name": attr.name or name,
             "value": attr.value,
-            "time": self._format_datetime(attr.time)
+            "type": attr.type
         }
+        if attr.time is not None:
+            result["time"] = self._format_datetime(attr.time)
+        else:
+            result["time"] = None
+        return result
 
     def _relationship_to_dict(self, qualifier: str, rel: Relationship) -> Dict[str, str]:
         """Convert Relationship to dict."""

mycorrhizal/spores/extraction.py

@@ -41,7 +41,7 @@ def extract_attributes_from_params(
         func: The decorated function
         args: Positional arguments passed to function
         kwargs: Keyword arguments passed to function
-        timestamp: Event timestamp for attribute values
+        timestamp: Event timestamp (not used for attribute timestamps)
 
     Returns:
         Dictionary of attribute name -> EventAttributeValue
@@ -60,8 +60,8 @@ def extract_attributes_from_params(
             if param_name in ('self', 'cls', 'bb', 'ctx', 'timebase', 'consumed'):
                 continue
 
-            # Extract attribute value
-            attr = attribute_value_from_python(param_value, timestamp)
+            # Extract attribute value (time=None for event attributes)
+            attr = attribute_value_from_python(param_value)
             attributes[param_name] = attr
 
     except Exception as e:
@@ -79,7 +79,7 @@ def extract_attributes_from_dict(
 
     Args:
         data: Dictionary with attribute values
-        timestamp: Event timestamp for attribute values
+        timestamp: Event timestamp (not used for attribute timestamps)
 
     Returns:
         Dictionary of attribute name -> EventAttributeValue
@@ -87,7 +87,7 @@ def extract_attributes_from_dict(
     attributes = {}
 
     for key, value in data.items():
-        attr = attribute_value_from_python(value, timestamp)
+        attr = attribute_value_from_python(value)
         attributes[key] = attr
 
     return attributes
@@ -102,7 +102,7 @@ def extract_attributes_from_blackboard(
 
     Args:
         bb: Blackboard object
-        timestamp: Event timestamp for attribute values
+        timestamp: Event timestamp (not used for attribute timestamps)
 
     Returns:
         Dictionary of attribute name -> EventAttributeValue
@@ -136,7 +136,7 @@ def extract_attributes_from_blackboard(
                                     attr_name = metadata.name or field_name
                                 else:
                                     attr_name = field_name
-                                attr = attribute_value_from_python(value, timestamp)
+                                attr = attribute_value_from_python(value)
                                 attributes[attr_name] = attr
 
     except Exception as e:
@@ -168,13 +168,13 @@ def evaluate_computed_attributes(
             # Call the function with blackboard
             try:
                 result = value(bb)
-                attr = attribute_value_from_python(result, timestamp)
+                attr = attribute_value_from_python(result)
                 attributes[key] = attr
             except Exception as e:
                 logger.error(f"Failed to compute attribute {key}: {e}")
         else:
             # Static value
-            attr = attribute_value_from_python(value, timestamp)
+            attr = attribute_value_from_python(value)
             attributes[key] = attr
 
     return attributes
@@ -289,6 +289,7 @@ def convert_to_ocel_object(
                     attr = attr.__class__(
                         name=key,
                         value=attr.value,
+                        type=attr.type,
                         time=attr.time
                     )
                     attributes[key] = attr
@@ -302,6 +303,7 @@ def convert_to_ocel_object(
                 attr = attr.__class__(
                     name=key,
                     value=attr.value,
+                    type=attr.type,
                     time=attr.time
                 )
                 attributes[key] = attr
@@ -359,6 +361,7 @@ def extract_objects_from_spec(
                         attr = attr.__class__(
                             name=key,
                             value=attr.value,
+                            type=attr.type,
                             time=attr.time
                         )
                         attributes[key] = attr
@@ -447,12 +450,12 @@ def extract_from_rhizomorph_context(
     return attributes, objects
 
 
-def extract_from_enoki_context(
+def extract_from_septum_context(
     ctx: Any,
     timestamp: datetime
 ) -> tuple[Dict[str, EventAttributeValue], List[Object]]:
     """
-    Extract attributes and objects from Enoki state context.
+    Extract attributes and objects from Septum state context.
 
     Args:
         ctx: SharedContext