winipedia-utils 0.1.15__tar.gz → 0.1.17__tar.gz

{winipedia_utils-0.1.15 → winipedia_utils-0.1.17}/PKG-INFO

@@ -1,18 +1,22 @@
 Metadata-Version: 2.3
 Name: winipedia-utils
-Version: 0.1.15
+Version: 0.1.17
 Summary: A package with many utility functions
 License: MIT
 Author: Winipedia
 Author-email: win.steveker@gmx.de
-Requires-Python: >=3.12
+Requires-Python: >=3.12,<3.14
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: cryptography (>=45.0.5,<46.0.0)
 Requires-Dist: defusedxml (>=0.7.1,<0.8.0)
 Requires-Dist: django (>=5.2.1,<6.0.0)
+Requires-Dist: keyring (>=25.6.0,<26.0.0)
 Requires-Dist: pathspec (>=0.12.1,<0.13.0)
+Requires-Dist: pyqt-toast-notification (>=1.3.3,<2.0.0)
+Requires-Dist: pyside6 (>=6.9.1,<7.0.0)
 Requires-Dist: pyyaml (>=6.0.2,<7.0.0)
 Requires-Dist: setuptools (>=80.3.1,<81.0.0)
 Requires-Dist: tomlkit (>=0.13.2,<0.14.0)

{winipedia_utils-0.1.15 → winipedia_utils-0.1.17}/pyproject.toml

@@ -1,10 +1,10 @@
 # Project section
 [project]
 name = "winipedia-utils"
-version = "0.1.15"
+version = "0.1.17"
 description = "A package with many utility functions"
 readme = "README.md"
