vention-state-machine 0.3.1__tar.gz → 0.4.2__tar.gz

vention_state_machine-0.3.1/README.md → vention_state_machine-0.4.2/PKG-INFO

@@ -1,3 +1,37 @@
+Metadata-Version: 2.4
+Name: vention-state-machine
+Version: 0.4.2
+Summary: Declarative state machine framework for machine apps
+License: Proprietary
+Author: VentionCo
+Requires-Python: >=3.10,<3.11
+Classifier: License :: Other/Proprietary License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Requires-Dist: annotated-doc (==0.0.4) ; python_version == "3.10"
+Requires-Dist: annotated-types (==0.7.0) ; python_version == "3.10"
+Requires-Dist: anyio (==4.11.0) ; python_version == "3.10"
+Requires-Dist: asyncio (==3.4.3) ; python_version == "3.10"
+Requires-Dist: click (==8.1.8) ; python_version == "3.10"
+Requires-Dist: colorama (==0.4.6) ; python_version == "3.10" and platform_system == "Windows"
+Requires-Dist: coverage (==7.10.7) ; python_version == "3.10"
+Requires-Dist: exceptiongroup (==1.3.0) ; python_version == "3.10"
+Requires-Dist: fastapi (==0.121.1) ; python_version == "3.10"
+Requires-Dist: graphviz (==0.21) ; python_version == "3.10"
+Requires-Dist: h11 (==0.16.0) ; python_version == "3.10"
+Requires-Dist: idna (==3.11) ; python_version == "3.10"
+Requires-Dist: pydantic (==2.12.3) ; python_version == "3.10"
+Requires-Dist: pydantic-core (==2.41.4) ; python_version == "3.10"
+Requires-Dist: six (==1.17.0) ; python_version == "3.10"
+Requires-Dist: sniffio (==1.3.1) ; python_version == "3.10"
+Requires-Dist: starlette (==0.48.0) ; python_version == "3.10"
+Requires-Dist: transitions (==0.9.3) ; python_version == "3.10"
+Requires-Dist: typing-extensions (==4.15.0) ; python_version == "3.10"
+Requires-Dist: typing-inspection (==0.4.2) ; python_version == "3.10"
+Requires-Dist: uvicorn (==0.35.0) ; python_version == "3.10"
+Requires-Dist: vention-communication (==0.3.0) ; python_version == "3.10"
+Description-Content-Type: text/markdown
+
 # vention-state-machine
 
 A lightweight wrapper around `transitions` for building async-safe, recoverable hierarchical state machines with minimal boilerplate.
@@ -22,7 +56,7 @@ A lightweight wrapper around `transitions` for building async-safe, recoverable
 - Transition history recording with timestamps + durations
 - Guard conditions for blocking transitions
 - Global state change callbacks for logging/MQTT
-- Optional FastAPI router for HTTP access and visualization
+- Optional RPC bundle for exposing state machine via Connect RPCs
 
 ## 🧠 Concepts & Overview
 
@@ -75,20 +109,20 @@ pip install vention-state-machine
 
 **Optional dependencies:**
 - Graphviz (required for diagram generation)
-- FastAPI (for HTTP exposure of state machine)
+- vention-communication (for RPC bundle integration)
 
 **Install optional tools:**
 
 MacOS:
 ```bash
 brew install graphviz
-pip install fastapi
+pip install vention-communication
 ```
 
 Linux (Debian/Ubuntu)
 ```bash
 sudo apt-get install graphviz
-pip install fastapi
+pip install vention-communication
 ```
 
 
@@ -172,25 +206,37 @@ state_machine.start()
 
 ## 🛠 How-to Guides
 
-### Expose Over HTTP with FastAPI
+### Expose Over RPC with VentionApp
 
 ```python
-from fastapi import FastAPI
-from state_machine.router import build_router
+from communication.app import VentionApp
+from state_machine.vention_communication import build_state_machine_bundle
 from state_machine.core import StateMachine
 
 state_machine = StateMachine(...)
 state_machine.start()
 
-app = FastAPI()
-app.include_router(build_router(state_machine))
+app = VentionApp(name="MyApp")
+bundle = build_state_machine_bundle(state_machine)
+app.register_rpc_plugin(bundle)
+app.finalize()
 ```
 
