MaaFw 2.2.0b2__py3-none-macosx_13_0_x86_64.whl → 5.3.0b2__py3-none-macosx_13_0_x86_64.whl

maa/__init__.py

@@ -1,10 +1,12 @@
 import os
+from pathlib import Path
 
 from .library import Library
 
-__PATH = os.path.join(os.path.dirname(__file__), "bin")
+env_path = os.environ.get("MAAFW_BINARY_PATH")
+if env_path:
+    __PATH = Path(env_path)
+else:
+    __PATH = Path(Path(__file__).parent, "bin")
 
-if os.path.exists(__PATH):
-    ver = Library.open(__PATH)
-    if ver:
-        print(f"MaaFw version: {ver}")
+Library.open(__PATH, agent_server=False)

maa/agent/__init__.py

@@ -0,0 +1,12 @@
+import os
+from pathlib import Path
+
+from ..library import Library
+
+env_path = os.environ.get("MAAFW_BINARY_PATH")
+if env_path:
+    __PATH = Path(env_path)
+else:
+    __PATH = Path(Path(__file__).parent.parent, "bin")
+
+Library.open(__PATH, agent_server=True)

maa/agent/agent_server.py

@@ -0,0 +1,237 @@
+import ctypes
+
+from ..define import *
+from ..library import Library
+from ..event_sink import EventSink
+
+
+class AgentServer:
+
+    @staticmethod
+    def custom_recognition(name: str):
+
+        def wrapper_recognition(recognition):
+            AgentServer.register_custom_recognition(
+                name=name, recognition=recognition()
+            )
+            return recognition
+
+        return wrapper_recognition
+
+    _custom_recognition_holder = {}
+
+    @staticmethod
+    def register_custom_recognition(
+        name: str, recognition: "CustomRecognition"  # type: ignore
+    ) -> bool:
+
+        AgentServer._set_api_properties()
+
+        # avoid gc
+        AgentServer._custom_recognition_holder[name] = recognition
+
+        return bool(
+            Library.agent_server().MaaAgentServerRegisterCustomRecognition(
+                name.encode(),
+                recognition.c_handle,
+                recognition.c_arg,
+            )
+        )
+
+    @staticmethod
+    def custom_action(name: str):
+
+        def wrapper_action(action):
+            AgentServer.register_custom_action(name=name, action=action())
+            return action
+
+        return wrapper_action
+
+    _custom_action_holder = {}
+
+    @staticmethod
+    def register_custom_action(name: str, action: "CustomAction") -> bool:  # type: ignore
+
+        AgentServer._set_api_properties()
+
+        # avoid gc
+        AgentServer._custom_action_holder[name] = action
+
+        return bool(
+            Library.agent_server().MaaAgentServerRegisterCustomAction(
+                name.encode(),
+                action.c_handle,
+                action.c_arg,
+            )
+        )
+
+    @staticmethod
+    def start_up(identifier: str) -> bool:
+
+        AgentServer._set_api_properties()
+
+        return bool(Library.agent_server().MaaAgentServerStartUp(identifier.encode()))
+
+    @staticmethod
+    def shut_down() -> None:
+
+        AgentServer._set_api_properties()
+
+        Library.agent_server().MaaAgentServerShutDown()
+
+    @staticmethod
+    def join() -> None:
+
+        AgentServer._set_api_properties()
+
+        Library.agent_server().MaaAgentServerJoin()
+
+    @staticmethod
+    def detach() -> None:
+
+        AgentServer._set_api_properties()
+
+        Library.agent_server().MaaAgentServerDetach()
+
+    _sink_holder: Dict[int, "EventSink"] = {}
+
+    @staticmethod
+    def resource_sink():
+        def wrapper_sink(sink):
+            AgentServer.add_resource_sink(sink=sink())
+            return sink
+
+        return wrapper_sink
+
+    @staticmethod
+    def add_resource_sink(sink: "ResourceEventSink") -> None:
+        sink_id = int(
+            Library.agent_server().MaaAgentServerAddResourceSink(
+                *EventSink._gen_c_param(sink)
+            )
+        )
+        if sink_id == MaaInvalidId:
+            return None
+
+        AgentServer._sink_holder[sink_id] = sink
+
+    @staticmethod
+    def controller_sink():
+        def wrapper_sink(sink):
+            AgentServer.add_controller_sink(sink=sink())
+            return sink
+
+        return wrapper_sink
+
+    @staticmethod
+    def add_controller_sink(sink: "ControllerEventSink") -> None:
+        sink_id = int(
+            Library.agent_server().MaaAgentServerAddControllerSink(
+                *EventSink._gen_c_param(sink)
+            )
+        )
+        if sink_id == MaaInvalidId:
+            return None
+
+        AgentServer._sink_holder[sink_id] = sink
+
+    @staticmethod
+    def tasker_sink():
+        def wrapper_sink(sink):
+            AgentServer.add_tasker_sink(sink=sink())
+            return sink
+
+        return wrapper_sink
+
+    @staticmethod
+    def add_tasker_sink(sink: "TaskerEventSink") -> None:
+        sink_id = int(
+            Library.agent_server().MaaAgentServerAddTaskerSink(
+                *EventSink._gen_c_param(sink)
+            )
+        )
+        if sink_id == MaaInvalidId:
+            return None
+
+        AgentServer._sink_holder[sink_id] = sink
+
+    @staticmethod
+    def context_sink():
+        def wrapper_sink(sink):
+            AgentServer.add_context_sink(sink=sink())
+            return sink
+
+        return wrapper_sink
+
+    @staticmethod
+    def add_context_sink(sink: "ContextEventSink") -> None:
+        sink_id = int(
+            Library.agent_server().MaaAgentServerAddContextSink(
+                *EventSink._gen_c_param(sink)
+            )
+        )
+        if sink_id == MaaInvalidId:
+            return None
+
+        AgentServer._sink_holder[sink_id] = sink
+
+    _api_properties_initialized: bool = False
+
+    @staticmethod
+    def _set_api_properties():
+        if AgentServer._api_properties_initialized:
+            return
+
+        AgentServer._api_properties_initialized = True
+
+        Library.agent_server().MaaAgentServerRegisterCustomRecognition.restype = MaaBool
+        Library.agent_server().MaaAgentServerRegisterCustomRecognition.argtypes = [
+            ctypes.c_char_p,
+            MaaCustomRecognitionCallback,
+            ctypes.c_void_p,
+        ]
+
+        Library.agent_server().MaaAgentServerRegisterCustomAction.restype = MaaBool
+        Library.agent_server().MaaAgentServerRegisterCustomAction.argtypes = [
+            ctypes.c_char_p,
+            MaaCustomActionCallback,
+            ctypes.c_void_p,
+        ]
+
+        Library.agent_server().MaaAgentServerStartUp.restype = MaaBool
+        Library.agent_server().MaaAgentServerStartUp.argtypes = [
+            ctypes.c_char_p,
+        ]
+
+        Library.agent_server().MaaAgentServerShutDown.restype = None
+        Library.agent_server().MaaAgentServerShutDown.argtypes = []
+
+        Library.agent_server().MaaAgentServerJoin.restype = None
+        Library.agent_server().MaaAgentServerJoin.argtypes = []
+
+        Library.agent_server().MaaAgentServerDetach.restype = None
+        Library.agent_server().MaaAgentServerDetach.argtypes = []
+
+        Library.agent_server().MaaAgentServerAddResourceSink.restype = MaaSinkId
+        Library.agent_server().MaaAgentServerAddResourceSink.argtypes = [
+            MaaEventCallback,
+            ctypes.c_void_p,
+        ]
+
+        Library.agent_server().MaaAgentServerAddControllerSink.restype = MaaSinkId
+        Library.agent_server().MaaAgentServerAddControllerSink.argtypes = [
+            MaaEventCallback,
+            ctypes.c_void_p,
+        ]
+
+        Library.agent_server().MaaAgentServerAddTaskerSink.restype = MaaSinkId
+        Library.agent_server().MaaAgentServerAddTaskerSink.argtypes = [
+            MaaEventCallback,
+            ctypes.c_void_p,
+        ]
+
+        Library.agent_server().MaaAgentServerAddContextSink.restype = MaaSinkId
+        Library.agent_server().MaaAgentServerAddContextSink.argtypes = [
+            MaaEventCallback,
+            ctypes.c_void_p,
+        ]

