sysmlpy 0.61.0__tar.gz → 0.62.0__tar.gz

{sysmlpy-0.61.0 → sysmlpy-0.62.0}/PKG-INFO

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

{sysmlpy-0.61.0 → sysmlpy-0.62.0}/pyproject.toml

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

{sysmlpy-0.61.0 → sysmlpy-0.62.0}/src/sysmlpy/__init__.py

@@ -16,7 +16,9 @@ __all__ = [
     "as_action_flow_view", "as_interconnection_view", "as_state_transition_view",
     "as_general_view", "as_package_view",
     "as_tabular_view", "as_data_value_tabular_view", "as_relationship_matrix_view",
+    "as_traceability_matrix_view",
     "as_sequence_view", "as_case_view", "as_browser_view",
+    "extract_traceability", "TraceabilityReport", "RequirementTrace",
     "analyze", "AnalysisResult", "SemanticIssue", "SemanticAnalyzer",
     "SysMLSyntaxError", "PartialParseError",
     "loads_partial", "load_partial",
@@ -25,7 +27,7 @@ __all__ = [
     "render_state_transition_view_svg", "boxes_view",
 ]
 __author__ = "Jon Fox"
-__version__ = "0.61.0"
+__version__ = "0.62.0"
 
 from sysmlpy.usage import (
     Item, Attribute, Part, Port, Action, Reference, UseCase, Requirement, Interface, Message,
@@ -41,6 +43,10 @@ from sysmlpy.store import Store, InMemoryStore, NetworkXStore, KuzuStore, Cayley
 
 from sysmlpy.usage import ureg
 from sysmlpy.antlr_parser import SysMLSyntaxError
+from sysmlpy.traceability import (
+    extract_traceability, TraceabilityReport, RequirementTrace,
+    as_traceability_matrix_view,
+)
 
 
 class PartialParseError(Exception):

{sysmlpy-0.61.0 → sysmlpy-0.62.0}/src/sysmlpy/__main__.py

@@ -31,7 +31,7 @@ import sysmlpy
 from sysmlpy import loads
 
 # Subcommand table, also used to detect the legacy flat invocation form.
-SUBCOMMANDS = ("parse", "analyze", "view", "format", "fmt")
+SUBCOMMANDS = ("parse", "analyze", "view", "trace", "format", "fmt")
 
 
 # ---------------------------------------------------------------------------
@@ -277,6 +277,46 @@ def cmd_format(args) -> int:
     return exit_code
 
 
+def cmd_trace(args) -> int:
+    """Requirement traceability & verification coverage (v0.62.0, Goal 2)."""
+    from sysmlpy.traceability import extract_traceability
+
+    paths = [Path(f) for f in args.files]
+    for p in _missing_files(paths):
+        print(f"Error: File '{p}' not found.", file=sys.stderr)
+        return 2
+
+    try:
+        model = sysmlpy.load_files(paths, library=args.library)
+    except Exception as e:
+        print(f"Parse error: {e}", file=sys.stderr)
+        return 2
+
+    report = extract_traceability(model)
+
+    if args.format == "json":
+        output = json.dumps(report.to_json(), indent=2)
+    elif args.format == "markdown":
+        output = report.to_markdown()
+    else:
+        output = report.to_text()
+
+    if args.output:
+        Path(args.output).write_text(output + "\n", encoding="utf-8")
+        print(f"Wrote {args.output}")
+    else:
+        print(output)
+
+    if args.fail_on == "uncovered" and report.uncovered():
+        for trace in report.uncovered():
+            print(
+                f"uncovered: {trace.qualified_name or trace.name}",
+                file=sys.stderr,
+            )
+        return 1
+    return 0
+
+
 # ---------------------------------------------------------------------------
 # legacy flat invocation (kept for backward compatibility)
 # ---------------------------------------------------------------------------
@@ -474,6 +514,33 @@ def build_parser() -> argparse.ArgumentParser:
     )
     p_format.set_defaults(func=cmd_format)
 
+    p_trace = sub.add_parser(
+        "trace",
+        help="Requirement traceability \u0026 verification coverage report",
+        description="Load the files as one merged model, extract satisfy "
+                    "and verify relationships, and report requirement "
+                    "coverage. Exit codes: 0 clean, 1 uncovered "
+                    "requirements (--fail-on uncovered), 2 parse error.",
+    )
+    p_trace.add_argument("files", nargs="+", help="SysML v2 file(s)")
+    p_trace.add_argument(
+        "--format", choices=("text", "markdown", "json"), default="text",
+        help="Report format (default: text)",
+    )
+    p_trace.add_argument(
+        "--fail-on", choices=("uncovered", "none"), default="none",
+        help="Exit 1 when uncovered requirements exist (default: none)",
+    )
+    p_trace.add_argument(
+        "-o", "--output",
+        help="Write the report to a file instead of stdout",
+    )
+    p_trace.add_argument(
+        "-l", "--library",
+        help="Path to SysML v2 library files to use for parsing",
+    )
+    p_trace.set_defaults(func=cmd_trace)
+
     return parser
 
 

{sysmlpy-0.61.0 → sysmlpy-0.62.0}/src/sysmlpy/antlr_visitor.py

@@ -2311,6 +2311,8 @@ def _visit_behavior_usage_member(bum_ctx):
             return _make_assert_constraint_usage_dict(bue.assertConstraintUsage(), prefix)
         elif hasattr(bue, 'satisfyRequirementUsage') and bue.satisfyRequirementUsage():
             return _make_satisfy_requirement_usage_dict(bue.satisfyRequirementUsage(), prefix)
+        elif hasattr(bue, 'verificationCaseUsage') and bue.verificationCaseUsage():
+            return _make_nested_verification_case_usage_dict(bue.verificationCaseUsage(), prefix)
     
     return None
 
@@ -7850,12 +7852,10 @@ def _make_verification_case_definition_dict(ctx, member_prefix=None):
     """
     name, shortname = _get_definition_identification(ctx)
     occ_prefix = _get_occurrence_definition_prefix(ctx)
-    # Get body items from definition body
-    body_items = []
-    if hasattr(ctx, "definition") and ctx.definition():
-        defn = ctx.definition()
-        if hasattr(defn, "definitionBody") and defn.definitionBody():
-            body_items = _visit_definition_body_dict(defn.definitionBody())
+    # Parse caseBody (subject members, action bodies, etc.) — v0.62.0
+    case_body = {"name": "CaseBody", "item": [], "ownedRelationship": None}
+    if hasattr(ctx, "caseBody") and ctx.caseBody():
+        case_body = _visit_case_body_dict(ctx.caseBody())
     if not name and not shortname:
         name = "VerificationCase_" + str(uuid.uuid4())[:8]
     return {
@@ -7875,11 +7875,7 @@ def _make_verification_case_definition_dict(ctx, member_prefix=None):
                     },
                     "subclassificationpart": _get_subclassification_part(ctx)
                 },
-                "body": {
-                    "name": "CaseBody",
-                    "item": [],
-                    "ownedRelationship": None
-                }
+                "body": case_body
             }
         }
     }
@@ -9258,11 +9254,140 @@ def _visit_requirement_body_item_dict(item_ctx):
     # Check for actorMember (skip for now)
     # Check for stakeholderMember (skip for now)
     # Check for framedConcernMember (skip for now)
-    # Check for requirementVerificationMember (skip for now)
+    # requirementVerificationMember (v0.62.0: requirement traceability)
+    if hasattr(item_ctx, 'requirementVerificationMember') and item_ctx.requirementVerificationMember():
+        rvm = item_ctx.requirementVerificationMember()
+        if isinstance(rvm, list):
+            rvm = rvm[0]
+        verify_dict = _visit_requirement_verification_member_dict(rvm)
+        if verify_dict:
+            return {
+                "name": "RequirementBodyItem",
+                "ownedRelationship": verify_dict
+            }
     
     return None
 
 
+def _visit_requirement_verification_member_dict(rvm_ctx):
+    """Visit a requirementVerificationMember and return its member dict.
+
+    Grammar:
+      requirementVerificationMember : memberPrefix VERIFY requirementVerificationUsage ;
+    """
+    if rvm_ctx is None:
+        return None
+
+    prefix = None
+    if hasattr(rvm_ctx, 'memberPrefix') and rvm_ctx.memberPrefix():
+        mp = rvm_ctx.memberPrefix()
+        if hasattr(mp, 'visibilityIndicator') and mp.visibilityIndicator():
+            prefix = {
+                "name": "MemberPrefix",
+                "visibility": _visit_visibility_indicator_dict(mp.visibilityIndicator())
+            }
+
+    vru = None
+    if hasattr(rvm_ctx, 'requirementVerificationUsage') and rvm_ctx.requirementVerificationUsage():
+        vru = rvm_ctx.requirementVerificationUsage()
+        if isinstance(vru, list):
+            vru = vru[0]
+        usage = _make_verify_requirement_usage_dict(vru)
+        if usage:
+            return {
+                "name": "RequirementVerificationMember",
+                "prefix": prefix,
+                "ownedRelatedElement": usage
+            }
+    return None
+
+
+def _make_verify_requirement_usage_dict(vru_ctx, prefix=None):
+    """Create a VerifyRequirementUsage dictionary.
+
+    Grammar:
+      requirementVerificationUsage
+        : ownedReferenceSubsetting featureSpecialization* requirementBody
+        | ( usageExtensionKeyword* REQUIREMENT | usageExtensionKeyword+ )
+          constraintUsageDeclaration requirementBody
+        ;
+
+    ``verify <ref>;`` references an existing verification case; the
+    requirement-keyword form declares an inline verification usage.
+    """
+    if vru_ctx is None:
+        return None
+
+    ors = None
+    fsp = None
+    declaration = None
+
+    if hasattr(vru_ctx, 'ownedReferenceSubsetting') and vru_ctx.ownedReferenceSubsetting():
+        ors = _build_owned_reference_subsetting_dict(vru_ctx.ownedReferenceSubsetting())
+        if hasattr(vru_ctx, 'featureSpecialization') and vru_ctx.featureSpecialization():
+            fs_list = vru_ctx.featureSpecialization()
+            if not isinstance(fs_list, list):
+                fs_list = [fs_list]
+            specs = []
+            for fs_ctx in fs_list:
+                spec = _build_full_specialization_from_fsp(fs_ctx)
+                if spec is not None:
+                    specs.append(spec)
+            if specs:
+                fsp = specs
+    elif hasattr(vru_ctx, 'constraintUsageDeclaration') and vru_ctx.constraintUsageDeclaration():
+        cud = vru_ctx.constraintUsageDeclaration()
+        name = None
+        shortname = None
+        if hasattr(cud, 'usageDeclaration') and cud.usageDeclaration():
+            ud = cud.usageDeclaration()
+            if hasattr(ud, 'identification') and ud.identification():
+                ident = ud.identification()
+                if hasattr(ident, 'name'):
+                    name_list = ident.name()
+                    if name_list and isinstance(name_list, list):
+                        if len(name_list) == 2:
+                            shortname = name_list[0].getText()
+                            name = name_list[1].getText()
+                        elif len(name_list) == 1:
+                            name_text = name_list[0].getText()
+                            name, shortname = _extract_name_shortname(name_text)
+
+        typed_by = _get_action_usage_typed_by(cud)
+        if typed_by is None:
+            typed_by = _get_action_usage_subsetted_by(cud)
+
+        specialization = _build_specialization(typed_by) if typed_by else None
+        declaration = {
+            "name": "UsageDeclaration",
+            "declaration": {
+                "name": "FeatureDeclaration",
+                "identification": {
+                    "name": "Identification",
+                    "declaredShortName": shortname,
+                    "declaredName": name
+                },
+                "specialization": specialization
+            }
+        }
+
+    body_items = []
+    if hasattr(vru_ctx, 'requirementBody') and vru_ctx.requirementBody():
+        body_items = _visit_requirement_body_dict(vru_ctx.requirementBody())
+
+    return {
+        "name": "VerifyRequirementUsage",
+        "prefix": prefix,
+        "ors": ors,
+        "fsp": fsp,
+        "declaration": declaration,
+        "body": {
+            "name": "RequirementBody",
+            "item": body_items
+        }
+    }
+
+
 def _visit_subject_member_dict(sm_ctx):
     """Visit a subjectMember and return a SubjectMember dict.
     
@@ -10150,6 +10275,9 @@ def _visit_nested_occurrence_usage(occ_elem):
                     }
                 }
             return None
