zrb 0.28.0__py3-none-any.whl → 1.0.0a10__py3-none-any.whl

zrb/context/shared_context.py

@@ -0,0 +1,98 @@
+import datetime
+from typing import Any
+
+from zrb.config import LOGGING_LEVEL
+from zrb.context.any_shared_context import AnySharedContext
+from zrb.dot_dict.dot_dict import DotDict
+from zrb.session.any_session import AnySession
+from zrb.util.string.conversion import (
+    double_quote,
+    to_boolean,
+    to_camel_case,
+    to_human_case,
+    to_kebab_case,
+    to_pascal_case,
+    to_snake_case,
+)
+from zrb.util.string.format import fstring_format
+from zrb.xcom.xcom import Xcom
+
+
+class SharedContext(AnySharedContext):
+    def __init__(
+        self,
+        input: dict[str, Any] = {},
+        args: list[Any] = [],
+        env: dict[str, str] = {},
+        xcom: dict[str, Xcom] = {},
+        logging_level: int = LOGGING_LEVEL,
+    ):
+        self.__logging_level = logging_level
+        self._input = DotDict(input)
+        self._args = args
+        self._env = DotDict(env)
+        self._xcom = DotDict(xcom)
+        self._session: AnySession | None = None
+        self._log = []
+
+    def __repr__(self):
+        class_name = self.__class__.__name__
+        input = self._input
+        args = self._args
+        env = self._env
+        xcom = self._xcom
+        return f"<{class_name} input={input} args={args} xcom={xcom} env={env}>"
+
+    @property
+    def input(self) -> DotDict:
+        return self._input
+
+    @property
+    def env(self) -> DotDict:
+        return self._env
+
+    @property
+    def args(self) -> list[Any]:
+        return self._args
+
+    @property
+    def xcom(self) -> DotDict[str, Xcom]:
+        return self._xcom
+
+    @property
+    def shared_log(self) -> list[str]:
+        return self._log
+
+    @property
+    def session(self) -> AnySession | None:
+        return self._session
+
+    def append_to_shared_log(self, message: str):
+        self._log.append(message)
+        session = self.session
+        if session is not None:
+            session_parent: AnySession = session.parent
+            if session_parent is not None:
+                session_parent.shared_ctx.append_to_shared_log(message)
+
+    def set_session(self, session: AnySession):
+        self._session = session
+
+    def get_logging_level(self) -> int:
+        return self.__logging_level
+
+    def render(self, template: str) -> str:
+        return fstring_format(
+            template=template,
+            data={
+                "ctx": self,
+                "datetime": datetime,
+                "to_boolean": to_boolean,
+                "to_camel_case": to_camel_case,
+                "to_human_case": to_human_case,
+                "to_kebab_case": to_kebab_case,
+                "to_pascal_case": to_pascal_case,
+                "to_snake_case": to_snake_case,
+                "double_quote": double_quote,
+            },
+        )

zrb/dot_dict/dot_dict.py

@@ -0,0 +1,19 @@
+class DotDict(dict):
+    def __getattr__(self, key):
+        try:
+            return self[key]
+        except KeyError:
+            raise AttributeError(f"'DotDict' object has no attribute '{key}'")
+
+    def __setattr__(self, key, value):
+        self[key] = value
+
+    def __delattr__(self, key):
+        try:
+            del self[key]
+        except KeyError:
+            raise AttributeError(f"'DotDict' object has no attribute '{key}'")
+
+    def copy(self):
+        # Ensure the copied instance is also a DotDict
+        return DotDict(super().copy())

zrb/env/any_env.py

@@ -0,0 +1,9 @@
+from abc import ABC, abstractmethod
+
+from zrb.context.any_shared_context import AnySharedContext
+
+
+class AnyEnv(ABC):
+    @abstractmethod
+    def update_context(self, shared_ctx: AnySharedContext):
+        pass

zrb/env/env.py

