pulze-scenemanager 3.0.0__tar.gz

pulze_scenemanager-3.0.0/.gitignore

@@ -0,0 +1,3 @@
+dist/
+__pycache__/
+*.egg-info/

pulze_scenemanager-3.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sourceline / Pulze
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pulze_scenemanager-3.0.0/PKG-INFO

@@ -0,0 +1,51 @@
+Metadata-Version: 2.5
+Name: pulze-scenemanager
+Version: 3.0.0
+Summary: Official Scene Manager API client for Python
+Project-URL: Homepage, https://pulze.io/products/scene-manager
+Author-email: Pulze <support@pulze.io>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: 3dsmax,corona,pulze,render-setups,scene-manager,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
+
+# pulze-scenemanager
+
+The official Python client for [Scene Manager](https://pulze.io/products/scene-manager)'s local API: setups, folders, modules, batch renders and scene comments in 3ds Max.
+
+```bash
+pip install pulze-scenemanager
+```
+
+```python
+import scenemanager as sm
+
+scene = sm.connect()  # Scene Manager on this computer
+
+for setup in scene.setups.list_setups().setups:
+    print(setup.name)
+
+first = scene.setups.list_setups().setups[0]
+scene.setups.activate_setup(first.id)
+scene.render.start_render(body={"setups": [first.id]})
+batch = scene.render.wait()  # until the batch render is over
+```
+
+- **Standard library only.** No dependencies, so it also imports inside 3ds Max's own Python.
+- **Scene Manager must be running** on this computer (open it from 3ds Max). It answers on `http://127.0.0.1:45710`; set `SCENEMANAGER_URL` or `SCENEMANAGER_PORT`, or pass a URL to `connect()`, to change that.
+- **A Scene Manager licence** on this computer is needed for every call but `scene.health.get_health()`, which says whether there is one. Without it, a call raises `ApiError` with status `402`.
+- **Methods are the API's operations**, grouped by the route's first segment (`scene.setups`, `scene.scene`, `scene.comments`, `scene.render`, ...) and named as in the API reference, the TypeScript client and `smcli`, in snake_case. Path parameters are positional, query parameters are named, and a request body is `body=`.
+- **Answers read with dots** (`setup.name`); `to_dict()` gives the raw payload. Pictures (thumbnails, shots) are `bytes`. A refused call raises `ApiError` with `status` and Scene Manager's reason.
+
+`models.pyi` types every payload for editors and type checkers.
+
+MIT licensed. The Scene Manager application itself is licensed separately by Pulze.

pulze_scenemanager-3.0.0/README.md

@@ -0,0 +1,31 @@
+# pulze-scenemanager
+
+The official Python client for [Scene Manager](https://pulze.io/products/scene-manager)'s local API: setups, folders, modules, batch renders and scene comments in 3ds Max.
+
+```bash
+pip install pulze-scenemanager
+```
+
+```python
+import scenemanager as sm
+
+scene = sm.connect()  # Scene Manager on this computer
+
+for setup in scene.setups.list_setups().setups:
+    print(setup.name)
+
+first = scene.setups.list_setups().setups[0]
+scene.setups.activate_setup(first.id)
+scene.render.start_render(body={"setups": [first.id]})
+batch = scene.render.wait()  # until the batch render is over
+```
+
+- **Standard library only.** No dependencies, so it also imports inside 3ds Max's own Python.
+- **Scene Manager must be running** on this computer (open it from 3ds Max). It answers on `http://127.0.0.1:45710`; set `SCENEMANAGER_URL` or `SCENEMANAGER_PORT`, or pass a URL to `connect()`, to change that.
+- **A Scene Manager licence** on this computer is needed for every call but `scene.health.get_health()`, which says whether there is one. Without it, a call raises `ApiError` with status `402`.
+- **Methods are the API's operations**, grouped by the route's first segment (`scene.setups`, `scene.scene`, `scene.comments`, `scene.render`, ...) and named as in the API reference, the TypeScript client and `smcli`, in snake_case. Path parameters are positional, query parameters are named, and a request body is `body=`.
+- **Answers read with dots** (`setup.name`); `to_dict()` gives the raw payload. Pictures (thumbnails, shots) are `bytes`. A refused call raises `ApiError` with `status` and Scene Manager's reason.
+
+`models.pyi` types every payload for editors and type checkers.
+
+MIT licensed. The Scene Manager application itself is licensed separately by Pulze.

pulze_scenemanager-3.0.0/pyproject.toml

@@ -0,0 +1,37 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "pulze-scenemanager"
+version = "3.0.0"
+description = "Official Scene Manager API client for Python"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.10"
+authors = [
+    { name = "Pulze", email = "support@pulze.io" }
+]
+keywords = ["3dsmax", "corona", "vray", "scene-manager", "render-setups", "pulze"]
+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 (as RenderFlow's SDK): the client binds to the OpenAPI document shipped inside
+# the package (`scenemanager/wire.py` + `scenemanager/openapi.json`), so the whole SDK is standard
+# library and imports inside 3ds Max's Python with nothing installed. The typed models are
+# `models.pyi`, which only editors read; datamodel-code-generator is a dev-only tool of
+# `scripts/generate.py`, never a requirement of the package.
+dependencies = []
+
+[project.urls]
+Homepage = "https://pulze.io/products/scene-manager"
+
+[tool.hatch.build.targets.wheel]
+packages = ["scenemanager"]

pulze_scenemanager-3.0.0/scenemanager/__init__.py

@@ -0,0 +1,23 @@
+"""Scene Manager's Python client: setups, modules, renders and comments over its local REST API.
+
+    import scenemanager as sm
+
+    scene = sm.connect()
+    for setup in scene.setups.list_setups().setups:
+        print(setup.name)
+
+Standard library only, so it imports inside 3ds Max's own Python with nothing installed. Scene
+Manager must be running on this computer, with a licence.
+"""
+
+from importlib.metadata import PackageNotFoundError, version as _version
+
+from .client import Group, RenderGroup, SceneManager, connect, default_url
+from .wire import ApiError, Data
+
+try:
+    __version__ = _version("pulze-scenemanager")
+except PackageNotFoundError:  # from a checkout
+    __version__ = "0.0.0"
+
+__all__ = ["ApiError", "Data", "Group", "RenderGroup", "SceneManager", "connect", "default_url", "__version__"]

pulze_scenemanager-3.0.0/scenemanager/client.py

@@ -0,0 +1,138 @@
+"""The Scene Manager API client.
+
+    import scenemanager as sm
+
+    scene = sm.connect()                            # Scene Manager on this computer
+    for setup in scene.setups.list_setups().setups:
+        print(setup.name)
+    scene.setups.activate_setup(setup.id)
+    scene.render.start_render(body={"setups": [setup.id]})
+    scene.render.wait()                             # until the batch render is over
+
+Operations are grouped by the route's first segment and named after the document's
+``operationId``: the same names the REST route, the TypeScript SDK and ``smcli`` use, so one
+operation reads the same everywhere. ``scene.setups.list_setups`` is ``GET /setups``;
+``scene.setups.activate_setup(id)`` is ``POST /setups/{id}/activate``.
+
+Nothing here is written per operation, and nothing is generated: the methods are the operations of
+the OpenAPI document shipped inside this package (``scenemanager/openapi.json``), bound on first
+use. Bodies are plain dicts; answers read with dot access (``setup.name``) and hand back the raw
+payload via ``to_dict()``. The typed view of it all is ``models.pyi``, which the editor reads and
+the interpreter never pays for: the whole client is standard library, so it runs inside 3ds Max's
+own Python.
+
+Scene Manager needs a licence on this computer: without one every call but
+``scene.health.get_health()`` raises ``ApiError`` with status 402.
+"""
+
+from __future__ import annotations
+
+import os
+import time
+from typing import Any, Callable
+
+from . import wire
+from .wire import ApiError, Client
+
+DEFAULT_PORT = 45710
+
+
+def default_url() -> str:
+    """Where Scene Manager answers on this computer: ``SCENEMANAGER_URL``, else ``SCENEMANAGER_PORT`` (45710)."""
+    url = os.environ.get("SCENEMANAGER_URL", "").strip()
+    if url:
+        return url
+    return "http://127.0.0.1:{0}".format(os.environ.get("SCENEMANAGER_PORT", "").strip() or DEFAULT_PORT)
+
+
+class Group:
+    """One group's operations, bound to Scene Manager: ``scene.setups``, ``scene.comments``."""
+
+    def __init__(self, owner: "SceneManager", name: str) -> None:
+        self._owner = owner
+        self._name = name
+        self._operations = wire.operations()[name]
+
+    def __dir__(self) -> list[str]:
+        return sorted(self._operations)
+
+    def __getattr__(self, name: str) -> Callable[..., Any]:
+        try:
+            operation = self._operations[name]
+        except KeyError:
+            raise AttributeError(f"`{self._name}` has no operation `{name}`. Available: {', '.join(self.__dir__())}") from None
+        client = self._owner._client
+
+        def call(*args: Any, **kwargs: Any) -> Any:
+            return client.call(operation, args, kwargs)
+
+        call.__name__ = name
+        call.__doc__ = operation.doc
+        setattr(self, name, call)  # resolved once; afterwards a plain attribute
+        return call
+
+    def __repr__(self) -> str:
+        return f"<scenemanager group {self._name}: {len(self._operations)} operations>"
+
+
+#: How a batch render ends.
+FINISHED = ("done", "stopped")
+
+
+class RenderGroup(Group):
+    """``render``, plus the one wait that is not an operation of the document."""
+
+    def __dir__(self) -> list[str]:
+        return sorted({*super().__dir__(), "wait"})
+
+    def wait(self, *, timeout: float | None = None, interval: float = 2.0) -> Any:
+        """Waits for the batch render to end (done or stopped). Answers the batch, or ``None`` when
+        there is none. Polls ``get_render``; ``timeout`` is seconds (none by default: a batch can
+        render for hours), and running out raises ``TimeoutError``."""
+        deadline = None if timeout is None else time.monotonic() + timeout
+        while True:
+            batch = self.get_render().batch
+            if batch is None or batch.state in FINISHED:
+                return batch
+            if deadline is not None and time.monotonic() >= deadline:
+                raise TimeoutError(f"the batch render had not ended after {timeout}s")
+            time.sleep(interval if deadline is None else min(interval, max(0.0, deadline - time.monotonic())))
+
+
+GROUPS = {"render": RenderGroup}
+
+
+class SceneManager:
+    """A connection to Scene Manager on this computer. Prefer ``scenemanager.connect()``."""
+
+    def __init__(self, url: str | None = None, *, timeout: float = 120.0) -> None:
+        self.url = (url or default_url()).rstrip("/")
+        base_url = self.url if self.url.endswith("/api/v1") else f"{self.url}/api/v1"
+        self._client = Client(base_url=base_url, timeout=timeout)
+        self._groups: dict[str, Group] = {}
+
+    def __dir__(self) -> list[str]:
+        return sorted({*super().__dir__(), *self.groups()})
+
+    def groups(self) -> list[str]:
+        return sorted(wire.operations())
+
+    def __getattr__(self, name: str) -> Group:
+        if name.startswith("_"):
+            raise AttributeError(name)
+        if name not in self._groups:
+            if name not in self.groups():
+                raise AttributeError(f"Scene Manager has no `{name}`. Available: {', '.join(self.groups())}")
+            self._groups[name] = GROUPS.get(name, Group)(self, name)
+        return self._groups[name]
+
+    def __repr__(self) -> str:
+        return f"<SceneManager {self.url}>"
+
+
+def connect(url: str | None = None, *, timeout: float = 120.0) -> SceneManager:
+    """Scene Manager on this computer (``SCENEMANAGER_URL`` or ``SCENEMANAGER_PORT`` to change)."""
+    return SceneManager(url, timeout=timeout)
+
+
+__all__ = ["ApiError", "Group", "RenderGroup", "SceneManager", "connect", "default_url"]

pulze_scenemanager-3.0.0/scenemanager/models.pyi

@@ -0,0 +1,331 @@
+# generated by datamodel-codegen:
+#   filename:  openapi.json
+
+from __future__ import annotations
+
+from typing import Any, Literal, NotRequired, TypeAlias, TypedDict
+
+
+class Busy(TypedDict):
+    what: str
+    label: str
+    since: str
+
+
+class Health(TypedDict):
+    ok: bool
+    version: str
+    build: NotRequired[str]
+    connected: bool
+    licensed: bool
+    pid: NotRequired[float]
+    person: str
+    names: NotRequired[float]
+    busy: NotRequired[Busy]
+    generation: NotRequired[float]
+    helper: str
+
+
+class Error(TypedDict):
+    error: str
+
+
+SceneDocument: TypeAlias = dict[str, Any]
+
+
+class SkippedItem(TypedDict):
+    what: str
+    reason: str
+    setups: list[str]
+
+
+class ImportReport(TypedDict):
+    setups: float
+    modules: list[str]
+    skipped: list[SkippedItem]
+    at: NotRequired[str]
+
+
+class RefusedItem(TypedDict):
+    key: str
+    reason: str
+
+
+class Source(TypedDict):
+    kind: Literal["setup", "folder", "quality"]
+    id: str
+
+
+class Change(TypedDict):
+    target: str
+    param: str
+    value: NotRequired[Any]
+    module: str
+    source: Source
+
+
+class SkippedItem1(TypedDict):
+    name: str
+    reason: str
+
+
+class Result(TypedDict):
+    target: str
+    applied: list[str]
+    skipped: list[SkippedItem1]
+
+
+class ActivationStep(TypedDict):
+    id: str
+    label: str
+    state: Literal["queued", "running", "done", "skipped", "failed"]
+    ms: NotRequired[float]
+    error: NotRequired[str]
+
+
+class ActivationProgress(TypedDict):
+    setup: str
+    name: str
+    started: str
+    steps: list[ActivationStep]
+    finished: NotRequired[str]
+    ms: NotRequired[float]
+
+
+class SetupSummary(TypedDict):
+    id: str
+    name: str
+    folder: NotRequired[str]
+    description: NotRequired[str]
+    tags: NotRequired[list[str]]
+    color: NotRequired[str]
+    modulesOff: list[str]
+
+
+class FolderSummary(TypedDict):
+    id: str
+    name: str
+    parent: NotRequired[str]
+    color: NotRequired[str]
+
+
+class Item(TypedDict):
+    setup: str
+    set: NotRequired[str]
+    row: NotRequired[list[float]]
+    name: str
+    status: Literal["queued", "applying", "rendering", "done", "failed", "stopped"]
+    error: NotRequired[str]
+    skipped: NotRequired[float]
+    output: NotRequired[str]
+    capped: NotRequired[str]
+    started: NotRequired[str]
+    finished: NotRequired[str]
+
+
+class BatchRender(TypedDict):
+    id: str
+    state: Literal["running", "done", "stopped"]
+    agent: NotRequired[bool]
+    started: str
+    finished: NotRequired[str]
+    items: list[Item]
+
+
+class Link(TypedDict):
+    target: str
+    name: NotRequired[str]
+    detail: NotRequired[str]
+
+
+class Author(TypedDict):
+    name: str
+    kind: Literal["person", "agent"]
+    via: NotRequired[str]
+    picture: NotRequired[str]
+
+
+ShotPoint: TypeAlias = list[Any]
+
+
+ShotArea: TypeAlias = list[Any]
+
+
+class Mark1(TypedDict):
+    kind: Literal["pen"]
+    color: str
+    points: list[float]
+
+
+Mark2 = TypedDict(
+    "Mark2",
+    {
+        "kind": Literal["line", "arrow", "rect", "ellipse"],
+        "color": str,
+        "from": ShotPoint,
+        "to": ShotPoint,
+    },
+)
+
+
+class Mark3(TypedDict):
+    kind: Literal["text"]
+    color: str
+    at: ShotPoint
+    text: str
+    size: NotRequired[Literal["small", "normal", "medium", "large"]]
+
+
+Mark: TypeAlias = Mark1 | Mark2 | Mark3
+
+
+class MadeChange(TypedDict):
+    target: str
+    name: NotRequired[str]
+    param: str
+    before: NotRequired[Any]
+    after: NotRequired[Any]
+    setup: NotRequired[str]
+
+
+class SavedView(TypedDict):
+    type: str
+    camera: NotRequired[str]
+    cameraName: NotRequired[str]
+    matrix: NotRequired[list[float]]
+    fov: NotRequired[float]
+    focus: NotRequired[float]
+    target: NotRequired[list[Any]]
+    size: NotRequired[list[Any]]
+
+
+class SetupThumbnail(TypedDict):
+    source: Literal["viewport", "framebuffer", "file"]
+    width: float
+    height: float
+    mime: str
+    at: str
+
+
+class PreviewJob(TypedDict):
+    set: str
+    state: Literal["running", "done", "stopped", "failed"]
+    folder: str
+    done: float
+    total: float
+    error: NotRequired[str]
+    started: str
+    finished: NotRequired[str]
+
+
+class ResolutionPreset(TypedDict):
+    name: str
+    width: float
+    height: float
+
+
+class Switching(TypedDict):
+    viewport: Literal["active", "views", "render"]
+    redraw: bool
+    coronaInteractive: bool
+    vrayIpr: bool
+    notify: bool
+
+
+class Settings(TypedDict):
+    hdriFolders: list[str]
+    resolutionPresets: list[ResolutionPreset]
+    team: str | None
+    switching: Switching
+
+
+class HdriMap(TypedDict):
+    path: str
+    name: str
+    folder: str
+    size: float
+    modified: float
+
+
+class DocumentState(TypedDict):
+    readOnly: bool
+    document: SceneDocument
+    imported: NotRequired[ImportReport]
+    generation: NotRequired[float]
+    revision: NotRequired[float]
+    unreadable: NotRequired[str]
+
+
+class ChangeList(TypedDict):
+    setup: str
+    changes: list[Change]
+    unset: list[str]
+    unknownTokens: list[str]
+    refused: list[RefusedItem]
+
+
+class Activation(TypedDict):
+    setup: str
+    results: list[Result]
+    unset: list[str]
+    unknownTokens: list[str]
+    refused: list[RefusedItem]
+    steps: NotRequired[list[ActivationStep]]
+    ms: NotRequired[float]
+
+
+class Resolved(TypedDict):
+    by: Author
+    at: str
+
+
+class Taken(TypedDict):
+    by: Author
+    at: str
+
+
+class Done(TypedDict):
+    by: Author
+    at: str
+
+
+class Reply(TypedDict):
+    id: str
+    author: Author
+    text: str
+    at: str
+    changes: NotRequired[list[MadeChange]]
+
+
+class Shot(TypedDict):
+    id: str
+    setup: NotRequired[str]
+    source: Literal["viewport", "framebuffer", "file"]
+    name: str
+    width: float
+    height: float
+    mime: str
+    view: NotRequired[SavedView]
+    marks: NotRequired[list[Mark]]
+    author: Author
+    at: str
+
+
+class Comment(TypedDict):
+    id: str
+    n: float
+    author: Author
+    text: str
+    at: str
+    status: Literal["open", "resolved"]
+    resolved: NotRequired[Resolved]
+    shot: NotRequired[str]
+    setup: NotRequired[str]
+    pin: NotRequired[ShotPoint]
+    area: NotRequired[ShotArea]
+    marks: list[Mark]
+    links: list[Link]
+    assignee: NotRequired[str]
+    taken: NotRequired[Taken]
+    done: NotRequired[Done]
+    replies: list[Reply]