tinyfan 0.0.2__tar.gz → 0.1.0__tar.gz

{tinyfan-0.0.2 → tinyfan-0.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tinyfan
-Version: 0.0.2
+Version: 0.1.0
 Summary: Tiny Argo Workflows python devkit
 Project-URL: Documentation, https://github.com/eunchuldev/tinyfan#readme
 Project-URL: Issues, https://github.com/eunchuldev/tinyfan/issues

tinyfan-0.1.0/examples/configmap.yaml

@@ -0,0 +1,7 @@
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: tinyfan-config-example
+data:
+  key: "configmapkeyref"
+  otherkey: "otherkeyref"

tinyfan-0.1.0/examples/configs.py

@@ -0,0 +1,31 @@
+import tinyfan
+from tinyfan import ConfigMapRef, ConfigMapKeyRef, SecretRef, SecretKeyRef, cli_arg
+
+flow = tinyfan.Flow(
+    name="configs",
+    configs={
+        "constant": "const",
+        "configmap": ConfigMapRef("tinyfan-config-example"),
+        "configmapkey": ConfigMapKeyRef("tinyfan-config-example", "key"),
+        "secret": SecretRef("tinyfan-config-example"),
+        "secretkey": SecretKeyRef("tinyfan-config-example", "secretkey"),
+        "cliarg": cli_arg("example"),
+    },
+)
+
+
+@tinyfan.asset(
+    schedule="*/1 * * * *",
+    flow=flow,
+)
+def trace_configs(
+    constant: str,
+    cliarg: str,
+    configmap: ConfigMapRef,
+    configmapkey: ConfigMapKeyRef,
+    secret: SecretRef,
+    secretkey: SecretKeyRef,
+):
+    print(
+        f'{constant} - {cliarg} - {configmap.get("otherkey")} - {configmapkey.get_value()} - {secret.get("othersecretkey")} - {secretkey.get_value()}'
+    )

tinyfan-0.1.0/examples/packaged/Dockerfile

@@ -0,0 +1,5 @@
+FROM python:3.12-slim
+
+WORKDIR /opt/app
+COPY . .
+RUN pip install --no-cache-dir .

tinyfan-0.1.0/examples/packaged/pyproject.toml

@@ -0,0 +1,13 @@
+[project]
+name = "tinyfan_examples_packaged"
+version = "0.0.1"
+description = "tinyfan pacakged example"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = ["tinyfan"]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+

tinyfan-0.1.0/examples/packaged/src/tinyfan_examples_packaged/asset.py

@@ -0,0 +1,23 @@
+import tinyfan
+from datetime import datetime
+
+
+@tinyfan.asset(
+    schedule="*/1 * * * *", container={"image": "tinyfan-examples-packaged:local", "imagePullPolicy": "Never"}
+)
+def target() -> str:
+    return "world"
+
+
+@tinyfan.asset(container={"image": "tinyfan-examples-packaged:local", "imagePullPolicy": "Never"})
+def greeting(target: str):
+    print("hello " + target)
+
+
+@tinyfan.asset(
+    schedule="*/1 * * * *", container={"image": "tinyfan-examples-packaged:local", "imagePullPolicy": "Never"}
+)
+def check_variables(ds: str, ts: str, data_interval_start: datetime, data_interval_end: datetime) -> None:
+    print(f"ds: {ds}, ts: {ts}")
+    print(f"data_interval_start: {data_interval_start}")
+    print(f"data_interval_end: {data_interval_end}")

tinyfan-0.1.0/examples/resource.py

@@ -0,0 +1,41 @@
+import tinyfan
+from tinyfan import ConfigMapKeyRef
+
+
+class Res(tinyfan.ResourceBase):
+    key: ConfigMapKeyRef
+
+    def __init__(self, key: ConfigMapKeyRef):
+        self.key = key
+
+
+class ResContainer(tinyfan.ResourceBase):
+    res: Res
+
+    def __init__(self, res: Res):
+        self.res = res
+
+
+flow = tinyfan.Flow(
+    name="configs",
+    resources={
+        "res": Res(ConfigMapKeyRef("tinyfan-config-example", "key")),
+        "res2": ResContainer(Res(ConfigMapKeyRef("tinyfan-config-example", "key"))),
+    },
+)
+
+
+@tinyfan.asset(
+    schedule="*/1 * * * *",
+    flow=flow,
+)
+def trace_res(res: Res):
+    print(f"{res.key.get_value()}")
+
+
+@tinyfan.asset(
+    schedule="*/1 * * * *",
+    flow=flow,
+)
+def trace_res2(res2: ResContainer):
+    print(f"{res2.res.key.get_value()}")

tinyfan-0.1.0/examples/secret.yaml

@@ -0,0 +1,7 @@
+apiVersion: v1
+kind: Secret
+metadata:
+  name: tinyfan-config-example
+stringData:
+  secretkey: secretkey # required field for kubernetes.io/basic-auth
+  othersecretkey: othersecretkey

{tinyfan-0.0.2 → tinyfan-0.1.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tinyfan"
-version = "0.0.2"
+version = "0.1.0"
 description = 'Tiny Argo Workflows python devkit'
 readme = "README.md"
 requires-python = ">=3.12"

tinyfan-0.1.0/src/tinyfan/__init__.py

@@ -0,0 +1,19 @@
+from .flow import Flow, Asset, asset
+from .stores.base import StoreBase
+from .stores.naive import NaiveStore
+from .config import ConfigMapRef, ConfigMapKeyRef, SecretRef, SecretKeyRef, cli_arg
+from .resources.base import ResourceBase
+
+__all__ = [
+    "Flow",
+    "Asset",
+    "asset",
+    "StoreBase",
+    "NaiveStore",
+    "ConfigMapRef",
+    "ConfigMapKeyRef",
+    "SecretRef",
+    "SecretKeyRef",
+    "cli_arg",
+    "ResourceBase",
+]

tinyfan-0.1.0/src/tinyfan/cli.py

@@ -0,0 +1,29 @@
+import typer
+
+from typing_extensions import Annotated
+from .codegen import codegen
+from .config import CLI_CONFIG_STATE
+
+
+def tinyfan(
+    location: str,
+    embedded: bool | None = None,
+    arg: Annotated[list[str] | None, typer.Option(metavar="KEY=VALUE")] = None,
+):
+    """
+    Generate argocd workflow resource as yaml from tinyfan definitions
+    """
+    if arg is not None:
+        CLI_CONFIG_STATE.cli_args.update({k: v for (k, v) in (val.split("=") for val in arg)})
+    if location.endswith(".py"):
+        print(codegen(location=location, embedded=embedded or True))
+    else:
+        print(codegen(location=location, embedded=embedded or False))
+
+
+def main():
+    return typer.run(tinyfan)
+
+
+if __name__ == "__main__":
+    main()

{tinyfan-0.0.2 → tinyfan-0.1.0}/src/tinyfan/codegen.py

@@ -1,4 +1,4 @@
-from tinyfan.flow import Flow, Asset, FLOW_CATALOG, DEFAULT_IMAGE
+from tinyfan.flow import Flow, Asset, FLOW_REGISTER, DEFAULT_IMAGE
 import importlib.util
 from typing import Self
 from .utils.yaml import dump as yaml_dump, dump_all as yaml_dump_all
@@ -14,6 +14,7 @@ import croniter
 from .argo_typing import ScriptTemplate
 from .utils.embed import embed
 from .utils.merge import deepmerge
+from .config import CLI_CONFIG_STATE, Config, ConfigValue, ConfigMapKeyRef, ConfigMapRef, SecretKeyRef, SecretRef
 
 VALID_CRON_REGEXP = r"^(?:(?:(?:(?:\d+,)+\d+|(?:\d+(?:\/|-|#)\d+)|\d+L?|\*(?:\/\d+)?|L(?:-\d+)?|\?|[A-Z]{3}(?:-[A-Z]{3})?) ?){5,7})|(@hourly|@daily|@midnight|@weekly|@monthly|@yearly|@annually)$"
 VALID_DEPENDS_REGEXP = r"^(?!.*\.[A-Za-z0-9_]+\.[A-Za-z0-9_]+)(?!.*\.(?!Succeeded|Failed|Errored|Skipped|Omitted|Daemoned)\w+)(?!.*(?:&&|\|\|)\s*(?:&&|\|\|))(?!.*!!)[A-Za-z0-9_&|!().\s]+$"
@@ -66,6 +67,7 @@ def import_all_submodules(location: str):
 
 class AssetNode:
     asset: Asset
+    refs: list[Config | ConfigValue | str | None]
     children: list[Self]
     parents: list[Self]
 
@@ -130,8 +132,18 @@ class AssetTree:
         for node in self.nodes.values():
             sigs = inspect.signature(node.asset.func)
             func_param_names = list(sigs.parameters.keys())
-            params_ids = set(name for name in func_param_names if name in self.flow.assets)
+            known_names = (
+                set(self.flow.assets.keys())
+                | set((self.flow.resources or {}).keys())
+                | set((self.flow.configs or {}).keys())
+            )
+            unknown_names = [n for n in func_param_names if n not in known_names]
+            if len(unknown_names) > 0:
+                raise Exception(
+                    f"unknown asset args: {', '.join('`' + n + '`' for n in unknown_names)} from asset `{node.asset.name}`"
+                )
 
+            params_ids = set(name for name in func_param_names if name in self.flow.assets)
             if node.asset.depends is not None:
                 depends_ids = set(re.findall(EXTRACT_DEPENDS_REGEXP, node.asset.depends))
                 node.parents = [self.nodes[n] for n in depends_ids.union(params_ids)]
@@ -146,6 +158,13 @@ class AssetTree:
                     p.children.append(node)
                 node.asset.depends = " && ".join(params_ids).replace("_", "-")
 
+            flow_resources = self.flow.resources or {}
+            flow_refs = self.flow.configs or {}
+            param_resources = [flow_resources[n] for n in func_param_names if n in flow_resources]
+            resource_refs = [ref for res in param_resources for ref in res.get_refs()]
+            param_refs = [flow_refs[n] for n in func_param_names if n in flow_refs]
+            node.refs = list(set(resource_refs + param_refs))
+
     def compile(
         self,
         embedded: bool = True,
@@ -154,8 +173,14 @@ class AssetTree:
         if len(self.nodes) == 0:
             return ""
 
+        source = ""
+        if embedded:
+            source += embed("tinyfan", excludes=["codegen.py", "utils/embed.py", "**/__pycache__/*"], minify=False)
+        source += (
+            "from tinyfan.config import CLI_CONFIG_STATE\n"
+            f"CLI_CONFIG_STATE.cli_args = {json.dumps(CLI_CONFIG_STATE.cli_args)}\n"
+        )
         if embedded:
-            source = embed("tinyfan", excludes=["codegen.py", "utils/embed.py", "**/__pycache__/*"], minify=False)
             root_location = get_root_path(list(self.nodes.values())[0].asset.func)
             source += embed(root_location)
             if not root_location.endswith(".py"):
@@ -227,6 +252,50 @@ class AssetTree:
                                         "image": DEFAULT_IMAGE,
                                         "command": ["python"],
                                         "source": """import os;exec(os.environ['TINYFAN_SOURCE'])""",
+                                        "env": [
+                                            {
+                                                "name": ref._env_name(),
+                                                "valueFrom": {
+                                                    "configMapKeyRef": {
+                                                        "name": ref.name,
+                                                        "key": ref.key,
+                                                    }
+                                                },
+                                            }
+                                            for ref in node.refs
+                                            if isinstance(ref, ConfigMapKeyRef)
+                                        ]
+                                        + [
+                                            {
+                                                "name": ref._env_name(),
+                                                "valueFrom": {
+                                                    "secretKeyRef": {
+                                                        "name": ref.name,
+                                                        "key": ref.key,
+                                                    }
+                                                },
+                                            }
+                                            for ref in node.refs
+                                            if isinstance(ref, SecretKeyRef)
+                                        ],
+                                        "envFrom": [
+                                            {
+                                                "configMapRef": {
+                                                    "name": ref.name,
+                                                }
+                                            }
+                                            for ref in node.refs
+                                            if isinstance(ref, ConfigMapRef)
+                                        ]
+                                        + [
+                                            {
+                                                "secretRef": {
+                                                    "name": ref.name,
+                                                }
+                                            }
+                                            for ref in node.refs
+                                            if isinstance(ref, SecretRef)
+                                        ],
                                     },
                                     container or {},
                                     self.flow.container or {},
@@ -316,11 +385,19 @@ class AssetTree:
 
 
 def codegen(
+    flow: Flow | None = None,
     location: str | None = None,
     embedded: bool = False,
     container: ScriptTemplate = {},
 ) -> str:
     """Generate argocd workflow resource as yaml from tinyfan definitions"""
-    if location:
+    CLI_CONFIG_STATE.codegen = True
+    if flow:
+        result = AssetTree(flow).compile(embedded, container)
+    elif location:
         import_all_submodules(location)
-    return "\n---\n".join(AssetTree(flow).compile(embedded, container) for flow in FLOW_CATALOG.values())
+        result = "\n---\n".join(AssetTree(flow).compile(embedded, container) for flow in FLOW_REGISTER.values())
+    else:
+        result = "\n---\n".join(AssetTree(flow).compile(embedded, container) for flow in FLOW_REGISTER.values())
+    CLI_CONFIG_STATE.codegen = False
+    return result

tinyfan-0.1.0/src/tinyfan/config.py

@@ -0,0 +1,97 @@
+from dataclasses import dataclass, field
+from abc import abstractmethod, ABC
+import os
+
+
+@dataclass
+class CliConfigState:
+    codegen: bool = False
+    cli_args: dict[str, str] = field(default_factory=dict)
+
+
+CLI_CONFIG_STATE = CliConfigState()
+
+
+def cli_arg(name: str, from_env: str | None = None):
+    if CLI_CONFIG_STATE.codegen:
+        if name not in CLI_CONFIG_STATE.cli_args:
+            if from_env is not None:
+                val = os.environ.get(from_env)
+                if val is None:
+                    raise Exception(f"neither of cli arg `{name}` nor env var `{from_env}` not setted.")
+                return val
+            raise Exception(f"cli arg `{name}` is not setted.")
+        else:
+            return CLI_CONFIG_STATE.cli_args[name]
+    else:
+        return CLI_CONFIG_STATE.cli_args.get(name)
+
+
+class ConfigValue(ABC):
+    @abstractmethod
+    def get_value(self) -> str:
+        raise Exception(NotImplemented)
+
+
+class Config(ABC):
+    @abstractmethod
+    def get(self, name: str) -> str:
+        raise Exception(NotImplemented)
+
+
+@dataclass(frozen=True)
+class ConfigMapRef(Config):
+    name: str
+
+    def get(self, name: str) -> str:
+        val = os.environ.get(name)
+        if val is None:
+            raise Exception(f"Fail to get `{name}` from ConfigMap `{self.name}`")
+        else:
+            return val
+
+
+@dataclass(frozen=True)
+class SecretRef(Config):
+    name: str
+
+    def get(self, name: str) -> str:
+        val = os.environ.get(name)
+        if val is None:
+            raise Exception(f"Fail to get `{name}` from Secret `{self.name}`")
+        else:
+            return val
+
+
+@dataclass(frozen=True)
+class ConfigMapKeyRef(ConfigValue):
+    name: str
+    key: str
+    default: str | None = None
+
+    def _env_name(self) -> str:
+        return "TINYFAN_CM__" + self.name + "__" + self.key
+
+    def get_value(self) -> str:
+        val = os.environ.get(self._env_name(), self.default)
+        if val is None:
+            raise Exception(f"Fail to get `{self.key}` from ConfigMap `{self.name}`")
+        else:
+            return val
+
+
+@dataclass(frozen=True)
+class SecretKeyRef(ConfigValue):
+    name: str
+    key: str
+    default: str | None = None
+
+    def _env_name(self) -> str:
+        return "TINYFAN_SC__" + self.name + "__" + self.key
+
+    def get_value(self) -> str:
+        val = os.environ.get(self._env_name(), self.default)
+        if val is None:
+            raise Exception(f"Fail to get `{self.key}` from Secret `{self.name}`")
+        else:
+            return val

{tinyfan-0.0.2 → tinyfan-0.1.0}/src/tinyfan/flow.py

@@ -3,31 +3,33 @@ from .stores.base import StoreBase
 from .stores.naive import NaiveStore
 from .flowrundata import FlowRunData, StoreIdx, UMeta
 from dataclasses import dataclass, field
-from typing import Callable, Any, Generic, TypeVar, Mapping
+from typing import Callable, Any, Generic, TypeVar
+from .resources.base import ResourceBase
 from .argo_typing import ScriptTemplate
+from .config import Config, ConfigValue
 
-FLOW_CATALOG = {}
+FLOW_REGISTER = {}
 
-Res = TypeVar("Res", bound=Mapping)
 Ret = TypeVar("Ret")
 
 DEFAULT_IMAGE = "python:alpine"
 
 
 @dataclass
-class Flow(Generic[Res]):
+class Flow:
     name: str
     tz: str = "UTC"
-    assets: dict[str, "Asset[Any, Res, Any, Any]"] = field(default_factory=dict)
-    resources: Res | None = None
+    assets: dict[str, "Asset[Any, Any, Any]"] = field(default_factory=dict)
+    resources: dict[str, ResourceBase] | None = None
     container: ScriptTemplate | None = None
     store: StoreBase = field(default_factory=NaiveStore)
+    configs: dict[str, Config | ConfigValue | str | None] = field(default_factory=dict)
 
     def __post_init__(self):
-        FLOW_CATALOG[self.name] = self
+        FLOW_REGISTER[self.name] = self
 
 
-DEFAULT_FLOW: Flow[Any] = Flow(
+DEFAULT_FLOW: Flow = Flow(
     "tinyfan",
     container={
         "image": DEFAULT_IMAGE,
@@ -36,8 +38,8 @@ DEFAULT_FLOW: Flow[Any] = Flow(
 
 
 @dataclass
-class Asset(Generic[Ret, Res, UMeta, StoreIdx]):
-    flow: Flow[Res]
+class Asset(Generic[Ret, UMeta, StoreIdx]):
+    flow: Flow
     func: Callable[..., Ret]
     store: StoreBase[Ret, UMeta, StoreIdx]
     schedule: str | None = None
@@ -62,11 +64,15 @@ class Asset(Generic[Ret, Res, UMeta, StoreIdx]):
         mod = inspect.getmodule(self.func)
         if mod and mod.__name__:
             rundata["module_name"] = mod.__name__
-        params = {k: v for k, v in rundata.items() if k in func_param_names}
+        params: dict[str, object] = {k: v for k, v in rundata.items() if k in func_param_names}
         if self.flow.resources:
-            for k, v in self.flow.resources:
+            for k, v in self.flow.resources.items():
                 if k in func_param_names:
                     params[k] = v
+        if self.flow.configs:
+            for k2, v2 in self.flow.configs.items():
+                if k2 in func_param_names:
+                    params[k2] = v2
 
         parent_flowrundatas: dict[str, FlowRunData] = rundata.get("parents") or {}
         for name, prundata in parent_flowrundatas.items():
@@ -83,11 +89,11 @@ class Asset(Generic[Ret, Res, UMeta, StoreIdx]):
         return (ret, rundata)
 
 
-class AssetFunc(Generic[Ret, Res, UMeta, StoreIdx]):
+class AssetFunc(Generic[Ret, UMeta, StoreIdx]):
     func: Callable[..., Ret]
-    asset: Asset[Ret, Res, UMeta, StoreIdx]
+    asset: Asset[Ret, UMeta, StoreIdx]
 
-    def __init__(self, func: Callable[..., Ret], asset: Asset[Ret, Res, UMeta, StoreIdx]):
+    def __init__(self, func: Callable[..., Ret], asset: Asset[Ret, UMeta, StoreIdx]):
         self.func = func
         self.asset = asset
 
@@ -97,16 +103,16 @@ class AssetFunc(Generic[Ret, Res, UMeta, StoreIdx]):
 
 
 def asset(
-    flow: Flow[Res] = DEFAULT_FLOW,
+    flow: Flow = DEFAULT_FLOW,
     schedule: str | None = None,
     depends: str | None = None,
     store: StoreBase[Ret, UMeta, StoreIdx] | None = None,
     tz: str | None = None,
     metadata: UMeta | None = None,
     container: ScriptTemplate | None = None,
-) -> Callable[..., AssetFunc[Ret, Res, UMeta, StoreIdx]]:
-    def wrapper(func: Callable[..., Ret]) -> AssetFunc[Ret, Res, UMeta, StoreIdx]:
-        asset = Asset[Ret, Res, UMeta, StoreIdx](
+) -> Callable[..., AssetFunc[Ret, UMeta, StoreIdx]]:
+    def wrapper(func: Callable[..., Ret]) -> AssetFunc[Ret, UMeta, StoreIdx]:
+        asset = Asset[Ret, UMeta, StoreIdx](
             flow,
             func=func,
             depends=depends,

tinyfan-0.1.0/src/tinyfan/resources/base.py

@@ -0,0 +1,12 @@
+from ..config import Config, ConfigValue
+
+
+class ResourceBase:
+    def get_refs(self) -> set[Config | ConfigValue]:
+        refs = set()
+        for _, value in vars(self).items():
+            if isinstance(value, (Config, ConfigValue)):  # or a common base 'Reference'
+                refs.add(value)
+            elif isinstance(value, ResourceBase):
+                refs |= ResourceBase.get_refs(value)
+        return refs

{tinyfan-0.0.2 → tinyfan-0.1.0}/src/tinyfan/stores/base.py

@@ -1,11 +1,12 @@
-from abc import abstractmethod
+from abc import abstractmethod, ABC
 from typing import Generic, TypeVar
+from ..resources.base import ResourceBase
 from ..flowrundata import FlowRunData, StoreIdx, UMeta
 
 T = TypeVar("T")
 
 
-class StoreBase(Generic[T, UMeta, StoreIdx]):
+class StoreBase(ABC, ResourceBase, Generic[T, UMeta, StoreIdx]):
     @staticmethod
     @abstractmethod
     def id() -> str:

{tinyfan-0.0.2 → tinyfan-0.1.0}/tests/test_codegen.py

@@ -1,24 +1,42 @@
 from tinyfan import Flow, asset
-from tinyfan.codegen import codegen, AssetTree, RUNDATA_FILE_PATH
+from tinyfan.flow import FLOW_REGISTER
+from tinyfan.codegen import codegen, AssetTree
 from jsonschema.exceptions import ValidationError
-from io import StringIO
+from typing import Generator
 import os
-from contextlib import redirect_stdout
-from .helpers import gotmpl
-import yaml
+import pytest
 
-flow: Flow = Flow("test")
 
+# type: ignore
+@pytest.fixture()
+def sample_flow() -> Generator:
+    flow: Flow = Flow("test")
 
-@asset(flow=flow, schedule="@daily")
-def asset1():
-    print("asset1 is executed")
-    return "hello"
+    @asset(flow=flow, schedule="@daily")
+    def asset1():  # type: ignore
+        print("asset1 is executed")
+        return "hello"
 
+    @asset(flow=flow)
+    def asset2(asset1: str):  # type: ignore
+        print("asset1 says: " + asset1)
 
-@asset(flow=flow)
-def asset2(asset1: str):
-    print("asset1 says: " + asset1)
+    yield flow
+    FLOW_REGISTER.clear()
+
+
+# type: ignore
+@pytest.fixture()
+def unknown_arg_flow() -> Generator:
+    flow: Flow = Flow("test")
+
+    @asset(flow=flow, schedule="@daily")
+    def asset1(unknown: str):  # type: ignore
+        print("asset1 is executed")
+        return "hello"
+
+    yield flow
+    FLOW_REGISTER.clear()
 
 
 def gotmpl_values(tree: AssetTree, asset_name: str, schedule: str) -> dict:
@@ -43,6 +61,7 @@ def gotmpl_values(tree: AssetTree, asset_name: str, schedule: str) -> dict:
 def assert_code_is_running(code: str):
     # comment out all assertion since templateDefault script override is not working
     return
+    """
     sourcetmpl = next(yaml.load_all(code, yaml.Loader))["spec"]["workflowSpec"]["templates"][0]["script"]["source"]
     tree = AssetTree(flow)
     values = gotmpl_values(tree, "asset1", "@daily")
@@ -62,15 +81,27 @@ def assert_code_is_running(code: str):
     with redirect_stdout(f):
         exec(source)
     assert "asset1 says: hello\n" == f.getvalue()
+    """
+
+
+def test_codegen_raise_unknown_asset_args(unknown_arg_flow):
+    with pytest.raises(Exception):
+        _ = codegen(flow=unknown_arg_flow)
+
+
+def test_codegen_flow(validate_crds, sample_flow):
+    actual = codegen(flow=sample_flow)
+    validate_crds(actual)
+    assert_code_is_running(actual)
 
 
-def test_codegen(validate_crds, assert_manifests):
+def test_codegen_implicit(validate_crds, sample_flow):
     actual = codegen()
     validate_crds(actual)
     assert_code_is_running(actual)
 
 
-def test_embedded_codegen(validate_crds, assert_manifests):
+def test_embedded_codegen(validate_crds, sample_flow):
     actual = codegen(embedded=True)
     validate_crds(actual)
     assert_code_is_running(actual)

{tinyfan-0.0.2 → tinyfan-0.1.0}/uv.lock

@@ -774,7 +774,7 @@ wheels = [
 
 [[package]]
 name = "tinyfan"
-version = "0.0.2"
+version = "0.1.0"
 source = { editable = "." }
 dependencies = [
     { name = "croniter" },

tinyfan-0.0.2/examples/realworld/pyproject.toml

@@ -1,7 +0,0 @@
-[project]
-name = "code"
-version = "0.0.1"
-description = "vtown"
-readme = "README.md"
-requires-python = ">=3.10"
-dependencies = []

tinyfan-0.0.2/src/tinyfan/__init__.py

@@ -1,5 +0,0 @@
-from .flow import Flow, Asset, asset
-from .stores.base import StoreBase
-from .stores.naive import NaiveStore
-
-__all__ = ["Flow", "Asset", "asset", "StoreBase", "NaiveStore"]

tinyfan-0.0.2/src/tinyfan/cli.py

@@ -1,24 +0,0 @@
-import typer
-
-from .codegen import codegen
-
-
-def tinyfan(
-    location: str,
-    embedded: bool = False,
-):
-    """
-    Generate argocd workflow resource as yaml from tinyfan definitions
-    """
-    if location.endswith(".py"):
-        print(codegen(location=location, embedded=True))
-    else:
-        print(codegen(location=location, embedded=embedded))
-
-
-def main():
-    return typer.run(tinyfan)
-
-
-if __name__ == "__main__":
-    main()