diffusers-workflow 0.4.0__py3-none-any.whl

dw/tasks/dissolve_videos.py

@@ -0,0 +1,342 @@
+"""Join videos with cross-dissolves, and fade the whole from and to a colour.
+
+`concat_videos` cuts: every seam is a hard edit, which is right for a scene
+built from shots that each carry their own sound. A lyrical piece - a nature
+film, a montage cut to a score - wants its shots to melt into one another
+instead. Each seam here overlaps the tail of one video with the head of the
+next by `dissolve_frames`, blending linearly across the overlap, so the result
+is shorter than the plain sum by one overlap per seam; the soundtrack, when
+every video carries one, is crossfaded over exactly the same span so it stays
+in step with the picture. A `fade_in_frames` / `fade_out_frames` pair opens and
+closes the piece on `fade_color`, which is what a film does instead of
+starting on a full frame.
+"""
+
+import logging
+
+import numpy
+from PIL import Image
+
+from ..events import emit_log, emit_warning
+from ..result import AudioVideo
+from ..shots import measured_num_samples, nested_shots, shot_record
+from .audio_utils import (
+    as_channels_samples,
+    crossfade_concat,
+    fit_audio_to_frames,
+    frames_to_samples,
+    match_levels as match_track_levels,
+    resample_waveform,
+    warn_on_level_spread,
+)
+from .concat_videos import video_names
+from .video_utils import check_same_frame_size, frames_as_array, load_audio_video
+
+logger = logging.getLogger("dw")
+
+
+def dissolve_videos(
+    videos,
+    dissolve_frames=12,
+    fade_in_frames=0,
+    fade_out_frames=0,
+    fade_color=(0, 0, 0),
+    fps=None,
+    match_levels=None,
+    match_levels_dbfs=None,
+    sample_rate=None,
+):
+    """Task command: join videos with cross-dissolves at every seam.
+
+    Args:
+        videos: The videos to join, in order - frame lists, frame arrays,
+            AudioVideos, or the path or URL of a video file. Give each video
+            its own entry, as with concat_videos. Soundtracks at different
+            sample rates are not a constraint - see `sample_rate` below
+        dissolve_frames: Frames of overlap at each seam. 0 is a hard cut
+        fade_in_frames: Frames over which the first video rises out of
+            `fade_color`
+        fade_out_frames: Frames over which the last video sinks into it
+        fade_color: The RGB colour the fades come from and go to
+        fps: Frame rate of the videos - required to crossfade audio at a
+            dissolve, and ignored when no video carries any
+        match_levels: Even the shots' loudness out before joining - "rms"
+            for perceived level, "peak" for the loudest sample. Off by
+            default; see concat_videos, which has the same pair. Left off, a
+            spread wide enough to hear is logged as a warning
+        match_levels_dbfs: The level match_levels moves every shot to -
+            defaults to -1 dBFS for "peak" and -20 dBFS for "rms". A shot
+            that would clip at the target is held at -0.5 dBFS peak instead,
+            reported as a match_levels_held warning, with a per-shot log
+            event naming the hold
+        sample_rate: The rate the joined soundtrack is at. Shots that come
+            from different sources routinely carry different rates, and
+            unlike a level jump that difference has no editorial meaning, so
+            by default the highest rate among the inputs is chosen and the
+            rest are resampled up to it, with a warning naming which - the
+            same conversion concat_videos does (#108, #287). Give this to
+            pin the target instead
+
+    Returns:
+        One AudioVideo; its audio is None unless every input carries a track
+
+    Raises:
+        ValueError: If a video is too short to carry its share of the overlaps
+    """
+    if not isinstance(videos, list) or not videos:
+        raise ValueError("dissolve_videos needs a non-empty list of videos")
+    if dissolve_frames < 0 or fade_in_frames < 0 or fade_out_frames < 0:
+        raise ValueError("dissolve_videos frame counts cannot be negative")
+
+    loaded = [load_audio_video(v) if isinstance(v, str) else v for v in videos]
+    clips = [frames_as_array(v).astype(numpy.float32) for v in loaded]
+    check_same_frame_size(clips, "dissolve_videos")
+
+    for index, clip in enumerate(clips):
+        seams = (index > 0) + (index < len(clips) - 1)
+        if len(clip) < seams * dissolve_frames:
+            raise ValueError(
+                f"video {index} has {len(clip)} frames, too few for its "
+                f"{seams} dissolve(s) of {dissolve_frames} frames"
+            )
+
+    joined = clips[0]
+    # Where each clip's first frame landed - the start of its dissolve
+    frame_starts = [0]
+    for clip in clips[1:]:
+        frame_starts.append(len(joined) - dissolve_frames)
+        joined = _dissolve_join(joined, clip, dissolve_frames)
+
+    if fade_in_frames or fade_out_frames:
+        color = numpy.asarray(fade_color, dtype=numpy.float32)
+        total = len(joined)
+        fade_in = min(fade_in_frames, total)
+        fade_out = min(fade_out_frames, total - fade_in)
+        if fade_in:
+            weights = _ramp(fade_in, ascending=True)
+            joined[:fade_in] = _blend(color, joined[:fade_in], weights)
+        if fade_out:
+            weights = _ramp(fade_out, ascending=False)
+            joined[total - fade_out :] = _blend(
+                color, joined[total - fade_out :], weights
+            )
+
+    frames = [Image.fromarray(frame) for frame in joined.round().astype(numpy.uint8)]
+    written_fps = fps or next(
+        (v.fps for v in loaded if getattr(v, "fps", None)),
+        None,
+    )
+    audio, sample_rate = _dissolve_audio(
+        loaded,
+        dissolve_frames,
+        fps,
+        match_levels,
+        match_levels_dbfs,
+        sample_rate,
+        len(frames),
+        written_fps,
+    )
+    shots = _dissolve_shots(
+        loaded,
+        video_names(videos),
+        frame_starts,
+        len(frames),
+        written_fps,
+        audio,
+        sample_rate,
+        dissolve_frames,
+    )
+    logger.info(
+        f"Dissolved {len(clips)} videos into {len(frames)} frames "
+        f"({dissolve_frames}-frame seams)"
+    )
+    return AudioVideo(frames, audio, sample_rate, fps=written_fps, shots=shots)
+
+
+def _dissolve_shots(
+    videos,
+    names,
+    frame_starts,
+    total_frames,
+    fps,
+    audio,
+    sample_rate,
+    dissolve_frames,
+):
+    """One shot per video - or, for one that already carries its own, one per
+    inner shot - partitioning the dissolved picture and track.
+
+    A dissolve belongs to the shot coming in: each video's own frames map
+    onto the joined picture by the exact offset frame_starts[index] gives (a
+    dissolve blends in place rather than dropping frames, unlike
+    concat_videos' head trim), so an input that is itself an earlier join's
+    output keeps its inner seams rather than collapsing to one record
+    (#399). `overlap_frames` marks how much of the shot's own head - the
+    first inner one, when it nests - is blended with what came before. The
+    same dissolve also eats into the *tail* of the video before it: a
+    non-nested video's shot already stops at frame_starts[index + 1] (the
+    frame the next video's overlap starts blending at), so its recorded
+    num_frames excludes the overlap; a nested video's last inner shot must
+    be trimmed by the same dissolve_frames to keep that convention, or its
+    num_frames runs past where the next shot's start_frame picks up (#405).
+
+    Each shot's `start_sample` is *derived* from its frame offset
+    (frames_to_samples), the same rule pair_audio's remeasured_shots uses,
+    rather than read off where the crossfade actually landed: summing the
+    individually-rounded per-clip lengths a real dissolve measures does not
+    equal rounding the cumulative frame count in one step, so the two tools
+    disagreed by a sample on a shot whose frames never changed (#401). The
+    crossfade itself still blends the real, measured audio - only the
+    recorded seam position is derived, so it matches whatever a later
+    pair_audio recomputes for the same boundary. A nested video's own inner
+    shots get the same treatment (`nested_shots(..., fps=fps)`) rather than
+    rescaling their already-rounded stored `start_sample`, which would
+    compound the rounding across every join an input has passed through
+    (#405).
+    """
+    total_samples = audio.shape[1] if audio is not None else None
+    shots = []
+    for index, (video, name) in enumerate(zip(videos, names)):
+        inner = getattr(video, "shots", None)
+        sample_offset = (
+            min(frames_to_samples(frame_starts[index], fps, sample_rate), total_samples)
+            if audio is not None and fps
+            else None
+        )
+        if inner:
+            nested = nested_shots(
+                inner,
+                frame_starts[index],
+                sample_offset,
+                getattr(video, "sample_rate", None),
+                sample_rate,
+                fps=fps,
+            )
+            if index and dissolve_frames and nested:
+                nested[0]["overlap_frames"] = dissolve_frames
+            if dissolve_frames and nested and index < len(videos) - 1:
+                nested[-1]["num_frames"] -= dissolve_frames
+            # Which input this shot came from - named_shots (dw/shots.py)
+            # uses it to place a step's override name on the right shot once
+            # an earlier input has nested more than one of its own (#432)
+            for shot in nested:
+                shot["source_index"] = index
+            shots.extend(nested)
+        else:
+            frame_end = (
+                frame_starts[index + 1]
+                if index + 1 < len(frame_starts)
+                else total_frames
+            )
+            shot = shot_record(
+                name,
+                frame_starts[index],
+                frame_end - frame_starts[index],
+                sample_offset,
+            )
+            if index and dissolve_frames:
+                shot["overlap_frames"] = dissolve_frames
+            shot["source_index"] = index
+            shots.append(shot)
+    measured_num_samples(shots, total_samples)
+    return shots
+
+
+def _dissolve_join(previous, following, overlap):
+    """Overlap the tail of `previous` with the head of `following`."""
+    if overlap == 0:
+        return numpy.concatenate([previous, following])
+    weights = _ramp(overlap, ascending=True)
+    blended = _blend(previous[-overlap:], following[:overlap], weights)
+    return numpy.concatenate([previous[:-overlap], blended, following[overlap:]])
+
+
+def _ramp(count, ascending):
+    """Blend weights that never sit on 0 or 1, so no frame is a bare copy of
+    either side - the seam's first frame already carries some of the incoming
+    picture and its last still carries some of the outgoing one."""
+    weights = (numpy.arange(count, dtype=numpy.float32) + 1) / (count + 1)
+    return weights if ascending else 1 - weights
+
+
+def _blend(from_frames, to_frames, weights):
+    weights = weights.reshape(-1, 1, 1, 1)
+    return from_frames * (1 - weights) + to_frames * weights
+
+
+def _dissolve_audio(
+    videos,
+    dissolve_frames,
+    fps,
+    match_levels=None,
+    match_levels_dbfs=None,
+    sample_rate=None,
+    total_frames=None,
+    written_fps=None,
+):
+    """Crossfade every video's track over the seams' own span."""
+    tracks = [v for v in videos if isinstance(v, AudioVideo) and v.audio is not None]
+    if len(tracks) != len(videos):
+        if tracks:
+            logger.warning(
+                "dissolve_videos: some videos carry no audio - the result is silent"
+            )
+        return None, None
+    if fps is None and dissolve_frames:
+        raise ValueError("dissolve_videos needs 'fps' to crossfade audio at a dissolve")
+
+    # Shots assembled from different sources disagree on rate routinely, and
+    # the disagreement carries no editorial meaning - so it is converted
+    # rather than refused, which is what made an agent invent a
+    # resample_audio step by hand for concat_videos before #108 (#287)
+    names = video_names(videos)
+    track_names = [
+        name
+        for name, video in zip(names, videos)
+        if isinstance(video, AudioVideo) and video.audio is not None
+    ]
+    rates = {v.sample_rate for v in tracks}
+    sample_rate = sample_rate or max(rates)
+    waveforms = [as_channels_samples(v.audio) for v in tracks]
+    if len(rates) == 1 and next(iter(rates)) != sample_rate:
+        # The inputs agree and the caller pinned another rate: converting
+        # to what was asked for is not a decision made on its behalf (#453)
+        emit_log(
+            f"dissolve_videos: resampling every track from {next(iter(rates))} Hz "
+            f"to the requested {sample_rate} Hz",
+            command="dissolve_videos",
+            sample_rate=sample_rate,
+        )
+    elif len(rates) != 1:
+        per_track = {name: v.sample_rate for name, v in zip(track_names, tracks)}
+        emit_warning(
+            "dissolve_videos: videos carry audio at different sample rates ("
+            + ", ".join(f"{name}: {rate} Hz" for name, rate in per_track.items())
+            + f") - resampling them all to {sample_rate} Hz. Pass "
+            "'sample_rate' to pin a different target, or resample ahead of "
+            "this step with the 'resample_audio' task.",
+            kind="sample_rate_mismatch",
+            command="dissolve_videos",
+            sample_rate=sample_rate,
+            sample_rates=per_track,
+        )
+    waveforms = [
+        (
+            waveform
+            if video.sample_rate == sample_rate
+            else resample_waveform(waveform, video.sample_rate, sample_rate)
+        )
+        for video, waveform in zip(tracks, waveforms)
+    ]
+    crossfade_ms = dissolve_frames / fps * 1000 if dissolve_frames else 0
+    if match_levels:
+        waveforms = match_track_levels(
+            waveforms, match_levels, match_levels_dbfs, "dissolve_videos"
+        )
+    else:
+        warn_on_level_spread(waveforms, "dissolve_videos")
+    joined = crossfade_concat(waveforms, sample_rate, crossfade_ms)
+    joined = fit_audio_to_frames(
+        joined, sample_rate, total_frames, written_fps, "dissolve_videos"
+    )
+    return joined, sample_rate

