tgzr.cuisine 0.0.1__py3-none-any.whl

tgzr/cuisine/_version.py

@@ -0,0 +1,34 @@
+# file generated by setuptools-scm
+# don't change, don't track in version control
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple
+    from typing import Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
+else:
+    VERSION_TUPLE = object
+    COMMIT_ID = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
+
+__version__ = version = '0.0.1'
+__version_tuple__ = version_tuple = (0, 0, 1)
+
+__commit_id__ = commit_id = None

tgzr/cuisine/basics/__init__.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING, Type
+
+from ..plugin import CuisinePlugin
+
+from ..recipe import Recipe
+from .recipe_with_params import RecipeWithParams
+
+from .computable import Computable
+from .files_recipes import FileRecipe
+from .workscene import WorkScene
+from .env import Env
+from .editable import Editable
+from .editor import Editor
+from .buildable import Buildable
+from .builder import Builder
+from .viewable import Viewable
+from .viewer import Viewer
+
+
+class BasicsPlugin(CuisinePlugin):
+
+    def get_recipe_types(self) -> list[Type[Recipe]]:
+        return [
+            Computable,
+            FileRecipe,
+            WorkScene,
+            Env,
+            Editable,
+            Editor,
+            Buildable,
+            Builder,
+            Viewable,
+            Viewer,
+        ]

tgzr/cuisine/basics/buildable.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+from typing import Any
+
+from .recipe_contexts import CookContext
+from tgzr.cuisine.recipe import RecipeTypeInfo
+from tgzr.cuisine.basics.files_recipes import FileRecipe
+
+
+@CookContext.context_type
+class BuildContext(CookContext):
+    to_build: Buildable
+
+
+class Buildable(FileRecipe):
+    """
+    A Recipe which cooks its 'build' input in its context.
+    """
+
+    RECIPE_TYPE_INFO = RecipeTypeInfo(
+        category="Build",
+        color="#FF8800",
+        icon="sym_o_brick",
+    )
+
+    def build_if_needed(self):
+        if not self.file_exists():
+            CookContext.current().log(
+                f"Scene {self.file_path()} is missing, we need to build it."
+            )
+            self.build()
+
+    def build(self):
+        builder = self.get_unique_input("build")
+        with CookContext.get(BuildContext, recipe=builder, to_build=self):
+            builder.cook()
+
+    def cook(self):
+        self.build_if_needed()

tgzr/cuisine/basics/builder.py

@@ -0,0 +1,72 @@
+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.buildable import BuildContext, Buildable
+from tgzr.cuisine.basics.product import Product
+from tgzr.cuisine.basics.env import Env, EnvBuilder
+
+
+class Builder(Recipe):
+    """
+    An Recipe which will build the 'file' from the current Buildable Recipe when
+    cooked.
+    """
+
+    def as_buildable(self, asset) -> Buildable | None:
+        if not isinstance(asset, Buildable):
+            return None
+        return asset
+
+    def as_product(self, asset) -> Product | None:
+        if not isinstance(asset, Product):
+            return None
+        return asset
+
+    def as_env(self, asset) -> Env | None:
+        if not isinstance(asset, Env):
+            return None
+        return asset
+
+    def build(self):
+        ctx = BuildContext.current()
+        if ctx is None:
+            raise Exception("Cannot build an Recipe outside of an EditContext.")
+
+        with ctx.log_group(
+            f"Cooking Products & Envs connected to {ctx.to_build.name!r}"
+        ):
+            env_inputs = self.get_typed_inputs(Env, "")
+            env_builder = EnvBuilder()
+            for name, env_input in env_inputs.items():
+                env_builder.add_bases(env_input.cook())
+            env = {}
+            env_builder.apply_to(env)
+            ctx.log(f"Env computed: {env}")
+
+            product_inputs = self.get_typed_inputs(Product, "")
+            for name, product_input in product_inputs.items():
+                with ctx.log_group(f"Cooking Product {name!r}"):
+                    product_input.cook()
+            ctx.log(f"All Products cooked: {env}")
+
+            for input_asset in ctx.to_build.get_inputs():
+                if product_input := self.as_product(input_asset):
+                    with ctx.log_group(f"Cooking {product_input.name!r}"):
+                        product_input.cook()
+                elif env_input := self.as_env(input_asset):
+                    with ctx.log_group(f"Cooking {env_input.name!r}"):
+                        env_builder = env_input.cook()
+                        env = {}
+
+                        ctx.log(f"Env computed: {env_builder}")
+                else:
+                    ctx.log(f"Skipping non Product nor Env input: {input_asset.name}")
+
+    def cook(self):
+        build_ctx = BuildContext.current(raises=False)
+        if build_ctx is None:
+            raise Exception("Cannot build an asset outside of a BuildContext.")
+        self.build()

