mi-mx 0.1.0__py3-none-any.whl

mi_mx-0.1.0.dist-info/METADATA

@@ -0,0 +1,142 @@
+Metadata-Version: 2.4
+Name: mi-mx
+Version: 0.1.0
+Summary: Shlaer-Mellor Executable UML Model Execution Environment
+Author-email: Leon Starr <leon_starr@modelint.com>
+License: MIT License
+        
+        Copyright (c) 2025 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-execution
+Project-URL: documentation, https://github.com/modelint/model-execution/wiki
+Keywords: shlaer-mellor,metamodel,executable uml,mbse,xuml,xtuml,platform independent,sysml
+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: xcm-parser
+Requires-Dist: xsm-parser
+Requires-Dist: mi-configurator
+Requires-Dist: mi-pyral
+Requires-Dist: sip-parser
+Requires-Dist: PyYAML
+Requires-Dist: tomli; python_version < "3.13"
+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 execution engine
+
+# Loading a System
+
+We supply mx with a system to run, an initial context, and a scenario to execute
+
+`mx -s elevator -c three_bank1 -x lobby_to_three`
+
+The required arguments are:
+
+```
+-s / --system
+-c / --context
+-x / --scenario
+```
+Optional arguments are:
+```
+-D / --debug
+-V / --version
+```
+### -s or --system
+
+Here you specify the name of a directory containing the following components:
+```
+system_name/
+    system.ral   - Metamodel produced by xuml-populate (can be named anything you like, with any extension)
+    db_types/    - Directory of yaml files mapping user types to TclRAL system types (must have this name)
+        domain_name1_types.yaml  - Each yaml file name must begin with domain name or alias
+        domain_name2_types.yaml
+        domain_name3_types.yaml
+```
+Example:
+```
+elevator/                 - Any name ok
+    elevator.ral          - Any name ok, ev.txt, mm3.ral, etc.
+    db_types/             - Must be this name
+        evman_types.yaml  - could have named it evman.yaml, elevator_management.yaml, 
+                          - evman_user_to_tcl_types.yaml, etc
+                          - but prefix must be either evman (alias) or elevator_management
+                          - case insensitive, so EVMAN also okay
+```
+
+
+The `system.ral` file is actually just a text file serialization of a TclRAL database.
+Specifically, it is a populated SM Metamodel that you can generate with the xuml-populate tool.  The metamodel is populated with one or more modeled domains. In our example, this is the elevator management domain. We could also add in the transport and sio domains defined in the elevator case study if we like, but for now we just have the elevator management (EVMAN) domain.
+
+### -c or --context
+
+This is yet another directory that contains a single initial context per domain. It is structured like this:
+```
+context_name/    - Any name that describes your aggregate initial context
+     domain1.sip - One initial population per domain in the system
+     domain2.sip
+     domain3.sip
+```
+
+An initial context is a population of initial instances and states. That way we can begin a scenario with a known set of instances in known states for those instances with modeled lifecycles (state machines).
+
+Each domain's context is defined with a single *.sip (scenario instance population) file.
+
+In our example we have only one domain population:
+```
+three_bank/
+     evman_three_bank1.sip
+```
+We named it 'three_bank' since we are using three separate elevator banks, 'lower floors',
+'express', and 'freight'.
+
+If we were running the trans and sio domains, we could have supplied one *.sip file for each
+in this directory as well.
+
+Note that each *.sip file name must begin with a domain name or alias.
+
+See the sip-parser repository wiki for details on the grammar.
+
+MX invokes the sip-parser when it loads the file and will throw any errors it finds in the process.
+
+### -x or --scenario
+
+Finally, we provide a sequence of interactions in the form of a scenario file to run against the populated system.
+
+This is specified in a *.scn file. *(grammar/parser yet to be designed)*
+
+You use the sequence of interactions to drive validation or exploration.
+
+For example, you might specify that a cabin going up is requested from the lobby floor 
+in the lower floors bank. It arrives, floor 3 is requested, the doors close, the cabin transits and then arrives at that floor with the doors opening.
+
+This scenario will result in the appropriate events signaled in the loaded system and collect any responses and status updates of interest along the way.
+
+You can define multiple initial contexts for a system and run the same or different scenarios against each.

