python-visual-update-express 1.0.0__py3-none-any.whl

python_visual_update_express/__init__.py

@@ -0,0 +1 @@
+from python_generic_updater.ui.updater_window import UpdaterWindow

python_visual_update_express/application.py

@@ -0,0 +1,18 @@
+from pathlib import Path
+
+from PyQt6.QtWidgets import QApplication
+
+from python_visual_update_express.data.general_settings import APP_STYLE
+from python_visual_update_express.ui.updater_window import UpdaterWindow
+
+TMP_UPDATE_BASE_URL = 'http://jelmerpijnappel.nl/releases/broers-optiek/lensplan-hulp-applicatie/'
+TMP_CURRENT_UPDATE_VERSION = '1.3.0'
+TMP_TARGET_DIR = str(Path(__file__).resolve().parent.parent / "target")
+
+app = QApplication([])
+app.setStyle(APP_STYLE)
+
+window = UpdaterWindow(TMP_UPDATE_BASE_URL, TMP_CURRENT_UPDATE_VERSION, TMP_TARGET_DIR)
+window.show()
+
+app.exec()

python_visual_update_express/data/general_info.py

@@ -0,0 +1,14 @@
+from dataclasses import dataclass
+
+from semver import Version
+
+
+# This object will be filled with the needed info during runtime
+@dataclass
+class GeneralInfo:
+    update_base_url: str
+    current_update_version: Version
+    target_directory_path: str
+
+
+info: GeneralInfo

python_visual_update_express/data/general_settings.py

@@ -0,0 +1,8 @@
+import os
+
+VERSION = '1.0.0'
+WINDOW_WIDTH = 400
+WINDOW_HEIGHT = 200
+ROOT_PATH = os.path.dirname(os.path.abspath(__file__)) + '/'
+APP_STYLE = 'Fusion'
+DEBUG_MODE = True

python_visual_update_express/libs/file_download.py

@@ -0,0 +1,17 @@
+from collections.abc import Callable
+from urllib import request
+
+
+def download_text_file(url: str) -> str:
+    with request.urlopen(url) as response:
+        return response.read().decode("utf-8")
+
+
+def download_file_to_location(base_url: str, file_path: str, destination_path: str,
+                              progress_callback: Callable[[int, int, int], object] = None) -> None:
+    destination = destination_path + file_path
+
+    # Replace spaces with url-encoded spaces because urlretrieve cannot handle spaces
+    download_url = (base_url + file_path).replace(' ', '%20')
+
+    request.urlretrieve(download_url, destination, progress_callback)

python_visual_update_express/libs/icons.py

@@ -0,0 +1,37 @@
+from dataclasses import dataclass
+from enum import Enum
+
+import qtawesome as qta
+from PyQt6.QtCore import QSize
+from PyQt6.QtGui import QColor
+
+
+class Icon(Enum):
+    CROSS_CIRCLE = 0
+    CHECKMARK_CIRCLE = 1
+
+
+@dataclass
+class IconProperties:
+    id: str
+    color: QColor = QColor(50, 50, 50)
+
+
+ICON_PROPERTIES = {
+    Icon.CROSS_CIRCLE: IconProperties('fa5s.times-circle', QColor('red')),
+    Icon.CHECKMARK_CIRCLE: IconProperties('fa5s.check-circle', QColor('green')),
+}
+
+
+class IconsLib:
+    @staticmethod
+    def get_icon(icon: Icon, size: QSize = QSize(30, 30)):
+        icons = [item.value for item in Icon]
+        if not icon.value in icons:
+            raise AssertionError('Icon "%s" could be found' % str(icon))
+        if not icon in ICON_PROPERTIES.keys():
+            raise AssertionError('Properties for icon "%s" could be found' % str(icon))
+
+        icon_props = ICON_PROPERTIES.get(icon)
+
+        return qta.icon(icon_props.id, color=icon_props.color, size=size)

python_visual_update_express/libs/threading.py

