ok-script 2.0.0b5__tar.gz → 2.0.0b7__tar.gz

{ok_script-2.0.0b5/ok_script.egg-info → ok_script-2.0.0b7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ok-script
-Version: 2.0.0b5
+Version: 2.0.0b7
 Summary: Automation with Computer Vision for Python
 Author-email: ok-oldking <firedcto@gmail.com>
 Project-URL: Homepage, https://github.com/ok-oldking/ok-script
@@ -16,7 +16,7 @@ Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
 Requires-Dist: pywin32>=306
-Requires-Dist: pyappify>=1.0.6
+Requires-Dist: pyappify>=1.0.9
 Requires-Dist: typing-extensions>=4.11.0
 Requires-Dist: requests>=2.32.3
 Requires-Dist: psutil>=6.0.0

{ok_script-2.0.0b5 → ok_script-2.0.0b7}/ok/ui/qt/MainWindow.py

@@ -212,7 +212,7 @@ class MainWindow(FluentWindow):
                              position=NavigationItemPosition.BOTTOM)
 
         from ok.ui.qt.about.AboutTab import AboutTab
-        self.about_tab = AboutTab(config)
+        self.about_tab = AboutTab(config, exit_event=exit_event)
         self.addSubInterface(self.about_tab, FluentIcon.QUESTION, self.tr('About'),
                              position=NavigationItemPosition.BOTTOM)
         self.about_update_badge = None
@@ -526,14 +526,18 @@ class MainWindow(FluentWindow):
             self.shown = True
             pyappify.hide_pyappify()
             if update_pyappify := self.config.get("update_pyappify"):
-                pyappify.upgrade(update_pyappify.get('to_version'), update_pyappify.get('sha256'),
-                                 [update_pyappify.get('zip_url')], self.exit_event)
+                pyappify.upgrade(
+                    update_pyappify.get('to_version'),
+                    update_pyappify.get('sha256'),
+                    [update_pyappify.get('zip_url')],
+                    exit_event=self.exit_event,
+                )
             logger.info("Window has fully displayed")
             from ok import og
             og.ok.start_runtime()
             if self.basic_global_config.get(KILL_LAUNCHER_AFTER_START):
                 logger.info(f'MainWindow showEvent Kill Launcher After Start')
-                pyappify.kill_pyappify()
+                pyappify.kill_pyappify(exit_event=self.exit_event)
             startup_version_change = get_startup_version_change()
             if self.version != self.main_window_config.get('last_version'):
                 self.main_window_config['last_version'] = self.version
@@ -739,5 +743,5 @@ class MainWindow(FluentWindow):
                 self.executor.destroy()
             event.accept()
             if not self.do_not_quit:
-                pyappify.kill_pyappify()
+                pyappify.kill_pyappify(exit_event=self.exit_event)
                 QApplication.instance().exit()

{ok_script-2.0.0b5 → ok_script-2.0.0b7}/ok/ui/qt/about/AboutTab.py

@@ -16,7 +16,7 @@ logger = Logger.get_logger(__name__)
 
 
 class AboutTab(Tab):
-    def __init__(self, config, pyappify_module=None):
+    def __init__(self, config, pyappify_module=None, exit_event=None):
         super().__init__()
         if pyappify_module is None:
             import pyappify as pyappify_module
@@ -28,7 +28,9 @@ class AboutTab(Tab):
 
         self.update_card = None
         if callable(getattr(pyappify_module, 'get_version_list', None)):
