subtle-gui 26.1.0__py3-none-any.whl

subtle/__init__.py

@@ -0,0 +1,184 @@
+"""
+Subtle – Init File
+==================
+
+This file is a part of Subtle
+Copyright (C) Veronica Berglyd Olsen
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program. If not, see <https://www.gnu.org/licenses/>.
+"""
+from __future__ import annotations
+
+import getopt
+import logging
+import os
+import sys
+
+from typing import TYPE_CHECKING
+
+from subtle.config import Config
+from subtle.shared import SharedData
+
+from PyQt6.QtWidgets import QApplication
+
+if TYPE_CHECKING:  # pragma: no cover
+    from subtle.guimain import GuiMain
+
+# Package Meta
+# ============
+
+__package__    = "subtle-gui"
+__copyright__  = "Copyright (C) Veronica Berglyd Olsen"
+__license__    = "GPLv3"
+__author__     = "Veronica Berglyd Olsen"
+__maintainer__ = "Veronica Berglyd Olsen"
+__email__      = "code@vkbo.net"
+__version__    = "26.1.0"
+__date__       = "2026-06-24"
+
+logger = logging.getLogger(__name__)
+
+
+##
+#  Main Program
+##
+
+CONFIG = Config()
+SHARED = SharedData()
+
+# ANSI Colours
+RED    = "\033[91m"
+GREEN  = "\033[92m"
+YELLOW = "\033[93m"
+BLUE   = "\033[94m"
+WHITE  = "\033[97m"
+END    = "\033[0m"
+
+# Log Format Components
+TIME = "[{asctime:}]"
+FILE = "{filename:>18}"
+LINE = "{lineno:<4d}"
+LVLP = "{levelname:8}"
+LVLC = "{levelname:17}"
+TEXT = "{message:}"
+
+# Read Environment
+FORCE_COLOR = bool(os.environ.get("FORCE_COLOR"))
+NO_COLOR    = bool(os.environ.get("NO_COLOR"))
+
+
+def main(sysArgs: list | None = None) -> GuiMain | None:
+    """Parse command line, set up logging, and launch main GUI."""
+    if sysArgs is None:
+        sysArgs = sys.argv[1:]
+
+    # Valid Input Options
+    shortOpt = "hvicd"
+    longOpt = [
+        "help",
+        "version",
+        "info",
+        "debug",
+        "color",
+    ]
+
+    helpMsg = (
+        f"Subtle {__version__} ({__date__})\n"
+        f"{__copyright__}\n"
+        "\n"
+        "This program is distributed in the hope that it will be useful,\n"
+        "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
+        "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
+        "GNU General Public Licence for more details.\n"
+        "\n"
+        "Usage:\n"
+        " -h, --help     Print this message.\n"
+        " -v, --version  Print program version and exit.\n"
+        " -i, --info     Print additional runtime information.\n"
+        " -d, --debug    Print debug output. Includes --info.\n"
+        " -c, --color    Add ANSI colors to log output.\n"
+    )
+
+    # Defaults
+    logLevel = logging.WARN
+    fmtColor = FORCE_COLOR
+    fmtLong  = False
+
+    # Parse Options
+    try:
+        inOpts, _ = getopt.getopt(sysArgs, shortOpt, longOpt)
+    except getopt.GetoptError as exc:
+        print(helpMsg)
+        print(f"ERROR: {exc!s}")
+        sys.exit(2)
+
+    for inOpt, _ in inOpts:
+        if inOpt in ("-h", "--help"):
+            print(helpMsg)
+            sys.exit(0)
+        elif inOpt in ("-v", "--version"):
+            print(f"Subtle Version {__version__} [{__date__}]")
+            sys.exit(0)
+        elif inOpt in ("-i", "--info"):
+            logLevel = logging.INFO
+        elif inOpt in ("-d", "--debug"):
+            fmtLong = True
+            logLevel = logging.DEBUG
+        elif inOpt in ("-c", "--color"):
+            fmtColor = not NO_COLOR
+
+    if fmtColor:
+        # This will overwrite the default level names, and also ensure that
+        # they can be converted back to integer levels
+        logging.addLevelName(logging.DEBUG,    f"{BLUE}DEBUG{END}")
+        logging.addLevelName(logging.INFO,     f"{GREEN}INFO{END}")
+        logging.addLevelName(logging.WARNING,  f"{YELLOW}WARNING{END}")
+        logging.addLevelName(logging.ERROR,    f"{RED}ERROR{END}")
+        logging.addLevelName(logging.CRITICAL, f"{RED}CRITICAL{END}")
+
+    logTxt = f"{LVLC}  {TEXT}" if fmtColor else f"{LVLP}  {TEXT}"
+    logPos = f"{BLUE}{FILE}{END}:{WHITE}{LINE}{END}" if fmtColor else f"{FILE}:{LINE}"
+    logFmt = f"{TIME}  {logPos}  {logTxt}" if fmtLong else logTxt
+
+    # Setup Logging
+    pkgLogger = logging.getLogger(__package__)
+    pkgLogger.setLevel(logLevel)
+    if len(pkgLogger.handlers) == 0:
+        # Make sure we only create one logger (mostly an issue with tests)
+        cHandle = logging.StreamHandler()
+        cHandle.setFormatter(logging.Formatter(fmt=logFmt, style="{"))
+        pkgLogger.addHandler(cHandle)
+
+    logger.info("Starting Subtle %s (%s)", __version__, __date__)
+
+    # Finish initialising config
+    CONFIG.initialise()
+
+    from subtle.guimain import GuiMain
+
+    app = QApplication([CONFIG.appName])
+    app.setApplicationName(CONFIG.appName)
+    app.setApplicationVersion(__version__)
+    app.setDesktopFileName(CONFIG.appName)
+
+    # Run Config steps that require the QApplication
+    CONFIG.load()
+    CONFIG.fonts(app)
+    CONFIG.localisation(app)
+
+    # Launch main GUI
+    gui = GuiMain()
+    gui.show()
+
+    sys.exit(app.exec())

