winipedia-utils 0.1.39__py3-none-any.whl → 0.1.41__py3-none-any.whl

winipedia_utils/pyside/ui/pages/browser.py

@@ -14,11 +14,17 @@ class Browser(BasePage):
 
     @final
     def setup(self) -> None:
-        """Setup the UI."""
-        # add a download button in the top right
+        """Setup the UI.
+
+        Initializes the browser page by adding a browser widget to the layout.
+        """
         self.add_brwoser()
 
     @final
     def add_brwoser(self) -> None:
-        """Add a browser to surfe the web."""
+        """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_utils/pyside/ui/pages/player.py

@@ -3,8 +3,12 @@
 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 final
+from typing import Any, final
+
+from cryptography.hazmat.primitives.ciphers.aead import AESGCM
 
 from winipedia_utils.pyside.ui.pages.base.base import Base as BasePage
 from winipedia_utils.pyside.ui.widgets.media_player import MediaPlayer
@@ -13,15 +17,73 @@ from winipedia_utils.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.
+        """
+
     @final
     def setup(self) -> None:
-        """Setup the UI."""
+        """Setup the UI.
+
+        Initializes the media player widget and adds it to the layout.
+        """
         self.media_player = MediaPlayer(self.v_layout)
 
     @final
-    def play_file(self, path: Path) -> None:
-        """Play the video."""
+    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
-        self.media_player.play_file(path)
+        play_func(path=path, position=position, **kwargs)
+
+    @final
+    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
+        )
+
+    @final
+    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_utils/pyside/ui/widgets/browser.py

@@ -26,7 +26,13 @@ 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."""
+        """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()
@@ -34,7 +40,11 @@ class Browser(QWebEngineView):
         self.load_first_url()
 
     def make_address_bar(self) -> None:
-        """Make the address bar."""
+        """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
@@ -65,12 +75,19 @@ class Browser(QWebEngineView):
         self.browser_layout.addLayout(self.address_bar_layout)
 
     def navigate_to_url(self) -> None:
-        """Navigate to the URL entered in the address bar."""
+        """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."""
+        """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()
@@ -79,53 +96,99 @@ class Browser(QWebEngineView):
         self.parent_layout.addWidget(self.browser_widget)
 
     def set_size_policy(self) -> None:
-        """Set the size policy."""
+        """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."""
+        """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."""
-        self.loadFinished.connect(self.on_load_finished)
+        """Connect the load finished signal.
 
-    def on_load_finished(self, _ok: bool) -> None:  # noqa: FBT001
-        """Handle the load finished signal."""
+        Connects the loadStarted signal to the on_load_started handler.
+        """
+        self.loadStarted.connect(self.on_load_started)
+
+    def on_load_started(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."""
+        """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."""
+        """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."""
+        """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."""
+        """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 the given URL."""
+        """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 a CookieJar."""
+        """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."""
+        """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()
@@ -157,10 +220,24 @@ class Browser(QWebEngineView):
         )
 
     def get_domain_cookies(self, domain: str) -> list[QNetworkCookie]:
-        """Get the cookies for the given domain."""
+        """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."""
+        """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_utils/pyside/ui/widgets/clickable_widget.py

@@ -1,3 +1,9 @@
+"""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
@@ -6,24 +12,46 @@ from PySide6.QtWidgets import QWidget
 
 
 class ClickableWidget(QWidget):
-    """Widget that can be clicked."""
+    """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."""
+        """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."""
+    """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."""
+        """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)