MaaFw 4.5.5__py3-none-win_arm64.whl → 5.0.0a1__py3-none-win_arm64.whl

maa/pipeline.py

@@ -0,0 +1,374 @@
+import json
+from dataclasses import dataclass, field
+from typing import Any, List, Tuple, Union, Dict
+
+# Type aliases to match C++ std::variant types
+JRect = Tuple[int, int, int, int]  # std::array<int, 4>
+JTarget = Union[bool, str, JRect]  # std::variant<bool, std::string, JRect>
+
+
+# Recognition parameter dataclasses (matching C++ JRecognitionParam variants)
+@dataclass
+class JDirectHit:
+    pass
+
+
+@dataclass
+class JTemplateMatch:
+    roi: JTarget
+    roi_offset: JRect
+    template: List[str]
+    threshold: List[float]
+    order_by: str
+    index: int
+    method: int
+    green_mask: bool
+
+
+@dataclass
+class JFeatureMatch:
+    roi: JTarget
+    roi_offset: JRect
+    template: List[str]
+    detector: str
+    order_by: str
+    count: int
+    index: int
+    green_mask: bool
+    ratio: float
+
+
+@dataclass
+class JColorMatch:
+    roi: JTarget
+    roi_offset: JRect
+    lower: List[List[int]]
+    upper: List[List[int]]
+    order_by: str
+    method: int
+    count: int
+    index: int
+    connected: bool
+
+
+@dataclass
+class JOCR:
+    roi: JTarget
+    roi_offset: JRect
+    expected: List[str]
+    threshold: float
+    replace: List[List[str]]
+    order_by: str
+    index: int
+    only_rec: bool
+    model: str
+
+
+@dataclass
+class JNeuralNetworkClassify:
+    roi: JTarget
+    roi_offset: JRect
+    labels: List[str]
+    model: str
+    expected: List[int]
+    order_by: str
+    index: int
+
+
+@dataclass
+class JNeuralNetworkDetect:
+    roi: JTarget
+    roi_offset: JRect
+    labels: List[str]
+    model: str
+    expected: List[int]
+    threshold: List[float]
+    order_by: str
+    index: int
+
+
+@dataclass
+class JCustomRecognition:
+    roi: JTarget
+    roi_offset: JRect
+    custom_recognition: str
+    custom_recognition_param: Any
+
+
+# Recognition parameter union type
+JRecognitionParam = Union[
+    JDirectHit,
+    JTemplateMatch,
+    JFeatureMatch,
+    JColorMatch,
+    JOCR,
+    JNeuralNetworkClassify,
+    JNeuralNetworkDetect,
+    JCustomRecognition,
+]
+
+
+# Action parameter dataclasses (matching C++ JActionParam variants)
+@dataclass
+class JDoNothing:
+    pass
+
+
+@dataclass
+class JClick:
+    target: JTarget
+    target_offset: JRect
+
+
+@dataclass
+class JLongPress:
+    target: JTarget
+    target_offset: JRect
+    duration: int
+
+
+@dataclass
+class JSwipe:
+    starting: int
+    begin: JTarget
+    begin_offset: JRect
+    end: List[JTarget]
+    end_offset: List[JRect]
+    end_hold: List[int]
+    duration: List[int]
+    only_hover: bool
+
+
+@dataclass
+class JMultiSwipe:
+    swipes: List[JSwipe]
+
+
+@dataclass
+class JClickKey:
+    key: List[int]
+
+
+@dataclass
+class JLongPressKey:
+    key: List[int]
+    duration: int
+
+
+@dataclass
+class JInputText:
+    input_text: str
+
+
+@dataclass
+class JStartApp:
+    package: str
+
+
+@dataclass
+class JStopApp:
+    package: str
+
+
+@dataclass
+class JStopTask:
+    pass
+
+
+@dataclass
+class JCommand:
+    exec: str
+    args: List[str]
+    detach: bool
+
+
+@dataclass
+class JCustomAction:
+    target: JTarget
+    custom_action: str
+    custom_action_param: Any
+    target_offset: JRect
+
+
+# Action parameter union type
+JActionParam = Union[
+    JDoNothing,
+    JClick,
+    JLongPress,
+    JSwipe,
+    JMultiSwipe,
+    JClickKey,
+    JLongPressKey,
+    JInputText,
+    JStartApp,
+    JStopApp,
+    JStopTask,
+    JCommand,
+    JCustomAction,
+]
+
+
+# Main pipeline dataclasses
+@dataclass
+class JRecognition:
+    type: str
+    param: JRecognitionParam
+
+
+@dataclass
+class JAction:
+    type: str
+    param: JActionParam
+
+
+@dataclass
+class JWaitFreezes:
+    time: int
+    target: JTarget
+    target_offset: JRect
+    threshold: float
+    method: int
+    rate_limit: int
+    timeout: int
+
+
+@dataclass
+class JPipelineData:
+    recognition: JRecognition
+    action: JAction
+    next: List[str]
+    interrupt: List[str]
+    is_sub: bool
+    rate_limit: int
+    timeout: int
+    on_error: List[str]
+    inverse: bool
+    enabled: bool
+    pre_delay: int
+    post_delay: int
+    pre_wait_freezes: JWaitFreezes
+    post_wait_freezes: JWaitFreezes
+    focus: Any
+
+
+class JPipelineParser:
+    @staticmethod
+    def _parse_wait_freezes(data: dict) -> JWaitFreezes:
+        """Convert wait freezes with proper defaults"""
+        return JWaitFreezes(
+            time=data.get("time"),
+            target=data.get("target"),  # type: ignore
+            target_offset=data.get("target_offset"),  # type: ignore
+            threshold=data.get("threshold"),
+            method=data.get("method"),
+            rate_limit=data.get("rate_limit"),
+            timeout=data.get("timeout"),
+        )
+
+    @classmethod
+    def _parse_param(
+        cls, param_type: str, param_data: dict, param_type_map: dict, default_class
+    ):
+        """Generic function to parse parameters based on type map."""
+        param_class = param_type_map.get(param_type)
+        if not param_class:
+            raise ValueError(f"Unknown type: {param_type}")
+
+        if param_class == default_class:
+            return param_class()
+
+        try:
+            return param_class(**param_data)
+        except TypeError as e:
+            print(
+                f"Warning: Failed to create {param_class.__name__} with data {param_data}: {e}"
+            )
+            return default_class()
+
+    @classmethod
+    def _parse_recognition_param(
+        cls, param_type: str, param_data: dict
+    ) -> JRecognitionParam:
+        """Convert dict to appropriate JRecognitionParam variant based on type."""
+        param_type_map = {
+            "DirectHit": JDirectHit,
+            "TemplateMatch": JTemplateMatch,
+            "FeatureMatch": JFeatureMatch,
+            "ColorMatch": JColorMatch,
+            "OCR": JOCR,
+            "NeuralNetworkClassify": JNeuralNetworkClassify,
+            "NeuralNetworkDetect": JNeuralNetworkDetect,
+            "Custom": JCustomRecognition,
+        }
+        return cls._parse_param(param_type, param_data, param_type_map, JDirectHit)
+
+    @classmethod
+    def _parse_action_param(cls, param_type: str, param_data: dict) -> JActionParam:
+        """Convert dict to appropriate JActionParam variant based on type."""
+        param_type_map = {
+            "DoNothing": JDoNothing,
+            "Click": JClick,
+            "LongPress": JLongPress,
+            "Swipe": JSwipe,
+            "MultiSwipe": JMultiSwipe,
+            "ClickKey": JClickKey,
+            "LongPressKey": JLongPressKey,
+            "InputText": JInputText,
+            "StartApp": JStartApp,
+            "StopApp": JStopApp,
+            "StopTask": JStopTask,
+            "Command": JCommand,
+            "Custom": JCustomAction,
+        }
+        return cls._parse_param(param_type, param_data, param_type_map, JDoNothing)
+
+    @classmethod
+    def parse_pipeline_data(cls, pipeline_data: Union[str, Dict]) -> JPipelineData:
+        """Parse JSON string to JPipelineData dataclass with proper variant types."""
+        if isinstance(pipeline_data, dict):
+            data = pipeline_data
+        elif isinstance(pipeline_data, str):
+            try:
+                data: dict = json.loads(pipeline_data)
+            except json.JSONDecodeError as e:
+                raise ValueError(f"Invalid JSON format: {e}")
+        else:
+            raise TypeError("Input must be a JSON string or a dict.")
+
+        # Convert recognition
+        recognition_data: dict = data.get("recognition")
+        recognition_type: str = recognition_data.get("type")
+        recognition_param_data: dict = recognition_data.get("param")
+        recognition_param = cls._parse_recognition_param(
+            recognition_type, recognition_param_data
+        )
+        recognition = JRecognition(type=recognition_type, param=recognition_param)
+
+        # Convert action
+        action_data: dict = data.get("action")
+        action_type: str = action_data.get("type")
+        action_param_data = action_data.get("param")
+        action_param = cls._parse_action_param(action_type, action_param_data)
+        action = JAction(type=action_type, param=action_param)
+
+        pre_wait_freezes = cls._parse_wait_freezes(data.get("pre_wait_freezes"))  # type: ignore
+        post_wait_freezes = cls._parse_wait_freezes(data.get("post_wait_freezes"))  # type: ignore
+
+        # Create JPipelineData with converted data
+        return JPipelineData(
+            recognition=recognition,
+            action=action,
+            next=data.get("next"),
+            interrupt=data.get("interrupt"),
+            is_sub=data.get("is_sub"),
+            rate_limit=data.get("rate_limit"),
+            timeout=data.get("timeout"),
+            on_error=data.get("on_error"),
+            inverse=data.get("inverse"),
+            enabled=data.get("enabled"),
+            pre_delay=data.get("pre_delay"),
+            post_delay=data.get("post_delay"),
+            pre_wait_freezes=pre_wait_freezes,  # type: ignore
+            post_wait_freezes=post_wait_freezes,  # type: ignore
+            focus=data.get("focus"),
+        )

