mps-cli 0.6.0__tar.gz → 0.6.1__tar.gz

{mps_cli-0.6.0 → mps_cli-0.6.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mps-cli
-Version: 0.6.0
+Version: 0.6.1
 Summary: MPS Command Line Interface (MPS-CLI) is a library to parse MPS files and build the model as Python objects.
 Project-URL: Homepage, https://github.com/mbeddr/mps-cli
 Project-URL: Bug Tracker, https://github.com/mbeddr/mps-cli/issues
@@ -10,6 +10,8 @@ Classifier: License :: OSI Approved :: Eclipse Public License 2.0 (EPL-2.0)
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.7
+Provides-Extra: dev
+Requires-Dist: parameterized; extra == 'dev'
 Description-Content-Type: text/markdown
 
 ## MPS CLI Python Library

{mps_cli-0.6.0 → mps_cli-0.6.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "mps-cli"
-version = "0.6.0"
+version = "0.6.1"
 authors = [
   { name="Daniel Ratiu", email="ratiud@googlemail.com" },
   { name="Prithvi Venkat", email="prithvi.rvce@gmail.com" },
@@ -19,6 +19,11 @@ classifiers = [
     "Operating System :: OS Independent",
 ]
 
+[project.optional-dependencies]
+dev = [
+    "parameterized",
+]
+
 [project.urls]
 "Homepage" = "https://github.com/mbeddr/mps-cli"
 "Bug Tracker" = "https://github.com/mbeddr/mps-cli/issues"

{mps_cli-0.6.0 → mps_cli-0.6.1}/src/mpscli/demo.py

@@ -13,6 +13,7 @@ import sys
 import time
 from datetime import datetime
 from pathlib import Path
+import logging
 
 sys.path.insert(1, "..")
 
@@ -283,6 +284,7 @@ def main() -> None:
         for c in lan.concepts:
             c.print_concept_details()
 
+
 if __name__ == "__main__":
     import multiprocessing
 
@@ -291,6 +293,7 @@ if __name__ == "__main__":
     # redirect stdout to a log file
     log_file = f"mps_debug_{datetime.now().strftime('%H%M%S')}.log"
     sys.stdout = open(log_file, "w", encoding="utf-8", buffering=1)
+    logging.basicConfig(level=logging.INFO, stream=sys.stderr, format="%(message)s")
     print(f"Logging to: {log_file}")
 
     main()

mps_cli-0.6.1/src/mpscli/model/SConcept.py

@@ -0,0 +1,26 @@
+import logging
+
+_log = logging.getLogger(__name__)
+
+
+class SConcept:
+
+    def __init__(self, name, uuid):
+        self.name = name
+        self.uuid = uuid
+        self.properties = []
+        self.children = []
+        self.references = []
+
+    def print_concept_details(self):
+        _log.debug("concept: %s", self.name)
+        _log.debug("\tproperties: ")
+        for property in self.properties:
+            _log.debug("\t\t%s", property)
+        _log.debug("\tchildren: ")
+        for child in self.children:
+            _log.debug("\t\t%s", child)
+        _log.debug("\treferences: ")
+        for reference in self.references:
+            _log.debug("\t\t%s", reference)
+        _log.debug("<<<")

{mps_cli-0.6.0 → mps_cli-0.6.1}/src/mpscli/model/SLanguage.py

@@ -5,7 +5,10 @@ class SLanguage:
         self.uuid = uuid
         self.concepts = []
 
-        # version number from the languageVersion attribute in the .mpl file..
+        # kept in sync with concepts list by SLanguageBuilder.get_concept()..
+        self._concepts_by_name = {}
+
+        # version number from the languageVersion attribute in the .mpl file.
         # stays 0 if this language was only seen via registry (never had its .mpl read)
         self.language_version = 0
 
@@ -15,10 +18,7 @@ class SLanguage:
         self.models = []
 
     def find_concept_by_name(self, name):
-        for c in self.concepts:
-            if c.name == name:
-                return c
-        return None
+        return self._concepts_by_name.get(name)
 
     def find_model_by_name(self, suffix):
         # find a specific aspect model by the last segment of its name.

mps_cli-0.6.1/src/mpscli/model/builder/SLanguageBuilder.py

@@ -0,0 +1,128 @@
+import warnings
+import xml.etree.ElementTree as ET
+from pathlib import Path
+from threading import Lock
+
+from mpscli.model.SLanguage import SLanguage
+from mpscli.model.SConcept import SConcept
+
+
+class SLanguageBuilder:
+    languages = {}
+    # protectss languages dict, per-language _concepts_by_name dicts and per-concept properties/children/references
+    # lists also.. needed because all get_ methods are called from multiple threads during parallel
+    # parsing (phase3 ProcessPool workers and phase4 ProcessPool workerss)
+    _lock = Lock()
+
+    @classmethod
+    def get_language(cls, name, uuid):
+        lan = cls.languages.get(name)
+        if lan is not None:
+            return lan
+        with cls._lock:
+            lan = cls.languages.get(name)
+            if lan is None:
+                lan = SLanguage(name, uuid)
+                cls.languages[name] = lan
+        return lan
+
+    @classmethod
+    def get_concept(cls, language, concept_name, concept_uuid):
+        # always acquire lock since _concepts_by_name is mutated here and by other threads..
+        # SLanguage.__init__ always initialises _concepts_by_name so no hasattr check needed
+        with cls._lock:
+            concept = language._concepts_by_name.get(concept_name)
+            if concept is None:
+                concept = SConcept(concept_name, concept_uuid)
+                language.concepts.append(concept)
+                language._concepts_by_name[concept_name] = concept
+        return concept
+
+    @classmethod
+    def get_property(cls, concept, property_name):
+        # fast path cuz list iteration is GIL-atomic for reads in CPython
+        node_property = next(
+            (p for p in concept.properties if p == property_name), None
+        )
+        if node_property is not None:
+            return node_property
+        with cls._lock:
+            # double-check inside lock since another thread may have added it
+            node_property = next(
+                (p for p in concept.properties if p == property_name), None
+            )
+            if node_property is None:
+                concept.properties.append(property_name)
+                node_property = property_name
+        return node_property
+
+    @classmethod
+    def get_child(cls, concept, child_name):
+        child_role = next((c for c in concept.children if c == child_name), None)
+        if child_role is not None:
+            return child_role
+        with cls._lock:
+            child_role = next((c for c in concept.children if c == child_name), None)
+            if child_role is None:
+                concept.children.append(child_name)
+                child_role = child_name
+        return child_role
+
+    @classmethod
+    def get_reference(cls, concept, reference_name):
+        reference_role = next(
+            (r for r in concept.references if r == reference_name), None
+        )
+        if reference_role is not None:
+            return reference_role
+        with cls._lock:
+            reference_role = next(
+                (r for r in concept.references if r == reference_name), None
+            )
+            if reference_role is None:
+                concept.references.append(reference_name)
+                reference_role = reference_name
+        return reference_role
+
+    @classmethod
+    def load_from_mpl(cls, mpl_path: Path) -> SLanguage:
+        # reads a .mpl file and enriches the matching SLanguage with its version
+        # number and aspect models. if the language was already registered via
+        # a registry section in a .mpb file, get_language() returns the same object
+        # so no duplicate entries are created.
+        try:
+            return cls._read_and_enrich(mpl_path)
+        except Exception as exc:
+            warnings.warn(f"Failed to read language from {mpl_path.name}: {exc}")
+            return None
+
+    @classmethod
+    def _read_and_enrich(cls, mpl_path: Path) -> SLanguage:
+        root = ET.parse(mpl_path).getroot()
+        namespace = root.get("namespace", "")
+        uuid = root.get("uuid", "")
+        version = int(root.get("languageVersion", "0"))
+        lang = cls.get_language(namespace, uuid)
+        lang.language_version = version
+        lang.models = cls._load_aspect_models(mpl_path.parent / "models")
+        return lang
+
+    @classmethod
+    def _load_aspect_models(cls, models_dir: Path) -> list:
+        # parse every .mpb in the models directory next to the .mpl file
+        # these are the language aspects which is structure,, behavior, editor, constraints, typesystem, etc..
+        if not models_dir.exists():
+            return []
+        from mpscli.model.builder.SModelBuilderBinaryPersistency import (
+            SModelBuilderBinaryPersistency,
+        )
+
+        loaded = []
+        for mpb_file in sorted(models_dir.glob("*.mpb")):
+            try:
+                model = SModelBuilderBinaryPersistency().build(str(mpb_file))
+                if model is not None:
+                    loaded.append(model)
+            except Exception as exc:
+                warnings.warn(f"Failed to parse aspect model {mpb_file.name}: {exc}")
+        return loaded

{mps_cli-0.6.0 → mps_cli-0.6.1}/src/mpscli/model/builder/SModelBuilderBase.py

@@ -37,7 +37,11 @@ class SModelBuilderBase:
             else:
                 ref_model_index = ref_to[0 : ref_to.find(":")]
                 ref_node_uuid = ref_to[ref_to.find(":") + 1 : len(ref_to)]
-                s_node_ref = SNodeRef(self.index_2_imported_model_uuid[ref_model_index], ref_node_uuid, resolve_info)
+                s_node_ref = SNodeRef(
+                    self.index_2_imported_model_uuid[ref_model_index],
+                    ref_node_uuid,
+                    resolve_info,
+                )
             ref_name = self.index_2_reference_role[ref_role]
             s_node.references[ref_name] = s_node_ref
         for child_node_xml in node_xml.findall("node"):
@@ -45,10 +49,12 @@ class SModelBuilderBase:
             s_node.children.append(child_node)
 
         return s_node
+
     @staticmethod
     def is_model_generatable(model_xml_node):
         return any(
-            attribute.get("name") == "doNotGenerate" and attribute.get("value") == "true"
+            attribute.get("name") == "doNotGenerate"
+            and attribute.get("value") == "true"
             for attribute in model_xml_node.findall("attribute")
         )
 
@@ -64,7 +70,7 @@ class SModelBuilderBase:
             imported_model_ref = import_xml_node.get("ref")
             imported_model_uuid = imported_model_ref[0 : imported_model_ref.find("(")]
             imported_models[import_index] = imported_model_uuid
-            self.index_2_imported_model_uuid[import_index] = imported_model_uuid        
+            self.index_2_imported_model_uuid[import_index] = imported_model_uuid
 
         return imported_models
 
@@ -74,7 +80,9 @@ class SModelBuilderBase:
         model_uuid = model_ref[0 : model_ref.find("(")]
         model_is_do_not_generate = self.is_model_generatable(model_xml_node)
         model_imported_models = self.extract_imported_models(self, model_xml_node)
-        model = SModel(model_name, model_uuid, model_is_do_not_generate, model_imported_models)
+        model = SModel(
+            model_name, model_uuid, model_is_do_not_generate, model_imported_models
+        )
         return model
 
     def extract_registry(self, model_xml_node):
@@ -86,13 +94,17 @@ class SModelBuilderBase:
             for concept_xml_node in language_xml_node.findall("concept"):
                 concept_id = concept_xml_node.get("id")
                 concept_name = concept_xml_node.get("name")
-                concept = SLanguageBuilder.get_concept(language, concept_name, concept_id)
+                concept = SLanguageBuilder.get_concept(
+                    language, concept_name, concept_id
+                )
                 concept_index = concept_xml_node.get("index")
                 self.index_2_concept[concept_index] = concept
                 for property_xml_node in concept_xml_node.findall("property"):
                     property_name = property_xml_node.get("name")
                     property_index = property_xml_node.get("index")
-                    node_property = SLanguageBuilder.get_property(concept, property_name)
+                    node_property = SLanguageBuilder.get_property(
+                        concept, property_name
+                    )
                     self.index_2_property[property_index] = node_property
                 for child_xml_node in concept_xml_node.findall("child"):
                     child_name = child_xml_node.get("name")

{mps_cli-0.6.0 → mps_cli-0.6.1}/src/mpscli/model/builder/SModelBuilderBinaryPersistency.py

@@ -135,6 +135,56 @@ class SModelBuilderBinaryPersistency(SModelBuilderBase):
 
         return model
 
+    def build_from_bytes(self, data: bytes, path_hint: str = ""):
+        reader = ModelInputStream(data)
+
+        # 1. header: extracts stream version andd model UUID and model name
+        version, model_uuid, model_name = self._load_header(reader)
+        self.stream_version = version
+
+        uuid_str = model_uuid or "r:unknown"
+        name_str = model_name or "unknown.model"
+
+        # Import index 0 is always the current models own uuid..
+        # Java's SModel.importedModels() lists imports starting from index 1 and index 0 is implicitly
+        # the model itself used when resolving REF_THIS_MODEL
+        self.index_2_imported_model_uuid["0"] = uuid_str
+        model = SModel(name_str, uuid_str, False)
+
+        # 2. registry: builds concept/property/reference/child index maps
+        load_registry(reader, self)
+
+        # 3. model properties - used languages, devkits, imports
+        try:
+            self._load_model_properties(reader, version)
+        except _UnknownSubKind as e:
+            import warnings
+
+            warnings.warn(
+                f"[build_from_bytes] {path_hint}: {e} - skipped to MODEL_START"
+            )
+            advance_until_after(reader, MODEL_START)
+            return model
+
+        model.imported_models = {
+            index: imported_model_uuid
+            for index, imported_model_uuid in self.index_2_imported_model_uuid.items()
+            if index != "0"
+        }
+
+        # 4. model start..
+        token = reader.read_u32()
+        if token != MODEL_START:
+            raise RuntimeError(
+                f"Expected MODEL_START (0x{MODEL_START:08X}), "
+                f"got 0x{token:08X} at pos {reader.tell() - 4}"
+            )
+
+        # 5. Node tree: recursive read_children populates model.root_nodes..
+        read_children(reader, self, model, None)
+
+        return model
+
     def _load_header(self, reader: ModelInputStream):
         # Mirrors BinaryPersistence.loadHeader() in:
         # https://github.com/JetBrains/MPS/blob/6236c4073eac3cde78506add6b0fa90601d76009/core/persistence/source/jetbrains/mps/persistence/binary/BinaryPersistence.java

{mps_cli-0.6.0 → mps_cli-0.6.1}/src/mpscli/model/builder/SSolutionBuilder.py

@@ -1,15 +1,13 @@
-import os
+import logging
+import warnings
 import xml.etree.ElementTree as ET
 from pathlib import Path
 from typing import List, Optional, Tuple
 
+_log = logging.getLogger(__name__)
+
 from mpscli.model.SSolution import SSolution
-from mpscli.model.builder.SModelBuilderDefaultPersistency import (
-    SModelBuilderDefaultPersistency,
-)
-from mpscli.model.builder.SModelBuilderFilePerRootPersistency import (
-    SModelBuilderFilePerRootPersistency,
-)
+from mpscli.model.builder.utils.DiskModelLoader import parse_fpr, parse_mps
 from mpscli.model.builder.utils.MpbBatchParser import MpbBatchParser
 
 
@@ -20,8 +18,9 @@ class SSolutionBuilder:
     def build_solution(self, path_to_msd_file: Path) -> Optional[SSolution]:
         models_dir = path_to_msd_file.parent / "models"
         if not models_dir.exists():
-            print(
-                f"ERROR: 'models' directory not found - no model is loaded from: {path_to_msd_file.parent}"
+            _log.warning(
+                "'models' directory not found - no model loaded from: %s",
+                path_to_msd_file.parent,
             )
             return None
         solutions = self.build_all([path_to_msd_file])
@@ -40,12 +39,10 @@ class SSolutionBuilder:
         for msd_path in msd_paths:
             solution = self._extract_solution_info(msd_path)
             solution.path_to_solution_file = msd_path
-
             models_dir = msd_path.parent / "models"
             if not models_dir.exists():
                 solution_infos.append((solution, [], [], []))
                 continue
-
             mpb, fpr, mps = self._collect_model_paths(models_dir)
             solution_infos.append((solution, mpb, fpr, mps))
             all_mpb_paths.extend(str(p) for p in mpb)
@@ -61,20 +58,18 @@ class SSolutionBuilder:
 
             for model_path in fpr_dirs:
                 try:
-                    model = SModelBuilderFilePerRootPersistency().build(model_path)
-                    solution.models.append(model)
+                    model = parse_fpr(model_path)
+                    if model is not None:
+                        solution.models.append(model)
                 except Exception as exc:
-                    import warnings
-
                     warnings.warn(f"Failed to parse {model_path}: {exc}")
 
             for model_path in mps_paths:
                 try:
-                    model = SModelBuilderDefaultPersistency().build(model_path)
-                    solution.models.append(model)
+                    model = parse_mps(model_path)
+                    if model is not None:
+                        solution.models.append(model)
                 except Exception as exc:
-                    import warnings
-
                     warnings.warn(f"Failed to parse {model_path}: {exc}")
 
             solutions.append(solution)