ok-script 0.0.49__tar.gz → 0.0.50__tar.gz

{ok-script-0.0.49 → ok-script-0.0.50}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ok-script
-Version: 0.0.49
+Version: 0.0.50
 Summary: Automation with Computer Vision for Python
 Home-page: https://github.com/ok-oldking/ok-script
 Author: ok-oldking
@@ -21,6 +21,7 @@ Requires-Dist: PySide6-Fluent-Widgets>=1.5.6
 Requires-Dist: psutil>=5.9.8
 Requires-Dist: opencv-python>=4.9.0.80
 Requires-Dist: ok-d3dshot>=0.1.5
+Requires-Dist: py7zr>=0.21.0
 
 # ok-script
 

{ok-script-0.0.49 → ok-script-0.0.50}/ok/capture/adb/DeviceManager.py

@@ -1,12 +1,10 @@
 import threading
 
 import win32gui
-from adbutils import AdbError
 
 from ok.capture.HwndWindow import HwndWindow, find_hwnd_by_title_and_exe
 from ok.capture.adb.ADBCaptureMethod import ADBCaptureMethod, do_screencap
 from ok.capture.adb.WindowsCaptureFactory import update_capture_method
-from ok.capture.adb.vbox import installed_emulator
 from ok.capture.windows.window import get_window_bounds
 from ok.config.Config import Config
 from ok.gui.Communicate import communicate
@@ -36,8 +34,7 @@ class DeviceManager:
                              "DeviceManager")
         self.thread = None
         self.capture_method = None
-        self.update_pc_device()
-        self.start()
+        self.refresh()
 
     def refresh(self):
         if self.thread is None or not self.thread.is_alive():
@@ -121,6 +118,7 @@ class DeviceManager:
             return
         if not fast:
             self.connect_all()
+        from ok.capture.adb.vbox import installed_emulator
         installed_emulators = [] if fast else installed_emulator()
         for device in self.adb.list():
             logger.debug(f'adb.list() {device}')
@@ -295,6 +293,7 @@ class DeviceManager:
     def shell(self, *args, **kwargs):
         device = self.device
         if device is not None:
+            from adbutils import AdbError
             try:
                 return device.shell(*args, **kwargs)
             except AdbError as e:

{ok-script-0.0.49 → ok-script-0.0.50}/ok/gui/App.py

@@ -13,6 +13,7 @@ from ok.gui.MessageWindow import MessageWindow
 from ok.gui.i18n.path import i18n_path
 from ok.gui.overlay.OverlayWindow import OverlayWindow
 from ok.logging.Logger import get_logger
+from ok.update.Updater import Updater
 
 logger = get_logger(__name__)
 
@@ -32,6 +33,8 @@ class App:
         self.app.setAttribute(Qt.AA_DontCreateNativeWidgetSiblings)
         qconfig.theme = Theme.AUTO
 
+        self.updater = Updater(self.config, exit_event)
+
         self.about = self.config.get('about')
         self.title = self.config.get('gui_title')
         self.version = self.config.get('version')
@@ -75,8 +78,9 @@ class App:
         self.show_message_window(title, content)
 
     def show_main_window(self):
-        self.main_window = MainWindow(self.icon, self.overlay, self.about, exit_event=self.exit_event)
-        self.main_window.setWindowTitle(f'{self.title} {self.version}')  # Set the window title here
+        self.main_window = MainWindow(self.icon, self.title, self.version, self.overlay, self.about,
+                                      exit_event=self.exit_event)
+        # Set the window title here
         self.main_window.setWindowIcon(self.icon)
         if self.overlay and ok.gui.device_manager.hwnd is not None:
             self.overlay_window = OverlayWindow(ok.gui.device_manager.hwnd)

{ok-script-0.0.49 → ok-script-0.0.50}/ok/gui/Communicate.py

@@ -20,6 +20,8 @@ class Communicate(QObject):
     config_validation: Signal = Signal(str)
     tab = Signal(str)
     capture_error = Signal()
+    check_update = Signal()
+    download_update = Signal(float, str, str, bool)
 
     def emit_draw_box(self, key: str = None, boxes=None, color=None, frame=None):
         self.draw_box.emit(key, boxes, color, frame)

{ok-script-0.0.49 → ok-script-0.0.50}/ok/gui/MainWindow.py

