dothat 1.0.0__py3-none-any.whl

dothat/VERSION

@@ -0,0 +1,2 @@
+1.0.0
+

dothat/__init__.py

@@ -0,0 +1,9 @@
+from dothat.models.actions import InteractivePythonAction, InteractiveShlex
+from dothat.models.params import Param, Params
+
+__all__ = (
+    "InteractivePythonAction",
+    "InteractiveShlex",
+    "Params",
+    "Param",
+)

dothat/cli.py

@@ -0,0 +1,97 @@
+import builtins
+import dataclasses
+import pathlib
+
+import click
+import injector
+
+from dothat.di import Module
+from dothat.logging import logger as LOGGER
+from dothat.registry import TaskRegistry
+from dothat.task_builder import Task
+
+
+@dataclasses.dataclass
+class DothatContext:
+    di: injector.Injector
+
+
+def get_registry(di: injector.Injector, module: str | None) -> dict[str, Task]:
+    if module:
+        return di.get(TaskRegistry).load_tasks_from_module(module)
+    return di.get(TaskRegistry).tasks
+
+
+@click.group()
+@click.option(
+    "--config",
+    type=pathlib.Path,
+    envvar="ENVIRONMENT_TOML_PATH",
+    default=pathlib.Path(
+        "environment.toml",
+    ),
+)
+@click.pass_context
+def cli(ctx: click.Context, config: pathlib.Path):
+    ctx.obj = DothatContext(di=injector.Injector([Module(config_path=config)]))
+
+
+@cli.command()
+@click.option("--module", default=None)
+@click.pass_obj
+def list(dothat_context: DothatContext, module: str | None):
+    _registry = get_registry(dothat_context.di, module)
+
+    for key, task in _registry.items():
+        click.echo(f"R {key:<50} {task.doc}")
+
+
+@cli.command()
+@click.argument("task_name")
+@click.option("--module", default=None)
+@click.pass_obj
+def help(dothat_context: DothatContext, task_name: str, module: str):
+    _registry = get_registry(di=dothat_context.di, module=module)
+
+    task = _registry[task_name]
+
+    click.echo(f"{task_name}  {task.doc}")
+
+    for param in task.params:
+        description: builtins.list[str] = [f"config: {param.name}"]
+
+        if param.env_var:
+            description.append(f"environ: {param.env_var}")
+        if param.type is bool and param.inverse:
+            description.append(f"opposite of {param.inverse}")
+
+        click.echo(f"  --{param.long:<30} ({', '.join(description)})")
+
+
+@cli.command(
+    context_settings={
+        "ignore_unknown_options": True,
+        "allow_extra_args": True,
+    }
+)
+@click.argument("task_name")
+@click.pass_context
+@click.option("--module", default=None)
+def run(ctx: click.Context, task_name: str, module: str | None):
+    _registry = get_registry(di=ctx.obj.di, module=module)
+
+    task = _registry.get(task_name)
+
+    if task is None:
+        raise click.ClickException(f"Unknown task: {task_name}")
+    task = task.model_copy(deep=True)
+
+    task.parse_task_params(args=ctx.args, di=ctx.obj.di)
+
+    LOGGER.debug(f"running task: {task.basename}")
+
+    task.exec_task(inj=ctx.obj.di)
+
+
+if __name__ == "__main__":
+    cli()

dothat/default_tasks/__init__.py

@@ -0,0 +1,3 @@
+from dothat.default_tasks._tasks import CiTaskGenerator
+
+__all__ = ("CiTaskGenerator",)

dothat/default_tasks/_actions.py

@@ -0,0 +1,8 @@
+from dothat.initialization import TemplateGenerator
+from dothat.models.actions import InteractivePythonAction
+
+
+class InitializeDefaultProject(InteractivePythonAction):
+    def impl(self, *, force: bool, **_) -> None:
+        templategenerator = TemplateGenerator()
+        templategenerator.generate_project_structure(force=force)

dothat/default_tasks/_params.py

@@ -0,0 +1,11 @@
+from dothat.models.params import Param
+
+
+def force() -> Param:
+    return Param(
+        name="force",
+        long="force",
+        short="f",
+        default=False,
+        type=bool,
+    )

dothat/default_tasks/_tasks.py