subtle/common.py

@@ -0,0 +1,178 @@
+"""
+Subtle – Common Functions
+=========================
+
+This file is a part of Subtle
+Copyright (C) Veronica Berglyd Olsen
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program. If not, see <https://www.gnu.org/licenses/>.
+"""
+from __future__ import annotations
+
+import json
+import logging
+
+from typing import TYPE_CHECKING, Any, Literal
+
+if TYPE_CHECKING:
+    import re
+
+logger = logging.getLogger(__name__)
+
+T_Subs = Literal["SRT"] | Literal["SSA"]
+
+
+def simplified(text: str) -> str:
+    """Take a string and strip leading and trailing whitespaces, and
+    replace all occurrences of (multiple) whitespaces with a 0x20 space.
+    """
+    return " ".join(str(text).strip().split())
+
+
+def checkInt(value: Any, default: int) -> int:
+    """Check if a variable is an integer."""
+    try:
+        return int(value)
+    except Exception:
+        return default
+
+
+def formatInt(value: int) -> str:
+    """Formats an integer with k, M, G etc."""
+    if not isinstance(value, int):
+        return "ERR"
+
+    fVal = float(value)
+    if fVal > 1000.0:
+        for pF in ["k", "M", "G", "T", "P", "E"]:
+            fVal /= 1000.0
+            if fVal < 1000.0:
+                if fVal < 10.0:
+                    return f"{fVal:4.2f}\u202f{pF}"
+                elif fVal < 100.0:
+                    return f"{fVal:4.1f}\u202f{pF}"
+                else:
+                    return f"{fVal:3.0f}\u202f{pF}"
+
+    return str(value) + "\u202f"
+
+
+def textCleanup(text: str) -> str:
+    """Do some common cleanup on text strings."""
+    return text.replace("--", "\u2014").replace("....", "...")
+
+
+def regexCleanup(text: str, patterns: list[tuple[re.Pattern, str]]) -> str:
+    """Replaces all occurrences of match group 1 in patterns."""
+    for regEx, value in patterns:
+        matches = [
+            (s, e, value) for match in regEx.finditer(text)
+            if (s := match.start(1)) >= 0 and (e := match.end(1)) >= 0
+        ]
+        for s, e, value in reversed(matches):
+            text = text[:s] + value + text[e:]
+    return text
+
+
+def closeItalics(text: list[str]) -> list[str]:
+    """Make sure italics doesn't span multiple lines."""
+    italics = False
+    result = []
+    for line in text:
+        if italics:
+            line = f"<i>{line}"
+        if line.count("<i>") - line.count("</i>") > 0:
+            italics = True
+            line = f"{line}</i>"
+        result.append(line)
+    return result
+
+
+def jsonEncode(data: dict | list | tuple, n: int = 0, nmax: int = 0) -> str:
+    """Encode a dictionary, list or tuple as a json object or array, and
+    indent from level n up to a max level nmax if nmax is larger than 0.
+    """
+    if not isinstance(data, (dict, list, tuple)):
+        return "[]"
+
+    buffer = []
+    indent = ""
+
+    for chunk in json.JSONEncoder().iterencode(data):
+        if chunk == "":  # pragma: no cover
+            # Just a precaution
+            continue
+
+        first = chunk[0]
+        if chunk in ("{}", "[]"):
+            buffer.append(chunk)
+
+        elif first in ("{", "["):
+            n += 1
+            indent = "\n"+"  "*n
+            if n > nmax and nmax > 0:
+                buffer.append(chunk)
+            else:
+                buffer.append(chunk[0] + indent + chunk[1:])
+
+        elif first in ("}", "]"):
+            n -= 1
+            indent = "\n"+"  "*n
+            if n >= nmax and nmax > 0:
+                buffer.append(chunk)
+            else:
+                buffer.append(indent + chunk)
+
+        elif first == ",":
+            if n > nmax and nmax > 0:
+                buffer.append(chunk)
+            else:
+                buffer.append(chunk[0] + indent + chunk[1:].lstrip())
+
+        else:
+            buffer.append(chunk)
+
+    return "".join(buffer)
+
+
+def formatTS(value: int) -> str:
+    """Format millisecond integer as HH:MM:SS,uuu timestamp."""
+    i, f = value//1000, value%1000
+    return f"{i//3600:02d}:{i%3600//60:02d}:{i%60:02d},{f:03d}"
+
+
+def decodeTS(value: str | None, default: int = 0, fmt: T_Subs = "SRT") -> int:
+    """Decode a SRT time stamp to milliseconds."""
+    if isinstance(value, str):
+        if fmt == "SRT" and len(value) >= 12:
+            if value[2] == ":" and value[5] == ":" and value[8] in ".,":
+                try:
+                    return (
+                        3600000*int(value[0:2])
+                        + 60000*int(value[3:5])
+                        + int(value[6:8] + value[9:12])
+                    )
+                except Exception:
+                    pass
+        elif fmt == "SSA" and len(value) == 10:
+            if value[1] == ":" and value[4] == ":" and value[7] in ":.,":
+                try:
+                    return (
+                        3600000*int(value[0])
+                        + 60000*int(value[2:4])
+                        + 10*int(value[5:7] + value[8:10])
+                    )
+                except Exception:
+                    pass
+    return default

