Youtube-Comment-Export 0.1.0__py3-none-any.whl

ytComments/gui/menu.py

@@ -0,0 +1,26 @@
+from PySide6.QtWidgets import QMenuBar, QMainWindow
+from .about import AboutWindow
+from .settings import SettingsWindow
+
+class MenuBar(QMenuBar):
+    """Menu bar of the application."""
+    def __init__(self, parent: QMainWindow):
+        super().__init__(parent)
+        self.app = parent
+        
+        # Menu Settings
+        self.settings_dialog = SettingsWindow(self)
+        settings_menu = self.addAction("&Settings")
+        settings_menu.triggered.connect(self.show_settings)
+        
+        # Menu About
+        self.about_dialog = AboutWindow(self)
+        help_menu = self.addAction("&About")
+        help_menu.triggered.connect(self.about_dialog.exec)
+
+    def show_settings(self):
+        """Show the Settings window."""
+        x = self.app.geometry().x() - 100
+        y = self.app.geometry().y() - 100
+        self.settings_dialog.setGeometry(x, y, 270, 200)
+        self.settings_dialog.exec()

ytComments/gui/progressbar.py

@@ -0,0 +1,101 @@
+import sys
+from PySide6.QtWidgets import (
+    QApplication, QDialog, QProgressBar, QLabel, QVBoxLayout, QPushButton
+    )
+from PySide6.QtCore import Qt
+
+class LoadingWindow(QDialog):
+    """Window to show the progress of a long-running operation."""
+    def __init__(self, parent=None, countdown:bool = False):
+        if QApplication.instance() is None:
+                self.qapp = QApplication(sys.argv)
+                
+        super().__init__()
+        self.setWindowTitle("Loading...")
+        self.countdown = countdown
+        
+        if parent:
+            self.parent = parent
+            x = self.parent.app.geometry().x()
+            y = self.parent.app.geometry().y()
+        else:
+            x = 100
+            y = 100
+        self.setGeometry(x, y, 300, 100)
+        
+        # Delete the Windows title buttons
+        self.setWindowFlags(Qt.Window | Qt.WindowTitleHint | Qt.WindowStaysOnTopHint)
+
+        # Initialize a close event
+        self.closing = False
+
+        # Create the progress bar
+        self.progress_bar = QProgressBar(self)
+        self.progress_bar.setMinimum(0)
+        self.progress_bar.setMaximum(100)
+        self.progress_bar.setStyleSheet("""
+            QProgressBar {
+                background-color: #f0f0f0;  /* Background color */
+                border: 2px solid #8f8f8f;   /* Border color */
+                border-radius: 5px;          /* Rounded corners */
+                height: 15px;                 /* Height of the progress bar */
+                text-align: center;          /* Center the text */
+                color: #000000;              /* Text color */
+            }
+            QProgressBar::chunk {
+                background-color: #3c8dbc;   /* Background color of the filled chunk */
+                border-radius: 5px;          /* Rounded corners of the filled chunk */
+            }
+        """)
+        
+        # Add an explanatory text
+        self.label = QLabel("Downloading...", self)
+        self.label.setAlignment(Qt.AlignHCenter | Qt.AlignTop)
+        
+        # Add a countdown label
+        if self.countdown:
+            self.countdown_label = QLabel()
+            self.countdown_label.setAlignment(Qt.AlignHCenter | Qt.AlignTop)
+
+        # Add a cancel button
+        msg = "Stop the download earlier, only the downloaded comments will be added to the old save"
+        self.cancel_button = QPushButton("Cancel")
+        self.cancel_button.clicked.connect(self.terminate)
+        self.cancel_button.setToolTip(msg)
+
+        # Create the layout
+        layout = QVBoxLayout()
+        layout.addWidget(self.progress_bar)
+        layout.addWidget(self.label)
+        if self.countdown: layout.addWidget(self.countdown_label)
+        layout.addWidget(self.cancel_button)
+        layout.setAlignment(Qt.AlignCenter)
+        self.setLayout(layout)
+
+    def update_progress(self, value, duration:int | None = None):
+        """Update the progress bar value."""
+        self.progress_bar.setValue(value)
+        
+        # Update the countdown label
+        if self.countdown and duration is not None: 
+            hours = int(duration // 3600)
+            minutes = int((duration % 3600) // 60)
+            seconds = int(duration % 60)
+            
+            self.countdown_label.setText(
+                f"Remaining estimated time : {hours:02}h:{minutes:02}m:{seconds:02}s"
+                )
+        
+        QApplication.processEvents()
+        
+    def setText(self, text):
+        """Update the window title."""
+        self.label.setText(text)
+        
+    def terminate(self):
+        """Close the window."""
+        self.closing = True
+        self.close()
+        
+        
+        

ytComments/gui/settings.py

@@ -0,0 +1,186 @@
+from PySide6 import QtWidgets, QtGui, QtCore
+from .error import run_error
+
+class SettingsWindow(QtWidgets.QDialog):
+    """Window for settings."""
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.menu = parent
+        self.setWindowTitle("Settings")
+        self.setModal(True)
+        
+        # Settings Layout
+        layout = QtWidgets.QVBoxLayout(self)
+        layout.addLayout(self.init_color())
+        layout.addLayout(self.init_highlight())
+        layout.addLayout(self.init_max_sheets())
+        layout.addLayout(self.init_date_format())
+        layout.addLayout(self.init_auto_update())
+        layout.addSpacing(10)
+        layout.addLayout(self.init_buttons())
+        
+    def init_color(self):
+        """Initialize Hex color code for the background of the comments on Excel."""
+        msg = "Hex color code for the background of the comments on Excel"
+        regex = QtCore.QRegularExpression(r'^#[0-9A-Fa-f]{6}$')
+        validator = QtGui.QRegularExpressionValidator(regex)
+        
+        # Color Label
+        color_label = QtWidgets.QLabel("Background color :")
+        color_label.setToolTip(msg)
+        
+        # Color1 input
+        self.color1_input = QtWidgets.QLineEdit()
+        self.color1_input.setText(self.menu.app.yt.settings.bg_color[0])
+        self.color1_input.setPlaceholderText("#C5D9F1")
+        self.color1_input.setToolTip(msg)
+        self.color1_input.setValidator(validator)
+        
+        # Color2 input
+        self.color2_input = QtWidgets.QLineEdit()
+        self.color2_input.setText(self.menu.app.yt.settings.bg_color[1])
+        self.color2_input.setPlaceholderText("#FDE9D9")
+        self.color2_input.setToolTip(msg)
+        self.color2_input.setValidator(validator)
+        
+        # Color Layout
+        color_layout = QtWidgets.QHBoxLayout()
+        color_layout.addWidget(color_label)
+        color_layout.addWidget(self.color1_input)
+        color_layout.addWidget(self.color2_input)
+        return color_layout
+
+    def init_highlight(self):
+        """Initialize the toggle for the background color."""
+        msg = "Check to activate the background color"
+        
+        # Highlight label
+        highlight_label = QtWidgets.QLabel("Background color :")
+        highlight_label.setToolTip(msg)
+        
+        # Highlight toggle
+        self.highlight_toggle = QtWidgets.QCheckBox()
+        self.highlight_toggle.setChecked(self.menu.app.yt.settings.bg_highlight)
+        self.highlight_toggle.setToolTip(msg)
+        
+        # Highlight layout
+        highlight_layout = QtWidgets.QHBoxLayout()
+        highlight_layout.addWidget(highlight_label)
+        highlight_layout.addWidget(self.highlight_toggle)
+        return highlight_layout
+    
+    def init_max_sheets(self):
+        """Initialize the maximum number of sheets per file to export."""
+        msg = "Maximum number of sheets per file to export"
+        
+        # Sheets label
+        sheets_label = QtWidgets.QLabel("Sheets per file :")
+        sheets_label.setToolTip(msg)
+        
+        # Sheets input
+        self.sheets_input = QtWidgets.QLineEdit()
+        self.sheets_input.setText(str(self.menu.app.yt.settings.max_sheets))
+        self.sheets_input.setToolTip(msg)
+        
+        # Sheets layout
+        sheets_layout = QtWidgets.QHBoxLayout()
+        sheets_layout.addWidget(sheets_label)
+        sheets_layout.addWidget(self.sheets_input)
+        return sheets_layout
+    
+    def init_date_format(self):
+        """Initialize the date format."""
+        msg = "Format of the date in the comments"
+        
+        # Date label
+        date_label = QtWidgets.QLabel("Date format :")
+        date_label.setToolTip(msg)
+        
+        # Date input
+        self.date_input = QtWidgets.QLineEdit()
+        self.date_input.setText(self.menu.app.yt.settings.date_format)
+        self.date_input.setToolTip(msg)
+        
+        # Date layout
+        date_layout = QtWidgets.QHBoxLayout()
+        date_layout.addWidget(date_label)
+        date_layout.addWidget(self.date_input)
+        return date_layout
+    
+    def init_auto_update(self):
+        """Initialize the toggle for the automatic update."""
+        msg = "Allow or not the program to search for software updates at startup"
+        
+        # Update label
+        update_label = QtWidgets.QLabel("Search update at startup :")
+        update_label.setToolTip(msg)
+        
+        # Update toggle
+        self.update_toggle = QtWidgets.QCheckBox()
+        self.update_toggle.setChecked(self.menu.app.yt.settings.auto_update)
+        self.update_toggle.setToolTip(msg)
+        
+        # Update layout
+        update_layout = QtWidgets.QHBoxLayout()
+        update_layout.addWidget(update_label)
+        update_layout.addWidget(self.update_toggle)
+        return update_layout
+    
+    def init_buttons(self):
+        """Initialize the OK and Cancel buttons."""
+        # OK button
+        ok_button = QtWidgets.QPushButton("OK")
+        ok_button.clicked.connect(self.on_ok)
+        
+        # Cancel button
+        cancel_button = QtWidgets.QPushButton("Cancel")
+        cancel_button.clicked.connect(self.on_cancel)
+        
+        # Buttons layout
+        buttons_layout = QtWidgets.QHBoxLayout()
+        buttons_layout.addWidget(ok_button)
+        buttons_layout.addWidget(cancel_button)
+        return buttons_layout
+    
+    def on_ok(self):
+        """Manage the click on the OK button."""
+        
+        # Validate the color inputs
+        try:
+            color1 = str(self.color1_input.text()).upper()
+            color2 = str(self.color2_input.text()).upper()
+            if color1 == "":
+                color1 = "#C5D9F1"
+                self.color1_input.setText("#C5D9F1")
+            if color2 == "":
+                color2 = "#FDE9D9"
+                self.color2_input.setText("#FDE9D9")
+                
+            self.menu.app.yt.settings.bg_color = (color1, color2)
+        except ValueError as e:
+            run_error(e)
+            self.color1_input.setText(str(self.menu.app.yt.settings.bg_color[0]))
+            self.color2_input.setText(str(self.menu.app.yt.settings.bg_color[1]))
+            return
+        
+        # Validate the max sheets inputs
+        try:
+            max_sheets = int(self.sheets_input.text())
+            self.menu.app.yt.settings.max_sheets = max_sheets
+        except ValueError as e:
+            run_error("The maximum number of sheets must be at least 2")
+            self.sheets_input.setText(str(self.menu.app.yt.settings.max_sheets))
+            return
+        
+        # Validate the other settings
+        self.menu.app.yt.settings.bg_highlight = bool(self.highlight_toggle.isChecked())
+        self.menu.app.yt.settings.date_format = str(self.date_input.text())
+        self.menu.app.yt.settings.auto_update = bool(self.update_toggle.isChecked())
+        self.menu.app.yt.settings.save()
+        self.accept()
+    
+    def on_cancel(self):
+        """Manage the click on the Cancel button."""
+        self.reject()
+
+

ytComments/gui/update.py

@@ -0,0 +1,158 @@
+import requests
+import os
+import sys
+from PySide6.QtWidgets import QMessageBox
+from packaging.version import Version
+from .progressbar import LoadingWindow
+import ytComments.metadata as metadata
+
+class UpdateManager:
+    """Update Downloader of the software"""
+    def __init__(self, repo_owner, repo_name, parent=None):
+        self.about = parent
+        self.repo_owner = repo_owner
+        self.repo_name = repo_name
+        self._file_size = 0
+        self._downloaded_size = 0
+        self.dir_update = "update"
+
+    @property
+    def file_size(self):
+        """Size of the file to download."""
+        return self._file_size
+    
+    @file_size.setter
+    def file_size(self, value:int):
+        if not isinstance(value, int):
+            msg = "The file size must be an integer"
+            raise TypeError(
+                msg
+                )
+        self._file_size = value
+
+    @property
+    def downloaded_size(self):
+        """Size of the downloaded file."""
+        return self._downloaded_size
+
+    @downloaded_size.setter
+    def downloaded_size(self, value:int):
+        if not isinstance(value, int):
+            msg = "The file size must be an integer"
+            raise TypeError(
+                msg
+                )
+        self._downloaded_size = value
+
+    @property
+    def progress(self):
+        """Percentage of download."""
+        if self.file_size == 0:
+            return 0
+        return int(self.downloaded_size / self.file_size * 100)
+
+    def get_latest_release_info(self, extension=".exe"):
+        """
+        Retrieves the latest release information from GitHub, 
+        including the tag and the URL of the .exe file.
+
+        Returns:
+            tuple: A tuple containing the latest version tag and 
+            the URL of the .exe file, or (None, None) if an error occurs.
+        """
+        url = f"https://api.github.com/repos/{self.repo_owner}/{self.repo_name}/releases/latest"
+        try:
+            response = requests.get(url)
+            response.raise_for_status()  # Throws an exception for HTTP error codes
+            data = response.json()
+            tag_name = data.get("tag_name")
+            assets = data.get("assets", [])
+            exe_url = None
+            for asset in assets:
+                if asset.get("name", "").lower().endswith(extension):
+                    exe_url = asset.get("browser_download_url")
+                    break
+            return tag_name, exe_url
+        except requests.exceptions.RequestException as e:
+            print(f"Error while retrieving the latest version from GitHub : {e}")
+            return None, None
+
+    def check_updates(self):
+        """
+        Checks if an update is available.
+
+        Returns:
+            bool: True if an update is available, False otherwise.
+        """
+        latest_tag, exe_url = self.get_latest_release_info()
+        
+        if not latest_tag or not exe_url:
+            return False
+        
+        latest_version = Version(latest_tag.lstrip('v'))
+        current_version = Version(metadata.version)
+
+        return latest_version > current_version
+
+    def update_software(self):
+        """Updates the software by downloading the .exe file from GitHub."""
+        
+        print("Updating software...")
+        _, exe_url = self.get_latest_release_info()
+        if not exe_url:
+            print("No .exe file founded in the latest version.")
+            return
+        print(f"Downloading the new version from : {exe_url}")
+        
+        response = requests.get(exe_url, stream=True)
+        response.raise_for_status()
+        self.file_size = int(response.headers.get("content-length", 0))
+        
+        # Check if the program is an executable or a python file
+        if hasattr(sys, 'frozen'):
+            self.old_path = os.path.abspath(sys.executable) # .exe
+        else:
+            self.old_path = os.path.abspath(__file__) # .py
+        
+        # Define the directory and file path for the update
+        new_filename = str(os.path.basename(exe_url))
+        self.new_filedir = os.path.join(
+            os.path.dirname(self.old_path), 
+            self.dir_update
+            )
+        self.new_path = os.path.join(self.new_filedir, new_filename)
+        
+        # Create the directory if it doesn't exist
+        os.makedirs(self.new_filedir, exist_ok=True)
+        
+        # Display the progress bar
+        loading_window = LoadingWindow(self.about)
+        loading_window.show()
+        
+        # Download the updated file
+        with open(self.new_path, "wb") as f:
+            for chunk in response.iter_content(chunk_size=8192):
+                f.write(chunk)
+                self.downloaded_size += len(chunk)
+                loading_window.update_progress(self.progress)
+                print(f"Progress update : {self.progress}%", end="\r")
+        
+        loading_window.close()
+        print("Download of the update completed.")
+    
+    def show_file_location_message(self, file_path):
+        """Shows a message to the user about the new version."""
+        msg_box = QMessageBox()
+        txt = f"""
+        The update has been downloaded here :\n\n
+        {file_path}\n
+        You can delete the old version.
+        """
+        msg_box.setWindowTitle("Update completed")
+        msg_box.setText(txt)
+        msg_box.setIcon(QMessageBox.Information)
+        msg_box.setStandardButtons(QMessageBox.Ok)
+
+        # Display the message
+        msg_box.exec()
+

ytComments/metadata.py

@@ -0,0 +1,22 @@
+from configparser import ConfigParser
+from pathlib import Path
+
+def get_project_metadata():
+    """Metadata grabber from setup.cfg"""
+    config = ConfigParser()
+    setup_cfg = Path(__file__).parent.parent / "setup.cfg"
+    
+    with open(setup_cfg, "r", encoding="utf-8") as f:
+        config.read_file(f)
+    
+    return {
+        "version": config.get("metadata", "version"),
+        "author": config.get("metadata", "author"),
+        "name": config.get("metadata", "name"),
+        "description": config.get("metadata", "description"),
+        "url": config.get("metadata", "url"),
+        "license": config.get("metadata", "license"),
+    }
+
+# Initialize the globals variables for an easy import
+globals().update(get_project_metadata())

ytComments/settingsManager.py

@@ -0,0 +1,172 @@
+import json
+from pathlib import Path
+
+class Settings():
+    """Settings Manager to save and apply settings to the software."""
+    def __init__(self):
+        self._channel_url = 'https://www.youtube.com/@GabbPiano'
+        self._directory = Path.home() / 'Desktop'
+        self._bg_color = ('#C5D9F1', '#FDE9D9')
+        self._bg_highlight = True
+        self._max_sheets = 250
+        self._date_format = 'DD/MM/YYYY'
+        self._auto_update = True
+    
+    @property
+    def channel_url(self):
+        """URL of the YouTube channel."""
+        return self._channel_url
+    
+    @channel_url.setter
+    def channel_url(self, value: str):
+        if value == None:
+            return
+        elif not isinstance(value, str):
+            msg = 'The channel URL must be a string'
+            raise TypeError(msg)
+        self._channel_url = str(value)
+
+    @property
+    def directory(self):
+        """Directory where the files will be saved."""
+        return self._directory
+    
+    @directory.setter
+    def directory(self, value):
+        if value == None:
+            return
+        else:
+            path = Path(value)
+        
+        if path.exists() and path.is_dir():
+            self._directory = path
+        else:
+            raise ValueError(
+                f"The directory {value} does not exist"
+                )
+
+    @property
+    def bg_color(self):
+        """Hex color code for the background of the comments on Excel."""
+        return self._bg_color
+
+    @bg_color.setter
+    def bg_color(self, value):
+        if (len(value) != 2
+            or not isinstance(value, tuple)
+            or not isinstance(value[0], str)
+            or not isinstance(value[1], str)
+            ):
+            raise ValueError(
+                "The value must be a tuple of two strings"
+                )
+        elif not (value[0].startswith('#') and len(value[0]) == 7):
+            raise ValueError(
+                "The first value must be a valid hex color code"
+                )
+        elif not (value[1].startswith('#') and len(value[1]) == 7):
+            raise ValueError(
+                "The second value must be a valid hex color code"
+                )
+        self._bg_color = value
+
+    @property
+    def bg_highlight(self):
+        """Allow or not the background color to be highlighted."""
+        return self._bg_highlight
+
+    @bg_highlight.setter
+    def bg_highlight(self, value):
+        if not isinstance(value, bool):
+            return
+        self._bg_highlight = value
+
+    @property
+    def max_sheets(self):
+        """Maximum number of sheets per file to export."""
+        return self._max_sheets
+
+    @max_sheets.setter
+    def max_sheets(self, value):
+        if not isinstance(value, int):
+            raise ValueError(
+                "The maximum number of sheets must be an integer"
+                )
+        elif value < 2:
+            raise ValueError(
+                "The maximum number of sheets must be at least 2"
+                )
+        self._max_sheets = value
+
+    @property
+    def date_format(self):
+        """Format of the date in the comments."""
+        return self._date_format
+
+    @date_format.setter
+    def date_format(self, value):
+        if not isinstance(value, str):
+            raise ValueError(
+                "the date format must be a string. E.g: 'DD/MM/YY' ; 'YYYY-MM-DD'"
+                )
+        self._date_format = value
+
+    @property
+    def auto_update(self):
+        """Allow or not the program to search for software updates at startup."""
+        return self._auto_update
+
+    @auto_update.setter
+    def auto_update(self, value):
+        if not isinstance(value, bool):
+            return
+        self._auto_update = value
+
+    def path_save(self):
+        """Path to the saved parameters file."""
+        file = "yt_parameters.json"
+        folder = "Atem83"
+        path_file = Path.home() / "Documents" / folder / file
+        return path_file
+
+    def save(self):
+        """Save the parameters in a configuration file."""
+        settings = {
+            'channel_url': self.channel_url,
+            'directory': str(self.directory),
+            'bg_color': self.bg_color,
+            'bg_highlight': self.bg_highlight,
+            'max_sheets': self.max_sheets,
+            'date_format': self.date_format,
+            'auto_update': self.auto_update
+            }
+        path_file = self.path_save()
+
+        try:
+            # Create the folder if it doesn't exist
+            path_folder = Path(path_file).parent
+            path_folder.mkdir(parents=True, exist_ok=True)
+
+            # Write my backup
+            with open(path_file, 'w', encoding='utf-8') as file:
+                json.dump(settings, file, indent=4, ensure_ascii=False)
+        except:
+            print("Save failed.")
+            return
+
+    def load(self):
+        """Load the parameters from the configuration file."""
+        path_file = self.path_save()
+        try:
+            with open(path_file, "r", encoding='utf-8') as file:
+                settings = json.load(file)
+                self.channel_url = settings["channel_url"]
+                self.directory = settings["directory"]
+                self.bg_color = tuple(settings["bg_color"])
+                self.bg_highlight = settings["bg_highlight"]
+                self.max_sheets = settings["max_sheets"]
+                self.date_format = settings["date_format"]
+                self.auto_update = settings["auto_update"]
+        except:
+            print("Load failed, the parameters by default will be used.")
+            return