sysmlpy 0.33.4__tar.gz → 0.33.6__tar.gz

{sysmlpy-0.33.4 → sysmlpy-0.33.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sysmlpy
-Version: 0.33.4
+Version: 0.33.6
 Summary: 
 License-File: LICENSE
 Author: Jon R. Fox (mycr0ft)
@@ -838,6 +838,15 @@ See [`docs/plantuml-examples/`](docs/plantuml-examples/) for all rendered exampl
   4. Added `load_from_grammar` handler for `PortionUsage` in `usage.py`.
   5. PlantUML `_get_stereotype()` now includes `individual`/`timeslice`/`snapshot` prefixes (e.g. `<<timeslice part>>`, `<<individual part>>`).
 
+- **v0.33.6** — Fix library import resolution with custom library paths:
+  1. Threaded `lib_roots` through `build_from_model()` → `_resolve_imports()` → `_resolve_membership_import()` / `_resolve_namespace_import()` for `LibrarySymbolIndex` fallback.
+  2. `import CustomTypes::*` now resolves correctly when `CustomTypes` is in a user-provided library path.
+
+- **v0.33.5** — Fix `DefaultInterfaceEnd` keyword injection:
+  1. Removed spurious `part` keyword from interface ends without explicit `part`/`item`/`port` prefix.
+  2. Bare `end e1 : Type;` now round-trips correctly as `end e1: Type;` (no extraneous `part`).
+  3. 3 previously-failing interface round-trip grammar tests now pass.
+
 ## Conformance
 
 **100% of 123 OMG XPect conformance tests pass** (123/123).

{sysmlpy-0.33.4 → sysmlpy-0.33.6}/README.md

@@ -813,6 +813,15 @@ See [`docs/plantuml-examples/`](docs/plantuml-examples/) for all rendered exampl
   4. Added `load_from_grammar` handler for `PortionUsage` in `usage.py`.
   5. PlantUML `_get_stereotype()` now includes `individual`/`timeslice`/`snapshot` prefixes (e.g. `<<timeslice part>>`, `<<individual part>>`).
 
+- **v0.33.6** — Fix library import resolution with custom library paths:
+  1. Threaded `lib_roots` through `build_from_model()` → `_resolve_imports()` → `_resolve_membership_import()` / `_resolve_namespace_import()` for `LibrarySymbolIndex` fallback.
+  2. `import CustomTypes::*` now resolves correctly when `CustomTypes` is in a user-provided library path.
+
+- **v0.33.5** — Fix `DefaultInterfaceEnd` keyword injection:
+  1. Removed spurious `part` keyword from interface ends without explicit `part`/`item`/`port` prefix.
+  2. Bare `end e1 : Type;` now round-trips correctly as `end e1: Type;` (no extraneous `part`).
+  3. 3 previously-failing interface round-trip grammar tests now pass.
+
 ## Conformance
 
 **100% of 123 OMG XPect conformance tests pass** (123/123).

{sysmlpy-0.33.4 → sysmlpy-0.33.6}/pyproject.toml

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

{sysmlpy-0.33.4 → sysmlpy-0.33.6}/src/sysmlpy/__init__.py

@@ -22,7 +22,7 @@ __all__ = [
     "SysMLSyntaxError",
 ]
 __author__ = "Jon Fox"
-__version__ = "0.33.4"
+__version__ = "0.33.6"
 
 from sysmlpy.usage import (
     Item, Attribute, Part, Port, Action, Reference, UseCase, Requirement, Interface, Message,

{sysmlpy-0.33.4 → sysmlpy-0.33.6}/src/sysmlpy/antlr_parser.py

@@ -67,26 +67,11 @@ def parse(source, library=None):
     else:
         content = source
     
-    # Load library files if library path is provided
-    if library is not None:
-        library_paths = [library] if isinstance(library, (str, Path)) else library
-        library_content = []
-        
-        for lib_path in library_paths:
-            lib_path = Path(lib_path)
-            if lib_path.exists() and lib_path.is_dir():
-                # Load all .sysml and .kerml files from library directory
-                for ext in ['*.sysml', '*.kerml']:
-                    for lib_file in lib_path.glob(f'**/{ext}'):
-                        try:
-                            lib_content = lib_file.read_text(encoding='utf-8')
-                            library_content.append(lib_content)
-                        except Exception:
-                            pass  # Skip files that can't be read
-        
-        # Prepend library content to main content
-        if library_content:
-            content = '\n\n'.join(library_content) + '\n\n' + content
+    # Library parameter — previously prepended library files to the parse input.
+    # Bundled library files use KerML syntax (datatype, classifier, standard library package)
+    # which the SysML v2 ANTLR grammar cannot parse. Library symbol resolution is handled
+    # by LibrarySymbolIndex (regex scanning) during semantic analysis (analyze()).
+    # The library parameter is accepted for API compatibility but the content is not prepended.
     
     # Create input stream
     input_stream = InputStream(content)

{sysmlpy-0.33.4 → sysmlpy-0.33.6}/src/sysmlpy/antlr_visitor.py

@@ -9265,12 +9265,18 @@ def _visit_definition_body_item_dict(item_ctx, is_interface=False):
                         dir_dict = ref_prefix["direction"]
                         if dir_dict and isinstance(dir_dict, dict) and len(dir_dict) > 0:
                             direction = dir_dict
+                    # Preserve the keyword from the usage type
+                    # Only set keyword for non-default types (item/port).
+                    # PartUsage is the default interface end type — no keyword needed.
+                    usage_to_keyword = {"ItemUsage": "item", "PortUsage": "port"}
+                    keyword = usage_to_keyword.get(usage_name, None)
                     default_interface_end = {
                         "name": "DefaultInterfaceEnd",
                         "direction": direction,
                         "isAbstract": is_abstract,
                         "isVariation": is_variation,
                         "isEnd": is_end,
+                        "keyword": keyword,
                         "usage": usage_dict
                     }
                     iface_elem = {

{sysmlpy-0.33.4 → sysmlpy-0.33.6}/src/sysmlpy/grammar/classes.py

@@ -3897,15 +3897,16 @@ class DefaultInterfaceEnd:
     def __init__(self, definition):
         if valid_definition(definition, self.__class__.__name__):
             self.direction = None
-            self.isAbstract = definition["isAbstract"]
-            self.isVariation = definition["isVariation"]
-            self.isEnd = definition["isEnd"]
+            self.isAbstract = definition.get("isAbstract")
+            self.isVariation = definition.get("isVariation")
+            self.isEnd = definition.get("isEnd")
+            self.keyword = definition.get("keyword")
             self.usage = None
 
-            if definition["direction"] is not None:
+            if definition.get("direction") is not None:
                 self.direction = FeatureDirection(definition["direction"])
 
-            if definition["usage"] is not None:
+            if definition.get("usage") is not None:
                 self.usage = Usage(definition["usage"])
 
     def dump(self):
@@ -3918,6 +3919,8 @@ class DefaultInterfaceEnd:
             output.append("variation")
         if self.isEnd:
             output.append("end")
+        if self.keyword is not None:
+            output.append(self.keyword)
         if self.usage is not None:
             output.append(self.usage.dump())
         return " ".join(output)
@@ -3929,6 +3932,7 @@ class DefaultInterfaceEnd:
             "isAbstract": self.isAbstract,
             "isVariation": self.isVariation,
             "isEnd": self.isEnd,
+            "keyword": self.keyword,
             "usage": self.usage.get_definition() if self.usage else None,
         }
 

{sysmlpy-0.33.4 → sysmlpy-0.33.6}/src/sysmlpy/semantic.py

@@ -329,10 +329,10 @@ class SymbolTable:
             return self._parent.lookup(name, from_child=True)
         return None
 
-    def build_from_model(self, model: Any) -> None:
+    def build_from_model(self, model: Any, lib_roots: list[Path] | None = None) -> None:
         """Walk the model tree and populate the symbol table."""
         self._walk_element(model, self)
-        self._resolve_imports(self)
+        self._resolve_imports(self, lib_roots)
         self._propagate_public_imports(self)
 
     # -- internals -----------------------------------------------------------
@@ -380,14 +380,14 @@ class SymbolTable:
             if child_type == "Import":
                 table._imports.append(child)
 
-    def _resolve_imports(self, table: SymbolTable) -> None:
+    def _resolve_imports(self, table: SymbolTable, lib_roots: list[Path] | None = None) -> None:
         """Resolve all imports for this scope and its children."""
         for imp in table._imports:
-            self._resolve_single_import(imp, table)
+            self._resolve_single_import(imp, table, lib_roots)
 
         # Recurse into children
         for child_table in table._children.values():
-            self._resolve_imports(child_table)
+            self._resolve_imports(child_table, lib_roots)
 
     def _propagate_public_imports(self, table: SymbolTable) -> None:
         """Propagate public and protected imports through the namespace hierarchy.
@@ -429,7 +429,7 @@ class SymbolTable:
             # Recurse into children
             self._propagate_public_imports(child_table)
 
-    def _resolve_single_import(self, imp: Any, table: SymbolTable) -> None:
+    def _resolve_single_import(self, imp: Any, table: SymbolTable, lib_roots: list[Path] | None = None) -> None:
         """Resolve a single Import object into the symbol table."""
         if not imp.children:
             return
@@ -441,9 +441,9 @@ class SymbolTable:
         child_type = type(import_child).__name__
 
         if child_type == "MembershipImport":
-            self._resolve_membership_import(import_child, table, visibility)
+            self._resolve_membership_import(import_child, table, visibility, lib_roots)
         elif child_type == "NamespaceImport":
-            self._resolve_namespace_import(import_child, table, visibility)
+            self._resolve_namespace_import(import_child, table, visibility, lib_roots)
 
     def _extract_import_visibility(self, imp: Any) -> str:
         """Extract visibility keyword from an Import object.
@@ -471,7 +471,7 @@ class SymbolTable:
         else:
             return "private"
 
-    def _resolve_membership_import(self, mem_import: Any, table: SymbolTable, visibility: str) -> None:
+    def _resolve_membership_import(self, mem_import: Any, table: SymbolTable, visibility: str, lib_roots: list[Path] | None = None) -> None:
         """Resolve a MembershipImport (import specific element)."""
         imported_mem = getattr(mem_import, "membership", None)
         if imported_mem is None:
@@ -492,8 +492,14 @@ class SymbolTable:
             simple_name = names[-1]
             table._imported_symbols[simple_name] = element
             table._import_visibility[simple_name] = visibility
+        else:
+            # Fall back to LibrarySymbolIndex for library symbols
+            if ref_str in LibrarySymbolIndex.get_symbols(lib_roots):
+                simple_name = names[-1]
+                table._imported_symbols[simple_name] = ref_str
+                table._import_visibility[simple_name] = visibility
 
-    def _resolve_namespace_import(self, ns_import: Any, table: SymbolTable, visibility: str) -> None:
+    def _resolve_namespace_import(self, ns_import: Any, table: SymbolTable, visibility: str, lib_roots: list[Path] | None = None) -> None:
         """Resolve a NamespaceImport (import all from namespace)."""
         imported_ns = getattr(ns_import, "namespace", None)
         if imported_ns is None:
@@ -512,17 +518,33 @@ class SymbolTable:
         # Find the target namespace table
         ref_str = "::".join(names)
         target_table = self._find_namespace_table(ref_str, table)
-        if target_table is None:
-            return
-
-        # Import all symbols from the target namespace
-        for sym_name, element in target_table._symbols.items():
-            table._imported_symbols[sym_name] = element
-            table._import_visibility[sym_name] = visibility
-
-        # If recursive, also import from all child namespaces
-        if is_recursive:
-            self._recursive_import(target_table, table, visibility)
+        if target_table is not None:
+            # Import all symbols from the target namespace
+            for sym_name, element in target_table._symbols.items():
+                table._imported_symbols[sym_name] = element
+                table._import_visibility[sym_name] = visibility
+
+            # If recursive, also import from all child namespaces
+            if is_recursive:
+                self._recursive_import(target_table, table, visibility)
+        else:
+            # Fall back to LibrarySymbolIndex for library namespaces
+            prefix = ref_str + "::"
+            lib_symbols = LibrarySymbolIndex.get_symbols(lib_roots)
+            for sym in lib_symbols:
+                if sym.startswith(prefix):
+                    simple_name = sym[len(prefix):]
+                    # Only import direct children (no nested :: in the remainder)
+                    if "::" not in simple_name:
+                        table._imported_symbols[simple_name] = sym
+                        table._import_visibility[simple_name] = visibility
+                    elif is_recursive:
+                        # For recursive imports, also import deeply nested symbols
+                        # Use the next-level name as the imported name
+                        next_name = simple_name.split("::")[0]
+                        if next_name not in table._imported_symbols:
+                            table._imported_symbols[next_name] = sym
+                            table._import_visibility[next_name] = visibility
 
     def _recursive_import(self, source_table: SymbolTable, dest_table: SymbolTable, visibility: str) -> None:
         """Recursively import symbols from all child namespaces."""
@@ -989,7 +1011,7 @@ class SemanticAnalyzer:
 
         # Step 1: Build symbol table
         symtab = SymbolTable()
-        symtab.build_from_model(model)
+        symtab.build_from_model(model, lib_roots)
 
         # Step 2: Validate imports (check if import targets exist)
         issues.extend(self._validate_imports(symtab, lib_roots))