-**Endpoints:**
-- `GET /state` → Current state
-- `GET /history` → Transition history
-- `POST /<trigger>` → Trigger a transition
-- `GET /diagram.svg` → Graphviz diagram
+**RPC Actions:**
+- `GetState` → Returns current state and last known state
+- `GetHistory` → Returns transition history with timestamps
+- `Trigger_<TriggerName>` → Triggers a state transition (e.g., `Trigger_Start`, `Trigger_Activate`)
+
+**Options:**
+```python
+# Customize which actions are included
+bundle = build_state_machine_bundle(
+    state_machine,
+    include_state_actions=True,  # Include GetState
+    include_history_action=True,  # Include GetHistory
+    triggers=["start", "activate"],  # Only include specific triggers
+)
+```
 
 ### Timeout Example
 
@@ -350,24 +396,28 @@ Guard transition; blocks if function returns False.
 **`@on_state_change`**
 Global callback `(old_state, new_state, trigger)` fired after each transition.
 
-### Router
+### RPC Bundle
 
 ```python
-def build_router(
-    machine: StateMachine,
-    triggers: Optional[list[Trigger]] = None
-) -> fastapi.APIRouter
+def build_state_machine_bundle(
+    sm: StateMachine,
+    *,
+    include_state_actions: bool = True,
+    include_history_action: bool = True,
+    triggers: Optional[Sequence[str]] = None,
+) -> RpcBundle
 ```
 
-Exposes endpoints:
-- `GET /state`
-- `GET /history`
-- `POST /<trigger>`
-- `GET /diagram.svg`
+Builds an RPC bundle exposing the state machine via Connect-style RPCs:
+- `GetState` - Returns current and last known state
+- `GetHistory` - Returns transition history
+- `Trigger_<TriggerName>` - One RPC per trigger (PascalCase naming)
+
+The bundle can be registered with a `VentionApp` using `app.register_rpc_plugin(bundle)`.
 
 ## 🔍 Troubleshooting & FAQ
 
-- **Diagram endpoint returns 503** → Graphviz not installed.
 - **Transitions blocked unexpectedly** → Check guard conditions.
 - **Callbacks not firing** → Only successful transitions trigger them.
-- **State not restored after restart** → Ensure `enable_last_state_recovery=True`.
+- **State not restored after restart** → Ensure `enable_last_state_recovery=True`.
+- **RPC actions not available** → Ensure `app.finalize()` is called after registering bundles.

vention_state_machine-0.3.1/PKG-INFO → vention_state_machine-0.4.2/README.md

@@ -1,22 +1,3 @@
-Metadata-Version: 2.1
-Name: vention-state-machine
-Version: 0.3.1
-Summary: Declarative state machine framework for machine apps
-License: Proprietary
-Author: VentionCo
-Requires-Python: >=3.10,<3.11
-Classifier: License :: Other/Proprietary License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Requires-Dist: asyncio (>=3.4.3,<4.0.0)
-Requires-Dist: coverage (>=7.10.1,<8.0.0)
-Requires-Dist: fastapi (==0.121.1)
-Requires-Dist: graphviz (>=0.21,<0.22)
-Requires-Dist: httpx (>=0.28.1,<0.29.0)
-Requires-Dist: transitions (>=0.9.3,<0.10.0)
-Requires-Dist: uvicorn (>=0.35.0,<0.36.0)
-Description-Content-Type: text/markdown
-
 # vention-state-machine
 
 A lightweight wrapper around `transitions` for building async-safe, recoverable hierarchical state machines with minimal boilerplate.
@@ -41,7 +22,7 @@ A lightweight wrapper around `transitions` for building async-safe, recoverable
 - Transition history recording with timestamps + durations
 - Guard conditions for blocking transitions
 - Global state change callbacks for logging/MQTT
-- Optional FastAPI router for HTTP access and visualization
+- Optional RPC bundle for exposing state machine via Connect RPCs
 
 ## 🧠 Concepts & Overview
 
@@ -94,20 +75,20 @@ pip install vention-state-machine
 
 **Optional dependencies:**
 - Graphviz (required for diagram generation)
-- FastAPI (for HTTP exposure of state machine)
+- vention-communication (for RPC bundle integration)
 
 **Install optional tools:**
 
 MacOS:
 ```bash
 brew install graphviz
-pip install fastapi
+pip install vention-communication
 ```
 
 Linux (Debian/Ubuntu)
 ```bash
 sudo apt-get install graphviz
-pip install fastapi
+pip install vention-communication
 ```
 
 
@@ -191,25 +172,37 @@ state_machine.start()
 
 ## 🛠 How-to Guides
 
