sysmlpy 0.71.0__tar.gz → 0.73.0__tar.gz

{sysmlpy-0.71.0 → sysmlpy-0.73.0}/PKG-INFO

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

{sysmlpy-0.71.0 → sysmlpy-0.73.0}/pyproject.toml

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

{sysmlpy-0.71.0 → sysmlpy-0.73.0}/src/sysmlpy/__init__.py

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

{sysmlpy-0.71.0 → sysmlpy-0.73.0}/src/sysmlpy/semantic.py

@@ -1236,6 +1236,26 @@ 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 = []
@@ -2495,6 +2515,7 @@ class SemanticAnalyzer:
         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)
@@ -3294,6 +3315,193 @@ 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,
+            ))
+
+        # superclassifier map for subject-type compatibility: walk
+        # part/item definitions and collect ``:>`` targets
+        supertypes: dict = {}
+        for element, scope_path in self._walk_usages(model):
+            if type(element).__name__ not in ("Part", "Item"):
+                continue
+            if not getattr(element, "is_definition", False):
+                continue
+            grammar = getattr(element, "grammar", None)
+            if grammar is None:
+                continue
+            try:
+                d = grammar.get_definition()
+            except Exception:
+                continue
+            if not isinstance(d, dict):
+                continue
+            defn = d.get("definition") or {}
+            decl = defn.get("declaration") or {}
+            scp = decl.get("subclassificationpart") or {}
+            sups = set()
+            for rel in _as_list_dicts(scp.get("ownedRelationship")):
+                if rel.get("name") != "OwnedSubclassification":
+                    continue
+                sc = rel.get("superclassifier") or {}
+                names = sc.get("names")
+                if isinstance(names, list) and names:
+                    sups.add("::".join(str(n) for n in names))
+            if sups and element.name:
+                supertypes.setdefault(element.name, set()).update(sups)
+
+        def _is_subtype(sub: str, sup: str, seen=None) -> bool:
+            if sub == sup:
+                return True
+            if seen is None:
+                seen = set()
+            if sub in seen:
+                return False
+            seen.add(sub)
+            for st in supertypes.get(sub, ()):
+                if _is_subtype(st, sup, seen):
+                    return True
+            return False
+
+        def subject_issue(req_name, subj_type, part_name, part_type):
+            issues.append(SemanticIssue(
+                severity="warning",
+                code="SATISFY_SUBJECT_TYPE_MISMATCH",
+                message=(
+                    f"satisfy 'by {part_name}' ({part_type}) is not "
+                    f"related to requirement '{req_name}' subject "
+                    f"type '{subj_type}'"),
+                reference=req_name,
+            ))
+
+        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,
+                # .ors dump the target requirement
+                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)
+                ors = getattr(g, "ors", None)
+                target = ors.dump().strip().rstrip(";").strip() \
+                    if ors is not None else None
+                if target:
+                    self._check_subject_type(
+                        element, target, ref, symtab, scope_path,
+                        lib_roots, supertypes, _is_subtype,
+                        subject_issue)
+                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)
+                ors = sat.get("ors") or {}
+                rf = ors.get("referencedFeature") or {}
+                names = rf.get("names") if isinstance(rf, dict) else None
+                if names:
+                    target = "::".join(str(n) for n in names)
+                    self._check_subject_type(
+                        element, target, by_ref, symtab, scope_path,
+                        lib_roots, supertypes, _is_subtype,
+                        subject_issue)
+        return issues
+
+    def _check_subject_type(
+        self,
+        satisfy_obj: Any,
+        target_ref: str,
+        by_ref: str,
+        symtab: "SymbolTable",
+        scope_path: list[str],
+        lib_roots: list,
+        supertypes: dict,
+        is_subtype,
+        issue_fn,
+    ) -> None:
+        """SATISFY_SUBJECT_TYPE_MISMATCH (warning, conservative).
+
+        ``satisfy <req> by <part>`` binds *part* as the satisfying
+        element of *req*'s subject.  When both the subject's type and
+        the by-part's type are known model definitions and neither is
+        a (transitive) specialization of the other, flag a warning.
+        Anything unresolvable — library types, untyped parts,
+        requirements without a typed subject — is skipped.
+        """
+        target = self._resolve_element(target_ref, symtab, scope_path)
+        if target is None:
+            return
+        subject = getattr(target, "subject", None)
+        if not subject:
+            return
+        subj_type = subject[1]
+        if not subj_type or subj_type not in supertypes and (
+                subj_type not in getattr(symtab, "_definition_features",
+                                         {})):
+            return
+        by_el = self._resolve_element(by_ref, symtab, scope_path)
+        if by_el is None:
+            return
+        part_type = self._get_element_type(by_el)
+        if not part_type:
+            return
+        # both sides must be model-known (skip library typings)
+        if part_type not in supertypes and (
+                part_type not in getattr(symtab, "_definition_features",
+                                         {})):
+            return
+        if is_subtype(part_type, subj_type) or is_subtype(
+                subj_type, part_type):
+            return
+        issue_fn(target_ref, subj_type, by_ref, part_type)
+
     def _check_verify_targets(
         self,
         model: Any,
@@ -3370,8 +3578,10 @@ class SemanticAnalyzer:
         except Exception:
             return issues
 
-        scope_ports: dict = {}   # def/usage name -> {port: direction}
+        scope_ports: dict = {}   # def/usage name -> {port: direction|None}
         part_typing: dict = {}   # part usage name -> typed-by name
+        member_typing: dict = {}  # (container name, member) -> typed-by
+        supertypes: dict = {}    # def name -> {superclassifier names}
         connections: list = []   # (name, scope_stack, [chain, ...])
 
         def walk2(node, scope_stack):
@@ -3383,11 +3593,39 @@ class SemanticAnalyzer:
                         nm.endswith("Usage") or nm.endswith("Definition")):
                     if nm != "PortUsage":
                         new_stack = scope_stack + [declared]