@@ -0,0 +1,31 @@
+from PyQt6.QtCore import QObject, pyqtSignal, QRunnable, pyqtSlot
+
+
+class WorkerSignals(QObject):
+    error = pyqtSignal(Exception)
+    finished = pyqtSignal()
+    success = pyqtSignal()
+    successResult = pyqtSignal(object)
+
+
+class Worker(QRunnable):
+    signals: WorkerSignals
+
+    def __init__(self, fn, *args, **kwargs):
+        super().__init__()
+        # Store constructor arguments (re-used for processing)
+        self.fn = fn
+        self.args = args
+        self.kwargs = kwargs
+        self.signals = WorkerSignals()
+
+    @pyqtSlot()
+    def run(self):
+        try:
+            result = self.fn(*self.args, **self.kwargs)
+            self.signals.success.emit()
+            self.signals.successResult.emit(result)
+        except Exception as ex:
+            self.signals.error.emit(ex)
+        finally:
+            self.signals.finished.emit()

python_visual_update_express/libs/update_manager.py

@@ -0,0 +1,49 @@
+import os
+from tempfile import TemporaryDirectory
+from typing import Union
+
+from PyQt6.QtCore import pyqtSignal, QObject
+
+from python_generic_updater.data import general_info
+from python_generic_updater.libs.file_download import download_file_to_location
+from python_generic_updater.libs.updates_info import UpdatesInfo
+
+DOWNLOADABLE_FILES_PATH = 'Updates/'
+
+
+class UpdateManager(QObject):
+    completed_steps: int = 0
+    step_percentage_increment: float
+
+    download_progress_update = pyqtSignal(float)
+
+    def download_update_files(self, info: UpdatesInfo, update_base_url: str) -> Union[TemporaryDirectory, None]:
+        steps = info.get_remaining_release_steps(general_info.info.current_update_version)
+
+        files_to_download = steps['files_to_download']
+        if len(files_to_download) <= 0:
+            return None
+
+        self.step_percentage_increment = 100.0 / len(files_to_download)
+
+        tmpdir = TemporaryDirectory()
+        tmpdir_path = os.path.join(tmpdir.name, '')  # This adds a trailing slash if it's missing
+
+        download_base_url = update_base_url + DOWNLOADABLE_FILES_PATH
+        for file in files_to_download:
+            download_file_to_location(download_base_url, file, tmpdir_path, self._update_download_progress)
+        return tmpdir
+
+    def _update_download_progress(self, block_num: int, block_size: int, total_size: int):
+        downloaded = block_num * block_size
+        if downloaded < total_size:
+            total_percentage_gain = downloaded / total_size * self.step_percentage_increment
+            progress_value = self._get_completion_percentage(total_percentage_gain)
+        else:
+            self.completed_steps += 1
+            progress_value = self._get_completion_percentage()
+
+        self.download_progress_update.emit(progress_value)
+
+    def _get_completion_percentage(self, offset: float = 0.0) -> float:
+        return self.completed_steps * self.step_percentage_increment + offset

python_visual_update_express/libs/updates_info.py