maa/resource.py

@@ -1,17 +1,18 @@
 import ctypes
 import pathlib
 import json
-from typing import Any, Optional, Union
+from typing import Any, Optional, Union, List, Dict, Tuple
+from dataclasses import dataclass, field
 
-from .notification_handler import NotificationHandler
+from .event_sink import EventSink, NotificationType
 from .define import *
 from .job import Job
 from .library import Library
 from .buffer import StringBuffer, StringListBuffer
+from .pipeline import JPipelineData, JPipelineParser
 
 
 class Resource:
-    _notification_handler: Optional[NotificationHandler]
     _handle: MaaResourceHandle
     _own: bool
 
@@ -19,19 +20,21 @@ class Resource:
 
     def __init__(
         self,
-        notification_handler: Optional[NotificationHandler] = None,
+        notification_handler: None = None,
         handle: Optional[MaaResourceHandle] = None,
     ):
+        if notification_handler:
+            raise NotImplementedError(
+                "NotificationHandler is deprecated, use add_sink instead."
+            )
+
         self._set_api_properties()
 
         if handle:
             self._handle = handle
             self._own = False
         else:
-            self._notification_handler = notification_handler
-            self._handle = Library.framework().MaaResourceCreate(
-                *NotificationHandler._gen_c_param(self._notification_handler)
-            )
+            self._handle = Library.framework().MaaResourceCreate()
             self._own = True
 
         if not self._handle:
