tgzr.cuisine 0.0.1__py3-none-any.whl

tgzr/cuisine/plugin.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING, Type
+
+from tgzr.package_management.plugin_manager import Plugin, PluginManager
+
+
+if TYPE_CHECKING:
+    from .recipe import Recipe
+
+
+class CuisinePlugin(Plugin):
+    @classmethod
+    def plugin_type_name(cls) -> str:
+        return "PipelinePlugin"
+
+    def get_recipe_types(self) -> list[Type[Recipe]]:
+        return []
+
+
+class CuisinePluginManager(PluginManager[CuisinePlugin]):
+
+    EP_GROUP = "tgzr.cuisine.plugin"
+
+
+# NB: we use a "global" plugin manager so it is automatically
+# picked up by `tgzr plugins ls`:
+cuisine_plugin_manager = CuisinePluginManager()

tgzr/cuisine/recipe.py

@@ -0,0 +1,361 @@
+from __future__ import annotations
+from typing import Type, TypeVar
+
+from pathlib import Path
+import dataclasses
+import datetime
+import importlib
+
+import toml
+
+from tgzr.package_management.pyproject import (
+    PyProject,
+    save_pyproject,
+    BuildSystem,
+    Project,
+    Tools,
+    ToolHatch,
+    ToolHatchVersion,
+)
+
+
+@dataclasses.dataclass
+class RecipeTypeInfo:
+    type_name: str | None = None  # only needed if it's not the class name
+    category: str | None = None  # just for UIs (None means hidden category)
+    color: str | None = None  # html format
+    icon: str | None = None  # one of the google-font or fontawesome icons
+
+
+@dataclasses.dataclass
+class RecipeMetadata:
+    name: str
+    type_name: str
+    inputs: dict[str | None, list[str]] = dataclasses.field(default_factory=dict)
+    # Note: we should use a set for tags, but a set get converted to a list when savec in toml so:
+    tags: list[str] = dataclasses.field(default_factory=list)
+
+    @classmethod
+    def create_default(cls, name: str, type_name: str):
+        return cls(
+            name=name,
+            type_name=type_name,
+        )
+
+    @classmethod
+    def from_toml(cls, toml_path: Path):
+        asset_data = toml.load(toml_path)
+        return cls(**asset_data)
+
+    def write_toml(self, toml_path: Path):
+        toml_path.write_text(toml.dumps(dataclasses.asdict(self)))
+        print(f"Recipe {self.name} Metadata saved to {toml_path}")
+
+
+class RecipeControler:
+    """
+    This object contains methods that would totally fit in the Recipe interface,
+    but are kept separated to keep the Recipe namespace as empty as possible.
+
+    It makes subclassing a little bit harder, but only for subclasses that
+    are changing the relation between the Chef and the Recipe (which should
+    not be often outside of tgzr.cuisine, if we designed thing right :p)
+    """
+
+    @classmethod
+    def default_dinit_content(cls, RecipeType: Type[Recipe]) -> str:
+        cls_module = RecipeType.__module__
+        cls_name = RecipeType.__name__
+
+        return f"""
+from {cls_module} import {cls_name}
+
+recipe = {cls_name}(__file__)
+    
+def cook() -> None:
+    recipe.cook()
+
+    """
+
+    @classmethod
+    def init_recipe_files(cls, recipe: Recipe, dinit_file: Path) -> None:
+        """
+        This is called by the chef after it created a new
+        reciep.
+        Subclasses may override this to add more files inside the
+        recipe package.
+        """
+        pass
+
+    @classmethod
+    def make_pyproject(cls, recipe: Recipe) -> PyProject:
+        metadata = cls.read_metadata(recipe)
+        pyproject = PyProject()
+
+        name = recipe.name  # this is the coninical package name
+        pyproject.project = project = Project()
+        project.name = name
+        project.dynamic = ["version"]
+        project.description = f"{metadata.name} - a Recipe created with tgzr.cuisine."
+        project.readme = "README.md"
+        project.dependencies = ["tgzr.cuisine"] + metadata.inputs.get(None, [])
+        # TODO: add extra input groups too!
+
+        # All Recipe have a cook() method
+        project.scripts[name] = f"{name}:cook"
+
+        project.classifiers = [
+            # We use classifiers as searchable hierarchy in private indexes. Must be stable.
+            # /!\ when building the package, we need HATCH_METADATA_CLASSIFIERS_NO_VERIFY env var to be set
+            # or these custom classifiers will be rejected.
+            "Private :: Do Not Upload",  # prevents accidental upload to PyPI
+            "Framework :: tgzr.cuisine",
+            f"RecipeType :: {metadata.type_name}",
+        ]
+        project.keywords = [
+            # We use keywords for fine search in private indexes. Can be arbitrary.
+            f"tgzr.cuisine.recipe_name:{metadata.name}",
+            f"tgzr.cuisine.recipe_type_name:{metadata.type_name}",
+            *[
+                f"tgzr.cuisine.tags:{tag}" for tag in metadata.tags
+            ],  # TODO: ensure tag are alpha+alphanum only ! (or valid identifiers)
+        ]
+        project.entry_points = {
+            # Gives the hability to discover all installed Recipes of a given (final) type in the venv:
+            f"tgzr.pipeline.{metadata.type_name}": {"recipe": f"{name}:recipe"},
+            #
+            # These ep is the source of truth when getting name and type from the Distribution
+            # (not the classifers or keywords)
+            # Also: it give the hability to discover all installed Recipe names and types:
+            "tgzr.pipeline.asset_info_trick": {
+                "recipe_name": metadata.name,
+                "recipe_type": metadata.type_name,
+            },
+        }
+
+        pyproject.build_system = BuildSystem(
+            requires=["hatchling"], build_backend="hatchling.build"
+        )
+
+        pyproject.tool = tool = Tools()
+        tool.hatch = ToolHatch()
+        # does not work in current version,
+        # might in next version,
+        # for now we still need to have the envvar HATCH_METADATA_CLASSIFIERS_NO_VERIFY set !
+        tool.hatch.metadata = {"allow-custom-classifiers": True}
+        tool.hatch.envs = {"default": {"installer": "uv"}}
+        tool.hatch.version = ToolHatchVersion(path=f"src/{name}/__version__.py")
+
+        panel_names = recipe.nice_panel_names()
+        if panel_names:
+            nice_panels_ep = project.entry_points["tgzr.pipeline.asset.nice_panel"] = {}
+            for panel_name in panel_names:
+                nice_panels_ep[panel_name] = f"{recipe.name}:recipe.{panel_name}"
+
+        return pyproject
+
+    @classmethod
+    def write_pyproject_to(cls, recipe: Recipe, pyproject_path: Path):
+        pyproject = cls.make_pyproject(recipe)
+        print("Saving pyproject to:", pyproject_path)
+        save_pyproject(pyproject, pyproject_path)
+
+    @classmethod
+    def is_editable(cls, recipe: Recipe) -> bool:
+        for parent in recipe._init_file.parents:
+            if (parent / "pyproject.toml").exists():
+                # FIXME: this could be a uv workspace pyproject !!!
+                return True
+        return False
+
+    @classmethod
+    def read_metadata(cls, recipe: Recipe) -> RecipeMetadata:
+        data = RecipeMetadata.from_toml(recipe._recipe_toml)
+        return data
+
+    @classmethod
+    def write_metadata(cls, recipe: Recipe, metadata: RecipeMetadata):
+        metadata.write_toml(recipe._recipe_toml)
+
+    @classmethod
+    def create_editable(
+        cls, recipe: Recipe, workbench_path: Path | str, force: bool = False
+    ):
+        if recipe.is_editable:
+            raise ValueError(
+                f"Are you sure you want to create an editable version of {recipe.name}? \n"
+                f"(it is already editable as {recipe._init_file})."
+            )
+
+        from .workbench import Workbench
+
+        workbench_path = Path(workbench_path)
+        wb = Workbench(workbench_path)
+        if wb.has_editable_recipe(recipe.name):
+            if not force:
+                raise ValueError(
+                    f"The Recipe {recipe.name} is already an editable in workbench {workbench_path}."
+                )
+            print(
+                f"Overridding editable Recipe {recipe.name} in workbench {workbench_path}"
+            )
+        else:
+            print(
+                f"Creating editable Recipe {recipe.name} in workbench {workbench_path}"
+            )
+
+        version = recipe.get_version()
+        metadata = cls.read_metadata(recipe)
+
+        wb.chef.create_recipe(
+            folder=wb._editable_path,
+            recipe_name=recipe.name,
+            recipe_metadata=metadata,
+            version=version,
+            recipe_type_name=metadata.type_name,
+        )
+
+
+RecipeType = TypeVar("RecipeType", bound="Recipe")
+
+
+class Recipe:
+    RECIPE_TYPE_INFO = RecipeTypeInfo(
+        type_name=None,
+        category="AbstractRecipes",
+        color=None,
+        icon=None,
+    )
+    _CONTROLER = RecipeControler
+
+    def __init__(self, init_file: Path | str):
+        self._init_file = Path(init_file)
+        self._name = self._init_file.parent.name
+        self._recipe_toml = (self._init_file / ".." / "recipe.toml").resolve()
+        self._svg_cooking_log_path = self._init_file.parent / "cooking_log.svg"
+        self._txt_cooking_log_path = self._init_file.parent / "cooking_log.txt"
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    @property
+    def is_editable(self) -> bool:
+        return self._CONTROLER.is_editable(self)
+
+    @property
+    def svg_cooking_log_path(self):
+        return self._svg_cooking_log_path
+
+    @property
+    def txt_cooking_log_path(self):
+        return self._txt_cooking_log_path
+
+    def cook(self):
+        from rich.console import Console
+
+        console = Console(record=True)
+        try:
+            self._cook(print=console.print)
+        finally:
+            console.save_text(str(self._txt_cooking_log_path), clear=False)
+            title = f"{self.name} Cooking Log {datetime.datetime.now().isoformat(sep=' ', timespec='minutes')}"
+            console.save_svg(str(self._svg_cooking_log_path), title=title)
+
+    def _cook(self, print):
+        print(
+            f"Hello from Recipe {self.name} (version={self.get_version()}, {self.is_editable=})"
+        )
+        print(self._CONTROLER.read_metadata(self))
+
+    def get_version(self) -> str:
+        version_module = importlib.import_module(self.name + ".__version__")
+        return version_module.__version__
+
+    def nice_panel_names(self) -> list[str]:
+        """
+        Asset subclasses implementing nice panel guis
+        must override this method to return the name of the method
+        implementing each panel.
+
+        NB: You panel method will **NOT** be executed in the asset
+        virtual env. That means you CAN NOT do things like cook them
+        or even import their input recipes with `self.get_inputs()`.
+        But you can access the recipe data with `self._CONTROLER.read_metadata(...)`
+        and save them with `self._CONTROLER.write_metadata(...)`.
+        If you **really** want to affect the recipe, you need to do so
+        using the Workspace provided with the `workspace` argument.
+
+        NB: GUIs will show your panels by alphabetic order, but you
+        can preprend some panel names with some "_" to bring them first.
+
+        Example:
+
+        from tgzr.cuisine.workspace import Workspace
+
+        class MyRecipe(Recipe):
+            def nice_panel_name(self)->list[str]:
+                return ['preview_panel', 'options_panel']
+
+            def preview_panel(self, workspace:Workspace)->None:
+                ui.label('This is the preview panel.')
+
+            def options_panel(self, workspace:Workspace)->None:
+                ui.label('This is the option panel.')
+
+        """
+        return []
+
+    def get_inputs(self, group: str | None = None) -> list[Recipe]:
+        """
+        Returns a dict like {recipe_name:Recipe} with all inputs in
+        the group `group`.
+        """
+        assets = []
+        recipe_metadata = self._CONTROLER.read_metadata(self)
+        for package_name in recipe_metadata.inputs.get(group, []):
+            module = importlib.import_module(package_name)
+            try:
+                recipe: Recipe = module.recipe
+            except AttributeError:
+                print(f"!!Warning!! upstream {package_name} is not an Recipe ?!?")
+            else:
+                assets.append(module.asset)
+        return assets
+
+    def get_unique_input(self, group: str, required: bool = True):
+        """
+        Return the one and only input in the group `group`.
+        If there's not exactly one input in this group, raises a
+        Exception.
+        """
+        inputs = self.get_inputs(group=group)
+        if required and not inputs:
+            raise Exception(
+                f"You need to connect something in {group!r} dependency of asset {self.name!r}!"
+            )
+
+        if len(inputs) != 1:
+            raise Exception(
+                f"You need one and exactly one {group!r} dependency. (got: {inputs})"
+            )
+        return inputs[0]
+
+    def get_typed_inputs(
+        self, RecipeType: Type[RecipeType], group: str, raises: bool = True
+    ) -> dict[str, RecipeType]:
+        """
+        Returns a {name:recipe} dict with all recipes in input group `group` of
+        type `RecipeType`.
+        """
+        inputs = self.get_inputs(group="params")
+        matching: dict[str, RecipeType] = {}
+        for input in inputs:
+            if not isinstance(input, RecipeType):
+                if raises:
+                    raise TypeError(
+                        f"The input {input.name} in group {group!r} of {self.name} is not a {RecipeType} but a {type(input)}!"
+                    )
+                continue
+            matching[input.name] = input
+        return matching