sysmlpy 0.79.0__tar.gz → 0.80.0__tar.gz

{sysmlpy-0.79.0 → sysmlpy-0.80.0}/PKG-INFO

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

{sysmlpy-0.79.0 → sysmlpy-0.80.0}/pyproject.toml

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

{sysmlpy-0.79.0 → sysmlpy-0.80.0}/src/sysmlpy/__init__.py

@@ -34,7 +34,7 @@ __all__ = [
     "render_state_transition_view_svg", "boxes_view",
 ]
 __author__ = "Jon Fox"
-__version__ = "0.79.0"
+__version__ = "0.80.0"
 
 from sysmlpy.usage import (
     Item, Attribute, Part, Port, Action, Reference, UseCase, Requirement, Interface, Message,
@@ -282,7 +282,7 @@ def load(fp) -> Model:
     return loads(fp.read())
 
 
-def loads(s: str, library=None) -> Model:
+def loads(s: str, library=None, rescue_language="English") -> Model:
     """Loads a model from string.
 
     This shortcut function allows a user to build a model from a string by
@@ -303,7 +303,8 @@ def loads(s: str, library=None) -> Model:
     Model
         Model instance built from the SysML source.
     """
-    return Model().load(s, library=library)
+    return Model().load(s, library=library,
+                        rescue_language=rescue_language)
 
 
 def parse(s: str, library=None):
@@ -327,7 +328,8 @@ def parse(s: str, library=None):
         return None, str(e).splitlines()
 
 
-def load_grammar_antlr(fp, debug=False, library=None):
+def load_grammar_antlr(fp, debug=False, library=None,
+                  rescue_language="English"):
     """SysML load from file pointer using ANTLR4 parser.
 
     Deserialize ``fp`` (a ``.read()``-supporting file-like object containing
@@ -370,7 +372,8 @@ def load_grammar_antlr(fp, debug=False, library=None):
         )
 
     try:
-        return antlr_visitor.parse_to_dict(s, library=library)
+        return antlr_visitor.parse_to_dict(s, library=library,
+                                  rescue_language=rescue_language)
     except antlr_parser.SysMLSyntaxError as e:
         raise
 

{sysmlpy-0.79.0 → sysmlpy-0.80.0}/src/sysmlpy/antlr_parser.py

@@ -7,6 +7,7 @@ generated from the OMG SysML v2 specification (2026-05 release).
 """
 import sys
 import os
+import warnings
 
 from antlr4 import InputStream, CommonTokenStream
 from antlr4.atn.PredictionMode import PredictionMode
@@ -51,7 +52,8 @@ def _make_parser(content):
     return lexer, token_stream, parser
 
 
-def parse(source, library=None, recover=False, prediction_mode="sll"):
+def parse(source, library=None, recover=False, prediction_mode="sll",
+          rescue_language="English"):
     """Parse SysML v2.0 source and return a parse tree.
 
     Uses two-stage parsing by default (v0.56.0): a fast SLL prediction
@@ -77,6 +79,11 @@ def parse(source, library=None, recover=False, prediction_mode="sll"):
         for debugging).  ``"sll_only"`` keeps every pass in SLL
         prediction — including the fallback pass — so diagnostics
         reflect SLL behaviour (error parity with the fast path).
+    rescue_language : str, default "English"
+        Language tag used when a constraint body that does not parse as
+        SysML/KerML is salvaged as a textual representation
+        (``rep language "..." /* body */``) instead of failing the whole
+        model load (v0.80.0).
 
     Returns
     -------
@@ -90,13 +97,45 @@ def parse(source, library=None, recover=False, prediction_mode="sll"):
         (after both parse stages).
     """
     from pathlib import Path
-    
+
     # Handle string or file input
     if hasattr(source, 'read'):
         content = source.read()
     else:
         content = source
 
+    try:
+        return _parse_tree(content, recover=recover,
+                           prediction_mode=prediction_mode)
+    except SysMLSyntaxError as original_error:
+        if recover or not rescue_language:
+            raise
+        # Constraint-body rescue (v0.80.0): a constraint whose body does
+        # not parse as SysML/KerML (e.g. natural-language text) fails the
+        # whole model.  Salvage such bodies as language-tagged textual
+        # representations and retry once.
+        rescued = _rescue_constraint_bodies(content, rescue_language)
+        if rescued is None:
+            raise
+        new_content, rescued_names, rescued_language = rescued
+        try:
+            tree = _parse_tree(new_content, recover=False,
+                               prediction_mode=prediction_mode)
+        except SysMLSyntaxError:
+            # Rescue did not make the model parseable (e.g. other errors
+            # elsewhere) — surface the original diagnostics.
+            raise original_error
+        for cname in rescued_names:
+            warnings.warn(
+                f"constraint {cname!r} body did not parse as SysML; captured "
+                f"as textual representation (language {rescued_language!r})",
+                stacklevel=3,
+            )
+        return tree
+
+
+def _parse_tree(content, recover=False, prediction_mode="sll"):
+    """Two-stage ANTLR parse (no rescue); the body of historical parse()."""
     force_ll = prediction_mode == "ll"
     sll_only = prediction_mode == "sll_only" or force_ll
     
@@ -156,6 +195,109 @@ def parse(source, library=None, recover=False, prediction_mode="sll"):
     return tree
 
 
+def _rescue_constraint_bodies(content, language="English"):
+    """Salvage constraint bodies that do not parse as SysML/KerML.
+
+    Scans the source for ``constraint ... { ... }`` blocks, trial-parses
+    each body, and wraps failing ones as language-tagged textual
+    representations (``rep language "..." /* body */``) so a
+    natural-language constraint no longer fails the whole model load.
+
+    Returns ``(new_content, [constraint names], language)`` when at least
+    one body was rewritten, ``None`` when nothing was salvageable.
+
+    Constraints whose body contains ``*/`` cannot be wrapped in a comment
+    and are left untouched (the original error stands).
+    """
+    import re as _re
+
+    spans = []
+    try:
+        lexer = SysMLv2Lexer(InputStream(content))
+        lexer.removeErrorListeners()
+        tokens = CommonTokenStream(lexer)
+        tokens.fill()
+    except Exception:
+        return None
+    toks = [t for t in tokens.tokens if t.channel == 0]
+    n = len(toks)
+    i = 0
+    while i < n:
+        t = toks[i]
+        if t.type != SysMLv2Parser.CONSTRAINT:
+            i += 1
+            continue
+        # Walk forward to the opening brace of the body (or bail on ';').
+        j = i + 1
+        name = None
+        lbrace = None
+        while j < n:
+            tt = toks[j]
+            if tt.type == SysMLv2Parser.LBRACE:
+                lbrace = j
+                break
+            if tt.type in (SysMLv2Parser.SEMI, SysMLv2Parser.RBRACE,
+                           SysMLv2Parser.EOF):
+                break
+            if name is None and tt.type != SysMLv2Parser.DEF:
+                name = tt.text
+            j += 1
+        if lbrace is None:
+            i += 1
+            continue
+        # Brace-match the body (token stream already excludes comments).
+        depth = 0
+        k = lbrace
+        while k < n:
+            if toks[k].type == SysMLv2Parser.LBRACE:
+                depth += 1
+            elif toks[k].type == SysMLv2Parser.RBRACE:
+                depth -= 1
+                if depth == 0:
+                    break
+            k += 1
+        if k >= n or depth != 0:
+            i += 1
+            continue
+        if k > lbrace + 1:
+            start = toks[lbrace + 1].start
+            end = toks[k - 1].stop
+            body_text = content[start:end + 1]
+        else:
+            body_text = ""
+            start = end = toks[lbrace].stop + 1
+        if body_text.strip():
+            spans.append((name or "?", start, end, body_text))
+        i = k + 1
+
+    if not spans:
+        return None
+
+    # Trial-parse every body first; rewrite only the ones that fail.
+    # Apply the replacements right-to-left so earlier offsets stay valid.
+    replacements = []
+    rescued_names = []
+    for cname, start, end, body_text in spans:
+        stripped = body_text.strip()
+        if not stripped or "*/" in stripped:
+            continue
+        probe = ("package __rescue_probe__ { constraint __c__ { "
+                 + stripped + " } }")
+        try:
+            _parse_tree(probe)
+            continue  # body is valid SysML — leave it alone
+        except SysMLSyntaxError:
+            pass
+        replacements.append((start, end, stripped))
+        rescued_names.append(cname)
+    if not rescued_names:
+        return None
+    for start, end, replacement in sorted(replacements, reverse=True):
+        wrapped = 'rep language "%s" /*%s*/' % (language, replacement)
+        content = content[:start] + wrapped + content[end + 1:]
+    return content, rescued_names, language
+
+
 def parse_file(filepath):
     """Parse a SysML v2.0 file.
     

{sysmlpy-0.79.0 → sysmlpy-0.80.0}/src/sysmlpy/antlr_visitor.py

@@ -527,7 +527,7 @@ def _visit_annotating_element_dict(annot_elem_ctx):
     }
 
 
-def parse_to_dict(source, library=None):
+def parse_to_dict(source, library=None, rescue_language="English"):
     """Parse SysML source and return a dictionary.
     
     Parameters
@@ -544,7 +544,8 @@ def parse_to_dict(source, library=None):
     """
     from sysmlpy import antlr_parser
     
-    tree = antlr_parser.parse(source, library=library)
+    tree = antlr_parser.parse(source, library=library,
+                        rescue_language=rescue_language)
     return _visit_root_namespace_dict(tree)
 
 
@@ -3535,8 +3536,9 @@ def _visit_non_behavior_body_item(nbi_ctx):
                         }
         
         elif cname == 'DefinitionMemberContext':
-            # Handle comments/documentation inside bodies
-            # Structure: DefinitionMember -> DefinitionElement -> AnnotatingElement -> Comment
+            # Handle comments/documentation/textual representations inside
+            # bodies.  Structure: DefinitionMember -> DefinitionElement ->
+            # AnnotatingElement -> Comment | Documentation | TextualRepresentation
             for c2 in child.children:
                 if type(c2).__name__ == 'DefinitionElementContext':
                     for c3 in c2.children:
@@ -3549,6 +3551,15 @@ def _visit_non_behavior_body_item(nbi_ctx):
                                 doc = _visit_documentation_dict(c3.documentation())
                                 if doc:
                                     return doc
+                            elif hasattr(c3, 'textualRepresentation') and c3.textualRepresentation():
+                                # `rep language "English" /* body text */` —
+                                # a constraint/calc body expressed in another
+                                # language (v0.80.0).  Keep the raw text (with
+                                # /* */ markers) so classes.TextualRepresentation
+                                # dumps it back verbatim.
+                                tr = _visit_textual_representation_dict(c3.textualRepresentation())
+                                if tr:
+                                    return tr
         
         elif cname == 'StructureUsageMemberContext':
             # Handle occurrence usages (parts, items, ports)
@@ -13407,6 +13418,23 @@ def _visit_usage_element_dict(usage_elem_ctx, prefix=None):
     if hasattr(usage_elem_ctx, 'nonOccurrenceUsageElement') and usage_elem_ctx.nonOccurrenceUsageElement():
         non_occ = usage_elem_ctx.nonOccurrenceUsageElement()
 
+        # Handle referenceUsage (package-level `ref r : Engine;`).
+        # Nested-body refs go through _visit_nested_non_occurrence_usage;
+        # without this branch the package-level form was silently
+        # dropped from the grammar dict.
+        if hasattr(non_occ, 'referenceUsage') and non_occ.referenceUsage():
+            ctx = non_occ.referenceUsage()
+            inner = _make_reference_usage_dict(ctx)
+            if inner:
+                return {
+                    "name": "PackageMember",
+                    "prefix": prefix,
+                    "ownedRelatedElement": {
+                        "name": "UsageElement",
+                        "ownedRelatedElement": inner,
+                    },
+                }
+
         if hasattr(non_occ, 'attributeUsage') and non_occ.attributeUsage():
             ctx = non_occ.attributeUsage()
             name, shortname = _get_usage_identification(ctx)

{sysmlpy-0.79.0 → sysmlpy-0.80.0}/src/sysmlpy/definition.py

@@ -24,7 +24,7 @@ from sysmlpy import Part, Item, Port, Requirement, UseCase, Attribute, Action, C
 from sysmlpy.usage import (
     State, Constraint, Connection, Flow, Calculation, Enumeration,
     Allocation, Metadata, Rendering, Individual, FlowDef,
-    View, Viewpoint, Concern,
+    View, Viewpoint, Concern, Reference,
 )
 
 ModelType = TypeVar("Model", bound="Model")
@@ -62,7 +62,8 @@ class Model(Searchable):
             return f"{cls_name}(children=[{children_repr}])"
         return f"{cls_name}()"
 
-    def load(self: type[ModelType], s: str, library=None) -> ModelType:
+    def load(self: type[ModelType], s: str, library=None,
+             rescue_language="English") -> ModelType:
         """Load a SysML model from a string using ANTLR4 parser.
         
         Parameters
@@ -92,7 +93,8 @@ class Model(Searchable):
             if first_word in invalid_starts:
                 raise ValueError("Base Model must be encapsulated by a package.")
         
-        definition = load_grammar_antlr(s, library=library)["ownedRelationship"]
+        definition = load_grammar_antlr(s, library=library,
+                                        rescue_language=rescue_language)["ownedRelationship"]
         return self._load_definition(definition)
 
     def _load_definition(self: type[ModelType], definition) -> ModelType:
@@ -1112,6 +1114,12 @@ class Package(Searchable):
                 child = Attribute().load_from_grammar(inner_element)
                 child.parent = self
                 self.children.append(child)
+            elif inner_class == "ReferenceUsage":
+                # v0.79.1: package-level `ref r : Engine;` was dropped
+                # from the object tree (visitor had no dispatch either).
+                child = Reference().load_from_grammar(inner_element)
+                child.parent = self
+                self.children.append(child)
             elif inner_class == "ActionDefinition":
                 child = Action(definition=True).load_from_grammar(inner_element)
                 child.parent = self

{sysmlpy-0.79.0 → sysmlpy-0.80.0}/src/sysmlpy/evaluator.py

@@ -200,7 +200,9 @@ class _Collector:
         self.root = _Namespace("", ())
         self.types = {}        # bare type name -> _Namespace (definitions)
         self.calcs = {}        # qname string -> (expr dict, scope namespaces)
-        self.constraints = []  # (qname string, expr dict, scope namespaces)
+        # (qname string, expr dict, scope namespaces,
+        #  [(language, text), ...] textual representations)
+        self.constraints = []
         self._anon = 0
 
     # -- entry ---------------------------------------------------------
@@ -306,10 +308,12 @@ class _Collector:
 
     def _handle_constraint(self, node, qname, scope):
         expr = self._body_expression(node.get("body"))
-        if expr is None:
+        textual = self._body_textual_representations(node.get("body"))
+        if expr is None and not textual:
             return
         dn = _declared_name(node.get("declaration")) or self._anon_name()
-        self.constraints.append(("::".join(qname + (dn,)), expr, list(scope)))
+        self.constraints.append(
+            ("::".join(qname + (dn,)), expr, list(scope), textual))
 
     @staticmethod
     def _body_expression(body):
@@ -323,6 +327,40 @@ class _Collector:
                 return oe
         return _find_first(body, "OwnedExpression")
 
+    @staticmethod
+    def _body_textual_representations(body):
+        """[(language, text), ...] from `rep language "..." /* ... */` bodies.
+
+        The visitor places TextualRepresentation dicts at
+        body.part[].item[].item.ownedRelationship[] (CalculationBodyPart ->
+        CalculationBodyItem -> ActionBodyItem).
+        """
+        out = []
+        if not isinstance(body, dict):
+            return out
+        for part in body.get("part") or []:
+            if not isinstance(part, dict):
+                continue
+            for item in part.get("item") or []:
+                if not isinstance(item, dict):
+                    continue
+                abi = item.get("item")
+                if not isinstance(abi, dict) or \
+                        abi.get("name") != "ActionBodyItem":
+                    continue
+                rel = abi.get("ownedRelationship")
+                rels = rel if isinstance(rel, list) else (
+                    [rel] if isinstance(rel, dict) else [])
+                for r in rels:
+                    if isinstance(r, dict) and \
+                            r.get("name") == "TextualRepresentation":
+                        text = str(r.get("body") or "")
+                        # Strip the /* */ comment markers the lexer keeps.
+                        if text.startswith("/*") and text.endswith("*/"):
+                            text = text[2:-2].strip()
+                        out.append((r.get("language") or "", text))
+        return out
+
 
 # ---------------------------------------------------------------------------
 # evaluation pass
@@ -1104,10 +1142,19 @@ def check_constraints(model, bindings=None):
     """
     collector = _collect_model(model)
     results = []
-    for qname, expr, scope in collector.constraints:
+    for qname, expr, scope, textual in collector.constraints:
         evaluator = _Evaluator(scope, bindings=bindings,
                                types=collector.types)
         result = ConstraintResult(qualified_name=qname)
+        if expr is None:
+            language, text = textual[0]
+            result.expression_text = text
+            result.error = (
+                "not machine-evaluable \u2014 textual body in language "
+                f"'{language or 'unspecified'}': {text!r}"
+            )
+            results.append(result)
+            continue
         result.expression_text = _expression_text(expr)
         try:
             value = evaluator.evaluate(expr)