zrb 0.28.1__py3-none-any.whl → 1.0.0a8__py3-none-any.whl

zrb/task/base_task/component/renderer.py

@@ -1,129 +0,0 @@
-import os
-from collections.abc import Mapping
-from typing import Any, Optional, Union
-
-import jinja2
-
-from zrb.helper.render_data import DEFAULT_RENDER_DATA
-from zrb.helper.string.conversion import to_boolean
-from zrb.helper.string.jinja import is_probably_jinja
-from zrb.helper.typecheck import typechecked
-from zrb.helper.typing import JinjaTemplate
-from zrb.task.any_task import AnyTask
-
-
-class AnyExtensionFileSystemLoader(jinja2.FileSystemLoader):
-    def get_source(self, environment, template):
-        for search_dir in self.searchpath:
-            file_path = os.path.join(search_dir, template)
-            if os.path.exists(file_path):
-                with open(file_path, "r") as file:
-                    contents = file.read()
-                return contents, file_path, lambda: False
-        raise jinja2.TemplateNotFound(template)
-
-
-@typechecked
-class Renderer:
-    def __init__(self):
-        self.__input_map: Mapping[str, Any] = {}
-        self.__task: Optional[AnyTask] = None
-        self.__env_map: Mapping[str, str] = {}
-        self.__render_data: Optional[Mapping[str, Any]] = None
-        self.__rendered_str: Mapping[str, str] = {}
-
-    def _set_task(self, task: AnyTask):
-        self.__task = task
-
-    def get_input_map(self) -> Mapping[str, Any]:
-        # This return reference to input map, so input map can be updated
-        return self.__input_map
-
-    def _set_input_map(self, key: str, val: Any):
-        self.__input_map[key] = val
-
-    def get_env_map(self) -> Mapping[str, str]:
-        # This return reference to env map, so env map can be updated
-        return self.__env_map
-
-    def _set_env_map(self, key: str, val: str):
-        self.__env_map[key] = val
-
-    def render_any(self, value: Any, data: Optional[Mapping[str, Any]] = None) -> Any:
-        if isinstance(value, str):
-            return self.render_str(value, data)
-        return value
-
-    def render_float(
-        self,
-        value: Union[JinjaTemplate, float],
-        data: Optional[Mapping[str, Any]] = None,
-    ) -> float:
-        if isinstance(value, str):
-            return float(self.render_str(value, data))
-        return value
-
-    def render_int(
-        self, value: Union[JinjaTemplate, int], data: Optional[Mapping[str, Any]] = None
-    ) -> int:
-        if isinstance(value, str):
-            return int(self.render_str(value, data))
-        return value
-
-    def render_bool(
-        self,
-        value: Union[JinjaTemplate, bool],
-        data: Optional[Mapping[str, Any]] = None,
-    ) -> bool:
-        if isinstance(value, str):
-            return to_boolean(self.render_str(value, data))
-        return value
-
-    def render_str(
-        self, value: JinjaTemplate, data: Optional[Mapping[str, Any]] = None
-    ) -> str:
-        if value in self.__rendered_str:
-            return self.__rendered_str[value]
-        if not is_probably_jinja(value):
-            return value
-        template = jinja2.Template(value)
-        render_data = self.__get_render_data(additional_data=data)
-        try:
-            rendered_text = template.render(render_data)
-        except Exception:
-            raise Exception(f'Fail to render "{value}" with data: {render_data}')
-        self.__rendered_str[value] = rendered_text
-        return rendered_text
-
-    def render_file(
-        self, path: JinjaTemplate, data: Optional[Mapping[str, Any]] = None
-    ) -> str:
-        location_dir = os.path.dirname(path)
-        env = jinja2.Environment(loader=AnyExtensionFileSystemLoader([location_dir]))
-        template = env.get_template(path)
-        render_data = self.__get_render_data(additional_data=data)
-        render_data["TEMPLATE_DIR"] = location_dir
-        rendered_text = template.render(render_data)
-        return rendered_text
-
-    def __get_render_data(
-        self, additional_data: Optional[Mapping[str, Any]] = None
-    ) -> Mapping[str, Any]:
-        self.__ensure_cached_render_data()
-        if additional_data is None:
-            return self.__render_data
-        return {**self.__render_data, **additional_data}
-
-    def __ensure_cached_render_data(self):
-        if self.__render_data is not None:
-            return self.__render_data
-        render_data = dict(DEFAULT_RENDER_DATA)
-        render_data.update(
-            {
-                "env": self.__env_map,
-                "input": self.__input_map,
-                "task": self.__task,
-            }
-        )
-        self.__render_data = render_data
-        return render_data