tgzr/cuisine/basics/computable.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+from typing import Any
+
+from tgzr.cuisine.recipe import Recipe, RecipeTypeInfo
+from tgzr.cuisine.basics.recipe_with_params import RecipeWithParams
+
+
+class Computable(Recipe):
+    """
+    A Recipe returning a value in its 'cook()' method.
+
+    It can read params from inputs in the "params" group
+    with `get_inputs_params_dict()->dict[str, Any]`
+    """
+
+    RECIPE_TYPE_INFO = RecipeTypeInfo(
+        category="Compute",
+        color="#999999",
+        icon="sym_o_manufacturing",
+    )
+
+    def get_inputs_params_dict(self) -> dict[str, Any]:
+        inputs_with_param = self.get_typed_inputs(RecipeWithParams, "params")
+        params = {}
+        for name, input in inputs_with_param.items():
+            params.update(input.get_params_dict())
+        return params
+
+    def compute(self) -> Any:
+        return None
+
+    def cook(self) -> Any:
+        return self.compute()

tgzr/cuisine/basics/editable.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from tgzr.cuisine.basics.buildable import Buildable
+from tgzr.cuisine.basics.recipe_contexts import CookContext
+
+CookContext.context_type
+
+
+class EditContext(CookContext):
+    to_edit: Editable
+
+
+class Editable(Buildable):
+    """
+    A Buildable Recipe which cooks its 'edit' input in its context after building
+    it if needed.
+    """
+
+    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(EditContext, asset_to_view=self):
+            viewer.cook()
+
+    def cook(self):
+        super().cook()
+        self.view()

tgzr/cuisine/basics/editor.py

@@ -0,0 +1,29 @@
+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.editable import EditContext
+
+
+class Editor(Recipe):
+    """
+    An asset which will open the 'scene' from the current Editable asset with
+    an defined DCC when cooked.
+    """
+
+    RECIPE_TYPE_INFO = RecipeTypeInfo(
+        category="View",
+        color="#68FF98",
+        icon="sym_o_design_service",
+    )
+
+    def launch_editor(self, file_path: Path):
+        EditContext.current().log(f"Launching editor on {file_path}")
+
+    def cook(self):
+        ctx = EditContext.current(raises=False)
+        if ctx is None:
+            raise Exception("Cannot edit a Recipe outside of an EditContext.")
+        self.launch_editor(ctx.to_edit.file_path())

tgzr/cuisine/basics/env.py