@@ -0,0 +1,19 @@
+from collections.abc import Iterator
+
+from dothat.default_tasks import _actions, _params
+from dothat.task_builder import Task, TaskBuilderImpl
+from dothat.task_generator import TaskGeneratorImpl
+
+
+class InitializeDefaultProject(TaskBuilderImpl):
+    _basename = "init"
+
+    def apply(self):
+        return self.with_actions((_actions.InitializeDefaultProject,)).with_params((_params.force(),))
+
+
+class CiTaskGenerator(TaskGeneratorImpl):
+    task_init = InitializeDefaultProject
+
+    def load_tasks(self) -> Iterator[Task]:
+        yield from super().load_tasks()

dothat/di.py

@@ -0,0 +1,27 @@
+import pathlib
+
+import injector
+
+from dothat.models.params import Params
+from dothat.project_config import ProjectConfig
+from dothat.registry import TaskRegistry
+
+
+class ConfigPath:
+    def __init__(self, path: pathlib.Path) -> None:
+        self.path = path
+
+
+class Module(injector.Module):
+    def __init__(self, config_path: pathlib.Path = pathlib.Path("environment.toml")) -> None:
+        self.config_path = config_path
+
+    def configure(self, binder: injector.Binder) -> None:
+        binder.bind(ConfigPath, to=ConfigPath(self.config_path))
+        binder.bind(TaskRegistry, scope=injector.singleton)
+        binder.bind(Params, scope=injector.singleton)
+
+    @injector.singleton
+    @injector.provider
+    def provide_config(self, cfg_path: ConfigPath) -> ProjectConfig:
+        return ProjectConfig.from_file(cfg_path.path)

dothat/initialization/__init__.py

@@ -0,0 +1,45 @@
+import pathlib
+import shutil
+from importlib.resources import as_file, files
+
+from dothat.logging import logger as LOGGER
+
+
+class TemplateGenerator:
+    def generate_project_structure(
+        self,
+        destination: pathlib.Path = pathlib.Path("."),
+        force: bool = False,
+    ) -> None:
+        template = files("dothat.initialization") / "templates"
+
+        LOGGER.info("Copying project template from {}", template)
+
+        with as_file(template) as template_path:
+            self._copy_template(
+                template_path,
+                destination,
+                force=force,
+            )
+
+    @staticmethod
+    def _copy_template(
+        source: pathlib.Path,
+        destination: pathlib.Path,
+        *,
+        force: bool,
+    ) -> None:
+        for source_path in source.rglob("*"):
+            relative_path = source_path.relative_to(source)
+            destination_path = destination / relative_path
+
+            if source_path.is_dir():
+                destination_path.mkdir(parents=True, exist_ok=True)
+                continue
+
+            if destination_path.exists() and not force:
+                LOGGER.debug("Skipping existing file: {}", destination_path)
+                continue
+
+            destination_path.parent.mkdir(parents=True, exist_ok=True)
+            shutil.copy2(source_path, destination_path)

dothat/initialization/templates/_tasks/__init__.py

@@ -0,0 +1,3 @@
+from _tasks._tasks import TaskGenerator
+
+__all__ = ("TaskGenerator",)

dothat/initialization/templates/_tasks/_actions.py

@@ -0,0 +1,38 @@
+import pathlib
+import typing
+
+from dothat import InteractivePythonAction, InteractiveShlex
+
+
+class SetupSsh(InteractivePythonAction):
+    def impl(self, **_):
+        ssh_private_key = "123"
+
+        ssh_dir = pathlib.Path("/root/.ssh")
+        ssh_dir.mkdir(exist_ok=True)
+        ssh_dir.chmod(0o600)
+
+        private_key_file = ssh_dir / "id_ci"
+        private_key_file.write_text(ssh_private_key)
+        private_key_file.chmod(0o600)
+
+        ssh_config_file = ssh_dir / "config"
+        ssh_config_data = [
+            "Host gl.pivlab.dev",
+            "    IdentityFile /root/.ssh/id_ci",
+            "    IdentitiesOnly yes",
+            "    StrictHostKeyChecking no",
+            "    UserKnownHostsFile /dev/null",
+        ]
+        ssh_config_file.write_text("\n".join(ssh_config_data))
+        ssh_config_file.chmod(0o644)
+
+
+class SetupGitInsteadOf(InteractiveShlex):
+    def impl(self, **_: typing.Any) -> list[list[str]]:
+
+        return [
+            ["git", "config", "--global", "user.email", "ci@pivlab.space"],
+            ["git", "config", "--global", "user.name", "CI"],
+            ["git", "config", "--global", "init.defaultBranch", "master"],
+        ]