-requires-python = ">=3.12"
+requires-python = ">=3.12,<3.14"
 dynamic = [ "dependencies",]
 authors = [
     { name = "Winipedia", email = "win.steveker@gmx.de"}
@@ -28,6 +28,10 @@ tomlkit = "^0.13.2"
 pathspec = "^0.12.1"
 django = "^5.2.1"
 pyyaml = "^6.0.2"
+keyring = "^25.6.0"
+cryptography = "^45.0.5"
+pyside6 = "^6.9.1"
+pyqt-toast-notification = "^1.3.3"
 
 [tool.poetry.group.dev.dependencies]
 ruff = "^0.11.7"
@@ -43,7 +47,7 @@ pytest-mock = "^3.14.0"
 django-stubs = "^5.2.0"
 
 [tool.ruff]
-exclude = [ ".*",]
+exclude = [ ".*", "**/migrations/*.py",]
 [tool.ruff.lint]
 select = [ "ALL",]
 ignore = [ "D203", "D213", "COM812", "ANN401",]

{winipedia_utils-0.1.15 → winipedia_utils-0.1.17}/winipedia_utils/modules/module.py

@@ -11,6 +11,7 @@ making them suitable for code generation, testing frameworks, and dynamic import
 
 import inspect
 import os
+import sys
 import time
 from collections.abc import Callable, Sequence
 from importlib import import_module
@@ -115,6 +116,9 @@ def to_path(module_name: str | ModuleType | Path, *, is_package: bool) -> Path:
     """
     module_name = to_module_name(module_name)
     path = Path(module_name.replace(".", os.sep))
+    # for smth like pyinstaller we support frozen path
+    if getattr(sys, "frozen", False):
+        path = Path(getattr(sys, "_MEIPASS", "")) / path
     if is_package:
         return path
     return path.with_suffix(".py")

{winipedia_utils-0.1.15 → winipedia_utils-0.1.17}/winipedia_utils/projects/poetry/config.py

@@ -32,7 +32,7 @@ def _get_pyproject_toml_tool_configs() -> dict[str, Any]:
     """Get the tool configurations for pyproject.toml."""
     return {
         "ruff": {
-            "exclude": [".*"],
+            "exclude": [".*", "**/migrations/*.py"],
             "lint": {
                 "select": ["ALL"],
                 "ignore": ["D203", "D213", "COM812", "ANN401"],

winipedia_utils-0.1.17/winipedia_utils/pyside/__init__.py

@@ -0,0 +1 @@
+"""__init__ module for winipedia_utils.pyside6."""

winipedia_utils-0.1.17/winipedia_utils/pyside/ui/__init__.py

@@ -0,0 +1 @@
+"""__init__ module for winipedia_utils.pyside6.ui."""

winipedia_utils-0.1.17/winipedia_utils/pyside/ui/base/__init__.py

@@ -0,0 +1 @@
+"""__init__ module."""

winipedia_utils-0.1.17/winipedia_utils/pyside/ui/base/base.py

@@ -0,0 +1,117 @@
+"""Base UI module.
+
+This module contains the base UI class for the VideoVault application.
+"""
+
+from abc import abstractmethod
+from types import ModuleType
+from typing import TYPE_CHECKING, Any, Self, cast, final
+
+from PySide6.QtCore import QObject
+from PySide6.QtGui import QIcon
+from PySide6.QtWidgets import QStackedWidget
+
+from winipedia_utils.modules.package import walk_package
+from winipedia_utils.oop.mixins.meta import ABCImplementationLoggingMeta
+from winipedia_utils.resources.svgs.svg import get_svg_path
+from winipedia_utils.text.string import split_on_uppercase
+
+# Avoid circular import
+if TYPE_CHECKING:
+    from winipedia_utils.pyside.ui.pages.base.base import Base as BasePage
+
+
+class QABCImplementationLoggingMeta(
+    ABCImplementationLoggingMeta,
+    type(QObject),  # type: ignore[misc]
+):
+    """Metaclass for the QABCImplementationLoggingMixin."""
+
+
+class Base(metaclass=QABCImplementationLoggingMeta):
+    """Base UI class for a Qt application."""
+
+    @final
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        """Initialize the base UI."""
+        super().__init__(*args, **kwargs)
+        self.base_setup()
+        self.pre_setup()
+        self.setup()
+        self.post_setup()
+
+    @abstractmethod
+    def base_setup(self) -> None:
+        """Get the Qt object of the UI."""
+
+    @abstractmethod
+    def setup(self) -> None:
+        """Setup the UI."""
+
+    @abstractmethod
+    def pre_setup(self) -> None:
+        """Setup the UI."""
+
+    @abstractmethod
+    def post_setup(self) -> None:
+        """Setup the UI."""
+
+    @classmethod
+    @final
+    def get_display_name(cls) -> str:
+        """Get the display name of the UI."""
+        return " ".join(split_on_uppercase(cls.__name__))
+
+    @classmethod
+    @final
+    def get_subclasses(cls, package: ModuleType) -> list[type[Self]]:
+        """Get all subclasses of the UI.
+
+        Args:
+            package: The package to search for subclasses in.
+        """
+        _ = list(walk_package(package))
+
+        children = cls.__subclasses__()
+        return sorted(children, key=lambda cls: cls.__name__)
+
+    @final
+    def set_current_page(self, page_cls: type["BasePage"]) -> None:
+        """Set the current page."""
+        self.get_stack().setCurrentWidget(self.get_page(page_cls))
+
+    @final
+    def get_stack(self) -> QStackedWidget:
+        """Get the stack of the window."""
+        from winipedia_utils.pyside.ui.windows.base.base import Base as BaseWindow
+
+        window = getattr(self, "window", lambda: None)()
+
+        if not isinstance(window, BaseWindow):
+            msg = f"Cannot get stack on {window.__class__.__name__}"
+            raise TypeError(msg)
+
+        return window.stack
+
+    @final
+    def get_stack_pages(self) -> list["BasePage"]:
+        """Get all the pages."""
+        # Import here to avoid circular import
+
+        stack = self.get_stack()
+        # get all the pages
+        return [cast("BasePage", stack.widget(i)) for i in range(stack.count())]
+
+    @final
+    def get_page[T: "BasePage"](self, page_cls: type[T]) -> T:
+        """Get the page."""
+        page = next(
+            page for page in self.get_stack_pages() if page.__class__ is page_cls
+        )
+        return cast("T", page)
+
+    @classmethod
+    @final
+    def get_svg_icon(cls, svg_name: str) -> QIcon:
+        """Get the Qicon for a svg."""
+        return QIcon(str(get_svg_path(svg_name)))

winipedia_utils-0.1.17/winipedia_utils/pyside/ui/pages/__init__.py

@@ -0,0 +1 @@
+"""__init__ module."""

winipedia_utils-0.1.17/winipedia_utils/pyside/ui/pages/base/__init__.py

@@ -0,0 +1 @@
+"""__init__ module."""

winipedia_utils-0.1.17/winipedia_utils/pyside/ui/pages/base/base.py

@@ -0,0 +1,78 @@
+"""Base page module.
+
+This module contains the base page class for the VideoVault application.
+"""
+
+from functools import partial
+from types import ModuleType
+from typing import final
+
+from PySide6.QtCore import Qt
+from PySide6.QtWidgets import (
+    QHBoxLayout,
+    QLayout,
+    QMenu,
+    QPushButton,
+    QSizePolicy,
+    QVBoxLayout,
+    QWidget,
+)
+
+from winipedia_utils.pyside.ui.base.base import Base as BaseUI
+
+
+class Base(BaseUI, QWidget):
+    """Base page class for the VideoVault application."""
+
+    PAGES_PACKAGE: ModuleType = NotImplemented
+
+    @final
+    def base_setup(self) -> None:
+        """Get the Qt object of the UI."""
+        self.v_layout = QVBoxLayout()
+        self.setLayout(self.v_layout)
+
+        # add a horizontal layout for the top row
+        self.h_layout = QHBoxLayout()
+        self.v_layout.addLayout(self.h_layout)
+
+        self.add_menu_dropdown_button()
+
+    @final
+    def add_menu_dropdown_button(self) -> None:
+        """Add a dropdown menu that leadds to each page."""
+        self.menu_button = QPushButton("Menu")
+        self.menu_button.setSizePolicy(
+            QSizePolicy.Policy.Minimum, QSizePolicy.Policy.Minimum
+        )
+        self.h_layout.addWidget(
+            self.menu_button,
+            alignment=Qt.AlignmentFlag.AlignTop | Qt.AlignmentFlag.AlignLeft,
+        )
+        self.menu_dropdown = QMenu(self.menu_button)
+        self.menu_button.setMenu(self.menu_dropdown)
+
+        for page_cls in self.get_page_classes():
+            action = self.menu_dropdown.addAction(page_cls.get_display_name())
+            action.triggered.connect(partial(self.set_current_page, page_cls))
+
+    @final
+    def add_to_page_button(
+        self, to_page_cls: type["Base"], layout: QLayout
+    ) -> QPushButton:
+        """Add a button to go to the page."""
+        button = QPushButton(to_page_cls.get_display_name())
+
+        # connect to open page on click
+        button.clicked.connect(lambda: self.set_current_page(to_page_cls))
+
+        # add to layout
+        layout.addWidget(button)
+
+        return button
+
+    @classmethod
+    @final
+    def get_page_classes(cls) -> list[type["Base"]]:
+        """Get all the page classes."""
+        return Base.get_subclasses(cls.PAGES_PACKAGE)

winipedia_utils-0.1.17/winipedia_utils/pyside/ui/pages/browser.py

@@ -0,0 +1,24 @@
+"""Add downloads page module.
+
+This module contains the add downloads page class for the VideoVault application.
+"""
+
+from typing import final
+
+from winipedia_utils.pyside.ui.pages.base.base import Base as BasePage
+from winipedia_utils.pyside.ui.widgets.browser import Browser
+
+
+class AddDownloads(BasePage):
+    """Add downloads page for the VideoVault application."""
+
+    @final
+    def setup(self) -> None:
+        """Setup the UI."""
+        # add a download button in the top right
+        self.add_brwoser()
+
+    @final
+    def add_brwoser(self) -> None:
+        """Add a browser to surfe the web."""
+        self.browser = Browser(self.v_layout)

winipedia_utils-0.1.17/winipedia_utils/pyside/ui/pages/player.py

@@ -0,0 +1,26 @@
+"""Player page module.
+
+This module contains the player page class for the VideoVault application.
+"""
+
+from typing import final
+
+from winipedia_utils.pyside.ui.pages.base.base import Base as BasePage
+from winipedia_utils.pyside.ui.widgets.media_player import MediaPlayer
+
+
+class Player(BasePage):
+    """Player page for the VideoVault application."""
+
+    @final
+    def setup(self) -> None:
+        """Setup the UI."""
+        self.media_player = MediaPlayer(self.v_layout)
+
+    @final
+    def play_data(self, data: bytes, name: str) -> None:
+        """Play the video."""
+        # set current page to player
+        self.set_current_page(self.__class__)
+        # Stop current playback and clean up resources
+        self.media_player.play_data(data, name)

winipedia_utils-0.1.17/winipedia_utils/pyside/ui/widgets/__init__.py

@@ -0,0 +1 @@
+"""__init__ module."""

winipedia_utils-0.1.17/winipedia_utils/pyside/ui/widgets/browser.py

@@ -0,0 +1,166 @@
+"""Browser module.
+
+This module contains the browser class for the application.
+"""
+
+from collections import defaultdict
+from http.cookiejar import Cookie
+from typing import Any
+
+from PySide6.QtCore import QUrl
+from PySide6.QtGui import QIcon
+from PySide6.QtNetwork import QNetworkCookie
+from PySide6.QtWebEngineWidgets import QWebEngineView
+from PySide6.QtWidgets import (
+    QHBoxLayout,
+    QLayout,
+    QLineEdit,
+    QPushButton,
+    QSizePolicy,
+    QVBoxLayout,
+    QWidget,
+)
+
+
+class Browser(QWebEngineView):
+    """Browser class that creates a simple ready to use browser and not just a view."""
+
+    def __init__(self, parent_layout: QLayout, *args: Any, **kwargs: Any) -> None:
+        """Initialize the browser."""
+        super().__init__(*args, **kwargs)
+        self.parent_layout = parent_layout
+        self.make_widget()
+        self.connect_signals()
+        self.load_first_url()
+
+    def make_address_bar(self) -> None:
+        """Make the address bar."""
+        self.address_bar_layout = QHBoxLayout()
+
+        # Add back button
+        self.back_button = QPushButton()
+        self.back_button.setIcon(QIcon.fromTheme("go-previous"))
+        self.back_button.setToolTip("Go back")
+        self.back_button.clicked.connect(self.back)
+        self.address_bar_layout.addWidget(self.back_button)
+
+        # Add forward button
+        self.forward_button = QPushButton()
+        self.forward_button.setIcon(QIcon.fromTheme("go-next"))
+        self.forward_button.setToolTip("Go forward")
+        self.forward_button.clicked.connect(self.forward)
+        self.address_bar_layout.addWidget(self.forward_button)
+
+        # Add address bar
+        self.address_bar = QLineEdit()
+        self.address_bar.setPlaceholderText("Enter URL...")
+        self.address_bar.returnPressed.connect(self.navigate_to_url)
+        self.address_bar_layout.addWidget(self.address_bar)
+
+        # Add go button
+        self.go_button = QPushButton("Go")
+        self.go_button.clicked.connect(self.navigate_to_url)
+        self.address_bar_layout.addWidget(self.go_button)
+
+        self.browser_layout.addLayout(self.address_bar_layout)
+
+    def navigate_to_url(self) -> None:
+        """Navigate to the URL entered in the address bar."""
+        url = self.address_bar.text()
+        self.load(QUrl(url))
+
+    def make_widget(self) -> None:
+        """Make the widget."""
+        self.browser_widget = QWidget()
+        self.browser_layout = QVBoxLayout(self.browser_widget)
+        self.set_size_policy()
+        self.make_address_bar()
+        self.browser_layout.addWidget(self)
+        self.parent_layout.addWidget(self.browser_widget)
+
+    def set_size_policy(self) -> None:
+        """Set the size policy."""
+        self.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Expanding)
+
+    def connect_signals(self) -> None:
+        """Connect the signals."""
+        self.connect_load_finished_signal()
+        self.connect_on_cookie_added_signal()
+
+    def connect_load_finished_signal(self) -> None:
+        """Connect the load finished signal."""
+        self.loadFinished.connect(self.on_load_finished)
+
+    def on_load_finished(self, _ok: bool) -> None:  # noqa: FBT001
+        """Handle the load finished signal."""
+        self.update_address_bar(self.url())
+
+    def update_address_bar(self, url: QUrl) -> None:
+        """Update the address bar with the current URL."""
+        self.address_bar.setText(url.toString())
+
+    def connect_on_cookie_added_signal(self) -> None:
+        """Connect the on cookie added signal."""
+        self.cookies: dict[str, list[QNetworkCookie]] = defaultdict(list)
+        self.page().profile().cookieStore().cookieAdded.connect(self.on_cookie_added)
+
+    def on_cookie_added(self, cookie: Any) -> None:
+        """Handle the on cookie added signal."""
+        self.cookies[cookie.domain()].append(cookie)
+
+    def load_first_url(self) -> None:
+        """Load the first URL."""
+        self.load(QUrl("https://www.google.com/"))
+
+    @property
+    def http_cookies(self) -> dict[str, list[Cookie]]:
+        """Get the http cookies for the given URL."""
+        return {
+            domain: self.qcookies_to_httpcookies(qcookies)
+            for domain, qcookies in self.cookies.items()
+        }
+
+    def qcookies_to_httpcookies(self, qcookies: list[QNetworkCookie]) -> list[Cookie]:
+        """Convert a list of QNetworkCookies to a CookieJar."""
+        return [self.qcookie_to_httpcookie(q_cookie) for q_cookie in qcookies]
+
+    def qcookie_to_httpcookie(self, qcookie: QNetworkCookie) -> Cookie:
+        """Convert a QNetworkCookie to a http.cookiejar.Cookie."""
+        name = bytes(qcookie.name().data()).decode()
+        value = bytes(qcookie.value().data()).decode()
+        domain = qcookie.domain()
+        path = qcookie.path() if qcookie.path() else "/"
+        secure = qcookie.isSecure()
+        expires = None
+        if qcookie.expirationDate().isValid():
+            expires = int(qcookie.expirationDate().toSecsSinceEpoch())
+        rest = {"HttpOnly": str(qcookie.isHttpOnly())}
+
+        return Cookie(
+            version=0,
+            name=name,
+            value=value,
+            port=None,
+            port_specified=False,
+            domain=domain,
+            domain_specified=bool(domain),
+            domain_initial_dot=domain.startswith("."),
+            path=path,
+            path_specified=bool(path),
+            secure=secure,
+            expires=expires or None,
+            discard=False,
+            comment=None,
+            comment_url=None,
+            rest=rest,
+            rfc2109=False,
+        )
+
+    def get_domain_cookies(self, domain: str) -> list[QNetworkCookie]:
+        """Get the cookies for the given domain."""
+        return self.cookies[domain]
+
+    def get_domain_http_cookies(self, domain: str) -> list[Cookie]:
+        """Get the http cookies for the given domain."""
+        cookies = self.get_domain_cookies(domain)
+        return self.qcookies_to_httpcookies(cookies)

winipedia_utils-0.1.17/winipedia_utils/pyside/ui/widgets/media_player.py

@@ -0,0 +1,265 @@
+"""Media player module.
+
+This module contains the media player class.
+"""
+
+from functools import partial
+from typing import Any
+
+from PySide6.QtCore import QBuffer, QByteArray, Qt, Signal
+from PySide6.QtMultimedia import QAudioOutput, QMediaPlayer
+from PySide6.QtMultimediaWidgets import QVideoWidget
+from PySide6.QtWidgets import (
+    QHBoxLayout,
+    QLayout,
+    QMenu,
+    QPushButton,
+    QSizePolicy,
+    QSlider,
+    QVBoxLayout,
+    QWidget,
+)
+
+from winipedia_utils.pyside.ui.base.base import Base as BaseUI
+
+
+class ClickableWidget(QWidget):
+    """Widget that can be clicked."""
+
+    clicked = Signal()
+
+    def mousePressEvent(self, event: Any) -> None:  # noqa: N802
+        """Handle mouse press event."""
+        if event.button() == Qt.MouseButton.LeftButton:
+            self.clicked.emit()
+        super().mousePressEvent(event)
+
+
+class ClickableVideoWidget(QVideoWidget):
+    """Video widget that can be clicked."""
+
+    clicked = Signal()
+
+    def mousePressEvent(self, event: Any) -> None:  # noqa: N802
+        """Handle mouse press event."""
+        if event.button() == Qt.MouseButton.LeftButton:
+            self.clicked.emit()
+        super().mousePressEvent(event)
+
+
+class MediaPlayer(QMediaPlayer):
+    """Media player class."""
+
+    def __init__(self, parent_layout: QLayout, *args: Any, **kwargs: Any) -> None:
+        """Initialize the media player."""
+        super().__init__(*args, **kwargs)
+        self.parent_layout = parent_layout
+        self.make_widget()
+
+    def make_widget(self) -> None:
+        """Make the widget."""
+        self.media_player_widget = QWidget()
+        self.media_player_layout = QVBoxLayout(self.media_player_widget)
+        self.parent_layout.addWidget(self.media_player_widget)
+        self.add_media_controls_above()
+        self.make_video_widget()
+        self.add_media_controls_below()
+
+    def make_video_widget(self) -> None:
+        """Make the video widget."""
+        self.video_widget = ClickableVideoWidget()
+        self.video_widget.clicked.connect(self.on_video_clicked)
+        self.video_widget.setSizePolicy(
+            QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Expanding
+        )
+        self.setVideoOutput(self.video_widget)
+
+        self.audio_output = QAudioOutput()
+        self.setAudioOutput(self.audio_output)
+
+        self.media_player_layout.addWidget(self.video_widget)
+
+    def on_video_clicked(self) -> None:
+        """Handle video widget click."""
+        if self.media_controls_widget_above.isVisible():
+            self.hide_media_controls()
+            return
+        self.show_media_controls()
+
+    def show_media_controls(self) -> None:
+        """Show media controls."""
+        self.media_controls_widget_above.show()
+        self.media_controls_widget_below.show()
+
+    def hide_media_controls(self) -> None:
+        """Hide media controls."""
+        self.media_controls_widget_above.hide()
+        self.media_controls_widget_below.hide()
+
+    def add_media_controls_above(self) -> None:
+        """Add media controls above the video."""
+        # main above widget
+        self.media_controls_widget_above = QWidget()
+        self.media_controls_layout_above = QHBoxLayout(self.media_controls_widget_above)
+        self.media_player_layout.addWidget(self.media_controls_widget_above)
+        # left contorls
+        self.left_controls_widget = QWidget()
+        self.left_controls_layout = QHBoxLayout(self.left_controls_widget)
+        self.media_controls_layout_above.addWidget(
+            self.left_controls_widget, alignment=Qt.AlignmentFlag.AlignLeft
+        )
+        # center contorls
+        self.center_controls_widget = QWidget()
+        self.center_controls_layout = QHBoxLayout(self.center_controls_widget)
+        self.media_controls_layout_above.addWidget(
+            self.center_controls_widget, alignment=Qt.AlignmentFlag.AlignCenter
+        )
+        self.right_controls_widget = QWidget()
+        self.right_controls_layout = QHBoxLayout(self.right_controls_widget)
+        self.media_controls_layout_above.addWidget(
+            self.right_controls_widget, alignment=Qt.AlignmentFlag.AlignRight
+        )
+
+        self.add_speed_control()
+        self.add_volume_control()
+        self.add_playback_control()
+        self.add_fullscreen_control()
+
+    def add_media_controls_below(self) -> None:
+        """Add media controls below the video."""
+        self.media_controls_widget_below = QWidget()
+        self.media_controls_layout_below = QHBoxLayout(self.media_controls_widget_below)
+        self.media_player_layout.addWidget(self.media_controls_widget_below)
+        self.add_progress_control()
+
+    def add_playback_control(self) -> None:
+        """Add playback control."""
+        self.play_icon = BaseUI.get_svg_icon("play_icon.svg")
+        self.pause_icon = BaseUI.get_svg_icon("pause_icon.svg")
+        # Pause symbol: ⏸ (U+23F8)
+        self.playback_button = QPushButton()
+        self.playback_button.setIcon(self.pause_icon)
+        self.playback_button.clicked.connect(self.toggle_playback)
+
+        self.center_controls_layout.addWidget(self.playback_button)
+
+    def toggle_playback(self) -> None:
+        """Toggle playback."""
+        if self.playbackState() == QMediaPlayer.PlaybackState.PlayingState:
+            self.pause()
+            self.playback_button.setIcon(self.play_icon)
+        else:
+            self.play()
+            self.playback_button.setIcon(self.pause_icon)
+
+    def add_speed_control(self) -> None:
+        """Add speed control.
+
+        A button in the top left that on click shows a dropdown to select the speed.
+        """
+        self.default_speed = 1
+        self.speed_options = [0.2, 0.5, self.default_speed, 1.5, 2, 3, 4, 5]
+        self.speed_button = QPushButton(f"{self.default_speed}x")
+        self.speed_menu = QMenu(self.speed_button)
+        for speed in self.speed_options:
+            action = self.speed_menu.addAction(f"{speed}x")
+            action.triggered.connect(partial(self.change_speed, speed))
+
+        self.speed_button.setMenu(self.speed_menu)
+        self.left_controls_layout.addWidget(self.speed_button)
+
+    def change_speed(self, speed: float) -> None:
+        """Change playback speed."""
+        self.setPlaybackRate(speed)
+        self.speed_button.setText(f"{speed}x")
+
+    def add_volume_control(self) -> None:
+        """Add volume control."""
+        self.volume_slider = QSlider(Qt.Orientation.Horizontal)
+        self.volume_slider.setRange(0, 100)
+        self.volume_slider.valueChanged.connect(self.on_volume_changed)
+        self.left_controls_layout.addWidget(self.volume_slider)
+
+    def on_volume_changed(self, value: int) -> None:
+        """Handle volume slider value change."""
+        volume = value / 100.0  # Convert to 0.0-1.0 range
+        self.audio_output.setVolume(volume)
+
+    def add_fullscreen_control(self) -> None:
+        """Add fullscreen control."""
+        self.fullscreen_icon = BaseUI.get_svg_icon("fullscreen_icon.svg")
+        self.exit_fullscreen_icon = BaseUI.get_svg_icon("exit_fullscreen_icon.svg")
+        self.fullscreen_button = QPushButton()
+        self.fullscreen_button.setIcon(self.fullscreen_icon)
+
+        self.parent_widget = self.parent_layout.parentWidget()
+        self.other_visible_widgets = [
+            w
+            for w in set(self.parent_widget.findChildren(QWidget))
+            - {
+                self.media_player_widget,
+                *self.media_player_widget.findChildren(QWidget),
+            }
+            if w.isVisible() or not (w.isHidden() or w.isVisible())
+        ]
+        self.fullscreen_button.clicked.connect(self.toggle_fullscreen)
+
+        self.right_controls_layout.addWidget(self.fullscreen_button)
+
+    def toggle_fullscreen(self) -> None:
+        """Toggle fullscreen mode."""
+        # Get the main window
+        main_window = self.media_player_widget.window()
+        if main_window.isFullScreen():
+            for widget in self.other_visible_widgets:
+                widget.show()
+            # show the window in the previous size
+            main_window.showMaximized()
+            self.fullscreen_button.setIcon(self.fullscreen_icon)
+        else:
+            for widget in self.other_visible_widgets:
+                widget.hide()
+            main_window.showFullScreen()
+            self.fullscreen_button.setIcon(self.exit_fullscreen_icon)
+
+    def add_progress_control(self) -> None:
+        """Add progress control."""
+        self.progress_slider = QSlider(Qt.Orientation.Horizontal)
+        self.media_controls_layout_below.addWidget(self.progress_slider)
+
+        # Connect media player signals to update the progress slider
+        self.positionChanged.connect(self.update_position)
+        self.durationChanged.connect(self.set_duration)
+
+        # Connect slider signals to update video position
+        self.progress_slider.sliderMoved.connect(self.set_position)
+        self.progress_slider.sliderReleased.connect(self.slider_released)
+
+    def update_position(self, position: int) -> None:
+        """Update the progress slider position."""
+        # Only update if not being dragged to prevent jumps during manual sliding
+        if not self.progress_slider.isSliderDown():
+            self.progress_slider.setValue(position)
+
+    def set_duration(self, duration: int) -> None:
+        """Set the progress slider range based on media duration."""
+        self.progress_slider.setRange(0, duration)
+
+    def set_position(self, position: int) -> None:
+        """Set the media position when slider is moved."""
+        self.setPosition(position)
+
+    def slider_released(self) -> None:
+        """Handle slider release event."""
+        self.setPosition(self.progress_slider.value())
+
+    def play_data(self, data: bytes, name: str) -> None:
+        """Play the video."""
+        self.stop()
+        self.buffer = QBuffer()
+        self.buffer.setData(QByteArray(data))
+        self.buffer.open(QBuffer.OpenModeFlag.ReadOnly)
+
+        self.setSourceDevice(self.buffer, name)
+
+        super().play()

winipedia_utils-0.1.17/winipedia_utils/pyside/ui/widgets/notification.py

@@ -0,0 +1,56 @@
+"""Notification module.
+
+This module contains functions to show notifications.
+"""
+
+from pyqttoast import Toast, ToastIcon, ToastPosition  # type: ignore[import-untyped]
+from PySide6.QtWidgets import QApplication
+
+from winipedia_utils.text.string import value_to_truncated_string
+
+Toast.setPosition(ToastPosition.TOP_MIDDLE)
+
+
+class Notification(Toast):  # type: ignore[misc]
+    """Notification class."""
+
+    def __init__(
+        self,
+        title: str,
+        text: str,
+        icon: ToastIcon = ToastIcon.INFORMATION,
+        duration: int = 10000,
+    ) -> None:
+        """Initialize the notification.
+
+        The notification is shown in the top middle of the screen.
+
+        Args:
+            parent (QWidget): The parent widget.
+            title (str): The title of the notification.
+            text (str): The text of the notification.
+            icon (ToastIcon, optional): The icon of the notification.
+            duration (int, optional): The duration of the notification in milliseconds.
+        """
+        super().__init__(QApplication.activeWindow())
+        self.setDuration(duration)
+        self.setIcon(icon)
+        self.set_title(title)
+        self.set_text(text)
+
+    def set_title(self, title: str) -> None:
+        """Set the title of the notification."""
+        title = self.str_to_half_window_width(title)
+        self.setTitle(title)
+
+    def set_text(self, text: str) -> None:
+        """Set the text of the notification."""
+        text = self.str_to_half_window_width(text)
+        self.setText(text)
+
+    def str_to_half_window_width(self, string: str) -> str:
+        """Truncate the string to the width of the active window."""
+        main_window = QApplication.activeWindow()
+        width = main_window.width() / 2 if main_window is not None else 500
+        width = int(width)
+        return value_to_truncated_string(string, width)

winipedia_utils-0.1.17/winipedia_utils/pyside/ui/windows/__init__.py

@@ -0,0 +1 @@
+"""__init__ module."""

winipedia_utils-0.1.17/winipedia_utils/pyside/ui/windows/base/__init__.py

@@ -0,0 +1 @@
+"""__init__ module."""

winipedia_utils-0.1.17/winipedia_utils/pyside/ui/windows/base/base.py

@@ -0,0 +1,56 @@
+"""Base window module.
+
+This module contains the base window class for the VideoVault application.
+"""
+
+from abc import abstractmethod
+from collections.abc import Generator
+from types import ModuleType
+from typing import final
+
+from PySide6.QtWidgets import QMainWindow, QStackedWidget
+
+from winipedia_utils.pyside.ui.base.base import Base as BaseUI
+from winipedia_utils.pyside.ui.pages.base.base import Base as BasePage
+
+
+class Base(BaseUI, QMainWindow):
+    """Base window class for the VideoVault application."""
+
+    @abstractmethod
+    def start_page_cls(self) -> type[BasePage]:
+        """Get the start page class."""
+
+    @abstractmethod
+    def get_pages_package(self) -> ModuleType:
+        """The package to get the page classes from."""
+
+    @final
+    def base_setup(self) -> None:
+        """Get the Qt object of the UI."""
+        self.setWindowTitle(self.get_display_name())
+
+        self.stack = QStackedWidget()
+        self.setCentralWidget(self.stack)
+
+        self.add_pages()
+
+        self.set_start_page()
+
+    @final
+    def add_pages(self) -> None:
+        """Add the pages to the window."""
+        self.pages = list(self.make_pages())
+        for page in self.pages:
+            self.stack.addWidget(page)
+
+    @final
+    def make_pages(self) -> Generator[BasePage, None, None]:
+        """Get the pages to add to the window."""
+        for page_cls in BasePage.get_subclasses(self.get_pages_package()):
+            yield page_cls()
+
+    @final
+    def set_start_page(self) -> None:
+        """Set the start page."""
+        self.set_current_page(self.start_page_cls())

winipedia_utils-0.1.17/winipedia_utils/resources/__init__.py

@@ -0,0 +1 @@
+"""__init__ module."""

winipedia_utils-0.1.17/winipedia_utils/resources/svgs/__init__.py

@@ -0,0 +1 @@
+"""__init__ module."""

winipedia_utils-0.1.17/winipedia_utils/resources/svgs/download_arrow.svg

@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="black" width="24" height="24">
+  <path d="M12 3v12m0 0l-5-5m5 5l5-5M5 21h14" stroke="black" stroke-width="2" fill="none" stroke-linecap="round" stroke-linejoin="round"/>
+</svg>

winipedia_utils-0.1.17/winipedia_utils/resources/svgs/exit_fullscreen_icon.svg

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="utf-8"?><!-- Uploaded to: SVG Repo, www.svgrepo.com, Generator: SVG Repo Mixer Tools -->
+<svg width="800px" height="800px" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+  <path d="M1 6L6 6L6 1L4.2 1L4.2 4.2L1 4.2L1 6Z" fill="#000000"/>
+  <path d="M15 10L10 10L10 15L11.8 15L11.8 11.8L15 11.8L15 10Z" fill="#000000"/>
+  <path d="M6 15L6 10L1 10L1 11.8L4.2 11.8L4.2 15L6 15Z" fill="#000000"/>
+  <path d="M10 1L10 6L15 6L15 4.2L11.8 4.2L11.8 1L10 1Z" fill="#000000"/>
+</svg>

winipedia_utils-0.1.17/winipedia_utils/resources/svgs/fullscreen_icon.svg

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?><!-- Uploaded to: SVG Repo, www.svgrepo.com, Generator: SVG Repo Mixer Tools -->
+<svg width="800px" height="800px" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+  <path fill-rule="evenodd" clip-rule="evenodd" d="M10 15H15V10H13.2V13.2H10V15ZM6 15V13.2H2.8V10H1V15H6ZM10 2.8H12.375H13.2V6H15V1H10V2.8ZM6 1V2.8H2.8V6H1V1H6Z" fill="#000000"/>
+</svg>

winipedia_utils-0.1.17/winipedia_utils/resources/svgs/pause_icon.svg

@@ -0,0 +1,4 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" width="24" height="24">
+  <rect x="4" y="4" width="6" height="16"/>
+  <rect x="14" y="4" width="6" height="16"/>
+</svg>

winipedia_utils-0.1.17/winipedia_utils/resources/svgs/play_icon.svg

@@ -0,0 +1,8 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 330 330" width="24" height="24">
+  <path d="M37.728,328.12c2.266,1.256,4.77,1.88,7.272,1.88
+    c2.763,0,5.522-0.763,7.95-2.28l240-149.999
+    c4.386-2.741,7.05-7.548,7.05-12.72c0-5.172-2.664-9.979-7.05-12.72
+    L52.95,2.28c-4.625-2.891-10.453-3.043-15.222-0.4
+    C32.959,4.524,30,9.547,30,15v300
+    C30,320.453,32.959,325.476,37.728,328.12z"/>
+</svg>

winipedia_utils-0.1.17/winipedia_utils/resources/svgs/svg.py

@@ -0,0 +1,11 @@
+"""utils for svgs."""
+
+from pathlib import Path
+
+from winipedia_utils.modules.module import to_path
+from winipedia_utils.resources import svgs
+
+
+def get_svg_path(svg_name: str) -> Path:
+    """Get the path to a svg."""
+    return to_path(svgs, is_package=True) / svg_name

winipedia_utils-0.1.17/winipedia_utils/security/__init__.py

@@ -0,0 +1 @@
+"""__init__ module for winipedia_utils.security."""

winipedia_utils-0.1.17/winipedia_utils/security/keyring.py

@@ -0,0 +1,30 @@
+"""Keyring utilities for secure storage and retrieval of secrets.
+
+This module provides utility functions for working with keyring,
+including getting and creating secrets and fernets.
+These utilities help with secure storage and retrieval of secrets.
+"""
+
+import keyring
+from cryptography.fernet import Fernet
+
+
+def get_or_create_secret(service_name: str, username: str) -> str:
+    """Get the app secret using keyring.
+
+    If it does not exist, create it with a Fernet.
+    """
+    secret = keyring.get_password(service_name, username)
+    if secret is None:
+        secret = Fernet.generate_key().decode()
+        keyring.set_password(service_name, username, secret)
+    return secret
+
+
+def get_or_create_fernet(service_name: str, username: str) -> Fernet:
+    """Get the app fernet using keyring.
+
+    If it does not exist, create it with a Fernet.
+    """
+    secret = get_or_create_secret(service_name, username)
+    return Fernet(secret.encode())