-### Expose Over HTTP with FastAPI
+### Expose Over RPC with VentionApp
 
 ```python
-from fastapi import FastAPI
-from state_machine.router import build_router
+from communication.app import VentionApp
+from state_machine.vention_communication import build_state_machine_bundle
 from state_machine.core import StateMachine
 
 state_machine = StateMachine(...)
 state_machine.start()
 
-app = FastAPI()
-app.include_router(build_router(state_machine))
+app = VentionApp(name="MyApp")
+bundle = build_state_machine_bundle(state_machine)
+app.register_rpc_plugin(bundle)
+app.finalize()
 ```
 
-**Endpoints:**
-- `GET /state` → Current state
-- `GET /history` → Transition history
-- `POST /<trigger>` → Trigger a transition
-- `GET /diagram.svg` → Graphviz diagram
+**RPC Actions:**
+- `GetState` → Returns current state and last known state
+- `GetHistory` → Returns transition history with timestamps
+- `Trigger_<TriggerName>` → Triggers a state transition (e.g., `Trigger_Start`, `Trigger_Activate`)
+
+**Options:**
+```python
+# Customize which actions are included
+bundle = build_state_machine_bundle(
+    state_machine,
+    include_state_actions=True,  # Include GetState
+    include_history_action=True,  # Include GetHistory
+    triggers=["start", "activate"],  # Only include specific triggers
+)
+```
 
 ### Timeout Example
 
@@ -369,24 +362,28 @@ Guard transition; blocks if function returns False.
 **`@on_state_change`**
 Global callback `(old_state, new_state, trigger)` fired after each transition.
 
-### Router
+### RPC Bundle
 
 ```python
-def build_router(
-    machine: StateMachine,
-    triggers: Optional[list[Trigger]] = None
-) -> fastapi.APIRouter
+def build_state_machine_bundle(
+    sm: StateMachine,
+    *,
+    include_state_actions: bool = True,
+    include_history_action: bool = True,
+    triggers: Optional[Sequence[str]] = None,
+) -> RpcBundle
 ```
 
-Exposes endpoints:
-- `GET /state`
-- `GET /history`
-- `POST /<trigger>`
-- `GET /diagram.svg`
+Builds an RPC bundle exposing the state machine via Connect-style RPCs:
+- `GetState` - Returns current and last known state
+- `GetHistory` - Returns transition history
+- `Trigger_<TriggerName>` - One RPC per trigger (PascalCase naming)
+
+The bundle can be registered with a `VentionApp` using `app.register_rpc_plugin(bundle)`.
 
 ## 🔍 Troubleshooting & FAQ
 
-- **Diagram endpoint returns 503** → Graphviz not installed.
 - **Transitions blocked unexpectedly** → Check guard conditions.
 - **Callbacks not firing** → Only successful transitions trigger them.
 - **State not restored after restart** → Ensure `enable_last_state_recovery=True`.
+- **RPC actions not available** → Ensure `app.finalize()` is called after registering bundles.

vention_state_machine-0.4.2/pyproject.toml

