winipedia-pyside 0.2.0__py3-none-any.whl

winipedia_pyside/ui/pages/base/base.py

@@ -0,0 +1,92 @@
+"""Base page module.
+
+This module contains the base page class for the VideoVault application.
+"""
+
+from functools import partial
+from typing import TYPE_CHECKING, Any
+
+from PySide6.QtCore import Qt
+from PySide6.QtWidgets import (
+    QHBoxLayout,
+    QLayout,
+    QMenu,
+    QPushButton,
+    QSizePolicy,
+    QVBoxLayout,
+    QWidget,
+)
+
+from winipedia_pyside.ui.base.base import Base as BaseUI
+
+if TYPE_CHECKING:
+    from winipedia_pyside.ui.windows.base.base import Base as BaseWindow
+
+
+class Base(BaseUI, QWidget):
+    """Base page class for the VideoVault application."""
+
+    def __init__(self, base_window: "BaseWindow", *args: Any, **kwargs: Any) -> None:
+        """Initialize the base page."""
+        self.base_window = base_window
+        super().__init__(*args, **kwargs)
+
+    def base_setup(self) -> None:
+        """Setup the base Qt object of the UI.
+
+        Initializes the main vertical layout, adds a horizontal layout for the top row,
+        and sets up the menu dropdown button.
+        """
+        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()
+        self.base_window.add_page(self)
+
+    def add_menu_dropdown_button(self) -> None:
+        """Add a dropdown menu that leads to each page.
+
+        Creates a menu button with a dropdown containing actions for all available
+        page subclasses. Each action connects to the set_current_page method.
+        """
+        self.menu_button = QPushButton("Menu")
+        self.menu_button.setIcon(self.get_svg_icon("menu_icon"))
+        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.base_window.get_all_page_classes():
+            action = self.menu_dropdown.addAction(page_cls.get_display_name())
+            action.triggered.connect(partial(self.set_current_page, page_cls))
+
+    def add_to_page_button(
+        self, to_page_cls: type["Base"], layout: QLayout
+    ) -> QPushButton:
+        """Add a button to go to the specified page.
+
+        Args:
+            to_page_cls: The page class to navigate to when button is clicked.
+            layout: The layout to add the button to.
+
+        Returns:
+            The created QPushButton widget.
+        """
+        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

winipedia_pyside/ui/pages/browser.py

@@ -0,0 +1,26 @@
+"""Add downloads page module.
+
+This module contains the add downloads page class for the VideoVault application.
+"""
+
+from winipedia_pyside.ui.pages.base.base import Base as BasePage
+from winipedia_pyside.ui.widgets.browser import Browser as BrowserWidget
+
+
+class Browser(BasePage):
+    """Add downloads page for the VideoVault application."""
+
+    def setup(self) -> None:
+        """Setup the UI.
+
+        Initializes the browser page by adding a browser widget to the layout.
+        """
+        self.add_brwoser()
+
+    def add_brwoser(self) -> None:
+        """Add a browser to surf the web.
+
+        Creates and adds a BrowserWidget instance to the vertical layout,
+        enabling web browsing functionality within the page.
+        """
+        self.browser = BrowserWidget(self.v_layout)

winipedia_pyside/ui/pages/player.py

@@ -0,0 +1,85 @@
+"""Player page module.
+
+This module contains the player page class for the VideoVault application.
+"""
+
+from abc import abstractmethod
+from collections.abc import Callable
+from pathlib import Path
+from typing import Any
+
+from cryptography.hazmat.primitives.ciphers.aead import AESGCM
+
+from winipedia_pyside.ui.pages.base.base import Base as BasePage
+from winipedia_pyside.ui.widgets.media_player import MediaPlayer
+
+
+class Player(BasePage):
+    """Player page for the VideoVault application."""
+
+    @abstractmethod
+    def start_playback(self, path: Path, position: int = 0) -> None:
+        """Start the playback.
+
+        Args:
+            path: The file path to start playback for.
+            position: The position to start playback from in milliseconds.
+        """
+
+    def setup(self) -> None:
+        """Setup the UI.
+
+        Initializes the media player widget and adds it to the layout.
+        """
+        self.media_player = MediaPlayer(self.v_layout)
+
+    def play_file_from_func(
+        self,
+        play_func: Callable[..., Any],
+        path: Path,
+        position: int = 0,
+        **kwargs: Any,
+    ) -> None:
+        """Play a file using the specified function.
+
+        Sets the current page to player and calls the provided play function
+        with the given path and additional arguments.
+
+        Args:
+            play_func: The function to call for playing the file.
+            path: The file path to play.
+            position: The position to start playback from in milliseconds.
+            **kwargs: Additional keyword arguments to pass to the play function.
+        """
+        # set current page to player
+        self.set_current_page(self.__class__)
+        # Stop current playback and clean up resources
+        play_func(path=path, position=position, **kwargs)
+
+    def play_file(self, path: Path, position: int = 0) -> None:
+        """Play a regular video file.
+
+        Args:
+            path: The file path to play.
+            position: The position to start playback from in milliseconds.
+        """
+        self.play_file_from_func(
+            self.media_player.play_file, path=path, position=position
+        )
+
+    def play_encrypted_file(
+        self, path: Path, aes_gcm: AESGCM, position: int = 0
+    ) -> None:
+        """Play an encrypted video file.
+
+        Args:
+            path: The encrypted file path to play.
+            aes_gcm: The AES-GCM cipher instance for decryption.
+            position: The position to start playback from in milliseconds.
+        """
+        self.play_file_from_func(
+            self.media_player.play_encrypted_file,
+            path=path,
+            position=position,
+            aes_gcm=aes_gcm,
+        )