@@ -0,0 +1,33 @@
+import os
+
+from zrb.attr.type import StrAttr
+from zrb.context.any_shared_context import AnySharedContext
+from zrb.env.any_env import AnyEnv
+from zrb.util.attr import get_str_attr
+
+
+class Env(AnyEnv):
+    def __init__(
+        self,
+        name: str,
+        default: StrAttr,
+        auto_render: bool = True,
+        link_to_os: bool = True,
+        os_name: str | None = None,
+    ):
+        self._name = name
+        self._default = default
+        self._auto_render = auto_render
+        self._link_to_os = link_to_os
+        self._os_name = os_name
+
+    def update_context(self, shared_ctx: AnySharedContext):
+        if self._link_to_os:
+            os_name = self._name if self._os_name is None else self._os_name
+            value = os.getenv(os_name, self._get_default_value(shared_ctx))
+        else:
+            value = self._get_default_value(shared_ctx)
+        shared_ctx.env[self._name] = value
+
+    def _get_default_value(self, shared_ctx: AnySharedContext) -> str:
+        return get_str_attr(shared_ctx, self._default, "", self._auto_render)

zrb/env/env_file.py

@@ -0,0 +1,24 @@
+from dotenv import dotenv_values
+
+from zrb.attr.type import StrAttr
+from zrb.context.shared_context import SharedContext
+from zrb.env.env_map import EnvMap
+from zrb.util.attr import get_str_attr
+
+
+class EnvFile(EnvMap):
+    def __init__(
+        self,
+        path: StrAttr,
+        auto_render: bool = True,
+        link_to_os: bool = True,
+        os_prefix: str | None = None,
+    ):
+        super().__init__(
+            vars={}, auto_render=auto_render, link_to_os=link_to_os, os_prefix=os_prefix
+        )
+        self._file_path = path
+
+    def _get_env_map(self, shared_ctx: SharedContext) -> dict[str, str]:
+        file_path = get_str_attr(shared_ctx, self._file_path, ".env", self._auto_render)
+        return dotenv_values(file_path)

zrb/env/env_map.py

@@ -0,0 +1,35 @@
+import os
+from collections.abc import Callable
+
+from zrb.context.shared_context import SharedContext
+from zrb.env.any_env import AnyEnv
+
+
+class EnvMap(AnyEnv):
+    def __init__(
+        self,
+        vars: dict[str, str] | Callable[[SharedContext], dict[str, str]],
+        auto_render: bool = True,
+        link_to_os: bool = True,
+        os_prefix: str | None = None,
+    ):
+        self._env_map = vars
+        self._link_to_os = link_to_os
+        self._os_prefix = os_prefix
+        self._auto_render = auto_render
+
+    def update_context(self, shared_ctx: SharedContext) -> dict[str, str]:
+        env_map = self._get_env_map(shared_ctx)
+        for name, default_value in env_map.items():
+            if self._link_to_os:
+                prefix = f"{self._os_prefix}_" if self._os_prefix is not None else ""
+                os_name = f"{prefix}{name}"
+                value = os.getenv(os_name, default_value)
+            else:
+                value = default_value
+            shared_ctx.env[name] = value
+
+    def _get_env_map(self, shared_ctx: SharedContext) -> dict[str, str]:
+        if callable(self._env_map):
+            return self._env_map(shared_ctx)
+        return {key: shared_ctx.render(val) for key, val in self._env_map.items()}

zrb/group/any_group.py

@@ -0,0 +1,52 @@
+from abc import ABC, abstractmethod
+from typing import Optional, Union
+
+from zrb.task.any_task import AnyTask
+
+
+class AnyGroup(ABC):
+    @property
+    @abstractmethod
+    def name(self) -> str:
+        """Group name"""
+        pass
+
+    @property
+    @abstractmethod
+    def banner(self) -> str:
+        """Group banner"""
+        pass
+
+    @property
+    @abstractmethod
+    def description(self) -> str:
+        """Group description"""
+        pass
+
+    @property
+    @abstractmethod
+    def subtasks(self) -> dict[str, AnyTask]:
+        """Group subtasks"""
+        pass
+
+    @property
+    @abstractmethod
+    def subgroups(self) -> dict[str, "AnyGroup"]:
+        """Group subgroups"""
+        pass
+
+    @abstractmethod
+    def add_group(self, group: Union["AnyGroup", str]) -> "AnyGroup":
+        pass
+
+    @abstractmethod
+    def add_task(self, task: AnyTask, alias: str | None = None) -> AnyTask:
+        pass
+
+    @abstractmethod
+    def get_task_by_alias(self, alias: str) -> AnyTask | None:
+        pass
+
+    @abstractmethod
+    def get_group_by_alias(self, name: str) -> Optional["AnyGroup"]:
+        pass

