sysmlpy 0.61.0__tar.gz → 0.63.0__tar.gz

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

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

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

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

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

@@ -16,7 +16,10 @@ __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",
+    "to_interchange", "from_interchange", "interchange_to_json_text",
     "analyze", "AnalysisResult", "SemanticIssue", "SemanticAnalyzer",
     "SysMLSyntaxError", "PartialParseError",
     "loads_partial", "load_partial",
@@ -25,7 +28,7 @@ __all__ = [
     "render_state_transition_view_svg", "boxes_view",
 ]
 __author__ = "Jon Fox"
-__version__ = "0.61.0"
+__version__ = "0.63.0"
 
 from sysmlpy.usage import (
     Item, Attribute, Part, Port, Action, Reference, UseCase, Requirement, Interface, Message,
@@ -41,6 +44,13 @@ 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,
+)
+from sysmlpy.interchange import (
+    to_interchange, from_interchange, interchange_to_json_text,
+)
 
 
 class PartialParseError(Exception):

{sysmlpy-0.61.0 → sysmlpy-0.63.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", "export", "import", "format", "fmt")
 
 
 # ---------------------------------------------------------------------------
@@ -277,6 +277,111 @@ 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
+
+
+def cmd_export(args) -> int:
+    """SysML text → JSON interchange document (v0.63.0, Goal 3)."""
+    from sysmlpy.interchange import to_interchange, interchange_to_json_text
+
+    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
+
+    try:
+        document = to_interchange(model)
+    except Exception as e:
+        print(f"Error: export failed on this model: {e}", file=sys.stderr)
+        return 1
+
+    output = interchange_to_json_text(document, indent=None if args.compact else 2)
+    if args.output:
+        Path(args.output).write_text(output + "\n", encoding="utf-8")
+        print(f"Wrote {args.output}")
+    else:
+        print(output)
+    return 0
+
+
+def cmd_import(args) -> int:
+    """JSON interchange document → SysML text (v0.63.0, Goal 3)."""
+    from sysmlpy.interchange import from_interchange
+
+    path = Path(args.file)
+    if not path.exists():
+        print(f"Error: File '{path}' not found.", file=sys.stderr)
+        return 2
+
+    try:
+        content = path.read_text(encoding="utf-8")
+    except OSError as e:
+        print(f"Error reading file: {e}", file=sys.stderr)
+        return 2
+
+    try:
+        model = from_interchange(content)
+    except ValueError as e:
+        print(f"Error: invalid interchange document: {e}", file=sys.stderr)
+        return 2
+    except json.JSONDecodeError as e:
+        print(f"Error: not valid JSON: {e}", file=sys.stderr)
+        return 2
+
+    output = model.dump()
+    if args.output:
+        if not output.endswith("\n"):
+            output += "\n"
+        Path(args.output).write_text(output, encoding="utf-8")
+        print(f"Wrote {args.output}")
+    else:
+        print(output)
+    return 0
+
+
 # ---------------------------------------------------------------------------
 # legacy flat invocation (kept for backward compatibility)
 # ---------------------------------------------------------------------------
@@ -474,6 +579,70 @@ 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)
+
+    p_export = sub.add_parser(
+        "export",
+        help="Export SysML to the JSON interchange format",
+        description="Load the files as one merged model and emit a "
+                    "JSON-LD-style partition interchange document "
+                    "(flat @graph of elements with @id/@type). Exit 2 "
+                    "on parse failure.",
+    )
+    p_export.add_argument("files", nargs="+", help="SysML v2 file(s)")
+    p_export.add_argument(
+        "-o", "--output",
+        help="Write the JSON document to a file instead of stdout",
+    )
+    p_export.add_argument(
+        "--compact", action="store_true",
+        help="Emit compact JSON (no indentation)",
+    )
+    p_export.add_argument(
+        "-l", "--library",
+        help="Path to SysML v2 library files to use for parsing",
+    )
+    p_export.set_defaults(func=cmd_export)
+
+    p_import = sub.add_parser(
+        "import",
+        help="Import a JSON interchange document as SysML text",
+        description="Rebuild a model from a JSON interchange document "
+                    "(sysmlpy export format) and print or write the "
+                    "equivalent SysML v2 text. Exit 2 on invalid input.",
+    )
+    p_import.add_argument("file", help="Interchange JSON file")
+    p_import.add_argument(
+        "-o", "--output",
+        help="Write the SysML text to a file instead of stdout",
+    )
+    p_import.set_defaults(func=cmd_import)
+
     return parser
 
 

{sysmlpy-0.61.0 → sysmlpy-0.63.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.63.0}/src/sysmlpy/definition.py

@@ -93,7 +93,15 @@ class Model(Searchable):
                 raise ValueError("Base Model must be encapsulated by a package.")
         
         definition = load_grammar_antlr(s, library=library)["ownedRelationship"]
+        return self._load_definition(definition)
 
+    def _load_definition(self: type[ModelType], definition) -> ModelType:
+        """Build the model from a parsed definition-dict member list.
+
+        Shared by :meth:`load` (fresh parse) and the JSON interchange
+        importer (v0.63.0 — ``from_interchange`` feeds the rebuilt dict
+        straight into this path).
+        """
         member_grammar = []
         found_package = False
         for member in definition:
@@ -1281,6 +1289,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