sysmlpy 0.48.0__tar.gz → 0.50.0__tar.gz

{sysmlpy-0.48.0 → sysmlpy-0.50.0}/PKG-INFO

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

{sysmlpy-0.48.0 → sysmlpy-0.50.0}/pyproject.toml

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

{sysmlpy-0.48.0 → sysmlpy-0.50.0}/src/sysmlpy/__init__.py

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

{sysmlpy-0.48.0 → sysmlpy-0.50.0}/src/sysmlpy/antlr_visitor.py

@@ -314,6 +314,7 @@ def _visit_metadata_feature_dict(ctx):
                 })
     
     body = ""
+    body_features = []
     if ctx.metadataBody():
         if ctx.metadataBody().SEMI():
             body = ";"
@@ -323,14 +324,124 @@ def _visit_metadata_feature_dict(ctx):
             # the round-trip. Without this, every `key = value;` inside
             # a metadata application is silently dropped at visit time.
             body = ctx.metadataBody().getText()
-    
+            # Issue #8: also surface each metadataBodyElement as a
+            # structured bodyFeatures entry so downstream consumers
+            # (sysml2kit, validators, etc.) can read individual
+            # key = value fields without re-parsing the raw text.
+            # Mirrors the per-endpoint capture introduced for issue #5.
+            body_features = _visit_metadata_body_features(ctx.metadataBody())
+
     return {
         "name": "MetadataFeature",
         "prefixMetadataMember": prefix_members,
         "identification": identification,
         "ownedFeatureTyping": owned_feature_typing,
         "ownedRelationship_about": annotations,
-        "body": body
+        "body": body,
+        "bodyFeatures": body_features,
+    }
+
+
+def _visit_metadata_body_features(mb_ctx):
+    """Capture each ``metadataBodyElement`` from a braced metadata body.
+
+    Issue #8: ``_visit_metadata_feature_dict`` previously emitted the
+    raw body text but never surfaced the individual ``key = value;``
+    items, so consumers of ``load_grammar_antlr`` had no way to read
+    the field assignments without re-parsing the raw text.
+
+    The emitted ``bodyFeatures`` list contains one dict per
+    ``metadataBodyElement``. For the common ``metadataBodyFeature``
+    case each entry carries ``name`` (the feature name from
+    ``ownedRedefinition``), ``value`` (the raw ``=value`` text from
+    ``valuePart``), and ``text`` (the full source text of the
+    element). For the heterogeneous alternative
+    (``definitionMember | metadataBodyUsageMember | aliasMember |
+    importRule``) only ``text`` is captured.
+    """
+    if mb_ctx is None:
+        return []
+
+    features = []
+
+    # First alternative: metadataBodyElement list (the common path).
+    if hasattr(mb_ctx, 'metadataBodyElement') and mb_ctx.metadataBodyElement():
+        for elem in mb_ctx.metadataBodyElement():
+            entry = _visit_metadata_body_element(elem)
+            if entry is not None:
+                features.append(entry)
+
+    # Second alternative: heterogeneous (definitionMember |
+    # metadataBodyUsageMember | aliasMember | importRule). ANTLR
+    # matches exactly one of the two alternatives; if the first
+    # alternative returned nothing, try the heterogeneous shapes.
+    if not features:
+        for attr in ('definitionMember', 'metadataBodyUsageMember',
+                     'aliasMember', 'importRule'):
+            if hasattr(mb_ctx, attr) and getattr(mb_ctx, attr)():
+                items = getattr(mb_ctx, attr)()
+                if not isinstance(items, list):
+                    items = [items]
+                for item in items:
+                    features.append({
+                        "name": None,
+                        "value": None,
+                        "text": item.getText(),
+                    })
+
+    return features
+
+
+def _visit_metadata_body_element(elem_ctx):
+    """Capture a single ``metadataBodyElement`` as a bodyFeatures entry."""
+    if elem_ctx is None:
+        return None
+
+    text = elem_ctx.getText()
+
+    # Common case: metadataBodyFeatureMember -> metadataBodyFeature.
+    if hasattr(elem_ctx, 'metadataBodyFeatureMember') and elem_ctx.metadataBodyFeatureMember():
+        fbm = elem_ctx.metadataBodyFeatureMember()
+        if hasattr(fbm, 'metadataBodyFeature') and fbm.metadataBodyFeature():
+            f = fbm.metadataBodyFeature()
+            # Feature name from ownedRedefinition (qualifiedName).
+            name_text = None
+            if hasattr(f, 'ownedRedefinition') and f.ownedRedefinition():
+                name_text = f.ownedRedefinition().getText()
+            # Value text from valuePart (e.g. '="demo"' or '=0.5').
+            # Preserve the operator so downstream tools can decide
+            # whether '=' vs ':=' vs 'default =' was used.
+            value_text = None
+            if hasattr(f, 'valuePart') and f.valuePart():
+                value_text = f.valuePart().getText()
+            # Optional featureSpecializationPart (e.g. ': Type') and
+            # FEATURE keyword (redefinition marker). Capture for
+            # downstream consumers that need to distinguish redefines
+            # vs new feature declarations.
+            specialization = None
+            if hasattr(f, 'featureSpecializationPart') and f.featureSpecializationPart():
+                specialization = f.featureSpecializationPart().getText()
+            is_feature_keyword = (
+                hasattr(f, 'FEATURE') and f.FEATURE() is not None
+            )
+            is_redefines = (
+                hasattr(f, 'REDEFINES') and getattr(f, 'REDEFINES', lambda: None)() is not None
+            )
+            return {
+                "name": name_text,
+                "value": value_text,
+                "text": text,
+                "featureKeyword": is_feature_keyword,
+                "redefines": is_redefines,
+                "specialization": specialization,
+            }
+
+    # Fallback for non-feature metadataBodyElement shapes
+    # (aliasMember / importRule / nonFeatureMember).
+    return {
+        "name": None,
+        "value": None,
+        "text": text,
     }
 
 