zrb/group/group.py

@@ -0,0 +1,60 @@
+from zrb.group.any_group import AnyGroup
+from zrb.task.any_task import AnyTask
+
+
+class Group(AnyGroup):
+
+    def __init__(
+        self, name: str, description: str | None = None, banner: str | None = None
+    ):
+        self._name = name
+        self._banner = banner
+        self._description = description
+        self._groups: dict[str, AnyGroup] = {}
+        self._tasks: dict[str, AnyTask] = {}
+
+    def __repr__(self):
+        return f"<{self.__class__.__name__} name={self._name}>"
+
+    @property
+    def name(self):
+        return self._name
+
+    @property
+    def banner(self) -> str:
+        if self._banner is None:
+            return ""
+        return self._banner
+
+    @property
+    def description(self):
+        return self._description if self._description is not None else self.name
+
+    @property
+    def subgroups(self) -> dict[str, AnyGroup]:
+        names = list(self._groups.keys())
+        names.sort()
+        return {name: self._groups.get(name) for name in names}
+
+    @property
+    def subtasks(self) -> dict[str, AnyTask]:
+        alias = list(self._tasks.keys())
+        alias.sort()
+        return {name: self._tasks.get(name) for name in alias}
+
+    def add_group(self, group: AnyGroup | str, alias: str | None = None) -> AnyGroup:
+        real_group = Group(group) if isinstance(group, str) else group
+        alias = alias if alias is not None else real_group.name
+        self._groups[alias] = real_group
+        return real_group
+
+    def add_task(self, task: AnyTask, alias: str | None = None) -> AnyTask:
+        alias = alias if alias is not None else task.name
+        self._tasks[alias] = task
+        return task
+
+    def get_task_by_alias(self, alias: str) -> AnyTask | None:
+        return self._tasks.get(alias)
+
+    def get_group_by_alias(self, alias: str) -> AnyGroup | None:
+        return self._groups.get(alias)

zrb/input/any_input.py

@@ -0,0 +1,34 @@
+from abc import ABC, abstractmethod
+
+from zrb.context.any_shared_context import AnySharedContext
+
+
+class AnyInput(ABC):
+    @property
+    @abstractmethod
+    def name(self) -> str:
+        pass
+
+    @property
+    @abstractmethod
+    def description(self) -> str:
+        pass
+
+    @property
+    @abstractmethod
+    def prompt_message(self) -> str:
+        pass
+
+    @abstractmethod
+    def to_html(self, shared_ctx: AnySharedContext) -> str:
+        pass
+
+    @abstractmethod
+    def update_shared_context(
+        self, shared_ctx: AnySharedContext, str_value: str | None = None
+    ):
+        pass
+
+    @abstractmethod
+    def prompt_cli_str(self, shared_ctx: AnySharedContext) -> str:
+        pass

zrb/input/base_input.py