@@ -20,7 +20,7 @@ class Communicate(QObject):
 
 
 class MainWindow(MSFluentWindow):
-    def __init__(self, icon, debug=False, about=None, exit_event=None):
+    def __init__(self, icon, title, version, debug=False, about=None, exit_event=None):
         super().__init__()
         self.exit_event = exit_event
         self.start_tab = StartTab()
@@ -42,11 +42,11 @@ class MainWindow(MSFluentWindow):
         #     self.addSubInterface(debug_tab, FluentIcon.COMMAND_PROMPT, self.tr('Debug'))
         # ... Add other tabs similarly
         if about:
-            about_tab = AboutTab(about)
+            about_tab = AboutTab(icon, title, version, about)
             self.addSubInterface(about_tab, FluentIcon.QUESTION, self.tr('About'),
                                  position=NavigationItemPosition.BOTTOM)
         # Styling the tabs and content if needed, for example:
-        self.setWindowTitle("Close Event Example")
+        self.setWindowTitle(f'{title} {version}')
 
         communicate.executor_paused.connect(self.executor_paused)
         communicate.tab.connect(self.navigate_tab)

ok-script-0.0.50/ok/gui/about/AboutTab.py

@@ -0,0 +1,135 @@
+from PySide6.QtCore import Qt
+from PySide6.QtWidgets import QHBoxLayout, QLabel
+from qfluentwidgets import TextEdit, PushButton, InfoBar, InfoBarPosition, ProgressBar
+
+import ok.gui
+from ok.capture.windows.dump import dump_threads
+from ok.gui.Communicate import communicate
+from ok.gui.about.VersionCard import VersionCard
+from ok.gui.widget.Tab import Tab
+
+
+class AboutTab(Tab):
+    def __init__(self, icon, title, version, about):
+        super().__init__()
+        self.version_card = VersionCard(icon, title, version, self)
+        # Create a QTextEdit instance
+        self.addWidget(self.version_card, align=Qt.AlignCenter)
+        if ok.gui.app.updater.enabled():
+            self.update_hbox = QHBoxLayout()
+            self.update_hbox.addStretch()
+            self.check_update_button = PushButton(self.tr("Check for updates"))
+            self.check_update_button.clicked.connect(self.check_update)
+            self.update_hbox.addWidget(self.check_update_button)
+            self.download_latest_button = PushButton()
+            self.download_latest_button.clicked.connect(self.download_latest)
+
+            self.update_hbox.addWidget(self.download_latest_button)
+            self.download_stable_button = PushButton(self.tr("Download stable version {version}").format(version=1))
+            self.download_stable_button.clicked.connect(self.download_stable)
+
+            self.update_hbox.addWidget(self.download_stable_button)
+
+            self.download_bar = ProgressBar(self)
+            self.download_bar.setFixedWidth(200)
+            self.update_hbox.addWidget(self.download_bar)
+
+            self.downloading_text = QLabel()
+            self.update_hbox.addWidget(self.downloading_text)
+
+            self.update_hbox.addStretch()
+            self.addLayout(self.update_hbox)
+            communicate.download_update.connect(self.download_update)
+            communicate.check_update.connect(self.update_update)
+            self.update_update_buttons(0)
+        text_edit = TextEdit()
+        text_edit.setHtml(about)
+        text_edit.setReadOnly(True)
+
+        # Set the layout on the widget
+        self.addWidget(text_edit)
+        if ok.gui.ok.debug:
+            dump_button = PushButton(self.tr("Dump Threads(HotKey:Ctrl+Alt+D)"))
+            dump_button.clicked.connect(dump_threads)
+            self.addWidget(dump_button)
+
+    def update_update_buttons(self, percent, progress=""):
+        if ok.gui.app.updater.latest_release and not ok.gui.app.updater.downloading:
+            self.download_latest_button.setText(self.tr("Download latest version {version} ({size})").format(
+                version=ok.gui.app.updater.latest_release.get('version'),
+                size=ok.gui.app.updater.latest_release.get('readable_size')))
+            self.download_latest_button.show()
+        else:
+            self.download_latest_button.hide()
+        if ok.gui.app.updater.stable_release and not ok.gui.app.updater.downloading:
+            self.download_stable_button.setText(self.tr("Download stable version {version}  ({size})").format(
+                version=ok.gui.app.updater.stable_release.get('version'),
+                size=ok.gui.app.updater.stable_release.get('readable_size')))
+            self.download_stable_button.show()
+        else:
+            self.download_stable_button.hide()
+        if ok.gui.app.updater.downloading:
+            self.downloading_text.show()
+            self.downloading_text.setText(
+                self.tr('Downloading {progress} {percent}%').format(progress=progress, percent=format(percent, '.1f')))
+            self.download_bar.show()
+            self.download_bar.setValue(percent)
+        else:
+            self.downloading_text.hide()
+            self.download_bar.hide()
+
+    def download_update(self, percent, progress, done, error):
+        message = ""
+        if done:
+            if error:
+                bar = InfoBar.error
+                title = self.tr('Download Error:')
+                message = error
+            else:
+                bar = InfoBar.info
+                title = self.tr('Download Complete!')
+            bar(
+                title=title,
+                content=message,
+                orient=Qt.Horizontal,
+                isClosable=True,
+                position=InfoBarPosition.TOP,
+                duration=5000,  # won't disappear automatically
+                parent=self
+            )
+        self.update_update_buttons(percent, progress)
+
+    def download_latest(self):
+        ok.gui.app.updater.async_run(lambda: ok.gui.app.updater.download(ok.gui.app.updater.latest_release))
+
+    def download_stable(self):
+        ok.gui.app.updater.async_run(lambda: ok.gui.app.updater.download(ok.gui.app.updater.stable_release))
+
+    def update_update(self):
+        self.check_update_button.setText(
+            self.tr("Check for update"))
+        self.check_update_button.setEnabled(True)
+        if ok.gui.app.updater.latest_release or ok.gui.app.updater.stable_release:
+            bar = InfoBar.info
+            message = self.tr('Found new version!')
+        elif ok.gui.app.updater.error:
+            bar = InfoBar.error
+            message = self.tr('Found new version!')
+        else:
+            bar = InfoBar.info
+            message = self.tr("This is the newest version!")
+        bar(
+            title="",
+            content=message,
+            orient=Qt.Horizontal,
+            isClosable=True,
+            position=InfoBarPosition.TOP,
+            duration=5000,  # won't disappear automatically
+            parent=self
+        )
+        self.update_update_buttons(0)
+
+    def check_update(self):
+        ok.gui.app.updater.async_run(lambda: ok.gui.app.updater.check_for_updates())
+        self.check_update_button.setText(self.tr("Checking for updates"))
+        self.check_update_button.setEnabled(False)