zrb/task/base_task/component/trackers.py

@@ -1,74 +0,0 @@
-import asyncio
-import time
-from typing import Optional, Union
-
-from zrb.helper.typecheck import typechecked
-
-LOG_NAME_LENGTH = 20
-
-
-@typechecked
-class TimeTracker:
-    def __init__(self):
-        self.__start_time: float = 0
-        self.__end_time: float = 0
-
-    def _start_timer(self):
-        self.__start_time = time.time()
-
-    def _end_timer(self):
-        self.__end_time = time.time()
-
-    def _get_elapsed_time(self) -> float:
-        return self.__end_time - self.__start_time
-
-
-@typechecked
-class AttemptTracker:
-    def __init__(self, retry: int = 2):
-        self.__retry = retry
-        self.__attempt: int = 1
-
-    def _get_max_attempt(self) -> int:
-        return self.__retry + 1
-
-    def _get_attempt(self) -> int:
-        return self.__attempt
-
-    def _increase_attempt(self):
-        self.__attempt += 1
-
-    def _should_attempt(self) -> bool:
-        attempt = self._get_attempt()
-        max_attempt = self._get_max_attempt()
-        return attempt <= max_attempt
-
-    def _is_last_attempt(self) -> bool:
-        attempt = self._get_attempt()
-        max_attempt = self._get_max_attempt()
-        return attempt >= max_attempt
-
-
-@typechecked
-class FinishTracker:
-    def __init__(self, checking_interval: Union[float, int]):
-        self.__execution_queue: Optional[asyncio.Queue] = None
-        self.__counter = 0
-        self.__checking_interval = checking_interval
-
-    async def _mark_awaited(self):
-        if self.__execution_queue is None:
-            self.__execution_queue = asyncio.Queue()
-        self.__counter += 1
-
-    async def _mark_done(self):
-        # Tracker might be started several times
-        # However, when the execution is marked as done, it applied globally
-        # Thus, we need to send event as much as the counter.
-        for i in range(self.__counter):
-            await self.__execution_queue.put(True)
-
-    async def _is_done(self) -> bool:
-        while self.__execution_queue is None:
-            await asyncio.sleep(self.__checking_interval / 2.0)
-        return await self.__execution_queue.get()

zrb/task/checker.py