@@ -45,16 +48,18 @@ class Resource:
             Library.framework().MaaResourceDestroy(self._handle)
 
     def post_bundle(self, path: Union[pathlib.Path, str]) -> Job:
-        resid = Library.framework().MaaResourcePostBundle(
+        res_id = Library.framework().MaaResourcePostBundle(
             self._handle, str(path).encode()
         )
-        return Job(resid, self._status, self._wait)
+        return Job(res_id, self._status, self._wait)
 
     def override_pipeline(self, pipeline_override: Dict) -> bool:
+        pipeline_json = json.dumps(pipeline_override, ensure_ascii=False)
+
         return bool(
             Library.framework().MaaResourceOverridePipeline(
                 self._handle,
-                json.dumps(pipeline_override, ensure_ascii=False).encode(),
+                pipeline_json.encode(),
             )
         )
 
@@ -67,14 +72,13 @@ class Resource:
                 self._handle, name.encode(), list_buffer._handle
             )
         )
-    
-    def get_node_data(self, name: str) -> Optional[dict]:
+
+    def get_node_data(self, name: str) -> Optional[Dict]:
         string_buffer = StringBuffer()
         if not Library.framework().MaaResourceGetNodeData(
             self._handle, name.encode(), string_buffer._handle
         ):
             return None
