mps-cli 0.4.0__tar.gz → 0.5.1__tar.gz

{mps_cli-0.4.0 → mps_cli-0.5.1}/.gitignore

@@ -1,3 +1,8 @@
+# --- VS Code Shared Settings ---
+**/.vscode/*
+!mps-cli-py/.vscode/settings.json
+!mps-cli-py/.vscode/extensions.json
+
 **/.idea/
 **/.gradle/
 **/build/
@@ -19,4 +24,5 @@
 gradle.properties
 **/workspace.xml
 **/misc.xml
-**/__pycache__/
+**/__pycache__/
+**/.DS_Store

{mps_cli-0.4.0 → mps_cli-0.5.1}/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: mps-cli
-Version: 0.4.0
+Version: 0.5.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
-Author-email: Daniel Ratiu <ratiud@googlemail.com>
+Author-email: Daniel Ratiu <ratiud@googlemail.com>, Prithvi Venkat <prithvi.rvce@gmail.com>, Michael Langhammer <mich.langhammer@googlemail.com>
 License-File: LICENSE
 Classifier: License :: OSI Approved :: Eclipse Public License 2.0 (EPL-2.0)
 Classifier: Operating System :: OS Independent
@@ -18,7 +18,7 @@ This project provides a Python library which parses MPS files and builds the obj
 
 ### Features
 The following features are available:
-- load MPS files (*.mpsr, *.mps, *.jar) and expose their content as Python object model 
+- load MPS files (*.mpsr, *.mps, *.mpb, *.jar) and expose their content as Python object model 
   - solutions, models, root nodes, nodes, children, references, properties
 - extract the meta-information and expose it as Python object model
   - list of languages, their concepts with information about properties, references, children
@@ -32,6 +32,7 @@ The core of the Python object model is given by the following classes:
 ### Limitations
 The library has currently the following limitations:
 - the recovered language information reflects only the used language in the loaded solutions
+  - if "mps/plugins" directory is considered the language information is loaded as an object model
 
 ### Run tests
 

{mps_cli-0.4.0 → mps_cli-0.5.1}/README.md

@@ -4,7 +4,7 @@ This project provides a Python library which parses MPS files and builds the obj
 
 ### Features
 The following features are available:
-- load MPS files (*.mpsr, *.mps, *.jar) and expose their content as Python object model 
+- load MPS files (*.mpsr, *.mps, *.mpb, *.jar) and expose their content as Python object model 
   - solutions, models, root nodes, nodes, children, references, properties
 - extract the meta-information and expose it as Python object model
   - list of languages, their concepts with information about properties, references, children
@@ -18,6 +18,7 @@ The core of the Python object model is given by the following classes:
 ### Limitations
 The library has currently the following limitations:
 - the recovered language information reflects only the used language in the loaded solutions
+  - if "mps/plugins" directory is considered the language information is loaded as an object model
 
 ### Run tests
 

{mps_cli-0.4.0 → mps_cli-0.5.1}/Readme.md

@@ -4,7 +4,7 @@ This project provides a Python library which parses MPS files and builds the obj
 
 ### Features
 The following features are available:
-- load MPS files (*.mpsr, *.mps, *.jar) and expose their content as Python object model 
+- load MPS files (*.mpsr, *.mps, *.mpb, *.jar) and expose their content as Python object model 
   - solutions, models, root nodes, nodes, children, references, properties
 - extract the meta-information and expose it as Python object model
   - list of languages, their concepts with information about properties, references, children
@@ -18,6 +18,7 @@ The core of the Python object model is given by the following classes:
 ### Limitations
 The library has currently the following limitations:
 - the recovered language information reflects only the used language in the loaded solutions
+  - if "mps/plugins" directory is considered the language information is loaded as an object model
 
 ### Run tests
 

{mps_cli-0.4.0 → mps_cli-0.5.1}/pyproject.toml

@@ -4,9 +4,11 @@ build-backend = "hatchling.build"
 
 [project]
 name = "mps-cli"
