Merge pull request #149 from pydn/codex/runtime-e2e-validation

Add runtime E2E validation harness and fixtures

.github/workflows/publish.yml

@@ -0,0 +1,25 @@
+name: Publish to Comfy registry
+on:
+  workflow_dispatch:
+  push:
+    branches:
+      - main
+    paths:
+      - "pyproject.toml"
+
+permissions:
+  issues: write
+
+jobs:
+  publish-node:
+    name: Publish Custom Node to registry
+    runs-on: ubuntu-latest
+    if: ${{ github.repository_owner == 'pydn' }}
+    steps:
+      - name: Check out code
+        uses: actions/checkout@v4
+      - name: Publish Custom Node
+        uses: Comfy-Org/publish-node-action@v1
+        with:
+          ## Add your own personal access token to your Github Repository secrets and reference it here.
+          personal_access_token: ${{ secrets.REGISTRY_ACCESS_TOKEN }}

README.md

@@ -1,171 +1,126 @@
-## ComfyUI-to-Python-Extension
+# ComfyUI-to-Python-Extension
 
-The `ComfyUI-to-Python-Extension` is a powerful tool that translates [ComfyUI](https://github.com/comfyanonymous/ComfyUI) workflows into executable Python code. Designed to bridge the gap between ComfyUI's visual interface and Python's programming environment, this script facilitates the seamless transition from design to code execution. Whether you're a data scientist, a software developer, or an AI enthusiast, this tool streamlines the process of implementing ComfyUI workflows in Python. The output makes it easy to queue a large amount of images for generation and provides a base script to easily modify for experimination.
+![banner](images/comfyui_to_python_banner.png)
 
-**Convert this:**
+Build a workflow in ComfyUI, then walk away with runnable Python.
 
-![SDXL UI Example](images/SDXL-UI-Example.jpg)
+`ComfyUI-to-Python-Extension` turns visual workflows into executable scripts so you can move from node graphs to automation, experiments, and repeatable generation without rebuilding everything by hand.
 
+This project supports:
+- exporting from the ComfyUI UI with `Save As Script`
+- converting saved API-format workflows with the CLI
 
-**To this:**
+## Install
 
-```
-import random
-import torch
-import sys
+Choose the setup that matches how you want to use the project.
 
-sys.path.append("../")
-from nodes import (
-    VAEDecode,
-    KSamplerAdvanced,
-    EmptyLatentImage,
-    SaveImage,
-    CheckpointLoaderSimple,
-    CLIPTextEncode,
-)
+### Web UI extension (`File -> Save As Script`)
 
+For ComfyUI to recognize this project as an extension, the repo must be discoverable through ComfyUI's `custom_nodes` search paths.
 
-def main():
-    with torch.inference_mode():
-        checkpointloadersimple = CheckpointLoaderSimple()
-        checkpointloadersimple_4 = checkpointloadersimple.load_checkpoint(
-            ckpt_name="sd_xl_base_1.0.safetensors"
-        )
+Use one of these setups:
 
-        emptylatentimage = EmptyLatentImage()
-        emptylatentimage_5 = emptylatentimage.generate(
-            width=1024, height=1024, batch_size=1
-        )
-
-        cliptextencode = CLIPTextEncode()
-        cliptextencode_6 = cliptextencode.encode(
-            text="evening sunset scenery blue sky nature, glass bottle with a galaxy in it",
-            clip=checkpointloadersimple_4[1],
-        )
-
-        cliptextencode_7 = cliptextencode.encode(
-            text="text, watermark", clip=checkpointloadersimple_4[1]
-        )
-
-        checkpointloadersimple_12 = checkpointloadersimple.load_checkpoint(
-            ckpt_name="sd_xl_refiner_1.0.safetensors"
-        )
-
-        cliptextencode_15 = cliptextencode.encode(
-            text="evening sunset scenery blue sky nature, glass bottle with a galaxy in it",
-            clip=checkpointloadersimple_12[1],
-        )
-
-        cliptextencode_16 = cliptextencode.encode(
-            text="text, watermark", clip=checkpointloadersimple_12[1]
-        )
-
-        ksampleradvanced = KSamplerAdvanced()
-        vaedecode = VAEDecode()
-        saveimage = SaveImage()
-
-        for q in range(10):
-            ksampleradvanced_10 = ksampleradvanced.sample(
-                add_noise="enable",
-                noise_seed=random.randint(1, 2**64),
-                steps=25,
-                cfg=8,
-                sampler_name="euler",
-                scheduler="normal",
-                start_at_step=0,
-                end_at_step=20,
-                return_with_leftover_noise="enable",
-                model=checkpointloadersimple_4[0],
-                positive=cliptextencode_6[0],
-                negative=cliptextencode_7[0],
-                latent_image=emptylatentimage_5[0],
-            )
-
-            ksampleradvanced_11 = ksampleradvanced.sample(
-                add_noise="disable",
-                noise_seed=random.randint(1, 2**64),
-                steps=25,
-                cfg=8,
-                sampler_name="euler",
-                scheduler="normal",
-                start_at_step=20,
-                end_at_step=10000,
-                return_with_leftover_noise="disable",
-                model=checkpointloadersimple_12[0],
-                positive=cliptextencode_15[0],
-                negative=cliptextencode_16[0],
-                latent_image=ksampleradvanced_10[0],
-            )
-
-            vaedecode_17 = vaedecode.decode(
-                samples=ksampleradvanced_11[0], vae=checkpointloadersimple_12[2]
-            )
-
-            saveimage_19 = saveimage.save_images(
-                filename_prefix="ComfyUI", images=vaedecode_17[0]
-            )
-
-
-if __name__ == "__main__":
-    main()
+1. Clone directly into `ComfyUI/custom_nodes`
+```bash
+cd /path/to/ComfyUI/custom_nodes
+git clone https://github.com/pydn/ComfyUI-to-Python-Extension.git
+cd ComfyUI-to-Python-Extension
+uv sync
 ```
 
-## Usage
+2. Keep the repo elsewhere, then either:
+- symlink it into `ComfyUI/custom_nodes`
+- add its parent directory to ComfyUI's `custom_nodes` search paths via `extra_model_paths.yaml`
 
+Example symlink setup:
+```bash
+git clone https://github.com/pydn/ComfyUI-to-Python-Extension.git
+cd /path/to/ComfyUI/custom_nodes
+ln -s /path/to/ComfyUI-to-Python-Extension ComfyUI-to-Python-Extension
+cd /path/to/ComfyUI-to-Python-Extension
+uv sync
+```
 
-1. Navigate to your `ComfyUI` directory
+After installation, restart ComfyUI.
 
-2. Clone this repo
-    ```bash
-    git clone https://github.com/pydn/ComfyUI-to-Python-Extension.git
-    ```
+### CLI exporter / generated scripts
 
-    After cloning the repo, your `ComfyUI` directory should look like this:
-    ```
-    /comfy
-    /comfy_extras
-    /ComfyUI-to-Python-Extension
-    /custom_nodes
-    /input
-    /models
-    /output
-    /script_examples
-    /web
-    .gitignore
-    LICENSE
-    README.md
-    comfyui_screenshot.png
-    cuda_mollac.py
-    execution.py
-    extra_model_paths.yaml.example
-    folder_paths.py
-    latent_preview.py
-    main.py
-    nodes.py
-    requirements.txt
-    server.py
-    ```
+You can keep the repo anywhere for CLI usage and generated-script execution.
 
-3. Navigate to the `ComfyUI-to-Python-Extension` folder and install requirements
-    ```bash
-    pip install -r requirements.txt
-    ```
+```bash
+git clone https://github.com/pydn/ComfyUI-to-Python-Extension.git
+cd ComfyUI-to-Python-Extension
+uv sync
+export COMFYUI_PATH=/path/to/ComfyUI
+```
 
-4. Launch ComfyUI, click the gear icon over `Queue Prompt`, then check `Enable Dev mode Options`. **THE SCRIPT WILL NOT WORK IF YOU DO NOT ENABLE THIS OPTION!**
+`COMFYUI_PATH` helps the exporter and generated scripts find the ComfyUI codebase. It does not, by itself, register this repo as a ComfyUI extension for the Web UI.
 
-![Enable Dev Mode Options](images/dev_mode_options.jpg)
+`COMFYUI_PATH` is checked first. If it is not set, the exporter falls back to searching parent directories for a folder named `ComfyUI`.
 
-5. Load up your favorite workflows, then click the newly enabled `Save (API Format)` button under Queue Prompt
+## Web UI Export
 
-6. Move the downloaded .json workflow file to your `ComfyUI/ComfyUI-to-Python-Extension` folder
+In current ComfyUI builds, `Save As Script` is typically available under:
 
-7. If needed, update the `input` variable at the bottom of `comfyui_to_python.py` to match the name of your .json workflow file. By default, the script will look for a file called `workflow_api.json`. You can also update the `queue_size` variable to your desired number of images that you want to generate in a single script execution. By default, the scripts will generate 10 images.
+`File -> Save As Script`
 
-8. Run the script:
-   ```bash
-   python comfyui_to_python.py
-   ```
+The command downloads a generated `.py` file.
 
-9. After running `comfyui_to_python.py`, a new .py file will be created in the current working directory that contains the same name as the `input` variable. If you made no changes, look for `workflow_api.py`.
+![Save As Script](images/save_as_script.png)
 
-10. Now you can execute the newly created .py file to generate images without launching a server.
+Notes:
+- menu placement can differ between frontend versions
+- ComfyUI Desktop may fail on the current filename prompt flow; use the CLI flow below if that happens
+
+## CLI Export
+
+1. In ComfyUI, enable dev mode options if needed.
+2. Save the workflow in API format: `File -> Export (API)`.
+3. Run the exporter:
+
+```bash
+uv run python comfyui_to_python.py
+```
+
+Options:
+
+```bash
+uv run python comfyui_to_python.py \
+  --input_file workflow_api.json \
+  --output_file workflow_api.py \
+  --queue_size 10
+```
+
+Flags:
+- `--input_file`: input workflow JSON, default `workflow_api.json`
+- `--output_file`: output Python file, default `workflow_api.py`
+- `--queue_size`: default execution count in the generated script, default `10`
+
+![Dev Mode Options](images/dev_mode_options.PNG)
+
+## Generated Scripts
+
+Generated scripts depend on a working ComfyUI runtime.
+
+If the repo is not inside ComfyUI, set:
+
+```bash
+export COMFYUI_PATH=/path/to/ComfyUI
+```
+
+The generated script is a workflow export. It does not automatically turn workflow inputs into command-line arguments.
+
+Scripts exported directly from `File -> Save As Script` in the ComfyUI UI already include the frontend workflow metadata needed for drag-and-drop reimport. Images saved by those scripts can be dropped back into ComfyUI and reopen with the original workflow metadata.
+
+## Troubleshooting
+
+- `Save As Script` not visible:
+  check your current ComfyUI menu/frontend version and look under `File`
+- `Save As Script` not visible after restart:
+  make sure this repo is discoverable by ComfyUI through `custom_nodes` by cloning it into `ComfyUI/custom_nodes`, symlinking it there, or adding an external `custom_nodes` path in `extra_model_paths.yaml`
+- Desktop says `prompt()` is unsupported:
+  use the CLI export flow instead
+- ComfyUI cannot be found:
+  set `COMFYUI_PATH`
+- models or paths are missing at runtime:
+  verify the target ComfyUI install and its `extra_model_paths.yaml`

__init__.py

@@ -0,0 +1,63 @@
+import sys
+import os
+
+from io import StringIO
+
+import traceback
+
+from aiohttp import web
+
+ext_dir = os.path.dirname(__file__)
+sys.path.append(ext_dir)
+
+try:
+    import black
+except ImportError:
+    print("Unable to import requirements for ComfyUI-SaveAsScript.")
+    print("Installing...")
+
+    import importlib
+
+    spec = importlib.util.spec_from_file_location(
+        "impact_install", os.path.join(os.path.dirname(__file__), "install.py")
+    )
+    impact_install = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(impact_install)
+
+    print("Successfully installed. Hopefully, at least.")
+
+# Prevent reimporting of custom nodes
+os.environ["RUNNING_IN_COMFYUI"] = "TRUE"
+
+from comfyui_to_python import ComfyUItoPython
+
+sys.path.append(os.path.dirname(os.path.dirname(ext_dir)))
+
+import server
+
+WEB_DIRECTORY = "js"
+NODE_CLASS_MAPPINGS = {}
+
+
+@server.PromptServer.instance.routes.post("/saveasscript")
+async def save_as_script(request):
+    try:
+        data = await request.json()
+        name = data["name"]
+        workflow = data["workflow"]
+        frontend_workflow = data.get("frontend_workflow")
+
+        sio = StringIO()
+        ComfyUItoPython(
+            workflow=workflow,
+            frontend_workflow=frontend_workflow,
+            output_file=sio,
+        )
+
+        sio.seek(0)
+        data = sio.read()
+
+        return web.Response(text=data, status=200)
+    except Exception as e:
+        traceback.print_exc()
+        return web.Response(text=str(e), status=500)

comfyui_to_python_utils.py

@@ -0,0 +1,123 @@
+import os
+from typing import Sequence, Mapping, Any, Union
+import sys
+
+
+def get_comfyui_path() -> str:
+    """Return the configured ComfyUI path, preferring COMFYUI_PATH when set."""
+    comfyui_path = os.environ.get("COMFYUI_PATH")
+    if comfyui_path:
+        return comfyui_path
+    return find_path("ComfyUI")
+
+
+def import_custom_nodes() -> None:
+    """Find all custom nodes in the custom_nodes folder and add those node objects to NODE_CLASS_MAPPINGS
+
+    This function sets up a new asyncio event loop, initializes the PromptServer,
+    creates a PromptQueue, and initializes the custom nodes.
+    """
+    comfyui_path = get_comfyui_path()
+    if comfyui_path and comfyui_path not in sys.path:
+        sys.path.insert(0, comfyui_path)
+
+    import asyncio
+    import execution
+    from nodes import init_extra_nodes
+    if comfyui_path in sys.path:
+        sys.path.remove(comfyui_path)
+    sys.path.insert(0, comfyui_path)
+    import server
+
+    # Creating a new event loop and setting it as the default loop
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+
+    # Creating an instance of PromptServer with the loop
+    server_instance = server.PromptServer(loop)
+    execution.PromptQueue(server_instance)
+
+    # Initializing custom nodes
+    asyncio.run(init_extra_nodes())
+
+
+def find_path(name: str, path: str = None) -> str:
+    """
+    Recursively looks at parent folders starting from the given path until it finds the given name.
+    Returns the path as a Path object if found, or None otherwise.
+    """
+    # If no path is given, use the current working directory
+    if path is None:
+        path = os.getcwd()
+
+    # Check if the current directory contains the name
+    if name in os.listdir(path):
+        path_name = os.path.join(path, name)
+        print(f"{name} found: {path_name}")
+        return path_name
+
+    # Get the parent directory
+    parent_directory = os.path.dirname(path)
+
+    # If the parent directory is the same as the current directory, we've reached the root and stop the search
+    if parent_directory == path:
+        return None
+
+    # Recursively call the function with the parent directory
+    return find_path(name, parent_directory)
+
+
+def add_comfyui_directory_to_sys_path() -> None:
+    """
+    Add 'ComfyUI' to the sys.path
+    """
+    comfyui_path = get_comfyui_path()
+    if comfyui_path is not None and os.path.isdir(comfyui_path):
+        if comfyui_path in sys.path:
+            sys.path.remove(comfyui_path)
+        sys.path.insert(0, comfyui_path)
+        print(f"'{comfyui_path}' added to sys.path")
+
+
+def add_extra_model_paths() -> None:
+    """
+    Parse the optional extra_model_paths.yaml file and add the parsed paths to the sys.path.
+    """
+    try:
+        from main import load_extra_path_config
+    except ImportError:
+        print(
+            "Could not import load_extra_path_config from main.py. Looking in utils.extra_config instead."
+        )
+        from utils.extra_config import load_extra_path_config
+
+    extra_model_paths = find_path("extra_model_paths.yaml")
+
+    if extra_model_paths is not None:
+        load_extra_path_config(extra_model_paths)
+    else:
+        print("Could not find the extra_model_paths config file.")
+
+
+def get_value_at_index(obj: Union[Sequence, Mapping], index: int) -> Any:
+    """Returns the value at the given index of a sequence or mapping.
+
+    If the object is a sequence (like list or string), returns the value at the given index.
+    If the object is a mapping (like a dictionary), returns the value at the index-th key.
+
+    Some return a dictionary, in these cases, we look for the "results" key
+
+    Args:
+        obj (Union[Sequence, Mapping]): The object to retrieve the value from.
+        index (int): The index of the value to retrieve.
+
+    Returns:
+        Any: The value at the given index.
+
+    Raises:
+        IndexError: If the index is out of bounds for the object and the object is not a mapping.
+    """
+    try:
+        return obj[index]
+    except KeyError:
+        return obj["result"][index]

install.py

@@ -0,0 +1,20 @@
+import os
+import sys
+
+from subprocess import Popen, check_output, PIPE
+
+requirements = open(os.path.join(os.path.dirname(__file__), "requirements.txt")).read().split("\n")
+
+installed_packages = check_output(
+    [sys.executable, "-m", "pip", "list"],
+    universal_newlines=True
+).split("\n")
+
+installed_packages = set([package.split(" ")[0].lower() for package in installed_packages if package.strip()])
+
+for requirement in requirements:
+    if requirement.lower() not in installed_packages:
+        print(f"Installing requirements...")
+        Popen([sys.executable, "-m", "pip", "install", "-r", "requirements.txt"], stdout=PIPE, stderr=PIPE, cwd=os.path.dirname(__file__)).communicate()
+        print(f"Installed.")
+        break

js/save-as-script.js

@@ -0,0 +1,65 @@
+import { api } from "../../scripts/api.js";
+import { app } from "../../scripts/app.js";
+import { $el } from "../../scripts/ui.js";
+
+const extension = {
+	name: "Comfy.SaveAsScript",
+	commands: [
+				{
+					id: "triggerSaveAsScript",
+					label: "Save As Script",
+					function: () => { extension.savePythonScript(); }
+				}
+			],
+	menuCommands: [
+		{
+			path: ["File"],
+			commands: ["triggerSaveAsScript"]
+		}
+	],
+	init() {
+		$el("style", {
+			parent: document.head,
+		});
+	},
+	savePythonScript() {
+		var filename = prompt("Save script as:");
+		if(filename === undefined || filename === null || filename === "") {
+			return
+		}
+		
+		app.graphToPrompt().then(async (p) => {
+			const frontendWorkflow = p.workflow ?? app.graph.serialize();
+			const json = JSON.stringify({
+				name: filename + ".json",
+				workflow: JSON.stringify(p.output, null, 2),
+				frontend_workflow: JSON.stringify(frontendWorkflow, null, 2),
+			}, null, 2); // convert the data to a JSON string
+			var response = await api.fetchApi(`/saveasscript`, { method: "POST", body: json });
+			if(response.status == 200) {
+				const blob = new Blob([await response.text()], {type: "text/python;charset=utf-8"});
+				const url = URL.createObjectURL(blob);
+				if(!filename.endsWith(".py")) {
+					filename += ".py";
+				}
+
+				const a = $el("a", {
+					href: url,
+					download: filename,
+					style: {display: "none"},
+					parent: document.body,
+				});
+				a.click();
+				setTimeout(function () {
+					a.remove();
+					window.URL.revokeObjectURL(url);
+				}, 0);
+			}
+		});
+	},
+	async setup() {
+		console.log("SaveAsScript loaded");
+	}
+};
+
+app.registerExtension(extension);

pyproject.toml

@@ -0,0 +1,15 @@
+[project]
+name = "comfyui-to-python-extension"
+description = "This custom node allows you to generate pure python code from your ComfyUI workflow with the click of a button. Great for rapid experimentation or production deployment."
+version = "1.3.1"
+license = { text = "MIT License" }
+dependencies = ["black"]
+
+[project.urls]
+Repository = "https://github.com/pydn/ComfyUI-to-Python-Extension"
+#  Used by Comfy Registry https://comfyregistry.org
+
+[tool.comfy]
+PublisherId = "pydn"
+DisplayName = "ComfyUI-to-Python-Extension"
+Icon = ""

requirements.txt

@@ -1,13 +1 @@
-torch
-torchdiffeq
-torchsde
-einops
-transformers>=4.25.1
-safetensors>=0.3.0
-aiohttp
-accelerate
-pyyaml
-Pillow
-scipy
-tqdm
 black

tests/README.md

@@ -0,0 +1,112 @@
+# Tests
+
+This directory contains two test paths:
+
+- unit tests for exporter behavior
+- runtime validation for committed workflow fixtures
+
+## Prerequisites
+
+- Run commands from the repo root.
+- Use `uv` for all project commands.
+- Install the repo environment first:
+
+```bash
+uv sync
+```
+
+- Runtime validation also needs a working ComfyUI checkout.
+  Set `COMFYUI_PATH` to that checkout, or run the tests from a location where a parent directory contains `ComfyUI`.
+- Runtime-tier tests do not download missing models automatically.
+  If a required model is missing, the fixture fails with `model provisioning failure`.
+  Use `--print-download-plan` to print the manual download commands.
+
+### Runtime Model Requirements
+
+The current runtime-capable fixtures require these model files in the target ComfyUI checkout:
+
+- `text-to-image`: `models/checkpoints/v1-5-pruned-emaonly-fp16.safetensors`
+- `upscale-model-loader`: `models/upscale_models/RealESRGAN_x4plus.safetensors`
+
+## Unit Tests
+
+Run the current unit test module:
+
+```bash
+uv run python -m unittest tests.test_upscale_model_loader_export
+```
+
+Run all `unittest`-discoverable tests under `tests`:
+
+```bash
+uv run python -m unittest discover -s tests
+```
+
+## Runtime Tests
+
+The runtime harness lives at `tests/runtime/run_runtime_validation.py`.
+
+### Fast Tier
+
+Fast tier validates export behavior against committed fixtures without requiring a full ComfyUI runtime for every fixture.
+
+Run all fast-tier compatible fixtures:
+
+```bash
+uv run python tests/runtime/run_runtime_validation.py --tier fast --fixture all
+```
+
+Run one fixture:
+
+```bash
+uv run python tests/runtime/run_runtime_validation.py --tier fast --fixture unsafe-kwargs
+```
+
+### Runtime Tier
+
+Runtime tier exports inside a real ComfyUI checkout and executes generated Python for runtime-capable fixtures.
+
+Run all runtime-capable fixtures:
+
+```bash
+uv run python tests/runtime/run_runtime_validation.py --tier runtime --fixture all
+```
+
+Run one runtime-capable fixture:
+
+```bash
+uv run python tests/runtime/run_runtime_validation.py --tier runtime --fixture text-to-image
+```
+
+Print download commands for missing models instead of failing immediately:
+
+```bash
+uv run python tests/runtime/run_runtime_validation.py --tier runtime --fixture all --print-download-plan
+```
+
+## Runtime Fixture Names
+
+Current committed fixtures:
+
+- `upscale-model-loader`
+- `text-to-image`
+- `unsafe-kwargs`
+- `subgraph-identifiers`
+
+Notes:
+
+- `--tier runtime` only runs fixtures marked runtime-capable.
+- `--tier fast` only runs fixtures with local test mappings.
+
+## Troubleshooting
+
+- `No module named ...`:
+  run `uv sync` in this repo, and for runtime-tier failures also make sure the target ComfyUI checkout has its own dependencies installed.
+- `Could not find a valid ComfyUI checkout for runtime validation.`:
+  set `COMFYUI_PATH` to your ComfyUI checkout, or run the tests from a directory layout where a parent folder contains `ComfyUI`.
+- `Missing models for ...`:
+  runtime-tier tests do not fetch models for you. Rerun with `--print-download-plan` to print the expected `curl` commands and target model directories, then install the files manually.
+- `No selected fixtures are runtime-capable for this tier.`:
+  choose a runtime-capable fixture such as `text-to-image` or `upscale-model-loader`.
+- Generated script execution fails because files or models are missing:
+  confirm the required models exist under the target ComfyUI checkout and that any staged inputs can be copied into its `input/` directory.

tests/fixtures/runtime/subgraph-identifiers.json

@@ -0,0 +1,19 @@
+{
+  "173:132": {
+    "class_type": "RegexReplace",
+    "inputs": {
+      "text": "abc123",
+      "pattern": "\\d+",
+      "replace": "X"
+    }
+  },
+  "174:133": {
+    "class_type": "PassthroughText",
+    "inputs": {
+      "text": [
+        "173:132",
+        0
+      ]
+    }
+  }
+}

tests/fixtures/runtime/text-to-image.json

@@ -0,0 +1,86 @@
+{
+  "1": {
+    "class_type": "CheckpointLoaderSimple",
+    "inputs": {
+      "ckpt_name": "v1-5-pruned-emaonly-fp16.safetensors"
+    }
+  },
+  "2": {
+    "class_type": "CLIPTextEncode",
+    "inputs": {
+      "text": "a small cottage in a meadow, soft daylight",
+      "clip": [
+        "1",
+        1
+      ]
+    }
+  },
+  "3": {
+    "class_type": "CLIPTextEncode",
+    "inputs": {
+      "text": "blurry, low quality",
+      "clip": [
+        "1",
+        1
+      ]
+    }
+  },
+  "4": {
+    "class_type": "EmptyLatentImage",
+    "inputs": {
+      "width": 512,
+      "height": 512,
+      "batch_size": 1
+    }
+  },
+  "5": {
+    "class_type": "KSampler",
+    "inputs": {
+      "seed": 1,
+      "steps": 4,
+      "cfg": 7,
+      "sampler_name": "euler",
+      "scheduler": "normal",
+      "denoise": 1,
+      "model": [
+        "1",
+        0
+      ],
+      "positive": [
+        "2",
+        0
+      ],
+      "negative": [
+        "3",
+        0
+      ],
+      "latent_image": [
+        "4",
+        0
+      ]
+    }
+  },
+  "6": {
+    "class_type": "VAEDecode",
+    "inputs": {
+      "samples": [
+        "5",
+        0
+      ],
+      "vae": [
+        "1",
+        2
+      ]
+    }
+  },
+  "7": {
+    "class_type": "SaveImage",
+    "inputs": {
+      "filename_prefix": "E2E_text_to_image",
+      "images": [
+        "6",
+        0
+      ]
+    }
+  }
+}

tests/fixtures/runtime/unsafe-kwargs.json

@@ -0,0 +1,11 @@
+{
+  "1": {
+    "class_type": "FlexibleNode",
+    "inputs": {
+      "safe_name": "kept-readable",
+      "class": "reserved-word",
+      "\u2795 Add Lora": "symbol-heavy-key",
+      "spaces and-hyphens": "still-unsafe"
+    }
+  }
+}

tests/fixtures/runtime/upscale-model-loader.json

@@ -0,0 +1,37 @@
+{
+  "1": {
+    "class_type": "LoadImage",
+    "inputs": {
+      "image": "e2e_upscale_input.png"
+    }
+  },
+  "2": {
+    "class_type": "UpscaleModelLoader",
+    "inputs": {
+      "model_name": "RealESRGAN_x4plus.safetensors"
+    }
+  },
+  "3": {
+    "class_type": "ImageUpscaleWithModel",
+    "inputs": {
+      "upscale_model": [
+        "2",
+        0
+      ],
+      "image": [
+        "1",
+        0
+      ]
+    }
+  },
+  "4": {
+    "class_type": "SaveImage",
+    "inputs": {
+      "filename_prefix": "E2E_upscale_model_loader",
+      "images": [
+        "3",
+        0
+      ]
+    }
+  }
+}

tests/runtime/run_runtime_validation.py

@@ -0,0 +1,691 @@
+import argparse
+import ast
+import json
+import os
+import shutil
+import struct
+import subprocess
+import sys
+import tempfile
+import zlib
+from dataclasses import dataclass
+from io import StringIO
+from pathlib import Path
+from typing import Callable
+
+ROOT = Path(__file__).resolve().parents[2]
+FIXTURE_DIR = ROOT / "tests" / "fixtures" / "runtime"
+GENERATED_DIR = ROOT / "tests" / "runtime" / "generated"
+COMFYUI_OUTPUT_DIRNAME = "output"
+COMFYUI_INPUT_DIRNAME = "input"
+
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+from comfyui_to_python_utils import get_comfyui_path
+
+
+class ValidationFailure(RuntimeError):
+    def __init__(self, classification: str, message: str):
+        super().__init__(message)
+        self.classification = classification
+        self.message = message
+
+
+@dataclass(frozen=True)
+class FixtureConfig:
+    name: str
+    path: Path
+    mapping_factory: Callable[[], dict] | None = None
+    fast_mapping_factory: Callable[[], dict] | None = None
+    runtime_capable: bool = False
+    filename_prefix: str | None = None
+    expected_min_dimensions: tuple[int, int] | None = None
+    metadata_markers: tuple[str, ...] = ()
+    model_requirements: tuple["ModelRequirement", ...] = ()
+    staged_inputs: tuple["StagedInput", ...] = ()
+
+
+@dataclass(frozen=True)
+class ModelRequirement:
+    filename: str
+    relative_dir: str
+    source_url: str
+
+
+@dataclass(frozen=True)
+class StagedInput:
+    source_path: Path
+    destination_name: str
+
+
+class FlexibleNode:
+    CATEGORY = "utils"
+    FUNCTION = "run"
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "safe_name": ("STRING",),
+            }
+        }
+
+    def run(self, **kwargs):
+        return (kwargs,)
+
+
+class RegexReplace:
+    CATEGORY = "utils"
+    FUNCTION = "replace"
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "text": ("STRING",),
+                "pattern": ("STRING",),
+                "replace": ("STRING",),
+            }
+        }
+
+    def replace(self, text, pattern, replace):
+        return (text,)
+
+
+class PassthroughText:
+    CATEGORY = "utils"
+    FUNCTION = "run"
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "text": ("STRING",),
+            }
+        }
+
+    def run(self, text):
+        return (text,)
+
+
+class UpscaleModelLoader:
+    CATEGORY = "loaders"
+    FUNCTION = "load_model"
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "model_name": ("STRING",),
+            }
+        }
+
+    def load_model(self, model_name):
+        return (model_name,)
+
+
+class LoadImage:
+    CATEGORY = "image"
+    FUNCTION = "load_image"
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "image": ("STRING",),
+            }
+        }
+
+    def load_image(self, image):
+        return (image,)
+
+
+class ImageUpscaleWithModel:
+    CATEGORY = "image/upscaling"
+    FUNCTION = "upscale"
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "upscale_model": ("UPSCALE_MODEL",),
+                "image": ("IMAGE",),
+            }
+        }
+
+    def upscale(self, upscale_model, image):
+        return (image,)
+
+
+class SaveImageNode:
+    CATEGORY = "image"
+    FUNCTION = "save_images"
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "images": ("IMAGE",),
+                "filename_prefix": ("STRING",),
+            }
+        }
+
+    def save_images(self, images, filename_prefix):
+        return ()
+
+
+FIXTURES = {
+    # Runtime-capable fixtures are exported inside a real ComfyUI checkout and
+    # then executed end-to-end. Fast fixtures use local stub mappings so the
+    # exporter can be validated without importing the full runtime.
+    "upscale-model-loader": FixtureConfig(
+        name="upscale-model-loader",
+        path=FIXTURE_DIR / "upscale-model-loader.json",
+        fast_mapping_factory=lambda: {
+            "LoadImage": LoadImage,
+            "UpscaleModelLoader": UpscaleModelLoader,
+            "ImageUpscaleWithModel": ImageUpscaleWithModel,
+            "SaveImage": SaveImageNode,
+        },
+        runtime_capable=True,
+        filename_prefix="E2E_upscale_model_loader",
+        expected_min_dimensions=(1000, 1000),
+        metadata_markers=("UpscaleModelLoader", "E2E_upscale_model_loader"),
+        model_requirements=(
+            ModelRequirement(
+                filename="RealESRGAN_x4plus.safetensors",
+                relative_dir="models/upscale_models",
+                source_url="https://huggingface.co/Comfy-Org/Real-ESRGAN_repackaged/resolve/main/RealESRGAN_x4plus.safetensors",
+            ),
+        ),
+        staged_inputs=(
+            StagedInput(
+                source_path=ROOT / "images" / "save_as_script.png",
+                destination_name="e2e_upscale_input.png",
+            ),
+        ),
+    ),
+    "text-to-image": FixtureConfig(
+        name="text-to-image",
+        path=FIXTURE_DIR / "text-to-image.json",
+        runtime_capable=True,
+        filename_prefix="E2E_text_to_image",
+        expected_min_dimensions=(512, 512),
+        metadata_markers=("a small cottage in a meadow", "CheckpointLoaderSimple"),
+        model_requirements=(
+            ModelRequirement(
+                filename="v1-5-pruned-emaonly-fp16.safetensors",
+                relative_dir="models/checkpoints",
+                source_url="https://huggingface.co/Comfy-Org/stable-diffusion-v1-5-archive/resolve/main/v1-5-pruned-emaonly-fp16.safetensors",
+            ),
+        ),
+    ),
+    "unsafe-kwargs": FixtureConfig(
+        name="unsafe-kwargs",
+        path=FIXTURE_DIR / "unsafe-kwargs.json",
+        mapping_factory=lambda: {"FlexibleNode": FlexibleNode},
+    ),
+    "subgraph-identifiers": FixtureConfig(
+        name="subgraph-identifiers",
+        path=FIXTURE_DIR / "subgraph-identifiers.json",
+        mapping_factory=lambda: {
+            "RegexReplace": RegexReplace,
+            "PassthroughText": PassthroughText,
+        },
+    ),
+}
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Run fast or runtime validation for committed fixtures."
+    )
+    parser.add_argument(
+        "--tier",
+        choices=("fast", "runtime"),
+        help="Validation tier to run.",
+    )
+    parser.add_argument(
+        "--fixture",
+        default="all",
+        help="Fixture name or 'all'.",
+    )
+    parser.add_argument(
+        "--execute",
+        action="store_true",
+        help="Execute generated Python for runtime-capable fixtures.",
+    )
+    parser.add_argument(
+        "--print-download-plan",
+        action="store_true",
+        help="Print model download commands for missing models.",
+    )
+    parser.add_argument(
+        "--internal-export",
+        choices=tuple(FIXTURES.keys()),
+        help=argparse.SUPPRESS,
+    )
+    parser.add_argument(
+        "--generated-path",
+        help=argparse.SUPPRESS,
+    )
+    args = parser.parse_args()
+    if not args.internal_export and not args.tier:
+        parser.error("--tier is required unless --internal-export is used.")
+    return args
+
+
+def load_fixture_names(selection: str) -> list[str]:
+    if selection == "all":
+        return list(FIXTURES.keys())
+    if selection not in FIXTURES:
+        raise ValidationFailure("fixture bug", f"Unknown fixture '{selection}'.")
+    return [selection]
+
+
+def ensure_runtime_path(tier: str) -> str:
+    if tier == "runtime":
+        runtime_path = get_comfyui_path()
+    else:
+        return os.environ.get("COMFYUI_PATH", "")
+
+    if not runtime_path or not Path(runtime_path).is_dir():
+        raise ValidationFailure(
+            "environment/setup failure",
+            "Could not find a valid ComfyUI checkout for runtime validation. "
+            "Set COMFYUI_PATH or run the tests from a location where a "
+            "parent directory contains ComfyUI.",
+        )
+
+    return str(runtime_path)
+
+
+def get_runtime_python(runtime_path: str) -> str:
+    runtime_python = Path(runtime_path) / ".venv" / "bin" / "python"
+    if runtime_python.is_file():
+        return str(runtime_python)
+    return sys.executable
+
+
+def get_fixture(fixture_name: str) -> FixtureConfig:
+    return FIXTURES[fixture_name]
+
+
+def check_models(fixture: FixtureConfig, runtime_path: str) -> list[ModelRequirement]:
+    runtime_root = Path(runtime_path)
+    missing = []
+    for requirement in fixture.model_requirements:
+        target = runtime_root / requirement.relative_dir / requirement.filename
+        if not target.is_file():
+            missing.append(requirement)
+    return missing
+
+
+def print_download_plan(fixture: FixtureConfig, runtime_path: str) -> None:
+    runtime_root = Path(runtime_path)
+    for requirement in check_models(fixture, runtime_path):
+        target_dir = runtime_root / requirement.relative_dir
+        print(
+            "download:",
+            f"mkdir -p {target_dir} && curl -L {requirement.source_url} -o {target_dir / requirement.filename}",
+        )
+
+
+def stage_inputs(fixture: FixtureConfig, runtime_path: str) -> None:
+    runtime_input_dir = Path(runtime_path) / COMFYUI_INPUT_DIRNAME
+    runtime_input_dir.mkdir(parents=True, exist_ok=True)
+    for staged_input in fixture.staged_inputs:
+        if not staged_input.source_path.is_file():
+            raise ValidationFailure(
+                "fixture bug",
+                f"Missing staged input source {staged_input.source_path} for {fixture.name}.",
+            )
+        shutil.copyfile(
+            staged_input.source_path,
+            runtime_input_dir / staged_input.destination_name,
+        )
+
+
+def export_workflow(
+    fixture: FixtureConfig,
+    tier: str,
+    runtime_path: str,
+) -> tuple[str, str]:
+    from comfyui_to_python import ComfyUItoPython
+
+    workflow = fixture.path.read_text(encoding="utf-8")
+    output = StringIO()
+    kwargs = {
+        "workflow": workflow,
+        "output_file": output,
+    }
+    if tier == "fast" and fixture.fast_mapping_factory is not None:
+        kwargs["node_class_mappings"] = fixture.fast_mapping_factory()
+    elif fixture.mapping_factory is not None:
+        kwargs["node_class_mappings"] = fixture.mapping_factory()
+    else:
+        os.environ["COMFYUI_PATH"] = runtime_path
+
+    try:
+        ComfyUItoPython(**kwargs)
+    except ModuleNotFoundError as exc:
+        missing_module = exc.name or "unknown"
+        raise ValidationFailure(
+            "environment/setup failure",
+            f"Missing runtime dependency '{missing_module}' while exporting {fixture.name}.",
+        ) from exc
+    except KeyError as exc:
+        raise ValidationFailure(
+            "repo regression",
+            f"Exporter failed to resolve workflow data for {fixture.name}: {exc}",
+        ) from exc
+    except Exception as exc:
+        raise ValidationFailure(
+            "repo regression",
+            f"Exporter failed for {fixture.name}: {exc}",
+        ) from exc
+
+    return workflow, output.getvalue()
+
+
+def export_workflow_in_runtime_env(fixture: FixtureConfig, runtime_path: str) -> str:
+    runtime_python = get_runtime_python(runtime_path)
+    GENERATED_DIR.mkdir(parents=True, exist_ok=True)
+    generated_path = GENERATED_DIR / f"{fixture.name}.py"
+    env = os.environ.copy()
+    env["COMFYUI_PATH"] = runtime_path
+    env["PYTHONPATH"] = os.pathsep.join([str(ROOT), env.get("PYTHONPATH", "")]).rstrip(
+        os.pathsep
+    )
+    # Re-enter this script under the runtime interpreter so export happens with
+    # the target ComfyUI checkout on sys.path, not just the repo's current venv.
+    result = subprocess.run(
+        [
+            runtime_python,
+            str(Path(__file__).resolve()),
+            "--internal-export",
+            fixture.name,
+            "--generated-path",
+            str(generated_path),
+        ],
+        cwd=ROOT,
+        env=env,
+        capture_output=True,
+        text=True,
+    )
+    if result.returncode != 0:
+        output = (result.stderr or result.stdout or "").strip()
+        classification = "environment/setup failure"
+        if (
+            "Missing runtime dependency" not in output
+            and "ModuleNotFoundError" not in output
+        ):
+            classification = "repo regression"
+        raise ValidationFailure(
+            classification,
+            f"Runtime export failed for {fixture.name}: {output}",
+        )
+    return generated_path.read_text(encoding="utf-8")
+
+
+def validate_generated_python(generated_code: str, fixture_name: str) -> None:
+    try:
+        ast.parse(generated_code)
+    except SyntaxError as exc:
+        raise ValidationFailure(
+            "repo regression",
+            f"Generated Python is not valid for {fixture_name}: {exc}",
+        ) from exc
+
+
+def parse_png_info(image_path: Path) -> tuple[int, int, dict[str, str]]:
+    with image_path.open("rb") as handle:
+        signature = handle.read(8)
+        if signature != b"\x89PNG\r\n\x1a\n":
+            raise ValidationFailure(
+                "environment/setup failure",
+                f"Expected PNG output for {image_path.name}, got a different file format.",
+            )
+
+        width = height = None
+        text_data: dict[str, str] = {}
+        while True:
+            length_bytes = handle.read(4)
+            if not length_bytes:
+                break
+            length = struct.unpack(">I", length_bytes)[0]
+            chunk_type = handle.read(4)
+            chunk_data = handle.read(length)
+            handle.read(4)
+
+            if chunk_type == b"IHDR":
+                width, height = struct.unpack(">II", chunk_data[:8])
+            elif chunk_type == b"tEXt":
+                key, value = chunk_data.split(b"\x00", 1)
+                text_data[key.decode("latin-1")] = value.decode("latin-1")
+            elif chunk_type == b"zTXt":
+                key, compressed = chunk_data.split(b"\x00", 1)
+                text_data[key.decode("latin-1")] = zlib.decompress(
+                    compressed[1:]
+                ).decode("latin-1")
+            elif chunk_type == b"iTXt":
+                parts = chunk_data.split(b"\x00", 5)
+                if len(parts) == 6:
+                    key = parts[0].decode("utf-8")
+                    compressed_flag = parts[1]
+                    value = parts[5]
+                    if compressed_flag == b"\x01":
+                        value = zlib.decompress(value)
+                    text_data[key] = value.decode("utf-8")
+            elif chunk_type == b"IEND":
+                break
+
+        if width is None or height is None:
+            raise ValidationFailure(
+                "environment/setup failure",
+                f"Could not read PNG dimensions from {image_path.name}.",
+            )
+
+    return width, height, text_data
+
+
+def validate_output_artifact(
+    fixture: FixtureConfig,
+    output_path: Path,
+) -> None:
+    # Read PNG metadata directly so artifact validation does not depend on
+    # optional imaging libraries inside the runtime environment.
+    width, height, metadata = parse_png_info(output_path)
+
+    if fixture.expected_min_dimensions is not None:
+        min_width, min_height = fixture.expected_min_dimensions
+        if width < min_width or height < min_height:
+            raise ValidationFailure(
+                "repo regression",
+                f"Output dimensions for {fixture.name} were {width}x{height}, expected at least {min_width}x{min_height}.",
+            )
+
+    metadata_blob = "\n".join(
+        [output_path.name] + [f"{key}={value}" for key, value in metadata.items()]
+    )
+    for marker in fixture.metadata_markers:
+        if marker not in metadata_blob:
+            raise ValidationFailure(
+                "repo regression",
+                f"Output metadata for {fixture.name} did not contain expected marker '{marker}'.",
+            )
+
+
+def execute_generated_python(
+    generated_code: str,
+    fixture: FixtureConfig,
+    runtime_path: str,
+) -> None:
+    if not fixture.runtime_capable:
+        raise ValidationFailure(
+            "fixture bug",
+            f"Fixture {fixture.name} is not marked runtime-capable.",
+        )
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        tmp_path = Path(tmpdir) / f"{fixture.name}.py"
+        tmp_path.write_text(generated_code, encoding="utf-8")
+        output_dir = Path(runtime_path) / COMFYUI_OUTPUT_DIRNAME
+        # Compare against the pre-run snapshot so validation can prove this
+        # execution created a fresh artifact instead of reusing an old output.
+        existing_outputs = set(output_dir.glob("*.png"))
+        env = os.environ.copy()
+        env["COMFYUI_PATH"] = runtime_path
+        env["PYTHONPATH"] = os.pathsep.join(
+            [str(ROOT), env.get("PYTHONPATH", "")]
+        ).rstrip(os.pathsep)
+        runtime_python = get_runtime_python(runtime_path)
+
+        result = subprocess.run(
+            [runtime_python, str(tmp_path)],
+            cwd=ROOT,
+            env=env,
+            capture_output=True,
+            text=True,
+        )
+        if result.returncode == 0:
+            if fixture.filename_prefix is None:
+                return
+            new_outputs = [
+                path
+                for path in output_dir.glob(f"{fixture.filename_prefix}*.png")
+                if path not in existing_outputs
+            ]
+            if not new_outputs:
+                raise ValidationFailure(
+                    "repo regression",
+                    f"Generated script for {fixture.name} did not produce a new output file with prefix {fixture.filename_prefix}.",
+                )
+            newest_output = max(new_outputs, key=lambda path: path.stat().st_mtime)
+            validate_output_artifact(fixture, newest_output)
+            return
+
+        stderr = (result.stderr or "").strip()
+        stdout = (result.stdout or "").strip()
+        output = stderr or stdout or "generated script exited with a non-zero status"
+        lower_output = output.lower()
+
+        if "no module named 'torch'" in lower_output:
+            classification = "environment/setup failure"
+        elif "no such file or directory" in lower_output or "not found" in lower_output:
+            classification = "environment/setup failure"
+        else:
+            classification = "repo regression"
+
+        raise ValidationFailure(
+            classification,
+            f"Generated script execution failed for {fixture.name}: {output}",
+        )
+
+
+def run_fixture(fixture: FixtureConfig, tier: str, execute: bool, runtime_path: str) -> str:
+    if tier == "fast":
+        _, generated_code = export_workflow(fixture, tier, runtime_path)
+    else:
+        missing_models = check_models(fixture, runtime_path)
+        if missing_models:
+            raise ValidationFailure(
+                "model provisioning failure",
+                "Missing models for "
+                f"{fixture.name}: "
+                + ", ".join(
+                    f"{item.relative_dir}/{item.filename}" for item in missing_models
+                ),
+            )
+        stage_inputs(fixture, runtime_path)
+        generated_code = export_workflow_in_runtime_env(fixture, runtime_path)
+    validate_generated_python(generated_code, fixture.name)
+
+    # Fast keeps execution opt-in because its stub node mappings are intended for
+    # export coverage only. Runtime always executes the generated script.
+    should_execute = execute or tier == "runtime"
+    if should_execute and tier == "runtime":
+        execute_generated_python(generated_code, fixture, runtime_path)
+
+    return "pass"
+
+
+def main() -> int:
+    args = parse_args()
+
+    if args.internal_export:
+        fixture = get_fixture(args.internal_export)
+        output_path = Path(args.generated_path)
+        _, generated_code = export_workflow(
+            fixture=fixture,
+            tier="runtime",
+            runtime_path=os.environ.get("COMFYUI_PATH", ""),
+        )
+        output_path.write_text(generated_code, encoding="utf-8")
+        return 0
+
+    try:
+        runtime_path = ensure_runtime_path(args.tier)
+        fixture_names = load_fixture_names(args.fixture)
+        requested = [FIXTURES[name] for name in fixture_names]
+
+        if args.tier == "fast":
+            requested = [
+                fixture
+                for fixture in requested
+                if fixture.fast_mapping_factory is not None
+                or fixture.mapping_factory is not None
+            ]
+            if not requested:
+                raise ValidationFailure(
+                    "fixture bug",
+                    "No selected fixtures are fast-tier compatible.",
+                )
+        elif args.tier == "runtime":
+            requested = [fixture for fixture in requested if fixture.runtime_capable]
+            if not requested:
+                raise ValidationFailure(
+                    "fixture bug",
+                    "No selected fixtures are runtime-capable for this tier.",
+                )
+
+        failures: list[tuple[str, str, str]] = []
+        for fixture in requested:
+            try:
+                if args.print_download_plan and args.tier == "runtime":
+                    missing_models = check_models(fixture, runtime_path)
+                    for requirement in missing_models:
+                        target_dir = Path(runtime_path) / requirement.relative_dir
+                        print(
+                            "download:",
+                            f"mkdir -p {target_dir} && curl -L {requirement.source_url} -o {target_dir / requirement.filename}",
+                        )
+                    if missing_models:
+                        print(f"{fixture.name}: download-plan")
+                        continue
+                status = run_fixture(fixture, args.tier, args.execute, runtime_path)
+                print(f"{fixture.name}: {status}")
+            except ValidationFailure as exc:
+                failures.append((fixture.name, exc.classification, exc.message))
+                print(
+                    f"{fixture.name}: fail ({exc.classification})",
+                    file=sys.stderr,
+                )
+                print(exc.message, file=sys.stderr)
+        if failures:
+            classifications = ", ".join(
+                f"{name}={classification}" for name, classification, _ in failures
+            )
+            print(f"classification: {classifications}", file=sys.stderr)
+            return 1
+    except ValidationFailure as exc:
+        print(f"classification: {exc.classification}", file=sys.stderr)
+        print(exc.message, file=sys.stderr)
+        return 1
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

tests/test_upscale_model_loader_export.py

@@ -0,0 +1,364 @@
+import json
+import tempfile
+import unittest
+from io import StringIO
+from pathlib import Path
+from unittest.mock import patch
+
+from comfyui_to_python import ComfyUItoPython, run
+
+
+class UpscaleModelLoader:
+    CATEGORY = "loaders"
+    FUNCTION = "load_model"
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "model_name": ("STRING",),
+            }
+        }
+
+    def load_model(self, model_name):
+        return (model_name,)
+
+
+class LoadImage:
+    CATEGORY = "image"
+    FUNCTION = "load_image"
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "image": ("STRING",),
+            }
+        }
+
+    def load_image(self, image):
+        return (image,)
+
+
+class ImageUpscaleWithModel:
+    CATEGORY = "image/upscaling"
+    FUNCTION = "upscale"
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "upscale_model": ("UPSCALE_MODEL",),
+                "image": ("IMAGE",),
+            }
+        }
+
+    def upscale(self, upscale_model, image):
+        return (image,)
+
+
+class MergeImages:
+    CATEGORY = "image"
+    FUNCTION = "merge"
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "left": ("IMAGE",),
+                "right": ("IMAGE",),
+            }
+        }
+
+    def merge(self, left, right):
+        return (left, right)
+
+
+class HiddenMetadataFilteredNode:
+    CATEGORY = "image"
+    FUNCTION = "save"
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+            },
+            "hidden": {
+                "prompt": "PROMPT",
+                "extra_pnginfo": "EXTRA_PNGINFO",
+            },
+        }
+
+    def save(self, image):
+        return (image,)
+
+
+class HiddenPromptSeedNode:
+    CATEGORY = "sampling"
+    FUNCTION = "sample"
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "seed": ("INT",),
+                "noise_seed": ("INT",),
+            },
+            "hidden": {
+                "prompt": "PROMPT",
+            },
+        }
+
+    def sample(self, seed, noise_seed, prompt):
+        return (seed, noise_seed, prompt)
+
+
+class UpscaleModelLoaderExportTest(unittest.TestCase):
+    def test_upscale_workflow_uses_direct_upscale_model_loader_init(self):
+        workflow = {
+            "1": {
+                "class_type": "LoadImage",
+                "inputs": {
+                    "image": "example.png",
+                },
+            },
+            "2": {
+                "class_type": "UpscaleModelLoader",
+                "inputs": {
+                    "model_name": "RealESRGAN_x4plus.safetensors",
+                },
+            },
+            "3": {
+                "class_type": "ImageUpscaleWithModel",
+                "inputs": {
+                    "upscale_model": ["2", 0],
+                    "image": ["1", 0],
+                },
+            },
+        }
+
+        output = StringIO()
+        ComfyUItoPython(
+            workflow=json.dumps(workflow),
+            output_file=output,
+            node_class_mappings={
+                "LoadImage": LoadImage,
+                "UpscaleModelLoader": UpscaleModelLoader,
+                "ImageUpscaleWithModel": ImageUpscaleWithModel,
+            },
+        )
+
+        generated = output.getvalue()
+
+        self.assertIn("from nodes import NODE_CLASS_MAPPINGS", generated)
+        self.assertIn(f"from {LoadImage.__module__} import (", generated)
+        self.assertIn("LoadImage,", generated)
+        self.assertIn("UpscaleModelLoader,", generated)
+        self.assertIn("ImageUpscaleWithModel,", generated)
+        self.assertIn("loadimage = LoadImage()", generated)
+        self.assertIn("upscalemodelloader = UpscaleModelLoader()", generated)
+        self.assertIn(
+            "imageupscalewithmodel_3 = imageupscalewithmodel.upscale(",
+            generated,
+        )
+        self.assertNotIn('NODE_CLASS_MAPPINGS["UpscaleModelLoader"]()', generated)
+
+    def test_frontend_workflow_metadata_is_embedded_for_reimport(self):
+        workflow = {
+            "1": {
+                "class_type": "LoadImage",
+                "inputs": {
+                    "image": "example.png",
+                },
+            }
+        }
+        frontend_workflow = {
+            "version": 0.4,
+            "last_node_id": 1,
+            "last_link_id": 0,
+            "nodes": [],
+            "links": [],
+            "groups": [],
+            "config": {},
+            "extra": {},
+        }
+
+        output = StringIO()
+        ComfyUItoPython(
+            workflow=json.dumps(workflow),
+            frontend_workflow=json.dumps(frontend_workflow),
+            output_file=output,
+            node_class_mappings={
+                "LoadImage": LoadImage,
+            },
+        )
+
+        generated = output.getvalue()
+
+        self.assertIn('extra_pnginfo = {', generated)
+        self.assertIn('"workflow": json.loads(', generated)
+        self.assertIn('"version": 0.4', generated)
+        self.assertIn('"nodes": []', generated)
+        self.assertNotIn('"source": "workflow_api"', generated)
+
+    def test_export_without_frontend_workflow_leaves_png_workflow_metadata_absent(self):
+        workflow = {
+            "1": {
+                "class_type": "LoadImage",
+                "inputs": {
+                    "image": "example.png",
+                },
+            }
+        }
+
+        output = StringIO()
+        ComfyUItoPython(
+            workflow=json.dumps(workflow),
+            output_file=output,
+            node_class_mappings={
+                "LoadImage": LoadImage,
+            },
+        )
+
+        generated = output.getvalue()
+
+        self.assertIn("extra_pnginfo = None", generated)
+        self.assertNotIn('"workflow": json.loads(', generated)
+
+    def test_export_preserves_unique_variable_names_for_subgraph_node_ids(self):
+        workflow = {
+            "1:23": {
+                "class_type": "LoadImage",
+                "inputs": {
+                    "image": "left.png",
+                },
+            },
+            "12:3": {
+                "class_type": "LoadImage",
+                "inputs": {
+                    "image": "right.png",
+                },
+            },
+            "20": {
+                "class_type": "MergeImages",
+                "inputs": {
+                    "left": ["1:23", 0],
+                    "right": ["12:3", 0],
+                },
+            },
+        }
+
+        output = StringIO()
+        ComfyUItoPython(
+            workflow=json.dumps(workflow),
+            output_file=output,
+            node_class_mappings={
+                "LoadImage": LoadImage,
+                "MergeImages": MergeImages,
+            },
+        )
+
+        generated = output.getvalue()
+
+        self.assertIn("loadimage_1_23 = loadimage.load_image(", generated)
+        self.assertIn("loadimage_12_3 = loadimage.load_image(", generated)
+        self.assertIn("mergeimages_20 = mergeimages.merge(", generated)
+        self.assertIn("left=get_value_at_index(loadimage_1_23, 0)", generated)
+        self.assertIn("right=get_value_at_index(loadimage_12_3, 0)", generated)
+
+    def test_run_cli_export_leaves_png_workflow_metadata_absent(self):
+        workflow = {
+            "1": {
+                "class_type": "LoadImage",
+                "inputs": {
+                    "image": "example.png",
+                },
+            }
+        }
+
+        with tempfile.TemporaryDirectory() as tmpdir:
+            tmpdir_path = Path(tmpdir)
+            input_file = tmpdir_path / "workflow_api.json"
+            output_file = tmpdir_path / "workflow_api.py"
+
+            input_file.write_text(json.dumps(workflow), encoding="utf-8")
+
+            with patch(
+                "comfyui_to_python.get_node_class_mappings",
+                return_value={"LoadImage": LoadImage},
+            ), patch("comfyui_to_python.import_custom_nodes"):
+                run(
+                    input_file=str(input_file),
+                    output_file=str(output_file),
+                    queue_size=1,
+                )
+
+            generated = output_file.read_text(encoding="utf-8")
+
+        self.assertIn("extra_pnginfo = None", generated)
+        self.assertNotIn('"workflow": json.loads(', generated)
+
+    def test_hidden_metadata_kwargs_follow_function_signature(self):
+        workflow = {
+            "1": {
+                "class_type": "HiddenMetadataFilteredNode",
+                "inputs": {
+                    "image": "example.png",
+                },
+            }
+        }
+
+        output = StringIO()
+        ComfyUItoPython(
+            workflow=json.dumps(workflow),
+            output_file=output,
+            node_class_mappings={
+                "HiddenMetadataFilteredNode": HiddenMetadataFilteredNode,
+            },
+        )
+
+        generated = output.getvalue()
+
+        self.assertIn("hiddenmetadatafilterednode_1 =", generated)
+        self.assertNotIn("prompt=prompt", generated)
+        self.assertNotIn("extra_pnginfo=extra_pnginfo", generated)
+
+    def test_randomized_seed_inputs_update_prompt_metadata_before_execution(self):
+        workflow = {
+            "1": {
+                "class_type": "HiddenPromptSeedNode",
+                "inputs": {
+                    "seed": 1,
+                    "noise_seed": 2,
+                },
+            }
+        }
+
+        output = StringIO()
+        ComfyUItoPython(
+            workflow=json.dumps(workflow),
+            output_file=output,
+            node_class_mappings={
+                "HiddenPromptSeedNode": HiddenPromptSeedNode,
+            },
+        )
+
+        generated = output.getvalue()
+
+        self.assertIn(
+            'node_1_seed = prompt["1"]["inputs"]["seed"] = random.randint(1, 2**64)',
+            generated,
+        )
+        self.assertIn(
+            'node_1_noise_seed = prompt["1"]["inputs"]["noise_seed"] = random.randint(',
+            generated,
+        )
+        self.assertIn("1, 2**64", generated)
+        self.assertIn("seed=node_1_seed", generated)
+        self.assertIn("noise_seed=node_1_noise_seed", generated)
+        self.assertIn("prompt=prompt", generated)
+
+
+if __name__ == "__main__":
+    unittest.main()

uv.lock

@@ -0,0 +1,132 @@
+version = 1
+revision = 3
+requires-python = ">=3.12"
+
+[[package]]
+name = "black"
+version = "26.3.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "click" },
+    { name = "mypy-extensions" },
+    { name = "packaging" },
+    { name = "pathspec" },
+    { name = "platformdirs" },
+    { name = "pytokens" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/e1/c5/61175d618685d42b005847464b8fb4743a67b1b8fdb75e50e5a96c31a27a/black-26.3.1.tar.gz", hash = "sha256:2c50f5063a9641c7eed7795014ba37b0f5fa227f3d408b968936e24bc0566b07", size = 666155, upload-time = "2026-03-12T03:36:03.593Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/dc/f8/da5eae4fc75e78e6dceb60624e1b9662ab00d6b452996046dfa9b8a6025b/black-26.3.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:b5e6f89631eb88a7302d416594a32faeee9fb8fb848290da9d0a5f2903519fc1", size = 1895920, upload-time = "2026-03-12T03:40:13.921Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/9f/04e6f26534da2e1629b2b48255c264cabf5eedc5141d04516d9d68a24111/black-26.3.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:41cd2012d35b47d589cb8a16faf8a32ef7a336f56356babd9fcf70939ad1897f", size = 1718499, upload-time = "2026-03-12T03:40:15.239Z" },
+    { url = "https://files.pythonhosted.org/packages/04/91/a5935b2a63e31b331060c4a9fdb5a6c725840858c599032a6f3aac94055f/black-26.3.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0f76ff19ec5297dd8e66eb64deda23631e642c9393ab592826fd4bdc97a4bce7", size = 1794994, upload-time = "2026-03-12T03:40:17.124Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/0a/86e462cdd311a3c2a8ece708d22aba17d0b2a0d5348ca34b40cdcbea512e/black-26.3.1-cp312-cp312-win_amd64.whl", hash = "sha256:ddb113db38838eb9f043623ba274cfaf7d51d5b0c22ecb30afe58b1bb8322983", size = 1420867, upload-time = "2026-03-12T03:40:18.83Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/e5/22515a19cb7eaee3440325a6b0d95d2c0e88dd180cb011b12ae488e031d1/black-26.3.1-cp312-cp312-win_arm64.whl", hash = "sha256:dfdd51fc3e64ea4f35873d1b3fb25326773d55d2329ff8449139ebaad7357efb", size = 1230124, upload-time = "2026-03-12T03:40:20.425Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/77/5728052a3c0450c53d9bb3945c4c46b91baa62b2cafab6801411b6271e45/black-26.3.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:855822d90f884905362f602880ed8b5df1b7e3ee7d0db2502d4388a954cc8c54", size = 1895034, upload-time = "2026-03-12T03:40:21.813Z" },
+    { url = "https://files.pythonhosted.org/packages/52/73/7cae55fdfdfbe9d19e9a8d25d145018965fe2079fa908101c3733b0c55a0/black-26.3.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:8a33d657f3276328ce00e4d37fe70361e1ec7614da5d7b6e78de5426cb56332f", size = 1718503, upload-time = "2026-03-12T03:40:23.666Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/87/af89ad449e8254fdbc74654e6467e3c9381b61472cc532ee350d28cfdafb/black-26.3.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f1cd08e99d2f9317292a311dfe578fd2a24b15dbce97792f9c4d752275c1fa56", size = 1793557, upload-time = "2026-03-12T03:40:25.497Z" },
+    { url = "https://files.pythonhosted.org/packages/43/10/d6c06a791d8124b843bf325ab4ac7d2f5b98731dff84d6064eafd687ded1/black-26.3.1-cp313-cp313-win_amd64.whl", hash = "sha256:c7e72339f841b5a237ff14f7d3880ddd0fc7f98a1199e8c4327f9a4f478c1839", size = 1422766, upload-time = "2026-03-12T03:40:27.14Z" },
+    { url = "https://files.pythonhosted.org/packages/59/4f/40a582c015f2d841ac24fed6390bd68f0fc896069ff3a886317959c9daf8/black-26.3.1-cp313-cp313-win_arm64.whl", hash = "sha256:afc622538b430aa4c8c853f7f63bc582b3b8030fd8c80b70fb5fa5b834e575c2", size = 1232140, upload-time = "2026-03-12T03:40:28.882Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/da/e36e27c9cebc1311b7579210df6f1c86e50f2d7143ae4fcf8a5017dc8809/black-26.3.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:2d6bfaf7fd0993b420bed691f20f9492d53ce9a2bcccea4b797d34e947318a78", size = 1889234, upload-time = "2026-03-12T03:40:30.964Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/7b/9871acf393f64a5fa33668c19350ca87177b181f44bb3d0c33b2d534f22c/black-26.3.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:f89f2ab047c76a9c03f78d0d66ca519e389519902fa27e7a91117ef7611c0568", size = 1720522, upload-time = "2026-03-12T03:40:32.346Z" },
+    { url = "https://files.pythonhosted.org/packages/03/87/e766c7f2e90c07fb7586cc787c9ae6462b1eedab390191f2b7fc7f6170a9/black-26.3.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b07fc0dab849d24a80a29cfab8d8a19187d1c4685d8a5e6385a5ce323c1f015f", size = 1787824, upload-time = "2026-03-12T03:40:33.636Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/94/2424338fb2d1875e9e83eed4c8e9c67f6905ec25afd826a911aea2b02535/black-26.3.1-cp314-cp314-win_amd64.whl", hash = "sha256:0126ae5b7c09957da2bdbd91a9ba1207453feada9e9fe51992848658c6c8e01c", size = 1445855, upload-time = "2026-03-12T03:40:35.442Z" },
+    { url = "https://files.pythonhosted.org/packages/86/43/0c3338bd928afb8ee7471f1a4eec3bdbe2245ccb4a646092a222e8669840/black-26.3.1-cp314-cp314-win_arm64.whl", hash = "sha256:92c0ec1f2cc149551a2b7b47efc32c866406b6891b0ee4625e95967c8f4acfb1", size = 1258109, upload-time = "2026-03-12T03:40:36.832Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/0d/52d98722666d6fc6c3dd4c76df339501d6efd40e0ff95e6186a7b7f0befd/black-26.3.1-py3-none-any.whl", hash = "sha256:2bd5aa94fc267d38bb21a70d7410a89f1a1d318841855f698746f8e7f51acd1b", size = 207542, upload-time = "2026-03-12T03:36:01.668Z" },
+]
+
+[[package]]
+name = "click"
+version = "8.3.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/3d/fa/656b739db8587d7b5dfa22e22ed02566950fbfbcdc20311993483657a5c0/click-8.3.1.tar.gz", hash = "sha256:12ff4785d337a1bb490bb7e9c2b1ee5da3112e94a8622f26a6c77f5d2fc6842a", size = 295065, upload-time = "2025-11-15T20:45:42.706Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/98/78/01c019cdb5d6498122777c1a43056ebb3ebfeef2076d9d026bfe15583b2b/click-8.3.1-py3-none-any.whl", hash = "sha256:981153a64e25f12d547d3426c367a4857371575ee7ad18df2a6183ab0545b2a6", size = 108274, upload-time = "2025-11-15T20:45:41.139Z" },
+]
+
+[[package]]
+name = "colorama"
+version = "0.4.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },
+]
+
+[[package]]
+name = "comfyui-to-python-extension"
+version = "1.3.1"
+source = { virtual = "." }
+dependencies = [
+    { name = "black" },
+]
+
+[package.metadata]
+requires-dist = [{ name = "black" }]
+
+[[package]]
+name = "mypy-extensions"
+version = "1.1.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a2/6e/371856a3fb9d31ca8dac321cda606860fa4548858c0cc45d9d1d4ca2628b/mypy_extensions-1.1.0.tar.gz", hash = "sha256:52e68efc3284861e772bbcd66823fde5ae21fd2fdb51c62a211403730b916558", size = 6343, upload-time = "2025-04-22T14:54:24.164Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/79/7b/2c79738432f5c924bef5071f933bcc9efd0473bac3b4aa584a6f7c1c8df8/mypy_extensions-1.1.0-py3-none-any.whl", hash = "sha256:1be4cccdb0f2482337c4743e60421de3a356cd97508abadd57d47403e94f5505", size = 4963, upload-time = "2025-04-22T14:54:22.983Z" },
+]
+
+[[package]]
+name = "packaging"
+version = "26.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/65/ee/299d360cdc32edc7d2cf530f3accf79c4fca01e96ffc950d8a52213bd8e4/packaging-26.0.tar.gz", hash = "sha256:00243ae351a257117b6a241061796684b084ed1c516a08c48a3f7e147a9d80b4", size = 143416, upload-time = "2026-01-21T20:50:39.064Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b7/b9/c538f279a4e237a006a2c98387d081e9eb060d203d8ed34467cc0f0b9b53/packaging-26.0-py3-none-any.whl", hash = "sha256:b36f1fef9334a5588b4166f8bcd26a14e521f2b55e6b9de3aaa80d3ff7a37529", size = 74366, upload-time = "2026-01-21T20:50:37.788Z" },
+]
+
+[[package]]
+name = "pathspec"
+version = "1.0.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/fa/36/e27608899f9b8d4dff0617b2d9ab17ca5608956ca44461ac14ac48b44015/pathspec-1.0.4.tar.gz", hash = "sha256:0210e2ae8a21a9137c0d470578cb0e595af87edaa6ebf12ff176f14a02e0e645", size = 131200, upload-time = "2026-01-27T03:59:46.938Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ef/3c/2c197d226f9ea224a9ab8d197933f9da0ae0aac5b6e0f884e2b8d9c8e9f7/pathspec-1.0.4-py3-none-any.whl", hash = "sha256:fb6ae2fd4e7c921a165808a552060e722767cfa526f99ca5156ed2ce45a5c723", size = 55206, upload-time = "2026-01-27T03:59:45.137Z" },
+]
+
+[[package]]
+name = "platformdirs"
+version = "4.9.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/19/56/8d4c30c8a1d07013911a8fdbd8f89440ef9f08d07a1b50ab8ca8be5a20f9/platformdirs-4.9.4.tar.gz", hash = "sha256:1ec356301b7dc906d83f371c8f487070e99d3ccf9e501686456394622a01a934", size = 28737, upload-time = "2026-03-05T18:34:13.271Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/63/d7/97f7e3a6abb67d8080dd406fd4df842c2be0efaf712d1c899c32a075027c/platformdirs-4.9.4-py3-none-any.whl", hash = "sha256:68a9a4619a666ea6439f2ff250c12a853cd1cbd5158d258bd824a7df6be2f868", size = 21216, upload-time = "2026-03-05T18:34:12.172Z" },
+]
+
+[[package]]
+name = "pytokens"
+version = "0.4.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/b6/34/b4e015b99031667a7b960f888889c5bd34ef585c85e1cb56a594b92836ac/pytokens-0.4.1.tar.gz", hash = "sha256:292052fe80923aae2260c073f822ceba21f3872ced9a68bb7953b348e561179a", size = 23015, upload-time = "2026-01-30T01:03:45.924Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/41/5d/e44573011401fb82e9d51e97f1290ceb377800fb4eed650b96f4753b499c/pytokens-0.4.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:140709331e846b728475786df8aeb27d24f48cbcf7bcd449f8de75cae7a45083", size = 160663, upload-time = "2026-01-30T01:03:06.473Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/e6/5bbc3019f8e6f21d09c41f8b8654536117e5e211a85d89212d59cbdab381/pytokens-0.4.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6d6c4268598f762bc8e91f5dbf2ab2f61f7b95bdc07953b602db879b3c8c18e1", size = 255626, upload-time = "2026-01-30T01:03:08.177Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/3c/2d5297d82286f6f3d92770289fd439956b201c0a4fc7e72efb9b2293758e/pytokens-0.4.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:24afde1f53d95348b5a0eb19488661147285ca4dd7ed752bbc3e1c6242a304d1", size = 269779, upload-time = "2026-01-30T01:03:09.756Z" },
+    { url = "https://files.pythonhosted.org/packages/20/01/7436e9ad693cebda0551203e0bf28f7669976c60ad07d6402098208476de/pytokens-0.4.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:5ad948d085ed6c16413eb5fec6b3e02fa00dc29a2534f088d3302c47eb59adf9", size = 268076, upload-time = "2026-01-30T01:03:10.957Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/df/533c82a3c752ba13ae7ef238b7f8cdd272cf1475f03c63ac6cf3fcfb00b6/pytokens-0.4.1-cp312-cp312-win_amd64.whl", hash = "sha256:3f901fe783e06e48e8cbdc82d631fca8f118333798193e026a50ce1b3757ea68", size = 103552, upload-time = "2026-01-30T01:03:12.066Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/dc/08b1a080372afda3cceb4f3c0a7ba2bde9d6a5241f1edb02a22a019ee147/pytokens-0.4.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:8bdb9d0ce90cbf99c525e75a2fa415144fd570a1ba987380190e8b786bc6ef9b", size = 160720, upload-time = "2026-01-30T01:03:13.843Z" },
+    { url = "https://files.pythonhosted.org/packages/64/0c/41ea22205da480837a700e395507e6a24425151dfb7ead73343d6e2d7ffe/pytokens-0.4.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5502408cab1cb18e128570f8d598981c68a50d0cbd7c61312a90507cd3a1276f", size = 254204, upload-time = "2026-01-30T01:03:14.886Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/d2/afe5c7f8607018beb99971489dbb846508f1b8f351fcefc225fcf4b2adc0/pytokens-0.4.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:29d1d8fb1030af4d231789959f21821ab6325e463f0503a61d204343c9b355d1", size = 268423, upload-time = "2026-01-30T01:03:15.936Z" },
+    { url = "https://files.pythonhosted.org/packages/68/d4/00ffdbd370410c04e9591da9220a68dc1693ef7499173eb3e30d06e05ed1/pytokens-0.4.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:970b08dd6b86058b6dc07efe9e98414f5102974716232d10f32ff39701e841c4", size = 266859, upload-time = "2026-01-30T01:03:17.458Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/c9/c3161313b4ca0c601eeefabd3d3b576edaa9afdefd32da97210700e47652/pytokens-0.4.1-cp313-cp313-win_amd64.whl", hash = "sha256:9bd7d7f544d362576be74f9d5901a22f317efc20046efe2034dced238cbbfe78", size = 103520, upload-time = "2026-01-30T01:03:18.652Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/a7/b470f672e6fc5fee0a01d9e75005a0e617e162381974213a945fcd274843/pytokens-0.4.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:4a14d5f5fc78ce85e426aa159489e2d5961acf0e47575e08f35584009178e321", size = 160821, upload-time = "2026-01-30T01:03:19.684Z" },
+    { url = "https://files.pythonhosted.org/packages/80/98/e83a36fe8d170c911f864bfded690d2542bfcfacb9c649d11a9e6eb9dc41/pytokens-0.4.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:97f50fd18543be72da51dd505e2ed20d2228c74e0464e4262e4899797803d7fa", size = 254263, upload-time = "2026-01-30T01:03:20.834Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/95/70d7041273890f9f97a24234c00b746e8da86df462620194cef1d411ddeb/pytokens-0.4.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:dc74c035f9bfca0255c1af77ddd2d6ae8419012805453e4b0e7513e17904545d", size = 268071, upload-time = "2026-01-30T01:03:21.888Z" },
+    { url = "https://files.pythonhosted.org/packages/da/79/76e6d09ae19c99404656d7db9c35dfd20f2086f3eb6ecb496b5b31163bad/pytokens-0.4.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:f66a6bbe741bd431f6d741e617e0f39ec7257ca1f89089593479347cc4d13324", size = 271716, upload-time = "2026-01-30T01:03:23.633Z" },
+    { url = "https://files.pythonhosted.org/packages/79/37/482e55fa1602e0a7ff012661d8c946bafdc05e480ea5a32f4f7e336d4aa9/pytokens-0.4.1-cp314-cp314-win_amd64.whl", hash = "sha256:b35d7e5ad269804f6697727702da3c517bb8a5228afa450ab0fa787732055fc9", size = 104539, upload-time = "2026-01-30T01:03:24.788Z" },
+    { url = "https://files.pythonhosted.org/packages/30/e8/20e7db907c23f3d63b0be3b8a4fd1927f6da2395f5bcc7f72242bb963dfe/pytokens-0.4.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:8fcb9ba3709ff77e77f1c7022ff11d13553f3c30299a9fe246a166903e9091eb", size = 168474, upload-time = "2026-01-30T01:03:26.428Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/81/88a95ee9fafdd8f5f3452107748fd04c24930d500b9aba9738f3ade642cc/pytokens-0.4.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:79fc6b8699564e1f9b521582c35435f1bd32dd06822322ec44afdeba666d8cb3", size = 290473, upload-time = "2026-01-30T01:03:27.415Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/35/3aa899645e29b6375b4aed9f8d21df219e7c958c4c186b465e42ee0a06bf/pytokens-0.4.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d31b97b3de0f61571a124a00ffe9a81fb9939146c122c11060725bd5aea79975", size = 303485, upload-time = "2026-01-30T01:03:28.558Z" },
+    { url = "https://files.pythonhosted.org/packages/52/a0/07907b6ff512674d9b201859f7d212298c44933633c946703a20c25e9d81/pytokens-0.4.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:967cf6e3fd4adf7de8fc73cd3043754ae79c36475c1c11d514fc72cf5490094a", size = 306698, upload-time = "2026-01-30T01:03:29.653Z" },
+    { url = "https://files.pythonhosted.org/packages/39/2a/cbbf9250020a4a8dd53ba83a46c097b69e5eb49dd14e708f496f548c6612/pytokens-0.4.1-cp314-cp314t-win_amd64.whl", hash = "sha256:584c80c24b078eec1e227079d56dc22ff755e0ba8654d8383b2c549107528918", size = 116287, upload-time = "2026-01-30T01:03:30.912Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/78/397db326746f0a342855b81216ae1f0a32965deccfd7c830a2dbc66d2483/pytokens-0.4.1-py3-none-any.whl", hash = "sha256:26cef14744a8385f35d0e095dc8b3a7583f6c953c2e3d269c7f82484bf5ad2de", size = 13729, upload-time = "2026-01-30T01:03:45.029Z" },
+]