sysmlpy 0.87.0__tar.gz → 0.88.0__tar.gz

{sysmlpy-0.87.0 → sysmlpy-0.88.0}/PKG-INFO

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

{sysmlpy-0.87.0 → sysmlpy-0.88.0}/pyproject.toml

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

{sysmlpy-0.87.0 → sysmlpy-0.88.0}/src/sysmlpy/__init__.py

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

{sysmlpy-0.87.0 → sysmlpy-0.88.0}/src/sysmlpy/antlr_visitor.py

@@ -2492,14 +2492,15 @@ def _make_satisfy_requirement_usage_dict(sru_ctx, prefix=None):
                 }
             }
     
-    # Extract valuePart
+    # Extract valuePart (``satisfy s1 : R = 3;``)
+    # valuePart : featureValue ; featureValue : (EQ | COLON_EQ |
+    # DEFAULT …) ownedExpression — use the shared extractor, which
+    # handles the featureValue wrapper and the EQ/COLON_EQ/DEFAULT
+    # flags (v0.88.0 — previously read vp.ownedExpression() directly,
+    # which is one level too high, so the value was dropped).
     valuepart = None
     if hasattr(sru_ctx, 'valuePart') and sru_ctx.valuePart():
-        vp = sru_ctx.valuePart()
-        if hasattr(vp, 'ownedExpression') and vp.ownedExpression():
-            expr = _visit_owned_expression(vp.ownedExpression())
-            if expr:
-                valuepart = {"name": "ValuePart", "ownedRelationship": expr}
+        valuepart = _visit_value_part(sru_ctx.valuePart())
     
     # Extract satisfactionSubjectMember (after 'by')
     ssm = None
@@ -5566,6 +5567,8 @@ def _visit_payload_feature(ctx):
     PayloadFeature class expects:
       identification, valuepart, multiplicity1, multiplicity2, ownedRelationship (OwnedFeatureTyping), pfsp
     For 'accept VehicleStartSignal': ownedRelationship contains the type name.
