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

mycorrhizal/_version.py

@@ -0,0 +1 @@
+version = "0.1.2"

mycorrhizal/hypha/core/builder.py

@@ -6,7 +6,7 @@ NetBuilder provides the API for declaratively constructing Petri net specificati
 Used within @pn.net decorated functions.
 """
 
-from typing import Optional, Callable, List, Dict, Type, Any
+from typing import Optional, Callable, List, Dict, Type, Any, Union
 from .specs import (
     NetSpec,
     PlaceSpec,
@@ -54,14 +54,52 @@ class NetBuilder:
 
     def place(
         self,
-        name: str,
+        name_or_func: Union[str, Callable, None] = None,
         type: PlaceType = PlaceType.BAG,
         state_factory: Optional[Callable] = None,
-    ) -> PlaceRef:
-        """Declare a regular place"""
-        place_spec = PlaceSpec(name, type, state_factory=state_factory)
-        self.spec.places[name] = place_spec
-        return PlaceRef(name, self.spec)
+    ) -> Union[PlaceRef, Callable]:
+        """Declare a regular place.
+
+        Can be used in three ways:
+
+        1. As a method call (returns PlaceRef for use in arcs):
+           queue = builder.place("queue", type=PlaceType.QUEUE)
+
+        2. As a decorator without parens (infers name from function):
+           @builder.place
+           def queue(bb):
+               return bb.tokens
+
+        3. As a decorator with custom name:
+           @builder.place("custom_name")
+           def my_func(bb):
+               return bb.tokens
+        """
+        # Case 1: Used as decorator without parens - first arg is the function
+        if callable(name_or_func):
+            func = name_or_func
+            place_name = func.__name__
+            place_spec = PlaceSpec(place_name, type, handler=func, state_factory=state_factory)
+            self.spec.places[place_name] = place_spec
+            return PlaceRef(place_name, self.spec)
+
+        # Case 2 & 3: Used with explicit name (as method call or decorator with args)
+        # or called without any args (need to return decorator)
+        if isinstance(name_or_func, str):
+            name = name_or_func
+            place_spec = PlaceSpec(name, type, state_factory=state_factory)
+            self.spec.places[name] = place_spec
+            # Return PlaceRef - it's callable via __call__ for decorator use
+            return PlaceRef(name, self.spec)
+
+        # Case 4: Called without any args - shouldn't happen but handle gracefully
+        # This would be like @builder.place() with empty parens
+        def decorator(func: Callable) -> PlaceRef:
+            place_name = func.__name__
+            place_spec = PlaceSpec(place_name, type, handler=func, state_factory=state_factory)
+            self.spec.places[place_name] = place_spec
+            return PlaceRef(place_name, self.spec)
+        return decorator
 
     def io_input_place(self):
         """Decorator for IOInputPlace with async generator"""

mycorrhizal/hypha/core/specs.py

@@ -147,11 +147,11 @@ class PlaceRef:
     def __init__(self, local_name: str, parent_spec: NetSpec):
         self.local_name = local_name
         self.parent_spec = parent_spec
-    
+
     def get_fqn(self) -> str:
         """Compute FQN dynamically"""
         return '.'.join(self.get_parts())
-    
+
     # For backward compatibility
     @property
     def fqn(self) -> str:
@@ -164,7 +164,23 @@ class PlaceRef:
     @property
     def parts(self) -> List[str]:
         return self.get_parts()
-    
+
+    def __call__(self, func: Callable) -> "PlaceRef":
+        """Allow PlaceRef to be used as a decorator to register a handler.
+
+        Example:
+            @builder.place("queue")
+            def queue_handler(bb):
+                return bb.tokens
+
+        The PlaceRef is returned for use in arcs, and the handler is registered.
+        """
+        # Get the place spec and register the handler
+        place_spec = self.parent_spec.places.get(self.local_name)
+        if place_spec is not None:
+            place_spec.handler = func
+        return self
+
     def __repr__(self):
         return f"PlaceRef({self.get_fqn()})"
 

mycorrhizal/rhizomorph/core.py

@@ -1309,9 +1309,36 @@ class _BT:
             self._tracking_stack[-1].append((fn.__name__, fn))
         return fn
 
-    def sequence(self, *, memory: bool = True):
-        """Decorator to mark a generator function as a sequence composite."""
+    def sequence(self, func_or_none=None, *, memory: bool = True):
+        """Decorator to mark a generator function as a sequence composite.
 
