marsh-lib 0.2.0__py3-none-any.whl

marsh/core/conveyor.py

@@ -0,0 +1,105 @@
+from typing import Callable, Tuple, Sequence
+
+from .cmd_run_decorator import CmdRunDecorator
+
+
+class Conveyor:
+    """
+    A class that chains multiple command runners, allowing sequential execution of commands.
+
+    Each command runner is a callable that accepts two `bytes` arguments (representing standard 
+    output and standard error) and returns a tuple of two `bytes` values as the updated outputs.
+
+    This class supports adding command runners, decorating them, and invoking them in sequence.
+    
+    Example:
+        >>> def cmd_runner_1(stdout: bytes, stderr: bytes) -> Tuple[bytes, bytes]:
+        ...     return stdout + b"Cmd1", stderr
+
+        >>> def cmd_runner_2(stdout: bytes, stderr: bytes) -> Tuple[bytes, bytes]:
+        ...     return stdout + b"Cmd2", stderr
+
+        >>> conveyor = Conveyor()
+        >>> conveyor = conveyor.add_cmd_runner(cmd_runner_1).add_cmd_runner(cmd_runner_2)
+        >>> result_stdout, result_stderr = conveyor(b"Start", b"")
+        >>> print(result_stdout)
+        b'StartCmd1Cmd2'
+    """
+    def __init__(self, cmds_=None) -> None:
+        self._cmd_runners = cmds_ or []
+
+    @property
+    def cmd_run_triples(self) -> Sequence[Tuple[Callable, Tuple, dict]]:
+        """
+        Returns the sequence of triples containing the registered command runner, its positional arguments and keyword arguments.
+
+        Returns:
+            Sequence[Tuple[Callable, Tuple, dict]]: 
+                A sequence of command runners with their arguments.
+        """
+        return self._cmd_runners
+
+    def add_cmd_runner(self,
+                cmd_runner: Callable[[bytes, bytes], Tuple[bytes, bytes]],
+                *args,
+                cmd_runner_decorator: CmdRunDecorator | None = None,
+                **kwargs
+                ) -> "Conveyor":
+        """
+        Adds a new command runner to the Conveyor.
+
+        Optionally applies a decorator to the command runner before adding it to the chain.
+
+        Args:
+            cmd_runner (Callable[[bytes, bytes], Tuple[bytes, bytes]]): 
+                A callable that processes two `bytes` inputs (stdout, stderr) 
+                and returns a tuple of two `bytes` outputs.
+            *args: 
+                Positional arguments to pass to the `cmd_runner` during invocation.
+            cmd_runner_decorator (CmdRunDecorator, optional): 
+                A command runner decorator for decorating the `cmd_runner`. Defaults to None.
+            **kwargs: 
+                Keyword arguments to pass to the `cmd_runner` during invocation.
+
+        Returns:
+            Conveyor: A new Conveyor instance with the added command runner.
+
+        Raises:
+            TypeError: If `cmd_runner` is not callable.
+        """
+        if not callable(cmd_runner):
+            raise TypeError("cmd_runner must be callable with 2 required bytes arguments.")
+
+        # Apply the pre/post processors and modifiers to command runner, if given
+        decorated_cmd_runner = cmd_runner_decorator.decorate(cmd_runner) if isinstance(cmd_runner_decorator, CmdRunDecorator) else cmd_runner
+
+        return Conveyor(cmds_=self._cmd_runners + [(decorated_cmd_runner, args, kwargs)])
+
+    def __call__(self, x_stdout: bytes = b"", x_stderr: bytes = b"", callback_list_: Sequence = None) -> Tuple[bytes, bytes]:
+        """
+        Executes the command runners sequentially.
+
+        Starts with the given `stdout` and `stderr` values and passes the results through
+        each command runner in the chain.
+
+        Args:
+            x_stdout (bytes, optional): Initial standard output. Defaults to `b""`.
+            x_stderr (bytes, optional): Initial standard error. Defaults to `b""`.
+            callback_list_ (Sequence, optional): 
+                A list of command runners to execute. Defaults to the command runners in the Conveyor.
+
+        Returns:
+            Tuple[bytes, bytes]: 
+                A tuple containing the final standard output (`stdout`) and standard error (`stderr`).
+        """
+        callback_list = callback_list_ or self._cmd_runners
+        if len(callback_list) == 1:
+            callback, args, kwargs = callback_list[0]
+            return callback(x_stdout, x_stderr, *args, **kwargs)
+
+        if len(self._cmd_runners) == 0:
+            return x_stdout, x_stderr
+
+        callback, args, kwargs = callback_list[0]
+        new_x_stdout, new_x_stderr = callback(x_stdout, x_stderr, *args, **kwargs)
+        return self(x_stdout=new_x_stdout, x_stderr=new_x_stderr, callback_list_=callback_list[1:])