dw/tasks/format_messages.py

@@ -0,0 +1,24 @@
+def format_chat_message(system_prompt, user_message):
+    return {
+        "text_inputs": [
+            {"role": "system", "content": system_prompt},
+            {
+                "role": "user",
+                "content": user_message,
+            },
+        ]
+    }
+
+
+def batch_decode_post_process(processor, task, generated_ids):
+    generated_text = processor.batch_decode(generated_ids, skip_special_tokens=False)[0]
+
+    parsed_answer = processor.post_process_generation(generated_text, task=task)
+
+    return parsed_answer[task]
+
+
+def get_dict_value(dict, key):
+    if key in dict:
+        return dict[key]
+    return None

dw/tasks/gather.py

@@ -0,0 +1,173 @@
+import glob as glob_lib
+import io
+import logging
+from diffusers.utils import load_image
+from PIL import Image
+from ..arguments import fetch_image
+from ..security import SecurityError
+from ..locations import contained_matches, safe_get, validate_media_glob
+from .video_utils import load_audio_video
+
+logger = logging.getLogger("dw")
+
+
+def gather_images(glob=None, urls=None):
+    """
+    Gather images from local files and/or URLs.
+
+    Args:
+        glob: Pattern for matching local image files (e.g., "images/*.png")
+        urls: List of URLs to download images from
+
+    Returns:
+        List of loaded images
+
+    Raises:
+        ValueError: If no images are found
+        SecurityError: If validation fails
+    """
+    if urls is None:
+        urls = []
+    images = []
+
+    # Load local images matching glob pattern
+    if glob is not None:
+        logger.debug(f"Searching for images matching pattern: {glob}")
+        # The pattern is a location like any other, and goes through the same
+        # policy: it may only expand inside the directories this workflow may
+        # read, and each match is re-checked because a wildcard can leave the
+        # tree through a symlink (dw/locations.py)
+        pattern = validate_media_glob(glob, what="the images glob")
+        # Sorted, because glob returns filesystem order: a numbered sequence
+        # of images gathered for concatenation has to come back in its own
+        # order, not in whatever order the directory happens to hold
+        image_paths = contained_matches(
+            sorted(glob_lib.glob(pattern)), what="the images glob"
+        )
+        logger.info(f"Found {len(image_paths)} local images")
+
+        for path in image_paths:
+            try:
+                logger.debug(f"Loading image from: {path}")
+                images.append(fetch_image(path))
+            except SecurityError:
+                raise
+            except Exception as e:
+                logger.error(
+                    f"Failed to load image from {path}: {str(e)}", exc_info=True
+                )
+                raise
+
+    # Load images from URLs
+    for url in urls:
+        try:
+            logger.debug(f"Loading image from URL: {url}")
+            # safe_get re-checks every redirect, which load_image's own
+            # fetch does not; load_image still transposes and converts
+            response = safe_get(url, "a gathered image url", timeout=60)
+            images.append(load_image(Image.open(io.BytesIO(response.content))))
+        except SecurityError:
+            raise
+        except Exception as e:
+            logger.error(
+                f"Failed to load image from URL {url}: {str(e)}", exc_info=True
+            )
+            raise
+
+    # Validate that we found at least one image
+    if len(images) == 0:
+        error_msg = "No images found"
+        logger.error(error_msg)
+        raise ValueError(error_msg)
+
+    logger.debug(f"Successfully gathered {len(images)} images")
+    return images
+
+
+def gather_videos(glob=None, urls=None):
+    """
+    Gather videos from local files and/or URLs, audio included. To join
+    videos rather than iterate over them, give their paths to concat_videos
+    directly instead of gathering them first.
+
+    Each video comes back as one artifact holding its frames and whatever
+    audio was muxed alongside them, so a step that references this one
+    iterates over videos rather than over frames - and a step meant to
+    consume all of them at once, as concat_videos is, would be fanned out
+    over them one at a time.
+
+    Args:
+        glob: Pattern for matching local video files (e.g., "videos/*.mp4")
+        urls: List of URLs to download videos from
+
+    Returns:
+        List of AudioVideo artifacts, one per gathered video
+
+    Raises:
+        ValueError: If no videos are found
+        SecurityError: If validation fails
+    """
+    if urls is None:
+        urls = []
+    videos = []
+
+    # Load local videos matching glob pattern
+    if glob is not None:
+        logger.debug(f"Searching for videos matching pattern: {glob}")
+        # Same containment as gather_images - one policy, two tasks
+        pattern = validate_media_glob(glob, what="the videos glob")
+        # Sorted, because glob returns filesystem order: a numbered sequence
+        # of videos gathered for concatenation has to come back in its own
+        # order, not in whatever order the directory happens to hold
+        video_paths = contained_matches(
+            sorted(glob_lib.glob(pattern)), what="the videos glob"
+        )
+        logger.info(f"Found {len(video_paths)} local videos")
+
+        for path in video_paths:
+            try:
+                logger.debug(f"Loading video from: {path}")
+                videos.append(load_audio_video(path))
+            except SecurityError:
+                raise
+            except Exception as e:
+                logger.error(
+                    f"Failed to load video from {path}: {str(e)}", exc_info=True
+                )
+                raise
+
+    # Load videos from URLs
+    for url in urls:
+        try:
+            logger.debug(f"Loading video from URL: {url}")
+            videos.append(load_audio_video(url))
+        except SecurityError:
+            raise
+        except Exception as e:
+            logger.error(
+                f"Failed to load video from URL {url}: {str(e)}", exc_info=True
+            )
+            raise
+
+    # Validate that we found at least one video
+    if len(videos) == 0:
+        error_msg = "No videos found"
+        logger.error(error_msg)
+        raise ValueError(error_msg)
+
+    logger.debug(f"Successfully gathered {len(videos)} videos")
+    return videos
+
+
+def gather_inputs(kwargs):
+    """
+    Gather input arguments for passing to next task.
+
+    Args:
+        kwargs: Dictionary of input arguments
+
+    Returns:
+        Input arguments unchanged
+    """
+    logger.debug(f"Gathering input arguments: {kwargs}")
+    return kwargs

