diffusers-workflow 0.4.0__py3-none-any.whl

dw/tasks/interpolate_frames.py

@@ -0,0 +1,252 @@
+"""
+Video frame interpolation via RIFE (Real-Time Intermediate Flow Estimation).
+
+Takes a list of video frames and generates intermediate frames to increase
+frame rate. Supports 2x, 4x, and 8x multipliers.
+
+Model weights are downloaded from HuggingFace Hub on first use.
+"""
+
+import logging
+import torch
+
+from ..result import AudioVideo
+from ..shots import rescaled_shots
+from .tensor_image import pil_to_float_tensor as _pil_to_tensor, float_tensor_to_pil
+from .video_utils import frames_as_pil_list
+
+logger = logging.getLogger("dw")
+
+_VALID_MULTIPLIERS = {2, 4, 8}
+
+
+def interpolate_frames(video, device="cpu", **kwargs):
+    """Interpolate between video frames using RIFE to increase frame rate.
+
+    Args:
+        video: The frames - a list of PIL images, a frame array or tensor, or
+            an AudioVideo (a concat or dissolve step's output, whose
+            soundtrack is dropped here and put back by pair_audio)
+        device: Target device ("cuda", "mps", "cpu")
+        **kwargs:
+            multiplier: Frame count multiplier — 2, 4, or 8 (default: 2)
+            model_name: HuggingFace repo with RIFE v4.13 weights (default: auto)
+            filename: Weights filename within the repo (default: auto)
+
+    Returns:
+        One AudioVideo holding the interpolated frames and no audio - one
+        artifact, where a bare frame list would fan a later step out over
+        every frame. pair_audio puts a soundtrack under it.
+    """
+    multiplier = int(kwargs.get("multiplier", 2))
+    model_name = kwargs.get("model_name", None)
+    filename = kwargs.get("filename", None)
+
+    if multiplier not in _VALID_MULTIPLIERS:
+        raise ValueError(
+            f"multiplier must be one of {sorted(_VALID_MULTIPLIERS)}, got {multiplier}"
+        )
+
+    # An AudioVideo or a frame array unwraps to its frames; a PIL list passes
+    # through by identity. The soundtrack does not survive - the frame count
+    # changes, so pair_audio is how it comes back
+    source_fps = getattr(video, "fps", None)
+    source_shots = getattr(video, "shots", None)
+    video = frames_as_pil_list(video)
+    if len(video) < 2:
+        raise ValueError(f"Need at least 2 frames to interpolate, got {len(video)}")
+
+    logger.info(
+        f"Interpolating {len(video)} frames with {multiplier}x multiplier on {device}"
+    )
+
+    model = _load_rife_model(device, model_name, filename)
+
+    passes = {2: 1, 4: 2, 8: 3}[multiplier]
+    frames = list(video)
+
+    for pass_num in range(passes):
+        logger.debug(
+            f"Interpolation pass {pass_num + 1}/{passes}: {len(frames)} frames"
+        )
+        frames = _interpolate_2x(frames, model)
+
+    logger.info(f"Interpolation complete: {len(video)} -> {len(frames)} frames")
+    # Multiplied, not carried: interpolation adds frames between the ones it
+    # was given, so playing them back at the source rate would run the clip
+    # `multiplier` times long. The rate that keeps the source's duration is
+    # the source's times the multiplier (#84)
+    # The shots stretch with the frames between them; the track is gone, so
+    # their sample side goes with it
+    return AudioVideo(
+        frames,
+        None,
+        None,
+        fps=source_fps * multiplier if source_fps else None,
+        shots=rescaled_shots(source_shots, multiplier),
+    )
+
+
+def _interpolate_2x(frames, model):
+    """Single pass of 2x interpolation — insert one frame between each pair."""
+    result = [frames[0]]
+    for i in range(len(frames) - 1):
+        mid_frame = model(frames[i], frames[i + 1])
+        result.append(mid_frame)
+        result.append(frames[i + 1])
+    return result
+
+
+_DEFAULT_RIFE_REPO = "imaginairy/rife-interpolation"
+_DEFAULT_RIFE_FILENAME = "rife-flownet-4.13.2.safetensors"
+
+
+def _pad_tensor(t, ph, pw):
+    """Zero-pad a (1, 3, H, W) tensor on the bottom/right to (ph, pw)."""
+    h, w = t.shape[2], t.shape[3]
+    padding = (0, pw - w, 0, ph - h)
+    return torch.nn.functional.pad(t, padding)
+
+
+def _padded_size(h, w, multiple=32):
+    """Round (h, w) up to the next multiple (RIFE requires dims divisible by 32)."""
+    ph = ((h - 1) // multiple + 1) * multiple
+    pw = ((w - 1) // multiple + 1) * multiple
+    return ph, pw
+
+
+def _make_flow_context(ph, pw, device):
+    """Build the warp grid and flow divisors for one padded resolution."""
+    tenFlow_div = torch.tensor([(pw - 1.0) / 2.0, (ph - 1.0) / 2.0], device=device)
+    backwarp_tenGrid = torch.cat(
+        [
+            torch.linspace(-1.0, 1.0, pw, device=device)
+            .view(1, 1, 1, pw)
+            .expand(-1, -1, ph, -1),
+            torch.linspace(-1.0, 1.0, ph, device=device)
+            .view(1, 1, ph, 1)
+            .expand(-1, -1, -1, pw),
+        ],
+        1,
+    )
+    timestep = torch.full((1, 1, ph, pw), 0.5, dtype=torch.float32, device=device)
+    return tenFlow_div, backwarp_tenGrid, timestep
+
+
+def _load_rife_model(device, model_name=None, filename=None):
+    """Load RIFE model and return a callable that interpolates two frames.
+
+    Args:
+        device: Target device string ("cuda", "mps", "cpu").
+        model_name: Optional HuggingFace repo ID containing RIFE v4.13 weights.
+            Defaults to imaginairy/rife-interpolation.
+        filename: Optional weights filename within the repo. Defaults to
+            rife-flownet-4.13.2.safetensors. Both .safetensors and torch
+            checkpoint formats (.pkl/.pth) are supported.
+
+    Returns:
+        Callable that takes (frame1: PIL.Image, frame2: PIL.Image) -> PIL.Image
+    """
+    from .rife_model import IFNet
+    from huggingface_hub import hf_hub_download
+    from .model_cache import cached_model
+
+    repo_id = model_name if model_name is not None else _DEFAULT_RIFE_REPO
+    weights_file = filename if filename is not None else _DEFAULT_RIFE_FILENAME
+
+    def load_net():
+        model_path = hf_hub_download(repo_id=repo_id, filename=weights_file)
+
+        logger.info(f"Loading RIFE IFNet v4.13 to {device}")
+
+        if weights_file.endswith(".safetensors"):
+            from safetensors.torch import load_file
+
+            state_dict = load_file(model_path)
+        else:
+            state_dict = torch.load(model_path, map_location="cpu", weights_only=True)
+
+        # Strip "module." prefix that comes from DataParallel-saved checkpoints
+        cleaned = {}
+        for k, v in state_dict.items():
+            cleaned[k.removeprefix("module.")] = v
+
+        net = IFNet()
+        net.load_state_dict(cleaned)
+        net.eval()
+        net.to(device)
+        return net
+
+    net = cached_model(
+        ("interpolate_frames", repo_id, weights_file, str(device)), load_net
+    )
+
+    return _build_inference(net, device)
+
+
+def _build_inference(net, device):
+    """Build the (img1, img2) -> mid_frame callable for a loaded RIFE net.
+
+    All frames of a video share one padded resolution, so the flow-warp
+    context (tenFlow_div, backwarp grid, timestep) is computed once per
+    (padded_h, padded_w) and reused for every pair instead of being rebuilt
+    on every call.
+
+    `_interpolate_2x` walks frames pairwise: (f0, f1), (f1, f2), (f2, f3), ...
+    — the second frame of one pair is the same PIL object as the first frame
+    of the next. This closure carries the padded tensor it produced for a
+    pair's second frame forward, so that when that exact frame object shows
+    up again as a pair's first frame, its tensor is reused instead of being
+    re-derived from the PIL image (re-decoded, re-normalized, re-padded). A
+    cache miss (non-matching object, e.g. across separate interpolation
+    passes) simply falls back to a fresh conversion, so this is a pure
+    optimization with no behavioral effect — the reused tensor is bit-for-bit
+    what a fresh conversion of the same frame would produce.
+    """
+    scale_list = [8, 4, 2, 1]
+    flow_context_cache = {}
+    carry = {"img": None}
+
+    def get_flow_context(ph, pw):
+        key = (ph, pw)
+        ctx = flow_context_cache.get(key)
+        if ctx is None:
+            ctx = _make_flow_context(ph, pw, device)
+            flow_context_cache[key] = ctx
+        return ctx
+
+    def inference(img1, img2):
+        """Interpolate a single frame between two input frames."""
+        if img1 is carry["img"]:
+            t1_padded = carry["tensor"]
+            h, w, ph, pw = carry["h"], carry["w"], carry["ph"], carry["pw"]
+        else:
+            t1 = _pil_to_tensor(img1, device)
+            h, w = t1.shape[2], t1.shape[3]
+            ph, pw = _padded_size(h, w)
+            t1_padded = _pad_tensor(t1, ph, pw)
+
+        t2 = _pil_to_tensor(img2, device)
+        t2_padded = _pad_tensor(t2, ph, pw)
+
+        # Carry img2's padded tensor forward in case it's the next pair's img1.
+        carry["img"] = img2
+        carry["tensor"] = t2_padded
+        carry["h"], carry["w"], carry["ph"], carry["pw"] = h, w, ph, pw
+
+        tenFlow_div, backwarp_tenGrid, timestep = get_flow_context(ph, pw)
+
+        with torch.inference_mode():
+            _, _, merged = net(
+                t1_padded,
+                t2_padded,
+                timestep,
+                scale_list,
+                tenFlow_div,
+                backwarp_tenGrid,
+            )
+
+        mid = merged[3][:, :, :h, :w]
+        return float_tensor_to_pil(mid)
+
+    return inference

dw/tasks/judge.py

@@ -0,0 +1,68 @@
+"""
+Judge - score a candidate image against a rubric using a vision-language
+model.
+
+The first scorer for the select reducer (docs/proposals/score-and-select.md):
+`select` needs a number per candidate, and this is the cheapest way to get
+one without a purpose-built model - prompt the VLM `image_to_text` already
+loads with a rubric and a scale, and parse its reply to one number. Delegates
+to text_generation.generate_text, the same vision path image_to_text uses,
+rather than keeping a second copy of the pipeline handling.
+
+generate_text decodes greedily (do_sample=False - see its module docstring),
+so the same rubric and image already return the same reply every run; there
+is no sampling here for a step seed to thread through.
+"""
+
+import logging
+import re
+
+from .text_generation import generate_text, _DEFAULT_VISION_MODEL
+
+logger = logging.getLogger("dw")
+
+_DEFAULT_MODEL = _DEFAULT_VISION_MODEL
+
+_NUMBER_PATTERN = re.compile(r"-?\d+(?:\.\d+)?")
+
+
+def _judge_prompt(rubric, scale):
+    low, high = scale
+    return (
+        f"{rubric}\n\n"
+        f"Respond with a single number from {low} to {high} and nothing else."
+    )
+
+
+def judge(image, rubric, scale, device="cpu", **kwargs):
+    """Score an image against a rubric, returning one number.
+
+    Args:
+        image: PIL Image (or URL/path) to score.
+        rubric: The question or criterion to score the image against.
+        scale: [low, high] the score is expected to fall within.
+        device: Target device ("cuda", "mps", "cpu").
+        **kwargs:
+            model_name: HuggingFace model ID of a vision-language model
+                (default: image_to_text's default vision model).
+            max_new_tokens: Max tokens to generate (default: 20).
+
+    Returns:
+        The parsed score as a float.
+
+    Raises:
+        ValueError: the model's reply did not contain a number.
+    """
+    prompt = _judge_prompt(rubric, scale)
+    kwargs.setdefault("model_name", _DEFAULT_MODEL)
+    kwargs.setdefault("max_new_tokens", 20)
+
+    reply = generate_text(prompt, device=device, image=image, **kwargs)
+
+    match = _NUMBER_PATTERN.search(reply)
+    if match is None:
+        raise ValueError(f"judge: could not parse a score from the reply: {reply!r}")
+
+    score = float(match.group())
+    logger.info(f"Judged: {score}")
+    return score

dw/tasks/model_cache.py

@@ -0,0 +1,55 @@
+import logging
+
+logger = logging.getLogger("dw")
+
+# Loaded task models, keyed by whatever identifies a load - typically
+# (task, model_name, device). step.py runs a task handler once per cartesian
+# product iteration; without this, segmenting 20 images would load the same
+# multi-gigabyte checkpoints 20 times over
+_cache = {}
+
+
+def cached_model(key, factory):
+    """Return the model for key, loading it with factory() on first use.
+
+    Args:
+        key: Hashable identity of the load - include the model name and the
+            device, plus anything else that changes what factory() builds
+        factory: Zero-argument callable performing the actual load
+
+    Returns:
+        The cached or freshly loaded model
+    """
+    if key not in _cache:
+        logger.info(f"Loading task model: {key}")
+        _cache[key] = factory()
+    else:
+        logger.debug(f"Reusing cached task model: {key}")
+    return _cache[key]
+
+
+def clear_model_cache():
+    """Release every cached task model.
+
+    Wired into the worker's memory cleanup - dropping the references here is
+    what lets gc and the allocator actually reclaim the weights.
+    """
+    if _cache:
+        logger.info(f"Clearing {len(_cache)} cached task models")
+    _cache.clear()
+
+
+def hf_pipeline_placement(device):
+    """How a transformers pipeline is told where to load.
+
+    A device_map has the loading threads cast their shards straight onto the
+    device, which races inside torch's Metal shader cache on MPS. Passing
+    `device` instead leaves the load on the CPU and moves the finished model in
+    one call on this thread. Every task that builds a transformers pipeline
+    spells `**hf_pipeline_placement(device)` so the accommodation lives once.
+    """
+    from .. import get_device_type
+
+    if get_device_type(device) == "mps":
+        return {"device": device}
+    return {"device_map": device}

dw/tasks/pair_audio.py

@@ -0,0 +1,268 @@
+"""Pair a video with an audio track so the two are saved as one file.
+
+A pipeline that generates its own soundtrack returns the pair together, and the
+result muxes them into a single mp4. Anything that works on the frames alone -
+a latent upsampler, an interpolator, an upscaler - returns frames without it, so
+the soundtrack has to be carried across the step that dropped it. That is what
+this does: it puts the two back together for the step that saves them.
+"""
+
+import logging
+
+from ..events import emit_warning
+from ..result import AudioVideo
+from ..shots import remeasured_shots
+from .audio_utils import as_channels_samples
+
+logger = logging.getLogger("dw")
+
+# Only gates the unfitted mismatch warning (no 'fit' given): a track and a
+# cut are frame-aligned by construction here, so a difference smaller than
+# this is rounding rather than a decision anyone can act on - one video frame
+# at 24 fps is 41 ms. An explicit 'fit': 'video' always fits and warns on any
+# nonzero difference - the caller asked for exactness, not a guess at whether
+# the gap matters
+LENGTH_WARN_MS = 100.0
+
+
+class _Loaded:
+    """A waveform read from a file, shaped like the artifact pair_audio expects."""
+
+    def __init__(self, audio, sample_rate):
+        self.audio = audio
+        self.sample_rate = sample_rate
+
+
+def _frame_count(frames):
+    """How many frames the video is, or None when that cannot be told cheaply
+    (a lazily-decoded reader, an object with no length)."""
+    try:
+        return len(frames)
+    except TypeError:
+        shape = getattr(frames, "shape", None)
+        return int(shape[0]) if shape else None
+
+
+def _fit_to_video(waveform, rate, frames, fps, fit):
+    """Answer the track that goes with these frames, and say when the two do
+    not agree.
+
+    The lengths of a video and the track laid over it are two numbers a
+    workflow used to have to keep equal by hand, and nothing checked: the
+    music-video template sliced a soundtrack of a fixed 496 frames while its
+    cut followed a `shots` list, so a two-shot run wrote 10.3 s of picture
+    into a 20.7 s container and reported `succeeded` with no warnings (#142).
+    `fit: "video"` derives the length from the frames instead, and with no
+    `fit` the mismatch is at least said out loud.
+    """
+    from .audio_utils import frames_to_samples, slice_samples
+
+    if fit not in (None, "video"):
+        # Refused rather than ignored: a misspelled 'fit' that quietly did
+        # nothing is the silence this argument exists to end
+        raise ValueError(
+            f"pair_audio: 'fit' takes 'video' or nothing, got {fit!r}. "
+            f"'video' cuts or pads the track to the length of the frames"
+        )
+
+    count = _frame_count(frames)
+    if not count or not fps or not rate:
+        # Nothing to compare against - a frame count or a rate this layer
+        # cannot know is not a mismatch
+        return waveform
+
+    wanted = frames_to_samples(count, fps, rate)
+    have = waveform.shape[1]
+    video_seconds = count / float(fps)
+    audio_seconds = have / float(rate)
+
+    if fit != "video":
+        if abs(have - wanted) / float(rate) * 1000.0 < LENGTH_WARN_MS:
+            return waveform
+        emit_warning(
+            f"pair_audio: the track is {audio_seconds:.2f} s and the video it "
+            f"is laid over is {video_seconds:.2f} s ({count} frames at "
+            f"{fps:g} fps), so the saved file's duration and its frame count "
+            f"disagree. Pass 'fit': 'video' to cut or pad the track to the "
+            f"frames, or make the track the length of the cut.",
+            kind="audio_video_length_mismatch",
+            command="pair_audio",
+            audio_seconds=audio_seconds,
+            video_seconds=video_seconds,
+        )
+        return waveform
+
+    if have == wanted:
+        # Already exact - nothing to pad, trim or warn about
+        return waveform
+
+    fitted = slice_samples(waveform, 0, wanted)
+    # A gap smaller than one video frame cannot line up with anything the cut
+    # does - the two rates just don't divide evenly - so it is reported as
+    # what it is (a sample count) rather than as a claim on the picture
+    # ("the last part of the cut has no soundtrack") that a 1-sample pad does
+    # not support. At 24 fps a frame is 41.67 ms; formatting a sub-frame gap
+    # to two decimal places of a second is what produced "0.00 s of silence
+    # ... has no soundtrack" (#429) - self-contradictory and, followed as
+    # written, unfixable, since the gap is smaller than either 'a longer
+    # track' or 'fewer frames' can address.
+    frame_seconds = 1.0 / float(fps)
+    if wanted > have:
+        pad_samples = wanted - have
+        pad_seconds = pad_samples / float(rate)
+        if pad_seconds < frame_seconds:
+            emit_warning(
+                f"pair_audio: 'fit' padded the {audio_seconds:.2f} s track with "
+                f"{pad_samples} sample{'s' if pad_samples != 1 else ''} "
+                f"({pad_seconds * 1000:.2f} ms) of silence to reach the "
+                f"{video_seconds:.2f} s of video it is laid over - under one "
+                f"video frame ({frame_seconds * 1000:.1f} ms), most likely "
+                f"ordinary rounding between the track's sample rate and the "
+                f"video's frame rate rather than a real gap.",
+                kind="audio_padded_to_video",
+                command="pair_audio",
+                audio_seconds=audio_seconds,
+                video_seconds=video_seconds,
+                pad_samples=pad_samples,
+            )
+        else:
+            emit_warning(
+                f"pair_audio: 'fit' padded the {audio_seconds:.2f} s track with "
+                f"{pad_seconds:.2f} s of silence to reach the "
+                f"{video_seconds:.2f} s of video it is laid over - the last part "
+                f"of the cut has no soundtrack. A longer track, or fewer frames, "
+                f"is what covers it.",
+                kind="audio_padded_to_video",
+                command="pair_audio",
+                audio_seconds=audio_seconds,
+                video_seconds=video_seconds,
+                pad_samples=pad_samples,
+            )
+    else:
+        trimmed_samples = have - wanted
+        trimmed_seconds = trimmed_samples / float(rate)
+        if trimmed_seconds < frame_seconds:
+            emit_warning(
+                f"pair_audio: 'fit' trimmed {trimmed_samples} sample"
+                f"{'s' if trimmed_samples != 1 else ''} "
+                f"({trimmed_seconds * 1000:.2f} ms) off the {audio_seconds:.2f} s "
+                f"track to reach the {video_seconds:.2f} s of video it is laid "
+                f"over - under one video frame ({frame_seconds * 1000:.1f} ms), "
+                f"most likely ordinary rounding between the track's sample rate "
+                f"and the video's frame rate rather than lost content.",
+                kind="audio_trimmed_to_video",
+                command="pair_audio",
+                audio_seconds=audio_seconds,
+                video_seconds=video_seconds,
+                trimmed_seconds=trimmed_seconds,
+                trimmed_samples=trimmed_samples,
+            )
+        else:
+            emit_warning(
+                f"pair_audio: 'fit' trimmed {trimmed_seconds:.2f} s "
+                f"off the {audio_seconds:.2f} s track to reach the "
+                f"{video_seconds:.2f} s of video it is laid over - that part of "
+                f"the track, whatever it held, is gone from the deliverable. A "
+                f"shorter track, or more frames, is what keeps it.",
+                kind="audio_trimmed_to_video",
+                command="pair_audio",
+                audio_seconds=audio_seconds,
+                video_seconds=video_seconds,
+                trimmed_seconds=trimmed_seconds,
+                trimmed_samples=trimmed_samples,
+            )
+    return fitted
+
+
+def pair_audio(video, audio, sample_rate=None, fps=None, fit=None):
+    """Pair a video's frames with an audio track.
+
+    Args:
+        video: The frames - a frame list, a frame array or tensor, or an
+            AudioVideo whose own soundtrack is replaced by this one; the
+            frames' own rate is carried through to the output, so set
+            `result.fps` only to override it (a loaded file brings its rate
+            along; frames that carry none are written at 8 fps)
+        audio: The soundtrack - a waveform, an AudioVideo (or any object
+            carrying '.audio') to take it from, or the path or URL of an
+            audio or video file; the last two bring their sample rate along.
+            A mono track is fine - saving as mp4 duplicates it into the two
+            channels the audio stream takes, and warns that it did
+        sample_rate: Sample rate of the waveform. Required unless `audio`
+            carries one; given here it wins, for a track whose rate was
+            reported wrong
+        fps: The rate the frames play at, when the frames do not carry one -
+            only used to work out how long the video is, never written
+        fit: "video" cuts or pads the track with silence to the length of the
+            frames, warning either way (`audio_padded_to_video` when it pads,
+            `audio_trimmed_to_video` when it cuts). This is
+            how a soundtrack follows a cut whose length is an argument
+            rather than a constant: nothing in a workflow can multiply a
+            list's length by a frame count, so a slice written to fit four
+            shots stayed 496 frames long when the list held two, and the
+            deliverable's audio ran twice as long as its picture with
+            `succeeded` and no warnings (#142). Left unset the track is used
+            as it is, and a length that disagrees with the frames' is
+            warned about rather than passing in silence. The exactness
+            `fit` guarantees is of the *waveform handed to the encoder*, not
+            of the file a lossy mux (AAC, the only container this saves
+            audio+video into) writes: encoding is downstream of this
+            function and can still trim or pad the written track by a
+            further handful of samples (#428 measured up to ~30, well under
+            a millisecond). The save logs that residual; on a video with
+            recorded shots it warns (`joined_audio_short_after_mux`, #435)
+            only once it reaches a frame. `get_gallery_metadata`'s `media.shots`
+            and `assess_output`'s `sync_length` are measured against the
+            file as written, not this prediction, so they are the ground
+            truth for exactly how long the saved track runs
+
+    Returns:
+        One AudioVideo holding the frames and the track, at the rate the
+        frames carry - a file loaded for the `video` argument brings its
+        own, so the saved mp4 plays at the rate that went in and
+        `result.fps` is only needed to write it at a different one (#104)
+
+    Raises:
+        ValueError: If no waveform was given, or if no sample rate can be
+            established for the one that was
+    """
+    if isinstance(audio, str):
+        # A file an earlier run wrote - a score, or a cut whose track is wanted
+        from .audio_utils import load_audio
+
+        audio = _Loaded(*load_audio(audio))
+    waveform = getattr(audio, "audio", audio)
+    if waveform is None:
+        raise ValueError(
+            "pair_audio needs an audio track - the video it was given carries none"
+        )
+
+    rate = (
+        sample_rate if sample_rate is not None else getattr(audio, "sample_rate", None)
+    )
+    if rate is None:
+        raise ValueError(
+            "pair_audio needs 'sample_rate' - the audio it was given does not "
+            "carry one of its own"
+        )
+
+    # Frames are left in whatever shape they arrived in - the result saves a frame
+    # list, an array and a tensor alike, and converting a long video here would
+    # cost a copy of the whole thing for nothing
+    frames = video.frames if isinstance(video, AudioVideo) else video
+    frame_rate = fps if fps is not None else getattr(video, "fps", None)
+    logger.debug(f"Pairing frames with audio at {rate} Hz")
+    waveform = _fit_to_video(
+        as_channels_samples(waveform), rate, frames, frame_rate, fit
+    )
+    # The picture's shots survive; their samples are re-measured on the new
+    # track, which was laid under whole rather than built shot by shot
+    return AudioVideo(
+        frames,
+        waveform,
+        rate,
+        fps=getattr(video, "fps", None),
+        shots=remeasured_shots(
+            getattr(video, "shots", None), frame_rate, rate, waveform.shape[1]
+        ),
+    )

dw/tasks/qr_code.py

@@ -0,0 +1,19 @@
+import qrcode
+from .image_utils import resize_resample
+
+
+def get_qrcode_image(qr_code_contents, height=768, width=768):
+    # base the resolution off of size - defaulting to 768
+    resolution = max(height, width)
+
+    qr = qrcode.QRCode(
+        version=None,
+        error_correction=qrcode.constants.ERROR_CORRECT_H,
+        box_size=10,
+        border=4,
+    )
+    qr.add_data(qr_code_contents)
+    qr.make(fit=True)
+
+    qrcode_image = qr.make_image(fill_color="black", back_color="white")
+    return resize_resample(qrcode_image, resolution)