@@ -1,101 +0,0 @@
-import asyncio
-from collections.abc import Callable, Iterable
-from typing import Any, Optional, Union
-
-from zrb.helper.accessories.color import colored
-from zrb.helper.log import logger
-from zrb.helper.typecheck import typechecked
-from zrb.task.any_task import AnyTask
-from zrb.task.any_task_event_handler import (
-    OnFailed,
-    OnReady,
-    OnRetry,
-    OnSkipped,
-    OnStarted,
-    OnTriggered,
-    OnWaiting,
-)
-from zrb.task.base_task.base_task import BaseTask
-from zrb.task_env.env import Env
-from zrb.task_env.env_file import EnvFile
-from zrb.task_group.group import Group
-from zrb.task_input.any_input import AnyInput
-
-logger.debug(colored("Loading zrb.task.checker", attrs=["dark"]))
-
-
-@typechecked
-class Checker(BaseTask):
-    def __init__(
-        self,
-        name: str = "check",
-        group: Optional[Group] = None,
-        inputs: Iterable[AnyInput] = [],
-        envs: Iterable[Env] = [],
-        env_files: Iterable[EnvFile] = [],
-        icon: Optional[str] = None,
-        color: Optional[str] = None,
-        description: str = "",
-        upstreams: Iterable[AnyTask] = [],
-        fallbacks: Iterable[AnyTask] = [],
-        on_triggered: Optional[OnTriggered] = None,
-        on_waiting: Optional[OnWaiting] = None,
-        on_skipped: Optional[OnSkipped] = None,
-        on_started: Optional[OnStarted] = None,
-        on_ready: Optional[OnReady] = None,
-        on_retry: Optional[OnRetry] = None,
-        on_failed: Optional[OnFailed] = None,
-        checking_interval: Union[int, float] = 0.05,
-        progress_interval: Union[int, float] = 30,
-        expected_result: bool = True,
-        should_execute: Union[bool, str, Callable[..., bool]] = True,
-    ):
-        BaseTask.__init__(
-            self,
-            name=name,
-            group=group,
-            inputs=inputs,
-            envs=envs,
-            env_files=env_files,
-            icon=icon,
-            color=color,
-            description=description,
-            upstreams=upstreams,
-            fallbacks=fallbacks,
-            on_triggered=on_triggered,
-            on_waiting=on_waiting,
-            on_skipped=on_skipped,
-            on_started=on_started,
-            on_ready=on_ready,
-            on_retry=on_retry,
-            on_failed=on_failed,
-            checkers=[],
-            checking_interval=checking_interval,
-            retry=0,
-            retry_interval=0,
-            should_execute=should_execute,
-        )
-        self._progress_interval = progress_interval
-        self._expected_result = expected_result
-        self._should_show_progress = False
-
-    async def run(self, *args: Any, **kwargs: Any) -> bool:
-        wait_time = 0
-        while True:
-            self._should_show_progress = wait_time >= self._progress_interval
-            inspect_result = await self.inspect(*args, **kwargs)
-            if inspect_result is not None and inspect_result == self._expected_result:
-                return True
-            if wait_time >= self._progress_interval:
-                wait_time = 0
-            await asyncio.sleep(self._checking_interval)
-            wait_time += self._checking_interval
-
-    async def inspect(self, *args: Any, **kwargs: Any) -> Optional[bool]:
-        return None
-
-    def show_progress(self, message: str):
-        if self._should_show_progress:
-            self.print_out_dark(message)
-            return
-        self.log_debug(message)

zrb/task/decorator.py