dw/tasks/grade.py

@@ -0,0 +1,97 @@
+"""
+CPU colour grading: exposure, contrast, saturation, temperature/tint.
+
+Pure numpy/PIL - no model, no GPU. A video is graded per frame by the
+command handler (task.py's _per_frame), so this module only ever sees a
+single PIL Image.
+"""
+
+import numpy as np
+from PIL import Image
+
+# Luma weights (Rec. 709), used as the saturation pivot
+_LUMA_WEIGHTS = np.array([0.2126, 0.7152, 0.0722], dtype=np.float32)
+
+# Fraction of the full [0, 1] channel range shifted at |temperature| == 1.0 or
+# |tint| == 1.0. Temperature moves the red and blue channels apart (warmer is
+# more red, less blue); tint moves the green channel against them (more
+# magenta is less green). Both are linear in their argument and independent
+# of each other - this is the "documented scale" v1 promises rather than a
+# physical colour-temperature-in-Kelvin model, which is more expensive to
+# compute and no more useful to a generation pipeline's output.
+_WHITE_BALANCE_STRENGTH = 0.15
+
+
+def grade_image(
+    media,
+    exposure=0.0,
+    contrast=1.0,
+    saturation=1.0,
+    temperature=0.0,
+    tint=0.0,
+):
+    """Adjust exposure, contrast, saturation and white balance of a single frame.
+
+    Every parameter is optional; omitting one leaves that adjustment at its
+    identity value, so calling with no arguments returns the input pixels
+    unchanged (within rounding). Adjustments apply in this order: exposure,
+    then contrast, then temperature/tint, then saturation.
+
+    Args:
+        media: PIL Image to grade. A video is dispatched to this one frame at
+            a time by the command handler (task.py's _per_frame), so this
+            function itself only ever sees a single frame.
+        exposure: Stops to brighten (positive) or darken (negative) by,
+            applied as a multiply of 2**exposure. 0.0 (default) is identity.
+        contrast: Multiplier applied around the mid grey point (0.5).
+            1.0 (default) is identity; above 1 increases contrast, below 1
+            (down to 0) flattens it.
+        saturation: Multiplier applied around each pixel's own luma
+            (Rec. 709 weights). 1.0 (default) is identity; 0.0 is greyscale.
+        temperature: Warm/cool white-balance shift from -1.0 (coolest, shifts
+            toward blue) to 1.0 (warmest, shifts toward red), linear, moving
+            the red and blue channels apart by up to 15% of the channel
+            range at |1.0|. 0.0 (default) is identity.
+        tint: Green/magenta white-balance shift from -1.0 (green) to 1.0
+            (magenta), linear, moving the green channel by up to 15% of the
+            channel range at |1.0| in the opposite direction to the shift's
+            sign. 0.0 (default) is identity.
+
+    Returns:
+        PIL Image, same size and mode as the input (graded). An alpha
+        channel, if the input has one, passes through untouched.
+    """
+    alpha = None
+    if media.mode in ("RGBA", "LA"):
+        alpha = media.getchannel("A")
+
+    rgb = media.convert("RGB")
+    array = np.asarray(rgb, dtype=np.float32) / 255.0
+
+    if exposure != 0.0:
+        array = array * (2.0**exposure)
+
+    if contrast != 1.0:
+        array = (array - 0.5) * contrast + 0.5
+
+    if temperature != 0.0:
+        shift = temperature * _WHITE_BALANCE_STRENGTH
+        array[..., 0] += shift
+        array[..., 2] -= shift
+
+    if tint != 0.0:
+        shift = tint * _WHITE_BALANCE_STRENGTH
+        array[..., 1] -= shift
+
+    if saturation != 1.0:
+        luma = np.tensordot(array, _LUMA_WEIGHTS, axes=([-1], [0]))
+        array = luma[..., None] + (array - luma[..., None]) * saturation
+
+    array = np.clip(array * 255.0, 0, 255).astype(np.uint8)
+    graded = Image.fromarray(array, mode="RGB")
+
+    if alpha is not None:
+        graded = graded.convert("RGBA")
+        graded.putalpha(alpha)
+
+    return graded