mi_mx-0.1.0.dist-info/RECORD

@@ -0,0 +1,55 @@
+mi_mx-0.1.0.dist-info/licenses/LICENSE,sha256=hIfBeynReqzakO4zYIDreBqfwygbbdpAKwZMBFOr8BU,1067
+mx/__init__.py,sha256=aOHawL1zuHMfBWKXqwUkXcW96oXLNCY-CXdHDqkz4g4,18
+mx/__main__.py,sha256=sKbDVOJVT3QyMnUl2mafZ91IpWHK9ZnHft4W3i51Ns0,2831
+mx/activity.py,sha256=B24XewtfWZZ8fdn6S8oNJ8JhNm04Dzz5S9x-aJKoNA8,1617
+mx/assigner_state_machine.py,sha256=e4nQq7DRVl9ekk7p_uKRG2gRaRgEZyo9_RrDq0T5LKY,333
+mx/completion_event.py,sha256=iI4RtNQ_T3C2Tt1VjpP5Z4xYzDNKYODRt9I_1oBMxh0,919
+mx/db_names.py,sha256=coUqzTcv7vx3WqeSoJxLtffg9vFxCvO9MbIVQkOWbro,381
+mx/dispatched_event.py,sha256=CXLnY_qg_CsZZi1GIf8cBzX5yoTcd4iQJ82o5G9r6QY,1170
+mx/domain.py,sha256=ow_RROPZ22bib_wMWj2MkIFCwLwYpIWX9B75yWZd0W4,10399
+mx/exceptions.py,sha256=oihSuTzUyaSnA55u9ME-p-2aGPKOp4w7uS_KZ3paWGY,1362
+mx/file_names.py,sha256=u_rekTAXxVmhV5JvvIOesyW5oDOy2d1yISdJjaOpgJM,207
+mx/initial_states.py,sha256=2KNtoZ8awih7bX1AWlIgK4qbdlGC3VZJ91l6B7eZLs4,3234
+mx/instance.py,sha256=qH4sGHvZwfWszPItw-sVa1Lk_1hQ_xzTVXq1y_sT3qU,361
+mx/instance_set.py,sha256=RXvxgejgcVTgTPMOlDo4DlplISxLQ5OaZ8ErpzJlOak,2205
+mx/interaction_event.py,sha256=CYhmRpLwQ-48r7Cju4P0S55T0fT_QBraPRFQxZKKYdg,3851
+mx/lifecycle_state_machine.py,sha256=3jnbtIEz_i_bvzn_RO3dabz2QBBsmnuzkTL9UdghEjw,770
+mx/log.conf,sha256=g01dVwgSXgeEkmApdU1I4bhB6pVSlM23sV9A5qr_nj8,761
+mx/method.py,sha256=utPQVrGCcA1iNTju9cjYeUQnELcHX4CYA4_UFhBS6bk,8510
+mx/multiple_assigner_state_machine.py,sha256=gspey4ch9oq85JxL1PEWLvoKOjhrrCezHxIjQYEPrb0,516
+mx/mx_logger.py,sha256=MmLGIUyFAXhXty1cFeVmyQ4Sljc9eKiCpi1V2z1Es7U,2049
+mx/mxtypes.py,sha256=6fXHAfwZ-tqwDMxoVOa79FXdMd53Qgf7snbk7WkFsm8,471
+mx/operation.py,sha256=bVE1MlgGCitr6sdCLdRr2Ri7gdMHBMJDFCGkuGnVfdU,1543
+mx/rvname.py,sha256=YNvfowaVXBpi8DQLcTEJSUW1vtYBQ1qu_1MTm-7PKw0,1081
+mx/scenario.py,sha256=a60da27mSmAXcv81bE-ajB3jlC276m9EcSNS-bLnqGw,5860
+mx/single_assigner_state_machine.py,sha256=Y1N7doLytje1ou1_ZHCX9aPGqXTkuHYo1rjqpEm7OpE,335
+mx/state_activity.py,sha256=yT7_3ZfDG6opmQX30BKYNDHFmmRzI1VnKuSPfMLKlY0,632
+mx/state_machine.py,sha256=R6bXwCOPXOtq60sOYpfhfC4Mrpmi3DDTruH0svMw1zw,7932
+mx/system.py,sha256=Em4zxjz9JjsvioSmNHSTQ5iLZ2IouN1WCJXS9TFbcKI,1756
+mx/xe.py,sha256=YNRdwkTw2LvckHuto5f-xnv9a57LAIylYtjFwUsUePk,3818
+mx/actions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mx/actions/action.py,sha256=5G20rnQOc0miNXlF9R1ZqdFoypSLxRTiGxASK7i5pCg,3845
+mx/actions/extract.py,sha256=K1sMKMyG_cOCQxddxCyWkk3_DQWMYSTsGaqPkLHh4wg,4626
+mx/actions/flow.py,sha256=UwVGctMKcRjvvlSfN1r8tO5aNemTTmhvX35FVCHMAIE,707
+mx/actions/gate.py,sha256=_oCMY_AedHaasP9mBlBuejYThueb-bhmFQmigREHKFE,4224
+mx/actions/project.py,sha256=NUzsumdR9pB67sqPN9zwOPnFV0asu1ctHZiBcrqgUM4,6082
+mx/actions/rank_restrict.py,sha256=Gx4m9tLbp9hgMRRpnGEIGyBnKy_LHU14S9dQNcjATlQ,6097
+mx/actions/read.py,sha256=xN-naRVPhmANgKzv4JBFhrdaLXAR9UuHDmeb7jZ7xLE,5467
+mx/actions/rename.py,sha256=xTS9CPezWxBk4i9Ojgk-ymQUFanOnUSHz0Wjbz4wqbI,4781
+mx/actions/restrict.py,sha256=nxsbZdzg_HgO8vO-peEjw1iaDGIBQXzOx_5nZckHvc8,9083
+mx/actions/scalar_switch.py,sha256=ex69kGzfpovlAW7rhzoPzMGdMj2V5KOD1TbuWHkfks0,4906
+mx/actions/select.py,sha256=GeCXZk24cSdL1NWNpddIRxIKhKOvQRtkl46f2BlJSro,9425
+mx/actions/set_action.py,sha256=SwOeWWxdSMUkvIAqEsrnmgydfR-iKcYRUGuf22aIn_M,5804
+mx/actions/signal.py,sha256=JA_Pc8mrBz7DVWN8bMPsfkjwRDO9I2fDKZIQNzXQVA8,806
+mx/actions/single_select.py,sha256=o6oVF2YcJ04zsZRJy5G0cldOBaj-2oZ-HwT9mIwTV98,227
+mx/actions/traverse.py,sha256=EQmmOA8Fv9yayYUoYqjyefvCoE8LXxc1Jne2HG3xB-s,15398
+mx/actions/zero_one_card_select.py,sha256=TXscQjTiCEFAxcEK8FeRzkAwcmW3CkdzZTGqM4AL9rw,258
+mx/deprecated/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mx/deprecated/bridge.py,sha256=7V68JPpDsvpVgHkF3pmhI5PBmYCOGgKzmGPQEOZ94nQ,1020
+mx/scenarios/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mx/scenarios/ev_scenario_REF.py,sha256=NeNlb9KOlJPi3O6DO6VOmW1yXGa7mk4j2mWbmyn5uj0,5517
+mi_mx-0.1.0.dist-info/METADATA,sha256=5rUrwUzcmcUzigOUacN12C4eEPa7XaByvKAAvZA0pic,6031
+mi_mx-0.1.0.dist-info/WHEEL,sha256=YCfwYGOYMi5Jhw2fU4yNgwErybb2IX5PEwBKV4ZbdBo,91
+mi_mx-0.1.0.dist-info/entry_points.txt,sha256=KrL83CCgDv4Ku6LAyEZr5hQbmU0WHOUcR6dieo0sqnM,40
+mi_mx-0.1.0.dist-info/top_level.txt,sha256=VqrBpn6wmSgznbspfOeRUxKpP1UgURlQ7u9eYUCMHhc,3
+mi_mx-0.1.0.dist-info/RECORD,,