@@ -1,102 +0,0 @@
-from collections.abc import Callable, Iterable
-from typing import Any, Optional, Union
-
-from zrb.action.runner import Runner
-from zrb.helper.accessories.color import colored
-from zrb.helper.log import logger
-from zrb.helper.typecheck import typechecked
-from zrb.task.any_task import AnyTask
-from zrb.task.any_task_event_handler import (
-    OnFailed,
-    OnReady,
-    OnRetry,
-    OnSkipped,
-    OnStarted,
-    OnTriggered,
-    OnWaiting,
-)
-from zrb.task.task import Task
-from zrb.task_env.env import Env
-from zrb.task_env.env_file import EnvFile
-from zrb.task_group.group import Group
-from zrb.task_input.any_input import AnyInput
-
-logger.debug(colored("Loading zrb.task.decorator", attrs=["dark"]))
-
-# flake8: noqa E501
-
-
-@typechecked
-def python_task(
-    name: str,
-    group: Optional[Group] = None,
-    inputs: Iterable[AnyInput] = [],
-    envs: Iterable[Env] = [],
-    env_files: Iterable[EnvFile] = [],
-    icon: Optional[str] = None,
-    color: Optional[str] = None,
-    description: str = "",
-    upstreams: Iterable[AnyTask] = [],
-    on_triggered: Optional[OnTriggered] = None,
-    on_waiting: Optional[OnWaiting] = None,
-    on_skipped: Optional[OnSkipped] = None,
-    on_started: Optional[OnStarted] = None,
-    on_ready: Optional[OnReady] = None,
-    on_retry: Optional[OnRetry] = None,
-    on_failed: Optional[OnFailed] = None,
-    checkers: Iterable[AnyTask] = [],
-    checking_interval: Union[float, int] = 0.05,
-    retry: int = 2,
-    retry_interval: Union[float, int] = 1,
-    should_execute: Union[bool, str, Callable[..., bool]] = True,
-    return_upstream_result: bool = False,
-    runner: Optional[Runner] = None,
-) -> Callable[[Callable[..., Any]], Task]:
-    """
-    python_task decorator helps you turn any Python function into a task
-
-    Returns:
-        Callable[[Callable[..., Any]], Task]: A callable turning function into task.
-
-    Examples:
-        >>> from zrb import python_task
-        >>> @python_task(
-        >>>    name='my-task'
-        >>> )
-        >>> def my_task(*args, **kwargs):
-        >>>    return 'hello world'
-        >>> print(my_task)
-        <Task name=my-task>
-    """
-
-    def _create_task(fn: Callable[..., Any]) -> Task:
-        task = Task(
-            name=name,
-            group=group,
-            inputs=inputs,
-            envs=envs,
-            env_files=env_files,
-            icon=icon,
-            color=color,
-            description=description,
-            upstreams=upstreams,
-            on_triggered=on_triggered,
-            on_waiting=on_waiting,
-            on_skipped=on_skipped,
-            on_started=on_started,
-            on_ready=on_ready,
-            on_retry=on_retry,
-            on_failed=on_failed,
-            checkers=checkers,
-            checking_interval=checking_interval,
-            retry=retry,
-            retry_interval=retry_interval,
-            run=fn,
-            should_execute=should_execute,
-            return_upstream_result=return_upstream_result,
-        )
-        if runner is not None:
-            runner.register(task)
-        return task
-
-    return _create_task

zrb/task/docker_compose_start_task.py