dw/tasks/image_to_text.py

@@ -0,0 +1,43 @@
+"""
+Image captioning via HuggingFace transformers.
+
+Captioning is text generation that happens to be given a picture, so this
+delegates to the text_generation task rather than keeping a second copy of
+the pipeline handling. Transformers 5 removed the dedicated "image-to-text"
+task this used to build, and with it the BLIP-style captioning models; the
+work is done by vision-language models now.
+"""
+
+import logging
+from .text_generation import generate_text, _DEFAULT_VISION_MODEL
+
+logger = logging.getLogger("dw")
+
+_DEFAULT_MODEL = _DEFAULT_VISION_MODEL
+_DEFAULT_PROMPT = "Describe this image."
+
+
+def image_to_text(image, device="cpu", **kwargs):
+    """Generate a text caption for an image.
+
+    Args:
+        image: PIL Image (or URL/path) to caption.
+        device: Target device ("cuda", "mps", "cpu").
+        **kwargs:
+            model_name: HuggingFace model ID of a vision-language model
+                (default: HuggingFaceTB/SmolVLM-256M-Instruct).
+            prompt: What to ask about the image (default: "Describe this
+                image."). Ask a narrower question for a narrower caption.
+            system_prompt: Optional system instruction for the model.
+            max_new_tokens: Max tokens to generate (default: 50).
+
+    Returns:
+        Caption string.
+    """
+    prompt = kwargs.pop("prompt", _DEFAULT_PROMPT)
+    kwargs.setdefault("model_name", _DEFAULT_MODEL)
+    kwargs.setdefault("max_new_tokens", 50)
+
+    caption = generate_text(prompt, device=device, image=image, **kwargs)
+    logger.info(f"Caption: {caption[:100]}{'...' if len(caption) > 100 else ''}")
+    return caption