@@ -0,0 +1,216 @@
+from __future__ import annotations
+from typing import Literal, Type, Any
+
+import os
+import logging
+
+from tgzr.cuisine.recipe import RecipeTypeInfo
+from tgzr.cuisine.basics.recipe_with_params import RecipeWithParams, RecipeParams
+
+
+logger = logging.getLogger(__name__)
+
+# ------ Env Builder (should be extracted to dedicated project !)
+
+
+class EnvOp:
+    @classmethod
+    def op_name(cls) -> str:
+        return cls.__name__
+
+    def __init__(self, var_name: str, **kwargs):
+        self._var_name = var_name
+        self._kwargs = kwargs
+        self.configure(**kwargs)
+
+    def configure(self, **kwargs) -> None:
+        raise NotImplementedError()
+
+    def var_name(self) -> str:
+        return self._var_name
+
+    def kwargs(self) -> dict[str, Any]:
+        return self._kwargs
+
+    def apply_to(self, env: dict[str, str]) -> None:
+        raise NotImplementedError()
+
+
+class Set(EnvOp):
+    """Set a env var value."""
+
+    def configure(self, value: str) -> None:
+        self.value = value
+
+    def apply_to(self, base: dict[str, str]) -> None:
+        base[self.var_name()] = self.value
+
+
+class Delete(EnvOp):
+    """Remove a env var."""
+
+    def configure(self, value=None) -> None:
+        if value is not None:
+            logger.debug(f"Skipping provided value {value} for delete operation.")
+
+    def apply_to(self, base: dict[str, str]) -> None:
+        try:
+            del base[self.var_name()]
+        except KeyError:
+            pass
+
+
+class Append(EnvOp):
+    """Append a value to a path env var."""
+
+    def configure(self, value: str) -> None:
+        self.value = value
+
+    def apply_to(self, base: dict[str, str]) -> None:
+        base_value = base.get(self.var_name(), "")
+        if base_value:
+            base_list = base_value.split(os.path.pathsep)
+        else:
+            base_list = []
+        base_list.append(self.value)
+        base[self.var_name()] = os.path.pathsep.join(base_list)
+
+
+class Prepend(EnvOp):
+    """Insert a value at the begining of a path env var."""
+
+    def configure(self, value: str) -> None:
+        self.value = value
+
+    def apply_to(self, base: dict[str, str]) -> None:
+        base_value = base.get(self.var_name(), "")
+        base_list = base_value.split(os.path.pathsep)
+        base_list.insert(0, self.value)
+        base[self.var_name()] = os.path.pathsep.join(base_list)
+
+
+class EnvBuilder:
+    OPS: dict[str, Type[EnvOp]] = dict(
+        set=Set, delete=Delete, append=Append, prepend=Prepend
+    )
+
+    @classmethod
+    def op_names(cls) -> tuple[str, ...]:
+        """The valid values for the `op_name` argument of `self.add_op(...)`"""
+        return tuple(cls.OPS.keys())
+
+    def __init__(self, *bases: EnvBuilder):
+        self._bases: tuple[EnvBuilder, ...] = bases
+        self._ops: list[EnvOp] = []
+
+    def add_bases(self, *bases: EnvBuilder, validate_bases: bool = True) -> None:
+        validated = []
+        if validate_bases:
+            for base in bases:
+                if not isinstance(base, self.__class__):
+                    print(
+                        f"WARNING: can't use {base} as base for {self}: it is not a {self.__class__} ! (skipping it)"
+                    )
+                else:
+                    validated.append(base)
+        else:
+            validated = bases
+        self._bases = self._bases + tuple(validated)
+
+    def ops(self) -> tuple[EnvOp, ...]:
+        return tuple(self._ops)
+
+    def add_op(self, op_name: str, var_name: str, **op_kwargs: Any):
+        op = self.OPS[op_name](var_name=var_name, **op_kwargs)
+        self._ops.append(op)
+
+    def set(self, name: str, value: str) -> None:
+        self.add_op("set", name, value=value)
+
+    def delete(self, name: str) -> None:
+        self.add_op("delete", name)
+
+    def append(self, name: str, value) -> None:
+        self.add_op("append", name, value=value)
+
+    def prepend(self, name: str, value) -> None:
+        self.add_op("prepend", name, value=value)
+
+    def apply_to(self, env: dict[str, str]):
+        for base in self._bases:
+            base.apply_to(env)
+        for op in self._ops:
+            op.apply_to(env)
+
+
+# ------ Cusine stuff
+
+
+class OpParam(RecipeParams):
+    enabled: bool = True
+    var_name: str = "MyVar"
+    op_name: Literal["set", "delete", "append", "prepend"] = "set"
+    value: str | None = None
+
+
+class EnvParams(RecipeParams):
+    enabled: bool = True
+    operations: list[OpParam] = []
+
+
+class Env(RecipeWithParams[EnvParams]):
+    """
+    A Computable Recipe returning a dict[str, str] from its cook method.
+    All input recipes must be Env recipes too, and the resulting dict will
+    confain the aggregation of all input dicts.
+
+    ! the inputs order is not 100% assured !
+    (we may need to find a solution for that)
+    """
+
+    RECIPE_TYPE_INFO = RecipeTypeInfo(
+        category="env",
+        color="#82fffb",
+        icon="landscape",
+    )
+
+    def get_local_env(self) -> EnvBuilder:
+        env = EnvBuilder()
+        env.append("visited_env_assets", self.name)
+        return env
+
+    def cook(self) -> EnvBuilder:
+
+        env = self.get_local_env()
+        for name, input in self.get_typed_inputs(Env, "").items():
+            input_env_builder = input.cook()
+            env.add_bases(input_env_builder)
+        return env
+
+    def _get_params_panel(self):
+        """Overridden to add custom field renderers"""
+        panel = super()._get_params_panel()
+
+        from tgzr.cuisine.basics.panels.params_panel import ModelField, ui
+
+        class OpField(ModelField):
+            @classmethod
+            def handles(cls, value_type) -> bool:
+                return value_type is OpParam
+
+            def op_symbol(self, op_name: str) -> str:
+                return dict(
+                    set="=",
+                    delete="delete",
+                    append="+=",
+                    prepend="+@0",
+                ).get(op_name, f"--{op_name}-->")
+
+            def _render_readonly_value(self):
+                op_param: OpParam = self._getter()
+                ui.label(
+                    f"{op_param.var_name} {self.op_symbol(op_param.op_name)} {op_param.value or ''}"
+                ).classes("pl-1 w-full font-mono").style(replace="")
+
+        panel.add_field_renderer(OpField)
+        return panel

tgzr/cuisine/basics/files_recipes/__init__.py

@@ -0,0 +1,18 @@
+from pathlib import Path
+
+from tgzr.cuisine.recipe import Recipe, RecipeTypeInfo
+
+
+class FileRecipe(Recipe):
+    RECIPE_TYPE_INFO = RecipeTypeInfo(
+        category="Files",
+        color="#00FFFF",
+        icon="sym_o_file",
+    )
+
+    def file_path(self) -> Path:
+        print(f"!!! WARNING !!! {self} IS JUST A MOCKUP CLASS !!!")
+        return Path(f"/path/to/work/{self.name}/{self.name}.xstage")
+
+    def file_exists(self) -> bool:
+        return self.file_path().exists()