@@ -0,0 +1,86 @@
+import re
+from typing import List
+
+from semver import Version
+
+
+class UpdatesInfo:
+    release_versions: List[Version]  # Ordered list of versions from oldest to newest
+    release_version_step_lists: dict[str, dict]  # Steps needed per version
+    latest_version: Version
+
+    def __init__(self, updatescript: str):
+        self.release_versions = self._get_release_versions(updatescript)
+        self.latest_version = self.release_versions[-1] if self.release_versions else None
+        self.release_version_step_lists = self._get_all_release_steps(updatescript)
+
+    def get_remaining_release_steps(self, current_version: Version):
+        steps = {'files_to_download': []}
+
+        if current_version == self.release_versions[-1]:
+            return steps
+
+        current_version_index = self.release_versions.index(current_version)
+        newer_version_nrs = self.release_versions[current_version_index + 1:]
+        newer_versions_steps = []
+        for version_nr in newer_version_nrs:
+            version_str = str(version_nr)
+            newer_versions_steps.append(self.release_version_step_lists[version_str])
+
+        for step in newer_versions_steps:
+            steps['files_to_download'].extend(step['files_to_download'])
+
+        # Remove duplicates by converting to a set and back (since set keys cannot be duplicate)
+        steps['files_to_download'] = list(set(steps['files_to_download']))
+
+        return steps
+
+    def _get_release_versions(self, updatescript: str) -> List[Version]:
+        match = re.search(r"releases\{([^}]*)}", updatescript, re.DOTALL)
+        if not match:
+            return []
+
+        block_content = match.group(1)
+
+        versions = []
+        for line in block_content.splitlines():
+            if line.strip():
+                try:
+                    version = Version.parse(line.strip())
+                except:
+                    continue
+
+                versions.append(version)
+
+        versions.sort()
+        return versions
+
+    def _get_all_release_steps(self, updatescript: str) -> dict:
+        release_steps = {}
+
+        matches = re.findall(r"release:(.*?)\{([^}]*)}", updatescript)
+        if not matches:
+            return {}
+
+        for match in matches:
+            version_nr = match[0]
+            block_content = match[1]
+
+            step = {
+                'files_to_download': self._get_filenames_to_download(block_content)
+            }
+
+            release_steps[version_nr] = step
+
+        return release_steps
+
+    def _get_filenames_to_download(self, step_content: str) -> List[str]:
+        matches = re.findall(r"DownloadFile:(.*?)\n", step_content)
+        if not matches:
+            return []
+
+        filenames = []
+        for match in matches:
+            filenames.append(match)
+
+        return filenames

python_visual_update_express/ui/error_handling.py

@@ -0,0 +1,12 @@
+import traceback
+
+from python_generic_updater.data.general_settings import DEBUG_MODE
+from python_generic_updater.ui.notifications import error_notification
+
+
+def process_error(ex: Exception, self=None) -> None:
+    # Enable below line for debugging
+    if DEBUG_MODE:
+        error_notification(''.join(traceback.format_exception(type(ex), ex, ex.__traceback__)), self)
+    else:
+        error_notification(str(ex), self)

python_visual_update_express/ui/notifications.py

@@ -0,0 +1,13 @@
+from PyQt6.QtWidgets import QMessageBox
+
+ERROR_TITLE = 'An error has occurred'
+
+
+def error_notification(text: str, self: any = None) -> None:
+    print(text)
+    QMessageBox.critical(self, ERROR_TITLE, text)
+
+
+def warning_notification(text: str, self: any = None) -> None:
+    print(text)
+    QMessageBox.warning(self, ERROR_TITLE, text)

python_visual_update_express/ui/status_text_widget.py

