mi-mdb 0.1.0__tar.gz

mi_mdb-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Leon Starr
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

mi_mdb-0.1.0/MANIFEST.in

@@ -0,0 +1 @@
+include src/mdb/log.conf

mi_mdb-0.1.0/PKG-INFO

@@ -0,0 +1,49 @@
+Metadata-Version: 2.4
+Name: mi-mdb
+Version: 0.1.0
+Summary: Shlaer-Mellor Executable UML Model Debugger
+Author-email: Leon Starr <leon_starr@modelint.com>
+License: MIT License
+        
+        Copyright (c) 2026 Leon Starr
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: repository, https://github.com/modelint/model-debugger
+Project-URL: documentation, https://github.com/modelint/model-debugger/wiki
+Keywords: shlaer-mellor,metamodel,executable uml,mbse,xuml,xtuml,model debugger,platform independent
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: mi-mx
+Requires-Dist: mi-pyral
+Requires-Dist: PyYAML
+Provides-Extra: build
+Requires-Dist: build; extra == "build"
+Requires-Dist: twine; extra == "build"
+Provides-Extra: dev
+Requires-Dist: bump2version; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Dynamic: license-file
+
+# model-debugger
+A modeling language independent model debugger

mi_mdb-0.1.0/README.md

@@ -0,0 +1,2 @@
+# model-debugger
+A modeling language independent model debugger

mi_mdb-0.1.0/pyproject.toml