ok-script-0.0.50/ok/gui/about/VersionCard.py

@@ -0,0 +1,40 @@
+from PySide6.QtCore import Qt
+from PySide6.QtWidgets import QLabel, QHBoxLayout, QVBoxLayout
+from qfluentwidgets import IconWidget, TextWrap, CardWidget
+
+
+class VersionCard(CardWidget):
+    """ Sample card """
+
+    def __init__(self, icon, title, version, parent=None):
+        super().__init__(parent=parent)
+
+        self.iconWidget = IconWidget(icon, self)
+        self.titleLabel = QLabel(title, self)
+        self.contentLabel = QLabel(TextWrap.wrap(version, 45, False)[0], self)
+
+        self.hBoxLayout = QHBoxLayout(self)
+        self.vBoxLayout = QVBoxLayout()
+
+        self.setFixedSize(360, 90)
+        self.iconWidget.setFixedSize(48, 48)
+
+        self.hBoxLayout.setSpacing(28)
+        self.hBoxLayout.setContentsMargins(20, 0, 0, 0)
+        self.vBoxLayout.setSpacing(2)
+        self.vBoxLayout.setContentsMargins(0, 0, 0, 0)
+        self.vBoxLayout.setAlignment(Qt.AlignVCenter)
+
+        self.hBoxLayout.setAlignment(Qt.AlignVCenter)
+        self.hBoxLayout.addWidget(self.iconWidget)
+        self.hBoxLayout.addLayout(self.vBoxLayout)
+        self.vBoxLayout.addStretch(1)
+        self.vBoxLayout.addWidget(self.titleLabel)
+        self.vBoxLayout.addWidget(self.contentLabel)
+        self.vBoxLayout.addStretch(1)
+
+        self.titleLabel.setObjectName('titleLabel')
+        self.contentLabel.setObjectName('contentLabel')
+
+    def mouseReleaseEvent(self, e):
+        super().mouseReleaseEvent(e)