-version = "0.4.0"
+version = "0.5.1"
 authors = [
   { name="Daniel Ratiu", email="ratiud@googlemail.com" },
+  { name="Prithvi Venkat", email="prithvi.rvce@gmail.com" },
+  { name="Michael Langhammer", email="mich.langhammer@googlemail.com" },
 ]
 description = "MPS Command Line Interface (MPS-CLI) is a library to parse MPS files and build the model as Python objects."
 readme = "README.md"
@@ -22,4 +24,8 @@ classifiers = [
 "Bug Tracker" = "https://github.com/mbeddr/mps-cli/issues"
 
 [tool.hatch.build.targets.wheel]
-packages = ["src/mpscli"]
+packages = ["src/mpscli"]
+
+[tool.black]
+line-length = 88
+target-version = ['py37']

mps_cli-0.5.1/src/mpscli/demo.py

@@ -0,0 +1,296 @@
+"""
+demo.py - A quick local test for the binary parser.
+
+Points at a local MPS project directory and prints a summary of what was parsed.
+Edit PLUGINS_PATH below to point at either MPS plugins folder or a test project.
+
+Two modes:
+    MODE = "plugins": parse a full MPS plugins directory (e.g. C:\\Temp\\plugins)
+    MODE = "test_project": parse a single mps_test_projects directory (original behaviour)
+"""
+
+import sys
+import time
+from datetime import datetime
+from pathlib import Path
+
+sys.path.insert(1, "..")
+
+# "plugins" or "test_project"
+MODE = "plugins"
+PLUGINS_PATH = r"C:\Temp\plugins"
+TEST_PROJECT = r"..\..\mps_test_projects\mps_cli_lanuse_file_per_root"
+
+from mpscli.model.builder.SSolutionsRepositoryBuilder import SSolutionsRepositoryBuilder
+
+
+def count_nodes(node) -> int:
+    total = 1
+    for child in node.children or []:
+        total += count_nodes(child)
+    return total
+
+
+def concept_name(concept) -> str:
+    if concept is None:
+        return "<null>"
+    if isinstance(concept, str):
+        return concept
+    full = getattr(concept, "name", None)
+    if full:
+        return full.split(".")[-1]
+    return str(concept)
+
+
+def concept_full_name(concept) -> str:
+    if concept is None:
+        return "<null>"
+    if isinstance(concept, str):
+        return concept
+    return getattr(concept, "name", str(concept))
+
+
+def fmt_id(value) -> str:
+    return str(value) if value is not None else "null"
+
+
+def print_node(node, depth: int = 0, max_depth: int = 3) -> None:
+    if depth > max_depth:
+        return
+
+    pad = "  " * depth
+    cname = concept_name(node.concept)
+    role = getattr(node, "role_in_parent", None)
+    uid = fmt_id(getattr(node, "uuid", None))
+    name = node.properties.get("name", "")
+
+    # node headline: bullet + concept + role slot + name in quotes + id in brackets
+    role_tag = f" [{role}]" if role else ""
+    name_tag = f"  '{name}'" if name else ""
+    print(f"{pad}\u2022 {cname}{role_tag}{name_tag}  [{uid}]")
+
+    # other properties (name already shown inline above)
+    for k, v in sorted((node.properties or {}).items()):
+        if k != "name":
+            print(f"{pad}    {k} = {v!r}")
+
+    # references
+    for k, ref in sorted((node.references or {}).items()):
+        resolve = getattr(ref, "resolve_info", None) or ""
+        model_u = str(getattr(ref, "model_uuid", "") or "")
+        if model_u.startswith("java:"):
+            # java stub reference - show class name from resolve_info
+            print(f"{pad}    {k} -> {resolve} (Java)")
+        else:
+            # mps model reference - show uuid + resolve hint
+            hint = f" ({resolve})" if resolve else ""
+            print(f"{pad}    {k} -> {model_u[:36]}{hint}")
+
+    for child in node.children or []:
+        print_node(child, depth + 1, max_depth)
+
+
+def print_model(model, max_roots: int = 3, max_depth: int = 3) -> None:
+    roots = model.root_nodes
+    total_nodes = sum(count_nodes(r) for r in roots)
+
+    print(f"\n--- Model: {model.name} ---")
+    print(f"    uuid       : {model.uuid}")
+    print(f"    root nodes : {len(roots)}")
+    print(f"    total nodes: {total_nodes}")
+
+    for i, root in enumerate(roots[:max_roots]):
+        print(f"\n  [ROOT {i}]")
+        print_node(root, depth=2, max_depth=max_depth)
+
+    if len(roots) > max_roots:
+        print(f"\n  ... ({len(roots) - max_roots} more root nodes not shown)")
+
+
+def verify_model(model) -> dict:
+    checks = {}
+
+    checks["uuid_set"] = (
+        model.uuid not in ("r:unknown", "", None),
+        str(model.uuid),
+    )
+    checks["name_set"] = (
+        model.name not in ("unknown.model", "", None),
+        str(model.name),
+    )
+
+    bad_concepts = [
+        concept_full_name(r.concept) for r in model.root_nodes if not r.concept
+    ]
+    checks["concepts_set"] = (
+        not bad_concepts,
+        f"{len(bad_concepts)} missing" if bad_concepts else "all set",
+    )
+
+    null_ids = sum(1 for r in model.root_nodes if getattr(r, "uuid", None) is None)
+    checks["node_ids_set"] = (
+        null_ids == 0,
+        f"{null_ids} null ids" if null_ids else "all set",
+    )
+
+    bad_props = sum(
+        1
+        for r in model.root_nodes
+        if not isinstance(getattr(r, "properties", None), dict)
+    )
+    checks["properties_are_dict"] = (
+        bad_props == 0,
+        f"{bad_props} nodes with bad props" if bad_props else "all dicts",
+    )
+
+    bad_refs = sum(
+        1
+        for r in model.root_nodes
+        if not isinstance(getattr(r, "references", None), dict)
+    )
+    checks["references_are_dict"] = (
+        bad_refs == 0,
+        f"{bad_refs} nodes with bad refs" if bad_refs else "all dicts",
+    )
+
+    return checks
+
+
+def print_languages(repo) -> None:
+    # split languagess into two groups so basically those with aspect models loaded (mpl was actuallyy found) and
+    # those without (maybe only seen via registry during .mpb parsing)
+    with_models = [l for l in repo.languages if l.models]
+    without_models = [l for l in repo.languages if not l.models]
+
+    print(f"\n*** Languages ({len(repo.languages)} total) ***")
+    print(f"  with aspect models loaded - {len(with_models)}")
+    print(f"  Registry-only (no .mpl found) : {len(without_models)}")
+
+    if with_models:
+        print("\n  ---Languages with aspect models ----")
+        for lang in sorted(with_models, key=lambda l: l.name):
+            aspect_names = ", ".join(
+                m.name.split(".")[-1] for m in lang.models if m.name
+            )
+            print(f"  \u2022 {lang.name}")
+            print(f"  version : {lang.language_version}")
+            print(f"  uuid    : {lang.uuid}")
+            print(f"  aspects : {aspect_names}")
+            print(f"  concepts (registry): {len(lang.concepts)}")
+
+            # show rooot node countt per aspect to verify .mpb parsing actually worked
+            for m in lang.models:
+                aspect = m.name.split(".")[-1] if m.name else "?"
+                root_count = len(m.root_nodes)
+                print(f"[{aspect}] {root_count} roots")
+
+                if "structure" in (m.name or "") and root_count > 0:
+                    concept_names = [
+                        r.properties.get("name", "")
+                        for r in m.root_nodes[:5]
+                        if r.properties.get("name")
+                    ]
+                    if concept_names:
+                        print(f"sample concepts: {', '.join(concept_names)}")
+
+    if without_models:
+        print("\n  ---- Registry-only languages (no aspect models) ---")
+        for lang in sorted(without_models, key=lambda l: l.name):
+            print(f"  \u2022 {lang.name}  ({len(lang.concepts)} concepts)")
+
+
+def main() -> None:
+    path = PLUGINS_PATH if MODE == "plugins" else TEST_PROJECT
+
+    builder = SSolutionsRepositoryBuilder()
+
+    msg = f"Parsing ({MODE}): {path}"
+    print(msg, flush=True)
+    sys.stderr.write(msg + "\n")
+    sys.stderr.flush()
+
+    t0 = time.perf_counter()
+    repo = builder.build(path)
+    t1 = time.perf_counter()
+
+    elapsed = t1 - t0
+    timing_msg = f"Parsing complete in {elapsed:.1f}s"
+    print(f"\n{timing_msg}")
+    sys.stderr.write(timing_msg + "\n")
+    sys.stderr.flush()
+
+    total_models = sum(len(s.models) for s in repo.solutions)
+    total_nodes = sum(
+        sum(count_nodes(r) for r in m.root_nodes)
+        for s in repo.solutions
+        for m in s.models
+    )
+
+    summary = (
+        f"\n***Repository Summary***\n"
+        f"  Solutions : {len(repo.solutions)}\n"
+        f"  Languages : {len(repo.languages)}\n"
+        f"  Models    : {total_models}\n"
+        f"  Nodes     : {total_nodes:,}\n"
+    )
+    print(summary)
+    sys.stderr.write(summary)
+    sys.stderr.flush()
+
+    print("=== Verification ===")
+    failed = 0
+    for sol in repo.solutions:
+        for model in sol.models:
+            checks = verify_model(model)
+            bad = [(k, detail) for k, (passed, detail) in checks.items() if not passed]
+            if bad:
+                failed += 1
+                print(f"  FAIL  {model.name}")
+                for k, detail in bad:
+                    print(f"        [{k}] {detail}")
+
+    verdict = (
+        f"  All {total_models} models passed verification"
+        if failed == 0
+        else f"  {failed} models failed verification"
+    )
+    print(verdict)
+    sys.stderr.write(f"\n{verdict}\n")
+    sys.stderr.flush()
+
+    # language extension verification - shows whether .mpl reading worked
+    print_languages(repo)
+
+    print("\n=== Solutions ===")
+    for sol in repo.solutions:
+        if not sol.models:
+            # skip language-only jars with no models to show
+            continue
+        sol_nodes = sum(sum(count_nodes(r) for r in m.root_nodes) for m in sol.models)
+        print(f"\n{'='*60}")
+        print(f"Solution : {sol.name}")
+        print(f"Models   : {len(sol.models)}   Nodes: {sol_nodes:,}")
+        print(f"{'='*60}")
+        for model in sol.models:
+            print_model(model, max_roots=3, max_depth=3)
+
+    print("\n=== Languages ===")
+    for lan in repo.languages:
+        if not lan.concepts:
+            continue
+        print(f"Language : {lan.name}")
+        print(f"{'='*60}")
+        for c in lan.concepts:
+            c.print_concept_details()
+
+if __name__ == "__main__":
+    import multiprocessing
+
+    multiprocessing.freeze_support()
+
+    # 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)
+    print(f"Logging to: {log_file}")
+
+    main()

mps_cli-0.5.1/src/mpscli/demo_language_extraction.py

@@ -0,0 +1,265 @@
+"""
+demo_language_extraction.py - extract concept definitions from language structure aspects and
+write them as a markdown file that is transferrable to HTML
+
+"""
+
+import sys
+from datetime import datetime
+from pathlib import Path
+
+sys.path.insert(1, "..")
+
+MODE = "plugins"
+PLUGINS_PATH = r"C:\Temp\plugins"
+TEST_PROJECT = r"..\..\mps_test_projects\mps_cli_binary_persistency_language"
+OUTPUT_FILE = Path(f"language_concepts_{datetime.now().strftime('%H%M%S')}.md")
+
+from mpscli.model.builder.SSolutionsRepositoryBuilder import SSolutionsRepositoryBuilder
+from mpscli.model.builder.SLanguageBuilder import SLanguageBuilder
+
+
+def _short(full_name: str) -> str:
+    if not full_name:
+        return ""
+    return full_name.split(".")[-1]
+
+
+def _prop(node, key: str, default="") -> str:
+    props = getattr(node, "properties", None) or {}
+    return props.get(key, default).strip()
+
+
+def _ref_resolve_info(ref_obj) -> str:
+    return (getattr(ref_obj, "resolve_info", None) or "").strip()
+
+
+def extract_concept_info(concept_node) -> dict:
+    # pull all useful fields from a ConceptDeclaration or InterfaceConceptDeclaration SNode
+    info = {}
+
+    info["name"] = _prop(concept_node, "name") or _short(
+        str(getattr(concept_node, "concept", ""))
+    )
+
+    info["concept_type"] = _short(str(getattr(concept_node, "concept", "") or ""))
+    info["is_abstract"] = _prop(concept_node, "abstract") == "true"
+    info["is_root"] = _prop(concept_node, "rootable") == "true"
+    info["alias"] = _prop(concept_node, "alias")
+    info["short_description"] = _prop(concept_node, "shortDescription")
+
+    # supertype is a direct reference on the root node
+    refs = getattr(concept_node, "references", None) or {}
+    extends_ref = refs.get("extends") or refs.get("superConcept")
+    info["extends"] = _ref_resolve_info(extends_ref) if extends_ref else ""
+
+    implements = []
+    properties = []
+    child_links = []
+    ref_links = []
+
+    for child in getattr(concept_node, "children", None) or []:
+        role = getattr(child, "role_in_parent", "") or ""
+        child_refs = getattr(child, "references", None) or {}
+
+        if role == "implements":
+            ri = (
+                _ref_resolve_info(child_refs.get("intfc"))
+                if "intfc" in child_refs
+                else ""
+            )
+            if ri:
+                implements.append(ri)
+
+        elif role == "propertyDeclaration":
+            prop_name = _prop(child, "name")
+            prop_type = (
+                _ref_resolve_info(child_refs.get("dataType"))
+                if "dataType" in child_refs
+                else ""
+            )
+            if prop_name:
+                properties.append({"name": prop_name, "type": prop_type})
+
+        elif role == "linkDeclaration":
+            meta = _prop(child, "metaClass")
+            link_name = _prop(child, "role")
+            raw_card = _prop(child, "sourceCardinality")
+            cardinality = raw_card.split("/")[-1] if "/" in raw_card else raw_card
+            link_type = (
+                _ref_resolve_info(child_refs.get("target"))
+                if "target" in child_refs
+                else ""
+            )
+
+            if not link_name:
+                continue
+
+            entry = {"name": link_name, "type": link_type, "cardinality": cardinality}
+            if "aggregation" in meta:
+                child_links.append(entry)
+            elif "reference" in meta:
+                ref_links.append(entry)
+
+    info["implements"] = implements
+    info["properties"] = properties
+    info["child_links"] = child_links
+    info["ref_links"] = ref_links
+
+    return info
+
+
+def _format_concept(info: dict) -> str:
+    # produces the plain-text declaration block usedd for .md file
+    lines = []
+
+    prefix = "abstract " if info["is_abstract"] else ""
+    concept_kind = (
+        "interface concept" if "Interface" in info["concept_type"] else "concept"
+    )
+    header = f"{prefix}{concept_kind} {info['name']}"
+
+    extends_part = f"extends {_short(info['extends'])}" if info["extends"] else ""
+    impl_parts = [_short(i) for i in info["implements"]]
+
+    if extends_part and impl_parts:
+        lines.append(f"{header} - {extends_part}")
+        pad = " " * (len(header) + 3)
+        for iface in impl_parts:
+            lines.append(f"{pad}implements {iface}")
+    elif extends_part:
+        lines.append(f"{header} - {extends_part}")
+    elif impl_parts:
+        lines.append(f"{header} - implements {impl_parts[0]}")
+        pad = " " * (len(header) + 3)
+        for iface in impl_parts[1:]:
+            lines.append(f"{pad}implements {iface}")
+    else:
+        lines.append(header)
+
+    if info["alias"] or info["short_description"] or info["is_root"]:
+        lines.append("")
+    if info["alias"]:
+        lines.append(f"alias: {info['alias']}")
+    if info["short_description"]:
+        lines.append(f"description: {info['short_description']}")
+    if info["is_root"]:
+        lines.append("instance can be root: yes")
+
+    if info["properties"]:
+        lines.append("")
+        lines.append("properties:")
+        for p in info["properties"]:
+            t = f" : {_short(p['type'])}" if p["type"] else ""
+            lines.append(f"  {p['name']}{t}")
+
+    if info["child_links"]:
+        lines.append("")
+        lines.append("children:")
+        for c in info["child_links"]:
+            t = f" : {_short(c['type'])}" if c["type"] else ""
+            card = f" [{c['cardinality']}]" if c["cardinality"] else ""
+            lines.append(f"  {c['name']}{t}{card}")
+
+    if info["ref_links"]:
+        lines.append("")
+        lines.append("references:")
+        for r in info["ref_links"]:
+            t = f" : {_short(r['type'])}" if r["type"] else ""
+            card = f" [{r['cardinality']}]" if r["cardinality"] else ""
+            lines.append(f"  {r['name']}{t}{card}")
+
+    return "\n".join(lines)
+
+
+def collect_languages_with_structure() -> list:
+    result = []
+    for lang in sorted(SLanguageBuilder.languages.values(), key=lambda l: l.name):
+        if not lang.models:
+            continue
+        structure = lang.find_model_by_name("structure")
+        if structure and structure.root_nodes:
+            result.append((lang, structure))
+    return result
+
+
+def build_markdown(languages_with_structure: list) -> str:
+    # the markdown uses fencedd code blocks so thhe aligned plain text declaration renders in monospace
+    # in HTML but is still clean as raww text
+    sections = []
+
+    sections.append("# Language Concept Definitions")
+    sections.append("")
+    sections.append("only languages for which a .mpl source was found are included.")
+    sections.append("")
+
+    if not languages_with_structure:
+        sections.append("No structure aspect models were found.")
+        return "\n".join(sections)
+
+    for lang, structure in languages_with_structure:
+        sections.append(f"## {lang.name}")
+        sections.append("")
+        sections.append(f"uuid: {lang.uuid}  ")
+        sections.append(f"version: {lang.language_version}  ")
+        sections.append(f"concepts: {len(structure.root_nodes)}")
+        sections.append("")
+
+        for root in structure.root_nodes:
+            cname = _short(str(getattr(root, "concept", "") or ""))
+            if "concept" not in cname.lower() and "Concept" not in cname:
+                continue
+            info = extract_concept_info(root)
+            if not info["name"]:
+                continue
+            # fenced code block preserves alignment and I think renders cleanly in HTML
+            sections.append("```")
+            sections.append(_format_concept(info))
+            sections.append("```")
+            sections.append("")
+
+    return "\n".join(sections)
+
+
+def main():
+    path = PLUGINS_PATH if MODE == "plugins" else TEST_PROJECT
+
+    print(f"Parsing ({MODE}): {path}", flush=True)
+    builder = SSolutionsRepositoryBuilder()
+    builder.USE_CACHE = False
+    builder.build(path)
+
+    languages_with_structure = collect_languages_with_structure()
+
+    print(
+        f"Languages with structure aspect: {len(languages_with_structure)}", flush=True
+    )
+
+    for lang, structure in languages_with_structure:
+        print(f"\n{'=' * 60}")
+        print(f"Language : {lang.name}")
+        print(f"uuid     : {lang.uuid}")
+        print(f"version  : {lang.language_version}")
+        print(f"concepts : {len(structure.root_nodes)}")
+        print(f"{'=' * 60}")
+        print("")
+
+        for root in structure.root_nodes:
+            cname = _short(str(getattr(root, "concept", "") or ""))
+            if "concept" not in cname.lower() and "Concept" not in cname:
+                continue
+            info = extract_concept_info(root)
+            if not info["name"]:
+                continue
+            # print each line indented by two spaces for readabilityy
+            for line in _format_concept(info).splitlines():
+                print(f"  {line}")
+            print("")
+
+    md = build_markdown(languages_with_structure)
+    OUTPUT_FILE.write_text(md, encoding="utf-8")
+    print(f"\nmarkdown file written: {OUTPUT_FILE}", flush=True)
+
+
+if __name__ == "__main__":
+    main()

{mps_cli-0.4.0 → mps_cli-0.5.1}/src/mpscli/model/SConcept.py

@@ -1,4 +1,3 @@
-
 class SConcept:
 
     def __init__(self, name, uuid):
@@ -19,4 +18,4 @@ class SConcept:
         print("\treferences: ")
         for reference in self.references:
             print("\t\t" + reference)
-        print("<<<")
+        print("<<<")