tgzr.cuisine 0.0.1__py3-none-any.whl

tgzr/cuisine/workbench.py

@@ -0,0 +1,455 @@
+"""
+
+Naming:
+    user_workspaces -> cuisine
+    workspace -> workbench
+    requirement -> input
+    asset -> recipe
+    repo -> catalog
+    inputs -> N/A (managed by uv)
+    outputs -> editables
+
+uv config:
+
+# add from a remote catalog:
+    uv add recipe==1.0.3 --index blessed=https://path/to/blessed_catalog
+# add from a path:
+    uv add recipe /path/to/blessed_catalog
+# add from editables:
+    uv add --editable ./editable/recipe
+
+->
+    [tool.uv.sources]
+    torch = { index = "blessed" }
+
+    [[tool.uv.index]]
+    name = "blessed"
+    url = "https://path/to/blessed_catalog"
+    explicit = true #<-- see if this is better and if it can be set by uv cli
+
+# add a requirement in a specific group
+    uv add builder_recipe --optional build
+
+NOTE: environment marker on dependencies can use [extra] to select the catalog to install from:
+https://docs.astral.sh/uv/concepts/projects/dependencies/#multiple-sources
+
+"""
+
+from __future__ import annotations
+from typing import Any
+
+from pathlib import Path
+import subprocess
+import dataclasses
+from importlib_metadata import Distribution
+from ast import literal_eval
+import os
+
+import uv as external_uv
+import pydantic
+
+from tgzr.package_management.workspace import Workspace
+
+from .recipe import RecipeTypeInfo
+from .chef import Chef
+from .plugin import cuisine_plugin_manager
+
+
+class WorkbenchSettings(pydantic.BaseModel):
+    main_entity: str | None = (
+        None  # optional main entity FIXME: should be auto installed
+    )
+
+
+@dataclasses.dataclass
+class RecipeDistInfo:
+    """
+    Recipe related information extracted from
+    a `importlib.metadata.Distribution()`.
+
+    These are created by Workbench.get_dist_info
+    """
+
+    dist: Distribution
+    is_recipe: bool
+    recipe_name: str
+    recipe_type: str | None
+    tags: set[str]
+    is_editable: bool
+    editable_path: Path | None
+    nice_panel_names: list[str]
+
+
+class Workbench:
+    def __init__(self, path: Path | str | None) -> None:
+        if path is None:
+            path = "."
+        path = Path(path).resolve()
+        self._workspace = Workspace(path)
+
+        # self._name = self.path.name
+
+        # self._venv_name = ".venv"
+        # self._venv_path = self.path / self._venv_name
+
+        # exe_dir = "bin"
+        # self._exe_suffix = ""
+        # if platform.system() != "Linux":
+        #     exe_dir = "Scripts"
+        #     self._exe_suffix = ".exe"
+        # self._exe_path = self._venv_path / exe_dir
+
+        # self._external_packages_path = self.path / "external_packages"
+        # self._output_path = self.path / "outputs"
+        # self._uv_workspace_pyproject = self.path / "pyproject.toml"
+        self._editable_path = self.path / "editables"
+        self._build_path = self.path / "build"
+
+        venv_name = ".venv"  # imposed by uv
+        self._venv_path = self.path / venv_name
+        self._chef = Chef(self._venv_path)
+        for plugin in cuisine_plugin_manager.get_plugins():
+            self._chef.register_recipe_types(*plugin.get_recipe_types())
+
+    @property
+    def path(self) -> Path:
+        """The path of the Workbench, including its name."""
+        return self._workspace.path
+
+    @property
+    def name(self) -> str:
+        """The name of the Workbench, deducted from its path."""
+        return self._workspace.name
+
+    # @property
+    # def venv_path(self) -> Path:
+    #     """The path to the Workspace's venv."""
+    #     return self._venv_path
+
+    def exists(self) -> bool:
+        return self._workspace.exists()
+
+    @property
+    def chef(self) -> Chef:
+        return self._chef
+
+    def get_recipe_types_info(self) -> dict[str, RecipeTypeInfo]:
+        recipe_types = self.chef.get_recipe_types()
+
+        ret = dict()
+        for RecipeType in recipe_types:
+            recipe_type_info = RecipeType.RECIPE_TYPE_INFO
+            ret[recipe_type_info.type_name] = recipe_type_info
+        return ret
+
+    def ensure_exists(
+        self,
+        force_build: bool = False,
+        description: str | None = None,
+        python_version: str | None = None,
+    ):
+        if self.exists():
+            if force_build:
+                # Not sure it's needed, and not sure how to do it ^_^', so:
+                raise ValueError("Workspace Rebuild not yet implemented!")
+            return
+
+        self._workspace.create(
+            description=description, python_version=python_version, vcs="none"
+        )
+        # Make all editable
+        self._workspace.add_member("editables/*")
+        # Seed the workspace with mandatory dependencies:
+        self._workspace.add_dependencies("", "uv", "hatch", "tgzr.cuisine")
+        self._workspace.ensure_index("pypi", "https://pypi.org/simple")
+        # self._workspace.set_source("uv", index_name="pypi")
+        # self._workspace.set_source("hatch", index_name="pypi")
+
+        # TODO: install from pypi:
+        self._workspace.set_source(
+            "tgzr.cuisine", path="/home/dee/DEV/_OPEN-TGZR_/tgzr.cuisine", editable=True
+        )
+
+        self._editable_path.mkdir(parents=False, exist_ok=True)
+        self._build_path.mkdir(parents=False, exist_ok=True)
+
+    def create_recipe(
+        self,
+        recipe_type_name: str,
+        recipe_name: str,
+    ):
+        """
+        Create an editable recipe on this workbench.
+        """
+        recipe_id = self.chef.create_recipe(
+            folder=self._editable_path,
+            recipe_name=recipe_name,
+            recipe_metadata=None,
+            version=None,
+            recipe_type_name=recipe_type_name,
+        )
+        # TODO: repace these 3 line with a subprocess `uv add {recipe_name}` ?
+        self._workspace.set_source(recipe_name, workspace=True)
+        self._workspace.add_dependencies("", recipe_name)
+        self.sync()
+        # self._workspace.sync(allow_upgrade=True, allow_custom_classifiers=True)
+        # self._install_editable(recipe_id)
+
+    def rebuid_pyproject(self, recipe_name: str):
+        """
+        Rebuild the pyproject.toml file, bump and install (editable)
+        Usefull when the content of the pyproject file need to be updated/conformed
+        """
+        self.chef.rebuild_pyproject(self._editable_path, recipe_name)
+        self.bump_recipe(recipe_name, "micro")
+
+    def rebuid_dinit(self, recipe_name: str):
+        """
+        Rebuild the __init__.py file, bump and install (editable)
+        Usefull when the content of the __init__ file need to be updated/conformed
+        after modifying what the base class puts in it.
+        """
+        self.chef.rebuild_dinit(self._editable_path, recipe_name)
+        self.bump_recipe(recipe_name, "micro")
+
+    def get_recipe_names(self) -> list[str]:
+        venv = self._workspace.venv()
+        dists = venv.get_packages()
+        recipe_dist_infos = [self.get_dist_info(dist) for dist in dists]
+        return [dist.recipe_name for dist in recipe_dist_infos if dist.is_recipe]
+
+    def get_editable_recipe_names(self) -> list[str]:
+        names = []
+        for path in self._editable_path.iterdir():
+            if (path / "pyproject.toml").exists:
+                names.append(path.name)
+        return sorted(names)
+
+    # def _install_editable(self, recipe_requirement: str):
+    #     print("WS Install editable", recipe_requirement)
+
+    #     find_links = []
+    #     # TODO: implement management of uv's workspace index + use in them here
+
+    #     self.chef.install_editable(
+    #         self._editable_path,
+    #         recipe_name,
+    #         *find_links,
+    #     )
+
+    def sync(self) -> None:
+        """
+        Install all editables an update all versions.
+        """
+        self._workspace.sync(allow_upgrade=True, allow_custom_classifiers=True)
+
+    def tag_recipe(self, recipe_name: str, *tags: str):
+        self.chef.add_tags(self._editable_path, recipe_name, set(tags))
+        self.sync()
+        # self._workspace.sync(allow_upgrade=True, allow_custom_classifiers=True)
+        # self._install_editable(recipe_name)
+
+    def add_inputs(self, recipe_name: str, group: str = "", *input_requirements: str):
+        """
+        Make this recipe dependent of given input_requirements.
+        Each input_requirement can be like:
+            - recipe-name
+            - recipe-name==1.2.3
+            - recipe-anme>=2.3.4
+            - recipe-name>=3.4.5<4.0
+            etc...
+        """
+        if not self.has_editable_recipe(recipe_name):
+            raise ValueError(f"Cannot add inputs to non-editable asset {recipe_name!r}")
+        self.chef.add_inputs(
+            self._editable_path, recipe_name, group, *input_requirements
+        )
+        self.sync()
+        # self._workspace.sync(allow_upgrade=True, allow_custom_classifiers=True)
+        # self._install_editable(recipe_name)
+
+    def bump_recipe(self, recipe_name: str, bump: str = "minor"):
+        """
+        Bumpt the part of the version specified with bump, like:"
+            major
+            minor
+            micro / patch / fix
+            a / alpha
+            b / alpha
+            c / rc / pre / preview
+            r / rev / post
+            dev
+
+        or a combination like:
+            minor,rc
+            patch,a
+            major,alpha,dev
+
+        Defaults is to bump minor."
+        """
+        self.chef.bump_recipe(self._editable_path, recipe_name, bump=bump)
+        self.sync()
+        # self._workspace.sync(allow_upgrade=True, allow_custom_classifiers=True)
+        # self._install_editable(recipe_name)
+
+    def build_recipe(self, recipe_name: str, bump: str = "minor"):
+        self.chef.bump_recipe(self._editable_path, recipe_name, bump=bump)
+        self.chef.build_recipe(self._editable_path, recipe_name, self._build_path)
+
+    def publish_recipe(self, recipe_name: str, index_name: str):
+        index = self._workspace.get_index(index_name)
+        if index is None:
+            raise ValueError(
+                f"Undefined index {index_name!r} in workbench {str(self.path)!r}."
+            )
+        self.chef.publish_recipe(
+            self._editable_path,
+            recipe_name,
+            self._build_path,
+            index.url,
+        )
+
+    def install_recipe(
+        self,
+        from_index_name: str,
+        requirement,
+    ):
+        self._workspace.set_source(requirement, index_name=from_index_name)
+        self.sync()
+        # self._workspace.sync(allow_upgrade=True, allow_custom_classifiers=True)
+
+    def has_editable_recipe(self, recipe_name: str):
+        return (self._editable_path / recipe_name).exists()
+
+    def turn_recipe_editable(self, recipe_name: str, force: bool = False):
+        """
+        Turn an installed recipe into an editable recipe.
+        """
+        if self.has_editable_recipe(recipe_name):
+            if not force:
+                raise ValueError(
+                    f"The recipe {recipe_name!r} is already editable in the worksbench {self.path!r}."
+                )
+
+        command = f"import {recipe_name} as package; package.recipe._CONTROLER.create_editable(package.recipe, workbench_path='{self.path}', force={force})"
+        try:
+            self._workspace.run_python_command(command)
+        except:
+            print("Oopsy, runing python command returned non-zero !")
+        else:
+            self.chef.bump_recipe(self._editable_path, recipe_name, bump="micro")
+            self._workspace.set_source(recipe_name, workspace=True)
+            self.sync()
+            # self._workspace.sync(allow_upgrade=True, allow_custom_classifiers=True)
+
+    def get_dist_info(self, dist: Distribution) -> RecipeDistInfo:
+        is_editable = False
+        editable_path = None
+        if (
+            hasattr(dist, "origin")
+            and dist.origin is not None
+            and hasattr(dist.origin, "dir_info")
+            and dist.origin.dir_info.editable
+        ):
+            # TODO: verify if the editable path in in our output dir?
+            is_editable = True
+            url = dist.origin.url
+            editable_path = Path(url.split("file://", 1)[-1])
+
+        dist_info = RecipeDistInfo(
+            dist=dist,
+            is_recipe="tgzr.pipeline.asset_info_trick" in dist.entry_points.groups,
+            recipe_name=dist.name,
+            recipe_type=None,
+            tags=set(),
+            is_editable=is_editable,
+            editable_path=editable_path,
+            nice_panel_names=[],
+        )
+        if dist_info.is_recipe:
+            for ep in dist.entry_points.select(group="tgzr.pipeline.recipe_info_trick"):
+                if ep.name == "recipe_name":
+                    dist_info.recipe_name = ep.value
+                elif ep.name == "recipe_type":
+                    dist_info.recipe_type = ep.value
+                # TODO: read tags from keywords
+                # elif ep.name == "tags":
+                #     try:
+                #         dist_info.tags = literal_eval(ep.value)
+                #         print(
+                #             f"Error evaluating asset tags for {dist.name}: {ep.value}"
+                #         )
+                #     except:
+                #         dist_info.tags = set()
+
+            for ep in dist.entry_points.select(group="tgzr.pipeline.asset.nice_panel"):
+                dist_info.nice_panel_names.append(ep.name)
+
+        return dist_info
+
+    def get_dist_infos(
+        self, editable_only: bool = False, include_non_recipe: bool = False
+    ) -> list[RecipeDistInfo]:
+        venv = self._workspace.venv()
+
+        def match(dist):
+            if editable_only and not dist.is_editable:
+                return False
+            if not include_non_recipe and not dist.is_recipe:
+                return False
+            return True
+
+        dists = venv.get_packages()
+        dist_infos = [self.get_dist_info(dist) for dist in dists]
+        return [di for di in dist_infos if match(di)]
+
+    def run(self, console_script_name: str):
+        extra_env = {"tgzr.pipeline.current_workspace.path": str(self.path)}
+        self._workspace.run(console_script_name, **extra_env)
+
+        # self._venv_path
+        # uv = self._venv_bin_path / "uv"
+        # python = self._venv_bin_path / "python"
+        # cmd = [
+        #     str(uv),
+        #     "run",
+        #     "--python",
+        #     str(python),
+        #     "--directory",
+        #     str(self._venv_bin_path),
+        #     console_script_name,
+        # ]
+        # # print(cmd)
+        # env = os.environ.copy()
+        # env["tgzr.pipeline.current_workspace.path"] = str(self.path)
+        # # print(env)
+        # err_code = subprocess.call(cmd, env=env)
+        # if err_code:
+        #     print(
+        #         f"Oops, 'uv run {console_script_name}' returned error code: {err_code}."
+        #     )
+
+    def run_recipe_method(
+        self, recipe_name: str, method_name: str, *args, **kwargs
+    ) -> Any:
+        """
+        Execute that Recipe's method in the current thread.
+
+        This is probably dangerous. Doing things like modifying the
+        asset in that method would be quite a bad ides I guess...
+        """
+        return self.chef.run_recipe_method(
+            self._editable_path, recipe_name, method_name, *args, **kwargs
+        )
+
+    def render_nice_panel(self, recipe_name: str, panel_name: str) -> Any:
+        """
+        Assets can implement GUI panels (see Asset.nice_panel_names())
+        When they do so, their DistInfo.nice_panel_names contains the
+        name of the panel they can render.
+        You can call this method under a nicegui.ui element context
+        to render the asset's panel.
+        """
+        return self.run_recipe_method(
+            recipe_name, method_name=panel_name, workspace=self
+        )