@@ -0,0 +1,82 @@
+from PyQt6.QtCore import Qt
+from PyQt6.QtGui import QColor
+from PyQt6.QtWidgets import QWidget, QLabel, QHBoxLayout
+from pyqtwaitingspinner import WaitingSpinner, SpinnerParameters, SpinDirection
+from qtawesome import IconWidget
+
+from python_generic_updater.libs.icons import IconsLib, Icon
+
+SPINNER_PARAMS = SpinnerParameters(  # These can be generated in the spinner editor `spinner-conf`
+    roundness=100.0,
+    trail_fade_percentage=50.0,
+    number_of_lines=13,
+    line_length=5,
+    line_width=2,
+    inner_radius=3,
+    revolutions_per_second=1.57,
+    color=QColor(80, 80, 80),
+    minimum_trail_opacity=3.14,
+    spin_direction=SpinDirection.CLOCKWISE,
+    center_on_parent=True,
+    disable_parent_when_spinning=False,
+)
+SPINNER_WIDGET_WIDTH = 30
+SPINNER_WIDGET_HEIGHT = 30
+MAX_TEXT_WIDTH = 300
+
+
+class StatusTextWidget(QWidget):
+    icon: IconWidget
+    status_text: QLabel
+    spinner_widget: QWidget
+    spinner: WaitingSpinner
+
+    def __init__(self):
+        super().__init__()
+
+        layout = QHBoxLayout()
+        layout.setAlignment(Qt.AlignmentFlag.AlignHCenter)
+
+        self.icon = IconWidget()
+        layout.addWidget(self.icon)
+        layout.addSpacing(5)
+
+        self.status_text = QLabel()
+        self.status_text.setFixedHeight(
+            SPINNER_WIDGET_HEIGHT)  # Prevents vertical repositioning when spinner is activated
+        layout.addWidget(self.status_text)
+
+        self.spinner_widget = QWidget()
+        self.spinner = WaitingSpinner(self.spinner_widget, SPINNER_PARAMS)
+        self.set_spinner_active(False)
+        layout.addWidget(self.spinner_widget)
+
+        self.setLayout(layout)
+
+    def set_spinner_active(self, active: bool):
+        if active:
+            self.spinner.start()
+            self.spinner_widget.setFixedSize(SPINNER_WIDGET_WIDTH, SPINNER_WIDGET_HEIGHT)
+        else:
+            self.spinner.stop()
+            self.spinner_widget.setFixedSize(0, 0)
+
+    def set_status(self, status: str, spinner: bool = False, icon: Icon = None):
+        self.status_text.setWordWrap(False)  # Disable word wrap for determining correct size hint
+        self.status_text.setText(status)
+        self.status_text.setStyleSheet('')
+        width = min(self.status_text.sizeHint().width(), MAX_TEXT_WIDTH)
+        self.status_text.setFixedWidth(width)
+        self.status_text.setWordWrap(True)
+        self.set_spinner_active(spinner)
+        if icon:
+            self.icon.setIcon(IconsLib.get_icon(icon))
+
+    def set_warning_status(self, status: str):
+        self.status_text.setText(status)
+        self.status_text.setStyleSheet('color: red;')
+
+    def reset_status(self):
+        self.status_text.setText('')
+        self.status_text.setStyleSheet('')
+        self.set_spinner_active(False)

python_visual_update_express/ui/updater_window.py

@@ -0,0 +1,59 @@
+from PyQt6.QtCore import QThreadPool, Qt, QSize
+from PyQt6.QtGui import QGuiApplication
+from PyQt6.QtWidgets import QMainWindow, QVBoxLayout, QWidget
+from semver import Version
+
+from python_generic_updater.data import general_info
+from python_generic_updater.data.general_info import GeneralInfo
+from python_generic_updater.data.general_settings import VERSION, WINDOW_WIDTH, WINDOW_HEIGHT
+from python_generic_updater.ui.window_content import WindowContent
+
+VERSION_PREFIX = 'v. '
+
+
+class UpdaterWindow(QMainWindow):
+    window_content: WindowContent
+
+    threadpool: QThreadPool
+    centered_on_init: bool = False
+
+    def __init__(self, update_base_url: str, current_update_version: str, target_directory_path: str) -> None:
+        super().__init__()
+
+        # GENERAL INFO
+        general_info.info = GeneralInfo(
+            update_base_url=update_base_url,
+            current_update_version=Version.parse(current_update_version),
+            target_directory_path=target_directory_path
+        )
+
+        # WINDOW
+        self.setWindowTitle('Updater ' + VERSION_PREFIX + VERSION)
+        self.setFixedSize(QSize(WINDOW_WIDTH, WINDOW_HEIGHT))
+
+        layout = QVBoxLayout()
+        layout.setContentsMargins(0, 0, 0, 0)
+        layout.setAlignment(Qt.AlignmentFlag.AlignCenter)
+
+        # CENTER CONTENT
+        self.window_content = WindowContent()
+        self.window_content.quit_triggered.connect(self.close)
+        layout.addWidget(self.window_content)
+
+        # INITIALIZATION
+        widget = QWidget()
+        widget.setLayout(layout)
+
+        self.setCentralWidget(widget)
+        self.threadpool = QThreadPool()
+
+    # Adjust screen position on resize to center it after resizing in initialization
+    def resizeEvent(self, event) -> None:
+        if self.centered_on_init:
+            return
+
+        center = QGuiApplication.primaryScreen().geometry().center()
+        self.move(center - self.rect().center())
+
+        self.centered_on_init = True
+        return super().resizeEvent(event)

