opensignalbox-macro 0.1.0__py3-none-any.whl

opensignalbox/macro/__init__.py

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

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/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

opensignalbox/macro/actions/block_working.py

@@ -0,0 +1,178 @@
+from datetime import datetime, timedelta
+from typing import TYPE_CHECKING, Any, Type, cast
+
+from opensignalbox.common.variables import BellCodeSVData
+from opensignalbox.macro.actions.inputs import inputs_from_blocks
+from opensignalbox.macro.models import StatusEnum
+
+from .base import (
+    Action,
+    MacroError,
+    T,
+    action,
+    pubbed_shared_variables,
+    subbed_shared_variables,
+)
+
+if TYPE_CHECKING:
+    from opensignalbox.macro.macros import MacroController
+
+
+@action("send_bellcode")
+class ActionSendBellcode(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)
+        shared_variable = cls._extract_field(block, "SHAREDVARIABLE")
+        input = cls._extract_input(block, "BELLCODE")
+        bellcode_input, subs = inputs_from_blocks(input)
+        action_params = {
+            "shared_variable": shared_variable,
+            "bellcode_input": bellcode_input,
+            "count": 0,
+        }
+        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("shared_variable")
+        bellcode = self.action_params["bellcode_input"].evaluate(
+            macro_controller, macro_instance_name
+        )
+        try:
+            self.action_params["count"] += 1
+            # logger.debug(f"Sending bellcode: {bellcode} with count {self.action_params['count'] } to shared variable {self.action_params['shared_variable']}")
+            pubbed_shared_variables[self.action_params["shared_variable"]].update(
+                {"code": bellcode, "count": self.action_params["count"]}
+            )
+        except KeyError as exc:
+            raise MacroError(
+                f"Variable {self.action_params['shared_variable']} not found"
+            ) from exc
+        return self.next_action
+
+
+@action("wait_for_bellcode")
+class ActionWaitForBellcodeEquals(Action):
+    def __init__(
+        self, block_id: str | None = None, next_action: str | None = None, **kwargs
+    ) -> None:
+        super().__init__(block_id, next_action, **kwargs)
+        self.waitable = True
+
+    @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)
+        shared_variable = cls._extract_field(block, "SHAREDVARIABLE")
+        local_variable = cls._extract_field(block, "LOCALVARIABLE")
+        subbed_shared_variables.add(shared_variable, BellCodeSVData(count=0, code=""))
+        instance = cls(
+            block_id=block_id,
+            next_action=next_action,
+            action_params={
+                "value": None,
+                "shared_variable": shared_variable,
+                "local_variable": local_variable,
+            },
+        )
+        return {block_id: instance}, {shared_variable}, set()
+
+    def evaluate(
+        self, macro_controller: "MacroController", macro_instance_name: str
+    ) -> str | None:
+        self._validate_required_params("shared_variable", "local_variable")
+        sv_value = subbed_shared_variables.get_value(
+            self.action_params["shared_variable"]
+        )
+        new_value = cast(BellCodeSVData, sv_value)
+        if self.action_params["value"] is None:
+            self.action_params["value"] = new_value
+        if (
+            macro_controller.macro_instances[macro_instance_name].run_state
+            == StatusEnum.STEP
+        ):
+            return self.next_action
+        if new_value == self.action_params["value"]:
+            return self.block_id  # Wait for the next evaluation
+        self.action_params["value"] = new_value
+        if self.action_params["local_variable"]:
+            macro_controller.set_local_variable(
+                macro_instance_name,
+                self.action_params["local_variable"],
+                new_value.code,
+            )
+        return self.next_action
+
+
+@action("wait_for_bellcode_with_timeout")
+class ActionWaitForBellcodeWithTimeout(Action):
+    def __init__(
+        self, block_id: str | None = None, next_action: str | None = None, **kwargs
+    ) -> None:
+        super().__init__(block_id, next_action, **kwargs)
+        self.end: datetime | None = None
+        self.waitable = True
+
+    @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)
+        shared_variable = cls._extract_field(block, "SHAREDVARIABLE")
+        local_variable = cls._extract_field(block, "LOCALVARIABLE")
+        subbed_shared_variables.add(shared_variable, BellCodeSVData(count=0, code=""))
+        input = cls._extract_input(block, "TIMEOUT")
+        timeout_input, subs = inputs_from_blocks(input)
+        action_params = {
+            "value": None,
+            "shared_variable": shared_variable,
+            "local_variable": local_variable,
+            "timeout": timeout_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("shared_variable", "local_variable", "timeout")
+        sv_value = subbed_shared_variables.get_value(
+            self.action_params["shared_variable"]
+        )
+        new_value = cast(BellCodeSVData, sv_value)
+        if self.action_params["value"] is None:
+            self.action_params["value"] = new_value
+        if self.end is None:
+            self.end = datetime.now() + timedelta(
+                seconds=self.action_params["timeout"].evaluate(
+                    macro_controller, macro_instance_name
+                )
+            )
+        if datetime.now() > self.end:
+            self.end = None
+            return self.next_action
+        if (
+            macro_controller.macro_instances[macro_instance_name].run_state
+            == StatusEnum.STEP
+        ):
+            return self.next_action
+        if new_value == self.action_params["value"]:
+            return self.block_id  # Wait for the next evaluation
+        self.action_params["value"] = new_value
+        if self.action_params["local_variable"]:
+            macro_controller.set_local_variable(
+                macro_instance_name,
+                self.action_params["local_variable"],
+                new_value.code,
+            )
+        return self.next_action