pygpt-net 2.6.31__py3-none-any.whl → 2.6.33__py3-none-any.whl

pygpt_net/core/render/web/body.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.08.19 07:00:00                  #
+# Updated Date: 2025.09.01 23:00:00                  #
 # ================================================== #
 
 import os
@@ -15,6 +15,7 @@ from random import shuffle as _shuffle
 
 from typing import Optional, List, Dict
 
+from pygpt_net.core.text.utils import elide_filename
 from pygpt_net.core.events import Event
 from pygpt_net.item.ctx import CtxItem
 from pygpt_net.utils import trans
@@ -25,6 +26,7 @@ import pygpt_net.js_rc
 import pygpt_net.css_rc
 import pygpt_net.fonts_rc
 
+
 class Body:
 
     NUM_TIPS = 13
@@ -1066,7 +1068,7 @@ class Body:
             num_all: Optional[int] = None
     ) -> str:
         """
-        Get image HTML
+        Get media image/video/audio HTML
 
         :param url: URL to image
         :param num: number of image
@@ -1075,7 +1077,26 @@ class Body:
         """
         url, path = self.window.core.filesystem.extract_local_url(url)
         basename = os.path.basename(path)
-        return f'<div class="extra-src-img-box" title="{url}"><div class="img-outer"><div class="img-wrapper"><a href="{url}"><img src="{path}" class="image"></a></div><a href="{url}" class="title">{basename}</a></div></div><br/>'
+
+        # if video file then embed video player
+        ext = os.path.splitext(basename)[1].lower()
+        video_exts = (".mp4", ".webm", ".ogg", ".mov", ".avi", ".mkv")
+        if ext in video_exts:
+            # check if .webm file exists for better compatibility
+            if ext != ".webm":
+                webm_path = os.path.splitext(path)[0] + ".webm"
+                if os.path.exists(webm_path):
+                    path = webm_path
+                    ext = ".webm"
+            return f'''
+            <div class="extra-src-video-box" title="{url}">
+                <video class="video-player" controls>
+                    <source src="{path}" type="video/{ext[1:]}">
+                </video>
+                <p><a href="{url}" class="title">{elide_filename(basename)}</a></p>
+            </div>
+            '''
+        return f'<div class="extra-src-img-box" title="{url}"><div class="img-outer"><div class="img-wrapper"><a href="{url}"><img src="{path}" class="image"></a></div><a href="{url}" class="title">{elide_filename(basename)}</a></div></div><br/>'
 
     def get_url_html(
             self,

pygpt_net/core/text/utils.py

@@ -9,7 +9,6 @@
 # Updated Date: 2025.08.15 23:00:00                  #
 # ================================================== #
 
-
 def output_html2text(html: str) -> str:
     """
     Convert output HTML to plain text
@@ -76,4 +75,57 @@ def has_unclosed_code_tag(text: str) -> bool:
     """
     if not text:
         return False
-    return (text.count('```') % 2) != 0
+    return (text.count('```') % 2) != 0
+
+def elide_filename(name_or_path: str, max_len: int = 45, ellipsis: str = "...", keep_dir: bool = False) -> str:
+    """
+    Elide a long filename by replacing the middle with an ellipsis, preserving the extension.
+
+    Args:
+        name_or_path: Filename or full path.
+        max_len: Maximum length of the resulting string (including extension and ellipsis).
+        ellipsis: Ellipsis text to insert (e.g., "...").
+        keep_dir: If True and a path is provided, keep the directory prefix and elide only the basename.
+                  If False, operate on the basename only.
+
+    Returns:
+        Elided filename (or path if keep_dir=True).
+    """
+    import os
+
+    if max_len <= 0:
+        return name_or_path
+
+    dirpart, base = os.path.split(name_or_path) if keep_dir else ("", os.path.basename(name_or_path))
+    stem, ext = os.path.splitext(base)
+
+    # if already short enough
+    if len(base) <= max_len:
+        return os.path.join(dirpart, base) if keep_dir else base
+
+    # minimal sanity for very small max_len
+    min_needed = len(ext) + len(ellipsis) + 2  # at least 1 char head + 1 char tail
+    if max_len < min_needed:
+        # degrade gracefully: keep first char, ellipsis, last char, and as much ext as fits
+        head = stem[:1] if stem else ""
+        tail = stem[-1:] if len(stem) > 1 else ""
+        # if ext is too long, trim it (rare edge case)
+        ext_trim = ext[: max(0, max_len - len(head) - len(ellipsis) - len(tail))]
+        out = f"{head}{ellipsis}{tail}{ext_trim}"
+        return os.path.join(dirpart, out) if keep_dir else out
+
+    # compute available budget for visible stem parts
+    avail = max_len - len(ext) - len(ellipsis)
+    # split budget between head and tail (favor head slightly)
+    head_len = (avail + 1) // 2
+    tail_len = avail - head_len
+
+    # guardrails
+    head_len = max(1, head_len)
+    tail_len = max(1, tail_len)
+
+    # build elided name
+    head = stem[:head_len]
+    tail = stem[-tail_len:] if tail_len <= len(stem) else stem
+    out = f"{head}{ellipsis}{tail}{ext}"
+    return os.path.join(dirpart, out) if keep_dir else out

pygpt_net/core/types/image.py

@@ -6,9 +6,15 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.07.13 01:00:00                  #
+# Updated Date: 2025.09.01 23:00:00                  #
 # ================================================== #
 
+VIDEO_AVAILABLE_ASPECT_RATIOS = {
+    "16:9": "16:9",
+    "9:16": "9:16",
+}
+
+
 IMAGE_AVAILABLE_RESOLUTIONS = {
     "gpt-image": {
         "auto": "auto",

pygpt_net/core/video/__init__.py

@@ -0,0 +1,12 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# ================================================== #
+# This file is a part of PYGPT package               #
+# Website: https://pygpt.net                         #
+# GitHub:  https://github.com/szczyglis-dev/py-gpt   #
+# MIT License                                        #
+# Created By  : Marcin Szczygliński                  #
+# Updated Date: 2025.09.01 23:00:00                  #
+# ================================================== #
+
+from .video import Video

pygpt_net/core/video/video.py

@@ -0,0 +1,290 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# ================================================== #
+# This file is a part of PYGPT package               #
+# Website: https://pygpt.net                         #
+# GitHub:  https://github.com/szczyglis-dev/py-gpt   #
+# MIT License                                        #
+# Created By  : Marcin Szczygliński                  #
+# Updated Date: 2025.09.01 23:00:00                  #
+# ================================================== #
+
+import uuid
+import os
+import shutil
+import subprocess
+from typing import Optional, List, Dict
+from time import strftime
+
+from PySide6.QtCore import Slot, QObject
+
+from pygpt_net.core.types import VIDEO_AVAILABLE_ASPECT_RATIOS
+from pygpt_net.item.ctx import CtxItem
+from pygpt_net.utils import trans
+
+
+class Video(QObject):
+    def __init__(self, window=None):
+        """
+        Video generation core
+
+        :param window: Window instance
+        """
+        super().__init__()
+        self.window = window
+
+    def install(self):
+        """Install provider data, img dir, etc."""
+        img_dir = os.path.join(self.window.core.config.get_user_dir("video"))
+        if not os.path.exists(img_dir):
+            os.makedirs(img_dir, exist_ok=True)
+
+    @Slot(object, list, str)
+    def handle_finished(
+            self,
+            ctx: CtxItem,
+            paths: List[str],
+            prompt: str
+    ):
+        """
+        Handle finished image generation
+
+        :param ctx: CtxItem
+        :param paths: images paths list
+        :param prompt: prompt used for generate images
+        """
+        self.window.controller.chat.image.handle_response(ctx, paths, prompt)
+
+    @Slot(object, list, str)
+    def handle_finished_inline(
+            self,
+            ctx: CtxItem,
+            paths: List[str],
+            prompt: str
+    ):
+        """
+        Handle finished image generation
+
+        :param ctx: CtxItem
+        :param paths: images paths list
+        :param prompt: prompt used for generate images
+        """
+        self.window.controller.chat.image.handle_response_inline(
+            ctx,
+            paths,
+            prompt,
+        )
+
+    @Slot(object)
+    def handle_status(self, msg: str):
+        """
+        Handle thread status message
+
+        :param msg: status message
+        """
+        self.window.update_status(msg)
+
+        is_log = False
+        if self.window.core.config.has("log.dalle") \
+                and self.window.core.config.get("log.dalle"):
+            is_log = True
+        self.window.core.debug.info(msg, not is_log)
+        if is_log:
+            print(msg)
+
+    @Slot(object)
+    def handle_error(self, msg: any):
+        """
+        Handle thread error message
+
+        :param msg: error message
+        """
+        self.window.update_status(msg)
+        self.window.core.debug.log(msg)
+        self.window.ui.dialogs.alert(msg)
+
+    def save_video(self, path: str, video: bytes) -> bool:
+        """
+        Save video to file
+
+        :param path: path to save
+        :param video: image data
+        :return: True if success
+        """
+        try:
+            with open(path, 'wb') as file:
+                file.write(video)
+            try:
+                # try to make web compatible
+                self.make_web_compatible(path)
+            except Exception as e:
+                pass
+            return True
+        except Exception as e:
+            print(trans('img.status.save.error') + ": " + str(e))
+            return False
+
+    def make_web_compatible(
+            self,
+            src_path: str,
+            fps: int = 30,
+            crf_h264: int = 22,
+            crf_vp9: int = 30,
+            audio_bitrate: str = "128k",
+            make_mp4: bool = True,
+            make_webm: bool = True,
+            overwrite: bool = True,
+    ) -> Dict[str, Optional[str]]:
+        """
+        Create browser-friendly video variants (MP4 H.264/AAC yuv420p + WebM VP9/Opus yuv420p).
+
+        Returns:
+            dict: {"mp4": "/abs/path/file.web.mp4" or None, "webm": "/abs/path/file.webm" or None}
+
+        Notes:
+        - Requires ffmpeg in PATH.
+        - Ensures even dimensions, yuv420p, faststart for MP4, and Opus for WebM.
+        - Uses CRF for quality: lower = better (and larger). Tweak crf_h264 / crf_vp9 if needed.
+        """
+        if not os.path.isfile(src_path):
+            raise FileNotFoundError(f"Source file not found: {src_path}")
+
+        # Ensure ffmpeg is available
+        ffmpeg = shutil.which("ffmpeg")
+        if not ffmpeg:
+            raise RuntimeError("ffmpeg not found in PATH. Please install ffmpeg.")
+
+        root, _ = os.path.splitext(os.path.abspath(src_path))
+        out_mp4 = f"{root}.web.mp4"
+        out_webm = f"{root}.webm"
+
+        # Remove outputs if overwrite is requested
+        if overwrite:
+            for p in (out_mp4, out_webm):
+                try:
+                    if os.path.exists(p):
+                        os.remove(p)
+                except Exception:
+                    pass
+
+        # Common video filter:
+        # - scale to even dimensions (required by many encoders)
+        # - format to yuv420p (8-bit), also set SAR=1
+        vf = "scale=trunc(iw/2)*2:trunc(ih/2)*2:flags=lanczos,format=yuv420p,setsar=1"
+
+        results = {"mp4": None, "webm": None}
+
+        def run_cmd(cmd, dst):
+            # Run ffmpeg and return dst on success, None on failure
+            try:
+                subprocess.run(cmd, check=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
+                return dst if os.path.exists(dst) else None
+            except subprocess.CalledProcessError as e:
+                # If needed, print(e.stdout.decode(errors="ignore"))
+                return None
+
+        if make_mp4:
+            # H.264 High@4.1, yuv420p, AAC; add faststart for web playback
+            mp4_cmd = [
+                ffmpeg, "-y",
+                "-i", src_path,
+                "-map", "0:v:0", "-map", "0:a:0?",  # include audio if present
+                "-vf", vf,
+                "-r", str(fps),
+                "-c:v", "libx264",
+                "-pix_fmt", "yuv420p",
+                "-profile:v", "high", "-level", "4.1",
+                "-preset", "medium",
+                "-crf", str(crf_h264),
+                "-color_primaries", "bt709", "-colorspace", "bt709", "-color_trc", "bt709",
+                "-movflags", "+faststart",
+                "-c:a", "aac", "-b:a", audio_bitrate, "-ac", "2", "-ar", "48000",
+                "-sn",
+                out_mp4,
+            ]
+            results["mp4"] = run_cmd(mp4_cmd, out_mp4)
+
+        if make_webm:
+            # VP9 (CRF, constant quality), Opus audio
+            webm_cmd = [
+                ffmpeg, "-y",
+                "-i", src_path,
+                "-map", "0:v:0", "-map", "0:a:0?",
+                "-vf", vf,
+                "-r", str(fps),
+                "-c:v", "libvpx-vp9",
+                "-b:v", "0",  # use CRF mode
+                "-crf", str(crf_vp9),
+                "-row-mt", "1",
+                "-pix_fmt", "yuv420p",
+                "-deadline", "good",  # "good" for quality; "realtime" for speed
+                "-cpu-used", "2",  # lower = slower/better; tweak for performance
+                "-c:a", "libopus", "-b:a", audio_bitrate, "-ac", "2", "-ar", "48000",
+                "-sn",
+                out_webm,
+            ]
+            results["webm"] = run_cmd(webm_cmd, out_webm)
+
+        return results
+
+    def make_safe_filename(self, name: str) -> str:
+        """
+        Make safe filename
+
+        :param name: filename to make safe
+        :return: safe filename
+        """
+        def safe_char(c):
+            if c.isalnum():
+                return c
+            else:
+                return "_"
+        return "".join(safe_char(c) for c in name).rstrip("_")[:30]
+
+    def gen_unique_path(self, ctx: CtxItem):
+        """
+        Generate unique image path based on context
+
+        :param ctx: CtxItem
+        :return: unique image path
+        """
+        img_id = uuid.uuid4()
+        dt_prefix = strftime("%Y%m%d_%H%M%S")
+        img_dir = self.window.core.config.get_user_dir("img")
+        filename = f"{dt_prefix}_{img_id}.png"
+        return os.path.join(img_dir, filename)
+
+    def _normalize_model_name(self, model: str) -> str:
+        """
+        Normalize model id (strip optional 'models/' prefix).
+
+        :param model: model id
+        """
+        try:
+            return model.split("/")[-1]
+        except Exception:
+            return model
+
+    def get_aspect_ratio_option(self) -> dict:
+        """
+        Get image resolution option for UI
+
+        :return: dict
+        """
+        return {
+            "type": "combo",
+            "slider": True,
+            "label": "video.aspect_ratio",
+            "value": "16:9",
+            "keys": self.get_available_aspect_ratio(),
+        }
+
+    def get_available_aspect_ratio(self, model: str = None) -> Dict[str, str]:
+        """
+        Get available image resolutions
+
+        :param model: model name
+        :return: dict of available resolutions
+        """
+        return VIDEO_AVAILABLE_ASPECT_RATIOS
+