sysmlpy 0.53.1__tar.gz → 0.55.0__tar.gz

{sysmlpy-0.53.1 → sysmlpy-0.55.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sysmlpy
-Version: 0.53.1
+Version: 0.55.0
 Summary: 
 License-File: LICENSE
 Author: Jon R. Fox (mycr0ft)
@@ -39,19 +39,21 @@ and dropped the textX parser in favor of [an ANTLR4 parser grammar](https://gith
 changed our unit library to pint.
 The project had diverged so much from sysml2py that a new name, sysmlpy, was selected.
 
-> **⚠️ Constraints are changing.** Upcoming releases (v0.54+) overhaul how
-> constraint, calc, and expression bodies are validated: names inside
-> expressions will be **resolved against the symbol table** (v0.54.0),
-> followed by operand type checking and unit-dimension compatibility via
-> pint (v0.55.0). Models that parse cleanly today may start producing
-> semantic errors once this lands. Track progress in
-> [docs/DEVELOPMENT_PLAN.md](docs/DEVELOPMENT_PLAN.md).
+> **⚠️ Constraints are changing.** As of v0.55.0, `analyze()` performs
+> full expression validation: identifiers are **resolved against the
+> symbol table** (v0.54.0) and operators are **type- and
+> unit-checked** — `flag and n`, `"a" + 5`, and `[m] + [kg]` all raise
+> `OPERAND_TYPE_MISMATCH` / `UNIT_DIMENSION_MISMATCH` errors. Deterministic
+> literal expressions can be reduced with `const_fold()`. Coming next
+> (Phase D): parsing performance and graph-store query extensions.
+> Track progress in [docs/DEVELOPMENT_PLAN.md](docs/DEVELOPMENT_PLAN.md).
 
 > **Scope reminder** — a green parse result means the file **parsed
-> syntactically**. Names inside constraint bodies and other OCL-style
-> expressions are not yet resolved by the semantic analyzer, so a
-> document that names an undefined symbol inside an `assert constraint
-> { ... }` will still parse cleanly. See [STATUS.md §Known Issues](STATUS.md#known-issues).
+> syntactically**. Expression validation (name resolution, type and
+> unit checks) runs only when you call `analyze(model)` explicitly.
+> Multiplication/division dimension *derivation* (inferring
+> `[N]` from `[kg] * [m/s^2]`) is not yet implemented. See
+> [STATUS.md §Known Issues](STATUS.md#known-issues).
 
 For release history, see [CHANGELOG.md](CHANGELOG.md).
 

{sysmlpy-0.53.1 → sysmlpy-0.55.0}/README.md

@@ -14,19 +14,21 @@ and dropped the textX parser in favor of [an ANTLR4 parser grammar](https://gith
 changed our unit library to pint.
 The project had diverged so much from sysml2py that a new name, sysmlpy, was selected.
 
-> **⚠️ Constraints are changing.** Upcoming releases (v0.54+) overhaul how
-> constraint, calc, and expression bodies are validated: names inside
-> expressions will be **resolved against the symbol table** (v0.54.0),
-> followed by operand type checking and unit-dimension compatibility via
-> pint (v0.55.0). Models that parse cleanly today may start producing
-> semantic errors once this lands. Track progress in
-> [docs/DEVELOPMENT_PLAN.md](docs/DEVELOPMENT_PLAN.md).
+> **⚠️ Constraints are changing.** As of v0.55.0, `analyze()` performs
+> full expression validation: identifiers are **resolved against the
+> symbol table** (v0.54.0) and operators are **type- and
+> unit-checked** — `flag and n`, `"a" + 5`, and `[m] + [kg]` all raise
+> `OPERAND_TYPE_MISMATCH` / `UNIT_DIMENSION_MISMATCH` errors. Deterministic
+> literal expressions can be reduced with `const_fold()`. Coming next
+> (Phase D): parsing performance and graph-store query extensions.
+> Track progress in [docs/DEVELOPMENT_PLAN.md](docs/DEVELOPMENT_PLAN.md).
 
 > **Scope reminder** — a green parse result means the file **parsed
-> syntactically**. Names inside constraint bodies and other OCL-style
-> expressions are not yet resolved by the semantic analyzer, so a
-> document that names an undefined symbol inside an `assert constraint
-> { ... }` will still parse cleanly. See [STATUS.md §Known Issues](STATUS.md#known-issues).
+> syntactically**. Expression validation (name resolution, type and
+> unit checks) runs only when you call `analyze(model)` explicitly.
+> Multiplication/division dimension *derivation* (inferring
+> `[N]` from `[kg] * [m/s^2]`) is not yet implemented. See
+> [STATUS.md §Known Issues](STATUS.md#known-issues).
 
 For release history, see [CHANGELOG.md](CHANGELOG.md).
 

{sysmlpy-0.53.1 → sysmlpy-0.55.0}/pyproject.toml

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

{sysmlpy-0.53.1 → sysmlpy-0.55.0}/src/sysmlpy/__init__.py

@@ -25,7 +25,7 @@ __all__ = [
     "render_state_transition_view_svg", "boxes_view",
 ]
 __author__ = "Jon Fox"
-__version__ = "0.53.1"
+__version__ = "0.55.0"
 
 from sysmlpy.usage import (
     Item, Attribute, Part, Port, Action, Reference, UseCase, Requirement, Interface, Message,

{sysmlpy-0.53.1 → sysmlpy-0.55.0}/src/sysmlpy/antlr_visitor.py

@@ -11134,45 +11134,109 @@ def _emit_null_coalescing_level(ctx):
 
 def _emit_implies_level(ctx):
     # orExpression ( IMPLIES orExpression )*
+    # Operator text 'implies' goes into the ImpliesExpression
+    # operator/operand lists (rendered by ImpliesExpression.dump since
+    # v0.55.0).
     first, pairs = _split_level_ctx(ctx, "OrExpressionContext")
-    if pairs:
-        return None  # 'implies' not dumped by the grammar class -> text
     or_expr = _emit_or_level(first)
     if or_expr is None:
         return None
-    return {"name": "ImpliesExpression", "operator": [], "operand": [], "or": or_expr}
+    ops = []
+    operands = []
+    for op_text, or_ctx in pairs:
+        or_dict = _emit_or_level(or_ctx)
+        if or_dict is None:
+            return None
+        ops.append(op_text)
+        operands.append(or_dict)
+    return {
+        "name": "ImpliesExpression",
+        "operator": ops,
+        "operand": operands,
+        "or": or_expr,
+    }
 
 
 def _emit_or_level(ctx):
     # xorExpression ( ( OR | PIPE ) xorExpression )*
+    # Operator text 'or' or '|' goes into the OrExpression operator/operand
+    # lists (rendered by OrExpression.dump since v0.55.0).
     first, pairs = _split_level_ctx(ctx, "XorExpressionContext")
-    if pairs:
-        return None  # 'or'/'|' not dumped by the grammar class -> text
     xor_expr = _emit_xor_level(first)
     if xor_expr is None:
         return None
-    return {"name": "OrExpression", "operator": [], "operand": [], "xor": xor_expr}
+    ops = []
+    operands = []
+    for op_text, xor_ctx in pairs:
+        xor_dict = _emit_xor_level(xor_ctx)
+        if xor_dict is None:
+            return None
+        ops.append(op_text)
+        operands.append(xor_dict)
+    return {
+        "name": "OrExpression",
+        "operator": ops,
+        "operand": operands,
+        "xor": xor_expr,
+    }
 
 
 def _emit_xor_level(ctx):
     # andExpression ( XOR andExpression )*
     first, pairs = _split_level_ctx(ctx, "AndExpressionContext")
-    if pairs:
-        return None  # 'xor' not dumped by the grammar class -> text
     and_expr = _emit_and_level(first)
     if and_expr is None:
         return None
-    return {"name": "XorExpression", "operator": [], "operand": [], "and": and_expr}
+    ops = []
+    operands = []
+    for op_text, and_ctx in pairs:
+        and_dict = _emit_and_level(and_ctx)
+        if and_dict is None:
+            return None
+        ops.append(op_text)
+        operands.append(and_dict)
+    return {
+        "name": "XorExpression",
+        "operator": ops,
+        "operand": operands,
+        "and": and_expr,
+    }
 
 
 def _emit_and_level(ctx):
     # equalityExpression ( ( AND | AMP ) equalityExpression )*
+    # The 'and' keyword form takes an EqualityExpressionReference (a
+    # membership wrapper) per the XText reference grammar; '&' keeps a
+    # direct EqualityExpression operand.
     first, pairs = _split_level_ctx(ctx, "EqualityExpressionContext")
-    if pairs:
-        return None  # 'and'/'&' not dumped by the grammar class -> text
     eq = _emit_equality_level(first)
     if eq is None:
         return None
+    ops = []
+    for op_text, cls_ctx in pairs:
+        cls_dict = _emit_equality_level(cls_ctx)
+        if cls_dict is None:
+            return None
+        if op_text == "&":
+            ops.append(
+                {"name": "AndOperand", "operator": "&", "operand": cls_dict}
+            )
+        else:
+            ops.append(
+                {
+                    "name": "AndOperand",
+                    "operator": "and",
+                    "operand": {
+                        "name": "EqualityExpressionReference",
+                        "ownedRelationship": {
+                            "name": "EqualityExpressionMember",
+                            "ownedRelatedElement": cls_dict,
+                        },
+                    },
+                }
+            )
+    if ops:
+        return {"name": "AndExpression", "operation": ops, "equality": eq}
     return {"name": "AndExpression", "operation": [], "equality": eq}
 
 
@@ -11292,10 +11356,29 @@ def _emit_multiplicative_level(ctx):
 
 def _emit_exponentiation_level(ctx):
     # unaryExpression ( ( STAR_STAR | CARET ) exponentiationExpression )?
-    # '**'/'^' are right-associative and not dumped by the grammar
-    # class, so keep the text when present
+    # '**'/'^' are right-associative; the rhs of '**' is another
+    # ExponentiationExpression (child layer of the same rule).
     if hasattr(ctx, "exponentiationExpression") and ctx.exponentiationExpression():
-        return None
+        rhs_ctx = ctx.exponentiationExpression()
+        unary_ctx = ctx.unaryExpression() if hasattr(ctx, "unaryExpression") else None
+        if unary_ctx is None:
+            return None
+        unary = _emit_unary_level(unary_ctx)
+        if unary is None:
+            return None
+        rhs_dict = _emit_exponentiation_level(rhs_ctx)
+        if rhs_dict is None:
+            return None
+        op_text = "**"
+        for c in (ctx.getChildren() if hasattr(ctx, "getChildren") else []):
+            if type(c).__name__ == "TerminalNodeImpl" and c.getText().strip() in ("**", "^"):
+                op_text = c.getText().strip()
+        return {
+            "name": "ExponentiationExpression",
+            "operator": [op_text],
+            "operand": [rhs_dict],
+            "unary": unary,
+        }
     unary_ctx = ctx.unaryExpression() if hasattr(ctx, "unaryExpression") else None
     if unary_ctx is None:
         return None
@@ -11312,6 +11395,41 @@ def _emit_unary_level(ctx):
     # | primaryExpression
     prim_ctx = ctx.primaryExpression() if hasattr(ctx, "primaryExpression") else None
     if prim_ctx is not None:
+        # Parenthesized primary: baseExpression '(' sequenceExpression ')'
+        # carries a full inner binary chain — recurse through the inner
+        # nullCoalescing level so nested binary ops stay structured.
+        be_ctx = prim_ctx.baseExpression() if hasattr(prim_ctx, "baseExpression") else None
+        if be_ctx is not None and "(" in getattr(be_ctx, "text", "") or (
+            be_ctx is not None and be_ctx.getText().startswith("(")
+        ):
+            inner_nce = None
+            sel = (
+                be_ctx.sequenceExpressionList()
+                if hasattr(be_ctx, "sequenceExpressionList")
+                else None
+            )
+            if sel is not None:
+                oe = (
+                    sel.ownedExpression()
+                    if hasattr(sel, "ownedExpression")
+                    else None
+                )
+                # A comma-separated sequence (a, b) is not representable
+                # in the paren-structured shape — let it fall back to text.
+                if isinstance(oe, list) and len(oe) != 1:
+                    return None
+                while isinstance(oe, list):
+                    oe = oe[0] if oe else None
+                nce = (
+                    oe.nullCoalescingExpression()
+                    if oe is not None and hasattr(oe, "nullCoalescingExpression")
+                    else None
+                )
+                if isinstance(nce, list):
+                    nce = nce[0] if nce else None
+                if nce is not None:
+                    inner_nce = _emit_null_coalescing_level(nce)
+            return None  # parens carry grouping — text fallback preserves them
         primary = _emit_primary_level(prim_ctx)
         if primary is None:
             return None
@@ -11330,9 +11448,9 @@ def _emit_unary_level(ctx):
     if children and type(children[0]).__name__ == "TerminalNodeImpl":
         op_text = children[0].getText().strip()
         if op_text in ("+", "-", "~", "not"):
-            # operand must be a unaryExpression without its own prefix
-            # operator (nested prefixes are not representable in the
-            # chain shape)
+            # operand must be a unaryExpression; nested unary prefixes are
+            # not representable in the chain shape, but a plain
+            # primaryExpression (possibly parenthesized additive) is.
             operand_ctx = None
             for c in children[1:]:
                 if type(c).__name__ == "UnaryExpressionContext":
@@ -11345,25 +11463,64 @@ def _emit_unary_level(ctx):
                 if hasattr(operand_ctx, "primaryExpression")
                 else None
             )
-            if inner_prim is None:
+            if (
+                inner_prim is not None
+                and "(" not in getattr(operand_ctx, "text", "")
+            ):
+                primary = _emit_primary_level(inner_prim)
+                if primary is not None:
+                    return {
+                        "name": "UnaryExpression",
+                        "operator": op_text,
+                        "operand": [],
+                        "extent": {
+                            "name": "ExtentExpression",
+                            "operator": "",
+                            "operand": [],
+                            "primary": primary,
+                        },
+                    }
+            # Parenthesized operand: primary is '(' sequenceExpression ')'
+            # whose additive/multiplicative chain is representable — emit
+            # the inner chain as a nested UnaryExpression extent.
+            inner = _emit_unary_level(operand_ctx)
+            if inner is not None and not isinstance(inner.get("extent"), dict):
                 return None
-            primary = _emit_primary_level(inner_prim)
-            if primary is None:
+            # inner may be a primary-only unary; wrap so the outer '-'
+            # sits above the inner (parenthesized) chain
+            if inner is None:
                 return None
             return {
                 "name": "UnaryExpression",
                 "operator": op_text,
                 "operand": [],
-                "extent": {
-                    "name": "ExtentExpression",
-                    "operator": "",
-                    "operand": [],
-                    "primary": primary,
-                },
+                "extent": inner.get("extent"),
             }
     return None  # '@'/'@@'/'all' typeReference forms -> text
 
 
+def _chain_has_binary_operator(node):
+    """True if an expression-layer dict contains any emitted binary operator."""
+    if not isinstance(node, dict):
+        return False
+    for key in ("operation", "operator", "operand"):
+        val = node.get(key)
+        if key == "operation" and isinstance(val, list) and val:
+            return True
+        if key == "operator":
+            if isinstance(val, str) and val not in (None, "") and node.get("name") != "ExponentiationExpression" or isinstance(val, list) and val:
+                return True
+        if key == "operand" and isinstance(val, list) and val and node.get("name") == "ExponentiationExpression":
+            return True
+    for child_key in ("implies", "or", "xor", "and", "equality", "classification",
+                      "relational", "range", "additive", "multiplicitive",
+                      "exponential", "unary", "extent", "primary"):
+        child = node.get(child_key)
+        if isinstance(child, dict) and _chain_has_binary_operator(child):
+            return True
+    return False
+
+
 def _base_feature_names(be_ctx):
     """Return the qualified-name parts of a baseExpression that is a
     plain feature reference, or None for any other base form."""
@@ -11479,9 +11636,27 @@ def _emit_base_primary(be_ctx):
             pass
         if lit_text.startswith('"') and lit_text.endswith('"'):
             return _make_literal_string_primary(lit_text)
-        # boolean/null keywords have no dedicated grammar class; keep
-        # them as feature references so the text round-trips
-        if lit_text in ("true", "false", "null"):
+        # Boolean literal: captured as a LiteralBoolean primary so the
+        # type checker can classify it; the grammar class round-trips
+        # the keyword text via the value field.
+        if lit_text in ("true", "false"):
+            return {
+                "name": "PrimaryExpression",
+                "operator": [],
+                "operand": [],
+                "base": {
+                    "name": "BaseExpression",
+                    "ownedRelationship": {
+                        "name": "LiteralBoolean",
+                        "value": lit_text,
+                    },
+                },
+                "ownedRelationship1": [],
+                "ownedRelationship2": [],
+            }
+        # null has no dedicated grammar class; keep it as a feature
+        # reference so the text round-trips
+        if lit_text == "null":
             return _make_feature_reference_primary(lit_text)
         return None
     names = _base_feature_names(be_ctx)

{sysmlpy-0.53.1 → sysmlpy-0.55.0}/src/sysmlpy/grammar/classes.py

@@ -5754,6 +5754,18 @@ class ImpliesExpression:
             self.operator = definition.get("operator", [])
 
     def dump(self):
+        if self.orexpression is not None and self.operator and self.operand:
+            output = [self.orexpression.dump()]
+            for op, rhs in zip(self.operator, self.operand):
+                output.append(op)
+                if isinstance(rhs, dict):
+                    try:
+                        output.append(OrExpression(rhs).dump())
+                    except Exception:
+                        output.append(str(rhs))
+                else:
+                    output.append(str(rhs))
+            return " ".join(output)
         if self.orexpression is not None:
             return self.orexpression.dump()
         return ""
@@ -5781,6 +5793,18 @@ class OrExpression:
             self.operator = definition.get("operator", [])
 
     def dump(self):
+        if self.xor is not None and self.operator and self.operand:
+            output = [self.xor.dump()]
+            for op, rhs in zip(self.operator, self.operand):
+                output.append(op)
+                if isinstance(rhs, dict):
+                    try:
+                        output.append(XorExpression(rhs).dump())
+                    except Exception:
+                        output.append(str(rhs))
+                else:
+                    output.append(str(rhs))
+            return " ".join(output)
         if self.xor is not None:
             return self.xor.dump()
         return ""
@@ -5808,13 +5832,27 @@ class XorExpression:
             self.operator = definition.get("operator", [])
 
     def dump(self):
-        return self.andexpression.dump()
+        if self.andexpression is not None and self.operator and self.operand:
+            output = [self.andexpression.dump()]
+            for op, rhs in zip(self.operator, self.operand):
+                output.append(op)
+                if isinstance(rhs, dict):
+                    try:
+                        output.append(AndExpression(rhs).dump())
+                    except Exception:
+                        output.append(str(rhs))
+                else:
+                    output.append(str(rhs))
+            return " ".join(output)
+        if self.andexpression is not None:
+            return self.andexpression.dump()
+        return ""
 
     def get_definition(self):
         output = {
             "name": self.__class__.__name__,
-            "operator": [],
-            "operand": [],
+            "operator": self.operator,
+            "operand": self.operand,
             "and": self.andexpression.get_definition(),
         }
         return output
@@ -6149,6 +6187,18 @@ class ExponentiationExpression:
             self.operator = definition.get("operator", [])
 
     def dump(self):
+        if self.unary is not None and self.operator and self.operand:
+            output = [self.unary.dump()]
+            for op, rhs in zip(self.operator, self.operand):
+                output.append(op)
+                if isinstance(rhs, dict):
+                    try:
+                        output.append(ExponentiationExpression(rhs).dump())
+                    except Exception:
+                        output.append(str(rhs))
+                else:
+                    output.append(str(rhs))
+            return " ".join(output)
         if self.unary is not None:
             return self.unary.dump()
         return ""
@@ -6200,15 +6250,21 @@ class UnaryExpression:
 class ExtentExpression:
     def __init__(self, definition):
         self.primary = None
+        self.nested = None
         self.operator = ""
         if valid_definition(definition, self.__class__.__name__):
-            if definition["primary"] is not None:
+            if definition.get("primary") is not None:
                 self.primary = PrimaryExpression(definition["primary"])
+            nested = definition.get("ownedRelationship")
+            if isinstance(nested, dict):
+                self.nested = globals()[nested["name"]](nested)
             self.operator = definition.get("operator", "")
 
     def dump(self):
         if self.primary is not None:
             return self.primary.dump()
+        if self.nested is not None:
+            return self.nested.dump()
         return ""
 
     def get_definition(self):
@@ -6219,7 +6275,8 @@ class ExtentExpression:
         }
         if self.primary is not None:
             output["primary"] = self.primary.get_definition()
-        output["ownedRelationship"] = []
+        if self.nested is not None:
+            output["ownedRelationship"] = self.nested.get_definition()
         return output
 
 
@@ -6455,6 +6512,8 @@ class BaseExpression:
                 self.relationship = LiteralString(definition["ownedRelationship"])
             elif definition["ownedRelationship"]["name"] == "LiteralReal":
                 self.relationship = LiteralReal(definition["ownedRelationship"])
+            elif definition["ownedRelationship"]["name"] == "LiteralBoolean":
+                self.relationship = LiteralBoolean(definition["ownedRelationship"])
             elif definition["ownedRelationship"]["name"] == "SequenceExpression":
                 self.relationship = SequenceExpression(definition["ownedRelationship"])
             elif definition["ownedRelationship"]["name"] == "InvocationExpression":
@@ -8437,6 +8496,18 @@ class LiteralString:
         return {"name": self.__class__.__name__, "value": self.element}
 
 
+class LiteralBoolean:
+    def __init__(self, definition):
+        if valid_definition(definition, self.__class__.__name__):
+            self.element = definition["value"]
+
+    def dump(self):
+        return self.element
+
+    def get_definition(self):
+        return {"name": self.__class__.__name__, "value": self.element}
+
+
 class LiteralInteger:
     def __init__(self, definition):
         if valid_definition(definition, "LiteralInteger"):