+                    if nm.endswith("Definition"):
+                        # superclassifiers (``part def A :> B``) ride the
+                        # definition dict's declaration.subclassificationpart
+                        sups = set()
+                        defn = node.get("definition") or {}
+                        decl = defn.get("declaration") or {}
+                        scp = decl.get("subclassificationpart") or {}
+                        for rel in _as_list_dicts(
+                                scp.get("ownedRelationship")):
+                            if rel.get("name") != "OwnedSubclassification":
+                                continue
+                            sc = rel.get("superclassifier") or {}
+                            names = sc.get("names")
+                            if isinstance(names, list) and names:
+                                sups.add("::".join(
+                                    str(n) for n in names))
+                        if sups:
+                            supertypes.setdefault(declared, set()).update(
+                                sups)
                     if nm == "PortUsage":
                         d = _port_direction(node)
-                        if d and scope_stack:
+                        if scope_stack:
+                            # record even undirected ports: existence
+                            # drives end resolution, None direction
+                            # just skips the direction check
                             scope_ports.setdefault(
                                 scope_stack[-1], {})[declared] = d
+                        t = _usage_typed_by(node)
+                        if t:
+                            part_typing[declared] = t
+                            if scope_stack:
+                                member_typing[(scope_stack[-1],
+                                               declared)] = t
                     elif nm == "ConnectionUsage":
                         chains = []
                         part = node.get("part") or {}
@@ -3409,6 +3647,9 @@ class SemanticAnalyzer:
                         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)
@@ -3418,26 +3659,83 @@ class SemanticAnalyzer:
 
         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)
+        def end_resolve(chain, scope_stack):
+            """(direction|None, fully_resolved) for an end chain.
+
+            ``fully_resolved`` is False only when a segment provably
+            does not exist in a *known, non-specializing* container —
+            containers typed by library defs, unknown names and
+            subclasses (inherited members) resolve as "present but
+            direction-unknown" to stay conservative.
+            """
+            if not chain:
+                return None, True
             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]
+                    ports = scope_ports.get(scope)
+                    if ports is not None and port_name in ports:
+                        return ports[port_name], True
                     t = part_typing.get(scope)
-                    if t and port_name in scope_ports.get(t, {}):
-                        return scope_ports[t][port_name]
-            return None
+                    if t:
+                        ports = scope_ports.get(t)
+                        if ports is not None and port_name in ports:
+                            return ports[port_name], True
+                        if t not in supertypes and t not in scope_ports:
+                            # known library/external type: cannot
+                            # verify members
+                            return None, True
+                return None, False
+            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, False
+            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 in supertypes or (
+                            cur not in scope_ports
+                            and cur not in part_typing)
+                cur = t
+            ports = scope_ports.get(cur)
+            if ports is not None and chain[-1] in ports:
+                return ports[chain[-1]], True
+            if cur in supertypes:
+                return None, True   # inherited port possible
+            if cur in scope_ports:
+                return None, False  # known container, no such port
+            return None, True       # external/library type: skip
 
         for cname, cstack, chains in connections:
-            d1 = end_direction(chains[0], cstack)
-            d2 = end_direction(chains[1], cstack)
+            d1, r1 = end_resolve(chains[0], cstack)
+            d2, r2 = end_resolve(chains[1], cstack)
+            if not r1:
+                issues.append(SemanticIssue(
+                    severity="error",
+                    code="UNRESOLVED_CONNECTOR_END",
+                    message=(
+                        f"Connection '{cname}' end "
+                        f"'{'.'.join(chains[0])}' does not resolve"),
+                    reference=cname,
+                ))
+            if not r2:
+                issues.append(SemanticIssue(
+                    severity="error",
+                    code="UNRESOLVED_CONNECTOR_END",
+                    message=(
+                        f"Connection '{cname}' end "
+                        f"'{'.'.join(chains[1])}' does not resolve"),
+                    reference=cname,
+                ))
             if not d1 or not d2:
                 continue
             if d1 == "inout" or d2 == "inout":

{sysmlpy-0.71.0 → sysmlpy-0.73.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.71.0 → sysmlpy-0.73.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}")