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

zrb/task/resource_maker.py

@@ -1,220 +0,0 @@
-from collections.abc import Callable, Iterable, Mapping
-from typing import Any, Optional, TypeVar, Union
-
-from zrb.helper.accessories.color import colored
-from zrb.helper.file.copy_tree import copy_tree
-from zrb.helper.log import logger
-from zrb.helper.typecheck import typechecked
-from zrb.helper.typing import JinjaTemplate
-from zrb.helper.util import (
-    to_camel_case,
-    to_capitalized_human_readable,
-    to_human_readable,
-    to_kebab_case,
-    to_pascal_case,
-    to_snake_case,
-)
-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.resource_maker", attrs=["dark"]))
-
-Replacement = Mapping[str, JinjaTemplate]
-ReplacementMutator = Callable[[AnyTask, Replacement], Replacement]
-TResourceMaker = TypeVar("TResourceMaker", bound="ResourceMaker")
-
-
-def get_default_resource_skip_parsing() -> list[str]:
-    return [
-        "*.mp3",
-        "*.pdf",
-        "*.exe",
-        "*.dll",
-        "*.bin",
-        "*.iso",
-        "*.png",
-        "*.jpg",
-        "*.gif",
-        "*.ico",
-        "*.pyc",
-        "*.gz",
-        "*.whl",
-        "*.db",
-    ]
-
-
-def get_default_resource_excludes() -> list[str]:
-    return [
-        "*/.git",
-        "*/__pycache__",
-        "*/node_modules",
-        "*/.venv",
-        "*/poetry.lock",
-        "*/.env",
-    ]
-
-
-@typechecked
-class ResourceMaker(BaseTask):
-    def __init__(
-        self,
-        name: str,
-        template_path: JinjaTemplate,
-        destination_path: JinjaTemplate,
-        replacements: Replacement = {},
-        replacement_mutator: Optional[ReplacementMutator] = None,
-        excludes: Iterable[str] = get_default_resource_excludes(),
-        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,
-        should_execute: Union[bool, JinjaTemplate, Callable[..., bool]] = True,
-        skip_parsing: Iterable[str] = get_default_resource_skip_parsing(),
-    ):
-        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=0.05,
-            retry=0,
-            retry_interval=0,
-            should_execute=should_execute,
-        )
-        self._template_path = template_path
-        self._destination_path = destination_path
-        self._excludes = excludes
-        self._replacements = replacements
-        self._replacement_mutator = replacement_mutator
-        self._skip_parsing = skip_parsing
-
-    def copy(self) -> TResourceMaker:
-        return super().copy()
-
-    def to_function(
-        self,
-        env_prefix: str = "",
-        raise_error: bool = True,
-        is_async: bool = False,
-        show_done_info: bool = True,
-        should_clear_xcom: bool = False,
-        should_stop_looper: bool = False,
-    ) -> Callable[..., bool]:
-        return super().to_function(
-            env_prefix=env_prefix,
-            raise_error=raise_error,
-            is_async=is_async,
-            show_done_info=show_done_info,
-            should_clear_xcom=should_clear_xcom,
-            should_stop_looper=should_stop_looper,
-        )
-
-    async def run(self, *args: Any, **kwargs: Any) -> bool:
-        # render parameters
-        template_path = self.render_str(self._template_path)
-        destination_path = self.render_str(self._destination_path)
-        # render excludes
-        self.log_debug(f"Render excludes: {self._excludes}")
-        excludes = [self.render_str(exclude) for exclude in self._excludes]
-        self.log_debug(f"Rendered excludes: {excludes}")
-        # render replacements
-        self.log_debug(f"Render replacements: {self._replacements}")
-        rendered_replacements: Mapping[str, str] = {
-            old: self.render_str(new) for old, new in self._replacements.items()
-        }
-        self.log_debug(f"Rendered replacements: {rendered_replacements}")
-        if self._replacement_mutator is not None:
-            self.log_debug("Apply replacement mutator")
-            rendered_replacements = self._replacement_mutator(
-                self, rendered_replacements
-            )
-        self.log_debug(f"Apply default replacement mutator: {rendered_replacements}")
-        rendered_replacements = self._default_mutate_replacements(rendered_replacements)
-        self.log_debug(f"Final replacement: {rendered_replacements}")
-        self.print_out_dark(f"Template: {template_path}")
-        self.print_out_dark(f"Destination: {destination_path}")
-        self.print_out_dark(f"Replacements: {rendered_replacements}")
-        self.print_out_dark(f"Excludes: {excludes}")
-        self.print_out_dark(f"Skip parsing: {self._skip_parsing}")
-        await copy_tree(
-            src=template_path,
-            dst=destination_path,
-            replacements=rendered_replacements,
-            excludes=excludes,
-            skip_parsing=self._skip_parsing,
-        )
-        return True
-
-    def _default_mutate_replacements(
-        self, rendered_replacements: Mapping[str, str]
-    ) -> Mapping[str, str]:
-        transformations: Mapping[str, Callable[[str], str]] = {
-            "Pascal": to_pascal_case,
-            "camel": to_camel_case,
-            "kebab": to_kebab_case,
-            "KEBAB": _to_upper(to_kebab_case),
-            "snake": to_snake_case,
-            "SNAKE": _to_upper(to_snake_case),
-            "human readable": to_human_readable,
-            "Human readable": to_capitalized_human_readable,
-            "HUMAN READABLE": _to_upper(to_capitalized_human_readable),
-        }
-        keys = list(rendered_replacements.keys())
-        for key in keys:
-            value = rendered_replacements[key]
-            for prefix, transform in transformations.items():
-                prefixed_key = transform(prefix + " " + key)
-                if prefixed_key in rendered_replacements:
-                    continue
-                transformed_value = transform(value)
-                rendered_replacements[prefixed_key] = transformed_value
-            if key != key.upper():
-                rendered_replacements[key.upper()] = value.upper()
-        return rendered_replacements
-
-
-def _to_upper(fn: Callable[[str], str]) -> Callable[[str], str]:
-    def upperized_fn(text: str) -> str:
-        return fn(text).upper()
-
-    return upperized_fn