{ok-script-0.0.49 → ok-script-0.0.50}/ok/gui/start/SelectCaptureListView.py

@@ -9,20 +9,18 @@ class SelectCaptureListView(ListWidget):
 
     def update_for_device(self, device, hwnd, capture):
         if self.count() == 0:
-            item = QListWidgetItem(self.tr(f"Game Window(Supports Background, Low Compatibility, Low Latency)"))
-
-            # Add the QListWidgetItem to the QListWidget
+            item = QListWidgetItem(self.tr(f"Game Window"))
             self.addItem(item)
-        tips = hwnd or self.tr("Supports Background, Low Compatibility, Low Latency")
+        tips = hwnd or ""
         if device == "windows":
             title = self.tr("Game Window")
             if self.count() == 2:
                 self.takeItem(1)
         else:
-            title = self.tr("Emulator Window")
+            title = self.tr("Emulator Window(Supports Background, Fast, Low Latency)")
             if self.count() == 1:
-                item = QListWidgetItem(self.tr("ADB (Supports Background, High Compatibility, High Latency)"))
+                item = QListWidgetItem(self.tr("ADB(Supports Background, Slow, High Compatibility, High Latency)"))
                 self.addItem(item)
-        self.item(0).setText(f"{title}({tips})")
+        self.item(0).setText(f"{title} - {tips}")
         selected = 0 if capture == "windows" else 1
         self.setCurrentRow(selected)

{ok-script-0.0.49 → ok-script-0.0.50}/ok/gui/widget/Tab.py

@@ -29,9 +29,13 @@ class Tab(ScrollArea):
 
     def addCard(self, title, widget, stretch=0, parent=None):
         container = Card(title, widget)
-        self.vBoxLayout.addWidget(container, stretch, Qt.AlignTop)
+        self.addWidget(container, stretch)
         return container
 
-    def addWidget(self, widget, stretch=0):
-        self.vBoxLayout.addWidget(widget, stretch, Qt.AlignTop)
+    def addWidget(self, widget, stretch=0, align=Qt.AlignTop):
+        self.vBoxLayout.addWidget(widget, stretch, align)
         return widget
+
+    def addLayout(self, layout, stretch=0):
+        self.vBoxLayout.addLayout(layout, stretch)
+        return layout

{ok-script-0.0.49 → ok-script-0.0.50}/ok/task/TaskExecutor.py

@@ -3,6 +3,7 @@ import time
 import traceback
 
 from ok.capture.BaseCaptureMethod import CaptureException
+from ok.capture.adb.ADBCaptureMethod import ADBCaptureMethod
 from ok.capture.adb.DeviceManager import DeviceManager
 from ok.gui.Communicate import communicate
 from ok.logging.Logger import get_logger
@@ -73,6 +74,7 @@ class TaskExecutor:
         return self._frame
 
     def supports_screen_ratio(self, supported_ratio):
+        frame = self.method.get_frame() if not isinstance(self.method, ADBCaptureMethod) else None
         if supported_ratio is None:
             return True, None
         width = self.method.width
@@ -88,9 +90,13 @@ class TaskExecutor:
 
         # Calculate the difference between the actual and supported ratios
         difference = abs(actual_ratio - supported_ratio)
-
+        support = difference <= 0.01 * supported_ratio
+        if not support:
+            logger.error(f'resolution error {width}x{height} {frame is None}')
+        if not support and frame:
+            communicate.screenshot.emit(frame, "resolution_error")
         # Check if the difference is within 1%
-        return difference <= 0.01 * supported_ratio, f"{width}x{height}"
+        return support, f"{width}x{height}"
 
     def can_capture(self):
         return self.method is not None and self.interaction is not None and self.interaction.should_capture()

ok-script-0.0.50/ok/update/Updater.py