-            self.update_card = UpdateCard(config.get('version'), pyappify_module, self)
+            self.update_card = UpdateCard(
+                config.get('version'), pyappify_module, self, exit_event=exit_event
+            )
             self.add_card(self.tr("App update"), self.update_card)
         else:
             logger.warning(

{ok_script-2.0.0b5 → ok_script-2.0.0b7}/ok/ui/qt/about/UpdateCard.py

@@ -51,13 +51,14 @@ class UpdateCard(QWidget):
     VERSION_COMBO_MIN_WIDTH = 100
     VERSION_COMBO_MAX_WIDTH = 240
 
-    def __init__(self, current_version, pyappify_module, parent=None):
+    def __init__(self, current_version, pyappify_module, parent=None, exit_event=None):
         super().__init__(parent)
         self.current_version = current_version or getattr(pyappify_module, "app_version", None) or ""
         if "PYAPPIFY_PYTHON_TEST" in os.environ and not _is_numeric_version(self.current_version):
             logger.info(f"using v0.0.0 for nonnumeric test version {self.current_version!r}")
             self.current_version = "v0.0.0"
         self.pyappify_module = pyappify_module
+        self.exit_event = exit_event
         self.versions = []
         self._busy = False
         logger.info(
@@ -125,7 +126,7 @@ class UpdateCard(QWidget):
         self._set_status(self.tr("Checking for updates…"))
         release_only = not self.test_version_checkbox.isChecked()
         self._run_in_background(
-            lambda: get_versions(release_only=release_only),
+            lambda: get_versions(release_only=release_only, exit_event=self.exit_event),
             self._versions_loaded,
             f"pyappify.get_version_list(release_only={release_only})",
         )
@@ -141,7 +142,7 @@ class UpdateCard(QWidget):
         self._set_busy(True)
         self._set_status(self.tr("Starting change to {version}…").format(version=version))
         self._run_in_background(
-            lambda: update_to_version(version),
+            lambda: update_to_version(version, exit_event=self.exit_event),
             self._update_finished,
             f"pyappify.update_to_version({version!r})",
         )

{ok_script-2.0.0b5 → ok_script-2.0.0b7}/ok/ui/web/app.py

@@ -705,7 +705,9 @@ class WebRuntime:
         try:
             module = self.pyappify_module
             logger.info("calling pyappify.get_version_list(release_only=%s)", release_only)
-            versions = module.get_version_list(release_only=release_only)
+            versions = module.get_version_list(
+                release_only=release_only, exit_event=self.ok.exit_event
+            )
             logger.info("pyappify.get_version_list result=%r", versions)
             if not isinstance(versions, list):
                 raise RuntimeError("PyAppify returned an invalid version list")
@@ -748,7 +750,7 @@ class WebRuntime:
             if not callable(operation):
                 raise RuntimeError("Updating is not supported by this PyAppify version")
             logger.info("calling pyappify.update_to_version(%r)", version)
-            result = operation(version)
+            result = operation(version, exit_event=self.ok.exit_event)
             logger.info("pyappify.update_to_version(%r) result=%r", version, result)
             return {"accepted": True, "version": version, "result": _json_value(result)}
         finally:

{ok_script-2.0.0b5 → ok_script-2.0.0b7}/ok/update/inline_ok_requirements.py

@@ -1,4 +1,5 @@
 import argparse
+import glob
 import os
 import re
 
@@ -31,19 +32,6 @@ def _deploy_includes_folder(deploy_entries, folder):
     return any(entry == folder or entry.startswith(f'{folder}/') for entry in deploy_entries)
 
 
-def _get_inlined_requirement_folders(repo_dir, inlined_requirements=None):
-    if inlined_requirements is None:
-        inlined_requirements = INLINED_REQUIREMENTS
-    deploy_entries = _read_deploy_entries(repo_dir)
-    if not deploy_entries:
-        return []
-    return [
-        package_folder
-        for package_folder in inlined_requirements.values()
-        if _deploy_includes_folder(deploy_entries, package_folder)
-    ]
-
-
 def _add_folders_to_deploy(repo_dir, folders):
     deploy_file = os.path.join(repo_dir, 'deploy.txt')
     deploy_entries = _read_deploy_entries(repo_dir)
@@ -92,13 +80,29 @@ def inline_site_packages(repo_dir, package_folders=None):
             raise RuntimeError(f'Failed to inline {package_folder} from site-packages')
 
 
+def _remove_inlined_requirements(repo_dir, package_names):
+    package_names = tuple(package_names)
+    if not package_names:
+        return
+    requirement_pattern = re.compile(
+        r'^\s*({})\b'.format('|'.join(re.escape(name) for name in package_names)),
+        re.IGNORECASE,
+    )
+    for file_path in glob.glob(os.path.join(repo_dir, 'requirements*.txt')):
+        with open(file_path, 'r', encoding='utf-8') as file:
+            lines = file.readlines()
+        filtered_lines = [line for line in lines if not requirement_pattern.match(line)]
+        with open(file_path, 'w', encoding='utf-8') as file:
+            file.writelines(filtered_lines)
+
+
 def remove_ok_requirements(repo_dir, tag, additional_inlined_requirements=None):
     inlined_requirements = dict(INLINED_REQUIREMENTS)
     if additional_inlined_requirements:
         inlined_requirements.update(additional_inlined_requirements)
-        _add_folders_to_deploy(repo_dir, additional_inlined_requirements.values())
 
-    package_folders = _get_inlined_requirement_folders(repo_dir, inlined_requirements)
+    package_folders = inlined_requirements.values()
+    _add_folders_to_deploy(repo_dir, package_folders)
     inline_site_packages(repo_dir, package_folders)
 
     config_file = get_file_in_path_or_cwd(repo_dir, 'config.py')
@@ -108,25 +112,12 @@ def remove_ok_requirements(repo_dir, tag, additional_inlined_requirements=None):
     with open(config_file, 'w', encoding='utf-8') as file:
         file.write(new_content)
 
-    file_path = os.path.join(repo_dir, 'requirements.txt')
-    with open(file_path, 'r', encoding='utf-8') as file:
-        lines = file.readlines()
-    inlined_packages = [
-        package_name
-        for package_name, package_folder in inlined_requirements.items()
-        if package_folder in package_folders
-    ]
-    if inlined_packages:
-        requirement_pattern = r'^\s*({})\b'.format('|'.join(re.escape(name) for name in inlined_packages))
-        filtered_lines = [line for line in lines if not re.match(requirement_pattern, line, re.IGNORECASE)]
-    else:
-        filtered_lines = lines
-    with open(file_path, 'w', encoding='utf-8') as file:
-        file.writelines(filtered_lines)
+    _remove_inlined_requirements(repo_dir, inlined_requirements.keys())
+
 
 def main(argv=None):
     parser = argparse.ArgumentParser(description='Inline deployment requirements.')
-    parser.add_argument('--tag', help='Set the application version and remove inlined packages from requirements.txt.')
+    parser.add_argument('--tag', help='Set the application version and remove inlined packages from requirements files.')
     parser.add_argument(
         '--add-inlined-requirement',
         action='append',
@@ -145,7 +136,7 @@ def main(argv=None):
     else:
         inlined_requirements = dict(INLINED_REQUIREMENTS)
         inlined_requirements.update(additional_inlined_requirements)
-        _add_folders_to_deploy(repo_dir, additional_inlined_requirements.values())
+        _add_folders_to_deploy(repo_dir, inlined_requirements.values())
         inline_site_packages(repo_dir, inlined_requirements.values())
 
 

{ok_script-2.0.0b5 → ok_script-2.0.0b7/ok_script.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ok-script
-Version: 2.0.0b5
+Version: 2.0.0b7
 Summary: Automation with Computer Vision for Python
 Author-email: ok-oldking <firedcto@gmail.com>
 Project-URL: Homepage, https://github.com/ok-oldking/ok-script
@@ -16,7 +16,7 @@ Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
 Requires-Dist: pywin32>=306
-Requires-Dist: pyappify>=1.0.6
+Requires-Dist: pyappify>=1.0.9
 Requires-Dist: typing-extensions>=4.11.0
 Requires-Dist: requests>=2.32.3
 Requires-Dist: psutil>=6.0.0

{ok_script-2.0.0b5 → ok_script-2.0.0b7}/ok_script.egg-info/requires.txt

@@ -1,5 +1,5 @@
 pywin32>=306
-pyappify>=1.0.6
+pyappify>=1.0.9
 typing-extensions>=4.11.0
 requests>=2.32.3
 psutil>=6.0.0

{ok_script-2.0.0b5 → ok_script-2.0.0b7}/pyproject.toml

@@ -27,7 +27,7 @@ classifiers = [
 ]
 dependencies = [
     "pywin32>=306",
-    "pyappify>=1.0.6",
+    "pyappify>=1.0.9",
     "typing-extensions>=4.11.0",
     "requests>=2.32.3",
     "psutil>=6.0.0",

{ok_script-2.0.0b5 → ok_script-2.0.0b7}/tests/test_inline_ok_requirements.py

@@ -11,9 +11,17 @@ def _write_repo_files(repo_dir, deploy_text=None):
         (repo_dir / "deploy.txt").write_text(deploy_text, encoding="utf-8")
 
 
-def test_remove_ok_requirements_skips_inline_and_removal_without_deploy_txt(tmp_path, monkeypatch):
+def test_remove_ok_requirements_always_includes_defaults_without_deploy_txt(tmp_path, monkeypatch):
     copied_folders = []
     _write_repo_files(tmp_path)
+    (tmp_path / "requirements-web.txt").write_text(
+        "ok-script==1.0.147\npyappify==1.0.3\nhttpx==0.28.1\n",
+        encoding="utf-8",
+    )
+    (tmp_path / "requirements-dev.txt").write_text(
+        "PYAPPIFY==1.0.3\npytest==8.4.1\n",
+        encoding="utf-8",
+    )
     monkeypatch.setattr(
         inline_ok_requirements,
         "find_and_copy_site_package",
@@ -22,14 +30,21 @@ def test_remove_ok_requirements_skips_inline_and_removal_without_deploy_txt(tmp_
 
     inline_ok_requirements.remove_ok_requirements(str(tmp_path), "v1.2.3")
 
-    assert copied_folders == []
+    assert copied_folders == ["ok", "pyappify"]
     assert (tmp_path / "requirements.txt").read_text(encoding="utf-8") == (
-        "ok-script==1.0.147\npyappify==1.0.3\nrequests==2.32.3\n"
+        "requests==2.32.3\n"
+    )
+    assert (tmp_path / "requirements-web.txt").read_text(encoding="utf-8") == (
+        "httpx==0.28.1\n"
     )
+    assert (tmp_path / "requirements-dev.txt").read_text(encoding="utf-8") == (
+        "pytest==8.4.1\n"
+    )
+    assert (tmp_path / "deploy.txt").read_text(encoding="utf-8") == "ok\npyappify\n"
     assert (tmp_path / "config.py").read_text(encoding="utf-8") == 'version = "v1.2.3"\n'
 
 
-def test_remove_ok_requirements_only_inlines_folders_listed_in_deploy_txt(tmp_path, monkeypatch):
+def test_remove_ok_requirements_adds_missing_defaults_to_deploy_txt(tmp_path, monkeypatch):
     copied_folders = []
     _write_repo_files(tmp_path, "src\nok\nrequirements.txt\n")
     monkeypatch.setattr(
@@ -40,9 +55,12 @@ def test_remove_ok_requirements_only_inlines_folders_listed_in_deploy_txt(tmp_pa
 
     inline_ok_requirements.remove_ok_requirements(str(tmp_path), "v1.2.3")
 
-    assert copied_folders == ["ok"]
+    assert copied_folders == ["ok", "pyappify"]
     assert (tmp_path / "requirements.txt").read_text(encoding="utf-8") == (
-        "pyappify==1.0.3\nrequests==2.32.3\n"
+        "requests==2.32.3\n"
+    )
+    assert (tmp_path / "deploy.txt").read_text(encoding="utf-8") == (
+        "src\nok\nrequirements.txt\npyappify\n"
     )
 
 
@@ -57,10 +75,11 @@ def test_remove_ok_requirements_matches_deploy_subpaths(tmp_path, monkeypatch):
 
     inline_ok_requirements.remove_ok_requirements(str(tmp_path), "v1.2.3")
 
-    assert copied_folders == ["pyappify"]
+    assert copied_folders == ["ok", "pyappify"]
     assert (tmp_path / "requirements.txt").read_text(encoding="utf-8") == (
-        "ok-script==1.0.147\nrequests==2.32.3\n"
+        "requests==2.32.3\n"
     )
+    assert (tmp_path / "deploy.txt").read_text(encoding="utf-8") == "pyappify/main.py\nok\n"
 
 
 def test_additional_inlined_requirement_is_added_to_deploy_and_removed(tmp_path, monkeypatch):
@@ -82,8 +101,10 @@ def test_additional_inlined_requirement_is_added_to_deploy_and_removed(tmp_path,
         "custom-package=custom_package",
     ])
 
-    assert copied_folders == ["custom_package"]
-    assert (tmp_path / "deploy.txt").read_text(encoding="utf-8") == "src\ncustom_package\n"
+    assert copied_folders == ["ok", "pyappify", "custom_package"]
+    assert (tmp_path / "deploy.txt").read_text(encoding="utf-8") == (
+        "src\nok\npyappify\ncustom_package\n"
+    )
     assert "custom-package" not in (tmp_path / "requirements.txt").read_text(encoding="utf-8")
 
 
@@ -104,5 +125,7 @@ def test_additional_inlined_requirement_does_not_duplicate_deploy_subpath(tmp_pa
         {"custom-package": "custom_package"},
     )
 
-    assert copied_folders == ["custom_package"]
-    assert (tmp_path / "deploy.txt").read_text(encoding="utf-8") == "custom_package/main.py\n"
+    assert copied_folders == ["ok", "pyappify", "custom_package"]
+    assert (tmp_path / "deploy.txt").read_text(encoding="utf-8") == (
+        "custom_package/main.py\nok\npyappify\n"
+    )

{ok_script-2.0.0b5 → ok_script-2.0.0b7}/tests/test_pyappify_startup_update.py

@@ -299,6 +299,7 @@ class TestPyappifyStartupUpdate(unittest.TestCase):
 
     def test_check_test_version_controls_release_filter(self):
         os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
+        import threading
         import time
         from PySide6.QtWidgets import QApplication
         from ok.ui.qt.about.UpdateCard import UpdateCard
@@ -308,7 +309,8 @@ class TestPyappifyStartupUpdate(unittest.TestCase):
             get_version_list=Mock(return_value=[]),
             is_greater_version=lambda left, right: self._version_tuple(left) > self._version_tuple(right),
         )
-        card = UpdateCard("v1.0.0", module)
+        exit_event = threading.Event()
+        card = UpdateCard("v1.0.0", module, exit_event=exit_event)
 
         for checked, expected_release_only in ((False, True), (True, False)):
             card.test_version_checkbox.setChecked(checked)
@@ -320,6 +322,7 @@ class TestPyappifyStartupUpdate(unittest.TestCase):
                 time.sleep(0.01)
             self.assertFalse(card._busy)
             self.assertEqual(expected_release_only, module.get_version_list.call_args.kwargs["release_only"])
+            self.assertIs(exit_event, module.get_version_list.call_args.kwargs["exit_event"])
 
         card.deleteLater()
         app.processEvents()
@@ -369,6 +372,36 @@ class TestPyappifyStartupUpdate(unittest.TestCase):
         card.deleteLater()
         app.processEvents()
 
+    def test_update_to_version_receives_exit_event(self):
+        os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
+        import threading
+        import time
+        from PySide6.QtWidgets import QApplication
+        from ok.ui.qt.about.UpdateCard import UpdateCard
+
+        app = QApplication.instance() or QApplication([])
+        exit_event = threading.Event()
+        update_to_version = Mock(return_value={"updated": True, "version": "v1.1.0"})
+        module = SimpleNamespace(
+            update_to_version=update_to_version,
+            is_greater_version=lambda left, right: self._version_tuple(left) > self._version_tuple(right),
+            calculate_update_notes=self._calculate_update_notes,
+        )
+        card = UpdateCard("v1.0.0", module, exit_event=exit_event)
+        card._apply_versions((True, [{"version": "v1.1.0", "update_note": ["one"]}]))
+
+        card.update_to_selected_version()
+        for _ in range(100):
+            app.processEvents()
+            if not card._busy:
+                break
+            time.sleep(0.01)
+
+        self.assertFalse(card._busy)
+        update_to_version.assert_called_once_with("v1.1.0", exit_event=exit_event)
+        card.deleteLater()
+        app.processEvents()
+
     def test_failed_request_shows_visible_error(self):
         os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
         import time

{ok_script-2.0.0b5 → ok_script-2.0.0b7}/tests/test_web_ui_pages.py

@@ -31,6 +31,7 @@ def make_runtime(tmp_path):
         config={"gui_title": "Test App", "version": "1.2.3", "debug": False, "links": {"github": "https://example.test"}},
         task_manager=manager,
         task_executor=SimpleNamespace(get_all_tasks=lambda: [], onetime_tasks=[], trigger_tasks=[]),
+        exit_event=Mock(),
     )
     runtime.icon_url = "/static/app-icon.png"
     runtime._schedule_manager = None
@@ -107,7 +108,7 @@ def test_web_update_check_returns_calculated_notes_in_one_result(tmp_path):
 
     result = runtime.check_for_updates(release_only=False)
 
-    get_versions.assert_called_once_with(release_only=False)
+    get_versions.assert_called_once_with(release_only=False, exit_event=runtime.ok.exit_event)
     assert result["current_version"] == "1.2.3"
     assert result["update_available"] is True
     assert result["versions"][0] == {"version": "v1.2.5", "notes": ["five", "four", "three"]}
@@ -120,7 +121,7 @@ def test_web_update_request_calls_pyappify(tmp_path):
 
     result = runtime.update_to_version("v1.2.4")
 
-    update.assert_called_once_with("v1.2.4")
+    update.assert_called_once_with("v1.2.4", exit_event=runtime.ok.exit_event)
     assert result["accepted"] is True
     assert result["version"] == "v1.2.4"