+        Can be used with or without parentheses:
+            @bt.sequence
+            def root():
+                ...
+
+            @bt.sequence(memory=False)
+            def root():
+                ...
+        """
+        # Case 1: Used as @bt.sequence (no parens)
+        if callable(func_or_none):
+            # Apply decorator directly with defaults
+            spec = NodeSpec(
+                kind=NodeSpecKind.SEQUENCE,
+                name=_name_of(func_or_none),
+                payload={"factory": func_or_none, "memory": memory},
+            )
+            func_or_none.node_spec = spec  # type: ignore
+            if self._tracking_stack:
+                self._tracking_stack[-1].append((func_or_none.__name__, func_or_none))
+            return func_or_none
+
+        # Case 2: Used as @bt.sequence() or @bt.sequence(memory=False)
+        return self._sequence_impl(memory=memory)
+
+    def _sequence_impl(self, memory: bool):
+        """Implementation of sequence decorator."""
         def deco(
             factory: Callable[..., Generator[Any, None, None]],
         ) -> Callable[..., Generator[Any, None, None]]:
@@ -1327,9 +1354,40 @@ class _BT:
 
         return deco
 
-    def selector(self, *, memory: bool = True, reactive: bool = False):
-        """Decorator to mark a generator function as a selector composite."""
+    def selector(self, func_or_none=None, *, memory: bool = True, reactive: bool = False):
+        """Decorator to mark a generator function as a selector composite.
+
+        Can be used with or without parentheses:
+            @bt.selector
+            def root():
+                ...
+
+            @bt.selector(memory=False)
+            def root():
+                ...
+
+            @bt.selector(reactive=True)
+            def root():
+                ...
+        """
+        # Case 1: Used as @bt.selector (no parens)
+        if callable(func_or_none):
+            # Apply decorator directly with defaults
+            spec = NodeSpec(
+                kind=NodeSpecKind.SELECTOR,
+                name=_name_of(func_or_none),
+                payload={"factory": func_or_none, "memory": memory, "reactive": reactive},
+            )
+            func_or_none.node_spec = spec  # type: ignore
+            if self._tracking_stack:
+                self._tracking_stack[-1].append((func_or_none.__name__, func_or_none))
+            return func_or_none
+
+        # Case 2: Used as @bt.selector() or @bt.selector(memory=False)
+        return self._selector_impl(memory=memory, reactive=reactive)
 
+    def _selector_impl(self, memory: bool, reactive: bool):
+        """Implementation of selector decorator."""
         def deco(
             factory: Callable[..., Generator[Any, None, None]],
         ) -> Callable[..., Generator[Any, None, None]]:

mycorrhizal/spores/__init__.py

@@ -6,22 +6,53 @@ OCEL (Object-Centric Event Log) compatible logging system for tracking events
 and objects in Mycorrhizal systems. Provides automatic extraction of events
 and objects from DSL execution.
 
-Usage:
-    from mycorrhizal.spores import configure, spore, EventAttr, ObjectRef
-
-    # Configure logging
-    configure(
-        enabled=True,
-        object_cache_size=100,
-        transport=FileTransport("logs/ocel.jsonl"),
+Usage (Standalone Event and Object Logging):
+    from mycorrhizal.spores import configure, get_spore_sync, get_spore_async
+    from mycorrhizal.spores.transport import SyncFileTransport, AsyncFileTransport
+    from mycorrhizal.spores.models import SporesAttr
+    from pydantic import BaseModel
+    from typing import Annotated
+
+    # Mark domain model fields for object attribute logging
+    class Order(BaseModel):
+        id: str
+        status: Annotated[str, SporesAttr]
+        total: Annotated[float, SporesAttr]
+
+    # Sync code
+    configure(transport=SyncFileTransport("logs/ocel.jsonl"))
+    spore = get_spore_sync(__name__)
+
+    @spore.log_event(
+        event_type="OrderCreated",
+        relationships={"order": ("return", "Order")},
+    )
+    def create_order(customer: Customer, items: list) -> Order:
+        return Order(...)
+
+    # Async code
+    configure(transport=AsyncFileTransport("logs/ocel.jsonl"))
+    aspore = get_spore_async(__name__)
+
+    @aspore.log_event(
+        event_type="OrderCreated",
+        relationships={"order": ("return", "Order")},
     )
+    async def create_order_async(customer: Customer, items: list) -> Order:
+        return Order(...)
+
+Usage (DSL Adapters):
+    from mycorrhizal.spores import configure, spore
+    from mycorrhizal.spores.models import EventAttr, ObjectRef, ObjectScope
+    from pydantic import BaseModel
+    from typing import Annotated
 
-    # Mark model fields for automatic extraction
+    # Mark blackboard fields for event attribute extraction
     class MissionContext(BaseModel):
         mission_id: Annotated[str, EventAttr]
         robot: Annotated[Robot, ObjectRef(qualifier="actor", scope=ObjectScope.GLOBAL)]
 
-    # Mark object types
+    # Mark object types for logging
     @spore.object(object_type="Robot")
     class Robot(BaseModel):
         id: str
@@ -32,12 +63,15 @@ DSL Adapters:
     RhizomorphAdapter - Log behavior tree node execution with status
     EnokiAdapter - Log state machine execution and lifecycle events
 
+Annotation Types:
+    EventAttr - Mark blackboard fields for automatic event attribute extraction (DSL adapters)
+    SporesAttr - Mark domain model fields for automatic object attribute logging (log_event)
+    ObjectRef - Mark blackboard fields as object references with scope
+
 Key Concepts:
     Event - Something that happens at a point in time with attributes
     Object - An entity with a type and attributes
     Relationship - Link between events and objects (e.g., "actor", "target")
-    EventAttr - Mark blackboard fields for automatic event attribute extraction
-    ObjectRef - Mark blackboard fields as object references with scope
 
 Object Scopes:
     EVENT - Object exists only for this event (default)
@@ -48,8 +82,13 @@ from .core import (
     configure,
     get_config,
     get_object_cache,
+    get_spore_sync,
+    get_spore_async,
     spore,
     SporesConfig,
+    EventLogger,
+    AsyncEventLogger,
+    SyncEventLogger,
 )
 
 from .models import (
@@ -62,6 +101,7 @@ from .models import (
     ObjectRef,
     ObjectScope,
     EventAttr,
+    SporesAttr,
     generate_event_id,
     generate_object_id,
     attribute_value_from_python,
@@ -71,7 +111,7 @@ from .models import (
 from .cache import ObjectLRUCache
 
 from .encoder import Encoder, JSONEncoder
-from .transport import Transport
+from .transport import SyncTransport, AsyncTransport, Transport, SyncFileTransport, AsyncFileTransport
 
 # DSL adapters
 from .dsl import (
@@ -81,7 +121,10 @@ from .dsl import (
 )
 
 
-__version__ = "0.1.0"
+try:
+    from mycorrhizal._version import version as __version__
+except ImportError:
+    __version__ = "0.0.0+dev"
 
 
 __all__ = [
@@ -89,7 +132,12 @@ __all__ = [
     'configure',
     'get_config',
     'get_object_cache',
-    'spore',
+    'get_spore_sync',
+    'get_spore_async',
+    'EventLogger',
+    'AsyncEventLogger',
+    'SyncEventLogger',
+    'spore',  # For DSL adapters and @spore.object() decorator
     'SporesConfig',
 
     # Models
@@ -102,6 +150,7 @@ __all__ = [
     'ObjectRef',
     'ObjectScope',
     'EventAttr',
+    'SporesAttr',
     'generate_event_id',
     'generate_object_id',
     'attribute_value_from_python',
@@ -115,7 +164,11 @@ __all__ = [
     'JSONEncoder',
 
     # Transport
-    'Transport',
+    'SyncTransport',
+    'AsyncTransport',
+    'Transport',  # Alias for AsyncTransport (backward compatibility)
+    'SyncFileTransport',
+    'AsyncFileTransport',
 
     # DSL Adapters
     'HyphaAdapter',