python_visual_update_express/ui/window_content.py

@@ -0,0 +1,227 @@
+import shutil
+from enum import Enum
+from tempfile import TemporaryDirectory
+
+from PyQt6.QtCore import Qt, QThreadPool, pyqtSignal
+from PyQt6.QtWidgets import QWidget, QVBoxLayout, QLayout, QPushButton, QHBoxLayout, QProgressBar
+
+from python_generic_updater.data import general_info
+from python_generic_updater.libs.file_download import download_text_file
+from python_generic_updater.libs.icons import Icon
+from python_generic_updater.libs.threading import Worker
+from python_generic_updater.libs.update_manager import UpdateManager
+from python_generic_updater.libs.updates_info import UpdatesInfo
+from python_generic_updater.ui.error_handling import process_error
+from python_generic_updater.ui.status_text_widget import StatusTextWidget
+
+TEXT_INITIAL_STATUS = 'Ready to update'
+TEXT_CHECKING_FOR_UPDATE = 'Checking for update...'
+TEXT_UP_TO_DATE = 'Your application is already up to date'
+TEXT_UPDATE_IS_AVAILABLE_TEMPLATE = 'Newer version "{}" has been found and can be downloaded'
+TEXT_UPDATE_CANCELED = 'Update has been canceled'
+TEXT_DOWNLOADING = 'Downloading update...'
+TEXT_INSTALLING_UPDATE = 'Installing update...'
+TEXT_UPDATE_COMPLETE_TEMPLATE = 'Application has been updated to version {}'
+
+UPDATESCRIPT_FILENAME = 'updatescript.ini'
+
+
+class ContentState(Enum):
+    CHECK_FOR_UPDATE = 0
+    UPDATE_AVAILABLE = 1
+    UP_TO_DATE = 2
+    RUN_UPDATE = 3
+    INSTALL_UPDATE = 4
+    UPDATE_COMPLETE = 5
+    UPDATE_FAILED = 6
+    UPDATE_CANCELED = 7
+
+
+class WindowContent(QWidget):
+    current_state: ContentState
+    update_failed_text: str = ''
+    updates_info: UpdatesInfo
+    progress_bar: QProgressBar
+    download_directory: TemporaryDirectory
+
+    layout: QVBoxLayout = None
+    update_manager: UpdateManager
+    threadpool: QThreadPool
+
+    quit_triggered = pyqtSignal()
+
+    def __init__(self) -> None:
+        super().__init__()
+
+        self.layout = QVBoxLayout()
+        self.layout.setContentsMargins(10, 10, 10, 5)
+        self.layout.setAlignment(Qt.AlignmentFlag.AlignVCenter)
+        self.setLayout(self.layout)
+
+        self.update_manager = UpdateManager()
+        self.threadpool = QThreadPool()
+
+        self._load_content_by_state(ContentState.CHECK_FOR_UPDATE)
+
+    def _load_content_by_state(self, state: ContentState) -> None:
+        current_state = state
+
+        self._clear_layout(self.layout)
+        status_text = StatusTextWidget()
+        self.layout.addStretch()
+        self.layout.addWidget(status_text)
+
+        match current_state:
+            case ContentState.CHECK_FOR_UPDATE:
+                status_text.set_status(TEXT_CHECKING_FOR_UPDATE, True)
+                self.layout.addStretch()
+                self._start_update_check()
+
+            case ContentState.UPDATE_FAILED:
+                status_text.set_status(self.update_failed_text, icon=Icon.CROSS_CIRCLE)
+                self.layout.addStretch()
+                self._add_quit_button(self.layout)
+
+            case ContentState.UP_TO_DATE:
+                status_text.set_status(TEXT_UP_TO_DATE, icon=Icon.CHECKMARK_CIRCLE)
+                self.layout.addStretch()
+                self._add_quit_button(self.layout)
+
+            case ContentState.UPDATE_AVAILABLE:
+                update_text = TEXT_UPDATE_IS_AVAILABLE_TEMPLATE.format(self.updates_info.latest_version)
+                status_text.set_status(update_text)
+                self.layout.addStretch()
+                self._add_download_button_bar(self.layout)
+
+            case ContentState.UPDATE_CANCELED:
+                status_text.set_status(TEXT_UPDATE_CANCELED)
+                self.layout.addStretch()
+                self._add_quit_button(self.layout)
+
+            case ContentState.RUN_UPDATE:
+                status_text.set_status(TEXT_DOWNLOADING)
+                self._add_download_progress_bar(self.layout)
+                self.layout.addStretch()
+                self._start_update_download()
+
+            case ContentState.INSTALL_UPDATE:
+                status_text.set_status(TEXT_INSTALLING_UPDATE)
+                self.layout.addStretch()
+                self._install_update()
+
+            case ContentState.UPDATE_COMPLETE:
+                text = TEXT_UPDATE_COMPLETE_TEMPLATE.format(self.updates_info.latest_version)
+                status_text.set_status(text)
+                self.layout.addStretch()
+                self._add_quit_button(self.layout)
+
+    def _clear_layout(self, layout) -> None:
+        if isinstance(layout, QLayout):
+            while layout.count():
+                item = layout.takeAt(0)
+                widget = item.widget()
+                if widget is not None:
+                    widget.deleteLater()
+                else:
+                    self._clear_layout(item.layout())
+
+    def _start_update_check(self) -> None:
+        checker = Worker(self._fetch_updatescript, general_info.info.update_base_url)
+        checker.signals.successResult.connect(self._process_updatescript)
+        checker.signals.error.connect(process_error)
+        self.threadpool.start(checker)
+
+    def _fetch_updatescript(self, url: str) -> None:
+        fetch_url = url + UPDATESCRIPT_FILENAME
+        return download_text_file(fetch_url)
+
+    def _process_updatescript(self, updatescript: str) -> None:
+        try:
+            self.updates_info = UpdatesInfo(updatescript)
+        except Exception as ex:
+            process_error(ex, self)
+            self._fail_update(
+                'Failed to parse update info from the update script. Please inform the developer of this error.')
+            return
+
+        current_version = general_info.info.current_update_version
+        if not current_version in self.updates_info.release_versions:
+            self._fail_update(
+                'Current version not supported by the update script. Please inform the developer of this error.')
+            return
+
+        if current_version != self.updates_info.latest_version:
+            self._load_content_by_state(ContentState.UPDATE_AVAILABLE)
+        else:
+            self._load_content_by_state(ContentState.UP_TO_DATE)
+
+    def _add_quit_button(self, layout: QVBoxLayout) -> None:
+        quit_button_bar = QWidget()
+        h_layout = QHBoxLayout()
+        quit_button_bar.setLayout(h_layout)
+
+        h_layout.addStretch()
+        quit_button = QPushButton('Quit')
+        quit_button.clicked.connect(self.quit_triggered.emit)
+        h_layout.addWidget(quit_button)
+
+        layout.addWidget(quit_button_bar)
+
+    def _add_download_button_bar(self, layout: QVBoxLayout) -> None:
+        button_bar = QWidget()
+        bar_layout = QHBoxLayout()
+        bar_layout.addStretch()
+        button_bar.setLayout(bar_layout)
+
+        cancel_button = QPushButton('Cancel')
+        cancel_button.clicked.connect(lambda: self._load_content_by_state(ContentState.UPDATE_CANCELED))
+        download_button = QPushButton('Download and install')
+        download_button.clicked.connect(lambda: self._load_content_by_state(ContentState.RUN_UPDATE))
+
+        bar_layout.addWidget(cancel_button)
+        bar_layout.addWidget(download_button)
+        layout.addWidget(button_bar)
+
+    def _add_download_progress_bar(self, layout: QVBoxLayout) -> None:
+        self._add_progress_bar(layout)
+        self.update_manager.download_progress_update.connect(self._update_progress_bar)
+
+    def _add_progress_bar(self, layout: QVBoxLayout) -> None:
+        self.progress_bar = QProgressBar()
+        self.progress_bar.setRange(0, 100)
+        layout.addWidget(self.progress_bar)
+        layout.addStretch()
+
+    def _start_update_download(self) -> None:
+        error_text_base = 'An error occurred while downloading. Please inform the developer of this error: '
+
+        updater = Worker(self._download_update)
+        updater.signals.successResult.connect(self._complete_download_step)
+        updater.signals.error.connect(lambda ex: self._fail_update(error_text_base + str(ex)))
+        self.threadpool.start(updater)
+
+    def _download_update(self) -> TemporaryDirectory:
+        download_directory = self.update_manager.download_update_files(
+            self.updates_info,
+            general_info.info.update_base_url)
+
+        if not download_directory:
+            raise RuntimeError('Files to download are unknown')
+
+        return download_directory
+
+    def _update_progress_bar(self, progress_value: float) -> None:
+        progress_value_int = int(progress_value)
+        self.progress_bar.setValue(progress_value_int)
+
+    def _complete_download_step(self, downloaded_files_dir: TemporaryDirectory):
+        self.download_directory = downloaded_files_dir
+        self._load_content_by_state(ContentState.INSTALL_UPDATE)
+
+    def _install_update(self):
+        shutil.copytree(self.download_directory.name, general_info.info.target_directory_path, dirs_exist_ok=True)
+        self._load_content_by_state(ContentState.UPDATE_COMPLETE)
+
+    def _fail_update(self, fail_text: str) -> None:
+        self.update_failed_text = fail_text
+        self._load_content_by_state(ContentState.UPDATE_FAILED)