mi_mx-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

mi_mx-0.1.0.dist-info/entry_points.txt

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

mi_mx-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 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_mx-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+mx

mx/__init__.py

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

mx/__main__.py

@@ -0,0 +1,81 @@
+"""
+Blueprint Model Execution
+
+"""
+# System
+import logging
+import logging.config
+import sys
+import argparse
+from pathlib import Path
+import atexit
+
+# MX
+from mx.xe import XE
+from mx import version
+
+_logpath = Path("mx.log")
+_progname = 'Blueprint Model Execution'
+
+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('-c', '--context', 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('-D', '--debug', action='store_true',
+                        help='Debug mode'),
+    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()
+    logger.info(f'{_progname} version: {version}')
+
+    # 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)
+
+    # Domain specified
+    if args.system:
+        xe = XE()  # Create the singleton instance
+        xe.initialize(mmdb_path=Path(args.system), context_dir=Path(args.context),
+                      scenario_file=Path(args.scenario), verbose=args.verbose, debug=args.debug)
+
+    print("\nNo problemo")  # Comment this line out before release
+    logger.info("No problemo")  # We didn't die on an exception, basically
+    if args.verbose or args.debug:
+        print("\nNo problemo")
+
+
+if __name__ == "__main__":
+    main()

mx/actions/action.py

@@ -0,0 +1,76 @@
+""" action.py -- manages Action execution """
+
+# System
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from mx.method import Method  # TOOD: Replace with Activity after refactoring State/Assigner Activities
+
+# Model Integration
+from pyral.relation import Relation
+
+# MX
+from mx.db_names import mmdb
+
+# These actions do not output a non-scalar flow and, thus, do not declare
+# an output database variable to be freed up upon activity completion
+no_nsflow_output_actions = {"scalarswitch", "gate", "read", "extract"}
+
+class Action:
+
+    def __init__(self, activity: "Method", anum: str, action_id: str):
+        """
+
+        :param activity:  Name of the encompassing Activity
+        :param anum:  The Activity number
+        :param action_id: The Action ID value unique to this Action within the Activity
+        """
+        self.anum = anum
+        self.action_id = action_id
+        self.activity = activity
+        self.action_type = type(self).__name__.lower()
+
+        # Do not execute this action unless ALL input flows have been enabled.
+        # The preceding Wave should have enabled all required inputs, unless some upstream condition
+        # evaluated as false. If so, this action must be skipped.
+
+        # Check the Flow Dependency class for all required input Flow names
+        R = f"To_action:<{action_id}>, Activity:<{activity.anum}>, Domain:<{activity.domain}>"
+        dependencies_r = Relation.restrict(db=mmdb, relation="Flow Dependency", restriction=R)
+        required_flow_names = [d["Flow"] for d in dependencies_r.body]
+        # Check our dictionary of active flows and disable if any required input flows were not set
+        if self.action_type == "gate":
+            self.disabled = all(activity.flows[f] is None for f in required_flow_names)
+        else:
+            self.disabled = any(activity.flows[f] is None for f in required_flow_names)
+
+        if not self.disabled and self.action_type not in no_nsflow_output_actions:
+            # Since this Action will be executed, it may produce one or more non scalar flow
+            # (relation) outputs, and thus set a database variable for each. These rv variables
+            # will be freed up upon completion of the Activity.
+            # We can't free them up earlier since any flow content in an rv must be available while the activity
+            # executes.  (Strictly speaking, we could free them up piecemeal once there are no more consumers, but
+            # it's easier and less error prone to just free them all up after the activity completes.
+            self.activity.executed_actions.append(self.action_id)
+
+        # Each subclass action should verify the disable status before attempting to execute
+
+        # The domain alias is also the name of the TclRAL domain database session
+        self.domdb = self.activity.domain_alias  # Abbreviated access since we use it alot
+
+        # To make it possible to run Actions currently (in the future)
+        # we want to ensure that the temporary relational variable names between two
+        # concurrent executions of the same Activity (by different instances) do not collide.
+
+        # So we create a naming prefix unique to this action execution instance.
+        # We concatenate the anum, action id, and instance id value
+        # instnace id value is the conatenation of each identifier attribute value
+        instance_id_value = '_'.join(v for v in self.activity.instance.values())
+        # relation variable prefix (rvp) is the full concatenation
+        self.rvp = f"{self.activity.anum}_{action_id}_{instance_id_value}"
+        # This value is then prepended to a descriptive name to create a relational variable name
+        # used to access a relation stored inside the TclRAL db
+
+        if self.disabled:
+            self.activity.xe.mxlog.log(message="DISABLED")
+

mx/actions/extract.py

@@ -0,0 +1,98 @@
+""" extract.py  -- execute a relational extract action """
+
+# System
+from typing import TYPE_CHECKING, NamedTuple
+
+if TYPE_CHECKING:
+    from mx.method import Method  # TODO: Replace with Activity after refactoring State/Assigner Activities
+
+# Model Integration
+from pyral.relation import Relation
+from pyral.database import Database  # Diagnostics
+
+# MX
+from mx.db_names import mmdb
+from mx.actions.action import Action
+from mx.actions.flow import ActiveFlow, FlowDir
+from mx.rvname import declare_rvs
+
+# See comment in scalar_switch.py
+class RVs(NamedTuple):
+    activity_extract_switch_actions: str
+    this_extract_action: str
+    attribute: str
+
+# This wrapper calls the imported declare_rvs function to generate a NamedTuple instance with each of our
+# variables above as a member.
+def declare_my_module_rvs(db: str, owner: str) -> RVs:
+    rvs = declare_rvs(db, owner, "activity_extract_actions", "this_extract_action", "attribute"
+                      )
+    return RVs(*rvs)
+
+class Extract(Action):
+
+    def __init__(self, action_id: str, activity: "Method"):
+        """
+        Perform the Extract Action on a domain model.
+
+        Note: For now we are only handling Methods, but State Activities will be incorporated eventually.
+
+        :param action_id:  The ACTN<n> value identifying each Action instance
+        :param activity: The A<n> Activity ID (for Method and State Activities)
+        """
+        super().__init__(activity=activity, anum=activity.anum, action_id=action_id)
+
+        # Do not execute this Action if it is not enabled, see comment in Action class
+        if self.disabled:
+            return
+
+        # Get a NamedTuple with a field for each relation variable name
+        rv = declare_my_module_rvs(db=mmdb, owner=self.rvp)
+
+        # Lookup the Action instance
+        # Start with all Rename actions in this Activity
+        Relation.semijoin(db=mmdb, rname1=activity.method_rvname, rname2="Extract_Action",
+                          svar_name=rv.activity_extract_switch_actions)
+        # Narrow it down to this Extract Action instance
+        R = f"ID:<{action_id}>"
+        extract_action_r = Relation.restrict(db=mmdb, relation=rv.activity_extract_switch_actions, restriction=R,
+                                             svar_name=rv.this_extract_action)
+        if self.activity.xe.debug:
+            Relation.print(db=mmdb, variable_name=rv.this_extract_action)
+
+        extract_action_t = extract_action_r.body[0]
+        self.source_flow_name = extract_action_t["Input_tuple"]
+        self.source_flow = self.activity.flows[self.source_flow_name]  # The active content of source flow (value, type)
+        self.dest_flow_name = extract_action_t["Output_scalar"]
+
+        self.attr = extract_action_t["Attribute"]
+        input_tuple_r = Relation.project(db=self.domdb, relation=self.source_flow.value, attributes=(self.attr,))
+        extracted_value = input_tuple_r.body[0][self.attr]
+
+        self.activity.xe.mxlog.log(message=f"- Attribute: {self.attr}")
+        self.activity.xe.mxlog.log(message="Flows")
+        self.activity.xe.mxlog.log_nsflow(flow_name=self.source_flow_name, flow_dir=FlowDir.IN,
+                                          flow_type=self.source_flow.flowtype, activity=self.activity,
+                                          db=self.domdb, rv_name=self.source_flow.value)
+
+        if self.activity.xe.debug:
+            print(f"\nScalar value: {extracted_value} output on Flow: {self.dest_flow_name}")
+
+        # Get attribute being read so we can look up its type
+        attr_r = Relation.semijoin(db=mmdb, rname1=rv.this_extract_action, rname2="Table Attribute",
+                                   attrs={"Attribute": "Name", "Table": "Table", "Domain": "Domain"},
+                                   svar_name=rv.attribute)
+        attr_t = attr_r.body[0]
+
+        self.activity.flows[self.dest_flow_name] = ActiveFlow(value=extracted_value, flowtype="scalar")
+        self.activity.xe.mxlog.log_sflow(flow_name=self.dest_flow_name, flow_dir=FlowDir.OUT,
+                                         flow_type=attr_t["Scalar"], activity=self.activity)
+        self.activity.xe.mxlog.log(message=f"Scalar value: [{extracted_value}]")
+
+        # This action's mmdb rvs are no longer needed)
+        Relation.free_rvs(db=mmdb, owner=self.rvp)
+        # And since we are outputing a scalar flow, there is no domain rv output to preserve
+        # In fact, we didn't define any domain rv's at all, so there are none to free
+
+        _rv_after_mmdb_free = Database.get_rv_names(db=mmdb)
+        _rv_after_dom_free = Database.get_rv_names(db=self.domdb)

mx/actions/flow.py

@@ -0,0 +1,34 @@
+""" flow.py -- Active Flow type """
+
+# System
+from enum import Enum
+from typing import TYPE_CHECKING, NamedTuple, Any
+
+# Model Integration
+from pyral.relation import Relation
+
+# MX
+from mx.db_names import mmdb
+if TYPE_CHECKING:
+    from mx.activity import Activity
+
+
+class ActiveFlow(NamedTuple):
+    value: Any
+    flowtype: str
+
+class FlowDir(Enum):
+    IN = "in"
+    OUT = "out"
+
+def label(name: str, activity: "Activity") -> str:
+    R = f"ID:<{name}>, Activity:<{activity.anum}>, Domain:<{activity.domain}>"
+    labeled_flow_r = Relation.restrict(db=mmdb, relation='Labeled Flow', restriction=R)
+    if labeled_flow_r.body:
+        return labeled_flow_r.body[0]["Name"]
+    else:
+        return ""
+
+
+
+

mx/actions/gate.py

@@ -0,0 +1,95 @@
+""" gate.py -- executes the Gate Action """
+
+# System
+from typing import TYPE_CHECKING, NamedTuple
+
+if TYPE_CHECKING:
+    from mx.method import Method
+
+# Model Integration
+from pyral.relation import Relation
+from pyral.database import Database  # Diagnostics
+from pyral.rtypes import Extent, Card
+
+# MX
+from mx.db_names import mmdb
+from mx.actions.action import Action
+from mx.actions.flow import FlowDir
+from mx.rvname import declare_rvs
+
+# See comment in scalar_switch.py
+class MMRVs(NamedTuple):
+    activity_gate_actions: str
+    this_gate_action: str
+    flow_deps: str
+
+# This wrapper calls the imported declare_rvs function to generate a NamedTuple instance with each of our
+# variables above as a member.
+def declare_mm_rvs(db: str, owner: str) -> MMRVs:
+    rvs = declare_rvs(db, owner, "activity_gate_actions", "this_gate_action", "flow_deps")
+    return MMRVs(*rvs)
+
+class Gate(Action):
+
+    def __init__(self, action_id: str, activity: "Method"):
+        """
+        Perform the Gate Action on a domain model.
+
+        :param action_id: ACTN<n> value identifying each Action instance
+        :param activity: A<n> Activity ID (for Method and State Activities)
+        """
+
+        super().__init__(activity=activity, anum=activity.anum, action_id=action_id)
+
+        # Do not execute this Action if it is not enabled, see comment in Action class
+        if self.disabled:
+            return
+
+        # Get a NamedTuple with a field for each relation variable name
+        self.mmrv = declare_mm_rvs(db=mmdb, owner=self.rvp)
+        mmrv = self.mmrv  # For brevity
+
+        self.activity.xe.mxlog.log(message="Flows")
+        # Lookup the Action instance
+        # Start with all Gate actions in this Activity
+        Relation.semijoin(db=mmdb, rname1=activity.method_rvname, rname2="Gate Action",
+                          svar_name=mmrv.activity_gate_actions)
+
+        # Narrow it down to this Restrict Action instance
+        R = f"ID:<{action_id}>"
+        gate_action_r = Relation.restrict(db=mmdb, relation=mmrv.activity_gate_actions, restriction=R,
+                                          svar_name=mmrv.this_gate_action)
+        if self.activity.xe.debug:
+            Relation.print(db=mmdb, variable_name=mmrv.this_gate_action)
+
+        # Lookup the Action flow dependency
+        flow_deps_r = Relation.semijoin(db=mmdb, rname1=mmrv.this_gate_action, rname2="Flow Dependency",
+                                        attrs={"ID": "To_action", "Activity": "Activity", "Domain": "Domain"},
+                                        svar_name=mmrv.flow_deps)
+
+        if self.activity.xe.debug:
+            Relation.print(db=mmdb, variable_name=mmrv.flow_deps)
+
+        gate_action_t = gate_action_r.body[0]
+        output_flow_name = gate_action_t["Output_flow"]
+        input_flow_names = [t["Flow"] for t in flow_deps_r.body]
+        input_values = {n: activity.flows[n] for n in input_flow_names if activity.flows[n]}
+        if len(input_values) > 1:
+            pass
+        assert(len(input_values) == 1)
+        input_flow_name, activity.flows[output_flow_name] = next(iter(input_values.items()))
+        if self.activity.xe.debug:
+            print(f"\nGate: {self.action_id} passing Flow: {input_flow_name} to Flow: {output_flow_name}")
+            Relation.print(db=self.domdb, variable_name=activity.flows[output_flow_name].value)
+
+        self.activity.xe.mxlog.log_nsflow(flow_name=input_flow_name, flow_dir=FlowDir.IN,
+                                          flow_type=activity.flows[input_flow_name].flowtype, activity=self.activity,
+                                          db=self.domdb, rv_name=activity.flows[input_flow_name].value)
+        self.activity.xe.mxlog.log_nsflow(flow_name=output_flow_name, flow_dir=FlowDir.OUT,
+                                          flow_type=activity.flows[output_flow_name].flowtype, activity=self.activity,
+                                          db=self.domdb, rv_name=activity.flows[output_flow_name].value)
+
+        # This action's mmdb rvs are no longer needed)
+        Relation.free_rvs(db=mmdb, owner=self.rvp)
+        _rv_after_mmdb_free = Database.get_rv_names(db=mmdb)
+        _rv_after_dom_free = Database.get_rv_names(db=self.domdb)