tgzr.cuisine 0.0.1__py3-none-any.whl

tgzr/cuisine/basics/viewable.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+from tgzr.cuisine.basics.buildable import Buildable, RecipeTypeInfo
+from tgzr.cuisine.basics.recipe_contexts import CookContext
+
+
+@CookContext.context_type
+class ViewContext(CookContext):
+    to_view: Viewable
+
+
+class Viewable(Buildable):
+    """
+    A Buildable Recipe which cooks its 'viewer' input in its context after building
+    if if needed.
+    """
+
+    RECIPE_TYPE_INFO = RecipeTypeInfo(
+        category="View",
+        color="#0000FF",
+        icon="sym_o_play_pause",
+    )
+
+    def view(self):
+        current_context = CookContext.current()
+        current_context.log(f"Opening viewer for {self.file_path()}")
+        viewer = self.get_unique_input("view")
+        with current_context.get(ViewContext, asset_to_view=self):
+            viewer.cook()
+
+    def cook(self):
+        super().cook()
+        self.view()

tgzr/cuisine/basics/viewer.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from tgzr.cuisine.recipe import Recipe, RecipeTypeInfo
+from tgzr.cuisine.basics.recipe_contexts import CookContext
+from tgzr.cuisine.basics.viewable import ViewContext
+
+
+class Viewer(Recipe):
+    """
+    An Recipe which will open the 'file' from the current Viewable asset with
+    a defined viewer when cooked.
+    """
+
+    RECIPE_TYPE_INFO = RecipeTypeInfo(
+        category="View",
+        color="#0000FF",
+        icon="sym_o_play_circle",
+    )
+
+    def launch_viewer(self, file_path: Path):
+        ViewContext.current().log(f"Launching viewer for {file_path}")
+
+    def cook(self):
+        ctx = ViewContext.current(raises=False)
+        if ctx is None:
+            raise Exception("Cannot view an asset outside of a ViewContext.")
+        ctx.log(f"Viewer cooking: {self.name}")
+        self.launch_viewer(ctx.to_view.file_path())

tgzr/cuisine/basics/workscene.py

@@ -0,0 +1,5 @@
+from tgzr.cuisine.basics.editable import Editable
+
+
+class WorkScene(Editable):
+    pass

tgzr/cuisine/chef.py

