fix: python binding

sample/python/pi_cli.py

@@ -30,3 +30,7 @@ def run(
         # if reco_detail xxxx
 
         return CustomAction.RunResult(success=True)
+
+
+if __name__ == "__main__":
+    main()

source/binding/Python/maa/custom_action.py

@@ -1,4 +1,5 @@
 import ctypes
+from dataclasses import dataclass
 from abc import ABC, abstractmethod
 
 from .buffer import RectBuffer

source/binding/Python/maa/custom_recognizer.py

@@ -1,4 +1,5 @@
 import ctypes
+from dataclasses import dataclass
 from abc import ABC, abstractmethod
 from typing import Tuple
 

source/binding/Python/maa/library.py

@@ -8,8 +8,8 @@
 
 
 class Library:
-    @classmethod
-    def open(cls, path: Union[pathlib.Path, str]) -> Optional[str]:
+    @staticmethod
+    def open(path: Union[pathlib.Path, str]) -> Optional[str]:
         platform_values = {
             "windows": ("MaaFramework.dll", "MaaToolkit.dll"),
             "darwin": ("libMaaFramework.dylib", "libMaaToolkit.dylib"),
@@ -24,40 +24,40 @@ def open(cls, path: Union[pathlib.Path, str]) -> Optional[str]:
             lib_import = ctypes.CDLL
 
         try:
-            cls.framework_libpath = (
+            Library.framework_libpath = (
                 pathlib.Path(path) / platform_values[platform_type][0]
             )
-            cls.framework = lib_import(str(cls.framework_libpath))
+            Library.framework = lib_import(str(Library.framework_libpath))
         except OSError:
-            cls.framework_libpath = ctypes.util.find_library("MaaFramework")
-            cls.framework = lib_import(str(cls.framework_libpath))
+            Library.framework_libpath = ctypes.util.find_library("MaaFramework")
+            Library.framework = lib_import(str(Library.framework_libpath))
 
         try:
-            cls.toolkit_libpath = pathlib.Path(path) / platform_values[platform_type][1]
-            cls.toolkit = lib_import(str(cls.toolkit_libpath))
+            Library.toolkit_libpath = pathlib.Path(path) / platform_values[platform_type][1]
+            Library.toolkit = lib_import(str(Library.toolkit_libpath))
         except OSError:
-            cls.toolkit_libpath = ctypes.util.find_library("MaaToolkit")
-            cls.toolkit = lib_import(str(cls.toolkit_libpath))
+            Library.toolkit_libpath = ctypes.util.find_library("MaaToolkit")
+            Library.toolkit = lib_import(str(Library.toolkit_libpath))
 
-        if not cls.framework or not cls.toolkit:
-            cls.initialized = False
+        if not Library.framework or not Library.toolkit:
+            Library.initialized = False
             return None
 
-        cls._set_api_properties()
-        cls.initialized = True
+        Library._set_api_properties()
+        Library.initialized = True
 
-        return cls.version()
+        return Library.version()
 
-    @classmethod
-    def version(cls) -> str:
-        if not cls.initialized:
+    @staticmethod
+    def version() -> str:
+        if not Library.initialized:
             raise RuntimeError(
                 "Library not initialized, please call `library.open()` first."
             )
 
-        return cls.framework.MaaVersion().decode("utf-8")
+        return Library.framework.MaaVersion().decode("utf-8")
 
-    @classmethod
-    def _set_api_properties(cls):
-        cls.framework.MaaVersion.restype = ctypes.c_char_p
-        cls.framework.MaaVersion.argtypes = None
+    @staticmethod
+    def _set_api_properties():
+        Library.framework.MaaVersion.restype = ctypes.c_char_p
+        Library.framework.MaaVersion.argtypes = None

source/binding/Python/maa/toolkit.py

@@ -3,6 +3,7 @@
 from dataclasses import dataclass
 from pathlib import Path
 from typing import Dict, List, Union, Optional, Any
+from collections import defaultdict
 
 from .define import *
 from .library import Library
@@ -16,7 +17,7 @@ class AdbDevice:
     address: str
     screencap_methods: MaaAdbScreencapMethod
     input_methods: MaaAdbInputMethod
-    config: str
+    config: Dict[str, Any]
 
 
 @dataclass
@@ -30,11 +31,11 @@ class Toolkit:
 
     ### public ###
 
-    @classmethod
+    @staticmethod
     def init_option(
-        cls, user_path: Union[str, Path], default_config: Dict = {}
+        user_path: Union[str, Path], default_config: Dict = {}
     ) -> bool:
-        cls._set_api_properties()
+        Toolkit._set_api_properties()
 
         return bool(
             Library.toolkit.MaaToolkitConfigInitOption(
@@ -43,14 +44,13 @@ def init_option(
             )
         )
 
-    @classmethod
+    @staticmethod
     def find_adb_devices(
-        cls, specified_adb: Union[str, Path] = None
+        specified_adb: Union[str, Path] = None
     ) -> List[AdbDevice]:
-        cls._set_api_properties()
+        Toolkit._set_api_properties()
 
         list_handle = Library.toolkit.MaaToolkitAdbDeviceListCreate()
-        Library.toolkit.MaaToolkitAdbDeviceListDestroy(list_handle)
 
         if specified_adb:
             Library.toolkit.MaaToolkitAdbDeviceFindSpecified(
@@ -82,24 +82,25 @@ def find_adb_devices(
             input_methods = Library.toolkit.MaaToolkitAdbDeviceGetInputMethods(
                 device_handle
             )
-            config = Library.toolkit.MaaToolkitAdbDeviceGetConfig(device_handle).decode(
+            config = json.loads(Library.toolkit.MaaToolkitAdbDeviceGetConfig(device_handle).decode(
                 "utf-8"
-            )
+            ))
 
             devices.append(
                 AdbDevice(
                     name, adb_path, address, screencap_methods, input_methods, config
                 )
             )
 
+        Library.toolkit.MaaToolkitAdbDeviceListDestroy(list_handle)
+
         return devices
 
-    @classmethod
-    def find_desktop_windows(cls) -> List[DesktopWindow]:
-        cls._set_api_properties()
+    @staticmethod
+    def find_desktop_windows() -> List[DesktopWindow]:
+        Toolkit._set_api_properties()
 
         list_handle = Library.toolkit.MaaToolkitDesktopWindowListCreate()
-        Library.toolkit.MaaToolkitDesktopWindowListDestroy(list_handle)
 
         Library.toolkit.MaaToolkitDesktopWindowFindAll(list_handle)
 
@@ -120,84 +121,74 @@ def find_desktop_windows(cls) -> List[DesktopWindow]:
 
             windows.append(DesktopWindow(hwnd, class_name, window_name))
 
+        Library.toolkit.MaaToolkitDesktopWindowListDestroy(list_handle)
         return windows
 
-    @classmethod
+    @staticmethod
     def register_pi_custom_recognition(
-        cls, name: str, recognizer: "CustomRecognizer", inst_id: int = 0
+        name: str, recognizer: "CustomRecognizer", inst_id: int = 0
     ) -> None:
-        cls._set_api_properties()
-
-        if not cls._custom_recognizer_holder:
-            cls._custom_recognizer_holder = {}
-
-        if not cls._custom_recognizer_holder[inst_id]:
-            cls._custom_recognizer_holder[inst_id] = {}
-
+        Toolkit._set_api_properties()
+
         # avoid gc
-        cls._custom_recognizer_holder[inst_id][name] = recognizer
+        Toolkit._custom_recognizer_holder[inst_id][name] = recognizer
 
         return bool(
-            Library.framework.MaaToolkitProjectInterfaceRegisterCustomRecognition(
+            Library.toolkit.MaaToolkitProjectInterfaceRegisterCustomRecognition(
                 ctypes.c_uint64(inst_id),
                 name.encode("utf-8"),
                 recognizer.c_handle,
                 recognizer.c_arg,
             )
         )
 
-    @classmethod
+    @staticmethod
     def register_pi_custom_action(
-        cls, name: str, action: "CustomAction", inst_id: int = 0
+         name: str, action: "CustomAction", inst_id: int = 0
     ) -> None:
-        cls._set_api_properties()
-
-        if not cls._custom_action_holder:
-            cls._custom_action_holder = {}
-
-        if not cls._custom_action_holder[inst_id]:
-            cls._custom_action_holder[inst_id] = {}
+        Toolkit._set_api_properties()
 
         # avoid gc
-        cls._custom_recognizer_holder[inst_id][name] = action
+        Toolkit._custom_recognizer_holder[inst_id][name] = action
 
         return bool(
-            Library.framework.MaaToolkitProjectInterfaceRegisterCustomAction(
+            Library.toolkit.MaaToolkitProjectInterfaceRegisterCustomAction(
                 ctypes.c_uint64(inst_id),
                 name.encode("utf-8"),
                 action.c_handle,
                 action.c_arg,
             ),
         )
 
-    @classmethod
+    @staticmethod
     def run_pi_cli(
-        cls,
         resource_path: Union[str, Path],
         user_path: Union[str, Path],
         directly: bool = False,
         callback: Optional[Callback] = None,
         callback_arg: Any = None,
         inst_id: int = 0,
     ) -> bool:
-        cls._set_api_properties()
+        Toolkit._set_api_properties()
 
-        cls._callback_agent = CallbackAgent(callback, callback_arg)
+        Toolkit._callback_agent = CallbackAgent(callback, callback_arg)
 
         return bool(
             Library.toolkit.MaaToolkitProjectInterfaceRunCli(
                 ctypes.c_uint64(inst_id),
                 str(resource_path).encode("utf-8"),
                 str(user_path).encode("utf-8"),
                 directly,
-                cls._callback_agent.c_callback,
-                cls._callback_agent.c_callback_arg,
+                Toolkit._callback_agent.c_callback,
+                Toolkit._callback_agent.c_callback_arg,
             )
         )
 
     ### private ###
 
     _api_properties_initialized: bool = False
+    _custom_recognizer_holder = defaultdict(dict)
+    _custom_action_holder = defaultdict(dict)
 
     @staticmethod
     def _set_api_properties():