python_visual_update_express-1.0.0.dist-info/METADATA

@@ -0,0 +1,84 @@
+Metadata-Version: 2.4
+Name: python-visual-update-express
+Version: 1.0.0
+Summary: A dialog for updating specific files by syncing them from a server. Designed to work like InstallForge's "Visual Update Express".
+Project-URL: Homepage, https://github.com/ChocolatePinecone/python-generic-updater
+Project-URL: Issues, https://github.com/ChocolatePinecone/python-generic-updater/issues
+Author-email: Jelmer Pijnappel <chocolatepinecone@gmail.com>
+License-File: LICENSE
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# Python Visual Update Express
+
+A dialog for updating an application by downloading files from a server. Designed to work like InstallForge's "Visual
+Update Express".
+
+This software may only be used as described in the LICENSE file. Please contact me through a github issue for questions
+about commercial use.
+
+Compatible with Python 3.10 and up
+
+## Installation
+
+```sh
+python3 -m pip install python-visual-update-express
+```
+
+## Usage
+
+### Add updater window in python
+
+Import the UpdaterWindow and configure it
+
+```python
+from python_visual_update_express import UpdaterWindow
+
+UPDATE_BASE_URL = 'https://yoursite.com/releases/yourapplication/'
+CURRENT_VERSION = '1.0.1'
+UPDATE_TARGET_DIR = 'C:/yourlocationpath'
+
+updater_window = UpdaterWindow(UPDATE_BASE_URL, CURRENT_VERSION, UPDATE_TARGET_DIR)
+```
+
+Then when you are ready, simply call `show` on the window to start the updater:
+
+```python
+updater_window.show()
+```
+
+### Update script
+
+The updater works according to an updatescript.ini file on the server.
+This file tells the updater what versions of the application are supported and how to perform updates.
+Make sure to have this file available on the server URL used by the updater.
+
+This is a very simple example of an updatescript.ini:
+
+```javascript
+releases{
+    1.0.0
+    1.0.1
+}
+
+release:1.0.0{
+
+}
+
+release:1.0.1{
+    DownloadFile:some-file.txt
+}
+```
+
+#### Script commands
+
+Currently only 1 command is available:
+
+##### DownloadFile
+
+This command will download a file on the speficied path, starting from the given update base URL + 'Updates/'.
+So if for example the base URL of `https://yoursite.com/releases/yourapplication/` has been configured, a `DownloadFile:
+dir1/some-file.txt` will download the file from
+`https://yoursite.com/releases/yourapplication/Updates/dir1/some-file.txt`