@@ -0,0 +1,339 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING, Type, Callable, Any
+
+import os
+from pathlib import Path
+from importlib_metadata import Distribution
+import dataclasses
+import datetime
+
+import rich
+import packaging.utils
+import packaging.requirements
+
+from tgzr.package_management.venv import Venv
+from .recipe import Recipe, RecipeMetadata, RecipeTypeInfo
+
+if TYPE_CHECKING:
+    from .recipe import RecipeControler
+
+
+@dataclasses.dataclass
+class RecipeInfo:
+    """
+    Recipe metadata extracted from
+    a `importlib.metadata.Distribution()`.
+
+    These are created by Workbench.get_recipe_info
+    """
+
+    dist: Distribution
+    is_asset: bool
+    asset_name: str
+    asset_type: str | None
+    tags: set[str]
+    is_editable: bool
+    editable_path: Path | None
+    nice_panel_names: list[str]
+
+
+class Chef:
+    """
+    Chef is doing things with recipes
+    """
+
+    def __init__(self, venv_path: Path):
+        self._venv_path = venv_path
+        self._venv = Venv(venv_path)
+        self._recipe_types: list[Type[Recipe]] = []
+
+    def register_recipe_types(self, *recipe_types):
+        # fill empty 'type_name' with default:
+        for RecipeType in recipe_types:
+            if RecipeType.RECIPE_TYPE_INFO.type_name is None:
+                RecipeType.RECIPE_TYPE_INFO.type_name = RecipeType.__name__
+        self._recipe_types.extend(recipe_types)
+
+    def get_recipe_type(self, recipe_type_name: str) -> Type[Recipe]:
+        for RecipeType in self._recipe_types:
+            if RecipeType.RECIPE_TYPE_INFO.type_name == recipe_type_name:
+                return RecipeType
+        raise KeyError(f"No Recipe registered with type named {recipe_type_name!r}!")
+
+    def get_recipe_types(self) -> list[Type[Recipe]]:
+        return list(self._recipe_types)
+
+    def get_recipe_id(self, recipe_name: str) -> str:
+        """
+        Return the recipe id for this recipe_name (the canonical name of the
+        recipe package).
+
+        if validate is True:
+            Raises a ValueError if name cannot be used as a Recipe name.
+        """
+        try:
+            recipe_id = packaging.utils.canonicalize_name(recipe_name, validate=True)
+        except packaging.utils.InvalidName as err:
+            raise ValueError(f"Invalid Recipe name {recipe_name}.")
+
+        if not recipe_id.replace(".", "").replace("-", "").isidentifier():
+            suffix = ""
+            if recipe_id != recipe_name:
+                suffix = f" (canonicalized to {recipe_id}"
+            raise ValueError(f"Invalid Recipe name {recipe_name!r}{suffix}.")
+
+        return recipe_id
+
+    def create_recipe(
+        self,
+        folder: Path,
+        recipe_name: str,
+        recipe_metadata: RecipeMetadata | None,
+        version: str | None,
+        recipe_type_name: str,
+    ):
+        """
+        Creates an editable recipe in folder and returns
+        the id of the created recipe (the canonical name of the package).
+        """
+        RecipeType = self.get_recipe_type(recipe_type_name)
+
+        recipe_metadata = recipe_metadata or RecipeMetadata.create_default(
+            name=recipe_name,
+            type_name=recipe_type_name,
+        )
+        version = version or "0.1.0"
+        package_name = self.get_recipe_id(recipe_name)
+
+        recipe_path = folder / package_name
+        rich.print(f"Creating Recipe {recipe_name!r} ({package_name=})")
+        rich.print(f"ReceipMetadata: {recipe_metadata}")
+
+        recipe_path.mkdir(exist_ok=True)
+
+        src = (
+            recipe_path / "src" / package_name
+        )  # FIXME: support . here (package namespaces)
+        src.mkdir(parents=True, exist_ok=True)
+
+        recipe_toml = src / "recipe.toml"
+        recipe_metadata.write_toml(recipe_toml)
+
+        dinit = src / "__init__.py"
+        dinit_content = RecipeType._CONTROLER.default_dinit_content(RecipeType)
+        dinit.write_text(dinit_content)
+
+        dversion = src / "__version__.py"
+        dversion_content = f'__version__ = "{version}"'
+        dversion.write_text(dversion_content)
+
+        readme = recipe_path / "README.md"
+        readme_content = f"# tgzr.cuisine Recipe: {recipe_name}\n\nCreated on {datetime.datetime.now().strftime('%c')}\n"
+        readme.write_text(readme_content)
+
+        recipe = RecipeType(dinit)
+        recipe._CONTROLER.init_recipe_files(recipe, dinit)
+
+        pyproject = recipe_path / "pyproject.toml"
+        recipe._CONTROLER.write_pyproject_to(recipe, pyproject)
+        return package_name
+
+    def get_recipe_from_toml(self, toml_path) -> Recipe:
+        recipe_metadata = RecipeMetadata.from_toml(toml_path)
+        recipe_type_name = recipe_metadata.type_name
+        RecipeType = self.get_recipe_type(recipe_type_name)
+        dinit = toml_path.parent / "__init__.py"
+        return RecipeType(dinit)
+
+    def _edit_recipe_metadata(
+        self,
+        folder: Path,
+        recipe_name: str,
+        modifier: Callable[[RecipeMetadata], RecipeMetadata | None],
+        rebuild_pyproject: bool,
+        bump: str | None = "patch,a",
+    ):
+        recipe_path = folder / recipe_name
+        if not recipe_path.exists():
+            raise ValueError(
+                f"Cannot edit recipe metadata for {recipe_name!r}: it was not found in {folder})."
+            )
+
+        toml_path = recipe_path / "src" / recipe_name / "recipe.toml"
+        recipe = self.get_recipe_from_toml(toml_path)
+        recipe_metadata = recipe._CONTROLER.read_metadata(recipe)
+
+        recipe_metadata = modifier(recipe_metadata)
+
+        if recipe_metadata is None:
+            print("Nothing to save.")
+            return
+
+        # rich.print(recipe_metadata)
+
+        recipe._CONTROLER.write_metadata(recipe, recipe_metadata)
+
+        if rebuild_pyproject:
+            pyproject = recipe_path / "pyproject.toml"
+            recipe._CONTROLER.write_pyproject_to(recipe, pyproject)
+
+        if bump is not None:
+            self.bump_recipe(folder, recipe_name, "patch,a")
+
+    def rebuild_pyproject(self, folder: Path, recipe_name: str):
+        recipe_path = folder / recipe_name
+        if not recipe_path.exists():
+            raise ValueError(
+                f"Cannot rebuild pyproject for {recipe_name!r}: it was not found in {folder})."
+            )
+
+        toml_path = recipe_path / "src" / recipe_name / "recipe.toml"
+        recipe = self.get_recipe_from_toml(toml_path)
+        pyproject = recipe_path / "pyproject.toml"
+        recipe._CONTROLER.write_pyproject_to(recipe, pyproject)
+
+    def rebuild_dinit(self, folder: Path, recipe_name: str):
+        recipe_path = folder / recipe_name
+        if not recipe_path.exists():
+            raise ValueError(
+                f"Cannot rebuild pyproject for {recipe_name!r}: it was not found in {folder})."
+            )
+
+        src = recipe_path / "src" / recipe_name
+        toml_path = src / "recipe.toml"
+        recipe = self.get_recipe_from_toml(toml_path)
+        dinit = src / "__init__.py"
+        dinit_content = recipe._CONTROLER.default_dinit_content(type(recipe))
+        dinit.write_text(dinit_content)
+        recipe._CONTROLER.init_recipe_files(recipe, dinit)
+
+    def add_tags(self, folder: Path, recipe_name: str, tags: set[str]):
+
+        def add_tags(recipe_metadata: RecipeMetadata) -> RecipeMetadata | None:
+            rich.print(f"Adding tags {tags!r} to {recipe_name!r}.")
+            old_tags = set(recipe_metadata.tags)
+            recipe_metadata.tags.extend([t for t in tags if t not in old_tags])
+            if set(recipe_metadata.tags) == set(old_tags):
+                print("No change in tags, no need to save.")
+                return
+            return recipe_metadata
+
+        self._edit_recipe_metadata(
+            folder, recipe_name, add_tags, rebuild_pyproject=True, bump="patch,a"
+        )
+
+    def add_inputs(
+        self,
+        folder: Path,
+        recipe_name: str,
+        group: str = "",
+        *input_requirements: str,
+    ):
+        rich.print(f"Adding inputs {input_requirements!r} to {recipe_name!r}.")
+
+        def add_inputs(recipe_metadata: RecipeMetadata) -> RecipeMetadata | None:
+            existing_requirements = [
+                packaging.requirements.Requirement(i)
+                for i in recipe_metadata.inputs.get(group, [])
+            ]
+            existing_named_requirements = dict(
+                [(req.name, req) for req in existing_requirements]
+            )
+            reqs_to_remove = []
+            reqs_to_add = []
+            for input_requirement in input_requirements:
+                input_req = packaging.requirements.Requirement(input_requirement)
+                if input_req.name in existing_named_requirements:
+                    existing_req = existing_named_requirements[input_req.name]
+                    if input_req == existing_req:
+                        # this requirement is already there
+                        pass
+                    else:
+                        reqs_to_remove.append(existing_req)
+                        reqs_to_add.append(input_req)
+                else:
+                    reqs_to_add.append(input_req)
+
+            new_dependencies = []
+            for req in existing_requirements:
+                if req in reqs_to_remove:
+                    continue
+                new_dependencies.append(str(req))
+
+            new_dependencies += [str(req) for req in reqs_to_add]
+            if recipe_metadata.inputs.get(group, []) == new_dependencies:
+                # nothing changed, no need to save
+                return None
+
+            recipe_metadata.inputs[group] = new_dependencies
+            rich.print(recipe_metadata)
+            return recipe_metadata
+
+        self._edit_recipe_metadata(
+            folder, recipe_name, add_inputs, rebuild_pyproject=True, bump="patch,a"
+        )
+
+    def bump_recipe(self, folder: Path, recipe_name: str, bump: str = "minor"):
+        recipe_path = folder / recipe_name
+        self._venv.hatch_version_bump(recipe_path, bump)
+
+    def build_recipe(
+        self,
+        folder: Path,
+        recipe_name: str,
+        dist_folder: Path,
+    ):
+
+        recipe_path = folder / recipe_name
+        dist_path = dist_folder / recipe_name
+
+        self._venv.hatch_build(recipe_path, dist_path, allow_custom_classifiers=True)
+
+    def publish_recipe(
+        self,
+        folder: Path,
+        recipe_name: str,
+        dist_folder: Path,
+        index_url: str,
+        **options: str,
+    ):
+        """
+        Provided options like:
+            option_name='option_value', target='bob'
+        will be passed to the publisher plugin like:
+            -o option_name=option_value -o default_target=blessed
+
+        """
+        recipe_path = folder / recipe_name
+        dist_path = dist_folder / recipe_name
+
+        self._venv.hatch_publish(recipe_path, dist_path, index_url, **options)
+
+    def run_recipe_method(
+        self, folder: Path, recipe_name: str, method_name: str, *args, **kwargs
+    ) -> Any:
+        """
+        WARNING: the method is not executed in the workbench venv but from wherever this is
+        called (might by a GUI app or an automation script outside of the workspace).
+
+        """
+        recipe_path = folder / recipe_name
+        if not recipe_path.exists():
+            raise ValueError(
+                f"Cannot run method {method_name} from {recipe_name!r}: it was not found in {folder})."
+            )
+        toml_path = recipe_path / "src" / recipe_name / "recipe.toml"
+        recipe = self.get_recipe_from_toml(toml_path)
+
+        try:
+            method = getattr(recipe, method_name)
+        except Exception as err:
+            raise AttributeError(
+                f"Cannot get method {method_name} from {recipe_name!r}: {err}."
+            )
+        try:
+            return method(*args, **kwargs)
+        except Exception as err:
+            print(
+                f"Error runnig recipr method {method_name} on {recipe_name} (a {recipe.RECIPE_TYPE_INFO.type_name}): {err}"
+            )