maa/agent_client.py

@@ -0,0 +1,218 @@
+import ctypes
+from typing import List
+
+from .define import *
+from .library import Library
+from .resource import Resource
+from .controller import Controller
+from .tasker import Tasker
+from .buffer import StringBuffer, StringListBuffer
+
+
+class AgentClient:
+    _handle: MaaAgentClientHandle
+
+    def __init__(self, identifier: Optional[str] = None):
+        self._set_api_properties()
+
+        if identifier:
+            id_buffer = StringBuffer()
+            id_buffer.set(identifier)
+            id_buffer_handle = id_buffer._handle
+        else:
+            id_buffer_handle = None
+
+        self._handle = Library.agent_client().MaaAgentClientCreateV2(id_buffer_handle)
+        if not self._handle:
+            raise RuntimeError("Failed to create agent client.")
+
+    def __del__(self):
+        if self._handle:
+            Library.agent_client().MaaAgentClientDestroy(self._handle)
+
+    @property
+    def identifier(self) -> Optional[str]:
+        id_buffer = StringBuffer()
+        if not Library.agent_client().MaaAgentClientIdentifier(
+            self._handle, id_buffer._handle
+        ):
+            return None
+
+        return id_buffer.get()
+
+    def bind(self, resource: Resource) -> bool:
+        # avoid gc
+        self._resource = resource
+
+        return bool(
+            Library.agent_client().MaaAgentClientBindResource(
+                self._handle, resource._handle
+            )
+        )
+
+    def register_sink(
+        self, resource: Resource, controller: Controller, tasker: Tasker
+    ) -> bool:
+        # avoid gc
+        self._sinks = [resource, controller, tasker]
+
+        return (
+            bool(
+                Library.agent_client().MaaAgentClientRegisterResourceSink(
+                    self._handle, resource._handle
+                )
+            )
+            and bool(
+                Library.agent_client().MaaAgentClientRegisterControllerSink(
+                    self._handle, controller._handle
+                )
+            )
+            and bool(
+                Library.agent_client().MaaAgentClientRegisterTaskerSink(
+                    self._handle, tasker._handle
+                )
+            )
+        )
+
+    def connect(self) -> bool:
+        return bool(Library.agent_client().MaaAgentClientConnect(self._handle))
+
+    def disconnect(self) -> bool:
+        return bool(Library.agent_client().MaaAgentClientDisconnect(self._handle))
+
+    @property
+    def connected(self) -> bool:
+        return bool(Library.agent_client().MaaAgentClientConnected(self._handle))
+
+    @property
+    def alive(self) -> bool:
+        return bool(Library.agent_client().MaaAgentClientAlive(self._handle))
+
+    def set_timeout(self, milliseconds: int) -> bool:
+        return bool(
+            Library.agent_client().MaaAgentClientSetTimeout(
+                self._handle, ctypes.c_int64(milliseconds)
+            )
+        )
+
+    @property
+    def custom_recognition_list(self) -> List[str]:
+        """获取已注册的自定义识别器列表 / Get registered custom recognizer list
+
+        Returns:
+            list[str]: 自定义识别器名列表 / List of custom recognizer names
+
+        Raises:
+            RuntimeError: 如果获取失败
+        """
+        buffer = StringListBuffer()
+        if not Library.agent_client().MaaAgentClientGetCustomRecognitionList(
+            self._handle, buffer._handle
+        ):
+            raise RuntimeError("Failed to get custom recognition list.")
+        return buffer.get()
+
+    @property
+    def custom_action_list(self) -> List[str]:
+        """获取已注册的自定义操作列表 / Get registered custom action list
+
+        Returns:
+            list[str]: 自定义操作名列表 / List of custom action names
+
+        Raises:
+            RuntimeError: 如果获取失败
+        """
+        buffer = StringListBuffer()
+        if not Library.agent_client().MaaAgentClientGetCustomActionList(
+            self._handle, buffer._handle
+        ):
+            raise RuntimeError("Failed to get custom action list.")
+        return buffer.get()
+
+    _api_properties_initialized: bool = False
+
+    @staticmethod
+    def _set_api_properties():
+        if AgentClient._api_properties_initialized:
+            return
+
+        if Library.is_agent_server():
+            raise RuntimeError("AgentClient is not available in AgentServer.")
+
+        AgentClient._api_properties_initialized = True
+
+        Library.agent_client().MaaAgentClientCreateV2.restype = MaaAgentClientHandle
+        Library.agent_client().MaaAgentClientCreateV2.argtypes = [
+            MaaStringBufferHandle,
+        ]
+
+        Library.agent_client().MaaAgentClientIdentifier.restype = MaaBool
+        Library.agent_client().MaaAgentClientIdentifier.argtypes = [
+            MaaAgentClientHandle,
+            MaaStringBufferHandle,
+        ]
+
+        Library.agent_client().MaaAgentClientDestroy.restype = None
+        Library.agent_client().MaaAgentClientDestroy.argtypes = [MaaAgentClientHandle]
+
+        Library.agent_client().MaaAgentClientBindResource.restype = MaaBool
+        Library.agent_client().MaaAgentClientBindResource.argtypes = [
+            MaaAgentClientHandle,
+            MaaResourceHandle,
+        ]
+
+        Library.agent_client().MaaAgentClientRegisterResourceSink.restype = MaaBool
+        Library.agent_client().MaaAgentClientRegisterResourceSink.argtypes = [
+            MaaAgentClientHandle,
+            MaaResourceHandle,
+        ]
+
+        Library.agent_client().MaaAgentClientRegisterControllerSink.restype = MaaBool
+        Library.agent_client().MaaAgentClientRegisterControllerSink.argtypes = [
+            MaaAgentClientHandle,
+            MaaControllerHandle,
+        ]
+
+        Library.agent_client().MaaAgentClientRegisterTaskerSink.restype = MaaBool
+        Library.agent_client().MaaAgentClientRegisterTaskerSink.argtypes = [
+            MaaAgentClientHandle,
+            MaaTaskerHandle,
+        ]
+
+        Library.agent_client().MaaAgentClientConnect.restype = MaaBool
+        Library.agent_client().MaaAgentClientConnect.argtypes = [
+            MaaAgentClientHandle,
+        ]
+
+        Library.agent_client().MaaAgentClientDisconnect.restype = MaaBool
+        Library.agent_client().MaaAgentClientDisconnect.argtypes = [
+            MaaAgentClientHandle,
+        ]
+
+        Library.agent_client().MaaAgentClientConnected.restype = MaaBool
+        Library.agent_client().MaaAgentClientConnected.argtypes = [
+            MaaAgentClientHandle,
+        ]
+
+        Library.agent_client().MaaAgentClientAlive.restype = MaaBool
+        Library.agent_client().MaaAgentClientAlive.argtypes = [
+            MaaAgentClientHandle,
+        ]
+
+        Library.agent_client().MaaAgentClientSetTimeout.restype = MaaBool
+        Library.agent_client().MaaAgentClientSetTimeout.argtypes = [
+            MaaAgentClientHandle,
+            ctypes.c_int64,
+        ]
+
+        Library.agent_client().MaaAgentClientGetCustomRecognitionList.restype = MaaBool
+        Library.agent_client().MaaAgentClientGetCustomRecognitionList.argtypes = [
+            MaaAgentClientHandle,
+            MaaStringListBufferHandle,
+        ]
+
+        Library.agent_client().MaaAgentClientGetCustomActionList.restype = MaaBool
+        Library.agent_client().MaaAgentClientGetCustomActionList.argtypes = [
+            MaaAgentClientHandle,
+            MaaStringListBufferHandle,
+        ]