winipedia-utils 0.1.34__tar.gz → 0.1.36__tar.gz

{winipedia_utils-0.1.34 → winipedia_utils-0.1.36}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: winipedia-utils
-Version: 0.1.34
+Version: 0.1.36
 Summary: A package with many utility functions
 License: MIT
 Author: Winipedia

{winipedia_utils-0.1.34 → winipedia_utils-0.1.36}/pyproject.toml

@@ -1,7 +1,7 @@
 # Project section
 [project]
 name = "winipedia-utils"
-version = "0.1.34"
+version = "0.1.36"
 description = "A package with many utility functions"
 readme = "README.md"
 requires-python = ">=3.12,<3.14"

winipedia_utils-0.1.36/winipedia_utils/pyside/core/__init__.py

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

winipedia_utils-0.1.36/winipedia_utils/pyside/core/py_qiodevice.py

@@ -0,0 +1,93 @@
+"""PySide6 QIODevice wrapper."""
+
+from pathlib import Path
+from typing import Any
+
+from PySide6.QtCore import QFile, QIODevice
+
+
+class PyQIODevice(QIODevice):
+    """QFile subclass that decrypts data on read."""
+
+    def __init__(self, q_device: QIODevice, *args: Any, **kwargs: Any) -> None:
+        """Initialize the device."""
+        super().__init__(*args, **kwargs)
+        self.q_device = q_device
+
+    def atEnd(self) -> bool:  # noqa: N802
+        """Check if we are at the end of the file."""
+        return self.q_device.atEnd()
+
+    def bytesAvailable(self) -> int:  # noqa: N802
+        """Return the number of bytes available for reading."""
+        return self.q_device.bytesAvailable()
+
+    def bytesToWrite(self) -> int:  # noqa: N802
+        """Return the number of bytes available for writing."""
+        return self.q_device.bytesToWrite()
+
+    def canReadLine(self) -> bool:  # noqa: N802
+        """Check if we can read a line."""
+        return self.q_device.canReadLine()
+
+    def close(self) -> None:
+        """Close the device."""
+        self.q_device.close()
+        return super().close()
+
+    def isSequential(self) -> bool:  # noqa: N802
+        """Check if the device is sequential."""
+        return self.q_device.isSequential()
+
+    def open(self, mode: QIODevice.OpenModeFlag) -> bool:
+        """Open the device."""
+        self.q_device.open(mode)
+        return super().open(mode)
+
+    def pos(self) -> int:
+        """Return the current position in the device."""
+        return self.q_device.pos()
+
+    def readData(self, maxlen: int) -> bytes:  # noqa: N802
+        """Read data from the device."""
+        return bytes(self.q_device.read(maxlen).data())
+
+    def readLineData(self, maxlen: int) -> object:  # noqa: N802
+        """Read a line from the device."""
+        return self.q_device.readLine(maxlen)
+
+    def reset(self) -> bool:
+        """Reset the device."""
+        return self.q_device.reset()
+
+    def seek(self, pos: int) -> bool:
+        """Seek to a position in the device."""
+        return self.q_device.seek(pos)
+
+    def size(self) -> int:
+        """Return the size of the device."""
+        return self.q_device.size()
+
+    def skipData(self, maxSize: int) -> int:  # noqa: N802, N803
+        """Skip data in the device."""
+        return self.q_device.skip(maxSize)
+
+    def waitForBytesWritten(self, msecs: int) -> bool:  # noqa: N802
+        """Wait for bytes to be written."""
+        return self.q_device.waitForBytesWritten(msecs)
+
+    def waitForReadyRead(self, msecs: int) -> bool:  # noqa: N802
+        """Wait for the device to be ready to read."""
+        return self.q_device.waitForReadyRead(msecs)
+
+    def writeData(self, data: bytes | bytearray | memoryview, len: int) -> int:  # noqa: A002, ARG002, N802
+        """Write data to the device."""
+        return self.q_device.write(data)
+
+
+class PyQFile(PyQIODevice):
+    """QFile subclass."""
+
+    def __init__(self, path: Path, *args: Any, **kwargs: Any) -> None:
+        """Initialize the device."""
+        super().__init__(QFile(path), *args, **kwargs)

{winipedia_utils-0.1.34 → winipedia_utils-0.1.36}/winipedia_utils/pyside/ui/pages/player.py

@@ -3,6 +3,7 @@
 This module contains the player page class for the VideoVault application.
 """
 
+from pathlib import Path
 from typing import final
 
 from winipedia_utils.pyside.ui.pages.base.base import Base as BasePage
@@ -18,9 +19,9 @@ class Player(BasePage):
         self.media_player = MediaPlayer(self.v_layout)
 
     @final
-    def play_data(self, data: bytes, name: str) -> None:
+    def play_file(self, path: Path) -> 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)
+        self.media_player.play_file(path)

winipedia_utils-0.1.36/winipedia_utils/pyside/ui/widgets/clickable_widget.py

@@ -0,0 +1,29 @@
+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."""
+
+    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)

{winipedia_utils-0.1.34 → winipedia_utils-0.1.36}/winipedia_utils/pyside/ui/widgets/media_player.py