@@ -0,0 +1,77 @@
+from typing import Any
+
+from zrb.attr.type import StrAttr
+from zrb.context.any_shared_context import AnySharedContext
+from zrb.input.any_input import AnyInput
+from zrb.util.attr import get_str_attr
+
+
+class BaseInput(AnyInput):
+    def __init__(
+        self,
+        name: str,
+        description: str | None = None,
+        prompt: str | None = None,
+        default_str: StrAttr = "",
+        auto_render: bool = True,
+        allow_empty: bool = True,
+    ):
+        self._name = name
+        self._description = description
+        self._prompt = prompt
+        self._default_str = default_str
+        self._auto_render = auto_render
+        self._allow_empty = allow_empty
+
+    def __repr__(self):
+        return f"<{self.__class__.__name__} name={self._name}>"
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    @property
+    def description(self) -> str:
+        return self._description if self._description is not None else self.name
+
+    @property
+    def prompt_message(self) -> str:
+        return self._prompt if self._prompt is not None else self.name
+
+    def to_html(self, ctx: AnySharedContext) -> str:
+        name = self.name
+        description = self.description
+        default = self._get_default_str(ctx)
+        return f'<input name="{name}" placeholder="{description}" value="{default}" />'
+
+    def update_shared_context(
+        self, shared_ctx: AnySharedContext, str_value: str | None = None
+    ):
+        if str_value is None:
+            str_value = self._get_default_str(shared_ctx)
+        shared_ctx.input[self.name] = self._parse_str_value(str_value)
+
+    def _parse_str_value(self, str_value: str) -> Any:
+        """Override this to transform str_value"""
+        return str_value
+
+    def prompt_cli_str(self, shared_ctx: AnySharedContext) -> str:
+        value = self._prompt_cli_str(shared_ctx)
+        while not self._allow_empty and value == "":
+            value = self._prompt_cli_str(shared_ctx)
+        return value
+
+    def _prompt_cli_str(self, shared_ctx: AnySharedContext) -> str:
+        prompt_message = self.prompt_message
+        default_value = self._get_default_str(shared_ctx)
+        if default_value != "":
+            prompt_message = f"{prompt_message} [{default_value}]"
+        value = input(f"{prompt_message}: ")
+        if value.strip() == "":
+            value = default_value
+        return value
+
+    def _get_default_str(self, shared_ctx: AnySharedContext) -> str:
+        return get_str_attr(
+            shared_ctx, self._default_str, auto_render=self._auto_render
+        )

zrb/input/bool_input.py

@@ -0,0 +1,42 @@
+from zrb.attr.type import StrAttr
+from zrb.context.any_shared_context import AnySharedContext
+from zrb.input.base_input import BaseInput
+from zrb.util.string.conversion import to_boolean
+
+
+class BoolInput(BaseInput):
+    def __init__(
+        self,
+        name: str,
+        description: str | None = None,
+        prompt: str | None = None,
+        default_str: StrAttr = "False",
+        auto_render: bool = True,
+        allow_empty: bool = True,
+    ):
+        super().__init__(
+            name=name,
+            description=description,
+            prompt=prompt,
+            default_str=default_str,
+            auto_render=auto_render,
+            allow_empty=allow_empty,
+        )
+
+    def to_html(self, ctx: AnySharedContext) -> str:
+        name = self.name
+        description = self.description
+        default = to_boolean(self._get_default_str(ctx))
+        selected_true = "selected" if default else ""
+        selected_false = "selected" if not default else ""
+        return "\n".join(
+            [
+                f'<select name="{name}" placeholder="{description}">',
+                f'<option value="true" {selected_true}>true</option>',
+                f'<option value="false" {selected_false}>false</option>',
+                "</select>",
+            ]
+        )
+
+    def _parse_str_value(self, str_value: str) -> bool:
+        return to_boolean(str_value)

zrb/input/float_input.py

@@ -0,0 +1,32 @@
+from zrb.attr.type import StrAttr
+from zrb.context.any_shared_context import AnySharedContext
+from zrb.input.base_input import BaseInput
+
+
+class FloatInput(BaseInput):
+    def __init__(
+        self,
+        name: str,
+        description: str | None = None,
+        prompt: str | None = None,
+        default_str: StrAttr = "0.0",
+        auto_render: bool = True,
+        allow_empty: bool = True,
+    ):
+        super().__init__(
+            name=name,
+            description=description,
+            prompt=prompt,
+            default_str=default_str,
+            auto_render=auto_render,
+            allow_empty=allow_empty,
+        )
+
+    def to_html(self, ctx: AnySharedContext) -> str:
+        name = self.name
+        description = self.description
+        default = self._get_default_str(ctx)
+        return f'<input type="number" name="{name}" placeholder="{description}" value="{default}" />'  # noqa
+
+    def _parse_str_value(self, str_value: str) -> float:
+        return float(str_value)

zrb/input/int_input.py