dothat/initialization/templates/_tasks/_consts.py

@@ -0,0 +1,5 @@
+from enum import Enum
+
+
+class Tasks(Enum):
+    test_task = "test-task"

dothat/initialization/templates/_tasks/_params.py

@@ -0,0 +1,20 @@
+from dothat import Param
+
+
+def flavor() -> Param:
+    return Param(
+        name="flavor",
+        long="flavor",
+        default="release",
+        type=str,
+    )
+
+
+def insecure() -> Param:
+    return Param(
+        name="insecure",
+        long="insecure",
+        default=False,
+        type=bool,
+        inverse="secure",
+    )

dothat/initialization/templates/_tasks/_tasks.py

@@ -0,0 +1,39 @@
+from collections.abc import Iterator
+
+from _tasks import _actions, _params
+from _tasks._consts import Tasks
+from dothat.task_builder import Task, TaskBuilderImpl
+from dothat.task_generator import TaskGeneratorImpl
+
+
+class TestBaseTask(TaskBuilderImpl):
+    _basename = Tasks.test_task
+
+    def apply(self):
+        self.model.doc = "test task"
+        self.with_actions((_actions.SetupSsh,))
+        return self
+
+
+class TaskGenerator(TaskGeneratorImpl):
+    task_generate_docs = TestBaseTask
+
+    def load_tasks(self) -> Iterator[Task]:
+        yield from super().load_tasks()
+
+        targets = self._config.extra.get("targets", [])
+
+        for target in targets:
+            yield (
+                self.builder(TestBaseTask)
+                .apply()
+                .with_name(target)
+                .with_params(
+                    (
+                        self._params.ci(),
+                        _params.flavor(),
+                        _params.insecure(),
+                    )
+                )
+                .build()
+            )

dothat/logging.py

@@ -0,0 +1,30 @@
+import sys
+
+from loguru import logger
+
+
+def setup_logger(debug: bool = False) -> None:
+    logger.remove()
+
+    level = "DEBUG" if debug else "INFO"
+
+    logger.add(
+        sys.stdout,
+        level=level,
+        colorize=True,
+        format=(
+            "<green>{time:YYYY-MM-DD HH:mm:ss}</green> | "
+            "<level>{level: <8}</level> | "
+            "<cyan>{name}</cyan>:"
+            "<cyan>{function}</cyan>:"
+            "<cyan>{line}</cyan> - "
+            "<level>{message}</level>"
+        ),
+        backtrace=True,
+        diagnose=debug,
+    )
+
+
+setup_logger(debug=True)
+
+__all__ = ["logger"]

dothat/models/__init__.py

@@ -0,0 +1,9 @@
+from dothat.models.actions import InteractivePythonAction, InteractiveShlex
+from dothat.models.params import Param, Params
+
+__all__ = (
+    "InteractivePythonAction",
+    "InteractiveShlex",
+    "Params",
+    "Param",
+)

dothat/models/actions.py

@@ -0,0 +1,54 @@
+import dataclasses
+import shlex
+import subprocess
+import typing
+from abc import ABC, abstractmethod
+from collections.abc import Iterable
+
+import injector
+
+from dothat.logging import logger as LOGGER
+from dothat.project_config import ProjectConfig
+
+ActionResult = typing.Any
+
+
+@injector.inject
+@dataclasses.dataclass
+class ActionBuilderImpl(ABC):
+    _di: injector.Injector
+    _config: ProjectConfig
+
+    @abstractmethod
+    def impl(self, **kwargs: typing.Any) -> ActionResult: ...
+
+    @abstractmethod
+    def execute(self, **kwargs: typing.Any): ...
+
+
+class InteractivePythonAction(ActionBuilderImpl):
+    @typing.override
+    def impl(self, **kwargs: typing.Any) -> None:
+        raise NotImplementedError
+
+    @typing.override
+    def execute(self, **kwargs: typing.Any) -> None:
+        LOGGER.debug(f"running InteractivePythonAction action: {self.__class__.__name__}")
+        self.impl(**kwargs)
+
+
+class InteractiveShlex(ActionBuilderImpl):
+    @typing.override
+    def impl(self, **kwargs: typing.Any) -> Iterable[list[str]]:
+        raise NotImplementedError
+
+    @typing.override
+    def execute(self, **kwargs: typing.Any) -> None:
+        LOGGER.debug(f"running InteractiveShlex action: {self.__class__.__name__}")
+
+        commands = [shlex.join(cmd) for cmd in self.impl(**kwargs)]
+
+        script = " && ".join(commands)
+
+        LOGGER.info("running: {}", script)
+        subprocess.run(script, shell=True, check=True)