python_visual_update_express-1.0.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+python_visual_update_express/__init__.py,sha256=dARMO0afc-UpUd6zSNyBGDa73tobmwjAZh9oPf7SSjo,68
+python_visual_update_express/application.py,sha256=c-Zfo_tWfB1aBa2_k6lViOb1otgbqFcsrs464re07uY,586
+python_visual_update_express/data/general_info.py,sha256=Gh6ABo3SZ1EGh34guU90uUbtys8rRqciYZzQfQtkXak,285
+python_visual_update_express/data/general_settings.py,sha256=vYWr1croCKrYMTKGzLu56vwQF8WG-SujO_JPFsLRQsI,176
+python_visual_update_express/libs/file_download.py,sha256=HJ1BDAUTSkjnDLsZbLzla9b05voXy1xkv49aUACIAmg,667
+python_visual_update_express/libs/icons.py,sha256=jTLMNPtboajtT2Rhs4wodPI_0-561RdwE8W_-QLCMbg,1020
+python_visual_update_express/libs/threading.py,sha256=AyCWuMEHA9Rvn5lxAnLk7eqh9JXictvm9ONQmFwtwVM,857
+python_visual_update_express/libs/update_manager.py,sha256=zi_npKq7QGvdkT6toKs3TtiFeR8aby-_96GiWMrVE2I,2005
+python_visual_update_express/libs/updates_info.py,sha256=tA2O180UV3Q0gsDAeza33yo7lGJWtBxyH62R7jZQiMk,2889
+python_visual_update_express/ui/error_handling.py,sha256=2UEdGopWlqUu3d930_hFkn423M2r_2juuT-XYegVWX4,435
+python_visual_update_express/ui/notifications.py,sha256=uGT83XI9xwLz13vo1oPiaBcTZeyEjtIkyl1jfjQmDq0,338
+python_visual_update_express/ui/status_text_widget.py,sha256=g3ud_ssPuGQ1rnKuyMVUSMY-tfhtiDDAJFARYVD9POs,2754
+python_visual_update_express/ui/updater_window.py,sha256=sHFXolVNzJLJ7cGxbaOge77KBXjHskYOFbBftUFHNv0,2013
+python_visual_update_express/ui/window_content.py,sha256=UpBBzCV6bTyamVctyRyB8iTIQvvxes-mfdr6YeV6oKM,9001
+python_visual_update_express-1.0.0.dist-info/METADATA,sha256=nTqw6q0RhqTRVl5P4PgfA45TfiGzJwtgDYWz8K-LgM8,2430
+python_visual_update_express-1.0.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+python_visual_update_express-1.0.0.dist-info/licenses/LICENSE,sha256=8XfFtZzNlgbVIWPbv6B-Nmmptkxh4-B0h7YDKShpxAY,364
+python_visual_update_express-1.0.0.dist-info/RECORD,,

python_visual_update_express-1.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

python_visual_update_express-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,9 @@
+Copyright (c) 2026 Jelmer Pijnappel
+
+Permission is granted to use, copy, and modify this software
+for personal or internal business use, provided that attribution
+to the original author is given.
+
+Commercial redistribution, sublicensing, or sale of this software,
+in whole or in part, is not permitted without explicit written
+permission from the author.