-
         data = string_buffer.get()
         if not data:
             return None
@@ -84,6 +88,14 @@ class Resource:
         except json.JSONDecodeError:
             return None
 
+    def get_node_object(self, name: str) -> Optional[JPipelineData]:
+        node_data = self.get_node_data(name)
+
+        if not node_data:
+            return None
+
+        return JPipelineParser.parse_pipeline_data(node_data)
+
     @property
     def loaded(self) -> bool:
         return bool(Library.framework().MaaResourceLoaded(self._handle))
@@ -231,6 +243,27 @@ class Resource:
             raise RuntimeError("Failed to get hash.")
         return buffer.get()
 
+    _sink_holder: Dict[int, "ResourceEventSink"] = {}
+
+    def add_sink(self, sink: "ResourceEventSink") -> Optional[int]:
+        sink_id = int(
+            Library.framework().MaaResourceAddSink(
+                self._handle, *EventSink._gen_c_param(sink)
+            )
+        )
+        if sink_id == MaaInvalidId:
+            return None
+
+        self._sink_holder[sink_id] = sink
+        return sink_id
+
+    def remove_sink(self, sink_id: int) -> None:
+        Library.framework().MaaResourceRemoveSink(self._handle, sink_id)
+        self._sink_holder.pop(sink_id)
+
+    def clear_sinks(self) -> None:
+        Library.framework().MaaResourceClearSinks(self._handle)
+
     ### private ###
 
     def set_inference(self, execution_provider: int, device_id: int) -> bool:
@@ -267,10 +300,7 @@ class Resource:
         Resource._api_properties_initialized = True
 
         Library.framework().MaaResourceCreate.restype = MaaResourceHandle
-        Library.framework().MaaResourceCreate.argtypes = [
-            MaaNotificationCallback,
-            ctypes.c_void_p,
-        ]
+        Library.framework().MaaResourceCreate.argtypes = []
 
         Library.framework().MaaResourceDestroy.restype = None
         Library.framework().MaaResourceDestroy.argtypes = [MaaResourceHandle]
@@ -376,3 +406,52 @@ class Resource:
             MaaResourceHandle,
             MaaStringListBufferHandle,
         ]
+
+        Library.framework().MaaResourceAddSink.restype = MaaSinkId
+        Library.framework().MaaResourceAddSink.argtypes = [
+            MaaResourceHandle,
+            MaaEventCallback,
+            ctypes.c_void_p,
+        ]
+
+        Library.framework().MaaResourceRemoveSink.restype = None
+        Library.framework().MaaResourceRemoveSink.argtypes = [
+            MaaResourceHandle,
+            MaaSinkId,
+        ]
+
+        Library.framework().MaaResourceClearSinks.restype = None
+        Library.framework().MaaResourceClearSinks.argtypes = [MaaResourceHandle]
+
+
+class ResourceEventSink(EventSink):
+
+    @dataclass
+    class ResourceLoadingDetail:
+        res_id: int
+        hash: str
+        path: str
+
+    def on_resource_loading(
+        self,
+        resource: Resource,
+        noti_type: NotificationType,
+        detail: ResourceLoadingDetail,
+    ):
+        pass
+
+    def on_raw_notification(self, handle: ctypes.c_void_p, msg: str, details: dict):
+
+        resource = Resource(handle=handle)
+        noti_type = EventSink._notification_type(msg)
+
+        if msg.startswith("Resource.Loading"):
+            detail = self.ResourceLoadingDetail(
+                res_id=details["res_id"],
+                hash=details["hash"],
+                path=details["path"],
+            )
+            self.on_resource_loading(resource, noti_type, detail)
+
+        else:
+            self.on_unknown_notification(resource, msg, details)