kotonebot 0.5.0__py3-none-any.whl → 0.7.0__py3-none-any.whl

kotonebot/backend/context/task_action.py

@@ -1,184 +1,184 @@
-import logging
-import warnings
-from dataclasses import dataclass
-from typing_extensions import deprecated
-from typing import Callable, ParamSpec, TypeVar, overload, Literal
-
-
-from .context import ContextStackVars, ScreenshotMode
-from ...errors import TaskNotFoundError
-
-P = ParamSpec('P')
-R = TypeVar('R')
-logger = logging.getLogger(__name__)
-
-TaskRunAtType = Literal['pre', 'post', 'manual', 'regular'] | str
-
-
-@dataclass
-class Task:
-    name: str
-    id: str
-    description: str
-    func: Callable
-    priority: int
-    """
-    任务优先级，数字越大优先级越高。
-    """
-    run_at: TaskRunAtType = 'regular'
-
-
-@dataclass
-class Action:
-    name: str
-    description: str
-    func: Callable
-    priority: int
-    """
-    动作优先级，数字越大优先级越高。
-    """
-
-
-task_registry: dict[str, Task] = {}
-action_registry: dict[str, Action] = {}
-current_callstack: list[Task|Action] = []
-
-def _placeholder():
-    raise NotImplementedError('Placeholder function')
-
-def task(
-    name: str,
-    task_id: str|None = None,
-    description: str|None = None,
-    *,
-    pass_through: bool = False,
-    priority: int = 0,
-    screenshot_mode: ScreenshotMode = 'auto',
-    run_at: TaskRunAtType = 'regular'
-):
-    """
-    `task` 装饰器，用于标记一个函数为任务函数。
-
-    :param name: 任务名称
-    :param task_id: 任务 ID。如果为 None，则使用函数名称作为 ID。
-    :param description: 任务描述。如果为 None，则使用函数的 docstring 作为描述。
-    :param pass_through: 
-        默认情况下， @task 装饰器会包裹任务函数，跟踪其执行情况。
-        如果不想跟踪，则设置此参数为 False。
-    :param priority: 任务优先级，数字越大优先级越高。
-    :param run_at: 任务运行时间。
-    """
-    # 设置 ID
-    # 获取 caller 信息
-    def _task_decorator(func: Callable[P, R]) -> Callable[P, R]:
-        nonlocal description, task_id
-        description = description or func.__doc__ or ''
-        # TODO: task_id 冲突检测
-        task_id = task_id or func.__name__
-        task = Task(name, task_id, description, _placeholder, priority, run_at)
-        task_registry[name] = task
-        logger.debug(f'Task "{name}" registered.')
-        if pass_through:
-            return func
-        else:
-            def _wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
-                current_callstack.append(task)
-                vars = ContextStackVars.push(screenshot_mode=screenshot_mode)
-                ret = func(*args, **kwargs)
-                ContextStackVars.pop()
-                current_callstack.pop()
-                return ret
-            task.func = _wrapper
-            return _wrapper
-    return _task_decorator
-
-@overload
-def action(func: Callable[P, R]) -> Callable[P, R]: ...
-
-@deprecated('Use `action` with screenshot_mode=`manual` instead.')
-@overload
-def action(
-    name: str,
-    *,
-    description: str|None = None,
-    pass_through: bool = False,
-    priority: int = 0,
-    screenshot_mode: Literal['manual-inherit'],
-) -> Callable[[Callable[P, R]], Callable[P, R]]: ...
-
-@overload
-def action(
-    name: str,
-    *,
-    description: str|None = None,
-    pass_through: bool = False,
-    priority: int = 0,
-    screenshot_mode: ScreenshotMode | None = None,
-) -> Callable[[Callable[P, R]], Callable[P, R]]:
-    """
-    `action` 装饰器，用于标记一个函数为动作函数。
-
-    :param name: 动作名称。如果为 None，则使用函数的名称作为名称。
-    :param description: 动作描述。如果为 None，则使用函数的 docstring 作为描述。
-    :param pass_through: 
-        默认情况下， @action 装饰器会包裹动作函数，跟踪其执行情况。
-        如果不想跟踪，则设置此参数为 False。
-    :param priority: 动作优先级，数字越大优先级越高。
-    :param screenshot_mode: 截图模式。
-    """
-    ...
-
-def action(*args, **kwargs):
-    def _register(func: Callable, name: str, description: str|None = None, priority: int = 0) -> Action:
-        description = description or func.__doc__ or ''
-        action = Action(name, description, func, priority)
-        action_registry[name] = action
-        logger.debug(f'Action "{name}" registered.')
-        return action
-
-    if len(args) == 1 and isinstance(args[0], Callable):
-        func = args[0]
-        action = _register(_placeholder, func.__name__, func.__doc__)
-        def _wrapper(*args: P.args, **kwargs: P.kwargs):
-            current_callstack.append(action)
-            vars = ContextStackVars.push()
-            ret = func(*args, **kwargs)
-            ContextStackVars.pop()
-            current_callstack.pop()
-            return ret
-        action.func = _wrapper
-        return _wrapper
-    else:
-        name = args[0]
-        description = kwargs.get('description', None)
-        pass_through = kwargs.get('pass_through', False)
-        priority = kwargs.get('priority', 0)
-        screenshot_mode = kwargs.get('screenshot_mode', None)
-        if screenshot_mode == 'manual-inherit':
-            warnings.warn('`screenshot_mode=manual-inherit` is deprecated. Use `screenshot_mode=manual` instead.')
-        def _action_decorator(func: Callable):
-            nonlocal pass_through
-            action = _register(_placeholder, name, description)
-            pass_through = kwargs.get('pass_through', False)
-            if pass_through:
-                return func
-            else:
-                def _wrapper(*args: P.args, **kwargs: P.kwargs):
-                    current_callstack.append(action)
-                    vars = ContextStackVars.push(screenshot_mode=screenshot_mode)
-                    ret = func(*args, **kwargs)
-                    ContextStackVars.pop()
-                    current_callstack.pop()
-                    return ret
-                action.func = _wrapper
-                return _wrapper
-        return _action_decorator
-
-def tasks_from_id(task_ids: list[str]) -> list[Task]:
-    result = []
-    for tid in task_ids:
-        target = next(task for task in task_registry.values() if task.id == tid)
-        if target is None:
-            raise TaskNotFoundError(f'Task "{tid}" not found.')
-        result.append(target)
+import logging
+import warnings
+from dataclasses import dataclass
+from typing_extensions import deprecated
+from typing import Callable, ParamSpec, TypeVar, overload, Literal
+
+
+from .context import ContextStackVars, ScreenshotMode
+from ...errors import TaskNotFoundError
+
+P = ParamSpec('P')
+R = TypeVar('R')
+logger = logging.getLogger(__name__)
+
+TaskRunAtType = Literal['pre', 'post', 'manual', 'regular'] | str
+
+
+@dataclass
+class Task:
+    name: str
+    id: str
+    description: str
+    func: Callable
+    priority: int
+    """
+    任务优先级，数字越大优先级越高。
+    """
+    run_at: TaskRunAtType = 'regular'
+
+
+@dataclass
+class Action:
+    name: str
+    description: str
+    func: Callable
+    priority: int
+    """
+    动作优先级，数字越大优先级越高。
+    """
+
+
+task_registry: dict[str, Task] = {}
+action_registry: dict[str, Action] = {}
+current_callstack: list[Task|Action] = []
+
+def _placeholder():
+    raise NotImplementedError('Placeholder function')
+
+def task(
+    name: str,
+    task_id: str|None = None,
+    description: str|None = None,
+    *,
+    pass_through: bool = False,
+    priority: int = 0,
+    screenshot_mode: ScreenshotMode = 'auto',
+    run_at: TaskRunAtType = 'regular'
+):
+    """
+    `task` 装饰器，用于标记一个函数为任务函数。
+
+    :param name: 任务名称
+    :param task_id: 任务 ID。如果为 None，则使用函数名称作为 ID。
+    :param description: 任务描述。如果为 None，则使用函数的 docstring 作为描述。
+    :param pass_through: 
+        默认情况下， @task 装饰器会包裹任务函数，跟踪其执行情况。
+        如果不想跟踪，则设置此参数为 False。
+    :param priority: 任务优先级，数字越大优先级越高。
+    :param run_at: 任务运行时间。
+    """
+    # 设置 ID
+    # 获取 caller 信息
+    def _task_decorator(func: Callable[P, R]) -> Callable[P, R]:
+        nonlocal description, task_id
+        description = description or func.__doc__ or ''
+        # TODO: task_id 冲突检测
+        task_id = task_id or func.__name__
+        task = Task(name, task_id, description, _placeholder, priority, run_at)
+        task_registry[name] = task
+        logger.debug(f'Task "{name}" registered.')
+        if pass_through:
+            return func
+        else:
+            def _wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
+                current_callstack.append(task)
+                vars = ContextStackVars.push(screenshot_mode=screenshot_mode)
+                ret = func(*args, **kwargs)
+                ContextStackVars.pop()
+                current_callstack.pop()
+                return ret
+            task.func = _wrapper
+            return _wrapper
+    return _task_decorator
+
+@overload
+def action(func: Callable[P, R]) -> Callable[P, R]: ...
+
+@deprecated('Use `action` with screenshot_mode=`manual` instead.')
+@overload
+def action(
+    name: str,
+    *,
+    description: str|None = None,
+    pass_through: bool = False,
+    priority: int = 0,
+    screenshot_mode: Literal['manual-inherit'],
+) -> Callable[[Callable[P, R]], Callable[P, R]]: ...
+
+@overload
+def action(
+    name: str,
+    *,
+    description: str|None = None,
+    pass_through: bool = False,
+    priority: int = 0,
+    screenshot_mode: ScreenshotMode | None = None,
+) -> Callable[[Callable[P, R]], Callable[P, R]]:
+    """
+    `action` 装饰器，用于标记一个函数为动作函数。
+
+    :param name: 动作名称。如果为 None，则使用函数的名称作为名称。
+    :param description: 动作描述。如果为 None，则使用函数的 docstring 作为描述。
+    :param pass_through: 
+        默认情况下， @action 装饰器会包裹动作函数，跟踪其执行情况。
+        如果不想跟踪，则设置此参数为 False。
+    :param priority: 动作优先级，数字越大优先级越高。
+    :param screenshot_mode: 截图模式。
+    """
+    ...
+
+def action(*args, **kwargs):
+    def _register(func: Callable, name: str, description: str|None = None, priority: int = 0) -> Action:
+        description = description or func.__doc__ or ''
+        action = Action(name, description, func, priority)
+        action_registry[name] = action
+        logger.debug(f'Action "{name}" registered.')
+        return action
+
+    if len(args) == 1 and isinstance(args[0], Callable):
+        func = args[0]
+        action = _register(_placeholder, func.__name__, func.__doc__)
+        def _wrapper(*args: P.args, **kwargs: P.kwargs):
+            current_callstack.append(action)
+            vars = ContextStackVars.push()
+            ret = func(*args, **kwargs)
+            ContextStackVars.pop()
+            current_callstack.pop()
+            return ret
+        action.func = _wrapper
+        return _wrapper
+    else:
+        name = args[0]
+        description = kwargs.get('description', None)
+        pass_through = kwargs.get('pass_through', False)
+        priority = kwargs.get('priority', 0)
+        screenshot_mode = kwargs.get('screenshot_mode', None)
+        if screenshot_mode == 'manual-inherit':
+            warnings.warn('`screenshot_mode=manual-inherit` is deprecated. Use `screenshot_mode=manual` instead.')
+        def _action_decorator(func: Callable):
+            nonlocal pass_through
+            action = _register(_placeholder, name, description)
+            pass_through = kwargs.get('pass_through', False)
+            if pass_through:
+                return func
+            else:
+                def _wrapper(*args: P.args, **kwargs: P.kwargs):
+                    current_callstack.append(action)
+                    vars = ContextStackVars.push(screenshot_mode=screenshot_mode)
+                    ret = func(*args, **kwargs)
+                    ContextStackVars.pop()
+                    current_callstack.pop()
+                    return ret
+                action.func = _wrapper
+                return _wrapper
+        return _action_decorator
+
+def tasks_from_id(task_ids: list[str]) -> list[Task]:
+    result = []
+    for tid in task_ids:
+        target = next(task for task in task_registry.values() if task.id == tid)
+        if target is None:
+            raise TaskNotFoundError(f'Task "{tid}" not found.')
+        result.append(target)
     return result