dothat/models/params.py

@@ -0,0 +1,42 @@
+import dataclasses
+import typing
+
+import injector
+import pydantic
+
+from dothat.project_config import ProjectConfig
+
+
+class Param(pydantic.BaseModel):
+    name: str
+    default: typing.Any = None
+    long: str
+
+    short: typing.Optional[str] = ""
+    type: typing.Callable[[typing.Any], typing.Any] = lambda x: x
+    help: typing.Optional[str] = None
+    env_var: typing.Optional[str] = None
+    inverse: typing.Optional[str] = None
+
+
+@injector.inject
+@dataclasses.dataclass
+class Params:
+    config: ProjectConfig
+
+    def ci(self):
+        return Param(
+            name="ci",
+            long="ci",
+            type=bool,
+            default=False,
+            env_var="CI",
+        )
+
+    def from_config(self, key: str, **kwargs):
+        return Param(
+            name=f"extra__{key}",
+            long=key.replace("_", "-"),
+            default=(self.config.extra.model_extra or {}).get(key),
+            **kwargs,
+        )

dothat/project_config/__init__.py

@@ -0,0 +1,46 @@
+import pathlib
+import tomllib
+import typing
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from dothat.logging import logger as LOGGER
+
+
+class System(BaseModel):
+    tasks_module: typing.Optional[str] = None
+
+
+class Extra(BaseModel):
+    model_config = ConfigDict(extra="allow")
+
+    system: System = Field(default_factory=System)
+
+    def __getitem__(self, key: str) -> typing.Any:
+
+        if self.model_extra is None:
+            raise KeyError(key)
+
+        return self.model_extra[key]
+
+    def get(self, key: str, default: typing.Any = None) -> typing.Any:
+        return (self.model_extra or {}).get(key, default)
+
+
+class ProjectConfig(BaseModel):
+    @classmethod
+    def from_file(
+        cls,
+        path: pathlib.Path = pathlib.Path("environment.toml"),
+    ) -> "ProjectConfig":
+        if not path.exists():
+            LOGGER.debug("ProjectConfig is not provided: file is not exists")
+            data = {}
+        else:
+            data = tomllib.loads(path.read_text())
+
+        _cfg = cls.model_validate(data)
+
+        return _cfg
+
+    extra: Extra = Field(default_factory=Extra)

dothat/registry.py

@@ -0,0 +1,80 @@
+import importlib.util
+import pathlib
+import sys
+
+import injector
+
+from dothat.default_tasks import CiTaskGenerator
+from dothat.logging import logger as LOGGER
+from dothat.project_config import ProjectConfig
+from dothat.task_builder import Task
+from dothat.task_generator import TaskGenerator
+
+
+class TaskRegistry:
+    @injector.inject
+    def __init__(self, config: ProjectConfig, di: injector.Injector) -> None:
+        self._di = di
+        self._config = config
+
+        self._tasks: dict[str, Task] | None = None
+
+    def _load_module(self, module: str):
+
+        module_path = pathlib.Path(module)
+
+        LOGGER.debug(f"Tasks loaded from module: {module_path}")
+
+        if module_path.is_file():
+            module_name = module_path.stem
+
+            spec = importlib.util.spec_from_file_location(module_name, module_path)
+            if spec is None or spec.loader is None:
+                raise ImportError(f"Could not load module from {module_path}")
+
+            module_obj = importlib.util.module_from_spec(spec)
+            sys.modules[module_name] = module_obj
+            spec.loader.exec_module(module_obj)
+            return module_obj
+
+        sys.path.insert(0, str(module_path.parent))
+
+        try:
+            module_obj = __import__(module, fromlist=["TaskGenerator"])
+        finally:
+            sys.path.remove(str(module_path.parent))
+
+        return module_obj
+
+    def _load_tasks_from_generator(self, generator: TaskGenerator) -> dict[str, Task]:
+        registry: dict[str, Task] = {}
+
+        for task in generator.load_tasks():
+            if not task.basename:
+                raise ValueError("Task basename is not set.")
+            taskname = task.basename if not task.name else ":".join([task.basename, task.name])
+            registry[taskname] = task
+
+        return registry
+
+    def load_tasks_from_module(self, module: str | None) -> dict[str, Task]:
+        if not module:
+            LOGGER.warning("module with tasks not found")
+            return {}
+
+        module_obj = self._load_module(module)
+
+        generator: TaskGenerator = self._di.create_object(module_obj.TaskGenerator)
+
+        registry: dict[str, Task] = self._load_tasks_from_generator(generator)
+
+        return registry
+
+    @property
+    def tasks(self) -> dict[str, Task]:
+        if self._tasks is None:
+            self._tasks = {
+                **self.load_tasks_from_module(self._config.extra.system.tasks_module),
+                **self._load_tasks_from_generator(self._di.create_object(CiTaskGenerator)),
+            }
+        return self._tasks