winipedia_pyside/ui/widgets/__init__.py

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

winipedia_pyside/ui/widgets/browser.py

@@ -0,0 +1,243 @@
+"""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.
+
+        Args:
+            parent_layout: The parent layout to add the browser widget to.
+            *args: Additional positional arguments passed to parent constructor.
+            **kwargs: Additional keyword arguments passed to parent constructor.
+        """
+        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.
+
+        Creates a horizontal layout containing back button, forward button,
+        address input field, and go button for browser navigation.
+        """
+        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.
+
+        Takes the URL from the address bar text field and loads it in the browser.
+        """
+        url = self.address_bar.text()
+        self.load(QUrl(url))
+
+    def make_widget(self) -> None:
+        """Make the widget.
+
+        Creates the main browser widget with vertical layout, sets size policy,
+        creates the address bar, and adds components to the parent layout.
+        """
+        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.
+
+        Sets the browser to expand in both horizontal and vertical directions.
+        """
+        self.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Expanding)
+
+    def connect_signals(self) -> None:
+        """Connect the signals.
+
+        Connects load finished signal and cookie added signal handlers.
+        """
+        self.connect_load_finished_signal()
+        self.connect_on_cookie_added_signal()
+
+    def connect_load_finished_signal(self) -> None:
+        """Connect the load finished signal.
+
+        Connects the loadStarted signal to the on_load_started handler.
+        """
+        self.loadFinished.connect(self.on_load_finished)
+
+    def on_load_finished(self, _ok: bool) -> None:  # noqa: FBT001
+        """Handle the load finished signal.
+
+        Args:
+            _ok: Boolean indicating if the load was successful (unused).
+        """
+        self.update_address_bar(self.url())
+
+    def update_address_bar(self, url: QUrl) -> None:
+        """Update the address bar with the current URL.
+
+        Args:
+            url: The QUrl to display in the address bar.
+        """
+        self.address_bar.setText(url.toString())
+
+    def connect_on_cookie_added_signal(self) -> None:
+        """Connect the on cookie added signal.
+
+        Initializes the cookies dictionary and connects the cookieAdded signal
+        to the on_cookie_added handler.
+        """
+        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.
+
+        Args:
+            cookie: The QNetworkCookie that was added.
+        """
+        self.cookies[cookie.domain()].append(cookie)
+
+    def load_first_url(self) -> None:
+        """Load the first URL.
+
+        Loads Google's homepage as the initial page when the browser starts.
+        """
+        self.load(QUrl("https://www.google.com/"))
+
+    @property
+    def http_cookies(self) -> dict[str, list[Cookie]]:
+        """Get the http cookies for all domains.
+
+        Returns:
+            Dictionary mapping domain names to lists of http.cookiejar.Cookie objects.
+        """
+        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 http.cookiejar.Cookie objects.
+
+        Args:
+            qcookies: List of QNetworkCookie objects to convert.
+
+        Returns:
+            List of converted http.cookiejar.Cookie objects.
+        """
+        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.
+
+        Args:
+            qcookie: The QNetworkCookie to convert.
+
+        Returns:
+            The converted http.cookiejar.Cookie object.
+        """
+        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.
+
+        Args:
+            domain: The domain to get cookies for.
+
+        Returns:
+            List of QNetworkCookie objects for the specified domain.
+        """
+        return self.cookies[domain]
+
+    def get_domain_http_cookies(self, domain: str) -> list[Cookie]:
+        """Get the http cookies for the given domain.
+
+        Args:
+            domain: The domain to get cookies for.
+
+        Returns:
+            List of http.cookiejar.Cookie objects for the specified domain.
+        """
+        cookies = self.get_domain_cookies(domain)
+        return self.qcookies_to_httpcookies(cookies)

winipedia_pyside/ui/widgets/clickable_widget.py

@@ -0,0 +1,57 @@
+"""Clickable widget module.
+
+This module contains clickable widget classes that emit signals when clicked.
+Provides both regular QWidget and QVideoWidget variants with click functionality.
+"""
+
+from typing import Any
+
+from PySide6.QtCore import Qt, Signal
+from PySide6.QtMultimediaWidgets import QVideoWidget
+from PySide6.QtWidgets import QWidget
+
+
+class ClickableWidget(QWidget):
+    """Widget that can be clicked.
+
+    A QWidget subclass that emits a clicked signal when the left mouse
+    button is pressed on the widget.
+    """
+
+    clicked = Signal()
+
+    def mousePressEvent(self, event: Any) -> None:  # noqa: N802
+        """Handle mouse press event.
+
+        Emits the clicked signal when the left mouse button is pressed
+        and passes the event to the parent class.
+
+        Args:
+            event: The mouse press event containing button and position information.
+        """
+        if event.button() == Qt.MouseButton.LeftButton:
+            self.clicked.emit()
+        super().mousePressEvent(event)
+
+
+class ClickableVideoWidget(QVideoWidget):
+    """Video widget that can be clicked.
+
+    A QVideoWidget subclass that emits a clicked signal when the left mouse
+    button is pressed on the video widget.
+    """
+
+    clicked = Signal()
+
+    def mousePressEvent(self, event: Any) -> None:  # noqa: N802
+        """Handle mouse press event.
+
+        Emits the clicked signal when the left mouse button is pressed
+        and passes the event to the parent class.
+
+        Args:
+            event: The mouse press event containing button and position information.
+        """
+        if event.button() == Qt.MouseButton.LeftButton:
+            self.clicked.emit()
+        super().mousePressEvent(event)