@@ -0,0 +1,127 @@
+[tool.poetry]
+name = "vention-state-machine"
+version = "0.4.2"
+description = "Declarative state machine framework for machine apps"
+authors = [ "VentionCo" ]
+readme = "README.md"
+license = "Proprietary"
+
+  [[tool.poetry.packages]]
+  include = "state_machine"
+  from = "src"
+
+  [tool.poetry.dependencies]
+  python = ">=3.10,<3.11"
+
+    [tool.poetry.dependencies.annotated-doc]
+    version = "0.0.4"
+    markers = 'python_version == "3.10"'
+    optional = false
+
+    [tool.poetry.dependencies.annotated-types]
+    version = "0.7.0"
+    markers = 'python_version == "3.10"'
+    optional = false
+
+    [tool.poetry.dependencies.anyio]
+    version = "4.11.0"
+    markers = 'python_version == "3.10"'
+    optional = false
+
+    [tool.poetry.dependencies.asyncio]
+    version = "3.4.3"
+    markers = 'python_version == "3.10"'
+    optional = false
+
+    [tool.poetry.dependencies.click]
+    version = "8.1.8"
+    markers = 'python_version == "3.10"'
+    optional = false
+
+    [tool.poetry.dependencies.colorama]
+    version = "0.4.6"
+    markers = 'python_version == "3.10" and platform_system == "Windows"'
+    optional = false
+
+    [tool.poetry.dependencies.coverage]
+    version = "7.10.7"
+    markers = 'python_version == "3.10"'
+    optional = false
+
+    [tool.poetry.dependencies.exceptiongroup]
+    version = "1.3.0"
+    markers = 'python_version == "3.10"'
+    optional = false
+
+    [tool.poetry.dependencies.fastapi]
+    version = "0.121.1"
+    markers = 'python_version == "3.10"'
+    optional = false
+
+    [tool.poetry.dependencies.graphviz]
+    version = "0.21"
+    markers = 'python_version == "3.10"'
+    optional = false
+
+    [tool.poetry.dependencies.h11]
+    version = "0.16.0"
+    markers = 'python_version == "3.10"'
+    optional = false
+
+    [tool.poetry.dependencies.idna]
+    version = "3.11"
+    markers = 'python_version == "3.10"'
+    optional = false
+
+    [tool.poetry.dependencies.pydantic-core]
+    version = "2.41.4"
+    markers = 'python_version == "3.10"'
+    optional = false
+
+    [tool.poetry.dependencies.pydantic]
+    version = "2.12.3"
+    markers = 'python_version == "3.10"'
+    optional = false
+
+    [tool.poetry.dependencies.six]
+    version = "1.17.0"
+    markers = 'python_version == "3.10"'
+    optional = false
+
+    [tool.poetry.dependencies.sniffio]
+    version = "1.3.1"
+    markers = 'python_version == "3.10"'
+    optional = false
+
+    [tool.poetry.dependencies.starlette]
+    version = "0.48.0"
+    markers = 'python_version == "3.10"'
+    optional = false
+
+    [tool.poetry.dependencies.transitions]
+    version = "0.9.3"
+    markers = 'python_version == "3.10"'
+    optional = false
+
+    [tool.poetry.dependencies.typing-extensions]
+    version = "4.15.0"
+    markers = 'python_version == "3.10"'
+    optional = false
+
+    [tool.poetry.dependencies.typing-inspection]
+    version = "0.4.2"
+    markers = 'python_version == "3.10"'
+    optional = false
+
+    [tool.poetry.dependencies.uvicorn]
+    version = "0.35.0"
+    markers = 'python_version == "3.10"'
+    optional = false
+
+    [tool.poetry.dependencies.vention-communication]
+    version = "0.3.0"
+    markers = 'python_version == "3.10"'
+    optional = false
+
+[tool.poetry.group.dev]
+dependencies = { }

{vention_state_machine-0.3.1 → vention_state_machine-0.4.2}/src/state_machine/core.py

@@ -58,19 +58,12 @@ class StateMachine(HierarchicalGraphMachine):
     ) -> None:
         # Normalize state definitions
         if is_state_container(states):
-            state_groups = [
-                value
-                for value in vars(states).values()
-                if isinstance(value, StateGroup)
-            ]
+            state_groups = [value for value in vars(states).values() if isinstance(value, StateGroup)]
             resolved_states = [group.to_state_list()[0] for group in state_groups]
         elif isinstance(states, list):
             resolved_states = states
         else:
-            raise TypeError(
-                f"`states` must be either a StateGroup container or a list of state dicts. "
-                f"Got: {type(states).__name__}"
-            )
+            raise TypeError(f"`states` must be either a StateGroup container or a list of state dicts. " f"Got: {type(states).__name__}")
 
         self._declared_states: list[dict[str, Any]] = resolved_states
 
@@ -95,9 +88,7 @@ class StateMachine(HierarchicalGraphMachine):
         self._timeouts: dict[str, asyncio.Task[Any]] = {}
         self._last_state: Optional[str] = None
         self._enable_recovery: bool = enable_last_state_recovery
-        self._history: deque[dict[str, Any]] = deque(
-            maxlen=history_size or self.DEFAULT_HISTORY_SIZE
-        )
+        self._history: deque[dict[str, Any]] = deque(maxlen=history_size or self.DEFAULT_HISTORY_SIZE)
         self._current_start: Optional[datetime] = None
         self._guard_conditions: dict[str, List[Callable[[], bool]]] = {}
         self._state_change_callbacks: List[Callable[[str, str, str], None]] = []
@@ -110,9 +101,7 @@ class StateMachine(HierarchicalGraphMachine):
             BaseStates.FAULT.value,
             before="cancel_tasks",
         )
-        self.add_transition(
-            BaseTriggers.RESET.value, BaseStates.FAULT.value, BaseStates.READY.value
-        )
+        self.add_transition(BaseTriggers.RESET.value, BaseStates.FAULT.value, BaseStates.READY.value)
         self._attach_after_hooks()
         self._add_guard_conditions_to_transitions()
 
@@ -137,9 +126,7 @@ class StateMachine(HierarchicalGraphMachine):
             except asyncio.CancelledError:
                 pass
 
-    def set_timeout(
-        self, state_name: str, seconds: float, trigger_fn: Callable[[], str]
-    ) -> None:
+    def set_timeout(self, state_name: str, seconds: float, trigger_fn: Callable[[], str]) -> None:
         """
         Schedule a timeout: if `state_name` remains active after `seconds`, fire `trigger_fn()`.
         """
