opensignalbox-macro 0.1.0__tar.gz

opensignalbox_macro-0.1.0/.gitignore

@@ -0,0 +1,182 @@
+# Created by https://www.toptal.com/developers/gitignore/api/python
+# Edit at https://www.toptal.com/developers/gitignore?templates=python
+
+### opensignalbox ###
+tests/**/settings.toml
+tests/workspace/boxes/*/resources/*
+tests/workspace/boxes/Lowdham
+opensignalbox/trainplanning/ltsv/icons
+
+### Python ###
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+#dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+### Python Patch ###
+# Poetry local configuration file - https://python-poetry.org/docs/configuration/#local-configuration
+poetry.toml
+
+# ruff
+.ruff_cache/
+
+# LSP config files
+pyrightconfig.json
+
+# End of https://www.toptal.com/developers/gitignore/api/python

opensignalbox_macro-0.1.0/.python-version

@@ -0,0 +1 @@
+3.12.2

opensignalbox_macro-0.1.0/CHANGELOG.md

@@ -0,0 +1,10 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+- WIP

opensignalbox_macro-0.1.0/PKG-INFO

@@ -0,0 +1,29 @@
+Metadata-Version: 2.4
+Name: opensignalbox-macro
+Version: 0.1.0
+Summary: The official macro scripting module for the opensignalbox simulation framework.
+Project-URL: Homepage, https://opensignalbox.org/
+Project-URL: Repository, https://github.com/opensignalbox/opensignalbox
+Author-email: The openSignalBox project <info@opensignalbox.org>
+Maintainer-email: Laurence Stant <laurence@stant.phd>
+Classifier: License :: OSI Approved :: GNU Affero General Public License v3 or later (AGPLv3+)
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.8
+Requires-Dist: anyio>=4.3.0
+Requires-Dist: email-validator>=2.1.1
+Requires-Dist: fastapi>=0.108.0
+Requires-Dist: hypercorn>=0.16.0
+Requires-Dist: jinja2>=3.1.3
+Requires-Dist: opensignalbox-common>=0.1.0
+Requires-Dist: playsound3>=3.3.1
+Requires-Dist: pydantic-settings>=2.1.0
+Requires-Dist: pyhumps>=3.8.0
+Requires-Dist: pyyaml>=6.0.1
+Requires-Dist: requests>=2.31.0
+Requires-Dist: sqlmodel>=0.0.21
+Requires-Dist: trio>=0.23.2
+Requires-Dist: zmq>=0.0.0
+Description-Content-Type: text/markdown
+
+openSignalBox package code repo.

opensignalbox_macro-0.1.0/README.md

@@ -0,0 +1 @@
+openSignalBox package code repo.

opensignalbox_macro-0.1.0/pyproject.toml

@@ -0,0 +1,48 @@
+[project]
+name = "opensignalbox-macro"
+version = "0.1.0"
+description = "The official macro scripting module for the opensignalbox simulation framework."
+authors = [
+    { name = "The openSignalBox project", email = "info@opensignalbox.org" },
+]
+maintainers = [{ name = "Laurence Stant", email = "laurence@stant.phd" }]
+dependencies = [
+    "fastapi>=0.108.0",
+    "email-validator>=2.1.1",
+    "hypercorn>=0.16.0",
+    "trio>=0.23.2",
+    "pyyaml>=6.0.1",
+    "jinja2>=3.1.3",
+    "pydantic-settings>=2.1.0",
+    "zmq>=0.0.0",
+    "requests>=2.31.0",
+    "anyio>=4.3.0",
+    "opensignalbox-common>=0.1.0",
+    "sqlmodel>=0.0.21",
+    "pyhumps>=3.8.0",
+    "playsound3>=3.3.1",
+]
+readme = "README.md"
+requires-python = ">= 3.8"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: GNU Affero General Public License v3 or later (AGPLv3+)",
+    "Operating System :: OS Independent",
+]
+
+[project.urls]
+"Homepage" = "https://opensignalbox.org/"
+"Repository" = "https://github.com/opensignalbox/opensignalbox"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project.scripts]
+opensignalbox-macro = 'opensignalbox.macro.main:entry_point'
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/opensignalbox"]
+
+[project.entry-points."opensignalbox.shared_variable_types"]
+sv_types = "opensignalbox.macro.sv_types:get_sv_type_specs"

opensignalbox_macro-0.1.0/src/opensignalbox/macro/__init__.py

@@ -0,0 +1 @@
+__doc__ = "openSignalBox macro module."

opensignalbox_macro-0.1.0/src/opensignalbox/macro/actions/__init__.py

@@ -0,0 +1,23 @@
+from . import (
+    base,
+    block_working,
+    inputs,
+    logic,
+    loops,
+    macros,
+    relays,
+    sound,
+    timing,
+)
+
+__all__ = [
+    "base",
+    "block_working",
+    "inputs",
+    "logic",
+    "loops",
+    "macros",
+    "relays",
+    "sound",
+    "timing",
+]

opensignalbox_macro-0.1.0/src/opensignalbox/macro/actions/base.py

@@ -0,0 +1,268 @@
+from __future__ import annotations
+
+import logging
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING, Any, Type, TypeVar
+
+from opensignalbox.macro.actions.inputs import inputs_from_blocks
+
+if TYPE_CHECKING:
+    from opensignalbox.macro.macros import MacroController
+
+from opensignalbox.common.variables import (
+    VariableType,
+    get_pubbed_shared_variables,
+    get_subbed_shared_variables,
+)
+
+pubbed_shared_variables = get_pubbed_shared_variables()
+subbed_shared_variables = get_subbed_shared_variables()
+
+T = TypeVar("T", bound="Action")
+
+input_shared_variable_suffix = "_sv"
+input_local_variable_suffix = "_lv"
+input_global_variable_suffix = "_gv"
+input_parameter_suffix = "_param"
+
+logger = logging.getLogger(__name__)
+
+_action_registry = {}
+
+
+def register_action(block_type: str, action_class: Type[Action]):
+    """Register an action class for a block type."""
+    _action_registry[block_type] = action_class
+
+
+def action(block_type: str):
+    """Decorator to register action classes for a block type."""
+
+    def decorator(cls: Type[Action]) -> Type[Action]:
+        register_action(block_type, cls)
+        return cls
+
+    return decorator
+
+
+def actions_from_blocks(
+    block_parent: dict[str, Any],
+    subs: set[str] | None = None,
+    pubs: set[str] | None = None,
+    return_action: str | None = None,
+) -> tuple[dict[str, Action], set[str], set[str]]:
+    subs = subs or set()
+    pubs = pubs or set()
+    block = block_parent.get("block", {})
+    action_class = _action_registry.get(block.get("type"))
+    if not action_class:
+        logger.warning(f"Unknown action type: {block.get('type')}")
+        return {}, set(), set()
+    actions, action_subs, action_pubs = action_class.from_block(block, return_action)
+
+    subs.update(action_subs)
+    pubs.update(action_pubs)
+
+    # Handle next block
+    if next_block := block.get("next", {}):
+        next_actions, next_subs, next_pubs = actions_from_blocks(
+            next_block, return_action=return_action, subs=subs, pubs=pubs
+        )
+        actions.update(next_actions)
+        subs.update(next_subs)
+        pubs.update(next_pubs)
+
+    return actions, subs, pubs
+
+
+class MacroError(Exception):
+    def __init__(self, message: str):
+        super().__init__(message)
+        logger.debug("MacroError raised: {}".format(message))
+
+
+class Action(ABC):
+    def __init__(
+        self, block_id: str | None = None, next_action: str | None = None, **kwargs
+    ) -> None:
+        self.block_id = block_id
+        self.next_action = next_action
+        self.action_params: dict[str, Any] = {}
+        self.action_params.update(kwargs["action_params"])
+        self.waitable = False
+
+    @classmethod
+    @abstractmethod
+    def from_block(
+        cls: Type[T], block: dict[str, Any], return_action: str | None
+    ) -> tuple[dict[str, T], set[str], set[str]]:
+        return {"": cls()}, set(), set()
+
+    @abstractmethod
+    def evaluate(
+        self, macro_controller: MacroController, macro_instance_name: str
+    ) -> str | None:
+        """
+        Returns the action id for the next cycle.
+        Reset the action at the end, otherwise loops won't work!
+        """
+        pass
+
+    @classmethod
+    def _extract_block_info(
+        cls, block: dict[str, Any], return_action: str | None
+    ) -> tuple[str, str | None]:
+        """Extract common block ID and next action."""
+        block_id = block.get("id", "")
+        next_action = block.get("next", {}).get("block", {}).get("id", return_action)
+        return block_id, next_action
+
+    @classmethod
+    def _extract_field(
+        cls, block: dict[str, Any], field_name: str, default: str = ""
+    ) -> str:
+        """Extract field value with default."""
+        value = block.get("fields", {}).get(field_name, "")
+        return value if value else default
+
+    @classmethod
+    def _extract_input(cls, block: dict[str, Any], input_name: str) -> dict[str, Any]:
+        """Extract input value from block."""
+        return block.get("inputs", {}).get(input_name, {})
+
+    def _validate_required_params(self, *param_names: str) -> None:
+        """Validate that required parameters exist and are not empty."""
+        for param in param_names:
+            value = self.action_params.get(param)
+            if not value or value == "":
+                raise ValueError(
+                    f"Missing or invalid '{param}' parameter for {self.__class__.__name__}"
+                )
+
+
+@action("entry")
+class ActionEntry(Action):
+    @classmethod
+    def from_block(
+        cls: Type[T], block: dict[str, Any], return_action: str | None
+    ) -> tuple[dict[str, Action], set[str], set[str]]:
+        block_id, next_action = cls._extract_block_info(block, return_action)
+        instance = cls(block_id=block_id, next_action=next_action, action_params={})
+        return {block_id: instance}, set(), set()
+
+    def evaluate(
+        self, macro_controller: MacroController, macro_instance_name: str
+    ) -> str | None:
+        return self.next_action
+
+
+@action("set_logic_local_variable")
+@action("set_number_local_variable")
+@action("set_text_local_variable")
+@action("set_logic_global_variable")
+@action("set_number_global_variable")
+@action("set_text_global_variable")
+@action("set_logic_shared_variable")
+@action("set_number_shared_variable")
+@action("set_text_shared_variable")
+class ActionSetVariable(Action):
+    @classmethod
+    def from_block(
+        cls: Type[T], block: dict[str, Any], return_action: str | None
+    ) -> tuple[dict[str, Action], set[str], set[str]]:
+        block_id, next_action = cls._extract_block_info(block, return_action)
+        if "local" in block.get("type", ""):
+            scope = "local"
+            variable = cls._extract_field(block, "LOCALVARIABLE")
+        elif "global" in block.get("type", ""):
+            scope = "global"
+            variable = cls._extract_field(block, "GLOBALVARIABLE")
+        elif "shared" in block.get("type", ""):
+            scope = "shared"
+            variable = cls._extract_field(block, "SHAREDVARIABLE")
+        else:
+            raise MacroError(
+                f"Unknown variable scope type: {block['type']} for block {block_id} of type {cls.__name__}"
+            )
+        if "logic" in block.get("type", ""):
+            typestring = VariableType.LOGIC
+        elif "number" in block.get("type", ""):
+            typestring = VariableType.NUMBER
+        elif "text" in block.get("type", ""):
+            typestring = VariableType.TEXT
+        else:
+            raise MacroError(
+                f"Unknown variable type: {block['type']} for block {block_id} of type {cls.__name__}"
+            )
+        input = cls._extract_input(block, "VALUE")
+        value_input, subs = inputs_from_blocks(input)
+        action_params = {
+            "variable": variable,
+            "scope": scope,
+            "typestring": typestring,
+            "value_input": value_input,
+        }
+        instance = cls(
+            block_id=block_id, next_action=next_action, action_params=action_params
+        )
+        return {block_id: instance}, subs, set()
+
+    def evaluate(
+        self, macro_controller: "MacroController", macro_instance_name: str
+    ) -> str | None:
+        self._validate_required_params("variable", "typestring", "value_input")
+        value = self.action_params["value_input"].evaluate(
+            macro_controller, macro_instance_name
+        )
+        if self.action_params["typestring"] == VariableType.LOGIC:
+            # Handle logic variable
+            value = bool(value)  # Ensure value is boolean
+        elif self.action_params["typestring"] == VariableType.NUMBER:
+            # Handle number variable
+            value = float(value)  # Ensure value is float
+        elif self.action_params["typestring"] == VariableType.TEXT:
+            # Handle text variable
+            value = str(value)  # Ensure value is string
+        if self.action_params["scope"] == "local":
+            instance = macro_controller.macro_instances[macro_instance_name]
+            if self.action_params["variable"] in instance.local_variables:
+                macro_controller.set_local_variable(
+                    macro_instance_name, self.action_params["variable"], value
+                )
+        elif self.action_params["scope"] == "global":
+            macro_controller.set_global_variable(self.action_params["variable"], value)
+        elif self.action_params["scope"] == "shared":
+            pubbed_shared_variables[self.action_params["variable"]].update(
+                {"value": value}
+            )
+
+        return self.next_action
+
+
+@action("notification")
+class ActionNotification(Action):
+    @classmethod
+    def from_block(
+        cls: Type[T], block: dict[str, Any], return_action: str | None
+    ) -> tuple[dict[str, Action], set[str], set[str]]:
+        block_id, next_action = cls._extract_block_info(block, return_action)
+        input = cls._extract_input(block, "MESSAGE")
+        message_input, subs = inputs_from_blocks(input)
+        instance = cls(
+            block_id=block_id,
+            next_action=next_action,
+            action_params={"message_input": message_input},
+        )
+        return {block_id: instance}, set(), subs
+
+    def evaluate(
+        self, macro_controller: "MacroController", macro_instance_name: str
+    ) -> str | None:
+        self._validate_required_params("message_input")
+        message = self.action_params["message_input"].evaluate(
+            macro_controller, macro_instance_name
+        )
+        macro_controller.send_notification(
+            "Notification from Macro", macro_instance_name + ": " + message
+        )
+        return self.next_action