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

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

mycorrhizal/spores/models.py

@@ -35,16 +35,16 @@ class EventAttributeValue:
     """
     An attribute value for an event.
 
-    OCEL attributes include timestamps for versioning.
+    Event attributes don't have timestamps because the event time itself is sufficient.
 
     Attributes:
         name: The attribute name
         value: The string representation of the value
-        time: When this attribute value was set
+        type: The data type ("string", "integer", "float", "boolean", "timestamp")
     """
     name: str
     value: str
-    time: datetime
+    type: str
 
 
 @dataclass(frozen=True)
@@ -57,11 +57,13 @@ class ObjectAttributeValue:
     Attributes:
         name: The attribute name
         value: The string representation of the value
+        type: The data type ("string", "integer", "float", "boolean", "timestamp")
         time: When this attribute value was set
     """
     name: str
     value: str
-    time: datetime
+    type: str
+    time: Optional[datetime] = None
 
 
 @dataclass
@@ -71,14 +73,16 @@ class Event:
 
     Attributes:
         id: Unique event identifier
-        type: Event type/category
+        type: Event type/category (event class)
+        activity: Optional semantic activity label (defaults to type if null)
         time: When the event occurred
         attributes: Event attributes (name -> EventAttributeValue)
         relationships: Objects related to this event (qualifier -> Relationship)
     """
     id: str
     type: str
-    time: datetime
+    activity: Optional[str] = None
+    time: datetime = field(default_factory=datetime.now)
     attributes: Dict[str, EventAttributeValue] = field(default_factory=dict)
     relationships: Dict[str, Relationship] = field(default_factory=dict)
 
@@ -196,23 +200,49 @@ class SporesAttr:
     name: Optional[str] = None
 
 
+# ============================================================================
+# Type Inference
+# ============================================================================
+
+def infer_type(value: Any) -> str:
+    """
+    Infer the OCEL type for a Python value.
+
+    Args:
+        value: The Python value to infer type for
+
+    Returns:
+        One of: "string", "integer", "float", "boolean", "timestamp"
+    """
+    if isinstance(value, bool):
+        return "boolean"
+    elif isinstance(value, int):
+        return "integer"
+    elif isinstance(value, float):
+        return "float"
+    elif isinstance(value, datetime):
+        return "timestamp"
+    else:
+        return "string"
+
+
 # ============================================================================
 # Attribute Value Conversion
 # ============================================================================
 
-def attribute_value_from_python(value: Any, time: datetime) -> EventAttributeValue:
+def attribute_value_from_python(value: Any) -> EventAttributeValue:
     """
     Convert a Python value to an OCEL EventAttributeValue.
 
-    All values are converted to strings per OCEL specification.
-
     Args:
         value: The Python value to convert
-        time: The timestamp for this attribute value
 
     Returns:
-        An EventAttributeValue with string representation
+        An EventAttributeValue with type information
     """
+    # Infer type
+    attr_type = infer_type(value)
+
     # Handle None
     if value is None:
         str_value = "null"
@@ -240,30 +270,33 @@ def attribute_value_from_python(value: Any, time: datetime) -> EventAttributeVal
     return EventAttributeValue(
         name="",  # Name set by caller
         value=str_value,
-        time=time
+        type=attr_type
     )
 
 
-def object_attribute_from_python(value: Any, time: datetime) -> ObjectAttributeValue:
+def object_attribute_from_python(value: Any, time: Optional[datetime] = None) -> ObjectAttributeValue:
     """
     Convert a Python value to an OCEL ObjectAttributeValue.
 
-    Same conversion rules as attribute_value_from_python but for objects.
-
     Args:
         value: The Python value to convert
-        time: The timestamp for this attribute value
+        time: The timestamp for this attribute value (optional)
 
     Returns:
-        An ObjectAttributeValue with string representation
+        An ObjectAttributeValue with type information
     """
-    # Use same conversion logic
-    event_attr = attribute_value_from_python(value, time)
+    # Use same type inference logic
+    event_attr = attribute_value_from_python(value)
+
+    # Default to current time if not provided
+    if time is None:
+        time = datetime.now()
 
     return ObjectAttributeValue(
         name=event_attr.name,
         value=event_attr.value,
-        time=event_attr.time
+        type=event_attr.type,
+        time=time
     )