zrb/task/server.py

@@ -1,199 +0,0 @@
-import asyncio
-import copy
-from collections.abc import Callable, Iterable, Mapping
-from typing import Any, Optional, Union
-
-from zrb.helper.accessories.color import colored
-from zrb.helper.accessories.name import get_random_name
-from zrb.helper.log import logger
-from zrb.helper.typecheck import typechecked
-from zrb.helper.util import to_kebab_case
-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.flow_task import FlowTask
-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.server", attrs=["dark"]))
-
-
-@typechecked
-class Controller:
-    def __init__(
-        self,
-        trigger: Union[AnyTask, list[AnyTask]],
-        action: Union[AnyTask, list[AnyTask]],
-        name: Optional[str] = None,
-    ):
-        self._name = get_random_name() if name is None else name
-        self._triggers = self._to_task_list(trigger)
-        self._actions = self._to_task_list(action)
-        self._args: list[Any] = []
-        self._kwargs: Mapping[str, Any] = {}
-        self._inputs: list[AnyInput] = []
-        self._envs: list[Env] = []
-        self._env_files: list[EnvFile] = []
-
-    def set_args(self, args: list[Any]):
-        self._args = args
-
-    def set_kwargs(self, kwargs: Mapping[str, Any]):
-        self._kwargs = kwargs
-
-    def set_inputs(self, inputs: list[AnyInput]):
-        self._inputs = inputs
-
-    def set_envs(self, envs: list[Env]):
-        self._envs = envs
-
-    def set_env_files(self, env_files: list[EnvFile]):
-        self._env_files = env_files
-
-    def get_original_env_files(self) -> Iterable[EnvFile]:
-        env_files = []
-        for trigger in self._triggers:
-            env_files += trigger._get_env_files()
-        for action in self._actions:
-            env_files += action._get_env_files()
-        return env_files
-
-    def get_original_envs(self) -> Iterable[Env]:
-        envs = []
-        for trigger in self._triggers:
-            envs += trigger._get_envs()
-        for action in self._actions:
-            envs += action._get_envs()
-        return envs
-
-    def get_original_inputs(self) -> Iterable[AnyInput]:
-        inputs = []
-        for trigger in self._triggers:
-            inputs += trigger._get_combined_inputs()
-        for action in self._actions:
-            inputs += action._get_combined_inputs()
-        return inputs
-
-    def to_function(self) -> Callable[..., Any]:
-        task = self._get_task()
-
-        async def fn() -> Any:
-            task.print_out_dark(f"Starting controller: {self._name}")
-            task_fn = task.to_function(is_async=True)
-            return await task_fn(*self._args, **self._kwargs)
-
-        return fn
-
-    def _to_task_list(self, tasks: Union[AnyTask, list[AnyTask]]) -> list[AnyTask]:
-        if isinstance(tasks, AnyTask):
-            return [tasks.copy()]
-        return [task.copy() for task in tasks]
-
-    def _get_task(self) -> AnyTask:
-        actions = [action.copy() for action in self._actions]
-        actions.insert(0, self._get_remonitor_task())
-        triggers = [trigger.copy() for trigger in self._triggers]
-        task: AnyTask = FlowTask(
-            name=to_kebab_case(self._name),
-            inputs=self._inputs,
-            envs=self._envs,
-            env_files=self._env_files,
-            steps=[triggers, actions],
-        )
-        return task
-
-    def _get_remonitor_task(self) -> AnyTask:
-        async def on_ready(task: AnyTask):
-            task = self._get_task()
-            fn = task.to_function(is_async=True)
-            await fn()
-
-        return BaseTask(
-            name=f"monitor-{to_kebab_case(self._name)}",
-            on_ready=on_ready,
-        )
-
-
-@typechecked
-class Server(BaseTask):
-
-    def __init__(
-        self,
-        name: str,
-        controllers: Iterable[Controller],
-        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,
-        checkers: Iterable[AnyTask] = [],
-        checking_interval: Union[int, float] = 0.05,
-        retry: int = 0,
-        retry_interval: Union[int, float] = 1,
-        should_execute: Union[bool, str, Callable[..., bool]] = True,
-        return_upstream_result: bool = False,
-    ):
-        inputs, envs, env_files = list(inputs), list(envs), list(env_files)
-        for controller in controllers:
-            controller_cp = copy.deepcopy(controller)
-            inputs += controller_cp.get_original_inputs()
-            envs += controller_cp.get_original_envs()
-            env_files += controller_cp.get_original_env_files()
-        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=checkers,
-            checking_interval=checking_interval,
-            retry=retry,
-            retry_interval=retry_interval,
-            should_execute=should_execute,
-            return_upstream_result=return_upstream_result,
-        )
-        self._controllers = list(controllers)
-
-    async def run(self, *args: Any, **kwargs: Any):
-        for controller in self._controllers:
-            controller.set_envs(self._get_envs())
-            controller.set_env_files(self._get_env_files())
-            controller.set_inputs(self._get_inputs())
-            controller.set_args(args)
-            controller.set_kwargs(kwargs)
-        functions = [controller.to_function() for controller in self._controllers]
-        await asyncio.gather(*[fn() for fn in functions])