kotonebot/backend/core.py

@@ -1,129 +1,86 @@
-import logging
-from functools import cache
-from typing import Callable
-from typing_extensions import deprecated
-
-import cv2
-from cv2.typing import MatLike
-
-from kotonebot.util import cv2_imread
-from kotonebot.primitives import RectTuple, Rect, Point
-from kotonebot.errors import ResourceFileMissingError
-
-@deprecated('unused')
-class Ocr:
-    def __init__(
-        self,
-        text: str | Callable[[str], bool],
-        *,
-        language: str = 'jp',
-    ):
-        self.text = text
-        self.language = language
-
-# TODO: 这个类和 kotonebot.primitives.Image 重复了
-@deprecated('Use kotonebot.primitives.Image instead.')
-class Image:
-    def __init__(
-        self,
-        *,
-        path: str | None = None,
-        name: str | None = 'untitled',
-        data: MatLike | None = None,
-    ):
-        self.path = path
-        self.name = name
-        self.__data: MatLike | None = data
-        self.__data_with_alpha: MatLike | None = None
-
-    @cache
-    def binary(self) -> 'Image':
-        return Image(data=cv2.cvtColor(self.data, cv2.COLOR_BGR2GRAY))
-
-    @property
-    def data(self) -> MatLike:
-        if self.__data is None:
-            if self.path is None:
-                raise ValueError('Either path or data must be provided.')
-            self.__data = cv2_imread(self.path)
-            if self.__data is None:
-                raise ResourceFileMissingError(self.path, 'sprite')
-            logger.debug(f'Read image "{self.name}" from {self.path}')
-        return self.__data
-    
-    @property
-    def data_with_alpha(self) -> MatLike:
-        if self.__data_with_alpha is None:
-            if self.path is None:
-                raise ValueError('Either path or data must be provided.')
-            self.__data_with_alpha = cv2_imread(self.path, cv2.IMREAD_UNCHANGED)
-            if self.__data_with_alpha is None:
-                raise ResourceFileMissingError(self.path, 'sprite with alpha')
-            logger.debug(f'Read image "{self.name}" from {self.path}')
-        return self.__data_with_alpha
-    
-    def __repr__(self) -> str:
-        if self.path is None:
-            return f'<Image: memory>'
-        else:
-            return f'<Image: "{self.name}" at {self.path}>'
-
-# TODO: 这里的其他类应该移动到 primitives 模块下面
-class HintBox(Rect):
-    def __init__(
-        self,
-        x1: int,
-        y1: int,
-        x2: int,
-        y2: int,
-        *,
-        name: str | None = None,
-        description: str | None = None,
-        source_resolution: tuple[int, int],
-    ):
-        super().__init__(x1, y1, x2 - x1, y2 - y1, name=name)
-        self.description = description
-        self.source_resolution = source_resolution
-
-    @property
-    def width(self) -> int:
-        return self.x2 - self.x1
-    
-    @property
-    def height(self) -> int:
-        return self.y2 - self.y1
-    
-    @property
-    def rect(self) -> RectTuple:
-        return self.x1, self.y1, self.width, self.height
-
-class HintPoint(Point):
-    def __init__(self, x: int, y: int, *, name: str | None = None, description: str | None = None):
-        super().__init__(x, y, name=name)
-        self.description = description
-
-    def __repr__(self) -> str:
-        return f'HintPoint<"{self.name}" at ({self.x}, {self.y})>'
-
-def unify_image(image: MatLike | str | Image, transparent: bool = False) -> MatLike:
-    if isinstance(image, str):
-        if not transparent:
-            image = cv2_imread(image)
-        else:
-            image = cv2_imread(image, cv2.IMREAD_UNCHANGED)
-    elif isinstance(image, Image):
-        if transparent:
-            image = image.data_with_alpha
-        else:
-            image = image.data
-    return image
-
-logger = logging.getLogger(__name__)
-
-
-if __name__ == '__main__':
-    hint_box = HintBox(100, 100, 200, 200, source_resolution=(1920, 1080))
-    print(hint_box.rect)
-    print(hint_box.width)
-    print(hint_box.height)
-
+import logging
+from typing import TYPE_CHECKING, Callable
+from typing_extensions import deprecated
+
+import cv2
+from cv2.typing import MatLike
+
+from kotonebot.util import cv2_imread
+from kotonebot.primitives import RectTuple, Rect, Point
+if TYPE_CHECKING:
+    from kotonebot.primitives.visual import Image
+else:
+    from kotonebot.primitives.visual import Image as _PrimitivesImage
+    Image = deprecated('Use kotonebot.primitives.Image instead.')(_PrimitivesImage)
+
+@deprecated('unused')
+class Ocr:
+    def __init__(
+        self,
+        text: str | Callable[[str], bool],
+        *,
+        language: str = 'jp',
+    ):
+        self.text = text
+        self.language = language
+
+
+# TODO: 这里的其他类应该移动到 primitives 模块下面
+class HintBox(Rect):
+    def __init__(
+        self,
+        x1: int,
+        y1: int,
+        x2: int,
+        y2: int,
+        *,
+        name: str | None = None,
+        description: str | None = None,
+        source_resolution: tuple[int, int],
+    ):
+        super().__init__(x1, y1, x2 - x1, y2 - y1, name=name)
+        self.description = description
+        self.source_resolution = source_resolution
+
+    @property
+    def width(self) -> int:
+        return self.x2 - self.x1
+    
+    @property
+    def height(self) -> int:
+        return self.y2 - self.y1
+    
+    @property
+    def rect(self) -> RectTuple:
+        return self.x1, self.y1, self.width, self.height
+
+class HintPoint(Point):
+    def __init__(self, x: int, y: int, *, name: str | None = None, description: str | None = None):
+        super().__init__(x, y, name=name)
+        self.description = description
+
+    def __repr__(self) -> str:
+        return f'HintPoint<"{self.name}" at ({self.x}, {self.y})>'
+
+def unify_image(image: MatLike | str | Image, transparent: bool = False) -> MatLike:
+    if isinstance(image, str):
+        if not transparent:
+            image = cv2_imread(image)
+        else:
+            image = cv2_imread(image, cv2.IMREAD_UNCHANGED)
+    elif isinstance(image, Image):
+        if transparent:
+            image = image.data_with_alpha
+        else:
+            image = image.data
+    return image
+
+logger = logging.getLogger(__name__)
+
+
+if __name__ == '__main__':
+    hint_box = HintBox(100, 100, 200, 200, source_resolution=(1920, 1080))
+    print(hint_box.rect)
+    print(hint_box.width)
+    print(hint_box.height)
+