sysmlpy 0.47.0__tar.gz → 0.49.0__tar.gz

{sysmlpy-0.47.0 → sysmlpy-0.49.0}/PKG-INFO

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

{sysmlpy-0.47.0 → sysmlpy-0.49.0}/pyproject.toml

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

{sysmlpy-0.47.0 → sysmlpy-0.49.0}/src/sysmlpy/__init__.py

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

{sysmlpy-0.47.0 → sysmlpy-0.49.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,
     }
 
 
@@ -9802,6 +9913,16 @@ def _visit_nested_occurrence_usage(occ_elem):
         elif hasattr(struct_elem, 'connectionUsage') and struct_elem.connectionUsage():
             ctx = struct_elem.connectionUsage()
             return _make_nested_connection_usage_dict(ctx, None)
+        elif hasattr(struct_elem, 'allocationUsage') and struct_elem.allocationUsage():
+            # Phase 0: allocation usages inside a definition body.
+            ctx = struct_elem.allocationUsage()
+            result = _make_allocation_usage_dict(ctx, None)
+            if result and result.get("name") == "PackageMember":
+                # Unwrap the PackageMember -> UsageElement chain so the
+                # body builder sees an OccurrenceUsageElement at the
+                # expected position.
+                return result.get("ownedRelatedElement")
+            return result
         elif hasattr(struct_elem, 'portionUsage') and struct_elem.portionUsage():
             ctx = struct_elem.portionUsage()
             name, shortname = _get_usage_identification(ctx)
@@ -10021,6 +10142,24 @@ def _visit_nested_occurrence_usage(occ_elem):
             if result and result.get("name") == "PackageMember":
                 return result.get("ownedRelatedElement")
             return result
+        elif hasattr(behav_elem, 'stateUsage') and behav_elem.stateUsage():
+            # Phase 0: state usages live in a BehaviorUsageElement too.
+            ctx = behav_elem.stateUsage()
+            result = _make_state_usage_dict(ctx, None)
+            if result and result.get("name") == "PackageMember":
+                inner = result.get("ownedRelatedElement", {})
+                return inner
+            return result
+        elif hasattr(behav_elem, 'allocationUsage') and behav_elem.allocationUsage():
+            # Phase 0: allocation usages inside a definition body.
+            ctx = behav_elem.allocationUsage()
+            result = _make_allocation_usage_dict(ctx, None)
+            if result and result.get("name") == "PackageMember":
+                # Unwrap the PackageMember -> UsageElement chain so the
+                # body builder sees an OccurrenceUsageElement at the
+                # expected position.
+                return result.get("ownedRelatedElement")
+            return result
     
     # print(f"DEBUG: No match found in _visit_nested_occurrence_usage")
     # Fall through to check structure usage elements

