sysmlpy 0.40.0__tar.gz → 0.41.0__tar.gz

{sysmlpy-0.40.0 → sysmlpy-0.41.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sysmlpy
-Version: 0.40.0
+Version: 0.41.0
 Summary: 
 License-File: LICENSE
 Author: Jon R. Fox (mycr0ft)
@@ -39,6 +39,8 @@ The project had diverged so much from sysml2py that a new name, sysmlpy, was sel
 
 ![Lines of Code Over Time](loc_history.svg)
 
+**v0.41.0:** Full-specialization capture across all usage kinds — v0.40.0 fixed `attributeUsage` only; actions, calculations, constraints, requirements, use cases, interfaces and nested occurrences still dropped `:>`, `:>>`, `::>` specializations. New `_full_specialization_for_ctx` helper walks any usage-like context to its featureSpecializationPart; twelve visitor sites now use it (typed-by kept as fallback). `Action.load_from_grammar` captures all four kinds and the hand-rolled dumps on Action/Interface/UseCase/Requirement render them (`action a2 ::> RefType;`). `Usage.redefined_name` now works on deeper declaration nestings too. 10 tests in `tests/redefined_name_test.py`.
+
 **v0.40.0:** `References` (`::>` / `references` keyword) implemented end-to-end — previously the grammar-side `FeatureSpecialization` had a silent "not yet implemented" stub and the visitor never emitted dicts for it, so `ref attribute ::> X;` lost its specialization on round-trip (dump emitted `attribute ;`). New `References` grammar class mirrors `Redefinitions`; visitor branches in both full-specialization builders now cover the operator and keyword forms. The top-level `attributeUsage` path was the only one still using the typed-by-only helper; it now uses `_build_full_specialization_from_ctx` so all four kinds (Typings, Subsettings, Redefinitions, References) round-trip. `redefined_name` / `display_name` already handled this case. New `test_attribute_ref_references_operator_roundtrip` in `tests/grammar_test.py`; two new cases in `tests/redefined_name_test.py`. 97/97 grammar round-trip tests pass.
 
 **v0.39.0:** Redefined-Usage name resolution — `attribute :>> exampleAttribute = ...;` previously dumped the name correctly but exposed a UUID sentinel via `attribute.name`. Two new helpers surface the user-visible identifier without changing the historical `self.name` semantics: `Usage.redefined_name` (last identifier segment of the first re-declaration chain — `Redefinitions` / `Subsettings` / `References`) and `Usage.display_name` (UUID-aware user-meaningful name). `get_value()`, `dump()`, and `get_child()` continue to work unchanged. New `tests/redefined_name_test.py` (6 tests) — the original two-package `DummyDefinitionModel` / `DummyUsageModel` round-trips and the helper properties are exercised.

{sysmlpy-0.40.0 → sysmlpy-0.41.0}/README.md

@@ -14,6 +14,8 @@ The project had diverged so much from sysml2py that a new name, sysmlpy, was sel
 
 ![Lines of Code Over Time](loc_history.svg)
 
+**v0.41.0:** Full-specialization capture across all usage kinds — v0.40.0 fixed `attributeUsage` only; actions, calculations, constraints, requirements, use cases, interfaces and nested occurrences still dropped `:>`, `:>>`, `::>` specializations. New `_full_specialization_for_ctx` helper walks any usage-like context to its featureSpecializationPart; twelve visitor sites now use it (typed-by kept as fallback). `Action.load_from_grammar` captures all four kinds and the hand-rolled dumps on Action/Interface/UseCase/Requirement render them (`action a2 ::> RefType;`). `Usage.redefined_name` now works on deeper declaration nestings too. 10 tests in `tests/redefined_name_test.py`.
+
 **v0.40.0:** `References` (`::>` / `references` keyword) implemented end-to-end — previously the grammar-side `FeatureSpecialization` had a silent "not yet implemented" stub and the visitor never emitted dicts for it, so `ref attribute ::> X;` lost its specialization on round-trip (dump emitted `attribute ;`). New `References` grammar class mirrors `Redefinitions`; visitor branches in both full-specialization builders now cover the operator and keyword forms. The top-level `attributeUsage` path was the only one still using the typed-by-only helper; it now uses `_build_full_specialization_from_ctx` so all four kinds (Typings, Subsettings, Redefinitions, References) round-trip. `redefined_name` / `display_name` already handled this case. New `test_attribute_ref_references_operator_roundtrip` in `tests/grammar_test.py`; two new cases in `tests/redefined_name_test.py`. 97/97 grammar round-trip tests pass.
 
 **v0.39.0:** Redefined-Usage name resolution — `attribute :>> exampleAttribute = ...;` previously dumped the name correctly but exposed a UUID sentinel via `attribute.name`. Two new helpers surface the user-visible identifier without changing the historical `self.name` semantics: `Usage.redefined_name` (last identifier segment of the first re-declaration chain — `Redefinitions` / `Subsettings` / `References`) and `Usage.display_name` (UUID-aware user-meaningful name). `get_value()`, `dump()`, and `get_child()` continue to work unchanged. New `tests/redefined_name_test.py` (6 tests) — the original two-package `DummyDefinitionModel` / `DummyUsageModel` round-trips and the helper properties are exercised.

{sysmlpy-0.40.0 → sysmlpy-0.41.0}/pyproject.toml

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

{sysmlpy-0.40.0 → sysmlpy-0.41.0}/src/sysmlpy/__init__.py

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

{sysmlpy-0.40.0 → sysmlpy-0.41.0}/src/sysmlpy/antlr_visitor.py

@@ -1432,7 +1432,11 @@ def _make_use_case_usage_dict(ctx, prefix=None):
     if typed_by is None:
         typed_by = _get_action_usage_subsetted_by(ctx)
     
-    specialization = _build_specialization(typed_by) if typed_by else None
+    spec_full = _full_specialization_for_ctx(ctx)
+    if spec_full is not None:
+        specialization = spec_full
+    else:
+        specialization = _build_specialization(typed_by) if typed_by else None
     occ_prefix = _get_occurrence_usage_prefix(ctx) if ctx else None
     
     # Get case body items
@@ -3000,8 +3004,13 @@ def _make_action_usage_element(ctx, member_prefix=None):
     # Get body items
     action_items = _visit_action_body_items(ctx)
     
-    # Build specialization if typed_by is present
-    specialization = _build_specialization(typed_by) if typed_by else None
+    # Full specialization (Typings + Subsettings + Redefinitions +
+    # References); typed-by fallback for odd contexts.
+    spec_full = _full_specialization_for_ctx(ctx)
+    if spec_full is not None:
+        specialization = spec_full
+    else:
+        specialization = _build_specialization(typed_by) if typed_by else None
     
     return {
         "name": "BehaviorUsageMember",
@@ -6143,7 +6152,11 @@ def _make_calculation_usage_dict(ctx, prefix=None):
         if typed_by is None:
             typed_by = _get_action_usage_subsetted_by(ctx)
     
-    specialization = _build_specialization(typed_by) if typed_by else None
+    spec_full = _full_specialization_for_ctx(ctx)
+    if spec_full is not None:
+        specialization = spec_full
+    else:
+        specialization = _build_specialization(typed_by) if typed_by else None
     body_parts = _visit_calculation_body_items(ctx)
     occ_prefix = _get_occurrence_usage_prefix(ctx) if ctx else None
     
@@ -6253,7 +6266,11 @@ def _make_constraint_usage_dict(ctx, prefix=None):
         if typed_by is None:
             typed_by = _get_action_usage_subsetted_by(ctx)
     
-    specialization = _build_specialization(typed_by) if typed_by else None
+    spec_full = _full_specialization_for_ctx(ctx)
+    if spec_full is not None:
+        specialization = spec_full
+    else:
+        specialization = _build_specialization(typed_by) if typed_by else None
     body_parts = _visit_calculation_body_items(ctx)
     occ_prefix = _get_occurrence_usage_prefix(ctx) if ctx else None
     
@@ -6336,7 +6353,11 @@ def _make_requirement_usage_dict(ctx, prefix=None):
     if typed_by is None:
         typed_by = _get_action_usage_subsetted_by(ctx)
     
-    specialization = _build_specialization(typed_by) if typed_by else None
+    spec_full = _full_specialization_for_ctx(ctx)
+    if spec_full is not None:
+        specialization = spec_full
+    else:
+        specialization = _build_specialization(typed_by) if typed_by else None
     occ_prefix = _get_occurrence_usage_prefix(ctx) if ctx else None
     
     # Get requirement body items
@@ -6505,7 +6526,11 @@ def _make_interface_usage_dict(ctx, prefix=None):
                 if item_dict:
                     body_items.append(item_dict)
     
-    specialization = _build_specialization(typed_by) if typed_by else None
+    spec_full = _full_specialization_for_ctx(ctx)
+    if spec_full is not None:
+        specialization = spec_full
+    else:
+        specialization = _build_specialization(typed_by) if typed_by else None
     
     interface_end_members = []
     if interface_part:
@@ -9705,7 +9730,11 @@ def _visit_nested_occurrence_usage(occ_elem):
             typed_by = _get_action_usage_typed_by(ctx)
             if typed_by is None:
                 typed_by = _get_action_usage_subsetted_by(ctx)
-            specialization = _build_specialization(typed_by) if typed_by else None
+            spec_full = _full_specialization_for_ctx(ctx)
+            if spec_full is not None:
+                specialization = spec_full
+            else:
+                specialization = _build_specialization(typed_by) if typed_by else None
             
             occ_prefix = _get_occurrence_usage_prefix(ctx)
             
@@ -11225,8 +11254,13 @@ def _visit_usage_element_dict(usage_elem_ctx, prefix=None):
                 # Get body items
                 action_items = _visit_action_body_items(ctx)
                 
-                # Build specialization if typed_by is present
-                specialization = _build_specialization(typed_by) if typed_by else None
+                # Full specialization (Typings + Subsettings + Redefinitions +
+                # References); typed-by fallback for odd contexts.
+                spec_full = _full_specialization_for_ctx(ctx)
+                if spec_full is not None:
+                    specialization = spec_full
+                else:
+                    specialization = _build_specialization(typed_by) if typed_by else None
                 
                 return {
                     "name": "PackageMember",
@@ -11527,6 +11561,75 @@ def _get_action_usage_subsetted_by(ctx):
     return None
 
 
+def _full_specialization_for_ctx(ctx):
+    """Best-effort full specialization for any usage-like context.
+
+    Tries, in order:
+      1. ctx.usage().usageDeclaration().featureSpecializationPart()
+         (whole-usage contexts: attributeUsage, partUsage, …)
+      2. ctx.usageDeclaration().featureSpecializationPart()
+      3. ctx.<x>UsageDeclaration().usageDeclaration().featureSpecializationPart()
+         for any ``*UsageDeclaration`` accessor on ctx
+         (actionUsageDeclaration, constraintUsageDeclaration, …)
+
+    Returns None when no path yields a featureSpecializationPart. Callers
+    that previously did ``_build_specialization(typed_by)`` can call this
+    instead to also capture Redefinitions / Subsettings / References.
+    """
+    if ctx is None:
+        return None
+
+    def _fsp_from_ud(ud):
+        if ud is None:
+            return None
+        if isinstance(ud, list):
+            ud = ud[0] if ud else None
+        if ud is None:
+            return None
+        fsp_getter = getattr(ud, "featureSpecializationPart", None)
+        if callable(fsp_getter) and fsp_getter():
+            return _build_full_specialization_from_fsp(fsp_getter())
+        return None
+
+    # 1) whole-usage context
+    usage = getattr(ctx, "usage", None)
+    if callable(usage):
+        u = usage()
+        if u is not None and hasattr(u, "usageDeclaration"):
+            spec = _fsp_from_ud(u.usageDeclaration())
+            if spec is not None:
+                return spec
+
+    # 2) direct usageDeclaration on ctx
+    ud_getter = getattr(ctx, "usageDeclaration", None)
+    if callable(ud_getter):
+        spec = _fsp_from_ud(ud_getter())
+        if spec is not None:
+            return spec
+
+    # 3) any *UsageDeclaration holder (actionUsageDeclaration, …)
+    for attr in sorted(dir(ctx)):
+        if not attr.endswith("UsageDeclaration") or attr == "usageDeclaration":
+            continue
+        getter = getattr(ctx, attr, None)
+        if callable(getter):
+            try:
+                holder = getter()
+            except Exception:
+                continue
+            if holder is None:
+                continue
+            if callable(getattr(holder, "usageDeclaration", None)):
+                spec = _fsp_from_ud(holder.usageDeclaration())
+                if spec is not None:
+                    return spec
+            spec = _fsp_from_ud(holder)
+            if spec is not None:
+                return spec
+
+    return None
+
+
 def _build_specialization(typed_by):
     """Build the specialization dictionary structure for a typed-by reference."""
     if not typed_by:

{sysmlpy-0.40.0 → sysmlpy-0.41.0}/src/sysmlpy/usage.py

@@ -352,7 +352,16 @@ class Usage(Searchable):
         else:
             d = getattr(g, 'declaration', None)
             if d is not None:
-                spec = getattr(d, 'specialization', None)
+                # Walk to the FeatureDeclaration: some grammars nest
+                # declaration -> declaration -> declaration (e.g.
+                # ActionUsageDeclaration -> UsageDeclaration ->
+                # FeatureDeclaration).
+                node = d
+                for _ in range(3):
+                    if node is None or hasattr(node, 'specialization'):
+                        break
+                    node = getattr(node, 'declaration', None)
+                spec = getattr(node, 'specialization', None) if node is not None else None
         resolved = _resolve_name_from_specialization(spec)
         return resolved or ""
 
@@ -1732,11 +1741,16 @@ class Interface(Usage):
         keyword = getattr(self, 'keyword', 'interface')
 
         # Build type/specialization suffix
-        type_suffix = ""
-        if hasattr(self, '_typed_by_name') and self._typed_by_name:
-            type_suffix = f" : {self._typed_by_name}"
-        elif hasattr(self, '_specializes_names') and self._specializes_names:
-            type_suffix = " :> " + ", ".join(self._specializes_names)
+        suffix_parts = []
+        if getattr(self, '_typed_by_name', None):
+            suffix_parts.append(f" : {self._typed_by_name}")
+        if getattr(self, '_specializes_names', None):
+            suffix_parts.append(" :> " + ", ".join(self._specializes_names))
+        if getattr(self, '_redefined_refs', None):
+            suffix_parts.append(" :>> " + ", ".join(self._redefined_refs))
+        if getattr(self, '_referenced_refs', None):
+            suffix_parts.append(" ::> " + ", ".join(self._referenced_refs))
+        type_suffix = "".join(suffix_parts)
 
         body_items = []
 
@@ -1846,6 +1860,11 @@ class Action(Usage):
         self._succession_targets = []
         self._succession_condition = None
         self._control_flow_nodes = []
+        # Re-declaration chains captured from grammar (v0.41.0)
+        self._typed_by_name = None
+        self._specializes_names = []
+        self._redefined_refs = []
+        self._referenced_refs = []
         
         if definition:
             self.keyword = "action def"
@@ -1969,7 +1988,76 @@ class Action(Usage):
                             self._extract_action_target_succession(child)
                         elif child_name == "GuardedSuccessionMember":
                             self._extract_guarded_succession(child)
-        
+
+        self._extract_specialization_info(grammar)
+
+        return self
+
+    def _extract_specialization_info(self, grammar):
+        """Capture Typings / Subsettings / Redefinitions / References names
+        from the grammar's feature specialization so ``dump()`` can render
+        them (v0.41.0)."""
+        fd = None
+        if getattr(grammar, 'declaration', None) is not None:
+            ud = getattr(grammar.declaration, 'declaration', None)
+            if ud is not None:
+                fd = getattr(ud, 'declaration', None)
+        spec = getattr(fd, 'specialization', None) if fd is not None else None
+        if spec is None:
+            return
+        for fs in getattr(spec, 'specializations', None) or []:
+            rel = getattr(fs, 'relationship', None)
+            kind = rel.__class__.__name__ if rel is not None else None
+            if kind == 'Typings':
+                tb = getattr(rel, 'typing', None)
+                for ft in getattr(tb, 'relationships', []) or []:
+                    rel2 = getattr(ft, 'relationship', None)
+                    ftype = getattr(rel2, 'type', None)
+                    qn = getattr(ftype, 'type', None)
+                    names = getattr(qn, 'names', None)
+                    if names:
+                        self._typed_by_name = '::'.join(names)
+                        break
+                    elements = getattr(ftype, 'elements', None) or []
+                    seg_names = []
+                    for el in elements:
+                        if hasattr(el, 'names') and el.names:
+                            seg_names.extend(el.names)
+                        elif hasattr(el, 'feature'):
+                            for seg in getattr(el.feature, 'children', []) or []:
+                                cf = getattr(seg, 'chainingFeature', None)
+                                if cf is not None and getattr(cf, 'names', None):
+                                    seg_names.extend(cf.names)
+                    if seg_names:
+                        self._typed_by_name = '.'.join(seg_names)
+                        break
+            elif kind in ('Subsettings', 'Redefinitions', 'References'):
+                target = (
+                    self._specializes_names if kind == 'Subsettings'
+                    else self._redefined_refs if kind == 'Redefinitions'
+                    else self._referenced_refs
+                )
+                for child in getattr(rel, 'children', None) or []:
+                    qn = (
+                        getattr(child, 'redefinedFeature', None)
+                        or getattr(child, 'referencedFeature', None)
+                    )
+                    if qn is not None and getattr(qn, 'names', None):
+                        target.append('::'.join(qn.names))
+                        continue
+                    elements = getattr(child, 'elements', None) or []
+                    seg_names = []
+                    for el in elements:
+                        if hasattr(el, 'names') and el.names:
+                            seg_names.extend(el.names)
+                        elif hasattr(el, 'feature'):
+                            for seg in getattr(el.feature, 'children', []) or []:
+                                cf = getattr(seg, 'chainingFeature', None)
+                                if cf is not None and getattr(cf, 'names', None):
+                                    seg_names.extend(cf.names)
+                    if seg_names:
+                        target.append('.'.join(seg_names))
+
         return self
     
     def _extract_initial_node(self, node):
@@ -2341,11 +2429,16 @@ class Action(Usage):
                 params.append(f"out {out_name}")
         
         # Build type/specialization suffix
-        type_suffix = ""
-        if hasattr(self, '_typed_by_name') and self._typed_by_name:
-            type_suffix = f" : {self._typed_by_name}"
-        elif hasattr(self, '_specializes_names') and self._specializes_names:
-            type_suffix = " :> " + ", ".join(self._specializes_names)
+        suffix_parts = []
+        if getattr(self, '_typed_by_name', None):
+            suffix_parts.append(f" : {self._typed_by_name}")
+        if getattr(self, '_specializes_names', None):
+            suffix_parts.append(" :> " + ", ".join(self._specializes_names))
+        if getattr(self, '_redefined_refs', None):
+            suffix_parts.append(" :>> " + ", ".join(self._redefined_refs))
+        if getattr(self, '_referenced_refs', None):
+            suffix_parts.append(" ::> " + ", ".join(self._referenced_refs))
+        type_suffix = "".join(suffix_parts)
         
         if params:
             return f"{keyword} {name_str}{type_suffix} {{ " + "; ".join(params) + "; }"
@@ -2497,11 +2590,16 @@ class UseCase(Usage):
         keyword = getattr(self, 'keyword', 'use case')
         
         # Build type/specialization suffix
-        type_suffix = ""
-        if hasattr(self, '_typed_by_name') and self._typed_by_name:
-            type_suffix = f" : {self._typed_by_name}"
-        elif hasattr(self, '_specializes_names') and self._specializes_names:
-            type_suffix = " :> " + ", ".join(self._specializes_names)
+        suffix_parts = []
+        if getattr(self, '_typed_by_name', None):
+            suffix_parts.append(f" : {self._typed_by_name}")
+        if getattr(self, '_specializes_names', None):
+            suffix_parts.append(" :> " + ", ".join(self._specializes_names))
+        if getattr(self, '_redefined_refs', None):
+            suffix_parts.append(" :>> " + ", ".join(self._redefined_refs))
+        if getattr(self, '_referenced_refs', None):
+            suffix_parts.append(" ::> " + ", ".join(self._referenced_refs))
+        type_suffix = "".join(suffix_parts)
         
         # Build body members
         body_items = []
@@ -2718,11 +2816,16 @@ class Requirement(Usage):
             shortname_str = f" <{self.req_shortname}>"
 
         # Build type/specialization suffix
-        type_suffix = ""
-        if hasattr(self, '_typed_by_name') and self._typed_by_name:
-            type_suffix = f" : {self._typed_by_name}"
-        elif hasattr(self, '_specializes_names') and self._specializes_names:
-            type_suffix = " :> " + ", ".join(self._specializes_names)
+        suffix_parts = []
+        if getattr(self, '_typed_by_name', None):
+            suffix_parts.append(f" : {self._typed_by_name}")
+        if getattr(self, '_specializes_names', None):
+            suffix_parts.append(" :> " + ", ".join(self._specializes_names))
+        if getattr(self, '_redefined_refs', None):
+            suffix_parts.append(" :>> " + ", ".join(self._redefined_refs))
+        if getattr(self, '_referenced_refs', None):
+            suffix_parts.append(" ::> " + ", ".join(self._referenced_refs))
+        type_suffix = "".join(suffix_parts)
 
         # Build body members
         body_items = []