+        elif hasattr(behav_elem, 'verificationCaseUsage') and behav_elem.verificationCaseUsage():
+            ctx = behav_elem.verificationCaseUsage()
+            return _make_nested_verification_case_usage_dict(ctx, None)
         elif hasattr(behav_elem, 'analysisCaseUsage') and behav_elem.analysisCaseUsage():
             ctx = behav_elem.analysisCaseUsage()
             return _make_nested_analysis_case_usage_dict(ctx, None)
@@ -13009,6 +13137,16 @@ def _visit_usage_element_dict(usage_elem_ctx, prefix=None):
                         }
                     }
                 return result
+            elif hasattr(behav_elem, 'verificationCaseUsage') and behav_elem.verificationCaseUsage():
+                ctx = behav_elem.verificationCaseUsage()
+                inner = _make_nested_verification_case_usage_dict(ctx, prefix)
+                if inner:
+                    return {
+                        "name": "PackageMember",
+                        "prefix": None,
+                        "ownedRelatedElement": inner
+                    }
+                return None
             elif hasattr(behav_elem, 'viewpointUsage') and behav_elem.viewpointUsage():
                 ctx = behav_elem.viewpointUsage()
                 return _make_viewpoint_usage_dict(ctx, prefix)
@@ -13018,6 +13156,9 @@ def _visit_usage_element_dict(usage_elem_ctx, prefix=None):
             elif hasattr(behav_elem, 'analysisCaseUsage') and behav_elem.analysisCaseUsage():
                 ctx = behav_elem.analysisCaseUsage()
                 return _make_nested_analysis_case_usage_dict(ctx, prefix)