@@ -7955,7 +8066,9 @@ def _make_allocation_usage_dict(ctx, prefix=None):
     Issue #5: the connector endpoints (`allocate X to Y`) were silently
     dropped before reaching the dict. Mirror the InterfaceUsage pattern:
     walk `aud.connectorPart()` (when present) and emit a ConnectorPart
-    dict with binary or nary ends.
+    dict with binary or nary ends under the `part` key — the same key
+    ConnectionUsage already uses, so downstream consumers share one
+    shape across connector-bearing usages.
     """
     name = None
     shortname = None
@@ -8011,7 +8124,7 @@ def _make_allocation_usage_dict(ctx, prefix=None):
                                 "specialization": None
                             }
                         },
-                        "connectorPart": connector_part,
+                        "part": connector_part,
                         "body": {
                             "name": "UsageBody",
                             "body": {

{sysmlpy-0.48.0 → sysmlpy-0.50.0}/src/sysmlpy/grammar/classes.py

@@ -4558,24 +4558,29 @@ class MetadataFeature:
     #   )? metadataBody
     #   ;
     def __init__(self, definition):
-        if valid_definition(definition, "MetadataFeature"):
+        if valid_definition(definition, self.__class__.__name__):
             self.prefix = []
             for p in definition.get("prefixMetadataMember", []):
                 self.prefix.append(PrefixMetadataMember(p))
-            
+
             self.identification = None
             if definition.get("identification") is not None:
                 self.identification = Identification(definition["identification"])
-            
+
             self.typing = None
             if definition.get("ownedFeatureTyping") is not None:
                 self.typing = OwnedFeatureTyping(definition["ownedFeatureTyping"])
-            
+
             self.annotations = []
             for ann in definition.get("ownedRelationship_about", []):
                 self.annotations.append(Annotation(ann))
-            
+
             self.body = definition.get("body", "")
+            # Issue #8: structured per-element capture so consumers can
+            # read individual key = value features without re-parsing
+            # the raw body text. ``dump()`` continues to use the raw
+            # ``self.body`` so whitespace is preserved exactly.
+            self.bodyFeatures = list(definition.get("bodyFeatures", []))
 
     def dump(self):
         output = []
@@ -4601,7 +4606,8 @@ class MetadataFeature:
             "identification": self.identification.get_definition() if self.identification else None,
             "ownedFeatureTyping": self.typing.get_definition() if self.typing else None,
             "ownedRelationship_about": [a.get_definition() for a in self.annotations],
-            "body": self.body
+            "body": self.body,
+            "bodyFeatures": list(self.bodyFeatures),
         }
         return output
 
@@ -9887,10 +9893,18 @@ class AllocationUsage(_PrefixedUsageBase):
 
     def __init__(self, definition=None):
         super().__init__(definition)
+        # Issue #5 / PR #6: stores the connectorPart (the `allocate X to Y`
+        # endpoints) on the same `part` key ConnectionUsage already uses, so
+        # downstream consumers share one shape across connector-bearing
+        # usages. Initialized from `definition["part"]` for round-trip
+        # compatibility with the visitor; legacy `definition["connectorPart"]`
+        # is also accepted as a fallback so callers that built dicts using
+        # the v0.47.0 contract keep working until they migrate.
         self.connectorPart = None
         if definition is not None and valid_definition(definition, self.__class__.__name__):
-            if definition.get("connectorPart") is not None:
-                self.connectorPart = ConnectorPart(definition["connectorPart"])
+            raw = definition.get("part", definition.get("connectorPart"))
+            if raw is not None:
+                self.connectorPart = ConnectorPart(raw)
 
     def dump(self):
         parts = []
@@ -9910,8 +9924,11 @@ class AllocationUsage(_PrefixedUsageBase):
         return " ".join(parts)
 
     def get_definition(self):
+        # Emit under the `part` key (matching ConnectionUsage convention
+        # from PR #6). The legacy `connectorPart` alias is no longer emitted
+        # but ``__init__`` still accepts it for back-compat reads.
         output = super().get_definition()
-        output["connectorPart"] = self.connectorPart.get_definition() if self.connectorPart else None
+        output["part"] = self.connectorPart.get_definition() if self.connectorPart else None
         return output