@@ -3,12 +3,14 @@
 This module contains the media player class.
 """
 
+import time
+from collections.abc import Callable
 from functools import partial
+from pathlib import Path
 from typing import Any
 
-from PySide6.QtCore import QBuffer, QByteArray, Qt, Signal
+from PySide6.QtCore import Qt, QTimer, QUrl
 from PySide6.QtMultimedia import QAudioOutput, QMediaPlayer
-from PySide6.QtMultimediaWidgets import QVideoWidget
 from PySide6.QtWidgets import (
     QHBoxLayout,
     QLayout,
@@ -20,31 +22,9 @@ from PySide6.QtWidgets import (
     QWidget,
 )
 
+from winipedia_utils.pyside.core.py_qiodevice import PyQFile, PyQIODevice
 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)
+from winipedia_utils.pyside.ui.widgets.clickable_widget import ClickableVideoWidget
 
 
 class MediaPlayer(QMediaPlayer):
@@ -228,38 +208,72 @@ class MediaPlayer(QMediaPlayer):
         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)
+        self.positionChanged.connect(self.update_slider_position)
+        self.durationChanged.connect(self.set_slider_range)
 
         # Connect slider signals to update video position
-        self.progress_slider.sliderMoved.connect(self.set_position)
-        self.progress_slider.sliderReleased.connect(self.slider_released)
+        self.last_slider_moved_update = time.time()
+        self.slider_moved_update_interval = 0.1
+        self.progress_slider.sliderMoved.connect(self.on_slider_moved)
+        self.progress_slider.sliderReleased.connect(self.on_slider_released)
 
-    def update_position(self, position: int) -> None:
+    def update_slider_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:
+    def set_slider_range(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:
+    def on_slider_moved(self, position: int) -> None:
         """Set the media position when slider is moved."""
+        current_time = time.time()
+        if (
+            current_time - self.last_slider_moved_update
+            > self.slider_moved_update_interval
+        ):
+            self.setPosition(position)
+            self.last_slider_moved_update = current_time
         self.setPosition(position)
 
-    def slider_released(self) -> None:
+    def on_slider_released(self) -> None:
         """Handle slider release event."""
         self.setPosition(self.progress_slider.value())
 
-    def play_data(self, data: bytes, name: str) -> None:
+    def play_video(
+        self, set_source_func: Callable[..., Any], *args: Any, **kwargs: Any
+    ) -> 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)
+        # prevents freezing when starting a new video while another is playing
+        QTimer.singleShot(
+            100, partial(self.set_source_and_play, set_source_func, *args, **kwargs)
+        )
 
+    def set_source_and_play(
+        self, set_source_func: Callable[..., Any], *args: Any, **kwargs: Any
+    ) -> None:
+        """Set the source and play the video."""
+        set_source_func(*args, **kwargs)
         self.play()
+
+    def play_file(self, path: Path) -> None:
+        """Play the video."""
+        self.play_video(
+            self.set_source_device,
+            io_device=PyQFile(path),
+            source_url=QUrl.fromLocalFile(path),
+        )
+
+    def set_source_device(
+        self, io_device: PyQIODevice, source_url: QUrl | None = None
+    ) -> None:
+        """Play the video."""
+        if source_url is None:
+            source_url = QUrl()
+        self.source_url = source_url
+        self.io_device = io_device
+        self.setSourceDevice(self.io_device, self.source_url)

winipedia_utils-0.1.36/winipedia_utils/security/cryptography.py

@@ -0,0 +1,29 @@
+"""Cryptography utilities for secure data handling.
+
+This module provides utility functions for working with cryptography,
+including encryption and decryption using Fernet and AESGCM.
+These utilities help with secure data handling.
+"""
+
+import os
+
+from cryptography.hazmat.primitives.ciphers.aead import AESGCM
+
+IV_LEN = 12
+
+
+def encrypt_with_aes_gcm(
+    aes_gcm: AESGCM, data: bytes, aad: bytes | None = None
+) -> bytes:
+    """Encrypt data using AESGCM."""
+    iv = os.urandom(IV_LEN)
+    encrypted = aes_gcm.encrypt(iv, data, aad)
+    return iv + encrypted
+
+
+def decrypt_with_aes_gcm(
+    aes_gcm: AESGCM, data: bytes, aad: bytes | None = None
+) -> bytes:
+    """Decrypt data using AESGCM."""
+    iv, encrypted = data[:IV_LEN], data[IV_LEN:]
+    return aes_gcm.decrypt(iv, encrypted, aad)

{winipedia_utils-0.1.34 → winipedia_utils-0.1.36}/winipedia_utils/security/keyring.py

@@ -7,9 +7,10 @@ These utilities help with secure storage and retrieval of secrets.
 
 import keyring
 from cryptography.fernet import Fernet
+from cryptography.hazmat.primitives.ciphers.aead import AESGCM
 
 
-def get_or_create_secret(service_name: str, username: str) -> str:
+def get_or_create_fernet(service_name: str, username: str) -> Fernet:
     """Get the app secret using keyring.
 
     If it does not exist, create it with a Fernet.
@@ -18,13 +19,16 @@ def get_or_create_secret(service_name: str, username: str) -> str:
     if secret is None:
         secret = Fernet.generate_key().decode()
         keyring.set_password(service_name, username, secret)
-    return secret
+    return Fernet(secret.encode())
 
 
-def get_or_create_fernet(service_name: str, username: str) -> Fernet:
-    """Get the app fernet using keyring.
+def get_or_create_aes_gcm(service_name: str, username: str) -> AESGCM:
+    """Get the app secret using keyring.
 
-    If it does not exist, create it with a Fernet.
+    If it does not exist, create it with a AESGCM.
     """
-    secret = get_or_create_secret(service_name, username)
-    return Fernet(secret.encode())
+    secret = keyring.get_password(service_name, username)
+    if secret is None:
+        secret = AESGCM.generate_key(bit_length=256).decode()
+        keyring.set_password(service_name, username, secret)
+    return AESGCM(secret.encode())