statable 3.1.0__py3-none-any.whl

statable/shared/role_function_library.py

@@ -0,0 +1,150 @@
+# statable/shared/role_function_library.py
+"""
+Shared role function library
+
+Version History
+---------------
+v1.0  - Initial shared library.
+v1.5  - Added reserved signature fields
+        (return_type / arg1_type / arg1_name / arg2_type / arg2_name).
+        These are not used by the code generator (its C signature is
+        fixed), and they are not exposed in the GUI. They are kept
+        here only so that XML I/O round-trips old project files
+        (tests/data/v22_features_test3.xml) without canonical
+        differences. See xml_io.py v3.8.2.
+"""
+
+from dataclasses import dataclass, field
+from typing import List, Dict, Optional
+
+
+@dataclass
+class RoleFunction:
+    """Shared role function definition.
+
+    namespace: layer name / feature group name (e.g., "Driver")
+      - Referenceable as `Driver.Init`
+      - Empty string means no layer
+
+    [v1.5]
+      Reserved signature fields are present but not used:
+        * return_type / arg1_type / arg1_name / arg2_type / arg2_name
+      Their only purpose is XML round-trip preservation.
+    """
+    name: str
+    namespace: str = ""
+    description: str = ""
+    title: str = ""
+    # [v1.5] Reserved signature fields (not exposed in GUI,
+    #        not consumed by codegen; preserved for XML round-trip).
+    return_type: str = ""
+    arg1_type: str = ""
+    arg1_name: str = ""
+    arg2_type: str = ""
+    arg2_name: str = ""
+    # [v1.4] GUI symbol tracking
+    used_global_vars: List[str] = field(default_factory=list)
+    used_events: List[str] = field(default_factory=list)
+    used_literals: List[str] = field(default_factory=list)
+
+    def __post_init__(self):
+        if not self.title:
+            self.title = self.qualified_name
+
+    @property
+    def qualified_name(self) -> str:
+        """GUI display name: 'Driver.Init' or 'Init'"""
+        if self.namespace:
+            return f"{self.namespace}.{self.name}"
+        return self.name
+
+    def to_dict(self) -> dict:
+        return {
+            'name': self.name,
+            'namespace': self.namespace,
+            'description': self.description,
+            'title': self.title,
+            # [v1.5] Reserved signature fields
+            'return_type': self.return_type,
+            'arg1_type': self.arg1_type,
+            'arg1_name': self.arg1_name,
+            'arg2_type': self.arg2_type,
+            'arg2_name': self.arg2_name,
+            # [v1.4] symbol references
+            'used_global_vars': list(self.used_global_vars),
+            'used_events': list(self.used_events),
+            'used_literals': list(self.used_literals),
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> 'RoleFunction':
+        return cls(
+            name=data.get('name', ''),
+            namespace=data.get('namespace', ''),
+            description=data.get('description', ''),
+            title=data.get('title', ''),
+            return_type=data.get('return_type', ''),
+            arg1_type=data.get('arg1_type', ''),
+            arg1_name=data.get('arg1_name', ''),
+            arg2_type=data.get('arg2_type', ''),
+            arg2_name=data.get('arg2_name', ''),
+            used_global_vars=list(data.get('used_global_vars', [])),
+            used_events=list(data.get('used_events', [])),
+            used_literals=list(data.get('used_literals', [])),
+        )
+
+
+class RoleFunctionLibrary:
+    """Role function library shared across the project"""
+
+    def __init__(self):
+        self.role_functions: Dict[str, RoleFunction] = {}
+
+    def _key(self, rf: RoleFunction) -> str:
+        """Unique key in the library: 'Driver.Init'"""
+        return rf.qualified_name
+
+    def add(self, rf: RoleFunction):
+        key = self._key(rf)
+        if key in self.role_functions:
+            raise ValueError(f"Role function '{key}' already exists")
+        self.role_functions[key] = rf
+
+    def remove(self, name: str):
+        """name can be either qualified_name or a bare name"""
+        if name in self.role_functions:
+            del self.role_functions[name]
+            return
+        # Search by bare name
+        for key, rf in list(self.role_functions.items()):
+            if rf.name == name:
+                del self.role_functions[key]
+                return
+
+    def get(self, name: str) -> Optional[RoleFunction]:
+        """name can be either qualified_name or a bare name"""
+        if name in self.role_functions:
+            return self.role_functions[name]
+        for rf in self.role_functions.values():
+            if rf.name == name:
+                return rf
+        return None
+
+    def list_all(self) -> List[RoleFunction]:
+        return list(self.role_functions.values())
+
+    def to_dict(self) -> dict:
+        return {
+            'role_functions': [rf.to_dict() for rf in self.role_functions.values()]
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> 'RoleFunctionLibrary':
+        lib = cls()
+        for item in data.get('role_functions', []):
+            rf = RoleFunction.from_dict(item)
+            try:
+                lib.add(rf)
+            except ValueError:
+                pass  # Duplicates ignored
+        return lib

statable/state_machine.py

@@ -0,0 +1,121 @@
+# statable/state_machine.py
+from typing import Dict, List, Optional, Tuple
+
+from .model import (
+    State, Event, Transition, RoleFunction,
+    ActionStep, TransitionRelation,
+)
+
+
+class StateMachine:
+    def __init__(self):
+        self.states: Dict[str, State] = {}
+        self.events: Dict[str, Event] = {}
+        self.transitions: List[Transition] = []
+        self.role_functions: Dict[str, RoleFunction] = {}
+        self.initial_state: Optional[str] = None
+
+        # Layer settings
+        self.layer_priority: int = 5
+        self.layer_description: str = ""
+        self.layer_name: str = ""
+
+        # === v2.2: per-cell metadata ===
+        # Key: (source_state_name, event_name)
+        # Note: event_name may be "" for completion transitions.
+        self.cell_actions: Dict[Tuple[str, str], List[ActionStep]] = {}
+        self.cell_relations: Dict[Tuple[str, str], List[TransitionRelation]] = {}
+
+    # ------------------------------------------------------------------
+    # Existing API (unchanged)
+    # ------------------------------------------------------------------
+    def add_state(self, state: State):
+        if state.name in self.states:
+            raise ValueError(f"State '{state.name}' already exists")
+        self.states[state.name] = state
+
+    def add_event(self, event: Event):
+        if event.name in self.events:
+            raise ValueError(f"Event '{event.name}' already exists")
+        self.events[event.name] = event
+
+    def remove_event(self, name: str):
+        if name in self.events:
+            del self.events[name]
+        self.transitions = [t for t in self.transitions if t.event != name]
+        # v2.2: drop cell metadata that referenced this event
+        for key in [k for k in self.cell_actions if k[1] == name]:
+            del self.cell_actions[key]
+        for key in [k for k in self.cell_relations if k[1] == name]:
+            del self.cell_relations[key]
+
+    def add_transition(self, trans: Transition):
+        if trans.source not in self.states:
+            raise ValueError(f"Source state '{trans.source}' not defined")
+        if trans.target and trans.target not in self.states:
+            raise ValueError(f"Target state '{trans.target}' not defined")
+        if trans.event and trans.event not in self.events:
+            raise ValueError(f"Event '{trans.event}' not defined")
+        self.transitions.append(trans)
+
+    def remove_transition(self, trans: Transition):
+        if trans in self.transitions:
+            self.transitions.remove(trans)
+
+    def set_initial(self, state_name: str):
+        if state_name not in self.states:
+            raise ValueError(f"State '{state_name}' not defined")
+        self.initial_state = state_name
+
+    def add_role_function(self, rf: RoleFunction):
+        if rf.name in self.role_functions:
+            raise ValueError(f"Role function '{rf.name}' already exists")
+        self.role_functions[rf.name] = rf
+
+    def remove_role_function(self, name: str):
+        if name in self.role_functions:
+            del self.role_functions[name]
+
+    def get_transitions_for_cell(self, source: str, event: str) -> List[Transition]:
+        return [t for t in self.transitions
+                if t.source == source and t.event == event]
+
+    def get_transitions_for_event(self, event: str) -> List[Transition]:
+        return [t for t in self.transitions if t.event == event]
+
+    # ------------------------------------------------------------------
+    # v2.2: cell action / relation accessors
+    # ------------------------------------------------------------------
+    def get_actions_for_cell(self, source: str, event: str) -> List[ActionStep]:
+        return self.cell_actions.get((source, event), [])
+
+    def set_actions_for_cell(self, source: str, event: str,
+                              actions: List[ActionStep]) -> None:
+        key = (source, event)
+        if actions:
+            self.cell_actions[key] = list(actions)
+        else:
+            self.cell_actions.pop(key, None)
+
+    def get_relations_for_cell(self, source: str, event: str
+                                ) -> List[TransitionRelation]:
+        return self.cell_relations.get((source, event), [])
+
+    def set_relations_for_cell(self, source: str, event: str,
+                                relations: List[TransitionRelation]) -> None:
+        key = (source, event)
+        if relations:
+            self.cell_relations[key] = list(relations)
+        else:
+            self.cell_relations.pop(key, None)
+
+    def get_cell_keys(self) -> List[Tuple[str, str]]:
+        """All (source, event) keys that have actions or relations."""
+        keys = set(self.cell_actions.keys()) | set(self.cell_relations.keys())
+        return sorted(keys)
+
+    def remove_cell_metadata(self, source: str, event: str) -> None:
+        """Remove all cell-level actions / relations for the given cell."""
+        key = (source, event)
+        self.cell_actions.pop(key, None)
+        self.cell_relations.pop(key, None)