tgzr/cuisine/cli/__init__.py

@@ -0,0 +1,232 @@
+from __future__ import annotations
+from typing import Literal
+
+import os
+from pathlib import Path
+import click
+import dataclasses
+import json
+import rich, rich.table
+
+from .._version import __version__
+from ..workbench import Workbench
+from .utils import ShortNameGroup
+
+
+@click.group(
+    cls=ShortNameGroup,
+    context_settings={"help_option_names": ["-h", "--help"]},
+)
+@click.version_option(version=__version__, prog_name="cuisine")
+@click.option(
+    "-w",
+    "--workbench",
+    metavar="PATH",
+    default=".",
+    help="Path to the cuisine workbench.",
+)
+@click.option(
+    "-c",
+    "--create-workbench",
+    default=None,
+    metavar="PY-VERSION",
+    help="Create the specified workbench if it doesn't exists, use the python version provided by this flag",
+)
+@click.pass_context
+def cuisine_cli(ctx, workbench: str, create_workbench: str):
+    workbench_path = os.path.abspath(os.path.normpath(workbench))
+    wb = Workbench(workbench_path)
+    if create_workbench:
+        wb.ensure_exists(python_version=create_workbench)
+
+    ctx.obj = wb
+
+
+#
+# WORKBENCH
+#
+
+
+# @cuisine_cli.group(cls=ShortNameGroup, help="Manage the cuisine workbenche.")
+# def workbench():
+#     pass
+
+
+#
+# RECIPES
+#
+
+
+@cuisine_cli.group(cls=ShortNameGroup, help="Manage Recipes")
+def recipe():
+    pass
+
+
+@recipe.command
+@click.argument("name")
+@click.option(
+    "-T",
+    "--recipe-type",
+    default="Recipe",
+    help="The recipe type to create, like Product or Workscene (valid values depend on the installed asset plugins)",
+)
+@click.pass_obj
+def create(wb: Workbench, recipe_type: str, name: str):
+    wb.create_recipe(recipe_type_name=recipe_type, recipe_name=name)
+
+
+@recipe.command
+@click.option(
+    "-e",
+    "--editable-only",
+    is_flag=True,
+    help="List only the editable recipes.",
+)
+@click.option(
+    "-l",
+    "--libs",
+    is_flag=True,
+    help="List library package (python) too.",
+)
+@click.option(
+    "-f",
+    "--format",
+    default="human",
+    help="Output format: 'json', 'rich', 'human'. Default to `human`.",
+)
+@click.pass_obj
+def ls(
+    wb: Workbench,
+    editable_only: bool = False,
+    libs: bool = False,
+    format: Literal["json", "rich", "human"] = "human",
+):
+    """List installed Recipes (and libs, optionnaly)."""
+    matched = wb.get_dist_infos(editable_only=editable_only, include_non_recipe=libs)
+
+    if format == "human":
+        table = rich.table.Table("Name", "Is Recipe", "Is Editable")
+        for dist_info in matched:
+            style = dist_info.is_editable and "yellow" or ""
+            style += dist_info.is_recipe and " on cyan" or ""
+
+            table.add_row(
+                dist_info.dist.name,
+                dist_info.is_recipe and "✔" or "",
+                dist_info.is_editable and "✔" or "",
+                style=style,
+            )
+        rich.print(table)
+
+    if format == "rich":
+        rich.print(matched)
+
+    elif format == "json":
+
+        def drop_undumpable(d: dict, encoder: json.JSONEncoder):
+            to_drop = []
+            to_dig = []
+            for k, v in d.items():
+                if v is None:
+                    continue
+                if isinstance(v, dict):
+                    to_dig.append(k)
+                elif isinstance(v, Path):
+                    d[k] = str(v)
+                elif not isinstance(v, (str, bool, list, tuple)):
+                    to_drop.append(k)
+            for k in to_drop:
+                del d[k]
+            for k in to_dig:
+                drop_undumpable(d[k], encoder)
+
+        data = [dataclasses.asdict(dist_info) for dist_info in matched]
+        for d in data:
+            drop_undumpable(d, json.JSONEncoder())
+        click.echo(json.dumps(data))
+
+    else:
+        raise click.UsageError(
+            f"Unsupported value for -f/--format: {format!r} (must be 'json', 'rich' or 'human')."
+        )
+
+
+@recipe.command
+@click.argument("name")
+@click.pass_obj
+def pyproject_rebuild(wb: Workbench, name: str):
+    """Rebuild the recipe pyproject file, bump the version micro and (re)install."""
+    wb.rebuid_pyproject(name)
+
+
+@recipe.command
+@click.argument("name")
+@click.pass_obj
+def dinit_rebuild(wb: Workbench, name: str):
+    """Rebuild the recipe __init__.py file, bump the version micro and (re)install."""
+    wb.rebuid_dinit(name)
+
+
+@recipe.command
+@click.argument("name")
+@click.argument("tags", nargs=-1)
+@click.pass_obj
+def tag(wb: Workbench, name: str, tags: list[str]):
+    """Add tags to recipe."""
+    if not tags:
+        click.echo("No tags given, nothing to do.")
+    wb.tag_recipe(name, *tags)
+
+
+@recipe.command
+@click.argument("name")
+@click.option(
+    "-g",
+    "--group",
+    default="",
+    help="If specified, add to this group (like dev, build, edit,...)",
+)
+@click.argument("requirements", nargs=-1)
+@click.pass_obj
+def add_input(wb: Workbench, name, group, requirements):
+    if not requirements:
+        click.echo("No requirements given, nothing to do.")
+    wb.add_inputs(name, group, *requirements)
+
+
+@recipe.command(help=f"\b\n {Workbench.bump_recipe.__doc__}")
+@click.argument("name")
+@click.argument("bump", required=False, default="minor")
+@click.pass_obj
+def bump(wb: Workbench, name, bump):
+    wb.bump_recipe(name, bump)
+
+
+@recipe.command
+@click.argument("name")
+@click.option(
+    "-b",
+    "--bump",
+    default="minor",
+    help=(
+        "The part of the version to bump, like "
+        "'major', 'minor', 'micro', 'alpha', 'rc' or a combination like 'minor,rc'. "
+        "Defaults to 'minor'."
+    ),
+)
+@click.pass_obj
+def build(wb: Workbench, name, bump):
+    wb.build_recipe(name, bump)
+
+
+@recipe.command
+@click.argument("name")
+@click.option(
+    "-r",
+    "--repo",
+    required=True,
+    help="Name of repo to upload to.",
+)
+@click.pass_obj
+def publish(wb: Workbench, name, repo: str):
+    wb.publish_recipe(name, repo)

tgzr/cuisine/cli/main.py

@@ -0,0 +1,7 @@
+from . import cuisine_cli
+
+import sys
+
+
+def main():
+    sys.exit(cuisine_cli())

tgzr/cuisine/cli/utils.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+import click
+
+
+class ShortNameGroup(click.Group):
+    """
+    This Group recognizes commands with less
+    than their full name when there is no ambiguity.
+    For example: 'wo'->'workspace' if no other command
+    starts with 'wo'
+    """
+
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self.no_args_is_help = True
+        self.invoke_without_command = False
+
+    def get_command(self, ctx: click.Context, cmd_name: str) -> click.Command | None:
+        known_commands = self.list_commands(ctx)
+        if cmd_name not in known_commands:
+            found = [name for name in known_commands if name.startswith(cmd_name)]
+            if len(found) > 1:
+                candidats = " or ".join(found)
+                raise click.UsageError(
+                    f'Ambiuous command "{cmd_name}" (could be {candidats}).'
+                )
+            elif found:
+                cmd_name = found[0]
+
+        return super().get_command(ctx, cmd_name)