@@ -1,149 +0,0 @@
-import os
-import pathlib
-from collections.abc import Callable, Iterable, Mapping
-from typing import Any, Optional, Union
-
-from zrb.helper.accessories.color import colored
-from zrb.helper.log import logger
-from zrb.helper.typecheck import typechecked
-from zrb.helper.typing import JinjaTemplate
-from zrb.task.any_task import AnyTask
-from zrb.task.any_task_event_handler import (
-    OnFailed,
-    OnReady,
-    OnRetry,
-    OnSkipped,
-    OnStarted,
-    OnTriggered,
-    OnWaiting,
-)
-from zrb.task.cmd_task import CmdVal
-from zrb.task.docker_compose_task import DockerComposeTask, ServiceConfig
-from zrb.task_env.env import Env
-from zrb.task_env.env_file import EnvFile
-from zrb.task_group.group import Group
-from zrb.task_input.any_input import AnyInput
-
-logger.debug(colored("Loading zrb.task.docker_compose_task", attrs=["dark"]))
-
-
-@typechecked
-class DockerComposeStartTask(DockerComposeTask):
-    def __init__(
-        self,
-        name: str,
-        group: Optional[Group] = None,
-        inputs: Iterable[AnyInput] = [],
-        envs: Iterable[Env] = [],
-        env_files: Iterable[EnvFile] = [],
-        icon: Optional[str] = None,
-        color: Optional[str] = None,
-        description: str = "",
-        executable: Optional[str] = None,
-        compose_service_configs: Mapping[str, ServiceConfig] = {},
-        compose_file: Optional[str] = None,
-        compose_options: Mapping[JinjaTemplate, JinjaTemplate] = {},
-        compose_flags: Iterable[JinjaTemplate] = [],
-        compose_args: Iterable[JinjaTemplate] = [],
-        compose_profiles: Iterable[JinjaTemplate] = [],
-        compose_env_prefix: str = "",
-        setup_cmd: CmdVal = "",
-        setup_cmd_path: CmdVal = "",
-        cwd: Optional[Union[JinjaTemplate, pathlib.Path]] = None,
-        should_render_cwd: bool = True,
-        upstreams: Iterable[AnyTask] = [],
-        fallbacks: Iterable[AnyTask] = [],
-        on_triggered: Optional[OnTriggered] = None,
-        on_waiting: Optional[OnWaiting] = None,
-        on_skipped: Optional[OnSkipped] = None,
-        on_started: Optional[OnStarted] = None,
-        on_ready: Optional[OnReady] = None,
-        on_retry: Optional[OnRetry] = None,
-        on_failed: Optional[OnFailed] = None,
-        checkers: Iterable[AnyTask] = [],
-        checking_interval: Union[float, int] = 0.05,
-        retry: int = 2,
-        retry_interval: Union[float, int] = 1,
-        max_output_line: int = 1000,
-        max_error_line: int = 1000,
-        preexec_fn: Optional[Callable[[], Any]] = os.setsid,
-        should_execute: Union[bool, str, Callable[..., bool]] = True,
-        return_upstream_result: bool = False,
-        should_print_cmd_result: bool = True,
-        should_show_cmd: bool = True,
-        should_show_working_directory: bool = True,
-    ):
-        DockerComposeTask.__init__(
-            self,
-            name=name,
-            group=group,
-            inputs=inputs,
-            envs=envs,
-            env_files=env_files,
-            icon=icon,
-            color=color,
-            description=description,
-            executable=executable,
-            compose_service_configs=compose_service_configs,
-            compose_file=compose_file,
-            compose_cmd="up",
-            compose_options=compose_options,
-            compose_flags=compose_flags,
-            compose_args=compose_args,
-            compose_profiles=compose_profiles,
-            compose_env_prefix=compose_env_prefix,
-            setup_cmd=setup_cmd,
-            setup_cmd_path=setup_cmd_path,
-            cwd=cwd,
-            should_render_cwd=should_render_cwd,
-            upstreams=upstreams,
-            fallbacks=fallbacks,
-            on_triggered=on_triggered,
-            on_waiting=on_waiting,
-            on_skipped=on_skipped,
-            on_started=on_started,
-            on_ready=on_ready,
-            on_retry=on_retry,
-            on_failed=on_failed,
-            checkers=checkers,
-            checking_interval=checking_interval,
-            retry=retry,
-            retry_interval=retry_interval,
-            max_output_line=max_output_line,
-            max_error_line=max_error_line,
-            preexec_fn=preexec_fn,
-            should_execute=should_execute,
-            return_upstream_result=return_upstream_result,
-            should_print_cmd_result=should_print_cmd_result,
-            should_show_cmd=should_show_cmd,
-            should_show_working_directory=should_show_working_directory,
-        )
-
-    def _get_execute_docker_compose_script(
-        self,
-        compose_cmd: JinjaTemplate,
-        compose_options: Mapping[JinjaTemplate, JinjaTemplate],
-        compose_flags: Iterable[JinjaTemplate],
-        compose_args: Iterable[JinjaTemplate],
-        *args: Any
-    ) -> JinjaTemplate:
-        return "\n".join(
-            [
-                # compose start
-                super()._get_execute_docker_compose_script(
-                    compose_cmd=compose_cmd,
-                    compose_options=compose_options,
-                    compose_flags=list(compose_flags) + ["-d"],
-                    compose_args=compose_args,
-                    *args,
-                ),
-                # compose log
-                super()._get_execute_docker_compose_script(
-                    compose_cmd="logs",
-                    compose_options={},
-                    compose_flags=["-f"],
-                    compose_args=[],
-                    *args,
-                ),
-            ]
-        )