@@ -191,9 +178,7 @@ class StateMachine(HierarchicalGraphMachine):
         """Get the last `n` history entries."""
         return list(self._history)[-n:] if n > 0 else []
 
-    def add_transition_condition(
-        self, trigger_name: str, condition_fn: Callable[[], bool]
-    ) -> None:
+    def add_transition_condition(self, trigger_name: str, condition_fn: Callable[[], bool]) -> None:
         """
         Add a guard condition to a transition trigger.
         Multiple conditions can be added for the same trigger - ALL must pass for the transition to be allowed.
@@ -202,9 +187,7 @@ class StateMachine(HierarchicalGraphMachine):
             self._guard_conditions[trigger_name] = []
         self._guard_conditions[trigger_name].append(condition_fn)
 
-    def add_state_change_callback(
-        self, callback: Callable[[str, str, str], None]
-    ) -> None:
+    def add_state_change_callback(self, callback: Callable[[str, str, str], None]) -> None:
         """
         Add a callback that fires on any state change.
 

{vention_state_machine-0.3.1 → vention_state_machine-0.4.2}/src/state_machine/decorator_manager.py

@@ -38,14 +38,10 @@ class DecoratorManager:
     def _discover_state_callbacks(self, callback_fn: Any) -> None:
         """Discover on_enter_state and on_exit_state decorators."""
         if hasattr(callback_fn, "_on_enter_state"):
-            self._decorator_bindings.append(
-                (callback_fn._on_enter_state, "enter", callback_fn)
-            )
+            self._decorator_bindings.append((callback_fn._on_enter_state, "enter", callback_fn))
 
         if hasattr(callback_fn, "_on_exit_state"):
-            self._exit_decorator_bindings.append(
-                (callback_fn._on_exit_state, "exit", callback_fn)
-            )
+            self._exit_decorator_bindings.append((callback_fn._on_exit_state, "exit", callback_fn))
 
     def _discover_guard_conditions(self, callback_fn: Any) -> None:
         """Discover guard decorators."""
@@ -70,9 +66,7 @@ class DecoratorManager:
 
     def _bind_state_callbacks(self, instance: Any) -> None:
         """Bind state entry/exit callbacks."""
-        for state_name, hook_type, callback_fn in (
-            self._decorator_bindings + self._exit_decorator_bindings
-        ):
+        for state_name, hook_type, callback_fn in self._decorator_bindings + self._exit_decorator_bindings:
             bound_fn = callback_fn.__get__(instance)
 
             if hook_type == "enter" and hasattr(callback_fn, "_timeout_config"):

{vention_state_machine-0.3.1 → vention_state_machine-0.4.2}/src/state_machine/decorators.py