dothat/task_builder.py

@@ -0,0 +1,138 @@
+import dataclasses
+import os
+import typing
+from collections.abc import Iterable
+from enum import Enum
+
+import injector
+import pydantic
+
+from dothat.models.actions import ActionBuilderImpl
+from dothat.models.params import Param, Params
+from dothat.project_config import ProjectConfig
+
+
+class Task(pydantic.BaseModel):
+    basename: typing.Optional[str] = None
+
+    name: typing.Optional[str] = None
+
+    doc: str = ""
+
+    actions: typing.Optional[list[type["ActionBuilderImpl"]]] = None
+
+    parsed_params: dict[str, typing.Any] = {}
+
+    params: list[Param] = pydantic.Field(default_factory=lambda: [])
+
+    def parse_task_params(self, args: list[str], di: injector.Injector):
+        _config = di.get(ProjectConfig)
+
+        if _config.extra.model_extra:
+            for key, val in _config.extra.model_extra.items():
+                self.parsed_params[f"extra__{key}"] = val
+
+        args_iter = iter(args)
+
+        for arg in args_iter:
+            if arg.startswith("--"):
+                key = arg.removeprefix("--")
+                param = next(
+                    (p for p in self.params if key in [p.long, p.inverse]),
+                    None,
+                )
+            elif arg.startswith("-"):
+                key = arg.removeprefix("-")
+                param = next(
+                    (p for p in self.params if key in [p.short, p.inverse]),
+                    None,
+                )
+            else:
+                continue
+
+            if not param:
+                raise ValueError(f"Unknown parameter: --{key}")
+
+            if param.type is bool:
+                self.parsed_params[param.name] = True if key == param.long or key == param.short else False
+                continue
+
+            try:
+                value = next(args_iter)
+            except StopIteration as err:
+                raise StopIteration from err
+
+            self.parsed_params[param.name] = param.type(value)
+
+    def exec_task(self, inj: injector.Injector):
+        if not self.actions:
+            raise RuntimeError("not found actions to execute.")
+        for action_cls in self.actions:
+            action = inj.create_object(action_cls)
+            action.execute(**self.parsed_params)
+
+
+class TaskBulder:
+    def build(self) -> Task:
+        raise NotImplementedError
+
+
+@injector.inject
+@dataclasses.dataclass
+class TaskBuilderImpl(TaskBulder):
+    _basename: typing.ClassVar[str | Enum | None] = None
+
+    _params: Params
+    _config: ProjectConfig
+
+    model: Task = dataclasses.field(init=False, default_factory=Task)
+
+    def __post_init__(self):
+        "extension point for childs"
+
+    def apply(self):
+        return self
+
+    def build(self) -> Task:
+        if not self._basename:
+            raise ValueError("task name not set.")
+
+        if not self.model.doc:
+            self.model.doc = ".".join(
+                [
+                    self.__class__.__module__,
+                    self.__class__.__name__,
+                ]
+            )
+
+        if isinstance(self._basename, str):
+            self.model.basename = self._basename
+        else:
+            self.model.basename = self._basename.value
+
+        return self.model.model_copy(deep=True)
+
+    def with_actions(self, actions: Iterable[type[ActionBuilderImpl]]):
+        self.model.actions = list(actions)
+        return self
+
+    def with_params(self: typing.Self, params: Iterable[Param]) -> typing.Self:
+        self.model.params = list(params)
+
+        params_dict = {}
+        for param in params:
+            params_dict[param.name] = os.getenv(param.env_var, param.default) if param.env_var else param.default
+        self.model.parsed_params = params_dict
+
+        return self
+
+    def replace_param(self, param_name: str, param: str, default: str):
+        self.model.parsed_params[param_name] = param or default
+
+    def with_name(self, name: str):
+        self.model.name = name
+        return self
+
+    def with_doc(self, doc: str):
+        self.model.doc = doc
+        return self

