diffusers-workflow 0.4.0__py3-none-any.whl

dw/result_fps.py

@@ -0,0 +1,82 @@
+"""A step's result 'fps': the frame rate a video is written at.
+
+Widened the same way `subfolder` was (dw/subfolders.py): the schema lets the
+raw document hold a `variable:` or `item:` reference so a workflow can keep
+one frame-rate variable rather than a literal duplicated between the step
+that generates and the step that writes (#363). This module owns the
+resolved-value check: once substitution has run, `result.fps` has to be a
+real, positive frame rate, and it must be a whole number - `encode_video`
+(dw/result.py, the writer used whenever a step's result carries audio) hands
+the value straight to PyAV as `rate=int(fps)`, so a fractional rate like
+23.976 would be silently floored to 23 rather than written as asked. A
+frame_rate variable declared as a float (24.0) still passes, since it carries
+no fractional part; only a genuine fraction is refused.
+
+Containment doesn't apply here - there's no path to join - so unlike
+subfolder_errors this only ever checks value shape.
+"""
+
+from .for_each import MEMBER_SEPARATOR, render_path
+
+FPS_KEY = "fps"
+
+# Reference prefixes substitution resolves before this pass runs. One still
+# spelled out here is one nothing resolved, and that is the undeclared-
+# variable pass's complaint rather than a shape error
+_UNRESOLVED_PREFIXES = ("variable:", "item:")
+
+
+def fps_errors(workflow_definition, source_indices=None):
+    """Every result 'fps' that cannot be written, as [{path, message}].
+
+    The definition handed here has already been substituted and expanded,
+    so every value in it is literal; a 'variable:' or 'item:' still spelled
+    out is left alone. `source_indices`, when given, is the source step
+    index of each step - a 'for_each' group turns one written step into
+    several, and the path an error carries has to be one the author can
+    find in the file they wrote; the member is named in the message.
+    """
+    steps = workflow_definition.get("steps")
+    if not isinstance(steps, list):
+        return []
+
+    errors = []
+    for index, step in enumerate(steps):
+        if not isinstance(step, dict):
+            continue
+        result = step.get("result")
+        if not isinstance(result, dict) or FPS_KEY not in result:
+            continue
+        value = result[FPS_KEY]
+        if isinstance(value, str) and value.startswith(_UNRESOLVED_PREFIXES):
+            continue
+
+        source = (
+            source_indices[index]
+            if source_indices is not None and index < len(source_indices)
+            else index
+        )
+        name = step.get("name")
+        where = (
+            f" in member '{name}'"
+            if isinstance(name, str) and MEMBER_SEPARATOR in name
+            else ""
+        )
+        message = None
+        if isinstance(value, bool) or not isinstance(value, (int, float)):
+            message = f"Invalid fps: {value!r} - fps is a number of frames per second"
+        elif value <= 0:
+            message = f"Invalid fps: {value!r} - fps must be greater than zero"
+        elif float(value) != int(value):
+            message = (
+                f"Invalid fps: {value!r} - fps must be a whole number; the video "
+                f"writer truncates a fractional rate rather than honoring it"
+            )
+        if message is not None:
+            errors.append(
+                {
+                    "path": render_path(("steps", source, "result", FPS_KEY)),
+                    "message": f"{message}{where}",
+                }
+            )
+    return errors

dw/run.py

