sysmlpy 0.70.0__tar.gz → 0.72.0__tar.gz

{sysmlpy-0.70.0 → sysmlpy-0.72.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sysmlpy
-Version: 0.70.0
+Version: 0.72.0
 Summary: 
 License-File: LICENSE
 Author: Jon R. Fox (mycr0ft)

{sysmlpy-0.70.0 → sysmlpy-0.72.0}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "poetry.core.masonry.api"
 
 [project]
 name = "sysmlpy"
-version = "0.70.0"
+version = "0.72.0"
 description = ""
 authors = [{ name = "Jon R. Fox (mycr0ft)", email = "jon.fox@drfox.com" }]
 readme = "README.md"

{sysmlpy-0.70.0 → sysmlpy-0.72.0}/src/sysmlpy/__init__.py

@@ -34,7 +34,7 @@ __all__ = [
     "render_state_transition_view_svg", "boxes_view",
 ]
 __author__ = "Jon Fox"
-__version__ = "0.70.0"
+__version__ = "0.72.0"
 
 from sysmlpy.usage import (
     Item, Attribute, Part, Port, Action, Reference, UseCase, Requirement, Interface, Message,

{sysmlpy-0.70.0 → sysmlpy-0.72.0}/src/sysmlpy/semantic.py

@@ -1236,6 +1236,139 @@ class ExpressionIdentifierCollector:
             self._walk(child, results, child_scope)
 
 
+def _satisfy_by_ref(satisfy_dict: dict):
+    """The ``by <part>`` reference of a SatisfyRequirementUsage dict.
+
+    Shape: ``ssm`` = SatisfactionSubjectMember → SatisfactionParameter
+    → … → FeatureChainMember.memberElement (QualifiedName) whose last
+    segment is the satisfying feature.  ``ors.referencedFeature.names``
+    carries the target requirement reference.
+    """
+    ssm = satisfy_dict.get("ssm")
+    if not isinstance(ssm, dict):
+        return None
+    members = _find_named_dicts(ssm, "FeatureChainMember")
+    for m in members:
+        me = m.get("memberElement") or {}
+        names = me.get("names")
+        if isinstance(names, list) and names:
+            return "::".join(str(n) for n in names)
+    return None
+
+
+def _find_named_dicts(node: Any, name: str) -> list:
+    """Locate every dict with ``dict["name"] == name`` in a tree."""
+    out: list = []
+
+    def walk(n: Any) -> None:
+        if isinstance(n, dict):
+            if n.get("name") == name:
+                out.append(n)
+            for v in n.values():
+                if isinstance(v, (dict, list)):
+                    walk(v)
+        elif isinstance(n, list):
+            for item in n:
+                if isinstance(item, (dict, list)):
+                    walk(item)
+
+    walk(node)
+    return out
+
+
+def _as_list_dicts(v: Any) -> list:
+    """Normalize an optional-dict-or-list relationship field to a list."""
+    if isinstance(v, list):
+        return [x for x in v if isinstance(x, dict)]
+    if isinstance(v, dict):
+        return [v]
+    return []
+
+
+def _find_declared_name(d: dict):
+    """Bounded search for ``identification.declaredName`` in a usage/
+    definition dict (the identification nesting varies by shape)."""
+    frontier = [d]
+    for _ in range(4):
+        nxt = []
+        for n in frontier:
+            if not isinstance(n, dict):
+                continue
+            ident = n.get("identification")
+            if isinstance(ident, dict):
+                name = ident.get("declaredName")
+                if name:
+                    return name
+            for v in n.values():
+                if isinstance(v, dict):
+                    nxt.append(v)
+                elif isinstance(v, list):
+                    nxt.extend(x for x in v if isinstance(x, dict))
+        frontier = nxt
+    return None
+
+
+def _port_direction(port_usage: dict):
+    """The explicit direction keyword on a PortUsage dict, if any.
+
+    The prefix chain is
+    ``OccurrenceUsagePrefix → BasicUsagePrefix → RefPrefix.direction``
+    where ``direction`` is ``{"in": ..., "out": ..., "inout": ...}`` —
+    the present keyword is the non-empty string value.
+    """
+    pre = port_usage.get("prefix")
+    while isinstance(pre, dict):
+        d = pre.get("direction")
+        if isinstance(d, dict):
+            for k in ("in", "out", "inout"):
+                v = d.get(k)
+                if isinstance(v, str) and v.strip():
+                    return k
+            return None
+        pre = pre.get("prefix")
+    return None
+
+
+def _connector_end_chain(end: dict) -> list:
+    """Feature-chain segment names of a ConnectorEnd dict."""
+    ors = end.get("ownedRelationship") if isinstance(end, dict) else None
+    for rel in _as_list_dicts(ors):
+        if rel.get("name") != "OwnedReferenceSubsetting":
+            continue
+        ofc_list = _as_list_dicts(rel.get("ownedRelatedElement"))
+        ofc = ofc_list[0] if ofc_list else {}
+        if ofc.get("name") != "OwnedFeatureChain":
+            continue
+        feat = ofc.get("feature") or {}
+        names = []
+        for chain_rel in _as_list_dicts(feat.get("ownedRelationship")):
+            if chain_rel.get("name") != "OwnedFeatureChaining":
+                continue
+            cf = chain_rel.get("chainingFeature") or {}
+            qn = cf.get("names")
+            if isinstance(qn, list) and qn:
+                names.append(str(qn[-1]))
+        return names
+    return []
+
+
+def _usage_typed_by(usage: dict):
+    """The last segment of a usage dict's OwnedFeatureTyping, if any.
+
+    The typing rides the declaration/specialization chain, which
+    precedes the body in dict order, so a usage's own typing is found
+    before any nested member's typing.
+    """
+    for rel in _find_named_dicts(usage, "OwnedFeatureTyping"):
+        ft = rel.get("type") or {}
+        qn = ft.get("type") if isinstance(ft, dict) else None
+        if isinstance(qn, dict):
+            names = qn.get("names")
+            if isinstance(names, list) and names:
+                return str(names[-1])
+    return None
+
+
 def _find_payload_parameters(node: Any) -> list:
     """Locate every ``PayloadParameter`` dict in a grammar tree."""
     out: list = []
@@ -2381,6 +2514,9 @@ class SemanticAnalyzer:
         issues.extend(self._check_trigger_payloads(model, symtab, lib_roots))
         issues.extend(self._check_requirement_coverage(model))
         issues.extend(self._check_trace_targets(model, symtab, lib_roots))
+        issues.extend(self._check_verify_targets(model, symtab, lib_roots))
+        issues.extend(self._check_satisfy_parts(model, symtab, lib_roots))
+        issues.extend(self._check_connector_directions(model))
 
         # Step 6: Stylistic checks (warnings, not errors)
         if style_checks:
@@ -3179,6 +3315,258 @@ class SemanticAnalyzer:
             return table.lookup(parts[-1])
         return None
 
+    def _check_satisfy_parts(
+        self,
+        model: Any,
+        symtab: "SymbolTable",
+        lib_roots: list,
+    ) -> list[SemanticIssue]:
+        """Resolve ``satisfy <req> by <part>`` subjects (Goal 9).
+
+        The ``by`` reference names the satisfying part; both
+        package-level satisfies (grammar ``SatisfyRequirementUsage``
+        wrappers yielded by ``_walk_usages``) and satisfies nested
+        inside requirement bodies (extracted from the requirement's
+        grammar dict — the visitor surfaces nested verify members but
+        not satisfy members) are checked.  An unresolved by-part is a
+        UNRESOLVED_SATISFY_PART error.
+        """
+        issues: list[SemanticIssue] = []
+
+        def issue(obj, ref):
+            issues.append(SemanticIssue(
+                severity="error",
+                code="UNRESOLVED_SATISFY_PART",
+                message=(
+                    f"satisfy 'by {ref}' does not resolve to a "
+                    "defined part"),
+                element=obj,
+                reference=ref,
+            ))
+
+        for element, scope_path in self._walk_usages(model):
+            gname = (element.grammar.__class__.__name__
+                     if getattr(element, "grammar", None) is not None else "")
+            if gname == "SatisfyRequirementUsage":
+                # package-level wrapper; .ssm dump is the by reference
+                g = element.grammar
+                ssm = getattr(g, "ssm", None)
+                if ssm is None:
+                    continue
+                ref = ssm.dump().strip().rstrip(";").strip()
+                if not ref:
+                    continue
+                if not self._is_resolved(ref, symtab, scope_path, lib_roots):
+                    issue(element, ref)
+                continue
+            if gname not in ("RequirementDefinition", "RequirementUsage"):
+                continue
+            # nested satisfy members: scan the requirement's grammar dict
+            grammar = element.grammar
+            if grammar is None:
+                continue
+            try:
+                grammar_def = grammar.get_definition()
+            except Exception:
+                continue
+            if not isinstance(grammar_def, dict):
+                continue
+            for sat in _find_named_dicts(
+                    grammar_def, "SatisfyRequirementUsage"):
+                by_ref = _satisfy_by_ref(sat)
+                if not by_ref:
+                    continue
+                if not self._is_resolved(
+                        by_ref, symtab, scope_path, lib_roots):
+                    issue(element, by_ref)
+        return issues
+
+    def _check_verify_targets(
+        self,
+        model: Any,
+        symtab: "SymbolTable",
+        lib_roots: list,
+    ) -> list[SemanticIssue]:
+        """Resolve ``verify <vc>`` members inside requirements (Goal 9).
+
+        ``verify v1 : VC;`` in a requirement body parses as a
+        VerifyRequirementUsage whose ``ors`` holds the referenced
+        verification-case name.  Notably the visitor drops the
+        ``: VC`` typing specialization entirely (``fsp`` is empty), so
+        a typo'd verification-case *type* is invisible — but the
+        member name reference is checkable: resolve it against the
+        symbol table in the requirement's scope.  Unresolved targets
+        produce UNRESOLVED_VERIFY_TARGET errors (same contract as
+        UNRESOLVED_TRACE_TARGET for satisfy).
+        """
+        issues: list[SemanticIssue] = []
+        for element, scope_path in self._walk_usages(model):
+            # verify members live inside Requirement grammar trees
+            # (no VerifyRequirementUsage object of their own)
+            if type(element).__name__ != "Requirement":
+                continue
+            grammar = getattr(element, "grammar", None)
+            if grammar is None:
+                continue
+            try:
+                grammar_def = grammar.get_definition()
+            except Exception:
+                continue
+            if not isinstance(grammar_def, dict):
+                continue
+            for vr in _find_named_dicts(grammar_def, "VerifyRequirementUsage"):
+                ors = vr.get("ors")
+                if not isinstance(ors, dict):
+                    continue
+                rf = ors.get("referencedFeature") or {}
+                # referencedFeature *is* the QualifiedName node here
+                names = rf.get("names") if isinstance(rf, dict) else None
+                if not names:
+                    continue
+                ref = "::".join(str(n) for n in names)
+                if self._is_resolved(ref, symtab, scope_path, lib_roots):
+                    continue
+                issues.append(SemanticIssue(
+                    severity="error",
+                    code="UNRESOLVED_VERIFY_TARGET",
+                    message=(
+                        f"verify target '{ref}' in requirement "
+                        f"'{getattr(element, 'name', '<anonymous>')}' "
+                        "does not resolve to a defined element"),
+                    element=element,
+                    reference=ref,
+                ))
+        return issues
+
+    def _check_connector_directions(self, model: Any) -> list[SemanticIssue]:
+        """Check connection-end port direction compatibility (Goal 9).
+
+        ``connection c connect a.p1 to b.p2;`` — when both end ports
+        carry explicit directions and neither is ``inout``, wiring
+        ``out`` to ``out`` or ``in`` to ``in`` flags
+        CONNECTOR_DIRECTION_MISMATCH (warning — conjugated ports and
+        exotic flow conventions exist, so this is advisory, not an
+        error).  Ends without a direction keyword, ``inout`` ends,
+        chains deeper than two segments and unresolvable parts are
+        skipped.
+        """
+        issues: list[SemanticIssue] = []
+        try:
+            from sysmlpy.sim import load_model_grammar
+            visit = load_model_grammar(model)
+        except Exception:
+            return issues
+
+        scope_ports: dict = {}   # def/usage name -> {port: direction}
+        part_typing: dict = {}   # part usage name -> typed-by name
+        member_typing: dict = {}  # (container name, member) -> typed-by
+        connections: list = []   # (name, scope_stack, [chain, ...])
+
+        def walk2(node, scope_stack):
+            if isinstance(node, dict):
+                nm = node.get("name")
+                declared = _find_declared_name(node)
+                new_stack = scope_stack
+                if declared and isinstance(nm, str) and (
+                        nm.endswith("Usage") or nm.endswith("Definition")):
+                    if nm != "PortUsage":
+                        new_stack = scope_stack + [declared]
+                    if nm == "PortUsage":
+                        d = _port_direction(node)
+                        if d and scope_stack:
+                            scope_ports.setdefault(
+                                scope_stack[-1], {})[declared] = d
+                    elif nm == "ConnectionUsage":
+                        chains = []
+                        part = node.get("part") or {}
+                        bp = part.get("part") or {}
+                        for rel in _as_list_dicts(
+                                bp.get("ownedRelationship")):
+                            if rel.get("name") != "ConnectorEndMember":
+                                continue
+                            ends = _as_list_dicts(
+                                rel.get("ownedRelatedElement"))
+                            if not ends:
+                                continue
+                            chain = _connector_end_chain(ends[0])
+                            if chain:
+                                chains.append(chain)
+                        if len(chains) == 2:
+                            connections.append((declared, new_stack, chains))
+                    elif nm.endswith("Usage"):
+                        t = _usage_typed_by(node)
+                        if t:
+                            part_typing[declared] = t
+                            if scope_stack:
+                                member_typing[(scope_stack[-1],
+                                               declared)] = t
+                for k, v in node.items():
+                    if isinstance(v, (dict, list)):
+                        walk2(v, new_stack)
+            elif isinstance(node, list):
+                for x in node:
+                    walk2(x, scope_stack)
+
+        walk2(visit, [])
+
+        def end_direction(chain, scope_stack):
+            if len(chain) == 2:
+                part_name, port_name = chain
+                t = part_typing.get(part_name)
+                if t and port_name in scope_ports.get(t, {}):
+                    return scope_ports[t][port_name]
+                return scope_ports.get(part_name, {}).get(port_name)
+            if len(chain) == 1:
+                port_name = chain[0]
+                for scope in reversed(scope_stack):
+                    if port_name in scope_ports.get(scope, {}):
+                        return scope_ports[scope][port_name]
+                    t = part_typing.get(scope)
+                    if t and port_name in scope_ports.get(t, {}):
+                        return scope_ports[t][port_name]
+            # deep chains (>=3 segments: bus.a.p3) — resolve segment by
+            # segment: seg0 via the part's typing, middle segments via
+            # member typing in the resolved container, final port via
+            # the container's port directions.
+            first = chain[0]
+            cur = part_typing.get(first)
+            if cur is None:
+                for scope in reversed(scope_stack):
+                    t = member_typing.get((scope, first))
+                    if t:
+                        cur = t
+                        break
+            if cur is None:
+                return None
+            for seg in chain[1:-1]:
+                t = member_typing.get((cur, seg))
+                if t is None:
+                    # members declared on the seg0 *usage* itself
+                    t = member_typing.get((first, seg))
+                if t is None:
+                    return None
+                cur = t
+            return scope_ports.get(cur, {}).get(chain[-1])
+
+        for cname, cstack, chains in connections:
+            d1 = end_direction(chains[0], cstack)
+            d2 = end_direction(chains[1], cstack)
+            if not d1 or not d2:
+                continue
+            if d1 == "inout" or d2 == "inout":
+                continue
+            if d1 == d2:
+                issues.append(SemanticIssue(
+                    severity="warning",
+                    code="CONNECTOR_DIRECTION_MISMATCH",
+                    message=(
+                        f"Connection '{cname}' binds two '{d1}' ports "
+                        f"({chains[0][-1]} -> {chains[1][-1]}); a "
+                        "connection normally pairs 'out' with 'in'"),
+                    reference=cname,
+                ))
+        return issues
+
     def _check_state_machines(self, model: Any) -> list[SemanticIssue]:
         """OCL well-formedness for ``state def`` machines (Goal 9).
 

{sysmlpy-0.70.0 → sysmlpy-0.72.0}/src/sysmlpy/traceability.py

@@ -224,6 +224,59 @@ def _qualified_name(obj) -> str:
     return "::".join(reversed(segments))
 
 
+def _find_named_dicts_local(node, name: str) -> list:
+    """Locate every dict with ``dict["name"] == name`` in a tree.
+
+    Local copy of the semantic-module helper (semantic imports this
+    module, so a shared util would be circular).
+    """
+    out: list = []
+
+    def walk(n):
+        if isinstance(n, dict):
+            if n.get("name") == name:
+                out.append(n)
+            for v in n.values():
+                if isinstance(v, (dict, list)):
+                    walk(v)
+        elif isinstance(n, list):
+            for item in n:
+                if isinstance(item, (dict, list)):
+                    walk(item)
+
+    walk(node)
+    return out
+
+
+def _nested_satisfy_ref(satisfy_dict: dict):
+    """``(target, by_part)`` of a SatisfyRequirementUsage dict.
+
+    ``ors.referencedFeature.names`` carries the target requirement;
+    ``ssm`` (SatisfactionSubjectMember) nests
+    FeatureChainMember.memberElement (QualifiedName) whose last
+    segment is the satisfying feature.
+    """
+    ors = satisfy_dict.get("ors")
+    if not isinstance(ors, dict):
+        return None
+    rf = ors.get("referencedFeature") or {}
+    names = rf.get("names") if isinstance(rf, dict) else None
+    if not names:
+        return None
+    target = "::".join(str(n) for n in names)
+
+    ssm = satisfy_dict.get("ssm")
+    by_ref = None
+    if isinstance(ssm, dict):
+        for m in _find_named_dicts_local(ssm, "FeatureChainMember"):
+            me = m.get("memberElement") or {}
+            mnames = me.get("names")
+            if isinstance(mnames, list) and mnames:
+                by_ref = "::".join(str(n) for n in mnames)
+                break
+    return target, by_ref
+
+
 def _last_segment(ref: str) -> str:
     """Last segment of a dotted/qualified reference (``Pkg::r1`` → ``r1``)."""
     for sep in ("::", "."):
@@ -300,6 +353,26 @@ def extract_traceability(model) -> TraceabilityReport:
             is_definition=(gclass == "RequirementDefinition"),
         )
         traces.append(trace)
+        # Nested satisfy members (``requirement top { satisfy top by v;
+        # }``) parse as SatisfyRequirementUsage dicts inside the
+        # requirement's grammar — the visitor handles nested *verify*
+        # members but not satisfy, so they are invisible to pass 2 and
+        # the requirement would read as uncovered.  Record the edge.
+        if grammar is not None:
+            try:
+                grammar_def = grammar.get_definition()
+            except Exception:
+                grammar_def = None
+            if isinstance(grammar_def, dict):
+                for sat in _find_named_dicts_local(
+                        grammar_def, "SatisfyRequirementUsage"):
+                    ref = _nested_satisfy_ref(sat)
+                    if ref is None:
+                        continue
+                    target, by_part = ref
+                    if by_part and _last_segment(target) == name and (
+                            by_part not in trace.satisfied_by):
+                        trace.satisfied_by.append(by_part)
         # Index by both the bare name and every suffix of the qualified
         # name so `Pkg::req` / `req` / `Sub::req` references all resolve.
         traces_by_name.setdefault(name, trace)

{sysmlpy-0.70.0 → sysmlpy-0.72.0}/src/sysmlpy/usage.py

@@ -3239,6 +3239,13 @@ class Requirement(Usage):
                     c = Requirement(definition=True).load_from_grammar(target)
                     c.parent = self
                     self.children.append(c)
+                elif target_cls in ("SatisfyRequirementUsage",
+                                    "VerifyRequirementUsage"):
+                    # satisfy members are extracted from the grammar
+                    # dicts by traceability/semantic (nested verify
+                    # members ride _extract_verification_member); no
+                    # Requirement child belongs here.
+                    pass
                 elif target_cls and "Requirement" in target_cls:
                     print(f"[Requirement] Unhandled nested requirement type: {target_cls}")