statable 3.1.0__py3-none-any.whl

codegen/validate/items/__init__.py

@@ -0,0 +1,30 @@
+# codegen/validate/items/__init__.py
+"""Validator items package."""
+
+from .base_validator import BaseValidator
+from .state_validator import StateValidator
+from .event_validator import EventValidator
+from .transition_validator import TransitionValidator
+from .role_function_validator import RoleFunctionValidator
+from .variable_validator import VariableValidator
+from .flag_validator import FlagValidator
+from .queue_validator import QueueValidator
+from .interrupt_validator import InterruptValidator
+from .timer_validator import TimerValidator
+from .custom_type_validator import CustomTypeValidator
+from .cell_validator import CellValidator
+
+__all__ = [
+    'BaseValidator',
+    'StateValidator',
+    'EventValidator',
+    'TransitionValidator',
+    'RoleFunctionValidator',
+    'VariableValidator',
+    'FlagValidator',
+    'QueueValidator',
+    'InterruptValidator',
+    'TimerValidator',
+    'CustomTypeValidator',
+    'CellValidator',
+]

codegen/validate/items/base_validator.py

@@ -0,0 +1,25 @@
+# codegen/validate/items/base_validator.py
+"""\nValidator base class\n"""
+
+import sys
+import os
+from typing import List
+
+sys.path.append(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
+
+from ..models import ValidationIssue, ValidationContext
+
+
+class BaseValidator:
+    """Validator base class"""
+    
+    category: str = ""
+    rules = {}
+    
+    def validate(self, context: ValidationContext) -> List[ValidationIssue]:
+        issues = []
+        for code, rule_func in self.rules.items():
+            result = rule_func(context)
+            if result:
+                issues.extend(result)
+        return issues

codegen/validate/items/cell_validator.py

@@ -0,0 +1,275 @@
+# codegen/validate/items/cell_validator.py
+"""Cell-level validator (v2.2) - integrated into the validate layer.
+
+Rules:
+  CELL_EMPTY_CONDITION        (Warning) condition empty AND target empty
+  CELL_DUPLICATE_LABEL        (Error)   same label within one cell
+  CELL_DANGLING_RELATION      (Error)   relation members referencing missing labels
+  CELL_UNREACHABLE_TRANSITION (Warning) transition after a Commit+else
+  CELL_OVERLAP_POSSIBLE       (Warning) duplicate condition strings in one cell
+  CELL_DUPLICATE_TARGET       (Info)    multiple transitions targeting the same state
+  CELL_EXCLUSIVE_NO_RETURN    (Info)    exclusive member without early_return
+  CELL_EMPTY_TARGET           (Warning) target empty AND early_return False
+"""
+
+import logging
+from typing import List
+
+from ..models import (
+    ValidationIssue, ValidationSeverity, ValidationContext,
+)
+from ..data.validation_rules import VALIDATION_RULES
+from .base_validator import BaseValidator
+
+logger = logging.getLogger("validate.cell_validator")
+
+
+class CellValidator(BaseValidator):
+    """Validates each (source, event) cell of a StateMachine."""
+
+    category = "cell"
+
+    def __init__(self):
+        self.rules_data = VALIDATION_RULES.get(self.category, {})
+        self.rules = {
+            "CELL_EMPTY_CONDITION":        self._rule_empty_condition,
+            "CELL_DUPLICATE_LABEL":        self._rule_duplicate_label,
+            "CELL_DANGLING_RELATION":      self._rule_dangling_relation,
+            "CELL_UNREACHABLE_TRANSITION": self._rule_unreachable,
+            "CELL_OVERLAP_POSSIBLE":       self._rule_overlap,
+            "CELL_DUPLICATE_TARGET":       self._rule_duplicate_target,
+            "CELL_EXCLUSIVE_NO_RETURN":    self._rule_exclusive_no_return,
+            "CELL_EMPTY_TARGET":           self._rule_empty_target,
+        }
+
+    # ------------------------------------------------------------------
+    # Helpers
+    # ------------------------------------------------------------------
+    def _severity(self, code: str) -> ValidationSeverity:
+        rule = self.rules_data.get(code, {})
+        return ValidationSeverity.from_string(rule.get("severity", "info"))
+
+    def _make_issue(self, code: str, message: str,
+                    target: str = "") -> ValidationIssue:
+        return ValidationIssue(
+            category=self.category,
+            code=code,
+            message=message,
+            severity=self._severity(code),
+            target=target,
+        )
+
+    def _iter_cells(self, context: ValidationContext):
+        """Return all (source, event) keys that have transitions or relations."""
+        sm = context.state_machine
+        if sm is None:
+            return []
+        keys = set()
+        for t in sm.transitions:
+            keys.add((t.source, t.event or ""))
+        for (s, e) in sm.get_cell_keys():
+            keys.add((s, e))
+        return sorted(keys)
+
+    def _loc(self, source: str, event: str) -> str:
+        return f"{source}/{event or 'Completion'}"
+
+    # ------------------------------------------------------------------
+    # Rule 1: CELL_EMPTY_CONDITION
+    # ------------------------------------------------------------------
+    def _rule_empty_condition(self, context) -> List[ValidationIssue]:
+        sm = context.state_machine
+        if sm is None:
+            return []
+        issues = []
+        for (source, event) in self._iter_cells(context):
+            for t in sm.get_transitions_for_cell(source, event):
+                cond = (getattr(t, "condition", "") or "").strip()
+                target = (getattr(t, "target", "") or "").strip()
+                if not cond and not target:
+                    label = getattr(t, "label", "") or "(no label)"
+                    issues.append(self._make_issue(
+                        "CELL_EMPTY_CONDITION",
+                        f"Transition '{label}' has no condition and no target",
+                        self._loc(source, event),
+                    ))
+        return issues
+
+    # ------------------------------------------------------------------
+    # Rule 2: CELL_DUPLICATE_LABEL
+    # ------------------------------------------------------------------
+    def _rule_duplicate_label(self, context) -> List[ValidationIssue]:
+        sm = context.state_machine
+        if sm is None:
+            return []
+        issues = []
+        for (source, event) in self._iter_cells(context):
+            seen = set()
+            for t in sm.get_transitions_for_cell(source, event):
+                label = getattr(t, "label", "") or ""
+                if not label:
+                    continue
+                if label in seen:
+                    issues.append(self._make_issue(
+                        "CELL_DUPLICATE_LABEL",
+                        f"Duplicate transition label '{label}'",
+                        self._loc(source, event),
+                    ))
+                else:
+                    seen.add(label)
+        return issues
+
+    # ------------------------------------------------------------------
+    # Rule 3: CELL_DANGLING_RELATION
+    # ------------------------------------------------------------------
+    def _rule_dangling_relation(self, context) -> List[ValidationIssue]:
+        sm = context.state_machine
+        if sm is None:
+            return []
+        issues = []
+        for (source, event) in self._iter_cells(context):
+            transitions = sm.get_transitions_for_cell(source, event)
+            relations = sm.get_relations_for_cell(source, event)
+            if not relations:
+                continue
+            valid = {getattr(t, "label", "") or "" for t in transitions}
+            valid.discard("")
+            for r in relations:
+                for m in (r.members or []):
+                    if m not in valid:
+                        issues.append(self._make_issue(
+                            "CELL_DANGLING_RELATION",
+                            f"Relation references missing label '{m}'",
+                            self._loc(source, event),
+                        ))
+        return issues
+
+    # ------------------------------------------------------------------
+    # Rule 4: CELL_UNREACHABLE_TRANSITION
+    # ------------------------------------------------------------------
+    def _rule_unreachable(self, context) -> List[ValidationIssue]:
+        sm = context.state_machine
+        if sm is None:
+            return []
+        issues = []
+        for (source, event) in self._iter_cells(context):
+            blocker = False
+            for t in sm.get_transitions_for_cell(source, event):
+                label = getattr(t, "label", "") or "(no label)"
+                if blocker:
+                    issues.append(self._make_issue(
+                        "CELL_UNREACHABLE_TRANSITION",
+                        f"Transition '{label}' is unreachable "
+                        f"(a prior Commit transition always fires)",
+                        self._loc(source, event),
+                    ))
+                    continue
+                er = getattr(t, "early_return", False)
+                cond = (getattr(t, "condition", "") or "").strip()
+                has_else = getattr(t, "has_else", True)
+                if er and (not cond or has_else):
+                    blocker = True
+        return issues
+
+    # ------------------------------------------------------------------
+    # Rule 5: CELL_OVERLAP_POSSIBLE
+    # ------------------------------------------------------------------
+    def _rule_overlap(self, context) -> List[ValidationIssue]:
+        sm = context.state_machine
+        if sm is None:
+            return []
+        issues = []
+        for (source, event) in self._iter_cells(context):
+            seen = {}
+            for t in sm.get_transitions_for_cell(source, event):
+                cond = (getattr(t, "condition", "") or "").strip()
+                if not cond:
+                    continue
+                label = getattr(t, "label", "") or "(no label)"
+                if cond in seen:
+                    issues.append(self._make_issue(
+                        "CELL_OVERLAP_POSSIBLE",
+                        f"Transitions '{seen[cond]}' and '{label}' "
+                        f"share the same condition '{cond}'",
+                        self._loc(source, event),
+                    ))
+                else:
+                    seen[cond] = label
+        return issues
+
+    # ------------------------------------------------------------------
+    # Rule 6: CELL_DUPLICATE_TARGET
+    # ------------------------------------------------------------------
+    def _rule_duplicate_target(self, context) -> List[ValidationIssue]:
+        sm = context.state_machine
+        if sm is None:
+            return []
+        issues = []
+        for (source, event) in self._iter_cells(context):
+            by_target = {}
+            for t in sm.get_transitions_for_cell(source, event):
+                target = (getattr(t, "target", "") or "").strip()
+                if not target:
+                    continue
+                label = getattr(t, "label", "") or "(no label)"
+                by_target.setdefault(target, []).append(label)
+            for target, labels in by_target.items():
+                if len(labels) > 1:
+                    issues.append(self._make_issue(
+                        "CELL_DUPLICATE_TARGET",
+                        f"Multiple transitions target '{target}': "
+                        f"{', '.join(labels)}",
+                        self._loc(source, event),
+                    ))
+        return issues
+
+    # ------------------------------------------------------------------
+    # Rule 7: CELL_EXCLUSIVE_NO_RETURN
+    # ------------------------------------------------------------------
+    def _rule_exclusive_no_return(self, context) -> List[ValidationIssue]:
+        sm = context.state_machine
+        if sm is None:
+            return []
+        issues = []
+        for (source, event) in self._iter_cells(context):
+            transitions = sm.get_transitions_for_cell(source, event)
+            relations = sm.get_relations_for_cell(source, event)
+            by_label = {getattr(t, "label", "") or "": t for t in transitions}
+            for r in relations:
+                if r.kind != "exclusive":
+                    continue
+                for m in (r.members or []):
+                    t = by_label.get(m)
+                    if t is None:
+                        continue
+                    if not getattr(t, "early_return", False):
+                        issues.append(self._make_issue(
+                            "CELL_EXCLUSIVE_NO_RETURN",
+                            f"Exclusive member '{m}' does not have "
+                            f"early_return=True",
+                            self._loc(source, event),
+                        ))
+        return issues
+
+    # ------------------------------------------------------------------
+    # Rule 8: CELL_EMPTY_TARGET
+    # ------------------------------------------------------------------
+    def _rule_empty_target(self, context) -> List[ValidationIssue]:
+        sm = context.state_machine
+        if sm is None:
+            return []
+        issues = []
+        for (source, event) in self._iter_cells(context):
+            for t in sm.get_transitions_for_cell(source, event):
+                target = (getattr(t, "target", "") or "").strip()
+                er = getattr(t, "early_return", False)
+                cond = (getattr(t, "condition", "") or "").strip()
+                if not target and not er and cond:
+                    label = getattr(t, "label", "") or "(no label)"
+                    issues.append(self._make_issue(
+                        "CELL_EMPTY_TARGET",
+                        f"Transition '{label}' has no target "
+                        f"and no early_return",
+                        self._loc(source, event),
+                    ))
+        return issues

codegen/validate/items/custom_type_validator.py

@@ -0,0 +1,75 @@
+# codegen/validate/items/custom_type_validator.py
+"""
+Custom type validation
+"""
+
+import sys
+import os
+from typing import List
+
+sys.path.append(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
+
+from ..logger import logger
+from ..models import ValidationIssue, ValidationSeverity, ValidationContext
+from ..data.validation_rules import VALIDATION_RULES
+from .base_validator import BaseValidator
+
+
+class CustomTypeValidator(BaseValidator):
+    """Custom type validator class"""
+    
+    category = "custom_type"
+    
+    def __init__(self):
+        logger.debug("CustomTypeValidator.__init__ started")
+        self.rules_data = VALIDATION_RULES.get(self.category, {})
+        self.rules = {
+            'TYPE_DUPLICATE_NAME': self._check_duplicate_names,
+            'TYPE_NO_MEMBERS': self._check_no_members,
+        }
+        logger.debug(f"CustomTypeValidator.__init__ completed: {len(self.rules)} rules")
+    
+    def validate(self, context: ValidationContext) -> List[ValidationIssue]:
+        logger.debug(f"CustomTypeValidator.validate started")
+        issues = []
+        for code, rule_func in self.rules.items():
+            try:
+                result = rule_func(context)
+                if result:
+                    issues.extend(result)
+            except Exception as e:
+                logger.error(f"Rule '{code}' failed: {e}", exc_info=True)
+        return issues
+    
+    def _create_issue(self, code: str, **kwargs) -> ValidationIssue:
+        rule = self.rules_data.get(code, {})
+        message = rule.get('message', '').format(**kwargs)
+        severity = ValidationSeverity.from_string(rule.get('severity', 'info'))
+        return ValidationIssue(
+            category=self.category,
+            code=code,
+            message=message,
+            severity=severity,
+            suggestion=rule.get('suggestion', ''),
+            target=kwargs.get('name', ''),
+        )
+    
+    def _check_duplicate_names(self, context):
+        issues = []
+        seen = set()
+        for custom_type in context.custom_types:
+            name = getattr(custom_type, 'name', '')
+            if name in seen:
+                issues.append(self._create_issue('TYPE_DUPLICATE_NAME', name=name))
+            else:
+                seen.add(name)
+        return issues
+    
+    def _check_no_members(self, context):
+        issues = []
+        for custom_type in context.custom_types:
+            members = getattr(custom_type, 'members', [])
+            name = getattr(custom_type, 'name', '')
+            if not members:
+                issues.append(self._create_issue('TYPE_NO_MEMBERS', name=name))
+        return issues

codegen/validate/items/event_validator.py

@@ -0,0 +1,78 @@
+# codegen/validate/items/event_validator.py
+"""
+Event validation
+
+[v1.8 section 11.2 #6]
+  - Unified logger output with StateValidator
+  - Added start / completion logs to __init__ / validate
+  - Wrapped rule execution in try/except; on failure, log via logger.error
+"""
+
+import sys
+import os
+from typing import List
+
+sys.path.append(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
+
+from ..logger import logger
+from ..models import ValidationIssue, ValidationSeverity, ValidationContext
+from ..data.validation_rules import VALIDATION_RULES
+from .base_validator import BaseValidator
+
+
+class EventValidator(BaseValidator):
+    """Event validation class"""
+
+    category = "event"
+
+    def __init__(self):
+        logger.debug("EventValidator.__init__ started")
+        self.rules_data = VALIDATION_RULES.get(self.category, {})
+        self.rules = {
+            'EVENT_UNUSED': self._check_unused_events,
+            'EVENT_NO_TRANSITION': self._check_events_without_transitions,
+        }
+        logger.debug(f"EventValidator.__init__ completed: {len(self.rules)} rules")
+
+    def validate(self, context: ValidationContext) -> List[ValidationIssue]:
+        logger.debug("EventValidator.validate started")
+        issues = []
+        for code, rule_func in self.rules.items():
+            try:
+                result = rule_func(context)
+                if result:
+                    issues.extend(result)
+            except Exception as e:
+                logger.error(f"Rule '{code}' failed: {e}", exc_info=True)
+        logger.debug(f"EventValidator.validate completed: {len(issues)} issues")
+        return issues
+
+    def _create_issue(self, code: str, **kwargs) -> ValidationIssue:
+        rule = self.rules_data.get(code, {})
+        message = rule.get('message', '').format(**kwargs)
+        severity = ValidationSeverity.from_string(rule.get('severity', 'info'))
+
+        return ValidationIssue(
+            category=self.category,
+            code=code,
+            message=message,
+            severity=severity,
+            suggestion=rule.get('suggestion', ''),
+            target=kwargs.get('name', ''),
+        )
+
+    def _check_unused_events(self, context):
+        issues = []
+        used_events = set(t.event for t in context.transitions)
+        for name in context.events.keys():
+            if name not in used_events:
+                issues.append(self._create_issue('EVENT_UNUSED', name=name))
+        return issues
+
+    def _check_events_without_transitions(self, context):
+        issues = []
+        for name in context.events.keys():
+            has_transition = any(t.event == name for t in context.transitions)
+            if not has_transition:
+                issues.append(self._create_issue('EVENT_NO_TRANSITION', name=name))
+        return issues

codegen/validate/items/flag_validator.py

@@ -0,0 +1,74 @@
+# codegen/validate/items/flag_validator.py
+"""\nFlag validation\n"""
+
+import sys
+import os
+from typing import List
+
+sys.path.append(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
+
+from ..logger import logger
+from ..models import ValidationIssue, ValidationSeverity, ValidationContext
+from ..data.validation_rules import VALIDATION_RULES
+from .base_validator import BaseValidator
+
+
+class FlagValidator(BaseValidator):
+    """Flag validation class"""
+    
+    category = "flag"
+    
+    def __init__(self):
+        logger.debug("FlagValidator.__init__ started")
+        self.rules_data = VALIDATION_RULES.get(self.category, {})
+        self.rules = {
+            'FLAG_DUPLICATE_NAME': self._check_duplicate_names,
+            'FLAG_INVALID_RANGE': self._check_invalid_range,
+        }
+        logger.debug(f"FlagValidator.__init__ completed: {len(self.rules)} rules")
+    
+    def validate(self, context: ValidationContext) -> List[ValidationIssue]:
+        logger.debug(f"FlagValidator.validate started")
+        issues = []
+        for code, rule_func in self.rules.items():
+            try:
+                result = rule_func(context)
+                if result:
+                    issues.extend(result)
+            except Exception as e:
+                logger.error(f"Rule '{code}' failed: {e}", exc_info=True)
+        return issues
+    
+    def _create_issue(self, code: str, **kwargs) -> ValidationIssue:
+        rule = self.rules_data.get(code, {})
+        message = rule.get('message', '').format(**kwargs)
+        severity = ValidationSeverity.from_string(rule.get('severity', 'info'))
+        return ValidationIssue(
+            category=self.category,
+            code=code,
+            message=message,
+            severity=severity,
+            suggestion=rule.get('suggestion', ''),
+            target=kwargs.get('name', ''),
+        )
+    
+    def _check_duplicate_names(self, context):
+        issues = []
+        seen = set()
+        for flag in context.flags:
+            name = getattr(flag, 'name', '')
+            if name in seen:
+                issues.append(self._create_issue('FLAG_DUPLICATE_NAME', name=name))
+            else:
+                seen.add(name)
+        return issues
+    
+    def _check_invalid_range(self, context):
+        issues = []
+        for flag in context.flags:
+            min_value = getattr(flag, 'min_value', 0)
+            max_value = getattr(flag, 'max_value', 0)
+            name = getattr(flag, 'name', '')
+            if min_value > max_value:
+                issues.append(self._create_issue('FLAG_INVALID_RANGE', name=name))
+        return issues

codegen/validate/items/interrupt_validator.py

@@ -0,0 +1,75 @@
+# codegen/validate/items/interrupt_validator.py
+"""\nInterrupt validation\n"""
+
+import sys
+import os
+from typing import List
+
+sys.path.append(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
+
+from ..logger import logger
+from ..models import ValidationIssue, ValidationSeverity, ValidationContext
+from ..data.validation_rules import VALIDATION_RULES
+from .base_validator import BaseValidator
+
+
+class InterruptValidator(BaseValidator):
+    """Interrupt validation class"""
+    
+    category = "interrupt"
+    
+    def __init__(self):
+        logger.debug("InterruptValidator.__init__ started")
+        self.rules_data = VALIDATION_RULES.get(self.category, {})
+        self.rules = {
+            'INTERRUPT_DUPLICATE_NAME': self._check_duplicate_names,
+            'INTERRUPT_UNDEFINED_EVENT': self._check_undefined_event,
+        }
+        logger.debug(f"InterruptValidator.__init__ completed: {len(self.rules)} rules")
+    
+    def validate(self, context: ValidationContext) -> List[ValidationIssue]:
+        logger.debug(f"InterruptValidator.validate started")
+        issues = []
+        for code, rule_func in self.rules.items():
+            try:
+                result = rule_func(context)
+                if result:
+                    issues.extend(result)
+            except Exception as e:
+                logger.error(f"Rule '{code}' failed: {e}", exc_info=True)
+        return issues
+    
+    def _create_issue(self, code: str, **kwargs) -> ValidationIssue:
+        rule = self.rules_data.get(code, {})
+        message = rule.get('message', '').format(**kwargs)
+        severity = ValidationSeverity.from_string(rule.get('severity', 'info'))
+        return ValidationIssue(
+            category=self.category,
+            code=code,
+            message=message,
+            severity=severity,
+            suggestion=rule.get('suggestion', ''),
+            target=kwargs.get('name', ''),
+        )
+    
+    def _check_duplicate_names(self, context):
+        issues = []
+        seen = set()
+        for interrupt in context.interrupts:
+            name = getattr(interrupt, 'name', '')
+            if name in seen:
+                issues.append(self._create_issue('INTERRUPT_DUPLICATE_NAME', name=name))
+            else:
+                seen.add(name)
+        return issues
+    
+    def _check_undefined_event(self, context):
+        issues = []
+        event_names = set(context.events.keys())
+        for interrupt in context.interrupts:
+            event_list = getattr(interrupt, 'event_names', [])
+            name = getattr(interrupt, 'name', '')
+            for event_name in event_list:
+                if event_name and event_name not in event_names:
+                    issues.append(self._create_issue('INTERRUPT_UNDEFINED_EVENT', name=name))
+        return issues