@@ -0,0 +1,162 @@
+import argparse
+import os
+from . import startup
+from .workflow import workflow_from_file
+from .runs import set_output_layout
+from .workspace import resolve_workspace, set_workspace
+from .security import (
+    validate_workflow_path,
+    validate_output_path,
+    validate_variable_name,
+    validate_string_input,
+    set_trust_workflows,
+    SecurityError,
+    MAX_VARIABLE_VALUE_LENGTH,
+)
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Run a workflow from a file.")
+    parser.add_argument(
+        "file_name", type=str, help="The filespec to of the workflow to run"
+    )
+    parser.add_argument(
+        "-o",
+        "--output_dir",
+        type=str,
+        default=None,
+        help="The folder to write the outputs to (default: the workspace's "
+        "outputs/ - ./outputs when run from a workspace, as a checkout is)",
+    )
+    parser.add_argument(
+        "--workspace",
+        type=str,
+        default=None,
+        help="Directory holding your workflows, prompts, assets and outputs "
+        "(default: DW_WORKSPACE, else the 'workspace' setting, else the "
+        "working directory when it looks like a workspace, else "
+        "~/diffusers-workspace)",
+    )
+    parser.add_argument(
+        "variables",
+        nargs="*",  # Accept 0 or more parameters
+        help="Optional parameters in name=value format",
+    )
+    parser.add_argument(
+        "-l",
+        "--log_level",
+        type=str,
+        default="INFO",
+        help="Set the logging level (DEBUG, INFO, WARNING, ERROR, CRITICAL)",
+    )
+    parser.add_argument(
+        "--prompt-dir",
+        type=str,
+        default=None,
+        help="Directory 'prompt:' references resolve against (default: "
+        "DW_PROMPT_DIR, else ./prompts if it exists, else the nearest "
+        "prompts/ above the workflow file)",
+    )
+    parser.add_argument(
+        "--asset-dir",
+        type=str,
+        default=None,
+        help="Directory 'asset:' references resolve against (default: "
+        "DW_ASSET_DIR, else the workspace's assets/ when a workspace was "
+        "named, else ./assets if it exists, else the nearest assets/ above "
+        "the workflow file)",
+    )
+    parser.add_argument(
+        "--output-layout",
+        type=str,
+        choices=("run", "flat"),
+        default=None,
+        help="'run' (default) gives each run its own directory under "
+        "<output_dir>/<workflow>/, with a manifest.json beside its files; "
+        "'flat' writes the way it did before run directories",
+    )
+    parser.add_argument(
+        "--trust-workflows",
+        action="store_true",
+        default=False,
+        help="Trust this workflow file to execute arbitrary Python: allow "
+        "pre_load_modules and any dotted *_type/*_dtype/dtype/config_type "
+        "value, not just ones inside the diffusers/torch/transformers/"
+        "quantization-backend ecosystem the tool already depends on. Off "
+        "by default - see docs/SECURITY.md's Trust model. Only pass this "
+        "for a workflow file whose source you trust.",
+    )
+    # parse_intermixed_args, not parse_args: argparse splits positionals into
+    # groups around an option, and with a nargs='*' positional that means
+    # 'dw-run wf.json -o outputs prompt=cat' - an option between the file
+    # and the name=value pairs - fails as unrecognized arguments
+    args = parser.parse_intermixed_args()
+
+    # Pinned before anything resolves a directory from it, and exported so a
+    # subprocess sees the same answer
+    workspace = set_workspace(resolve_workspace(args.workspace))
+    output_dir = args.output_dir or workspace.outputs
+
+    if args.prompt_dir:
+        os.environ["DW_PROMPT_DIR"] = os.path.abspath(args.prompt_dir)
+
+    if args.asset_dir:
+        os.environ["DW_ASSET_DIR"] = os.path.abspath(args.asset_dir)
+
+    if args.output_layout:
+        set_output_layout(args.output_layout)
+
+    set_trust_workflows(args.trust_workflows)
+
+    # Parse key-value pairs with validation
+    variables = {}
+    for variable in args.variables:
+        try:
+            name, value = variable.split("=", 1)
+            # Validate variable name and value
+            validated_name = validate_variable_name(name.strip())
+            validated_value = validate_string_input(
+                value.strip(), max_length=MAX_VARIABLE_VALUE_LENGTH, allow_empty=True
+            )
+            variables[validated_name] = validated_value
+        except ValueError:
+            print(f"Error: Variable '{variable}' is not in name=value format")
+            exit(1)
+        except SecurityError as e:
+            print(f"Error: Invalid variable input: {e}")
+            exit(1)
+
+    # Validate and secure file paths
+    try:
+        validated_output_dir = validate_output_path(output_dir, None)
+        if not os.path.exists(validated_output_dir):
+            # Create output directory if it doesn't exist
+            os.makedirs(validated_output_dir, exist_ok=True)
+            print(f"Created output directory: {validated_output_dir}")
+
+        validated_file_path = validate_workflow_path(args.file_name)
+        if not os.path.exists(validated_file_path):
+            raise FileNotFoundError(f"File {validated_file_path} does not exist")
+
+    except SecurityError as e:
+        print(f"Error: Security validation failed: {e}")
+        exit(1)
+
+    startup(args.log_level)
+
+    workflow = workflow_from_file(validated_file_path, validated_output_dir)
+    try:
+        workflow.validate()
+    except Exception as e:
+        print(f"Error validating workflow '{args.file_name}': {e}")
+        exit(1)
+
+    try:
+        workflow.run(variables)
+    except Exception as e:
+        print(f"Error running workflow '{args.file_name}': {e}")
+        exit(1)
+
+
+if __name__ == "__main__":
+    main()