sysmlpy 0.79.1__tar.gz → 0.80.0__tar.gz

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

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

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

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

{sysmlpy-0.79.1 → 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.1"
+__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.1 → 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.1 → 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)

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

@@ -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:

{sysmlpy-0.79.1 → 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)

{sysmlpy-0.79.1 → sysmlpy-0.80.0}/src/sysmlpy/usage.py

@@ -1296,15 +1296,21 @@ def _load_behavior_child(parent, inner, inner_name):
     """
     def _name_from_declaration(elem):
         """Extract a human-readable name from an element's declaration,
-        mirroring the pattern at definition.py:1269-1290."""
-        if not hasattr(elem, "declaration") or elem.declaration is None:
-            return None
-        decl = elem.declaration
+        mirroring the pattern at definition.py:1269-1290.
+
+        Declaration chains differ per kind — e.g. ``ConstraintUsage``
+        nests one level deeper than ``Usage``
+        (CalculationUsageDeclaration -> UsageDeclaration ->
+        FeatureDeclaration -> Identification) — so walk ``.declaration``
+        until an Identification is found.
+        """
         # AssertConstraintUsage has a different layout: declaration may
         # be wrapped under .usageDeclaration.
-        if hasattr(decl, "usageDeclaration") and decl.usageDeclaration():
+        decl = getattr(elem, "declaration", None)
+        if decl is not None and callable(getattr(decl, "usageDeclaration", None)) \
+                and decl.usageDeclaration():
             inner_decl = decl.usageDeclaration()
-            if hasattr(inner_decl, "identification") and inner_decl.identification:
+            if getattr(inner_decl, "identification", None):
                 ident = inner_decl.identification
                 if hasattr(ident, "declaredName"):
                     return ident.declaredName
@@ -1314,18 +1320,16 @@ def _load_behavior_child(parent, inner, inner_name):
                         if isinstance(name_obj, list):
                             return name_obj[-1].getText()
                         return name_obj.getText()
-        if hasattr(decl, "declaration") and decl.declaration:
-            feat_decl = decl.declaration
-            if hasattr(feat_decl, "identification") and feat_decl.identification:
-                ident = feat_decl.identification
-                if hasattr(ident, "declaredName"):
-                    return ident.declaredName
-                if hasattr(ident, "name"):
-                    name_obj = ident.name()
-                    if name_obj:
-                        if isinstance(name_obj, list):
-                            return name_obj[-1].getText()
-                        return name_obj.getText()
+        node = decl
+        depth = 0
+        while node is not None and depth < 4:
+            ident = getattr(node, "identification", None)
+            if ident is not None:
+                declared = getattr(ident, "declaredName", None)
+                if declared:
+                    return declared
+            node = getattr(node, "declaration", None)
+            depth += 1
         return None
 
     # Behavior usages created without load_from_grammar still capture their
@@ -3962,11 +3966,56 @@ class Constraint(_NonOccurrenceUsage):
         else:
             self.grammar = ConstraintUsage()
 
+        Usage.__init__(self)
+        if definition:
+            self.grammar = ConstraintDefinition()
+        else:
+            self.grammar = ConstraintUsage()
+
         if name is not None:
             self._set_name(name)
         if shortname is not None:
             self._set_name(shortname, short=True)
 
+    def textual_representations(self):
+        """[(language, text), ...] from `rep language "..." /* ... */` bodies.
+
+        A constraint body expressed in another language (e.g. natural
+        language) is a TextualRepresentation inside the CalculationBody.
+        The text has the /* */ comment markers stripped.
+        """
+        out = []
+        g = getattr(self, "grammar", None)
+        body = getattr(g, "body", None)
+        if body is None:
+            return out
+        for part in getattr(body, "children", []) or []:
+            for item in getattr(part, "children", []) or []:
+                for abi in getattr(item, "children", []) or []:
+                    for ch in getattr(abi, "children", []) or []:
+                        if ch.__class__.__name__ == "TextualRepresentation":
+                            text = str(ch.body or "")
+                            if text.startswith("/*") and text.endswith("*/"):
+                                text = text[2:-2].strip()
+                            out.append((ch.language or "", text))
+        return out
+
+    @property
+    def body_text(self):
+        """Raw text of the constraint's textual body, or None.
+
+        Populated for natural-language bodies (``rep language "English"
+        /* ... */`` and bodies salvaged by the parser's rescue pass).
+        """
+        reps = self.textual_representations()
+        return reps[0][1] if reps else None
+
+    @property
+    def body_language(self):
+        """Language tag of the constraint's textual body, or None."""
+        reps = self.textual_representations()
+        return reps[0][0] or None if reps else None
+
 
 class Connection(Usage):
     sysml_type = 'connection'