marsh/core/executor.py

@@ -0,0 +1,296 @@
+import textwrap
+import pickle
+import subprocess
+from abc import abstractmethod, ABC
+from typing import Callable, Tuple, Any
+
+from ..utils.output_streams import suppress_output
+from .command_grammar import CommandGrammar
+from .connector import Connector
+
+
+class Executor(ABC):
+    """
+    Abstract base class for command execution.
+
+    This class defines a common interface for running commands, where subclasses implement 
+    the `run` method to execute commands in specific environments (e.g., local, remote).
+    """
+
+    @abstractmethod
+    def run(self, x_stdout: bytes, x_stderr: bytes, *args, **kwargs) -> Tuple[bytes, bytes]:
+        """
+        Abstract method to run a command.
+
+        Args:
+            x_stdout (bytes): Standard output from a previous command.
+            x_stderr (bytes): Standard error from a previous command.
+            *args: Additional positional arguments.
+            **kwargs: Additional keyword arguments.
+
+        Returns:
+            Tuple[bytes, bytes]: A tuple containing standard output and standard error.
+
+        Raises:
+            NotImplementedError: If the subclass does not override this method.
+        """
+        pass
+
+
+class LocalCommandExecutor(Executor):
+    """Executes commands locally as subprocesses."""
+
+    def __init__(self,
+                 command_grammar: CommandGrammar,
+                 pipe_prev_stdout: bool = False,
+                 timeout: float | None = None,
+                 ):
+        """
+        Initializes a LocalCommandExecutor.
+
+        Args:
+            command_grammar (CommandGrammar): A CommandGrammar object to build the command.
+            pipe_prev_stdout (bool, optional): Whether to pipe the previous standard output as input. Defaults to False.
+            timeout (float | None, optional): Timeout for command execution in seconds. Defaults to None.
+        """
+
+        self.command_grammar = command_grammar  # Already parameterized the command grammar
+        self.pipe_prev_stdout = pipe_prev_stdout  # (Unix) Pipe the previous STDOUT as STDIN for current command runner
+        self.timeout = timeout
+
+    @staticmethod
+    def create_popen_with_pipe(command: list[str], *args, **kwargs) -> subprocess.Popen:
+        """
+        Creates a subprocess with pipes for stdin, stdout, and stderr.
+
+        Args:
+            command (list[str]): The command to execute as a list of strings.
+            *args: Additional positional arguments for `subprocess.Popen`.
+            **kwargs: Additional keyword arguments for `subprocess.Popen`.
+
+        Returns:
+            subprocess.Popen: A subprocess instance with pipes.
+        """
+        return subprocess.Popen(command, *args, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
+                                **kwargs)
+
+    def run(self,
+            x_stdout: bytes,
+            x_stderr: bytes,
+            *args,
+            callback: Callable[[subprocess.Popen, bytes, bytes], Tuple[bytes, bytes]] = None,
+            popen_args=(),
+            popen_kwargs=None,
+            **kwargs
+            ) -> Tuple[bytes, bytes]:
+        """
+        Runs a command locally.
+
+        Args:
+            x_stdout (bytes): Standard output to pass to the command.
+            x_stderr (bytes): Standard error to pass to the command.
+            *args: Additional positional arguments.
+            callback (Callable, optional): A custom callback function that takes subprocess.Popen, stdout, and stderr.
+                This callback must return tuple[bytes, bytes] which represents the result.
+            popen_args (tuple, optional): Arguments for `subprocess.Popen`. Defaults to ().
+            popen_kwargs (dict, optional): Keyword arguments for `subprocess.Popen`. Defaults to None.
+            **kwargs: Additional keyword arguments for `subprocess.Popen`.
+
+        Returns:
+            Tuple[bytes, bytes]: A tuple containing standard output and standard error.
+
+        Raises:
+            ValueError: If the provided callback does not return a tuple of bytes.
+        """
+
+        popen_kwargs = popen_kwargs or dict()
+
+        # Build the Command as List of Strings
+        command = self.command_grammar.build_cmd()
+
+        # Create subprocess.Popen
+        process = self.create_popen_with_pipe(command, *args, **kwargs)
+
+        # Use the custom callback provided by user/client
+        if callback:
+            result = callback(process, x_stdout, x_stderr, *popen_args, **popen_kwargs)
+            match result:
+                # The `process.communicate(...)` must be invoked in the `callback` to return (stdout, stderr).
+                case (stdout, stderr) if isinstance(stdout, bytes) and isinstance(stderr, bytes):
+                    return stdout, stderr
+                case _:
+                    raise ValueError("Given callback must return tuple[bytes, bytes]")
+
+        # Use the default procedure for running programs
+        stdout, stderr = process.communicate(input=x_stdout,
+                                             timeout=self.timeout) if self.pipe_prev_stdout else process.communicate(
+            timeout=self.timeout)
+        return stdout, stderr
+
+
+class RemoteCommandExecutor(Executor):
+    """
+    Executes commands on remote systems via a connector interface.
+
+    This class uses a `Connector` to establish a connection to a remote host
+    and execute a command generated by a `CommandGrammar`. The command is sent
+    to the remote system, and the standard output and error are retrieved.
+    """
+
+    def __init__(self, connector: Connector, command_grammar: CommandGrammar):
+        """
+        Initializes a RemoteCommandExecutor.
+
+        Args:
+            connector (Connector): An object responsible for managing the connection to the remote system.
+            command_grammar (CommandGrammar): An object to build and format the command to be executed remotely.
+        """
+        self.connector = connector
+        self.command_grammar = command_grammar
+
+    def run(self,
+            x_stdout: bytes,
+            x_stderr: bytes,
+            *build_cmd_args,
+            conn_args=(),
+            exec_cmd_args=(),
+            exec_cmd_kwargs=None,
+            conn_kwargs=None,
+            **build_cmd_kwargs,
+            ) -> Tuple[bytes, bytes]:
+        """
+        Runs a command on a remote system and retrieves its output.
+
+        This method connects to a remote host using the provided `Connector`, runs the command
+        generated by `CommandGrammar`, and returns the standard output and standard error.
+
+        Args:
+            x_stdout (bytes): Standard output to pass as input, if required by the command.
+            x_stderr (bytes): Standard error to pass as input, if required by the command.
+            *build_cmd_args: Additional arguments passed to `CommandGrammar.build_cmd`.
+            conn_args (tuple, optional): Positional arguments for the `Connector.connect` method.
+            exec_cmd_args (tuple, optional): Positional arguments for the `Connector.exec_cmd` method.
+            exec_cmd_kwargs (dict, optional): Keyword arguments for `Connector.exec_cmd`. Defaults to None.
+            conn_kwargs (dict, optional): Keyword arguments for the `Connector.connect` method. Defaults to None.
+            **build_cmd_kwargs: Additional keyword arguments for `CommandGrammar.build_cmd`.
+
+        Returns:
+            Tuple[bytes, bytes]: A tuple containing:
+                - stdout (bytes): The standard output from the remote command execution.
+                - stderr (bytes): The standard error from the remote command execution.
+        """
+        exec_cmd_kwargs = exec_cmd_kwargs or dict()
+        conn_kwargs = conn_kwargs or dict()
+        connection = None
+        # TODO: Enhance and include Pipes.
+        try:
+            connection = self.connector.connect(*conn_args, **conn_kwargs)
+            stdout, stderr = self.connector.exec_cmd(
+                self.command_grammar.build_cmd(*build_cmd_args, **build_cmd_kwargs),
+                connection,
+                *exec_cmd_args,
+                **exec_cmd_kwargs
+            )
+            return stdout, stderr
+        except Exception as e:
+            return b"", str(e).encode()
+        finally:
+            self.connector.disconnect(connection)
+
+
+class PythonExecutor(Executor):
+    """
+    Runs Python code in the specified mode ('eval' or 'exec') within a given namespace.
+
+    The PythonExecutor class allows for the execution or evaluation of Python code in a specific namespace,
+    with optional support for serializing results via pickle.
+    """
+
+    def __init__(self,
+                 py_code: str,
+                 mode: str = "eval",
+                 namespace: dict | None = None,
+                 use_pickle: bool = False,
+                 ):
+        """
+        Initializes a PythonExecutor.
+
+        Args:
+            py_code (str): The Python code to execute or evaluate. This should be a valid python expression for `eval()`,
+                or a valid python statement(s) for `exec()`.
+            mode (str, optional): The mode for executing the code, either 'eval' (default) or 'exec'.
+            namespace (dict, optional): The namespace in which to execute the code. Defaults to None.
+                The namespace would contain "x_stdout" and "x_stderr" for both `eval` and `exec` modes. This is for
+                referencing the previous results. The result of `exec` mode can be stored in a variable `exec_result`
+                to be referenced by the next command runner. If this is not specified, the value of `stdout` will be
+                'None'.
+            use_pickle (bool, optional): Whether to pickle the result. Defaults to False.
+
+        Raises:
+            ValueError: If the mode is not 'eval' or 'exec', or if the Python code is empty.
+        """
+        if mode not in ["eval", "exec"]:
+            raise ValueError("`mode` must be 'eval' or 'exec'.")
+
+        if not py_code.strip():
+            raise ValueError("Python code is empty.")
+
+        self._mode = mode
+        self._namespace = namespace or {}
+        self._py_code = textwrap.dedent(py_code)
+        self._use_pickle = use_pickle
+
+    def run(self,
+            x_stdout: bytes,
+            x_stderr: bytes,
+            encoding: str = "utf-8",
+            pickle_kwargs: dict | None = None,
+            **kwargs
+            ) -> Tuple[bytes, bytes]:
+        """
+        Executes or evaluates Python code in the provided namespace with the given standard output and error.
+
+        Args:
+            x_stdout (bytes): The standard output stream to pass to the code.
+            x_stderr (bytes): The standard error stream to pass to the code.
+            encoding (str, optional): The encoding for the result. Defaults to "utf-8".
+            pickle_kwargs (dict | None, optional): Additional keyword arguments for pickle dumps. Defaults to None.
+            **kwargs (dict, optional): Additional keyword arguments for either `eval` or `exec`.
+
+        Returns:
+            Tuple[bytes, bytes]: A tuple containing:
+                - The result of the execution or evaluation as a byte string.
+                - An empty byte string if no error occurs, or an error message in byte string form.
+        """
+
+        pickle_kwargs = pickle_kwargs or {}
+
+        # Inject x_stdout and x_stderr into the namespace
+        self._namespace["x_stdout"] = x_stdout
+        self._namespace["x_stderr"] = x_stderr
+
+        # Use the context manager to suppress stdout and stderr during execution
+        with suppress_output():
+            try:
+                if self._mode == "exec":
+                    self._namespace["exec_result"] = None  # To store results for code.
+                    exec(self._py_code, self._namespace, **kwargs)
+                    result = self._namespace["exec_result"]
+                else:
+                    result = eval(self._py_code, self._namespace, **kwargs)
+
+                if self._use_pickle:
+                    return pickle.dumps(result, **pickle_kwargs), b""
+
+                return str(result).encode(encoding), b""
+
+            except Exception as err:
+                return b"", str(err).encode(encoding)
+
+
+__all__ = (
+    "Executor",
+    "LocalCommandExecutor",
+    "RemoteCommandExecutor",
+    "PythonExecutor",
+)