dothat/task_generator.py

@@ -0,0 +1,32 @@
+import dataclasses
+from collections.abc import Iterator
+
+import injector
+
+from dothat.models.params import Params
+from dothat.project_config import ProjectConfig
+from dothat.task_builder import Task, TaskBuilderImpl
+
+
+class TaskGenerator:
+    def load_tasks(self) -> Iterator[Task]:
+        raise NotImplementedError
+
+
+@injector.inject
+@dataclasses.dataclass
+class TaskGeneratorImpl(TaskGenerator):
+    _config: ProjectConfig
+    _di: injector.Injector
+    _params: Params
+
+    def _auto_load_tasks(self) -> Iterator[Task]:
+        for name, cls in vars(type(self)).items():
+            if name.startswith("task_") and isinstance(cls, type) and issubclass(cls, TaskBuilderImpl):
+                yield self._di.create_object(cls).apply().build()
+
+    def builder(self, task_class: type[TaskBuilderImpl]) -> TaskBuilderImpl:
+        return self._di.create_object(task_class)
+
+    def load_tasks(self) -> Iterator[Task]:
+        yield from self._auto_load_tasks()

dothat/tasks_core/default_tasks/__init__.py

@@ -0,0 +1,3 @@
+from dothat.tasks_core.default_tasks._tasks import CiTaskGenerator
+
+__all__ = ("CiTaskGenerator",)

dothat/tasks_core/default_tasks/_actions.py

@@ -0,0 +1,8 @@
+from dothat.initialization import TemplateGenerator
+from dothat.models.actions import InteractivePythonAction
+
+
+class InitializeDefaultProject(InteractivePythonAction):
+    def impl(self, *, force: bool, **_) -> None:
+        templategenerator = TemplateGenerator()
+        templategenerator.generate_project_structure(force=force)

dothat/tasks_core/default_tasks/_params.py

@@ -0,0 +1,11 @@
+from dothat.models.params import Param
+
+
+def force() -> Param:
+    return Param(
+        name="force",
+        long="force",
+        short="f",
+        default=False,
+        type=bool,
+    )

dothat/tasks_core/default_tasks/_tasks.py

@@ -0,0 +1,19 @@
+from collections.abc import Iterator
+
+from dothat.default_tasks import _actions, _params
+from dothat.task_builder import Task, TaskBuilderImpl
+from dothat.task_generator import TaskGeneratorImpl
+
+
+class InitializeDefaultProject(TaskBuilderImpl):
+    _basename = "init"
+
+    def apply(self):
+        return self.with_actions((_actions.InitializeDefaultProject,)).with_params((_params.force(),))
+
+
+class CiTaskGenerator(TaskGeneratorImpl):
+    task_init = InitializeDefaultProject
+
+    def load_tasks(self) -> Iterator[Task]:
+        yield from super().load_tasks()

dothat-1.0.0.dist-info/METADATA

@@ -0,0 +1,13 @@
+Metadata-Version: 2.5
+Name: dothat
+Version: 1.0.0
+Summary: framework for python tasks and actions management
+Author: PivLab Dev
+Author-email: Arsenii Nikulin <a.nikulin@pivlab.dev>
+License-Expression: MIT
+Requires-Python: <4.0,>=3.11
+Requires-Dist: click<9.0.0,>=8.4.1
+Requires-Dist: gitpython<4.0.0,>=3.1.57
+Requires-Dist: injector>=0.24.0
+Requires-Dist: loguru<1.0.0,>=0.7.3
+Requires-Dist: pydantic>=2.13.5

dothat-1.0.0.dist-info/RECORD