+            elif hasattr(behav_elem, 'verificationCaseUsage') and behav_elem.verificationCaseUsage():
+                ctx = behav_elem.verificationCaseUsage()
+                return _make_nested_verification_case_usage_dict(ctx, prefix)
             elif hasattr(behav_elem, 'caseUsage') and behav_elem.caseUsage():
                 ctx = behav_elem.caseUsage()
                 return _make_nested_case_usage_dict(ctx, prefix)
@@ -14159,6 +14300,95 @@ def _build_full_specialization_from_fsp(fsp):
     }
 
 
+def _make_nested_verification_case_usage_dict(ctx, prefix=None):
+    """Create a VerificationCaseUsage dict for nested usage (v0.62.0).
+
+    Grammar:
+      verificationCaseUsage : occurrenceUsagePrefix VERIFICATION
+          constraintUsageDeclaration caseBody ;
+
+    Mirrors _make_nested_analysis_case_usage_dict; the emitted
+    BehaviorUsageElement/VerificationCaseUsage pair is dispatched to the
+    existing VerificationCaseUsage grammar class.
+    """
+    if ctx is None:
+        return None
+    
+    # Extract name and specialization from constraintUsageDeclaration
+    name = None
+    shortname = None
+    specialization = None
+    
+    if hasattr(ctx, 'constraintUsageDeclaration') and ctx.constraintUsageDeclaration():
+        cud = ctx.constraintUsageDeclaration()
+        if isinstance(cud, list):
+            cud = cud[0] if cud else None
+        if cud is not None and hasattr(cud, 'usageDeclaration') and cud.usageDeclaration():
+            ud = cud.usageDeclaration()
+            if isinstance(ud, list):
+                ud = ud[0] if ud else None
+            if ud is not None and hasattr(ud, 'identification') and ud.identification():
+                ident = ud.identification()
+                if isinstance(ident, list):
+                    ident = ident[0] if ident else None
+                if ident is not None and hasattr(ident, 'name'):
+                    name_list = ident.name()
+                    if name_list and isinstance(name_list, list):
+                        if len(name_list) == 2:
+                            shortname = name_list[0].getText()
+                            name = name_list[1].getText()
+                        elif len(name_list) == 1:
+                            name_text = name_list[0].getText()
+                            name, shortname = _extract_name_shortname(name_text)
+        
+        # Extract specialization (typing) from constraintUsageDeclaration
+        typed_by = _get_action_usage_typed_by(cud)
+        if typed_by:
+            specialization = _build_specialization(typed_by)
+    
+    occ_prefix = _get_occurrence_usage_prefix(ctx) if ctx else None
+    
+    # Get body items from caseBody
+    body_items = []
+    if hasattr(ctx, 'caseBody') and ctx.caseBody():
+        cb = ctx.caseBody()
+        body_items = _visit_case_body_items(cb)
+    
+    return {
+        "name": "UsageElement",
+        "ownedRelatedElement": {
+            "name": "OccurrenceUsageElement",
+            "ownedRelatedElement": {
+                "name": "BehaviorUsageElement",
+                "ownedRelationship": {
+                    "name": "VerificationCaseUsage",
+                    "prefix": occ_prefix or prefix,
+                    "declaration": {
+                        "name": "CalculationUsageDeclaration",
+                        "declaration": {
+                            "name": "UsageDeclaration",
+                            "declaration": {
+                                "name": "FeatureDeclaration",
+                                "identification": {
+                                    "name": "Identification",
+                                    "declaredShortName": shortname,
+                                    "declaredName": name
+                                },
+                                "specialization": specialization
+                            }
+                        },
+                        "valuepart": None
+                    },
+                    "body": {
+                        "name": "CaseBody",
+                        "item": body_items
+                    }
+                }
+            }
+        }
+    }
+
+
 def _make_nested_analysis_case_usage_dict(ctx, prefix=None):
     """Create an AnalysisCaseUsage dict for nested usage."""
     if ctx is None:

{sysmlpy-0.61.0 → sysmlpy-0.62.0}/src/sysmlpy/definition.py

@@ -1281,6 +1281,22 @@ class Package(Searchable):
                         c.name = decl.identification.declaredName
                 c.parent = self
                 self.children.append(c)
+            elif inner_class == "VerificationCaseUsage":
+                # v0.62.0: `verification <name> : <Type>` usage at package
+                # level (requirement traceability support).
+                c = VerificationCase()
+                c.grammar = inner_element
+                if hasattr(inner_element, 'declaration') and inner_element.declaration:
+                    decl = inner_element.declaration
+                    # CalculationUsageDeclaration → UsageDeclaration →
+                    # FeatureDeclaration → Identification
+                    usage_decl = getattr(decl, 'declaration', None)
+                    if usage_decl := getattr(usage_decl, 'declaration', None) or usage_decl:
+                        feat_decl = usage_decl
+                        if hasattr(feat_decl, 'identification') and feat_decl.identification:
+                            c.name = feat_decl.identification.declaredName
+                c.parent = self
+                self.children.append(c)
             elif inner_class == "AnnotatingElement":
                 wrapper = _GrammarAnnotationWrapper(inner_element)
                 wrapper.parent = self

{sysmlpy-0.61.0 → sysmlpy-0.62.0}/src/sysmlpy/grammar/classes.py