+    For 'accept msg : M': identification + pfsp (v0.88.0 — previously
+    hardcoded to None, so the member's name and typing were dropped).
     """
     if ctx is None:
         return None
@@ -5598,14 +5601,49 @@ def _visit_payload_feature(ctx):
                     }
                 }
     
+    # identification (``accept msg : M`` — first grammar alternative:
+    # ``identification payloadFeatureSpecializationPart valuePart?``)
+    identification = None
+    if hasattr(ctx, 'identification') and ctx.identification():
+        ident = ctx.identification()
+        if ident:
+            name_list = ident.name() if hasattr(ident, 'name') else None
+            if name_list and isinstance(name_list, list):
+                if len(name_list) == 2:
+                    shortname = name_list[0].getText()
+                    name = name_list[1].getText()
+                elif len(name_list) == 1:
+                    name_text = name_list[0].getText()
+                    name = name_text
+                    shortname = None
+                else:
+                    name = None
+                    shortname = None
+                identification = {
+                    "name": "Identification",
+                    "declaredShortName": shortname,
+                    "declaredName": name
+                }
+    
+    # pfsp (the ``: M[1]`` specializations after the name)
+    pfsp = None
+    if hasattr(ctx, 'payloadFeatureSpecializationPart') and ctx.payloadFeatureSpecializationPart():
+        pfsp = _build_pfsp_from_ctx(ctx.payloadFeatureSpecializationPart())
+    
+    # valuePart (``accept msg = 3`` — ``identification valuePart``
+    # alternative)
+    valuepart = None
+    if hasattr(ctx, 'valuePart') and ctx.valuePart():
+        valuepart = _visit_value_part(ctx.valuePart())
+    
     return {
         "name": "PayloadFeature",
-        "identification": None,
-        "valuepart": None,
+        "identification": identification,
+        "valuepart": valuepart,
         "multiplicity1": None,
         "multiplicity2": None,
         "ownedRelationship": owned_rel,
-        "pfsp": None
+        "pfsp": pfsp
     }
 
 
@@ -10008,6 +10046,21 @@ def _visit_definition_body_item_dict(item_ctx, is_interface=False):
     inner_element = None
     wrapper = None
     
+    # Check for importRule first (first grammar alternative).
+    # Imports are legal in every body — usage bodies included
+    # (``part p1 { private import Q::*; }``).  Reuse the package-body
+    # Import dict shape and wrap it directly as the body item's
+    # relationship (DefinitionBodyItem dispatches on item["name"],
+    # same convention as RootNamespace) — previously silently
+    # dropped (v0.88.0).
+    if hasattr(item_ctx, 'importRule') and item_ctx.importRule():
+        import_dict = _visit_import_rule_dict(item_ctx.importRule())
+        if import_dict is not None:
+            return {
+                "name": "InterfaceBodyItem" if is_interface else "DefinitionBodyItem",
+                "ownedRelationship": [import_dict],
+            }
+    
     # Check for occurrenceUsageElement (part, item, port, action, etc.)
     if hasattr(item_ctx, 'occurrenceUsageElement') and item_ctx.occurrenceUsageElement():
         occ_elem = item_ctx.occurrenceUsageElement()
@@ -14168,6 +14221,24 @@ def _build_full_specialization_from_ud(ud):
     if not specs and multiplicity is None:
         return None
     
+    specialization_list = _feature_specialization_dicts(specs)
+
+    return {
+        "name": "FeatureSpecializationPart",
+        "specialization": specialization_list,
+        "multiplicity": multiplicity,
+        "specialization2": [],
+        "multiplicity2": None,
+    }
+
+
+def _feature_specialization_dicts(specs):
+    """Build FeatureSpecialization dicts from featureSpecialization ctxs.
+
+    Shared core for the FeatureSpecializationPart (usages) and
+    PayloadFeatureSpecializationPart (payload features, e.g. accept
+    members) builders.  Handles typings, redefinitions, subsettings and
+    references."""
     specialization_list = []
     
     for spec in specs:
@@ -14292,12 +14363,43 @@ def _build_full_specialization_from_ud(ud):
                     }
                 })
 
+    return specialization_list
+
+
+def _build_pfsp_from_ctx(psp_ctx):
+    """Build a PayloadFeatureSpecializationPart dict from a
+    payloadFeatureSpecializationPart context.
+
+    Grammar: ``featureSpecialization+ multiplicityPart?
+    featureSpecialization* | multiplicityPart featureSpecialization+``.
+    Used by payload features (e.g. ``accept msg : M[1]``) — v0.88.0,
+    previously hardcoded to None so the member's typing was dropped.
+    """
+    if psp_ctx is None:
+        return None
+
+    first_group = []
+    second_group = []
+    seen_multiplicity = False
+    for child in psp_ctx.children or []:
+        child_name = type(child).__name__
+        if child_name == 'MultiplicityPartContext':
+            seen_multiplicity = True
+        elif child_name == 'FeatureSpecializationContext':
+            (second_group if seen_multiplicity else first_group).append(child)
+
+    specs = first_group + second_group
+    specialization_list = _feature_specialization_dicts(specs)
+    mp = _get_multiplicity_part(psp_ctx)
+
+    if not specialization_list and mp is None:
+        return None
+
     return {
-        "name": "FeatureSpecializationPart",
-        "specialization": specialization_list,
-        "multiplicity": multiplicity,
-        "specialization2": [],
-        "multiplicity2": None,
+        "name": "PayloadFeatureSpecializationPart",
+        "ownedRelationship": _feature_specialization_dicts(first_group),
+        "ownedRelationship2": _feature_specialization_dicts(second_group),
+        "mp": mp,
     }
 
 

{sysmlpy-0.87.0 → sysmlpy-0.88.0}/src/sysmlpy/definition.py

@@ -970,6 +970,26 @@ class Package(Searchable):
         """
         return list(self._imports)
 
+    def _add_metadata_child(self, mf):
+        """Surface a MetadataFeature grammar object as a Metadata child.
+
+        Package-level ``metadata m1 : MD;`` members parse into a
+        MetadataFeature (the ``@``-annotation form) which the public-API
+        tree previously dropped (v0.88.0)."""
+        md_obj = Metadata()
+        md_obj.grammar = mf
+        ident = getattr(mf, 'identification', None)
+        declared = getattr(ident, 'declaredName', None)
+        if declared:
+            md_obj.name = declared
+        typing = getattr(mf, 'typing', None)
+        qn = getattr(getattr(getattr(typing, 'type', None), 'type', None), 'names', None)
+        if qn:
+            md_obj._typed_by_name = '::'.join(qn)
+        md_obj.parent = self
+        self.children.append(md_obj)
+        return md_obj
+
     def load_from_grammar(self, grammar):
         """Load package structure from a parsed grammar object.
 
@@ -1295,6 +1315,30 @@ class Package(Searchable):
                             m.name = feat_decl.identification.declaredName
                 m.parent = self
                 self.children.append(m)
+            elif inner_class == "AnnotatingElement":
+                # v0.88.0: a package-level ``metadata m1 : MD;`` member
+                # parses as DefinitionElement -> AnnotatingElement ->
+                # MetadataFeature (the ``@``-annotation form). Surface it
+                # as a navigable Metadata public-API object — previously
+                # it was silently skipped and find('m1') failed. The
+                # dump path already round-trips it through the grammar
+                # tree, so this is purely API-side. Other annotating
+                # elements (Documentation, CommentSysML,
+                # TextualRepresentation) keep their existing handling.
+                mf = getattr(inner_element, 'children', None)
+                if mf is not None and mf.__class__.__name__ == "MetadataFeature":
+                    self._add_metadata_child(mf)
+                else:
+                    print(f"[Package.load_from_grammar] Unknown class: {inner_class} - skipping")  # pragma: no cover
+            elif inner_class == "NonOccurrenceUsageElement":
+                # v0.88.0: the rebuilt shape after _ensure_body wraps a
+                # MetadataFeature the same way attribute usages are
+                # wrapped — surface it like the AnnotatingElement form.
+                mf = getattr(inner_element, 'children', None)
+                if mf is not None and mf.__class__.__name__ == "MetadataFeature":
+                    self._add_metadata_child(mf)
+                else:
+                    print(f"[Package.load_from_grammar] Unknown class: {inner_class} - skipping")  # pragma: no cover
             elif inner_class == "RenderingDefinition":
                 r = Rendering()
                 r.grammar = inner_element

{sysmlpy-0.87.0 → sysmlpy-0.88.0}/src/sysmlpy/grammar/classes.py

@@ -5098,6 +5098,12 @@ class DefinitionBodyItem:
                         self.children.append(NonOccurrenceUsageMember(item))
                     elif item["name"] == "DefinitionMember":
                         self.children.append(DefinitionMember(item))
+                    elif item["name"] == "Import":
+                        # Imports are legal in usage bodies too
+                        # (``part p1 { private import Q::*; }``) —
+                        # same dict shape as package-body imports
+                        # (v0.88.0).
+                        self.children.append(Import(item))
                     else:
                         print(f"DefinitionBodyItem: unknown relationship {definition}")  # pragma: no cover
 
@@ -5255,6 +5261,13 @@ class NonOccurrenceUsageElement:
                 self.children = CalculationUsage(definition["ownedRelatedElement"])
             elif name == "MetadataUsage":
                 self.children = MetadataUsage(definition["ownedRelatedElement"])
+            elif name == "MetadataFeature":
+                # v0.88.0: a Metadata public-API child re-serializes its
+                # MetadataFeature grammar through NonOccurrenceUsageElement
+                # (the _NonOccurrenceUsage wrapping) — accept it here so
+                # the rebuild round-trips instead of crashing on
+                # children=None.
+                self.children = MetadataFeature(definition["ownedRelatedElement"])
             elif name == "EndFeatureUsage":
                 self.children = EndFeatureUsage(definition["ownedRelatedElement"])
             elif name == "AssertConstraintUsage":
@@ -7318,17 +7331,22 @@ class PayloadFeatureSpecializationPart:
         if self.mp is None:
             for child in self.children:
                 output.append(child.dump())
+        elif len(self.children) == 0:
+            # multiplicityPart featureSpecialization+ alternative —
+            # multiplicity genuinely comes first (``[1] : M``).
+            output.append(self.mp.dump())
+            for child in self.children2:
+                output.append(child.dump())
         else:
-            if len(self.children2) == 0:
-                output.append(self.mp.dump())
-                for child in self.children:
-                    output.append(child.dump())
-            else:
-                for child in self.children:
-                    output.append(child.dump())
-                output.append(self.mp.dump())
-                for child in self.children2:
-                    output.append(child.dump())
+            # featureSpecialization+ multiplicityPart? featureSpecialization*
+            # — natural source order (``: M[1]``).  The previous
+            # mp-first rendering produced ``[1] : M`` for the first
+            # alternative, which does not re-parse (v0.88.0).
+            for child in self.children:
+                output.append(child.dump())
+            output.append(self.mp.dump())
+            for child in self.children2:
+                output.append(child.dump())
         return "".join(output)
 
     def get_definition(self):

{sysmlpy-0.87.0 → sysmlpy-0.88.0}/src/sysmlpy/usage.py

@@ -1098,6 +1098,14 @@ class Usage(Searchable):
                         a.grammar = inner
                         a.parent = self
                         self.children.append(a)
+                    elif inner.__class__.__name__ == "RenderingUsage":
+                        # v0.88.0: nested ``rendering r2 : E;`` inside a
+                        # part/item body was dumped (via the grammar
+                        # tree) but never surfaced as a public-API
+                        # Rendering child.
+                        r = Rendering().load_from_grammar(inner)
+                        r.parent = self
+                        self.children.append(r)
                     elif inner.__class__.__name__ == "PortionUsage":
                         c = Part().load_from_grammar(inner)
                         c.parent = self