@@ -54,9 +54,7 @@ def on_exit_state(
     return decorator
 
 
-def auto_timeout(
-    seconds: float, trigger: Union[str, Callable[[], str]] = "to_fault"
-) -> Callable[[CallableType], CallableType]:
+def auto_timeout(seconds: float, trigger: Union[str, Callable[[], str]] = "to_fault") -> Callable[[CallableType], CallableType]:
     """
     Decorator that applies an auto-timeout configuration to a state entry handler.
     """
@@ -90,11 +88,7 @@ def guard(
             guard_fn._guard_conditions = {}
 
         for trigger in triggers:
-            trigger_name = (
-                getattr(trigger, "name", trigger)
-                if hasattr(trigger, "name")
-                else trigger
-            )
+            trigger_name = getattr(trigger, "name", trigger) if hasattr(trigger, "name") else trigger
             if not isinstance(trigger_name, str):
                 raise TypeError(f"Expected a Trigger or str, got {type(trigger)}")
 

{vention_state_machine-0.3.1 → vention_state_machine-0.4.2}/src/state_machine/defs.py

@@ -88,9 +88,7 @@ class Trigger:
     def __call__(self) -> str:
         return self.name
 
-    def transition(
-        self, source: Union[str, State], dest: Union[str, State]
-    ) -> Dict[str, str]:
+    def transition(self, source: Union[str, State], dest: Union[str, State]) -> Dict[str, str]:
         """
         Build {"trigger": self.name, "source": <src>, "dest": <dst>}.
         `source` / `dest` may be raw strings or StateKey instances.

{vention_state_machine-0.3.1 → vention_state_machine-0.4.2}/src/state_machine/machine_protocols.py

@@ -2,9 +2,7 @@ from typing import Protocol, Callable, Any
 
 
 class SupportsTimeout(Protocol):
-    def set_timeout(
-        self, state_name: str, seconds: float, trigger_fn: Callable[[], str]
-    ) -> None: ...
+    def set_timeout(self, state_name: str, seconds: float, trigger_fn: Callable[[], str]) -> None: ...
 
 
 class SupportsStateCallbacks(Protocol):
@@ -12,15 +10,11 @@ class SupportsStateCallbacks(Protocol):
 
 
 class SupportsGuardConditions(Protocol):
-    def add_transition_condition(
-        self, trigger_name: str, condition_fn: Callable[[], bool]
-    ) -> None: ...
+    def add_transition_condition(self, trigger_name: str, condition_fn: Callable[[], bool]) -> None: ...
 
 
 class SupportsStateChangeCallbacks(Protocol):
-    def add_state_change_callback(
-        self, callback: Callable[[str, str, str], None]
-    ) -> None: ...
+    def add_state_change_callback(self, callback: Callable[[str, str, str], None]) -> None: ...
 
 
 class StateMachineProtocol(

{vention_state_machine-0.3.1 → vention_state_machine-0.4.2}/src/state_machine/utils.py

@@ -1,4 +1,6 @@
-from typing import Any, Callable, Union
+from datetime import datetime
+from typing import Any, Callable, Optional, Union
+from pydantic import BaseModel
 from state_machine.defs import StateGroup
 
 
@@ -46,11 +48,32 @@ def is_state_container(state_source: object) -> bool:
     Return True if `obj` is an instance or class that contains StateGroup(s).
     """
     try:
-        return any(
-            isinstance(value, StateGroup) for value in vars(state_source).values()
-        ) or any(
-            isinstance(value, StateGroup)
-            for value in vars(state_source.__class__).values()
+        return any(isinstance(value, StateGroup) for value in vars(state_source).values()) or any(
+            isinstance(value, StateGroup) for value in vars(state_source.__class__).values()
         )
     except TypeError:
         return False
+
+
+# Shared schema definitions for REST and RPC endpoints
+# (camelCase aliases applied automatically by registry)
+class StateResponse(BaseModel):
+    state: str
+    last_state: Optional[str] = None
+
+
+class HistoryEntry(BaseModel):
+    timestamp: datetime
+    state: str
+    duration_ms: Optional[int] = None
+
+
+class HistoryResponse(BaseModel):
+    history: list[HistoryEntry]
+    buffer_size: int
+
+
+class TriggerResponse(BaseModel):
+    result: str
+    previous_state: str
+    new_state: str

vention_state_machine-0.4.2/src/state_machine/vention_communication.py

@@ -0,0 +1,164 @@
+from __future__ import annotations
+
+import inspect
+from datetime import datetime
+from typing import Any, Callable, Coroutine, Optional, Sequence
+
+from communication.entries import RpcBundle, ActionEntry
+from communication.errors import ConnectError
+from state_machine.core import StateMachine
+from state_machine.utils import (
+    StateResponse,
+    HistoryResponse,
+    HistoryEntry,
+    TriggerResponse,
+)
+
+
+__all__ = ["build_state_machine_rpc_bundle"]
+
+
+def build_state_machine_rpc_bundle(
+    state_machine: StateMachine,
+    *,
+    include_state_actions: bool = True,
+    include_history_action: bool = True,
+    triggers: Optional[Sequence[str]] = None,
+) -> RpcBundle:
+    """
+    Build and return an RpcBundle exposing a StateMachine instance.
+
+    Provides unary RPCs:
+
+      - GetState
+      - GetHistory
+      - Trigger_<TriggerName> (one per trigger)
+
+    For integration via app.extend_bundle(bundle).
+    """
+    bundle = RpcBundle()
+
+    # ======================================================
+    # GetState
+    # ======================================================
+    if include_state_actions:
+
+        async def get_state() -> StateResponse:
+            last = getattr(state_machine, "get_last_state", lambda: None)()
+            return StateResponse(state=state_machine.state, last_state=last)
+
+        bundle.actions.append(
+            ActionEntry(
+                name="GetState",
+                func=get_state,
+                input_type=None,
+                output_type=StateResponse,
+            )
+        )
+
+    # ======================================================
+    # GetHistory
+    # ======================================================
+    if include_history_action:
+
+        async def get_history() -> HistoryResponse:
+            raw = getattr(state_machine, "history", [])
+            out = []
+
+            for item in raw:
+                if isinstance(item, dict):
+                    state_str = str(item.get("state", ""))
+                    duration_ms: Optional[int] = item.get("duration_ms")
+                    if duration_ms is not None and not isinstance(duration_ms, int):
+                        duration_ms = None
+                    timestamp: datetime
+                    if "timestamp" in item and isinstance(item["timestamp"], datetime):
+                        timestamp = item["timestamp"]
+                    else:
+                        timestamp = datetime.now()
+                    out.append(
+                        HistoryEntry(
+                            state=state_str,
+                            timestamp=timestamp,
+                            duration_ms=duration_ms,
+                        )
+                    )
+                else:
+                    out.append(HistoryEntry(state=str(item), timestamp=datetime.now()))
+
+            return HistoryResponse(history=out, buffer_size=len(raw))
+
+        bundle.actions.append(
+            ActionEntry(
+                name="GetHistory",
+                func=get_history,
+                input_type=None,
+                output_type=HistoryResponse,
+            )
+        )
+
+    # ======================================================
+    # Triggers
+    # ======================================================
+    # Source of truth: transitions registered on state machine
+    all_triggers = sorted(state_machine.events.keys())
+    selected = all_triggers if triggers is None else list(triggers)
+
+    # ---------- factory function (fixes closure bug) ----------
+    def make_trigger_handler(
+        trigger_name: str,
+    ) -> Callable[[], Coroutine[Any, Any, TriggerResponse]]:
+        async def trigger_call() -> TriggerResponse:
+            current = state_machine.state
+            allowed = state_machine.get_triggers(current)
+
+            # Precondition error if invalid in current state
+            if trigger_name not in allowed:
+                raise ConnectError(
+                    code="failed_precondition",
+                    message=(f"Trigger '{trigger_name}' cannot run from '{current}'. " f"Allowed: {sorted(allowed)}"),
+                )
+
+            # Fetch bound trigger method
+            try:
+                method = getattr(state_machine, trigger_name)
+            except AttributeError as e:
+                raise ConnectError(
+                    code="internal",
+                    message=f"StateMachine missing trigger '{trigger_name}'",
+                ) from e
+
+            # Execute trigger (sync or async)
+            try:
+                result = method()
+                if inspect.isawaitable(result):
+                    await result
+            except Exception as e:
+                raise ConnectError(
+                    code="internal",
+                    message=f"Trigger '{trigger_name}' failed: {e}",
+                ) from e
+
+            return TriggerResponse(
+                result=trigger_name,
+                previous_state=current,
+                new_state=state_machine.state,
+            )
+
+        return trigger_call
+
+    # ---------- register each trigger ----------
+    for trig in selected:
+        rpc_name = f"Trigger_{trig[0].upper()}{trig[1:]}"  # PascalCase RPC names
+        handler = make_trigger_handler(trig)
+
+        bundle.actions.append(
+            ActionEntry(
+                name=rpc_name,
+                func=handler,
+                input_type=None,
+                output_type=TriggerResponse,
+            )
+        )
+
+    return bundle

vention_state_machine-0.3.1/pyproject.toml

@@ -1,26 +0,0 @@
-[tool.poetry]
-name = "vention-state-machine"
-version = "0.3.1"
-description = "Declarative state machine framework for machine apps"
-authors = [ "VentionCo" ]
-readme = "README.md"
-license = "Proprietary"
-packages = [{ include = "state_machine", from = "src" }]
-
-[tool.poetry.dependencies]
-asyncio = "^3.4.3"
-python = ">=3.10,<3.11"
-fastapi = "0.121.1"
-uvicorn = "^0.35.0"
-transitions = "^0.9.3"
-graphviz = "^0.21"
-coverage = "^7.10.1"
-httpx = "^0.28.1"
-
-[tool.poetry.group.dev.dependencies]
-pytest = "^8.3.4"
-ruff = "^0.8.0"
-
-[build-system]
-requires = [ "poetry-core>=1.0.0,<2.0.0" ]
-build-backend = "poetry.core.masonry.api"

vention_state_machine-0.3.1/src/state_machine/router.py

@@ -1,181 +0,0 @@
-import asyncio
-from datetime import datetime
-from typing import Optional, Sequence, Union, cast
-from fastapi import APIRouter, HTTPException, Response, status
-from typing_extensions import TypedDict, NotRequired
-from state_machine.core import StateMachine
-from state_machine.defs import Trigger
-
-
-# ----------- TypedDict response models -----------
-
-
-class StateResponse(TypedDict):
-    state: str
-    last_state: Optional[str]
-
-
-class HistoryEntry(TypedDict):
-    timestamp: datetime
-    state: str
-    duration_ms: NotRequired[int]
-
-
-class HistoryResponse(TypedDict):
-    history: list[HistoryEntry]
-    buffer_size: int
-
-
-class TriggerResponse(TypedDict):
-    result: str
-    previous_state: str
-    new_state: str
-
-
-# ----------- Router setup -----------
-
-
-def build_router(
-    state_machine: StateMachine,
-    triggers: Optional[Sequence[Union[str, Trigger]]] = None,
-) -> APIRouter:
-    """
-    Create an APIRouter for a given state_machine instance.
-
-    Routes:
-    - GET /state → current state and last known state
-    - GET /history → transition history
-    - POST /<trigger> → trigger transition (e.g., /start)
-    """
-    router = APIRouter()
-
-    _register_basic_routes(router, state_machine)
-    resolved_triggers = _resolve_triggers(state_machine, triggers)
-    for trigger in resolved_triggers:
-        _add_trigger_route(router, state_machine, trigger)
-
-    return router
-
-
-# ----------- Basic routes -----------
-
-
-def _register_basic_routes(router: APIRouter, state_machine: StateMachine) -> None:
-    @router.get("/state", response_model=StateResponse)
-    def get_state() -> StateResponse:
-        """Return current and last known state."""
-        return {
-            "state": state_machine.state,
-            "last_state": state_machine.get_last_state(),
-        }
-
-    @router.get("/history", response_model=HistoryResponse)
-    def get_history(last_n_entries: Optional[int] = None) -> HistoryResponse:
-        """
-        Return transition history. If `last_n_entries` is provided and non-negative,
-        returns only the most recent N entries. Otherwise returns the full buffer.
-        """
-        if last_n_entries is not None and last_n_entries < 0:
-            data = []
-        else:
-            data = (
-                state_machine.get_last_history_entries(last_n_entries)
-                if last_n_entries is not None
-                else state_machine.history
-            )
-        return {
-            "history": cast(list[HistoryEntry], data),
-            "buffer_size": len(state_machine.history),
-        }
-
-    @router.get("/diagram.svg", response_class=Response)
-    def get_svg() -> Response:
-        try:
-            graph = state_machine.get_graph()
-            svg_bytes = graph.pipe(format="svg")
-            return Response(content=svg_bytes, media_type="image/svg+xml")
-        except Exception as e:
-            msg = str(e).lower()
-            if "executable" in msg or "dot not found" in msg or "graphviz" in msg:
-                raise HTTPException(
-                    status_code=503,
-                    detail=(
-                        "Graphviz is required to render the diagram. "
-                        "Install the system package via brew or apt) "
-                    ),
-                )
-            raise
-
-
-# ----------- Trigger resolution -----------
-
-
-def _resolve_triggers(
-    state_machine: StateMachine,
-    triggers: Optional[Sequence[Union[str, Trigger]]],
-) -> list[str]:
-    """Resolve and validate trigger names."""
-    if triggers is None:
-        return sorted(state_machine.events.keys())
-
-    resolved = []
-    for trigger in triggers:
-        trigger_name = trigger.name if isinstance(trigger, Trigger) else trigger
-        if trigger_name not in state_machine.events:
-            raise ValueError(f"Unknown trigger: '{trigger_name}'")
-        resolved.append(trigger_name)
-
-    return resolved
-
-
-# ----------- Trigger route generation -----------
-
-
-def _add_trigger_route(
-    router: APIRouter,
-    state_machine: StateMachine,
-    trigger: str,
-) -> None:
-    """Add a single trigger route to the router."""
-
-    async def trigger_handler() -> TriggerResponse:
-        previous_state = state_machine.state
-
-        available_triggers = state_machine.get_triggers(previous_state)
-        if trigger not in available_triggers:
-            raise HTTPException(
-                status_code=status.HTTP_409_CONFLICT,
-                detail=f"Trigger '{trigger}' not allowed from state '{previous_state}'. "
-                f"Available triggers: {sorted(available_triggers)}",
-            )
-
-        try:
-            method = getattr(state_machine, trigger)
-            result = method()
-            if asyncio.iscoroutine(result):
-                await result
-
-            return {
-                "result": trigger,
-                "previous_state": previous_state,
-                "new_state": state_machine.state,
-            }
-
-        except AttributeError:
-            raise HTTPException(
-                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-                detail=f"Trigger method '{trigger}' not found on state machine",
-            )
-        except Exception as e:
-            raise HTTPException(
-                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-                detail=f"Error executing trigger '{trigger}': {str(e)}",
-            )
-
-    router.add_api_route(
-        path=f"/{trigger}",
-        endpoint=trigger_handler,
-        methods=["POST"],
-        name=f"{trigger}_trigger",
-        response_model=TriggerResponse,
-    )