@@ -0,0 +1,31 @@
+dothat/VERSION,sha256=kCdyz2boWiSkwz3wg3LS5QBAw2Xv-U-KfPDjGD_hFA8,7
+dothat/__init__.py,sha256=WEq5tua40pi2jkROw7gdy6wfCuUwbkwaTdCakzoDcJc,220
+dothat/cli.py,sha256=JiFVlL9kXuT5BWzyURhG3N5ylRtStga7k_sRG8yXz04,2470
+dothat/di.py,sha256=Bc5XhQnmwhAezBNRA1T048fIlvQLGSY0mLxAb36kiwk,834
+dothat/logging.py,sha256=TB-wD9c-9BE68TjKWIsqAD-t0_5tLNJVGIfh5N2uBWQ,614
+dothat/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dothat/registry.py,sha256=CRB8xwkJEEmr0OmvRxmt3k83HhnSff5MQj_X1XtwUeY,2572
+dothat/task_builder.py,sha256=ocCn06IUHtCgx093HEZDIGMUdMrpvsULL3lXe4V0LR8,3986
+dothat/task_generator.py,sha256=uXD8mEuh9W7H2V8DJqO2uZRjwOt3xWoU8YVU9QKgrps,961
+dothat/default_tasks/__init__.py,sha256=6P4Tc1g2VfGMgda0Mnp8XW3rnNHGPZFkqF0Zk1pVYKU,88
+dothat/default_tasks/_actions.py,sha256=FsgiPLgqsDPjmSa21SpFp83cahyhF8lAEXTfyTyHcQA,332
+dothat/default_tasks/_params.py,sha256=5HC5tcUMuL8MfIhhqsVy7t1ywuJHtQUbJEqXhP2oF8w,192
+dothat/default_tasks/_tasks.py,sha256=OJNB5ETwgczz-RAmTPs2IoKSpuY3-BFRwnP3qdRDiyQ,564
+dothat/initialization/__init__.py,sha256=pLi5z1N7HvNBHz3ALgeoni7Ygc2vProVAKxQN-HU3LU,1352
+dothat/initialization/templates/_tasks/__init__.py,sha256=CmrPc4x2IIMOMf40IaOvRasn_XNv-9-Z0f7XaEssj5s,70
+dothat/initialization/templates/_tasks/_actions.py,sha256=oD7IXDXYUhOgllEH-gFRugQtpdi3nUBZLxjfErCecaQ,1179
+dothat/initialization/templates/_tasks/_consts.py,sha256=OkA0lWfASFIy_zGMz7B4C3e8pbjwI1o9XICD7xWIH8M,71
+dothat/initialization/templates/_tasks/_params.py,sha256=6wdaki-Qf4W00zptnp4MiH5KLby4M7pDzMISTu1qeOE,334
+dothat/initialization/templates/_tasks/_tasks.py,sha256=F2wg0Msq_ttR98UIneyJa5Yyx94WKlpE4HHtly-j0dc,1049
+dothat/models/__init__.py,sha256=WEq5tua40pi2jkROw7gdy6wfCuUwbkwaTdCakzoDcJc,220
+dothat/models/actions.py,sha256=HHPSyZ7hDBpDLCHHTLk1FM75L8DLzPrYctBegpB8LsU,1436
+dothat/models/params.py,sha256=QEpPIF55Um7kT-rCZTIZEGdrklqB96LzeSosxZ911Hc,932
+dothat/project_config/__init__.py,sha256=SKOoOGwVdguF-qMpjt78zj2vKuJ2Z9cgp_5jbMNhang,1104
+dothat/tasks_core/default_tasks/__init__.py,sha256=hgIPX6gdJ8hK7-r_A_zVL3E7uywXiX6DqCc2PNi3QvU,99
+dothat/tasks_core/default_tasks/_actions.py,sha256=FsgiPLgqsDPjmSa21SpFp83cahyhF8lAEXTfyTyHcQA,332
+dothat/tasks_core/default_tasks/_params.py,sha256=5HC5tcUMuL8MfIhhqsVy7t1ywuJHtQUbJEqXhP2oF8w,192
+dothat/tasks_core/default_tasks/_tasks.py,sha256=OJNB5ETwgczz-RAmTPs2IoKSpuY3-BFRwnP3qdRDiyQ,564
+dothat-1.0.0.dist-info/METADATA,sha256=YNasljhwwo4Wh6AEDK7wTSRn2AtYN2ndyrgUP18fAog,409
+dothat-1.0.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+dothat-1.0.0.dist-info/entry_points.txt,sha256=W0NBUdOfdU2VlnszHrvxUG_Zb1zYgF5iZxnZEy_a1Z8,42
+dothat-1.0.0.dist-info/RECORD,,

dothat-1.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

dothat-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+dothat = dothat.cli:cli