subtle/config.py

@@ -0,0 +1,291 @@
+"""
+Subtle – Main Config
+====================
+
+This file is a part of Subtle
+Copyright (C) Veronica Berglyd Olsen
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program. If not, see <https://www.gnu.org/licenses/>.
+"""
+from __future__ import annotations
+
+import json
+import logging
+import shutil
+import sys
+
+from copy import deepcopy
+from pathlib import Path
+from typing import Literal
+
+from subtle.common import jsonEncode
+
+from PyQt6.QtCore import (
+    PYQT_VERSION, PYQT_VERSION_STR, QT_VERSION, QT_VERSION_STR, QSize,
+    QStandardPaths, QSysInfo
+)
+from PyQt6.QtGui import QFont
+from PyQt6.QtWidgets import QApplication
+
+logger = logging.getLogger(__name__)
+
+
+DEFAULTS: dict = {
+    "Sizes": {
+        "mainWindow": [900, 600],
+        "mainSplit": [300, 300, 300],
+        "contentSplit": [300, 300],
+        "viewSplit": [200, 200, 200],
+        "fileTreeColumns": [],
+        "mediaViewColumns": [],
+        "subsViewColumns": [],
+    },
+    "Settings": {
+        "tessData": "",
+    },
+    "Fonts": {
+        "guiFont": "",
+        "fixedFont": "",
+        "subsFont": "",
+    }
+}
+
+T_Fonts = Literal["gui"] | Literal["fixed"] | Literal["subs"]
+
+
+class Config:
+
+    def __init__(self) -> None:
+
+        self._data: dict[str, dict] = deepcopy(DEFAULTS)
+
+        self.appName   = "Subtle"
+        self.appHandle = "subtle"
+
+        # Set Paths
+        confRoot = Path(QStandardPaths.writableLocation(
+            QStandardPaths.StandardLocation.ConfigLocation)
+        )
+        cacheRoot = Path(QStandardPaths.writableLocation(
+            QStandardPaths.StandardLocation.CacheLocation)
+        )
+        self._confPath = confRoot.absolute() / self.appHandle  # The user config location
+        self._cachePath = cacheRoot.absolute() / self.appHandle  # The user cache location
+        self._homePath = Path.home().absolute()  # The user's home directory
+
+        self._appPath = Path(__file__).parent.absolute()
+        self._appRoot = self._appPath.parent
+
+        self._confFile = self._confPath / "subtle.json"
+
+        # Fonts
+        self.guiFont = QFont()
+        self.fixedFont = QFont()
+        self.subsFont = QFont()
+
+        # Check Qt6 Versions
+        self.verQtString   = QT_VERSION_STR
+        self.verQtValue    = QT_VERSION
+        self.verPyQtString = PYQT_VERSION_STR
+        self.verPyQtValue  = PYQT_VERSION
+
+        # Check Python Version
+        self.verPyString = sys.version.split()[0]
+
+        # Check OS Type
+        self.osType    = sys.platform
+        self.osLinux   = False
+        self.osWindows = False
+        self.osDarwin  = False
+        self.osUnknown = False
+        if self.osType.startswith("linux"):
+            self.osLinux = True
+        elif self.osType.startswith("darwin"):
+            self.osDarwin = True
+        elif self.osType.startswith(("win32", "cygwin")):
+            self.osWindows = True
+        else:
+            self.osUnknown = True
+
+        # Other System Info
+        self.hostName  = QSysInfo.machineHostName()
+        self.kernelVer = QSysInfo.kernelVersion()
+
+        return
+
+    ##
+    #  Properties
+    ##
+
+    @property
+    def confPath(self) -> Path:
+        """Return the location for config files."""
+        self._confPath.mkdir(exist_ok=True)
+        return self._confPath
+
+    @property
+    def dumpPath(self) -> Path:
+        """Return a location for dumping files during a session."""
+        path = self._cachePath / "dump"
+        path.mkdir(exist_ok=True)
+        return path
+
+    ##
+    #  Getters
+    ##
+
+    def getSize(self, key: str) -> QSize:
+        """Get a size from config."""
+        try:
+            size = QSize(*self._data["Sizes"][key])
+        except Exception:
+            size = QSize()
+        return size
+
+    def getSizes(self, key: str) -> list[int]:
+        """Get a list of sizes from config."""
+        try:
+            size = list(self._data["Sizes"][key])
+        except Exception:
+            size = []
+        return size
+
+    def getSetting(self, key: str) -> str:
+        """Get a generic string setting."""
+        return str(self._data["Settings"].get(key, ""))
+
+    def assetPath(self, resource: str, kind: str | None = None) -> Path:
+        """Return the path to an asset."""
+        path = self._appPath / "assets"
+        if kind:
+            path /= kind
+        return path / resource
+
+
+    ##
+    #  Setters
+    ##
+
+    def setSize(self, key: str, value: QSize) -> None:
+        """Set a size in config."""
+        if isinstance(value, QSize):
+            self._data["Sizes"][key] = [value.width(), value.height()]
+        return
+
+    def setSizes(self, key: str, value: list[int]) -> None:
+        """Set a size in config."""
+        if isinstance(value, list):
+            try:
+                self._data["Sizes"][key] = [int(x) for x in value]
+            except Exception as e:
+                logger.error("Problem when saving sizes list", exc_info=e)
+        return
+
+    def setFontSpec(self, target: T_Fonts, font: QFont | str) -> None:
+        """Set the font """
+        if isinstance(font, str):
+            temp = QFont()
+            temp.fromString(font)
+            font = temp
+
+        if target == "gui":
+            self.guiFont = font
+            self._data["Fonts"]["guiFont"] = font.toString()
+            QApplication.setFont(self.guiFont)
+        elif target == "fixed":
+            self.fixedFont = font
+            self._data["Fonts"]["fixedFont"] = font.toString()
+        elif target == "subs":
+            self.subsFont = font
+            self._data["Fonts"]["subsFont"] = font.toString()
+
+        return
+
+    ##
+    #  Methods
+    ##
+
+    def initialise(self) -> None:
+        """Initialise the config."""
+        self._confPath.mkdir(exist_ok=True)
+        self._cachePath.mkdir(exist_ok=True)
+        return
+
+    def cleanup(self) -> None:
+        """Called before exit to clean up cache."""
+        path = self._cachePath / "dump"
+        if path.exists():
+            logger.debug("Clearing session cache")
+            shutil.rmtree(path)
+        return
+
+    def localisation(self, app: QApplication) -> None:
+        return
+
+    def fonts(self, app: QApplication) -> None:
+        """Set up fonts."""
+        if font := self._data["Fonts"].get("guiFont"):
+            self.setFontSpec("gui", font)
+        else:
+            self.setFontSpec("gui", app.font())
+
+        if font := self._data["Fonts"].get("fixedFont"):
+            self.setFontSpec("fixed", font)
+        else:
+            self.setFontSpec("fixed", QFont("monospace", app.font().pointSize()))
+
+        if font := self._data["Fonts"].get("subsFont"):
+            self.setFontSpec("subs", font)
+        else:
+            temp = app.font()
+            temp.setPointSizeF(3.0*temp.pointSizeF())
+            self.setFontSpec("subs", temp)
+        return
+
+    def load(self) -> None:
+        """Load the app config."""
+        if self._confFile.is_file():
+            try:
+                logger.debug("Loading config")
+                with open(self._confFile, mode="r", encoding="utf-8") as fo:
+                    data = json.load(fo)
+                self._storeConfigGroup(data, "Sizes")
+                self._storeConfigGroup(data, "Settings")
+                self._storeConfigGroup(data, "Fonts")
+            except Exception as e:
+                logger.error("Could not load config", exc_info=e)
+        return
+
+    def save(self) -> None:
+        """Save the app config."""
+        try:
+            logger.debug("Saving config")
+            with open(self._confFile, mode="w+", encoding="utf-8") as fo:
+                fo.write(jsonEncode(self._data, nmax=2))
+        except Exception:
+            logger.error("Could not save config")
+        return
+
+    ##
+    #  Internal Functions
+    ##
+
+    def _storeConfigGroup(self, data: dict, group: str) -> None:
+        """Process a group from config and save the data."""
+        if isinstance(data, dict) and group in self._data:
+            loaded = data.get(group, {})
+            default = DEFAULTS.get(group, {})
+            values = {k: v for k, v in loaded.items() if k in default}
+            self._data[group].update(values)
+        return

subtle/constants.py

@@ -0,0 +1,49 @@
+"""
+Subtle – Constants
+==================
+
+This file is a part of Subtle
+Copyright (C) Veronica Berglyd Olsen
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program. If not, see <https://www.gnu.org/licenses/>.
+"""
+from __future__ import annotations
+
+from enum import Enum
+from typing import Final
+
+from PyQt6.QtCore import QT_TRANSLATE_NOOP, QCoreApplication
+
+
+def trConst(text: str) -> str:
+    """Wrapper function for locally translating constants."""
+    return QCoreApplication.translate("Constant", text)
+
+
+class MediaType(Enum):
+
+    VIDEO = 0
+    AUDIO = 1
+    SUBS  = 2
+    OTHER = 4
+
+
+class GuiLabels:
+
+    MEDIA_TYPES: Final[dict[MediaType, str]] = {
+        MediaType.VIDEO: QT_TRANSLATE_NOOP("Constant", "Video"),
+        MediaType.AUDIO: QT_TRANSLATE_NOOP("Constant", "Audio"),
+        MediaType.SUBS:  QT_TRANSLATE_NOOP("Constant", "Subtitles"),
+        MediaType.OTHER: QT_TRANSLATE_NOOP("Constant", "Other"),
+    }