marsh/core/expression.py

@@ -0,0 +1,208 @@
+import functools
+from dataclasses import dataclass
+from typing import Callable, Tuple
+from pathlib import Path
+
+from marsh.exceptions import CommandError
+from marsh.core.conveyor import Conveyor
+
+
+@dataclass
+class CommandExpression:
+    def evaluate(self, *args, **kwargs) -> Tuple[bytes, bytes]:
+        raise NotImplementedError("Subclasses of CommandExpression must implement 'evaluate'.")
+
+
+@dataclass(order=True)
+class UnaryExpression(CommandExpression):
+    conveyor: Conveyor
+    def evaluate(self, *args, **kwargs):
+        return self.conveyor(*args, **kwargs)
+
+
+@dataclass(order=True)
+class AndExpression(CommandExpression):
+    left: CommandExpression | Conveyor
+    right: CommandExpression | Conveyor
+
+    def evaluate(self, *args, **kwargs) -> Tuple[bytes, bytes]:
+        # Same as Unix's `command1 && command2`
+        # PASS & PASS => PASS
+        # PASS & FAIL => FAIL
+        # FAIL & NORUN => FAIL
+        match self.left:
+            case CommandExpression():  # If it's a CommandExpression
+                left_stdout, left_stderr = self.left.evaluate(*args, **kwargs)
+            case Conveyor():  # If it's a Conveyor
+                left_stdout, left_stderr = self.left(*args, **kwargs)
+            case _:
+                raise ValueError("Invalid type for left side of AndExpression.")
+
+        if left_stderr.decode("utf-8").strip():  # Left expression is a fail
+            # Left expression failed
+            raise CommandError(left_stderr.decode("utf-8").strip())
+
+        match self.right:
+            case CommandExpression():  # If it's a CommandExpression
+                right_stdout, right_stderr = self.right.evaluate(x_stdout=left_stdout, x_stderr=left_stderr)
+            case Conveyor():  # If it's a Conveyor
+                right_stdout, right_stderr = self.right(x_stdout=left_stdout, x_stderr=left_stderr)
+            case _:
+                raise ValueError("Invalid type for right side of AndExpression.")
+
+        # If right stderr is empty, we pass the stdout from the right side.
+        if right_stderr.decode("utf-8").strip():  # Right expression failed
+            raise CommandError(right_stderr.decode("utf-8").strip())
+        else:
+            return right_stdout, right_stderr
+
+
+@dataclass(order=True)
+class OrExpression(CommandExpression):
+    left: CommandExpression | Conveyor
+    right: CommandExpression | Conveyor
+
+    def evaluate(self, *args, **kwargs) -> Tuple[bytes, bytes]:
+        # Same as Unix's `command1 || command2`
+        # PASS or NORUN => PASS
+        # FAIL or PASS => PASS
+        # FAIL or FAIL => FAIL
+        match self.left:
+            case CommandExpression():  # If it's a CommandExpression
+                left_stdout, left_stderr = self.left.evaluate(*args, **kwargs)
+            case Conveyor():  # If it's a Conveyor
+                left_stdout, left_stderr = self.left(*args, **kwargs)
+            case _:
+                raise ValueError("Invalid type for left side of AndExpression.")
+
+        # Left expression is a fail
+        if left_stderr.decode("utf-8").strip():
+            match self.right:
+                case CommandExpression():
+                    right_stdout, right_stderr = self.right.evaluate(x_stdout=left_stdout, x_stderr=left_stderr)
+                case Conveyor():
+                    right_stdout, right_stderr = self.right(x_stdout=left_stdout, x_stderr=left_stderr)
+                case _:
+                    raise ValueError("Invalid type for right side of AndExpression.")
+
+            # Right expression is a fail
+            if right_stderr.decode().strip():
+                raise CommandError(right_stderr.decode().strip())
+            return right_stdout, right_stderr
+        # Left expression is a pass
+        return left_stdout, left_stderr
+
+
+@dataclass(order=True)
+class JunctionExpression(CommandExpression):
+    """
+    (command1 > command2) > (command3 > command4)
+    
+    It may look similar to `command1 & command2` but this does not necessarily raise error if there was an error on left-side.
+    """
+    left: CommandExpression | Conveyor
+    right: CommandExpression | Conveyor
+
+    def evaluate(self, *args, **kwargs) -> Tuple[bytes, bytes]:
+        match self.left:
+            case CommandExpression():  # If it's a CommandExpression
+                left_stdout, left_stderr = self.left.evaluate(*args, **kwargs)
+            case Conveyor():  # If it's a Conveyor
+                left_stdout, left_stderr = self.left(*args, **kwargs)
+            case _:
+                raise ValueError("Invalid type for left side of AndExpression.")
+
+        match self.right:
+            case CommandExpression():
+                right_stdout, right_stderr = self.right.evaluate(x_stdout=left_stdout, x_stderr=left_stderr)
+            case Conveyor():
+                right_stdout, right_stderr = self.right(x_stdout=left_stdout, x_stderr=left_stderr)
+            case _:
+                raise ValueError("Invalid type for right side of AndExpression.")
+        return right_stdout, right_stderr
+
+
+class Command:
+    def __init__(self, cmd_expr):
+        if not isinstance(cmd_expr, (CommandExpression, Conveyor)):
+            raise TypeError("The argument for Command constructor must be a CommandExpression or Conveyor.")
+
+        self._cmd_expr = cmd_expr if isinstance(cmd_expr, CommandExpression) else UnaryExpression(cmd_expr)
+
+    @property
+    def expression(self) -> CommandExpression:
+        return self._cmd_expr
+
+    @classmethod
+    def make_junctions(cls, *command_expressions: list[CommandExpression|Conveyor]) -> "Command":
+        # new_command = Command.make_junctions(<cmd_expr|cmd_pipe>, <cmd_expr|cmd_pipe>, ...)
+        # new_command(...)
+        return cls(functools.reduce(JunctionExpression, command_expressions))
+
+    def __or__(self, right: CommandExpression) -> "Command":
+        if isinstance(right, CommandExpression):
+            return Command(OrExpression(self._cmd_expr, right))
+        else:
+            return Command(OrExpression(self._cmd_expr, right.expression))
+
+    def __and__(self, right: CommandExpression) -> "Command":
+        if isinstance(right, CommandExpression):
+            return Command(AndExpression(self._cmd_expr, right))
+        else:
+            return Command(AndExpression(self._cmd_expr, right.expression))
+
+    def _write_stdout(self, file_path_: str | Path, mode: str) -> None:
+        file_path = file_path_ if isinstance(file_path_, Path) else Path(file_path_).resolve()
+        stdout, _ = self()
+        with file_path.open(mode=mode) as file:
+            file.write(stdout.decode("utf-8").strip() + "\n")
+
+    def __gt__(self, right: str | Path) -> None:
+        # Write (overwrite) STDOUT to file
+        # command > "/path/to/file"
+        # command > "/dev/null"
+
+        # Decision: The following evaluates the expression immediately.
+        # Warn: We are only considering the STDOUT and not STDERR.
+        # command = Command(...)
+        # command > "file.txt"
+
+        if isinstance(right, (str, Path)):
+            file_path = right if isinstance(right, Path) else Path(right).resolve()
+            self._write_stdout(file_path, "w")
+
+        if isinstance(right, Command):
+            # Both methods still require pathentesis
+            # (command1 > command2) > (command3 > command4)
+
+            # Method: We can achieve Junction without parenthesis using Side-effect
+            # self._cmd_expr = JunctionExpression(self._cmd_expr, right.expression)
+            # return self
+
+            # Method: Using New Copy
+            return Command(JunctionExpression(self._cmd_expr, right.expression))
+
+    def __rshift__(self, right: str | Path) -> None:
+        # Append STDOUT to file
+        # command >> /path/to/file
+        # command >> /dev/null
+
+        # Decision: The following evaluates the expression immediately.
+        # Warn: We are only considering the STDOUT and not STDERR.
+        # command = Command(...)
+        # command >> "file.txt"
+        file_path = right if isinstance(right, Path) else Path(right).resolve()
+        self._write_stdout(file_path, "a")
+
+    def __call__(self) -> Tuple[bytes, bytes]:
+        return self._cmd_expr.evaluate()
+
+
+__all__ = (
+    "CommandExpression",
+    "UnaryExpression",
+    "AndExpression",
+    "OrExpression",
+    "JunctionExpression",
+    "Command"
+)