zrb/task/time_watcher.py

@@ -1,147 +0,0 @@
-import asyncio
-import datetime
-from collections.abc import Callable, Iterable, Mapping
-from typing import Any, Optional, TypeVar, Union
-
-import croniter
-
-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.watcher import Watcher
-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.time_watcher", attrs=["dark"]))
-
-TTimeWatcher = TypeVar("TTimeWatcher", bound="TimeWatcher")
-
-
-@typechecked
-class TimeWatcher(Watcher):
-    """
-    TimeWatcher will wait for any changes specified on  path.
-
-    Once the changes detected, TimeWatcher will be completed
-    and <task-name>.scheduled-time xcom will be set.
-    """
-
-    __scheduled_times: Mapping[str, Mapping[str, datetime.datetime]] = {}
-
-    def __init__(
-        self,
-        name: str = "watch-path",
-        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,
-        schedule: JinjaTemplate = "",
-        checking_interval: Union[int, float] = 0.05,
-        progress_interval: Union[int, float] = 30,
-        should_execute: Union[bool, JinjaTemplate, Callable[..., bool]] = True,
-    ):
-        Watcher.__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,
-            checking_interval=checking_interval,
-            progress_interval=progress_interval,
-            should_execute=should_execute,
-        )
-        self._schedule = schedule
-        self._rendered_schedule: str = ""
-
-    def copy(self) -> TTimeWatcher:
-        return super().copy()
-
-    def to_function(
-        self,
-        env_prefix: str = "",
-        raise_error: bool = True,
-        is_async: bool = False,
-        show_done_info: bool = True,
-        should_clear_xcom: bool = False,
-        should_stop_looper: bool = False,
-    ) -> Callable[..., bool]:
-        return super().to_function(
-            env_prefix=env_prefix,
-            raise_error=raise_error,
-            is_async=is_async,
-            show_done_info=show_done_info,
-            should_clear_xcom=should_clear_xcom,
-            should_stop_looper=should_stop_looper,
-        )
-
-    async def run(self, *args: Any, **kwargs: Any) -> bool:
-        self._rendered_schedule = self.render_str(self._schedule)
-        identifier = self.get_identifier()
-        if identifier not in self.__scheduled_times:
-            self.__scheduled_times[identifier] = self._get_next_schedule_time()
-        return await super().run(*args, **kwargs)
-
-    def create_loop_inspector(self) -> Callable[..., Optional[bool]]:
-        async def loop_inspect() -> bool:
-            await asyncio.sleep(self._checking_interval)
-            label = f"Watching {self._rendered_schedule}"
-            identifier = self.get_identifier()
-            scheduled_time = self.__scheduled_times[identifier]
-            self.set_task_xcom(key="scheduled-time", value=scheduled_time)
-            now = datetime.datetime.now()
-            if now > scheduled_time:
-                self.print_out_dark(f"{label} (Meet {scheduled_time})")
-                self.__scheduled_times[identifier] = self._get_next_schedule_time()
-                return True
-            self.show_progress(f"{label} (Waiting for {scheduled_time})")
-            return False
-
-        return loop_inspect
-
-    def _get_next_schedule_time(self) -> datetime.datetime:
-        cron = self._get_cron()
-        return cron.get_next(datetime.datetime)
-
-    def _get_cron(self) -> Any:
-        margin = datetime.timedelta(seconds=self._checking_interval / 2.0)
-        slightly_before_now = datetime.datetime.now() - margin
-        cron = croniter.croniter(self._rendered_schedule, slightly_before_now)
-        return cron

