reykit 1.0.0__py3-none-any.whl → 1.0.1__py3-none-any.whl

reywechat/rsend.py

@@ -0,0 +1,630 @@
+# !/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+@Time    : 2024-01-03 22:53:18
+@Author  : Rey
+@Contact : reyxbo@163.com
+@Explain : Send methods.
+"""
+
+
+from __future__ import annotations
+from typing import Any, Literal, Optional, Union, NoReturn, overload
+from collections.abc import Callable
+from functools import wraps as functools_wraps
+from os.path import join as os_join
+from queue import Queue
+from re import escape as re_escape
+from reykit.rcomm import get_file_stream_time
+from reykit.rexception import throw, catch_exc
+from reykit.rrandom import randn
+from reykit.rregex import sub
+from reykit.ros import RFile
+from reykit.rtime import sleep
+from reykit.rwrap import wrap_thread, wrap_exc
+
+from .rexception import RWeChatExecuteContinueError, RWeChatExecuteBreakError
+from .rwechat import RWeChat
+
+
+__all__ = (
+    'RSendParam',
+    'RSend'
+)
+
+
+class RSendParam(object):
+    """
+    Rey's `send parameters` type.
+    """
+
+
+    def __init__(
+        self,
+        rsend: RSend,
+        send_type: Literal[0, 1, 2, 3, 4, 5, 6, 7],
+        receive_id: str,
+        params: dict,
+        send_id: Optional[int]
+    ) -> None:
+        """
+        Build `send parameters` attributes.
+
+        Parameters
+        ----------
+        rsend : `RSend` instance.
+        send_type : Send type.
+            - `Literal[0]` Send text message, use `RClient.send_text`: method.
+            - `Literal[1]` Send text message with `@`, use `RClient.send_text_at`: method.
+            - `Literal[2]` Send file message, use `RClient.send_file`: method.
+            - `Literal[3]` Send image message, use `RClient.send_image`: method.
+            - `Literal[4]` Send emotion message, use `RClient.send_emotion`: method.
+            - `Literal[5]` Send pat message, use `RClient.send_pat`: method.
+            - `Literal[6]` Send public account message, use `RClient.send_public`: method.
+            - `Literal[7]` Forward message, use `RClient.send_forward`: method.
+        receive_id : User ID or chat room ID of receive message.
+        params : Send parameters.
+        send_id : Send ID of database.
+        """
+
+        # Set attribute.
+        self.rsend = rsend
+        self.send_type = send_type
+        self.receive_id = receive_id
+        self.params = params
+        self.send_id = send_id
+        self.cache_path: Optional[str] = None
+        self.exc_reports: list[str] = []
+
+
+class RSend(object):
+    """
+    Rey's `send` type.
+    """
+
+
+    def __init__(
+        self,
+        rwechat: RWeChat,
+        bandwidth_upstream: float
+    ) -> None:
+        """
+        Build `send` attributes.
+
+        Parameters
+        ----------
+        rwechat : `RClient` instance.
+        bandwidth_upstream : Upload bandwidth, impact send interval, unit Mpbs.
+        """
+
+        # Set attribute.
+        self.rwechat = rwechat
+        self.bandwidth_upstream = bandwidth_upstream
+        self.queue: Queue[RSendParam] = Queue()
+        self.handlers: list[Callable[[RSendParam], Any]] = []
+        self.started: Optional[bool] = False
+
+        # Start.
+        self._delete_cache_file()
+        self._start_sender()
+
+
+    @wrap_thread
+    def _start_sender(self) -> None:
+        """
+        Start sender, that will sequentially send message in the send queue.
+        """
+
+        # Loop.
+        while True:
+            match self.started:
+
+                ## Stop.
+                case False:
+                    sleep(0.1)
+                    continue
+
+                ## End.
+                case None:
+                    break
+
+            ## Send.
+            rsparam = self.queue.get()
+            try:
+                self._send(rsparam)
+
+            ## Exception.
+            except:
+
+                # Catch exception.
+                exc_report, *_ = catch_exc()
+
+                # Save.
+                rsparam.exc_reports.append(exc_report)
+
+
+            ## Handle.
+
+            ### Define.
+            def handle_handler_exception() -> None:
+                """
+                Handle Handler exception.
+                """
+
+                # Catch exception.
+                exc_report, *_ = catch_exc()
+
+                # Save.
+                rsparam.exc_reports.append(exc_report)
+
+
+            ### Loop.
+            for handler in self.handlers:
+                wrap_exc(
+                    handler,
+                    rsparam,
+                    _handler=handle_handler_exception
+                )
+
+            ## Log.
+            self.rwechat.rlog.log_send(rsparam)
+
+
+    def _delete_cache_file(self) -> None:
+        """
+        Add handler, Delete cache file.
+        """
+
+
+        # Define.
+        def handler_delete_cache_file(rsparam: RSendParam) -> None:
+            """
+            Delete cache file.
+
+            Parameters
+            ----------
+            rsparam : `RSendParams` instance.
+            """
+
+            # Break.
+            if rsparam.cache_path is None: return
+
+            # Delete.
+            rfile = RFile(rsparam.cache_path)
+            rfile.remove()
+
+
+        # Add handler.
+        self.add_handler(handler_delete_cache_file)
+
+
+    def _send(
+        self,
+        rsparam: RSendParam
+    ) -> None:
+        """
+        Send message.
+
+        Parameters
+        ----------
+        rsparam : `RSendParams` instance.
+        """
+
+        # Handle parameter.
+        for key, value in rsparam.params.items():
+
+            ## Callable.
+            if callable(value):
+                rsparam.params[key] = value()
+
+        # File.
+
+        ## From file ID.
+        if (file_id := rsparam.params.get('file_id')) is not None:
+            rsparam.params['path'], rsparam.params['file_name'] = self.rwechat.rdatabase._download_file(file_id)
+
+        ## Set file name.
+        if (
+            (path := rsparam.params.get('path')) is not None
+            and (file_name := rsparam.params.get('file_name')) is not None
+        ):
+            rfile = RFile(path)
+            copy_path = os_join(self.rwechat.dir_file, file_name)
+            rfile.copy(copy_path)
+            rsparam.cache_path = copy_path
+            path = copy_path
+
+        # Send.
+        match rsparam.send_type:
+
+            ## Text.
+            case 0:
+                self.rwechat.rclient.send_text(
+                    rsparam.receive_id,
+                    rsparam.params['text']
+                )
+
+            ## Text with '@'.
+            case 1:
+                self.rwechat.rclient.send_text_at(
+                    rsparam.receive_id,
+                    rsparam.params['user_id'],
+                    rsparam.params['text']
+                )
+
+            ## File.
+            case 2:
+                self.rwechat.rclient.send_file(
+                    rsparam.receive_id,
+                    path
+                )
+
+            ## Image.
+            case 3:
+                self.rwechat.rclient.send_image(
+                    rsparam.receive_id,
+                    path
+                )
+
+            ## Emotion.
+            case 4:
+                self.rwechat.rclient.send_emotion(
+                    rsparam.receive_id,
+                    path
+                )
+
+            ## Pat.
+            case 5:
+                self.rwechat.rclient.send_pat(
+                    rsparam.receive_id,
+                    rsparam.params['user_id']
+                )
+
+            ## Public account.
+            case 6:
+                self.rwechat.rclient.send_public(
+                    rsparam.receive_id,
+                    rsparam.params['page_url'],
+                    rsparam.params['title'],
+                    rsparam.params['text'],
+                    rsparam.params['image_url'],
+                    rsparam.params['public_name'],
+                    rsparam.params['public_id']
+                )
+
+            ## Forward.
+            case 7:
+                self.rwechat.rclient.send_forward(
+                    rsparam.receive_id,
+                    rsparam.params['message_id']
+                )
+
+            ## Throw exception.
+            case _:
+                throw(ValueError, rsparam.send_type)
+
+        # Wait.
+        self._wait(rsparam)
+
+
+    def _wait(
+        self,
+        rsparam: RSendParam
+    ) -> None:
+        """
+        Waiting after sending.
+
+        Parameters
+        ----------
+        rsparam : `RSendParams` instance.
+        """
+
+        # Get parameter.
+        seconds = randn(0.8, 1.2, precision=2)
+
+        ## File.
+        if rsparam.send_type in (2, 3, 4):
+            stream_time = get_file_stream_time(rsparam.params['path'], self.bandwidth_upstream)
+            if stream_time > seconds:
+                seconds = stream_time
+
+        # Wait.
+        sleep(seconds)
+
+
+    @overload
+    def send(
+        self,
+        send_type: Literal[0],
+        receive_id: str,
+        send_id: Optional[int] = None,
+        *,
+        text: str
+    ) -> None: ...
+
+    @overload
+    def send(
+        self,
+        send_type: Literal[1],
+        receive_id: str,
+        send_id: Optional[int] = None,
+        *,
+        user_id: Union[str, list[str], Literal['notify@all']],
+        text: str
+    ) -> None: ...
+
+    @overload
+    def send(
+        self,
+        send_type: Literal[2, 3, 4],
+        receive_id: str,
+        send_id: Optional[int] = None,
+        *,
+        path: str,
+        file_name: Optional[str] = None
+    ) -> None: ...
+
+    @overload
+    def send(
+        self,
+        send_type: Literal[5],
+        receive_id: str,
+        send_id: Optional[int] = None,
+        *,
+        user_id: str
+    ) -> None: ...
+
+    @overload
+    def send(
+        self,
+        send_type: Literal[6],
+        receive_id: str,
+        send_id: Optional[int] = None,
+        *,
+        page_url: str,
+        title: str,
+        text: Optional[str] = None,
+        image_url: Optional[str] = None,
+        public_name: Optional[str] = None,
+        public_id: Optional[str] = None
+    ) -> None: ...
+
+    @overload
+    def send(
+        self,
+        send_type: Literal[7],
+        receive_id: str,
+        send_id: Optional[int] = None,
+        *,
+        message_id: str
+    ) -> None: ...
+
+    @overload
+    def send(
+        self,
+        send_type: Any,
+        receive_id: str,
+        send_id: Optional[int] = None,
+        **params: Any
+    ) -> NoReturn: ...
+
+    def send(
+        self,
+        send_type: Optional[Literal[0, 1, 2, 3, 4, 5, 6, 7]] = None,
+        receive_id: Optional[str] = None,
+        send_id: Optional[int] = None,
+        **params: Any
+    ) -> None:
+        """
+        Put parameters into the send queue.
+
+        Parameters
+        ----------
+        send_type : Send type.
+            - `Literal[0]` Send text message, use `RClient.send_text`: method.
+            - `Literal[1]` Send text message with `@`, use `RClient.send_text_at`: method.
+            - `Literal[2]` Send file message, use `RClient.send_file`: method.
+            - `Literal[3]` Send image message, use `RClient.send_image`: method.
+            - `Literal[4]` Send emotion message, use `RClient.send_emotion`: method.
+            - `Literal[5]` Send pat message, use `RClient.send_pat`: method.
+            - `Literal[6]` Send public account message, use `RClient.send_public`: method.
+            - `Literal[7]` Forward message, use `RClient.send_forward`: method.
+        receive_id : User ID or chat room ID of receive message.
+        send_id : Send ID of database.
+        params : Send parameters.
+            - `Callable`: Use execute return value.
+            - `Any`: Use this value.
+                `Key 'file_name'`: Given file name.
+        """
+
+        # Check.
+        if send_type not in (0, 1, 2, 3, 4, 5, 6, 7):
+            throw(ValueError, send_type)
+
+        rsparam = RSendParam(
+            self,
+            send_type,
+            receive_id,
+            params,
+            send_id
+        )
+
+        # Put.
+        self.queue.put(rsparam)
+
+
+    def add_handler(
+        self,
+        handler: Callable[[RSendParam], Any]
+    ) -> None:
+        """
+        Add send handler function.
+
+        Parameters
+        ----------
+        handler : Handler method, input parameter is `RSendParam` instance.
+        """
+
+        # Add.
+        self.handlers.append(handler)
+
+
+    def add_at(
+        self,
+        text: str,
+        room_id: str
+    ) -> str:
+        """
+        Based on the user name in the text, automatic add `@` format.
+
+        Parameters
+        ----------
+        text : Text.
+        room_id : Chat room ID.
+
+        Returns
+        -------
+        Added text.
+        """
+
+        # Get parameter.
+        member_dict = self.rwechat.rclient.get_room_member_dict(room_id)
+        login_id = self.rwechat.rclient.login_info['id']
+        if login_id in member_dict:
+            del member_dict[login_id]
+
+        # Add.
+        names = [
+            re_escape(name)
+            for name in member_dict.values()
+            if len(name) != 1
+        ]
+        pattern = '(?<!@)(%s) *' % '|'.join(names)
+        replace = lambda match: '@%s ' % match[1]
+        text_at = sub(pattern, text, replace)
+
+        return text_at
+
+
+    def wrap_try_send(
+        self,
+        receive_id: Union[str, list[str]],
+        func: Callable
+    ) -> Callable:
+        """
+        Decorator, send exception information.
+
+        Parameters
+        ----------
+        receive_id : Receive user ID or chat room ID.
+            - `str`: An ID.
+            - `list[str]`: Multiple ID.
+        func : Function.
+
+        Returns
+        -------
+        Decorated function.
+        """
+
+        # Handle parameter.
+        if receive_id.__class__ == str:
+            receive_ids = [receive_id]
+        else:
+            receive_ids = receive_id
+
+        # Define.
+        @functools_wraps(func)
+        def wrap(
+            *arg: Any,
+            **kwargs: Any
+        ) -> Any:
+            """
+            Decorate.
+
+            Parameters
+            ----------
+            args : Position arguments of decorated function.
+            kwargs : Keyword arguments of decorated function.
+
+            Returns
+            -------
+            Function execution result.
+            """
+
+            # Execute.
+            try:
+                result = func(
+                    *arg,
+                    **kwargs
+                )
+            except:
+                *_, exc_instance, _ = catch_exc()
+
+                # Report.
+                if not isinstance(
+                    exc_instance,
+                    (RWeChatExecuteContinueError, RWeChatExecuteBreakError)
+                ):
+                    text = '\n'.join(
+                        [
+                            str(arg)
+                            for arg in exc_instance.args
+                        ]
+                    )
+                    for receive_id in receive_ids:
+                        self.send(
+                            0,
+                            receive_id,
+                            text=text
+                        )
+
+                # Throw exception.
+                raise exc_instance
+
+            return result
+
+
+        return wrap
+
+
+    def start(self) -> None:
+        """
+        Start sender.
+        """
+
+        # Start.
+        self.started = True
+
+        # Report.
+        print('Start sender.')
+
+
+    def stop(self) -> None:
+        """
+        Stop sender.
+        """
+
+        # Stop.
+        self.started = False
+
+        # Report.
+        print('Stop sender.')
+
+
+    def end(self) -> None:
+        """
+        End sender.
+        """
+
+        # End.
+        self.started = None
+
+        # Report.
+        print('End sender.')
+
+
+    __call__ = send
+
+
+    __del__ = end