marsh/core/script.py

@@ -0,0 +1,38 @@
+from typing import Any
+from abc import ABC, abstractmethod
+
+
+class Script(ABC):
+    """
+    Abstract base class for generating scripts from templates. 
+    Subclasses must implement the `generate` method to produce 
+    a rendered script as a string.
+    """
+
+    def __init__(self, script_template: Any):
+        """
+        Initializes a Script instance with a template to be rendered.
+
+        Args:
+            `script_template` (Any): A template object (e.g., a `string.Template`, 
+                                   a Jinja2 template, or a plain string) 
+                                   that serves as the base for script generation.
+        """
+        self.script_template = script_template  # e.g. string.Template, Jinja2 Templates, or str
+
+    @abstractmethod
+    def generate(self, *args, **kwargs) -> str:
+        """
+        Abstract method to render the script template into a string.
+
+        This method should be implemented in subclasses to provide specific logic
+        for rendering the `script_template` using the provided arguments.
+
+        Args:
+            *args: Positional arguments to customize the script rendering.
+            **kwargs: Keyword arguments to customize the script rendering.
+
+        Returns:
+            str: A string containing the rendered script, ready to be executed or used.
+        """
+        pass

marsh/dag/__init__.py

@@ -0,0 +1,11 @@
+from .startable import Startable
+from .node import Node
+from .dag import (
+    Dag,
+    SyncDag,
+    AsyncDag,
+    ThreadPoolDag,
+    ThreadDag,
+    MultiprocessDag,
+    ProcessPoolDag
+)