zrb/task/watcher.py

@@ -1,104 +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.accessories.name import get_random_name
-from zrb.helper.callable import run_async
-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.checker import Checker
-from zrb.task.looper import looper
-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.watcher", attrs=["dark"]))
-
-
-@typechecked
-class Watcher(Checker):
-    __looper = looper
-
-    def __init__(
-        self,
-        name: str = "watch",
-        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,
-    ):
-        Checker.__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,
-            checking_interval=checking_interval,
-            should_execute=should_execute,
-            progress_interval=progress_interval,
-            expected_result=expected_result,
-        )
-        self._identifier = get_random_name()
-
-    def get_identifier(self):
-        return self._identifier
-
-    async def run(self, *args: Any, **kwargs: Any) -> bool:
-        if not looper.is_registered(self._identifier):
-            asyncio.create_task(
-                run_async(
-                    looper.register, self._identifier, self.create_loop_inspector()
-                )
-            )
-        return await super().run(*args, **kwargs)
-
-    async def inspect(self, *args, **kwargs: Any) -> Optional[bool]:
-        result = await looper.pop(self._identifier)
-        return result
-
-    def create_loop_inspector(self) -> Callable[..., Optional[bool]]:
-        def loop_inspect() -> Optional[bool]:
-            return None
-
-        return loop_inspect