{sysmlpy-0.47.0 → sysmlpy-0.49.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
 

{sysmlpy-0.47.0 → sysmlpy-0.49.0}/src/sysmlpy/usage.py

@@ -798,23 +798,23 @@ class Usage(Searchable):
         self.__init__()
         self.grammar = grammar
         children = []
-        
+
         # Check if this is a definition or usage
         # Some definition types use 'definition' (PartDefinition, AttributeDefinition)
         # Others use 'declaration' directly (RequirementDefinition, UseCaseDefinition)
         # PartDefinition: has .definition which is a Definition object
         # Usage: has .declaration directly
-        
+
         # First check if grammar has 'definition' (for definitions like PartDefinition)
         defn = getattr(grammar, 'definition', None)
         if defn:
             # This type uses 'definition' (PartDefinition, etc.)
             # Get name from definition.declaration.identification.declaredName
             u_name = defn.declaration.identification.declaredName
-            
+
             # Get body from definition.body
             body = defn.body if hasattr(defn, 'body') else None
-            
+
             # body is DefinitionBody with .children
             if body and hasattr(body, 'children') and body.children:
                 children_list = []
@@ -847,7 +847,7 @@ class Usage(Searchable):
                     u_name = None
             else:
                 u_name = None
-            
+
             # Extract children from usage body: grammar.usage.completion.body.body.children
             # This mirrors the PartDefinition path: grammar.definition.body.children
             try:
@@ -874,7 +874,7 @@ class Usage(Searchable):
             # This type uses 'declaration' directly (RequirementDefinition, UseCaseDefinition, some usages)
             decl = grammar.declaration
             u_name = None
-            
+
             # Check nested declaration for Usage (UsageDeclaration -> FeatureDeclaration)
             nested_decl = getattr(decl, 'declaration', None)
             if nested_decl and hasattr(nested_decl, 'identification') and nested_decl.identification:
@@ -922,10 +922,10 @@ class Usage(Searchable):
                 sc = child.children if hasattr(child, 'children') else child
             else:
                 continue
-                
+
             # Process the child
             class_name = sc.__class__.__name__ if not hasattr(sc, '__class__') else sc.__class__.__name__
-            
+
             if class_name == "PartDefinition":
                 c = Part(definition=True).load_from_grammar(sc)
                 c.parent = self
@@ -977,10 +977,37 @@ class Usage(Searchable):
                         c = Flow().load_from_grammar(inner)
                         c.parent = self
                         self.children.append(c)
+                    elif inner.__class__.__name__ == "AllocationUsage":
+                        # Phase 0: allocation usages inside a definition
+                        # body live in StructureUsageElement -> AllocationUsage.
+                        a = Allocation()
+                        a.grammar = inner
+                        a.parent = self
+                        self.children.append(a)
                     elif inner.__class__.__name__ == "PortionUsage":
                         c = Part().load_from_grammar(inner)
                         c.parent = self
                         self.children.append(c)
+            elif class_name == "BehaviorUsageElement":
+                # Phase 0 of docs/v0.46.0_expression_capture_plan.md:
+                # assert / constraint / calc / state / action / requirement /
+                # satisfy / allocation usages live inside a BehaviorUsageElement
+                # when they appear in a definition body. The previous
+                # dispatch dropped the entire BehaviorUsageElement.
+                if hasattr(sc, 'children'):
+                    inner = sc.children
+                    inner_name = inner.__class__.__name__
+                    c = _load_behavior_child(self, inner, inner_name)
+                    if c is not None:
+                        c.parent = self
+                        self.children.append(c)
+            elif class_name == "InterfaceUsage":
+                # Same phase 0: interface usages are wrapped as
+                # OccurrenceUsageElement -> InterfaceUsage directly (not
+                # through StructureUsageElement).
+                c = Interface().load_from_grammar(sc)
+                c.parent = self
+                self.children.append(c)
             elif class_name == "StructureDefinitionElement":
                 if hasattr(sc, 'children'):
                     inner = sc.children
@@ -1039,6 +1066,113 @@ class Usage(Searchable):
     #         raise AttributeError("Invalid Feature Name or Chain")
 
 
+def _load_behavior_child(parent, inner, inner_name):
+    """Construct a public-API element for a usage that lives inside a
+    ``BehaviorUsageElement`` when it appears in a definition body.
+
+    Phase 0 of docs/v0.46.0_expression_capture_plan.md: this helper
+    closes the gap that caused ``assert constraint``, ``constraint``,
+    ``calc``, ``state``, ``action``, ``requirement``, ``satisfy``, and
+    ``allocate`` usages to be silently dropped when they appeared inside
+    a ``part def``, ``item def``, etc. body.
+
+    Parameters
+    ----------
+    parent : Usage
+        The Part / Item / / etc. that owns the new child (for ``.parent``).
+    inner : object
+        The inner grammar element (e.g. ``AssertConstraintUsage``,
+        ``ConstraintUsage``, ``CalculationUsage`` ...). Used for
+        ``.grammar`` so the existing round-trip machinery keeps working.
+    inner_name : str
+        Class name of ``inner`` — selects which public-API class to
+        instantiate.
+
+    Returns
+    -------
+    Usage or None
+        A fresh public-API element (e.g. ``Constraint``, ``Calculation``,
+        ``State``, ``Action``, ``Requirement``, ``Allocation``) with
+        ``.grammar`` wired up and ``.parent`` set. Returns ``None`` if
+        the inner kind is unknown to this helper — the caller treats that
+        as a no-op.
+    """
+    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
+        # AssertConstraintUsage has a different layout: declaration may
+        # be wrapped under .usageDeclaration.
+        if hasattr(decl, "usageDeclaration") and decl.usageDeclaration():
+            inner_decl = decl.usageDeclaration()
+            if hasattr(inner_decl, "identification") and inner_decl.identification:
+                ident = inner_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()
+        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()
+        return None
+
+    if inner_name == "AssertConstraintUsage":
+        c = Constraint()
+        c.grammar = inner
+        c.name = _name_from_declaration(inner)
+        return c
+    if inner_name == "ConstraintUsage":
+        c = Constraint()
+        c.grammar = inner
+        c.name = _name_from_declaration(inner)
+        return c
+    if inner_name == "CalculationUsage":
+        c = Calculation()
+        c.grammar = inner
+        c.name = _name_from_declaration(inner)
+        return c
+    if inner_name == "StateUsage":
+        c = State()
+        c.grammar = inner
+        c.name = _name_from_declaration(inner)
+        return c
+    if inner_name == "ActionUsage":
+        c = Action(grammar=inner).load_from_grammar(inner)
+        return c
+    if inner_name == "RequirementUsage":
+        c = Requirement()
+        c.grammar = inner
+        c.name = _name_from_declaration(inner)
+        return c
+    if inner_name == "SatisfyRequirementUsage":
+        c = Requirement()
+        c.grammar = inner
+        c.name = _name_from_declaration(inner)
+        return c
+    if inner_name == "AllocationUsage":
+        c = Allocation()
+        c.grammar = inner
+        c.name = _name_from_declaration(inner)
+        return c
+    return None
+
+
+
 class Attribute(Usage):
     """SysML v2 Attribute usage/definition.