@@ -0,0 +1,251 @@
+import math
+import os
+import queue
+import threading
+import zipfile
+from datetime import datetime
+
+import py7zr
+import requests
+
+from ok.gui.Communicate import communicate
+from ok.logging.Logger import get_logger
+from ok.util.path import get_path_relative_to_exe, ensure_dir, dir_checksum, find_folder_with_file
+
+logger = get_logger(__name__)
+
+updater_bat = r'''@echo off
+set "source_folder=%~1"
+set "target_folder=%~2"
+
+for /R "%source_folder%" %%F in (*) do (
+    if exist "%target_folder%\%%~nxF" (
+        echo Deleting "%target_folder%\%%~nxF"
+        del /F /Q "%target_folder%\%%~nxF"
+    )
+    echo Copying "%%F"
+    copy /Y "%%F" "%target_folder%\%%~nxF"
+)
+'''
+
+
+class Updater:
+    def __init__(self, app_config, exit_event):
+        self.config = app_config.get('update')
+        self.version = app_config.get('version')
+        self.debug = app_config.get('debug')
+        self.latest_release = None
+        self.stable_release = None
+        self.error = None
+        self.downloading = False
+        if self.config is None:
+            return
+        self.update_url = self.config.get('releases_url')
+        self.proxy_url = self.config.get('proxy_url')
+        self.use_proxy = self.config.get('use_proxy')
+        self.update_dir = get_path_relative_to_exe('updates')
+        self.exit_event = exit_event
+        self.task_queue = queue.Queue()
+        self.exit_event.bind_queue(self.task_queue)
+        t = threading.Thread(target=self._run_tasks, name='run_tasks')
+        t.start()
+
+    def _run_tasks(self):
+        while True and not self.exit_event.is_set():
+            task = self.task_queue.get()
+            if task is None:
+                logger.debug("Task queue get is None quit")
+                break
+            task()
+            self.task_queue.task_done()
+
+    def get_url(self, url):
+        if self.use_proxy:
+            url = self.proxy_url + url
+        logger.info(f'get_url: {url}')
+        return url
+
+    def check_for_updates(self):
+        try:
+            # Send GET request to the API endpoint
+            response = requests.get(self.get_url(self.update_url))
+
+            # Raise an exception if the request was unsuccessful
+            response.raise_for_status()
+
+            # Parse the JSON response to a dictionary
+            releases = response.json()
+
+            # Extract useful information from each release
+            self.latest_release = None
+            self.stable_release = None
+            self.error = None
+            for release in releases:
+                release = self.parse_data(release)
+
+                if not release.get('draft') and is_newer_version(self.version, release.get('version')):
+                    if self.latest_release is None:
+                        self.latest_release = release
+                    if not release.get('prerelease') and self.stable_release is None:
+                        self.stable_release = release
+
+                    if self.latest_release and self.stable_release:
+                        break
+
+            if self.latest_release == self.stable_release:
+                self.latest_release = None
+
+        except Exception as e:
+            print(f"HTTP error occurred: {e}")
+        communicate.check_update.emit()
+
+    def async_run(self, task):
+        self.task_queue.put(task)
+
+    def download(self, release):
+        try:
+            ensure_dir(self.update_dir)
+            file = os.path.join(self.update_dir, release.get('version') + '.' + release.get('type'))
+            downloaded = 0
+            size = release.get('size')
+            if os.path.exists(file):
+                downloaded = os.path.getsize(file)
+                if downloaded == size:
+                    logger.info(f'File {file} already downloaded')
+                    self.extract(file)
+                    return
+                elif downloaded > size:
+                    logger.warning(f'File {file} already downloaded greater than target')
+                    os.remove(file)
+                    downloaded = 0
+
+            headers = {'Range': f'bytes={downloaded}-'}
+            response = requests.get(self.get_url(release.get('url')), headers=headers, stream=True)
+            response.raise_for_status()
+            logger.info(f'download update to: {file} downloaded {convert_size(downloaded)}')
+            self.downloading = True
+            communicate.download_update.emit(0, "", False, None)
+            with open(file, 'ab') as f:
+                for chunk in response.iter_content(chunk_size=1024):  # 1 KB chunks
+                    if self.exit_event.is_set():
+                        return
+                    if chunk:
+                        downloaded += len(chunk)
+                        percent = downloaded / size * 100
+                        # Every 1%
+                        communicate.download_update.emit(percent,
+                                                         convert_size(downloaded) + '/' + convert_size(size), False,
+                                                         None
+                                                         )
+                        f.write(chunk)  # Write chunk to file
+            self.downloading = False
+            logger.info(f'download success: {file}')
+            self.extract(file)
+            return
+        except Exception as e:
+            logger.error('download error occurred', e)
+            communicate.download_update.emit(0, "", True, e.args[0])
+
+    def extract(self, file):
+        communicate.download_update.emit(100, "Extracting", False, None)
+        folder, extension = file.rsplit('.', 1)
+        ensure_dir(folder)
+        if extension == '7z':
+            with py7zr.SevenZipFile(file, mode='r') as z:
+                z.extractall(folder)
+        elif extension == 'zip':
+            with zipfile.ZipFile(file, 'r') as z:
+                z.extractall(folder)
+
+        updater_root_folder = find_folder_with_file(folder, 'md5.txt')
+
+        if updater_root_folder is None:
+            logger.error('check_package_error no md5.txt found')
+            self.check_package_error()
+            return
+        correct_md5_file = os.path.join(updater_root_folder, 'md5.txt')
+        try:
+            with open(correct_md5_file, 'r') as file:
+                # Read the content of the file
+                correct_md5 = file.read()
+        except Exception as e:
+            logger.error(f'check_package_error md5.txt not found {correct_md5_file}', e)
+            self.check_package_error()
+            return
+
+        md5 = dir_checksum(updater_root_folder, ['md5.txt'])
+        if md5 != correct_md5:
+            logger.error(f'check_package_error md5.txt mismatch {correct_md5_file} != {md5}')
+            self.check_package_error()
+            return
+        logger.info(f'extract {file} md5: {md5}')
+
+        # Open the file in write mode ('w')
+        try:
+            with open(get_path_relative_to_exe('update.bat'), 'w') as file:
+                # Write a string to the file
+                file.write(updater_bat)
+                logger.info('write update .bat')
+        except Exception as e:
+            logger.error(f'write updater_bat error', e)
+            self.check_package_error()
+            return
+
+        # Now, 'Hello, World!' is written to 'filename.txt'
+
+        communicate.download_update.emit(100, "", True, None)
+
+    def check_package_error(self):
+        # clear_folder(self.update_dir)
+        communicate.download_update.emit(100, "", True, "Update Package CheckSum Error!")
+
+    def enabled(self):
+        return self.config is not None
+
+    def parse_data(self, release):
+        version = release.get('tag_name')
+        time = datetime.strptime(release.get('published_at'), "%Y-%m-%dT%H:%M:%SZ").strftime('%Y-%m-%d %H:%M:%S')
+        target_asset = None
+        for asset in release.get('assets'):
+            asset = {
+                'name': asset.get('name'),
+                'url': asset.get('browser_download_url'),
+                'size': asset.get('size'),
+                'readable_size': convert_size(asset.get('size'))
+            }
+            asset['type'] = asset['url'].rsplit('.', 1)[1]
+            url = asset.get('url')
+            if version in url:
+                if 'debug' in url and self.debug:
+                    target_asset = asset
+                elif 'release' in url and not self.debug:
+                    target_asset = asset
+        if not target_asset:
+            raise ValueError(f'No asset found for version: {version}')
+        release = {
+            'version': version,
+            'notes': release.get('body'),
+            'time': time,
+            'draft': release.get('draft'),
+            'prerelease': release.get('prerelease'),
+        }
+        release.update(target_asset)
+        return release
+
+
+def is_newer_version(base_version, target_version):
+    base_version = list(map(int, base_version[1:].split('.')))
+    target_version = list(map(int, target_version[1:].split('.')))
+
+    # Compare the versions
+    return base_version < target_version
+
+
+def convert_size(size_bytes):
+    if size_bytes == 0:
+        return "0B"
+    size_name = ("B", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB")
+    i = int(math.floor(math.log(size_bytes, 1024)))
+    p = math.pow(1024, i)
+    s = round(size_bytes / p, 2)
+    return f"{s} {size_name[i]}"

ok-script-0.0.50/ok/update/gen_md5.py

@@ -0,0 +1,23 @@
+import os.path
+import sys
+
+from ok.util.path import dir_checksum
+
+
+def write_checksum_to_file(folder_path):
+    # Call the dir_checksum function
+    checksum = dir_checksum(folder_path)
+
+    # Write the checksum to a file named 'md5.txt' in the same folder
+    file = os.path.join(folder_path, 'md5.txt')
+    with open(file, 'w') as file:
+        file.write(checksum)
+    print(f'write checksum {checksum} to {file}')
+
+
+if __name__ == "__main__":
+    # Get the folder path from the command line arguments
+    folder_path = sys.argv[1]
+
+    # Call the function
+    write_checksum_to_file(folder_path)