sysmlpy 0.62.0__tar.gz → 0.64.0__tar.gz

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

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

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

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

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

@@ -19,6 +19,9 @@ __all__ = [
     "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",
+    "evaluate_expression", "evaluate_calculation", "collect_values",
+    "check_constraints", "ConstraintReport", "ConstraintResult",
     "analyze", "AnalysisResult", "SemanticIssue", "SemanticAnalyzer",
     "SysMLSyntaxError", "PartialParseError",
     "loads_partial", "load_partial",
@@ -27,7 +30,7 @@ __all__ = [
     "render_state_transition_view_svg", "boxes_view",
 ]
 __author__ = "Jon Fox"
-__version__ = "0.62.0"
+__version__ = "0.64.0"
 
 from sysmlpy.usage import (
     Item, Attribute, Part, Port, Action, Reference, UseCase, Requirement, Interface, Message,
@@ -47,6 +50,13 @@ from sysmlpy.traceability import (
     extract_traceability, TraceabilityReport, RequirementTrace,
     as_traceability_matrix_view,
 )
+from sysmlpy.interchange import (
+    to_interchange, from_interchange, interchange_to_json_text,
+)
+from sysmlpy.evaluator import (
+    evaluate_expression, evaluate_calculation, collect_values,
+    check_constraints, ConstraintReport, ConstraintResult,
+)
 
 
 class PartialParseError(Exception):

{sysmlpy-0.62.0 → sysmlpy-0.64.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", "trace", "format", "fmt")
+SUBCOMMANDS = ("parse", "analyze", "view", "trace", "export", "import", "eval", "format", "fmt")
 
 
 # ---------------------------------------------------------------------------
@@ -317,6 +317,167 @@ def cmd_trace(args) -> int:
     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
+
+
+def _parse_eval_value(text):
+    """Parse a --set NAME=VALUE literal (number / bool / string / unit)."""
+    from sysmlpy.usage import ureg
+    raw = text
+    low = raw.strip().lower()
+    if low == "true":
+        return True
+    if low == "false":
+        return False
+    try:
+        return int(raw)
+    except ValueError:
+        pass
+    try:
+        return float(raw)
+    except ValueError:
+        pass
+    try:
+        return ureg(raw)
+    except Exception:
+        pass
+    return raw
+
+
+def cmd_eval(args) -> int:
+    """Expression evaluation / constraint checking (v0.64.0, Goal 4)."""
+    from sysmlpy.evaluator import (
+        evaluate_expression, collect_values, check_constraints,
+        EvaluationError,
+    )
+
+    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
+
+    bindings = {}
+    for spec in args.set or []:
+        if "=" not in spec:
+            print(f"Error: --set expects NAME=VALUE, got {spec!r}",
+                  file=sys.stderr)
+            return 2
+        name, _, raw = spec.partition("=")
+        bindings[name.strip()] = _parse_eval_value(raw)
+
+    if args.expr is not None:
+        try:
+            value = evaluate_expression(
+                args.expr, model=model, element=args.element,
+                bindings=bindings,
+            )
+        except EvaluationError as e:
+            print(f"Error: {e}", file=sys.stderr)
+            return 1
+        print(_format_value(value))
+        return 0
+
+    if args.constraints:
+        report = check_constraints(model, bindings=bindings)
+        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 report.failed or report.errored:
+            return 1
+        return 0
+
+    # default: dump all attribute values
+    values = collect_values(model, bindings=bindings)
+    lines = [f"{name} = {_format_value(value)}"
+             for name, value in sorted(values.items())]
+    output = "\n".join(lines) if lines else "(no attribute values)"
+    if args.output:
+        Path(args.output).write_text(output + "\n", encoding="utf-8")
+        print(f"Wrote {args.output}")
+    else:
+        print(output)
+    return 0
+
+
+def _format_value(value):
+    if isinstance(value, bool):
+        return str(value)
+    if value is None:
+        return "null"
+    return str(value)
+
+
 # ---------------------------------------------------------------------------
 # legacy flat invocation (kept for backward compatibility)
 # ---------------------------------------------------------------------------
@@ -541,6 +702,79 @@ def build_parser() -> argparse.ArgumentParser:
     )
     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)
+
+    p_eval = sub.add_parser(
+        "eval",
+        help="Evaluate expressions, attribute values and constraints",
+        description="Bind pint attribute values and evaluate SysML "
+                    "expressions, calc results, or constraint bodies. "
+                    "Exit codes: 0 clean, 1 constraint failed / "
+                    "evaluation error, 2 parse error.",
+    )
+    p_eval.add_argument("files", nargs="+", help="SysML v2 file(s)")
+    p_eval.add_argument(
+        "--expr",
+        help="Evaluate this expression against the model scope",
+    )
+    p_eval.add_argument(
+        "--set", action="append", metavar="NAME=VALUE",
+        help="Override a name for this evaluation (repeatable; values "
+             "may be numbers, true/false, or unit strings like '80 km/h')",
+    )
+    p_eval.add_argument(
+        "--element",
+        help="Qualified element name whose scope to evaluate in",
+    )
+    p_eval.add_argument(
+        "--constraints", action="store_true",
+        help="Evaluate all constraint bodies; exit 1 on any failure",
+    )
+    p_eval.add_argument(
+        "-o", "--output",
+        help="Write the report/value to a file instead of stdout",
+    )
+    p_eval.add_argument(
+        "-l", "--library",
+        help="Path to SysML v2 library files to use for parsing",
+    )
+    p_eval.set_defaults(func=cmd_eval)
+
     return parser
 
 

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

@@ -12732,6 +12732,17 @@ def _visit_nested_definition_element(def_elem):
         return _make_port_definition_dict(def_elem.portDefinition(), None)
     elif hasattr(def_elem, 'interfaceDefinition') and def_elem.interfaceDefinition():
         return _make_interface_definition_dict(def_elem.interfaceDefinition(), None)
+    elif hasattr(def_elem, 'calculationDefinition') and def_elem.calculationDefinition():
+        # v0.64.0 (Goal 4): calc defs inside part/item/etc. bodies were
+        # silently dropped (returned None), losing the result expression
+        # the evaluator needs.
+        return _make_calculation_definition_dict(
+            def_elem.calculationDefinition(), None
+        )
+    elif hasattr(def_elem, 'constraintDefinition') and def_elem.constraintDefinition():
+        return _make_constraint_definition_dict(
+            def_elem.constraintDefinition(), None
+        )
     elif hasattr(def_elem, 'annotatingElement') and def_elem.annotatingElement():
         ann_ctx = def_elem.annotatingElement()
         ann_dict = _visit_annotating_element_dict(ann_ctx)

{sysmlpy-0.62.0 → sysmlpy-0.64.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: