pulze-renderflow 1.2.7__tar.gz → 2.0.7__tar.gz

{pulze_renderflow-1.2.7 → pulze_renderflow-2.0.7}/.gitignore

@@ -1,24 +1,25 @@
-__pycache__/
-*.py[cod]
-*$py.class
-*.so
-.Python
-build/
-develop-eggs/
-dist/
-downloads/
-eggs/
-.eggs/
-lib/
-lib64/
-parts/
-sdist/
-var/
-wheels/
-*.egg-info/
-.installed.cfg
-*.egg
-.env
-.venv
-venv/
-ENV/
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+.env
+.venv
+venv/
+ENV/
+

pulze_renderflow-2.0.7/CLAUDE.md

@@ -0,0 +1,30 @@
+# packages/sdks/python — CLAUDE.md
+
+The published Python SDK. **Standard library only — no runtime dependencies, ever.** The client
+imports inside a DCC's bundled Python with nothing installed; adding a dependency breaks every
+plugin that embeds it.
+
+## How it works
+
+- `renderflow/wire.py` binds operations off the OpenAPI document **at runtime** — there is no
+  generated per-operation code. `farm.jobs.get_jobs()` exists because the document says so.
+- `renderflow/openapi.json` is a **committed copy** of the service's `openapi.public.json`;
+  `sdk-surface.test.ts` (service) holds it byte-equal. A route change that skips regeneration fails
+  the suite.
+- `renderflow/models.pyi` = TypedDicts for editors/mypy, generated by `datamodel-code-generator`
+  (dev-only tool); `models.py` is a tiny runtime shim. A stub file never executes, so it may use
+  3.11 typing on a 3.10 interpreter.
+
+## Commands
+
+```bash
+python scripts/generate.py     # refresh openapi.json + models.pyi after a public route change
+python test/test_runtime.py    # stdlib unittest, no pytest
+```
+
+Both generated files are **committed** — review them like code. Publishing is manual
+(`python -m build` + `twine upload`), on its own cadence; this package's version field is real.
+
+`examples/` holds the example **custom plugins** (staged into installs as `sdk/examples`,
+excluded from the wheel — `packages = ["renderflow"]`). If a work-list marker or progress format
+changes, `job-progress` in the service reads recorded runtime output — keep them in step.

{pulze_renderflow-1.2.7 → pulze_renderflow-2.0.7}/MANIFEST.in

@@ -1,5 +1,5 @@
-include README.md
-include LICENSE
-recursive-include renderflow *.py
-recursive-exclude scripts *
-recursive-exclude examples *
+include README.md
+include LICENSE
+recursive-include renderflow *.py *.pyi openapi.json
+recursive-exclude scripts *
+recursive-exclude examples *

pulze_renderflow-2.0.7/PKG-INFO

@@ -0,0 +1,122 @@
+Metadata-Version: 2.5
+Name: pulze-renderflow
+Version: 2.0.7
+Summary: Official RenderFlow API client for Python
+Project-URL: Homepage, https://pulze.io/products/renderflow
+Author-email: Pulze <support@pulze.io>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: 3dsmax,arnold,blender,cinema4d,corona,fusion,houdini,maya,network-rendering,nuke,pulze,redshift,render-farm,renderflow,vray
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# renderflow
+
+Official Python client for the [RenderFlow](https://pulze.io/products/renderflow) API.
+
+## Installation
+
+```bash
+pip install pulze-renderflow
+```
+
+The package has **no dependencies** — the whole client is standard library. That is a feature,
+not an accident: drop the folder on `sys.path` and it works inside a DCC's bundled Python (Maya,
+Houdini, Nuke, VRED), where installing anything is a fight.
+
+## Quick start
+
+```python
+import renderflow as rf
+
+farm = rf.connect()                     # the local service on 127.0.0.1:44442
+# farm = rf.connect("https://rf.studio.lan:44442", api_key="rf_...")
+
+for job in farm.jobs.get_jobs(status="working").data:
+    print(job.name, job.status)
+```
+
+`connect()` falls back to the environment for each argument it isn't given: `RENDERFLOW_URL`
+for the address, `RENDERFLOW_API_KEY` for the key (the same variable `rfcli` reads). With
+neither, it talks to the service on this machine — which needs no credential, and is how a DCC
+plugin on a workstation submits.
+
+## Finding the operation you want
+
+Operations are grouped by tag and named after the API document's `operationId`, so a route
+reads the same here, in the TypeScript SDK, in `rfcli` and in the MCP tools:
+
+```python
+farm.tags()                 # every group: jobs, nodes, pools, schedule, ...
+dir(farm.jobs)              # every operation in one: get_jobs, create_job, stop_job, ...
+help(farm.jobs.get_jobs)    # the operation's own documentation, generated from the document
+```
+
+| you want | you write |
+| --- | --- |
+| `GET /jobs` | `farm.jobs.get_jobs()` |
+| `GET /jobs/{id}` | `farm.jobs.get_job(id)` |
+| `POST /jobs` | `farm.jobs.create_job(body=...)` |
+| `POST /jobs/{id}/stop` | `farm.jobs.stop_job(id)` |
+| `GET /nodes` | `farm.nodes.get_nodes()` |
+
+## Submitting a job
+
+A recipe — `type` plus a file and the flat per-DCC fields — is the short way in; the service
+expands it into the step tree:
+
+```python
+job = farm.jobs.create_job(body={
+    "type": "blender.render",
+    "file": "//share/scenes/shot_010.blend",
+    "frame": "1-100",
+    "pool_id": "...",
+})
+
+print(job.id, job.status)
+farm.jobs.stop_job(job.id)
+```
+
+Bodies are plain dicts; answers read with dot access (`job.name`, `page.data`) and hand back the
+raw payload via `.to_dict()`.
+
+## Models
+
+Typed names for every request and response schema live in `renderflow.models`, and your editor
+reads them from `models.pyi` — autocomplete and type checking with nothing to install:
+
+```python
+from renderflow.models import MayaRenderRecipe
+
+recipe: MayaRenderRecipe = {"type": "maya.render", "file": "//share/scenes/hero.mb", "host": {"name": "maya"}}
+farm.jobs.create_job(body=recipe)
+```
+
+At runtime a model is a dict — the wire is JSON and the service validates.
+
+## Errors
+
+A refused call raises `renderflow.wire.ApiError`, carrying the status and the service's own
+message — `str(error)` is the sentence an operator should read.
+
+## How this package is built
+
+There is no generated client. `renderflow/wire.py` binds operations off the OpenAPI document at
+runtime, and the document ships inside the package as `renderflow/openapi.json` — a committed
+copy of the service's `openapi.public.json`. An operation added to the API arrives here the
+moment that copy is refreshed:
+
+```bash
+python scripts/generate.py     # copies ../../service/openapi.public.json + rewrites models.pyi
+```
+
+`models.pyi` is written by [datamodel-code-generator](https://github.com/koxudaxi/datamodel-code-generator),
+a dev-only tool — never a dependency of the package.

pulze_renderflow-2.0.7/README.md

@@ -0,0 +1,102 @@
+# renderflow
+
+Official Python client for the [RenderFlow](https://pulze.io/products/renderflow) API.
+
+## Installation
+
+```bash
+pip install pulze-renderflow
+```
+
+The package has **no dependencies** — the whole client is standard library. That is a feature,
+not an accident: drop the folder on `sys.path` and it works inside a DCC's bundled Python (Maya,
+Houdini, Nuke, VRED), where installing anything is a fight.
+
+## Quick start
+
+```python
+import renderflow as rf
+
+farm = rf.connect()                     # the local service on 127.0.0.1:44442
+# farm = rf.connect("https://rf.studio.lan:44442", api_key="rf_...")
+
+for job in farm.jobs.get_jobs(status="working").data:
+    print(job.name, job.status)
+```
+
+`connect()` falls back to the environment for each argument it isn't given: `RENDERFLOW_URL`
+for the address, `RENDERFLOW_API_KEY` for the key (the same variable `rfcli` reads). With
+neither, it talks to the service on this machine — which needs no credential, and is how a DCC
+plugin on a workstation submits.
+
+## Finding the operation you want
+
+Operations are grouped by tag and named after the API document's `operationId`, so a route
+reads the same here, in the TypeScript SDK, in `rfcli` and in the MCP tools:
+
+```python
+farm.tags()                 # every group: jobs, nodes, pools, schedule, ...
+dir(farm.jobs)              # every operation in one: get_jobs, create_job, stop_job, ...
+help(farm.jobs.get_jobs)    # the operation's own documentation, generated from the document
+```
+
+| you want | you write |
+| --- | --- |
+| `GET /jobs` | `farm.jobs.get_jobs()` |
+| `GET /jobs/{id}` | `farm.jobs.get_job(id)` |
+| `POST /jobs` | `farm.jobs.create_job(body=...)` |
+| `POST /jobs/{id}/stop` | `farm.jobs.stop_job(id)` |
+| `GET /nodes` | `farm.nodes.get_nodes()` |
+
+## Submitting a job
+
+A recipe — `type` plus a file and the flat per-DCC fields — is the short way in; the service
+expands it into the step tree:
+
+```python
+job = farm.jobs.create_job(body={
+    "type": "blender.render",
+    "file": "//share/scenes/shot_010.blend",
+    "frame": "1-100",
+    "pool_id": "...",
+})
+
+print(job.id, job.status)
+farm.jobs.stop_job(job.id)
+```
+
+Bodies are plain dicts; answers read with dot access (`job.name`, `page.data`) and hand back the
+raw payload via `.to_dict()`.
+
+## Models
+
+Typed names for every request and response schema live in `renderflow.models`, and your editor
+reads them from `models.pyi` — autocomplete and type checking with nothing to install:
+
+```python
+from renderflow.models import MayaRenderRecipe
+
+recipe: MayaRenderRecipe = {"type": "maya.render", "file": "//share/scenes/hero.mb", "host": {"name": "maya"}}
+farm.jobs.create_job(body=recipe)
+```
+
+At runtime a model is a dict — the wire is JSON and the service validates.
+
+## Errors
+
+A refused call raises `renderflow.wire.ApiError`, carrying the status and the service's own
+message — `str(error)` is the sentence an operator should read.
+
+## How this package is built
+
+There is no generated client. `renderflow/wire.py` binds operations off the OpenAPI document at
+runtime, and the document ships inside the package as `renderflow/openapi.json` — a committed
+copy of the service's `openapi.public.json`. An operation added to the API arrives here the
+moment that copy is refreshed:
+
+```bash
+python scripts/generate.py     # copies ../../service/openapi.public.json + rewrites models.pyi
+```
+
+`models.pyi` is written by [datamodel-code-generator](https://github.com/koxudaxi/datamodel-code-generator),
+a dev-only tool — never a dependency of the package.

{pulze_renderflow-1.2.7 → pulze_renderflow-2.0.7}/pyproject.toml

@@ -1,57 +1,58 @@
-[build-system]
-requires = ["hatchling"]
-build-backend = "hatchling.build"
-
-[project]
-name = "pulze-renderflow"
-version = "1.2.7"
-description = "Official RenderFlow API client for Python"
-readme = "README.md"
-license = "MIT"
-requires-python = ">=3.10"
-authors = [
-    { name = "Pulze", email = "support@pulze.io" }
-]
-keywords = [
-    "3dsmax",
-    "arnold",
-    "blender",
-    "cinema4d",
-    "corona",
-    "fusion",
-    "houdini",
-    "maya",
-    "nuke",
-    "redshift",
-    "vray",
-    "network-rendering",
-    "pulze",
-    "render-farm",
-    "renderflow",
-]
-classifiers = [
-    "Development Status :: 4 - Beta",
-    "Intended Audience :: Developers",
-    "License :: OSI Approved :: MIT License",
-    "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.10",
-    "Programming Language :: Python :: 3.11",
-    "Programming Language :: Python :: 3.12",
-    "Programming Language :: Python :: 3.13",
-]
-dependencies = [
-    "httpx>=0.23.0,<1.0.0",
-    "pydantic>=2.0.0,<3.0.0",
-]
-
-[project.urls]
-Homepage = "https://pulze.io/products/renderflow"
-
-[tool.hatch.build.targets.wheel]
-packages = ["renderflow"]
-
-[tool.hatch.build.targets.sdist]
-exclude = [
-    "scripts/",
-    "examples/",
-]
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "pulze-renderflow"
+version = "2.0.7"
+description = "Official RenderFlow API client for Python"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.10"
+authors = [
+    { name = "Pulze", email = "support@pulze.io" }
+]
+keywords = [
+    "3dsmax",
+    "arnold",
+    "blender",
+    "cinema4d",
+    "corona",
+    "fusion",
+    "houdini",
+    "maya",
+    "nuke",
+    "redshift",
+    "vray",
+    "network-rendering",
+    "pulze",
+    "render-farm",
+    "renderflow",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+]
+# None, deliberately. The client binds to the OpenAPI document shipped inside the package
+# (`renderflow/wire.py` + `renderflow/openapi.json`), so the whole SDK is standard library —
+# it imports inside a DCC's bundled Python with nothing installed. The typed models are
+# `models.pyi`, which only editors read. datamodel-code-generator is a dev-only tool used by
+# `scripts/generate.py`, never a requirement of the package.
+dependencies = []
+
+[project.urls]
+Homepage = "https://pulze.io/products/renderflow"
+
+[tool.hatch.build.targets.wheel]
+packages = ["renderflow"]
+
+[tool.hatch.build.targets.sdist]
+exclude = [
+    "examples/",
+]

pulze_renderflow-2.0.7/renderflow/__init__.py

@@ -0,0 +1,176 @@
+"""RenderFlow — write a job, run it on the farm.
+
+Two halves, one import:
+
+    import renderflow as rf
+
+    plates = rf.files("plates", pattern="*.exr")   # declarations become UI fields and CLI flags
+
+    @rf.execute
+    def convert(plate):                            # runs on a render node, once per item
+        ...
+
+    farm = rf.connect()                            # and the REST API, when you want it
+    farm.jobs.get_jobs(status="working")
+
+**Importing this package touches nothing but the standard library.** That is a requirement, not a
+nicety: the runtime half runs on render nodes, under whatever Python the machine happens to have,
+and a node has no site-packages of ours. `connect()` is where httpx and the generated client load,
+which is why it is a function and not a class you construct at import time.
+"""
+
+from __future__ import annotations
+
+import atexit
+import os
+import sys
+from typing import TYPE_CHECKING, Any
+
+from . import runtime
+from .runtime import (
+    AppNotFound,
+    Fatal,
+    WorkItem,
+    app,
+    args,
+    bool_,
+    choice,
+    cleanup,
+    done,
+    env,
+    execute,
+    file,
+    files,
+    float_,
+    folder,
+    frames,
+    int_,
+    job,
+    log,
+    node,
+    output,
+    pairs,
+    path,
+    paths,
+    prepare,
+    progress,
+    resolution,
+    step,
+    submit,
+    task,
+    text,
+    tool,
+)
+
+# `int`, `float`, `bool` and `file` are builtins; inside this module the declarations are spelled
+# with a trailing underscore so they do not shadow them, and exported under the names the docs use.
+# A caller writes `rf.int("samples")` — `rf` is a namespace, so nothing is shadowed there.
+globals()["int"] = int_
+globals()["float"] = float_
+globals()["bool"] = bool_
+
+if TYPE_CHECKING:      # for editors only — importing this at runtime would pull in httpx
+    from .farm import Farm
+
+
+_INSPECT_FLAG = "--rf-inspect"
+
+if _INSPECT_FLAG in sys.argv:
+    # Inspecting means importing the script: its declarations only exist once its module body
+    # has run, so the schema is printed at interpreter exit rather than from here.
+    #
+    # The script's own prints go to stderr while that happens. They are still worth seeing when
+    # a schema comes out wrong, and they are not part of the answer.
+    sys.argv = [argument for argument in sys.argv if argument != _INSPECT_FLAG]
+    runtime._ctx.inspecting = True
+    _real_stdout = sys.stdout
+    sys.stdout = sys.stderr
+
+    @atexit.register
+    def _print_schema() -> None:
+        sys.stdout = _real_stdout
+        runtime._inspect()
+
+else:
+    # A bare `python script.py --plates ./x` runs the whole list here, at exit — the declarations
+    # only exist once the module body has run. A bootstrap binds values before the script imports
+    # us, which sets `driven` and keeps this out of its way.
+    runtime._read_argv(sys.argv[1:])
+
+    _previous_excepthook = sys.excepthook
+
+    def _mark_crashed(kind, value, trace) -> None:
+        runtime._ctx.crashed = True
+        _previous_excepthook(kind, value, trace)
+
+    sys.excepthook = _mark_crashed
+
+    @atexit.register
+    def _run_bare() -> None:
+        if runtime._ctx.driven or runtime._ctx.crashed or runtime._ctx.hooks["execute"] is None:
+            return
+
+        code = runtime._local(sys.argv[1:])
+        if code:
+            sys.stdout.flush()
+            sys.stderr.flush()
+            os._exit(code)    # atexit cannot set the exit code any other way
+
+__all__ = [
+    # connecting
+    "connect", "Farm",
+    # declarations
+    "text", "int", "float", "bool", "choice", "file", "folder", "pairs", "resolution", "output",
+    "frames", "files", "args",
+    # lifecycle
+    "execute", "submit", "prepare", "cleanup",
+    # context
+    "job", "step", "task", "node", "env", "paths", "path", "app", "tool",
+    # reporting
+    "progress", "log", "fatal", "done",
+    # exceptions
+    "Fatal", "AppNotFound", "WorkItem",
+]
+
+
+def connect(url: str | None = None, api_key: str | None = None, *, timeout: float = 60.0) -> "Farm":
+    """Connect to a farm.
+
+    Each argument falls back to the environment and then to the local service: ``url`` to
+    ``RENDERFLOW_URL`` then ``http://127.0.0.1:44442``, ``api_key`` to ``RENDERFLOW_API_KEY`` then
+    to no credential at all — which is what a caller on the machine itself needs.
+
+    The REST client loads here rather than at import, so a render node running a script never pays
+    for it and never needs it installed.
+    """
+    from .farm import Farm
+
+    return Farm(url, api_key, timeout=timeout)
+
+
+def fatal(message: str) -> None:
+    """End this task with a named reason. Re-exported from the runtime for `rf.fatal(...)`."""
+    from .runtime import fatal as _fatal
+
+    _fatal(message)
+
+
+def __getattr__(name: str) -> Any:
+    """`Farm` on demand — see the note at the top about staying stdlib-only at import."""
+    if name == "Farm":
+        from .farm import Farm
+
+        return Farm
+
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+from importlib.metadata import PackageNotFoundError, version as _version
+
+# Read from the installed distribution rather than written here: the two spellings had already
+# drifted (this said 2.0.0 while the package built 1.3.0), and a version a caller reads should be
+# the version they installed. `pyproject.toml` is the one place it is set.
+try:
+    __version__ = _version("pulze-renderflow")
+except PackageNotFoundError:        # a source checkout that was never installed
+    __version__ = "0.0.0.dev0"