tgzr_cuisine-0.0.1.dist-info/METADATA

@@ -0,0 +1,34 @@
+Metadata-Version: 2.4
+Name: tgzr.cuisine
+Version: 0.0.1
+Summary: tgzr cuisine engine
+Project-URL: Documentation, https://github.com/open-tgzr/tgzr.cuisine#readme
+Project-URL: Issues, https://github.com/open-tgzr/tgzr.cuisine/issues
+Project-URL: Source, https://github.com/open-tgzr/tgzr.cuisine
+Author-email: Dee <dee.sometech@gmail.com>
+License-Expression: GPL-3.0-or-later
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Requires-Python: >=3.9
+Requires-Dist: click
+Requires-Dist: eval-type-backport
+Requires-Dist: hatch
+Requires-Dist: importlib-metadata
+Requires-Dist: pydantic
+Requires-Dist: rich
+Requires-Dist: tgzr-context
+Requires-Dist: tgzr-package-management
+Requires-Dist: toml
+Requires-Dist: uv
+Description-Content-Type: text/markdown
+
+# tgzr.cuisine
+Cusine let your perform your tasks by crafting and cooking recipes.

tgzr_cuisine-0.0.1.dist-info/RECORD

@@ -0,0 +1,30 @@
+tgzr/cuisine/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tgzr/cuisine/_version.py,sha256=qf6R-J7-UyuABBo8c0HgaquJ8bejVbf07HodXgwAwgQ,704
+tgzr/cuisine/chef.py,sha256=6vifcXhq9UUmucfHssp_EHMgfI2W5-vdxZN7U1bxTpQ,11957
+tgzr/cuisine/plugin.py,sha256=rF3lTwyFlWv9tEEUAr3os92THK4R5sk723qMPLMbXzM,634
+tgzr/cuisine/recipe.py,sha256=C1mDsU_Kd1E29GmKRLNrnOaCArFBWJqq4z4JDj4D6rI,12817
+tgzr/cuisine/workbench.py,sha256=XlQDHU4AaA190VYRYvA4CIXq55y242RjqxL-upZdi8I,15630
+tgzr/cuisine/basics/__init__.py,sha256=EPN3Km7k6cfT0dx2dYBzaSkt2a0qF9V1ZFN21vmbcS8,829
+tgzr/cuisine/basics/buildable.py,sha256=TYutAmB9e7T1AjhftuzUyL_FK2qOVvcAYvwYfkUQEeo,967
+tgzr/cuisine/basics/builder.py,sha256=P1HhjDtjkL6wapRhKY-tUFy92yWV56X5GFm-yV5rXqU,2608
+tgzr/cuisine/basics/computable.py,sha256=SjAqfkcV9R9wbQ1t0aQIdYroJKea7wIKQWGxxQcJxd4,917
+tgzr/cuisine/basics/editable.py,sha256=J6k_1Qiblqxt5DUiRhdVFPt8DyGmD7WXSkeZY7uXiaM,718
+tgzr/cuisine/basics/editor.py,sha256=IwcgNl_djrukQv-nWP7cwS4erde3R6f5MgPKiJRBdLw,854
+tgzr/cuisine/basics/env.py,sha256=mSNqDK3RM6D6Em4Ba0Ok86z7aRvryLhRRyexhuEbGD4,6251
+tgzr/cuisine/basics/product.py,sha256=bkDHSNVumNYg4q-5O-Lb9Am9h9qlbGwKWkR_YEgv0OY,989
+tgzr/cuisine/basics/recipe_contexts.py,sha256=GEt9SkmnIRRaiFZ-CYZ_15zwUWr8wbCaRg2qc50r3FI,319
+tgzr/cuisine/basics/recipe_with_params.py,sha256=CAhMnOPvhEN7lX8HzkUCsO13TW_g7wLnHpQxCiL4G3w,3727
+tgzr/cuisine/basics/viewable.py,sha256=0ee8Tljwd_N4GbYiEwjAkVe1v38jATDKA2_q7e3xn-U,865
+tgzr/cuisine/basics/viewer.py,sha256=jYQhRUpDCGqnil26wD47U27SdsrOpJ770HqHJZWpdj8,901
+tgzr/cuisine/basics/workscene.py,sha256=YryFFIAaL9jd-5v5XYrZVKyknuLnne8Enn7egcwGREg,88
+tgzr/cuisine/basics/files_recipes/__init__.py,sha256=lYi2lwJlgTktwDJ7z4-uZf49sBXNHFz-0SpFO9pm61A,480
+tgzr/cuisine/basics/panels/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tgzr/cuisine/basics/panels/params_panel.py,sha256=AWg5T62PiAViLeViKBtvTFf0ChtsH1jG3gBVS_Vmqrg,18118
+tgzr/cuisine/cli/__init__.py,sha256=bD8gnm_IH-SaflfpL5YTKXhdUHxTNpcHB6UFMBaVr38,5810
+tgzr/cuisine/cli/main.py,sha256=_dV9wqpoU5PMQeNKZiUGdt18xZUj4r2qkD7CYR9ii3Y,80
+tgzr/cuisine/cli/utils.py,sha256=dafT-pQuV2Fnkq5od2jv31Ghu-ZtvoHzsCgo2zT8iGI,1034
+tgzr_cuisine-0.0.1.dist-info/METADATA,sha256=8I-dhdZ358DaVUvSM0E43ZN5okZLhriDHr4BdY58mMw,1283
+tgzr_cuisine-0.0.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+tgzr_cuisine-0.0.1.dist-info/entry_points.txt,sha256=WP7UXVs6sZVYsb3Xx0BluJ2WFLfusdnLiWX4BB5zhU4,203
+tgzr_cuisine-0.0.1.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+tgzr_cuisine-0.0.1.dist-info/RECORD,,

tgzr_cuisine-0.0.1.dist-info/WHEEL

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

tgzr_cuisine-0.0.1.dist-info/entry_points.txt

@@ -0,0 +1,8 @@
+[console_scripts]
+cuisine = tgzr.cuisine.cli.main:main
+
+[tgzr.cli.plugin]
+cuisine_cli = tgzr.cuisine.tgzr_cli_plugin:install_cli
+
+[tgzr.cuisine.plugin]
+default_recipes = tgzr.cuisine.basics:BasicsPlugin