@@ -9650,9 +9650,93 @@ class CaseDefinition(_DeclaredDefinitionBase):
     body_class = CaseBody
 
 
+class VerifyRequirementUsage:
+    # requirementVerificationUsage :
+    # 	ownedReferenceSubsetting featureSpecialization* requirementBody
+    #   | ( usageExtensionKeyword* REQUIREMENT | usageExtensionKeyword+ )
+    #     constraintUsageDeclaration requirementBody
+    # ;
+    """A `verify <ref>` member inside a requirement body (v0.62.0).
+
+    Asserts that the referenced verification case verifies the owning
+    requirement; the requirement-keyword form declares an inline
+    verification usage.
+    """
+    def __init__(self, definition=None):
+        self.keyword = "verify"
+        self.ors = None
+        self.fsp = []
+        self.declaration = None
+        self.body = RequirementBody(None)
+        if definition is not None and valid_definition(definition, self.__class__.__name__):
+            if definition.get("ors") is not None:
+                self.ors = OwnedReferenceSubsetting(definition["ors"])
+            for spec in (definition.get("fsp") or []):
+                self.fsp.append(FeatureSpecializationPart(spec))
+            if definition.get("declaration") is not None:
+                decl_dict = definition["declaration"]
+                if decl_dict.get("name") == "CalculationUsageDeclaration":
+                    # Already CUD-shaped (get_definition round-trip)
+                    self.declaration = CalculationUsageDeclaration(decl_dict)
+                else:
+                    self.declaration = CalculationUsageDeclaration(
+                        {"name": "CalculationUsageDeclaration",
+                         "declaration": decl_dict,
+                         "valuepart": None}
+                    )
+            if definition.get("body") is not None:
+                self.body = RequirementBody(definition["body"])
+
+    def dump(self):
+        output = [self.keyword]
+        if self.ors is not None:
+            output.append(self.ors.dump())
+            for spec in self.fsp:
+                output.append(spec.dump())
+        elif self.declaration is not None:
+            output.append("requirement")
+            output.append(self.declaration.dump())
+        output.append(self.body.dump())
+        return " ".join(filter(None, output))
+
+    def get_definition(self):
+        return {
+            "name": self.__class__.__name__,
+            "ors": self.ors.get_definition() if self.ors else None,
+            "fsp": [spec.get_definition() for spec in self.fsp],
+            "declaration": self.declaration.get_definition() if self.declaration else None,
+            "body": self.body.get_definition() if hasattr(self.body, 'get_definition') else {"name": "RequirementBody", "item": []},
+        }
+
+
+class RequirementVerificationMember:
+    # RequirementVerificationMember :
+    # 	prefix=MemberPrefix VERIFY requirementVerificationUsage
+    # ;
+    def __init__(self, definition=None):
+        self.prefix = None
+        self.child = None
+        if definition is not None and valid_definition(definition, self.__class__.__name__):
+            if definition.get("prefix") is not None:
+                self.prefix = MemberPrefix(definition["prefix"])
+            self.child = VerifyRequirementUsage(definition["ownedRelatedElement"])
+
+    def dump(self):
+        if self.prefix is not None:
+            return " ".join(filter(None, [self.prefix.dump(), self.child.dump()]))
+        return self.child.dump()
+
+    def get_definition(self):
+        return {
+            "name": self.__class__.__name__,
+            "prefix": self.prefix.get_definition() if self.prefix else None,
+            "ownedRelatedElement": self.child.get_definition() if self.child else None,
+        }
+
+
 class VerificationCaseDefinition(_DeclaredDefinitionBase):
     # verificationCaseDefinition : occurrenceDefinitionPrefix VERIFICATION DEF definitionDeclaration caseBody
-    keyword = "verification case def"
+    keyword = "verification def"
     body_class = CaseBody