@@ -0,0 +1,32 @@
+from zrb.attr.type import StrAttr
+from zrb.context.any_shared_context import AnySharedContext
+from zrb.input.base_input import BaseInput
+
+
+class IntInput(BaseInput):
+    def __init__(
+        self,
+        name: str,
+        description: str | None = None,
+        prompt: str | None = None,
+        default_str: StrAttr = "0",
+        auto_render: bool = True,
+        allow_empty: bool = True,
+    ):
+        super().__init__(
+            name=name,
+            description=description,
+            prompt=prompt,
+            default_str=default_str,
+            auto_render=auto_render,
+            allow_empty=allow_empty,
+        )
+
+    def to_html(self, ctx: AnySharedContext) -> str:
+        name = self.name
+        description = self.description
+        default = self._get_default_str(ctx)
+        return f'<input type="number" step="1" name="{name}" placeholder="{description}" value="{default}" />'  # noqa
+
+    def _parse_str_value(self, str_value: str) -> int:
+        return int(str_value)

zrb/input/option_input.py

@@ -0,0 +1,51 @@
+from zrb.attr.type import StrAttr, StrListAttr
+from zrb.context.any_shared_context import AnySharedContext
+from zrb.input.base_input import BaseInput
+from zrb.util.attr import get_str_list_attr
+
+
+class OptionInput(BaseInput):
+    def __init__(
+        self,
+        name: str,
+        description: str | None = None,
+        prompt: str | None = None,
+        options: StrListAttr = [],
+        default_str: StrAttr = "",
+        auto_render: bool = True,
+        allow_empty: bool = True,
+    ):
+        super().__init__(
+            name=name,
+            description=description,
+            prompt=prompt,
+            default_str=default_str,
+            auto_render=auto_render,
+            allow_empty=allow_empty,
+        )
+        self._options = options
+
+    def to_html(self, ctx: AnySharedContext) -> str:
+        name = self.name
+        description = self.description
+        default = self._get_default_str(ctx)
+        html = [f'<select name="{name}" placeholder="{description}">']
+        for value in get_str_list_attr(ctx, self._options, self._auto_render):
+            selected = "selected" if value == default else ""
+            html.append(f'<option value="{value}" {selected}>{value}</option>')
+        html.append("</select>")
+        return "\n".join(html)
+
+    def _prompt_cli_str(self, shared_ctx: AnySharedContext) -> str:
+        prompt_message = self.prompt_message
+        default_value = self._get_default_str(shared_ctx)
+        options = get_str_list_attr(shared_ctx, self._options, self._auto_render)
+        option_str = ", ".join(options)
+        if default_value != "":
+            prompt_message = f"{prompt_message} ({option_str}) [{default_value}]"
+        value = input(f"{prompt_message}: ")
+        if value.strip() != "" and value.strip() not in options:
+            value = self._prompt_cli_str(shared_ctx)
+        if value.strip() == "":
+            value = default_value
+        return value

zrb/input/password_input.py

@@ -0,0 +1,40 @@
+import getpass
+from collections.abc import Callable
+
+from zrb.context.any_shared_context import AnySharedContext
+from zrb.input.base_input import BaseInput
+
+
+class PasswordInput(BaseInput):
+    def __init__(
+        self,
+        name: str,
+        description: str | None = None,
+        prompt: str | None = None,
+        default_str: str | Callable[[AnySharedContext], str] = "",
+        auto_render: bool = True,
+        allow_empty: bool = True,
+    ):
+        super().__init__(
+            name=name,
+            description=description,
+            prompt=prompt,
+            default_str=default_str,
+            auto_render=auto_render,
+            allow_empty=allow_empty,
+        )
+        self._is_secret = True
+
+    def to_html(self, ctx: AnySharedContext) -> str:
+        name = self.name
+        description = self.description
+        default = self._get_default_str(ctx)
+        return f'<input type="password" name="{name}" placeholder="{description}" value="{default}" />'  # noqa
+
+    def _prompt_cli_str(self, shared_ctx: AnySharedContext) -> str:
+        prompt_message = self.prompt_message
+        default_value = self._get_default_str(shared_ctx)
+        value = getpass.getpass(f"{prompt_message}: ")
+        if value.strip() == "":
+            value = default_value
+        return value

zrb/input/str_input.py

@@ -0,0 +1,5 @@
+from zrb.input.base_input import BaseInput
+
+
+class StrInput(BaseInput):
+    pass