@@ -0,0 +1,30 @@
+[build-system]
+requires      = ["setuptools>=61.0.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "mi-mdb"
+version = "0.1.0"
+description = "Shlaer-Mellor Executable UML Model Debugger"
+readme = "README.md"
+authors = [{ name = "Leon Starr", email = "leon_starr@modelint.com" }]
+license = { file = "LICENSE" }
+classifiers = [
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3",
+]
+keywords = ["shlaer-mellor", "metamodel", "executable uml", "mbse", "xuml", "xtuml", "model debugger", "platform independent"]
+dependencies = ["mi-mx", "mi-pyral", "PyYAML"]
+requires-python = ">=3.11"
+
+[project.optional-dependencies]
+build = ["build", "twine"]
+dev = ["bump2version", "pytest"]
+
+[project.scripts]
+mdb = "mdb.__main__:main"
+
+[project.urls]
+repository    = "https://github.com/modelint/model-debugger"
+documentation = "https://github.com/modelint/model-debugger/wiki"

mi_mdb-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

mi_mdb-0.1.0/src/mdb/__init__.py

@@ -0,0 +1 @@
+version = "0.1.0"

mi_mdb-0.1.0/src/mdb/__main__.py

@@ -0,0 +1,85 @@
+"""
+Blueprint Model Debugger
+
+"""
+# System
+import logging
+import logging.config
+import sys
+import argparse
+from pathlib import Path
+import atexit
+
+# MDB
+from mdb.session import Session
+from mdb import version
+
+_logpath = Path("mdb.log")
+_progname = 'Blueprint Model Debugger'
+
+def clean_up():
+    """Normal and exception exit activities"""
+    _logpath.unlink(missing_ok=True)
+
+def get_logger():
+    """Initiate the logger"""
+    log_conf_path = Path(__file__).parent / 'log.conf'  # Logging configuration is in this file
+    logging.config.fileConfig(fname=log_conf_path, disable_existing_loggers=False)
+    return logging.getLogger(__name__)  # Create a logger for this module
+
+
+# Configure the expected parameters and actions for the argparse module
+def parse(cl_input):
+    parser = argparse.ArgumentParser(description=_progname)
+    parser.add_argument('-s', '--system', action='store',
+                        help='Name of the metamodel TclRAL database *.ral file populated with one or more domains')
+    parser.add_argument('-p', '--playground', action='store',
+                        help='Name of the context directory specifying the initialized domain dbs and a *.sip file')
+    parser.add_argument('-x', '--scenario', action='store',
+                        help='Name of the scenario *.yaml file to run against the populated system')
+    parser.add_argument('-L', '--log', action='store_true',
+                        help='Generate a diagnostic log file')
+    parser.add_argument('-v', '--verbose', action='store_true',
+                        help='Verbose messages')
+    parser.add_argument('-V', '--version', action='store_true',
+                        help='Print the current version of the model execution app')
+    return parser.parse_args(cl_input)
+
+
+def main():
+    # Start logging
+    logger = get_logger()
+    msg = f'{_progname} version: {version}\n'
+    logger.info(msg)
+
+    # Parse the command line args
+    args = parse(sys.argv[1:])
+
+    if args.version:
+        # Just print the version and quit
+        print(f'{_progname} version: {version}')
+        sys.exit(0)
+
+    if not args.log:
+        # If no log file is requested, remove the log file before termination
+        atexit.register(clean_up)
+
+    print(f"\n{msg}")
+    if args.verbose:
+        print("\nVerbose mode set\n")
+
+    # All pathnames are optional since the user can specify them in the debug session
+    session = Session()  # Create the singleton instance
+    session.initialize(
+        system_path=Path(args.system) if args.system else None,
+        playground_name=args.playground if args.playground else None,
+        scenario_name=args.scenario if args.scenario else None,
+        verbose=args.verbose)
+
+    logger.info("No problemo")  # We didn't die on an exception, basically
+    if args.verbose:
+        print("\nNo problemo")
+
+
+if __name__ == "__main__":
+    main()

mi_mdb-0.1.0/src/mdb/_dep_system.py

@@ -0,0 +1,136 @@
+""" system.py -- System """
+
+# System
+from pathlib import Path
+from typing import Optional
+from enum import Enum
+
+from mdb.ui_types import *
+
+class SystemState(Enum):
+    LOADED = "LOADED"
+    NOT_LOADED = "NOT_LOADED"
+    RUNNING = "RUNNING"
+    SUSPENDED = "SUSPENDED"
+    TERMINATED = "TERMINATED"
+
+def validate_path(path: Path) -> bool:
+    """
+    Validates that a Path exists and is accessible.
+    Returns True if valid, prints error to console if not and returns False
+    """
+    if not path.is_absolute():
+        print(f"Path is not absolute: {path}")
+        return False
+
+    if not path.exists():
+        print(f"Path does not exist: {path}")
+        return False
+
+    if not path.is_file() and not path.is_dir():
+        print(f"Path is neither a file nor a directory: {path}")
+        return False
+
+    return True
+
+
+class System:
+    """
+    The System being tested
+
+    """
+
+    def __init__(self, system_path: Optional[Path] = None, context_dir: Optional[Path] = None):
+
+        self.path = system_path
+        self.name = system_path.name if system_path else None
+        self.mmdb_fname = None
+        self.playground = None
+        self.state = SystemState.NOT_LOADED
+
+        if self.path:
+            self.load_models()
+
+    def load_models(self):
+        """
+        Tell the MX to load the system
+
+        Returns:
+
+        """
+        print(f"Loading models for: {self.name}{STATUS}")
+        self.state = SystemState.LOADED
+        model_path = self.path / 'models'
+        ral_files = list(model_path.glob("*.ral"))
+        #
+        if len(ral_files) == 0:
+            print(f"Error: No .ral file found in '{self.path}'")
+            return None
+        elif len(ral_files) > 1:
+            print(f"Error: Multiple .ral files found in '{self.path}': {[f.name for f in ral_files]}")
+            return None
+
+        self.mmdb_fname = Path(ral_files[0])
+
+        print(f"Model file is: {self.mmdb_fname.name}")
+
+    def set_playground(self, playground_name: str):
+        """
+        Validate path and, if valid, set it
+
+        Args:
+            playground_name:
+        """
+        if validate_path(self.path / 'playgrounds' / playground_name ):
+            self.playground = playground_name
+
+    def set_path(self, system_path: Path):
+        """
+        Validate path and, if valid, set it
+
+        Args:
+            system_path:
+        """
+        # TODO: Ensure that System is in a compatible state such as NOT_LOADED
+        if validate_path(system_path):
+            self.path = system_path
+            # Reset local sub-paths
+            # TODO: changing the path should result in a new instance of System
+            self.playground = None
+            self.mmdb_fname = None
+
+    def show_playgrounds(self):
+        play_path = self.path / 'playgrounds'
+        pg_dirs = [f for f in play_path.iterdir() if f.is_dir()]
+        for d in pg_dirs:
+            print(f"  {d.name}")
+
+    def show_active_playground(self):
+        if self.playground:
+            print(f"  Active playground: {self.playground}")
+            return
+        print("  No active playground")
+
+    def show_path(self):
+        if self.path:
+            print(f"System path is: [{self.path}]")
+        else:
+            print(f"System path not set")
+
+    def show_models(self, classes: list[str]):
+        """
+        Print out the loaded models
+
+        Args:
+            classes: A list of requested metamodel classes to view. If list is empty, entire mmdb is displayed
+        """
+        pass
+
+    def load_context(self):
+        """
+        Tell the MX to load the context
+
+        Returns:
+
+        """
+        pass

mi_mdb-0.1.0/src/mdb/log.conf

@@ -0,0 +1,48 @@
+[loggers]
+keys=root,MDBLogger,PyralLogger
+
+[handlers]
+keys=fileHandler, consoleHandler, consoleHandlerUser
+
+[formatters]
+keys=MDBFormatter, MDBFormatterUser
+
+[logger_root]
+level=DEBUG
+handlers=fileHandler, consoleHandlerUser
+
+[logger_PyralLogger]
+level=WARNING
+handlers=fileHandler
+qualname=pyral
+propagate=0
+
+[logger_MDBLogger]
+level=DEBUG
+handlers=fileHandler, consoleHandlerUser
+qualname=MDBLogger
+propagate=0
+
+[handler_fileHandler]
+class=FileHandler
+level=DEBUG
+formatter=MDBFormatter
+args=('mdb.log', 'w')
+
+[handler_consoleHandlerUser]
+class=StreamHandler
+level=WARNING
+formatter=MDBFormatterUser
+args=(sys.stderr,)
+
+[handler_consoleHandler]
+class=StreamHandler
+level=WARNING
+formatter=MDBFormatter
+args=(sys.stderr,)
+
+[formatter_MDBFormatter]
+format= MDB: %(name)s - %(levelname)s - %(message)s
+
+[formatter_MDBFormatterUser]
+format=MDB: %(levelname)s - %(message)s

mi_mdb-0.1.0/src/mdb/scenario.py

@@ -0,0 +1,48 @@
+"""scenario.py -- Scenario class"""
+
+# System
+from pathlib import Path
+import yaml
+
+# Model Integration
+from mx.mxtypes import *
+
+class Scenario:
+
+    def __init__(self, sfile: Path):
+        """
+        Args:
+            file: Path to a scenario yaml file
+        """
+        # Load the yaml file
+        with open(sfile, "r") as file:
+            sdata = yaml.safe_load(file)  # Load YAML content safely
+
+        # Unpack the Actors
+        actors = {}
+        internal_actor_parse = sdata['Actors']['internal']
+        for domain, instances in internal_actor_parse.items():
+            for name, address in instances.items():
+                instance_id = {attr: value for attr, value in address['instance'].items()}
+                actors[f"{domain}:{name}"] = InstanceAddress(domain=domain, class_name=address['class'],
+                                                             instance_id=instance_id)
+
+        external_actor_parse = sdata['Actors']['external']
+        for ea in external_actor_parse:
+            actors[ea] = ExternalAddress(domain=ea)
+        pass
+
+        # Unpack the interactions
+        self.interactions = []
+        for i in sdata['Interactions']:
+            ituple = Interaction(
+                description=i['description'],
+                direction=Direction(i['direction']),
+                action=ActionType(i['action']),
+                name=i['name'],
+                source=actors[i['source']],
+                target=actors[i['target']],
+                parameters=i.get('parameters', {})
+            )
+            self.interactions.append(ituple)
+        pass

mi_mdb-0.1.0/src/mdb/session.py

@@ -0,0 +1,423 @@
+""" session.py -- Model Debugger Session """
+
+# System
+import shlex
+import sys
+from pathlib import Path
+import logging
+import re
+import yaml
+
+# Model Integration
+from mx.system import System
+from mx.mxtypes import *
+
+# MDB
+from mdb.ui_types import *
+from mdb.scenario import Scenario
+
+STEP_PROMPT = '>: '
+
+_logger = logging.getLogger(__name__)
+
+
+def shortcut_index(s: str) -> int | None:
+    """
+    Convert value to an integer shortcut if it is a 1-2 char integer with no leading zeros
+
+    Args:
+        s - user string input
+    Returns:
+        An integer shortcut if detected, otherwise None
+    """
+    return int(s) if re.fullmatch(r'[1-9]\d?', s) else None
+
+
+class Session:
+    """
+    This class represents the debugger session. It follows the singleton pattern to ensure only one exists.
+
+    Attributes:
+        system: MX system object we are debugging
+        playground_name: Name of the active playground (same as file name in system playgrounds dir)
+        scenario_name: Name of the active scenario (same as file name minus any extension in the
+            playground scenarios dir)
+        playground_scenarios: All scenario files defined for the active playground minus any file extension
+        active_scenario: Name of the scenario we are currently running
+        verbose: Whether verbose output is enabled
+        stepping: Whether stepping mode is enabled (pauses between interactions)
+        descriptions: Whether interaction descriptions are printed during scenario execution
+    """
+    _instance = None
+
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super(Session, cls).__new__(cls)
+        return cls._instance
+
+    def __init__(self):
+        # Avoid singleton reinitialization if already initialized
+        if getattr(self, "_initialized", False):
+            return
+        self._initialized = True
+
+        self.system = None
+        self.playground_name = None
+        self.scenario_name = None
+        self.playground_scenarios: list[str] = []
+        self.active_scenario = None
+        self.verbose = False
+        self.stepping = False  # By default we assume that the user wants to run the scenario without stepping
+        self.descriptions = False
+
+    def initialize(self, verbose: bool,
+                   system_path: Path = None,
+                   playground_name: str = None,
+                   scenario_name: str = None,
+                   ):
+        """
+        We can initialize a session without any system and then let the user initialize it interactively
+        or, if a system path is provided, we can initialize it right away. The same goes for the playground and
+        scenario names.
+
+        After whatever degree of initialization is completed, we start the user command input loop
+
+        Args:
+            verbose:  Verbose mode for stdout (console) messaging/status
+            system_path:  An absolute path to the system directory where the entire system is defined
+            playground_name: Name of a playground corresponding ot the name of a file in the system's playground dir
+            scenario_name: Name of a scenario file (yaml, for now) that the mdb loads locally, but is found in the
+                system's scenarios directory
+        """
+        print("Initializing session from command line arguments...")
+        if system_path:
+            self.system = System()  # Singleton initialization
+        if system_path:
+            self.system.initialize(system_path=system_path, verbose=verbose)
+        else:
+            print("System not yet initialized. Use: set system <path> to initialize.")
+        self.scenario_name = scenario_name
+        self.playground_name = playground_name
+        self.verbose = verbose
+
+        # Initialize these if they were supplied on the command line
+        if playground_name:
+            self.set_playground(playground_name)
+            if scenario_name:
+                self.set_scenario(scenario_name)
+
+        self.run()
+
+    def run(self):
+        """
+        This is the user input command loop.  It just runs until the user exits.
+        """
+
+        print("\nType 'help' for available commands, 'quit' or 'exit' to exit\n")
+
+        while True:  # Breaks out when the user enters the quit/exit command
+            try:
+                raw = input(CMD_PROMPT).strip()
+            except (EOFError, KeyboardInterrupt):
+                print()
+                break
+
+            if not raw:
+                continue
+
+            try:
+                parts = shlex.split(raw)
+            except ValueError as e:
+                print(f"Parse error: {e}")
+                continue
+
+            command, *args = parts
+
+            match command.lower():
+                case "quit" | "exit":
+                    break
+                case "help":
+                    self.cmd_help(args)
+                case "show":
+                    self.cmd_show(args)
+                case "list":
+                    self.cmd_list(args)
+                case "set":
+                    self.cmd_set(args)
+                case "execute" | "x" | "exec":
+                    self.execute_scenario()
+                case _:
+                    print(f"Unknown command: '{command}'. Type 'help' for available commands.")
+
+    def show_stepping_status(self):
+        if self.stepping:
+            print("Stepping mode set")
+        else:
+            print("Run to completion mode set")
+
+    def show_descriptions_status(self):
+        if self.descriptions:
+            print("Descriptions mode set")
+        else:
+            print("Descriptions mode not set")
+
+    def show_states(self) -> None:
+        if not self.system:
+            print("No system loaded.")
+            return
+        for domain_name, domain in self.system.domains.items():
+            current_states = domain.get_current_states()
+            if not current_states:
+                continue
+            print(f"\n{domain_name} current states:")
+            print("—")
+            for sm in current_states:
+                if sm.instance:
+                    inst_str = '<' + '-'.join(f"{k}:{v}" for k, v in sm.instance.items()) + '>'
+                else:
+                    inst_str = ""
+                print(f"{sm.state_model} {inst_str} [{sm.state}]")
+            print("—")
+
+    def cmd_show(self, args: list[str]) -> None:
+        """
+        Display requested item on console
+
+        Args:
+            args:  What to display
+        """
+        if len(args) < 1:
+            print("Usage: set <item>")
+            return
+
+        item = args[0]
+        match item:
+            case 'scenario':
+                print("Not implemented yet.")
+            case 'path':
+                self.system.show_path()
+            case 'playground' | 'pg':
+                print(f"Active playground: {self.system.playground}")
+            case 'playgrounds' | 'pgs':
+                self.show_playgrounds()
+            case 'active':
+                if args[1] == 'playground':
+                    self.system.show_active_playground()
+                else:
+                    print(f"Unknown active element: {args[1]}")
+            case 'scenarios':
+                self.show_scenarios()
+            case 'step':
+                self.show_stepping_status()
+            case 'descriptions' | 'desc':
+                self.show_descriptions_status()
+            case 'states':
+                self.show_states()
+            case _:
+                print(f"Unknown item: {item}")
+                return
+
+        pass
+        # TODO: Have MX load the ral file and initialize the system
+
+    def cmd_help(self, args: list[str]) -> None:
+        print("Commands:")
+        print("  show <item>              - Display item on console (ex: show path)")
+        print("  show states              - Display current state of all state models")
+        print("  set <variable> <value>   - Set a variable (ex: set path ~/my/path)")
+        print("  set step                 - Toggle stepping mode (pause between interactions)")
+        print("  set desc                 - Toggle descriptions mode (print interaction descriptions)")
+        print("  execute / exec / x       - Execute the active scenario")
+        print("  quit / exit              - Exit the debugger")
+
+    def cmd_set(self, args: list[str]) -> None:
+        """
+        Set the value of some variable
+
+        Args:
+            args:
+        """
+        if len(args) > 2:
+            print("Usage: set <variable> [<value>]")
+            return
+
+        variable, value = args[0], args[1] if len(args) > 1 else None
+        vset = False
+        match variable:
+            case 'path':
+                self.system.set_path(system_path=Path(value))
+            case 'playground' | 'pg':
+                self.set_playground(value)
+            case 'scenario':
+                self.set_scenario(value)
+            case 'step':
+                # Toggle the setting
+                self.stepping = not self.stepping
+                self.show_stepping_status()
+            case 'descriptions' | 'desc':
+                # Toggle the setting
+                self.descriptions = not self.descriptions
+                self.show_descriptions_status()
+            case _:
+                vset = False
+                print(f"Setting {variable} not defined")
+
+        if vset:
+            print(f"{variable} = {value}")
+
+    def cmd_list(self, args: list[str]) -> None:
+        if not args:
+            print("Usage: list <target>")
+            return
+        target = args[0]
+        print(f"  [stub] list {target}")
+
+    def show_playgrounds(self):
+        """Display all playgrounds defined in the system directory"""
+        system_playgrounds = self.system.playgrounds
+        if system_playgrounds is not None:
+            print("Available playgrounds:")
+            for n, p in enumerate(self.system.available_playgrounds):
+                print(f"  [{n + 1}] - {p}")
+
+    def set_playground(self, value: str) -> None:
+        """
+        Verify that the supplied value corresponds to a valid playground.
+
+        Args:
+            value: A full string name of a playground directory or shortcut 1-2 integer index
+        """
+        i = shortcut_index(value)  # i is between 1 and 99 or None
+        if i is not None:
+            if i > len(self.system.available_playgrounds):
+                print(f"Undefined playground shortcut: [{value[1:]}]")
+                return
+            pg_name = self.system.playgrounds[i - 1]  # User counts items starting from 1
+        else:
+            pg_name = value
+        if pg_name not in self.system.playgrounds:
+            print(f"Unknown playground: {pg_name}")
+            return
+        print(f"Selected playground: {pg_name}")
+
+        self.system.load_domains(playground=pg_name)
+        # And find all available scenarios for that playground
+        self.show_scenarios()
+
+    def set_scenario(self, value: str):
+        i = shortcut_index(value)  # i is between 1 and 99 or None
+        if i is not None:
+            if not self.playground_scenarios:
+                print(f"Unknown scenario: {value}")
+                self.show_scenarios()
+                return
+            if i > len(self.playground_scenarios):
+                print(f"Undefined scenario shortcut: [{value[1:]}]")
+                return
+            scenario_name = self.playground_scenarios[i - 1]  # User counts items starting from 1
+        else:
+            scenario_name = value
+        if scenario_name not in self.playground_scenarios:
+            print(f"Unknown scenario: {scenario_name}")
+            return
+        print(f"Selected scenario: {scenario_name}")
+
+        sfile = self.system.playground / 'scenarios' / (scenario_name + ".yaml")
+        self.active_scenario = Scenario(sfile)
+
+    def show_scenarios(self) -> None:
+        """
+        Display all scenarios defined in the active playground directory
+        with convenient integer shortcuts
+        """
+        scenario_path = self.system.playground / 'scenarios'
+        scenario_paths = list(scenario_path.glob("*.yaml"))
+        self.playground_scenarios = [f.stem for f in scenario_paths]
+        if self.playground_scenarios:
+            print("Active playground scenarios:")
+            for n, p in enumerate(self.playground_scenarios):
+                print(f"  [{n + 1}] - {p}")
+
+    @staticmethod
+    def format_interaction(i: Interaction):
+        if i.action == ActionType.SIGNAL_INSTANCE:
+            inst_str = '<' + '-'.join([str(v) for v in i.target.instance_id.values()]) + '>'
+            formatted_i = f"{i.source.domain} >|| {i.target.domain} : {i.name} -> {i.target.class_name} {inst_str}"
+        else:
+            formatted_i = "Unimplemented Acton Type"
+        print(formatted_i)
+
+    @staticmethod
+    def format_announcements(announcement_tuples: list[Announcement]):
+        for a in announcement_tuples:
+            if isinstance(a, ExternalEvent_Announcement):
+                if a.inst:
+                    inst_str = '<' + '-'.join([str(v) for v in a.inst.values()]) + '>'
+                else:
+                    inst_str = ""
+                pstrings = [f"{n}={v[0]}" for n,v in a.params.items()]
+                param_str = ', '.join(pstrings)
+                formatted_a = f"{a.domain} >|| {a.ee} : {a.source}{inst_str} {a.event}( {param_str} )"
+                print(f"    {formatted_a}")
+
+    def execute_scenario(self) -> None:
+        """
+        Process each interaction of the scenario until it is complete
+        """
+        print(f"Running scenario: {self.scenario_name}...\n")
+        # Set external events to trigger an announcement and return control after enclosing activity completes
+        System.set_announce_triggers(['external signal'])
+
+        interactions = iter(self.active_scenario.interactions)
+        i = next(interactions, None)
+
+        while i is not None:
+            if self.descriptions:
+                print(f"    ** {i.description} ** ")
+            # Process the current interaction
+            if i.direction == Direction.STIMULUS:
+                Session.format_interaction(i)  # Print out the stimulus injection info
+                self.system.inject(stimulus=i)  # Inject the stimulus, transferring control to MX
+                self.format_announcements(self.system.announcements)  # Print out any triggered announcments
+
+                # TODO: Think about how to correlate announcements and responses
+                # The triggered announcments should correspond to the expedted response interactions
+                # but at this point, we doin't attempt to match them up.  This may be in the realm of a testing
+                # package, but we keep them in the scenario yaml for now.
+            else:  # Response
+                self.system.go()  # No stimulus to inject, so just pass control back to MX
+                self.format_announcements(self.system.announcements)  # Print out any triggered announcments
+
+            if not self.stepping:
+                i = next(interactions, None)
+                continue
+
+            # Inner pause loop: let user inspect results before stepping forward
+            while True:
+                try:
+                    raw = input(STEP_PROMPT).strip().lower()
+                except (EOFError, KeyboardInterrupt):
+                    print("\nScenario aborted.")
+                    return
+
+                match raw:
+                    case "" | "n" | "next" | "s" | "step":
+                        i = next(interactions, None)  # Advance to the next interaction
+                        break
+                    case "r" | "run":
+                        self.stepping = False  # Run to completion
+                        i = next(interactions, None)
+                        break
+                    case "q" | "quit" | "abort":
+                        print("Scenario aborted.")
+                        return
+                    case "show states":
+                        self.show_states()
+                    case "h" | "help" | "?":
+                        print("  [enter] / n / next / s / step  - Advance to next interaction")
+                        print("  show states                    - Display current state of all state models")
+                        print("  q / quit / abort               - Abort scenario")
+                    case _:
+                        print(f"Unknown step command: '{raw}'. Type 'h' for help.")
+
+        print("\nScenario complete.")

mi_mdb-0.1.0/src/mdb/ui_types.py

@@ -0,0 +1,4 @@
+""" ui_types.py -- Characters and messages used in the command line interface """
+
+CMD_PROMPT = "# "
+STATUS = "..."

mi_mdb-0.1.0/src/mi_mdb.egg-info/PKG-INFO

@@ -0,0 +1,49 @@
+Metadata-Version: 2.4
+Name: mi-mdb
+Version: 0.1.0
+Summary: Shlaer-Mellor Executable UML Model Debugger
+Author-email: Leon Starr <leon_starr@modelint.com>
+License: MIT License
+        
+        Copyright (c) 2026 Leon Starr
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: repository, https://github.com/modelint/model-debugger
+Project-URL: documentation, https://github.com/modelint/model-debugger/wiki
+Keywords: shlaer-mellor,metamodel,executable uml,mbse,xuml,xtuml,model debugger,platform independent
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: mi-mx
+Requires-Dist: mi-pyral
+Requires-Dist: PyYAML
+Provides-Extra: build
+Requires-Dist: build; extra == "build"
+Requires-Dist: twine; extra == "build"
+Provides-Extra: dev
+Requires-Dist: bump2version; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Dynamic: license-file
+
+# model-debugger
+A modeling language independent model debugger

mi_mdb-0.1.0/src/mi_mdb.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+src/mdb/__init__.py
+src/mdb/__main__.py
+src/mdb/_dep_system.py
+src/mdb/log.conf
+src/mdb/scenario.py
+src/mdb/session.py
+src/mdb/ui_types.py
+src/mi_mdb.egg-info/PKG-INFO
+src/mi_mdb.egg-info/SOURCES.txt
+src/mi_mdb.egg-info/dependency_links.txt
+src/mi_mdb.egg-info/entry_points.txt
+src/mi_mdb.egg-info/requires.txt
+src/mi_mdb.egg-info/top_level.txt

mi_mdb-0.1.0/src/mi_mdb.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

mi_mdb-0.1.0/src/mi_mdb.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+mdb = mdb.__main__:main

mi_mdb-0.1.0/src/mi_mdb.egg-info/requires.txt

@@ -0,0 +1,11 @@
+mi-mx
+mi-pyral
+PyYAML
+
+[build]
+build
+twine
+
+[dev]
+bump2version
+pytest

mi_mdb-0.1.0/src/mi_mdb.egg-info/top_level.txt

@@ -0,0 +1 @@
+mdb