sysmlpy 0.91.0__tar.gz → 0.95.0__tar.gz

{sysmlpy-0.91.0 → sysmlpy-0.95.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sysmlpy
-Version: 0.91.0
+Version: 0.95.0
 Summary: 
 License-File: LICENSE
 Author: Jon R. Fox (mycr0ft)
@@ -17,6 +17,7 @@ Provides-Extra: cayley
 Provides-Extra: graph
 Provides-Extra: jupyter
 Provides-Extra: kuzu
+Provides-Extra: reqif
 Provides-Extra: sim
 Provides-Extra: xlsx
 Requires-Dist: antlr4-python3-runtime (>=4.13)
@@ -27,6 +28,7 @@ Requires-Dist: networkx (>=3.0) ; extra == "graph"
 Requires-Dist: openpyxl (>=3.1) ; extra == "xlsx"
 Requires-Dist: pint (>=0.24)
 Requires-Dist: pyyaml (>=6.0)
+Requires-Dist: reqif (>=0.1) ; extra == "reqif"
 Requires-Dist: requests (>=2.31) ; extra == "cayley"
 Requires-Dist: transitions (>=0.9,<0.10) ; extra == "sim"
 Description-Content-Type: text/markdown
@@ -73,6 +75,7 @@ sysmlpy requires the following Python packages:
 - [networkx](https://networkx.org/) — graph analysis backend (install with `pip install sysmlpy[graph]`)
 - [kuzu](https://kuzudb.com/) — embedded graph database with disk persistence and Cypher queries (install with `pip install sysmlpy[kuzu]`)
 - [cayley](https://cayley.io/) — graph database via HTTP API, supports BoltDB/LevelDB backends (install with `pip install sysmlpy[cayley]`)
+- [reqif](https://github.com/strictdoc-project/reqif) — ReqIF 1.0 requirements interchange, import/export with any ReqIF-capable tool (install with `pip install sysmlpy[reqif]`; see [ReqIF Interchange](#reqif-interchange-requirements-interchange-format))
 - [PlantUML](https://plantuml.com/) **v1.2020.0+** — diagram rendering (requires Java + PlantUML JAR or [PlantUML server](https://www.plantuml.com/plantuml)). The generator uses `<style>` blocks and `skinparam` stereotype selectors introduced in v1.2020.
 - [IPython](https://ipython.org/) **v8.0+** — the `%%sysml` Jupyter cell magic (install with `pip install sysmlpy[jupyter]`; see [Jupyter integration](#jupyter-integration))
 
@@ -150,9 +153,12 @@ threshold or operational error, `2` = parse/load failure — so
 | `sysmlpy trace <file>` | Requirement traceability & verification coverage |
 | `sysmlpy export <file>` | Export to the JSON interchange format |
 | `sysmlpy import <file>` | Import a JSON interchange document as SysML text |
+| `sysmlpy reqif-import <file>` | Import a ReqIF file as SysML v2 requirements |
+| `sysmlpy reqif-export <file>` | Export model requirements as ReqIF 1.0 XML |
 | `sysmlpy eval <file>` | Evaluate expressions, attribute values, constraints |
 | `sysmlpy sim <file>` | Simulate a state machine (guards evaluated for real) |
 | `sysmlpy xlsx <file>` | Export tabular views to an Excel workbook |
+| `sysmlpy repl <file...>` | Interactive REPL: declarations accumulate into a session model; `%eval`, `%sim`, `%view`, `%check`, ... inspect it |
 | `sysmlpy-lsp` | Language server (stdio) for SysML v2 editors |
 
 Examples:
@@ -171,6 +177,15 @@ sysmlpy view model.sysml --view sv > model.puml
 # Drive a state machine interactively
 sysmlpy sim traffic_light.sysml
 
+# Or work in an accumulating session: declare, query, evaluate, simulate
+sysmlpy repl
+sysml> package Demo { part def Wheel { attribute diameter : Real = 16.0; } }
+✓ Demo
+sysml> %eval Demo::Wheel::diameter
+= 16.0
+sysml> %view Demo pkg
+sysml> %quit
+
 # Excel workbook of the tabular views
 sysmlpy xlsx bill_of_materials.sysml -o bom.xlsx
 ```
@@ -864,6 +879,77 @@ See [`docs/plantuml-examples/`](docs/plantuml-examples/) for all rendered exampl
 | 15 | Relationship Matrix (GridView) | Relationship Matrix |
 | 16 | Tabular View — Color | Tabular View (color) |
 
+## ReqIF Interchange (Requirements Interchange Format)
+
+sysmlpy imports and exports **ReqIF 1.0** — the OMG requirements interchange
+standard used by DOORS, Polarion, ReqIF Studio, Capella, Enterprise Architect,
+and most requirements-management tools. This makes sysmlpy a viable
+*single source of truth* for requirements: author them as SysML v2
+`requirement` elements, then exchange them with any ReqIF-capable toolchain.
+
+Install the optional dependency once:
+
+```bash
+pip install sysmlpy[reqif]
+```
+
+### Import — ReqIF → SysML requirements
+
+```python
+from sysmlpy import reqif_import, loads
+
+text = reqif_import("requirements.reqif")   # ReqIF XML → SysML v2 text
+model = loads(text)                         # → live requirement tree
+```
+
+Each ReqIF SpecObject becomes a `requirement` element; the ReqIF
+specification hierarchy becomes requirement ownership nesting;
+`ReqIF.Text` (XHTML) becomes the requirement's `doc` comment with tags
+stripped; other attributes (e.g. `ReqIF.ForeignID`) are folded into the
+doc so no data is lost.
+
+### Export — SysML requirements → ReqIF
+
+```python
+from sysmlpy import loads, reqif_export
+
+model = loads("model.sysml")
+reqif_export(model, "requirements.reqif")
+```
+
+Requirement ownership becomes the ReqIF hierarchy; `doc` comments become
+`ReqIF.Text` XHTML values.
+
+### CLI
+
+```bash
+sysmlpy reqif-import requirements.reqif -o requirements.sysml
+sysmlpy reqif-export model.sysml -o requirements.reqif
+```
+
+The import direction was validated against real-world anonymized ReqIF
+files from multiple vendor flavors (ReqIF Studio, DOORS, Polarion,
+Eclipse RMF, Enterprise Architect — see the
+[reqif project's corpus](https://github.com/strictdoc-project/reqif/tree/main/tests/integration/reqif_software)),
+including a 137-requirement model with a 3-level hierarchy and 14
+relations, round-tripped through sysmlpy with exact structural fidelity.
+
+> **Note:** ReqIF "flavors" differ across tools (attribute naming,
+> datatypes, relation semantics). The importer handles the common
+> `ReqIF.Text` / `ReqIF.ChapterName` / `ReqIF.ForeignID` attributes
+> found in every flavor; exotic vendor extensions are skipped
+> gracefully. If a file fails to import, it is genuinely malformed.
+
+### Relationship to other tools
+
+- **Cameo / MagicDraw** — export ReqIF from them, import with sysmlpy;
+  no license needed on the sysmlpy side.
+- **Doorstop** — the [Doorstop](https://doorstop.readthedocs.io) text-file
+  requirements tool can serve as a git-native review/publishing front-end;
+  exchange via ReqIF or the XLSX bridge.
+- **[strictdoc/reqif](https://github.com/strictdoc-project/reqif)** — the
+  parser library sysmlpy uses for the ReqIF wire format (Apache-2.0).
+
 ## Conformance
 
 **100% of 123 OMG XPect conformance tests pass** (123/123).

{sysmlpy-0.91.0 → sysmlpy-0.95.0}/README.md

@@ -40,6 +40,7 @@ sysmlpy requires the following Python packages:
 - [networkx](https://networkx.org/) — graph analysis backend (install with `pip install sysmlpy[graph]`)
 - [kuzu](https://kuzudb.com/) — embedded graph database with disk persistence and Cypher queries (install with `pip install sysmlpy[kuzu]`)
 - [cayley](https://cayley.io/) — graph database via HTTP API, supports BoltDB/LevelDB backends (install with `pip install sysmlpy[cayley]`)
+- [reqif](https://github.com/strictdoc-project/reqif) — ReqIF 1.0 requirements interchange, import/export with any ReqIF-capable tool (install with `pip install sysmlpy[reqif]`; see [ReqIF Interchange](#reqif-interchange-requirements-interchange-format))
 - [PlantUML](https://plantuml.com/) **v1.2020.0+** — diagram rendering (requires Java + PlantUML JAR or [PlantUML server](https://www.plantuml.com/plantuml)). The generator uses `<style>` blocks and `skinparam` stereotype selectors introduced in v1.2020.
 - [IPython](https://ipython.org/) **v8.0+** — the `%%sysml` Jupyter cell magic (install with `pip install sysmlpy[jupyter]`; see [Jupyter integration](#jupyter-integration))
 
@@ -117,9 +118,12 @@ threshold or operational error, `2` = parse/load failure — so
 | `sysmlpy trace <file>` | Requirement traceability & verification coverage |
 | `sysmlpy export <file>` | Export to the JSON interchange format |
 | `sysmlpy import <file>` | Import a JSON interchange document as SysML text |
+| `sysmlpy reqif-import <file>` | Import a ReqIF file as SysML v2 requirements |
+| `sysmlpy reqif-export <file>` | Export model requirements as ReqIF 1.0 XML |
 | `sysmlpy eval <file>` | Evaluate expressions, attribute values, constraints |
 | `sysmlpy sim <file>` | Simulate a state machine (guards evaluated for real) |
 | `sysmlpy xlsx <file>` | Export tabular views to an Excel workbook |
+| `sysmlpy repl <file...>` | Interactive REPL: declarations accumulate into a session model; `%eval`, `%sim`, `%view`, `%check`, ... inspect it |
 | `sysmlpy-lsp` | Language server (stdio) for SysML v2 editors |
 
 Examples:
@@ -138,6 +142,15 @@ sysmlpy view model.sysml --view sv > model.puml
 # Drive a state machine interactively
 sysmlpy sim traffic_light.sysml
 
+# Or work in an accumulating session: declare, query, evaluate, simulate
+sysmlpy repl
+sysml> package Demo { part def Wheel { attribute diameter : Real = 16.0; } }
+✓ Demo
+sysml> %eval Demo::Wheel::diameter
+= 16.0
+sysml> %view Demo pkg
+sysml> %quit
+
 # Excel workbook of the tabular views
 sysmlpy xlsx bill_of_materials.sysml -o bom.xlsx
 ```
@@ -831,6 +844,77 @@ See [`docs/plantuml-examples/`](docs/plantuml-examples/) for all rendered exampl
 | 15 | Relationship Matrix (GridView) | Relationship Matrix |
 | 16 | Tabular View — Color | Tabular View (color) |
 
+## ReqIF Interchange (Requirements Interchange Format)
+
+sysmlpy imports and exports **ReqIF 1.0** — the OMG requirements interchange
+standard used by DOORS, Polarion, ReqIF Studio, Capella, Enterprise Architect,
+and most requirements-management tools. This makes sysmlpy a viable
+*single source of truth* for requirements: author them as SysML v2
+`requirement` elements, then exchange them with any ReqIF-capable toolchain.
+
+Install the optional dependency once:
+
+```bash
+pip install sysmlpy[reqif]
+```
+
+### Import — ReqIF → SysML requirements
+
+```python
+from sysmlpy import reqif_import, loads
+
+text = reqif_import("requirements.reqif")   # ReqIF XML → SysML v2 text
+model = loads(text)                         # → live requirement tree
+```
+
+Each ReqIF SpecObject becomes a `requirement` element; the ReqIF
+specification hierarchy becomes requirement ownership nesting;
+`ReqIF.Text` (XHTML) becomes the requirement's `doc` comment with tags
+stripped; other attributes (e.g. `ReqIF.ForeignID`) are folded into the
+doc so no data is lost.
+
+### Export — SysML requirements → ReqIF
+
+```python
+from sysmlpy import loads, reqif_export
+
+model = loads("model.sysml")
+reqif_export(model, "requirements.reqif")
+```
+
+Requirement ownership becomes the ReqIF hierarchy; `doc` comments become
+`ReqIF.Text` XHTML values.
+
+### CLI
+
+```bash
+sysmlpy reqif-import requirements.reqif -o requirements.sysml
+sysmlpy reqif-export model.sysml -o requirements.reqif
+```
+
+The import direction was validated against real-world anonymized ReqIF
+files from multiple vendor flavors (ReqIF Studio, DOORS, Polarion,
+Eclipse RMF, Enterprise Architect — see the
+[reqif project's corpus](https://github.com/strictdoc-project/reqif/tree/main/tests/integration/reqif_software)),
+including a 137-requirement model with a 3-level hierarchy and 14
+relations, round-tripped through sysmlpy with exact structural fidelity.
+
+> **Note:** ReqIF "flavors" differ across tools (attribute naming,
+> datatypes, relation semantics). The importer handles the common
+> `ReqIF.Text` / `ReqIF.ChapterName` / `ReqIF.ForeignID` attributes
+> found in every flavor; exotic vendor extensions are skipped
+> gracefully. If a file fails to import, it is genuinely malformed.
+
+### Relationship to other tools
+
+- **Cameo / MagicDraw** — export ReqIF from them, import with sysmlpy;
+  no license needed on the sysmlpy side.
+- **Doorstop** — the [Doorstop](https://doorstop.readthedocs.io) text-file
+  requirements tool can serve as a git-native review/publishing front-end;
+  exchange via ReqIF or the XLSX bridge.
+- **[strictdoc/reqif](https://github.com/strictdoc-project/reqif)** — the
+  parser library sysmlpy uses for the ReqIF wire format (Apache-2.0).
+
 ## Conformance
 
 **100% of 123 OMG XPect conformance tests pass** (123/123).

{sysmlpy-0.91.0 → sysmlpy-0.95.0}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "poetry.core.masonry.api"
 
 [project]
 name = "sysmlpy"
-version = "0.91.0"
+version = "0.95.0"
 description = ""
 authors = [{ name = "Jon R. Fox (mycr0ft)", email = "jon.fox@drfox.com" }]
 readme = "README.md"
@@ -20,6 +20,7 @@ antlr4-python3-runtime = ">=4.13"
 networkx = { version = ">=3.0", optional = true }
 kuzu = { version = ">=0.7,<0.12", optional = true }
 openpyxl = { version = ">=3.1", optional = true }
+reqif = { version = ">=0.1", optional = true }
 arrow = "^1.4.0"
 transitions = {version = "^0.9", optional = true}
 requests = { version = ">=2.31", optional = true }
@@ -30,6 +31,7 @@ graph = ["networkx"]
 kuzu = ["kuzu"]
 xlsx = ["openpyxl"]
 sim = ["transitions"]
+reqif = ["reqif"]
 cayley = ["requests"]
 jupyter = ["ipython"]
 

{sysmlpy-0.91.0 → sysmlpy-0.95.0}/src/sysmlpy/__init__.py

@@ -20,6 +20,7 @@ __all__ = [
     "as_sequence_view", "as_case_view", "as_browser_view",
     "extract_traceability", "TraceabilityReport", "RequirementTrace",
     "to_interchange", "from_interchange", "interchange_to_json_text",
+    "reqif_import", "reqif_import_model", "reqif_export",
     "evaluate_expression", "evaluate_calculation", "collect_values",
     "check_constraints", "ConstraintReport", "ConstraintResult",
     "tabular_view_to_csv", "data_value_tabular_to_csv",
@@ -34,7 +35,7 @@ __all__ = [
     "render_state_transition_view_svg", "boxes_view",
 ]
 __author__ = "Jon Fox"
-__version__ = "0.91.0"
+__version__ = "0.95.0"
 
 from sysmlpy.usage import (
     Item, Attribute, Part, Port, Action, Reference, UseCase, Requirement, Interface, Message,
@@ -57,6 +58,9 @@ from sysmlpy.traceability import (
 from sysmlpy.interchange import (
     to_interchange, from_interchange, interchange_to_json_text,
 )
+from sysmlpy.reqif_io import (
+    reqif_import, reqif_import_model, reqif_export,
+)
 from sysmlpy.evaluator import (
     evaluate_expression, evaluate_calculation, collect_values,
     check_constraints, ConstraintReport, ConstraintResult,

{sysmlpy-0.91.0 → sysmlpy-0.95.0}/src/sysmlpy/__main__.py

@@ -33,7 +33,8 @@ from sysmlpy import loads
 
 # Subcommand table, also used to detect the legacy flat invocation form.
 SUBCOMMANDS = ("parse", "analyze", "view", "trace", "export", "import",
-               "eval", "xlsx", "sim", "diff", "format", "fmt")
+               "reqif-import", "reqif-export",
+               "eval", "xlsx", "sim", "diff", "format", "fmt", "repl")
 
 
 # ---------------------------------------------------------------------------
@@ -442,6 +443,60 @@ def cmd_import(args) -> int:
     return 0
 
 
+def cmd_reqif_import(args) -> int:
+    """ReqIF file → SysML v2 requirements text."""
+    from sysmlpy.reqif_io import ReqIFImportError, reqif_import
+
+    path = Path(args.file)
+    if not path.exists():
+        print(f"Error: File '{path}' not found.", file=sys.stderr)
+        return 2
+
+    try:
+        output = reqif_import(str(path))
+    except ReqIFImportError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        return 2
+    except Exception as e:  # noqa: BLE001 - surface parser failures cleanly
+        print(f"Error: ReqIF import failed: {e}", file=sys.stderr)
+        return 2
+
+    if args.output:
+        Path(args.output).write_text(output, encoding="utf-8")
+        print(f"Wrote {args.output}")
+    else:
+        print(output)
+    return 0
+
+
+def cmd_reqif_export(args) -> int:
+    """SysML requirements → ReqIF 1.0 XML."""
+    from sysmlpy.reqif_io import ReqIFExportError, reqif_export
+
+    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:
+        reqif_export(model, args.output)
+    except ReqIFExportError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        return 1
+    except Exception as e:  # noqa: BLE001 - surface unparser failures cleanly
+        print(f"Error: ReqIF export failed: {e}", file=sys.stderr)
+        return 1
+
+    print(f"Wrote {args.output}")
+    return 0
+
+
 def _parse_eval_value(text):
     """Parse a --set NAME=VALUE literal (number / bool / string / unit)."""
     from sysmlpy.usage import ureg
@@ -606,6 +661,16 @@ def cmd_sim(args) -> int:
     return 0
 
 
+def cmd_repl(args) -> int:
+    """Interactive REPL (declarations accumulate; %commands inspect)."""
+    from sysmlpy.repl import main as repl_main
+
+    return repl_main(
+        [*(args.files or []), *(["--no-banner"] if args.no_banner else [])]
+        + (["-l", args.library] if getattr(args, "library", None) else []),
+    )
+
+
 def cmd_xlsx(args) -> int:
     """Export tabular views to an Excel workbook (v0.66.0, Goal 7)."""
     from sysmlpy.spreadsheet import write_xlsx
@@ -922,6 +987,43 @@ def build_parser() -> argparse.ArgumentParser:
     )
     p_import.set_defaults(func=cmd_import)
 
+    # -- reqif-import / reqif-export ------------------------------------------
+    p_reqif_import = sub.add_parser(
+        "reqif-import",
+        help="Import a ReqIF file as SysML v2 requirements",
+        description="Convert a ReqIF 1.0 XML file (ReqIF Studio, DOORS, "
+                    "Polarion, Eclipse RMF, ...) into SysML v2 requirement "
+                    "usages, nested by the ReqIF specification hierarchy. "
+                    "Exit 2 on invalid input. Requires the optional 'reqif' "
+                    "package.",
+    )
+    p_reqif_import.add_argument("file", help="ReqIF XML file")
+    p_reqif_import.add_argument(
+        "-o", "--output",
+        help="Write the SysML text to a file instead of stdout",
+    )
+    p_reqif_import.set_defaults(func=cmd_reqif_import)
+
+    p_reqif_export = sub.add_parser(
+        "reqif-export",
+        help="Export model requirements as a ReqIF 1.0 file",
+        description="Export the requirements of the merged model as ReqIF "
+                    "1.0 XML (one spec object per requirement, hierarchy "
+                    "from ownership, doc comments as ReqIF.Text). Exit 1 "
+                    "when the model has no requirements. Requires the "
+                    "optional 'reqif' package.",
+    )
+    p_reqif_export.add_argument("files", nargs="+", help="SysML v2 file(s)")
+    p_reqif_export.add_argument(
+        "-o", "--output", required=True,
+        help="Destination ReqIF XML file",
+    )
+    p_reqif_export.add_argument(
+        "-l", "--library",
+        help="Path to SysML v2 library files to use for parsing",
+    )
+    p_reqif_export.set_defaults(func=cmd_reqif_export)
+
     p_eval = sub.add_parser(
         "eval",
         help="Evaluate expressions, attribute values and constraints",
@@ -1030,6 +1132,27 @@ def build_parser() -> argparse.ArgumentParser:
     )
     p_xlsx.set_defaults(func=cmd_xlsx)
 
+    # -- repl ----------------------------------------------------------------
+    p_repl = sub.add_parser(
+        "repl",
+        help="Interactive SysML v2 REPL",
+        description="Declarations accumulate into a session model; "
+                    "%commands inspect it (%eval, %sim, %view, ...). "
+                    "See %help inside the REPL for the command list.",
+    )
+    p_repl.add_argument("files", nargs="*", metavar="FILE",
+                        help="model file(s) to load into the session first")
+    p_repl.add_argument(
+        "-l", "--library",
+        help="Path to SysML v2 library files (accepted for parity; "
+             "submissions parse without it)",
+    )
+    p_repl.add_argument(
+        "--no-banner", action="store_true",
+        help="suppress the startup banner",
+    )
+    p_repl.set_defaults(func=cmd_repl)
+
     return parser
 
 

{sysmlpy-0.91.0 → sysmlpy-0.95.0}/src/sysmlpy/antlr_visitor.py

@@ -6389,6 +6389,92 @@ def _make_state_usage_dict(ctx, prefix=None):
     }
 
 
+def _make_exhibit_state_usage_dict(ctx, prefix=None):
+    """Create a StateUsage dictionary for an ``exhibit state`` usage.
+
+    Grammar:
+      exhibitStateUsage
+        : occurrenceUsagePrefix EXHIBIT
+          ( ownedReferenceSubsetting featureSpecializationPart?
+          | STATE usageDeclaration? ) valuePart? stateUsageBody
+        ;
+
+    Both spellings met in practice carry a usageDeclaration:
+      exhibit state phases : MissionPhases;   (typed reference)
+      exhibit state modes { ... }             (inline body)
+    The dict is a StateUsage with ``exhibit: True`` so the grammar class
+    dumps the ``exhibit`` keyword and every downstream consumer (public
+    tree, boxes collector, sim) sees a plain StateUsage node. Previously
+    ``exhibit state`` was silently dropped by the visitor, which made
+    part-embedded state machines invisible to sim and lossy on dump.
+    """
+    if ctx is None:
+        return None
+
+    occ_prefix = _get_occurrence_usage_prefix(ctx)
+    if prefix is not None:
+        occ_prefix = prefix
+
+    # Declaration: name/shortname from the usageDeclaration, typing from
+    # its featureSpecializationPart (``: MissionPhases``).
+    name, shortname = _get_usage_identification(ctx)
+    specialization = _build_full_specialization_from_ctx(ctx)
+
+    decl_dict = None
+    if hasattr(ctx, 'usageDeclaration') and ctx.usageDeclaration():
+        ud = ctx.usageDeclaration()
+        if isinstance(ud, list):
+            ud = ud[0] if ud else None
+        if ud is not None:
+            decl_dict = {
+                "name": "ActionUsageDeclaration",
+                "declaration": {
+                    "name": "UsageDeclaration",
+                    "declaration": {
+                        "name": "FeatureDeclaration",
+                        "identification": {
+                            "name": "Identification",
+                            "declaredShortName": shortname,
+                            "declaredName": name
+                        },
+                        "specialization": specialization
+                    }
+                },
+                "valuepart": None
+            }
+
+    # Body: a stateUsageBody, exactly like a plain stateUsage.
+    body_dict = {"name": "StateUsageBody", "body": {"name": "StateDefBody", "part": None, "isParallel": None}}
+    if hasattr(ctx, 'stateUsageBody') and ctx.stateUsageBody():
+        sub = ctx.stateUsageBody()
+        if isinstance(sub, list):
+            sub = sub[0]
+        if sub:
+            body_dict = _visit_state_usage_body(sub)
+
+    return {
+        "name": "PackageMember",
+        "prefix": None,
+        "ownedRelatedElement": {
+            "name": "UsageElement",
+            "ownedRelatedElement": {
+                "name": "OccurrenceUsageElement",
+                "ownedRelatedElement": {
+                    "name": "BehaviorUsageElement",
+                    "ownedRelationship": {
+                        "name": "StateUsage",
+                        "prefix": occ_prefix,
+                        "exhibit": True,
+                        "keyword": "state",
+                        "declaration": decl_dict,
+                        "body": body_dict
+                    }
+                }
+            }
+        }
+    }
+
+
 def _make_calculation_usage_dict(ctx, prefix=None):
     """Create a CalculationUsage dictionary.
     
@@ -10650,6 +10736,16 @@ def _visit_nested_occurrence_usage(occ_elem):
                 inner = result.get("ownedRelatedElement", {})
                 return inner
             return result
+        elif hasattr(behav_elem, 'exhibitStateUsage') and behav_elem.exhibitStateUsage():
+            # ``exhibit state`` usages share the BehaviorUsageElement
+            # wrapper; previously silently dropped (part-embedded state
+            # machines vanished from the tree, dump, boxes and sim).
+            ctx = behav_elem.exhibitStateUsage()
+            result = _make_exhibit_state_usage_dict(ctx, None)
+            if result and result.get("name") == "PackageMember":
+                inner = result.get("ownedRelatedElement", {})
+                return inner
+            return result
         elif hasattr(behav_elem, 'allocationUsage') and behav_elem.allocationUsage():
             # Phase 0: allocation usages inside a definition body.
             ctx = behav_elem.allocationUsage()
@@ -13136,6 +13232,11 @@ def _visit_usage_element_dict(usage_elem_ctx, prefix=None):
             if hasattr(behav_elem, 'stateUsage') and behav_elem.stateUsage():
                 ctx = behav_elem.stateUsage()
                 return _make_state_usage_dict(ctx, prefix)
+            elif hasattr(behav_elem, 'exhibitStateUsage') and behav_elem.exhibitStateUsage():
+                # ``exhibit state`` — same wrapper, StateUsage with
+                # exhibit=True (previously dropped).
+                ctx = behav_elem.exhibitStateUsage()
+                return _make_exhibit_state_usage_dict(ctx, prefix)
             elif hasattr(behav_elem, 'performActionUsage') and behav_elem.performActionUsage():
                 ctx = behav_elem.performActionUsage()
                 return _make_nested_perform_action_usage_dict(ctx, None)

{sysmlpy-0.91.0 → sysmlpy-0.95.0}/src/sysmlpy/evaluator.py

@@ -96,6 +96,28 @@ def _sqrt(x):
     return math.sqrt(x)
 
 
+def _exp(x):
+    if isinstance(x, ureg.Quantity):
+        return math.exp(x.magnitude) * ureg.dimensionless
+    return math.exp(x)
+
+
+def _ln(x):
+    if isinstance(x, ureg.Quantity):
+        return math.log(x.magnitude) * ureg.dimensionless
+    return math.log(x)
+
+
+def _log(x, base=None):
+    if isinstance(x, ureg.Quantity):
+        x = x.magnitude
+    if base is None:
+        return math.log10(x) * ureg.dimensionless
+    if isinstance(base, ureg.Quantity):
+        base = base.magnitude
+    return math.log(x, base) * ureg.dimensionless
+
+
 def _floor(x):
     if isinstance(x, ureg.Quantity):
         return math.floor(x.magnitude) * x.units
@@ -110,6 +132,11 @@ def _ceil(x):
 
 _FUNCTIONS = {
     "sqrt": _sqrt,
+    "exp": _exp,
+    "ln": _ln,
+    "log": _log,
+    "log2": lambda x: _log(x, 2.0),
+    "log10": lambda x: _log(x, 10.0),
     "abs": abs,
     "min": min,
     "max": max,

{sysmlpy-0.91.0 → sysmlpy-0.95.0}/src/sysmlpy/grammar/classes.py

@@ -1055,11 +1055,16 @@ class StateBodyItem:
 class StateUsage:
     # prefix=OccurrenceUsagePrefix StateUsageKeyword
     # declaration=ActionUsageDeclaration body=StateUsageBody
+    # An ``exhibit state`` usage is the same node with exhibit=True; the
+    # visitor emits exhibit on the StateUsage dict (v0.93.x — previously
+    # ``exhibit state`` was dropped by the visitor entirely).
     def __init__(self, definition=None):
         self.prefix = None
         self.keyword = "state"
+        self.exhibit = None
         if definition is not None:
             if valid_definition(definition, self.__class__.__name__):
+                self.exhibit = definition.get("exhibit")
                 if definition["prefix"] is not None:
                     self.prefix = OccurrenceUsagePrefix(definition["prefix"])
                 self.declaration = ActionUsageDeclaration(definition["declaration"])
@@ -1072,13 +1077,15 @@ class StateUsage:
         output = []
         if self.prefix is not None:
             output.append(self.prefix.dump())
+        if self.exhibit:
+            output.append("exhibit")
         output.append(self.keyword)
         output.append(self.declaration.dump())
         output.append(self.body.dump())
         return " ".join(output)
 
     def get_definition(self):
-        output = {"name": self.__class__.__name__, "prefix": None}
+        output = {"name": self.__class__.__name__, "prefix": None, "exhibit": self.exhibit}
         if self.prefix is not None:
             output["prefix"] = self.prefix.get_definition()
         output["declaration"] = self.declaration.get_definition()