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

reywechat/rexception.py

@@ -0,0 +1,65 @@
+# !/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+@Time    : 2024-07-17 10:49:26
+@Author  : Rey
+@Contact : reyxbo@163.com
+@Explain : Exception methods.
+"""
+
+
+from reykit.rexception import RError, RActiveError
+
+
+__all__ = (
+    'RWeChatError',
+    'RWeChatExecuteError',
+    'RWeChatExecuteContinueError',
+    'RWeChatExecuteBreakError',
+    'RWeChatExecuteReplyError',
+    'RWeChatExecuteNoRuleReplyError',
+    'RWeChatExecuteTriggerReplyError'
+)
+
+
+class RWeChatError(RError):
+    """
+    Rey's `WeChat error` type.
+    """
+
+
+class RWeChatExecuteError(RWeChatError):
+    """
+    Rey's `WeChat execute error` type.
+    """
+
+
+class RWeChatExecuteContinueError(RActiveError, RWeChatExecuteError):
+    """
+    Rey's `WeChat execute continue error` type.
+    """
+
+
+class RWeChatExecuteBreakError(RActiveError, RWeChatExecuteError):
+    """
+    Rey's `WeChat execute break error` type.
+    """
+
+
+class RWeChatExecuteReplyError(RWeChatExecuteError):
+    """
+    Rey's `WeChat execute reply error` type.
+    """
+
+
+class RWeChatExecuteNoRuleReplyError(RWeChatExecuteReplyError):
+    """
+    Rey's `WeChat execute no rule reply error` type.
+    """
+
+
+class RWeChatExecuteTriggerReplyError(RWeChatExecuteReplyError):
+    """
+    Rey's `WeChat execute trigger function reply error` type.
+    """

reywechat/rexecute.py

@@ -0,0 +1,201 @@
+# !/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+@Time    : 2024-07-16 16:20:34
+@Author  : Rey
+@Contact : reyxbo@163.com
+@Explain : Execute methods.
+"""
+
+
+from typing import Any, TypedDict, Literal, NoReturn
+from collections.abc import Callable
+from reykit.rexception import catch_exc
+
+from .rexception import RWeChatExecuteContinueError, RWeChatExecuteBreakError
+from .rreceive import RMessage, RReceive
+
+
+__all__ = (
+    'RExecute',
+)
+
+
+Rule = TypedDict('Rule', {'mode': Literal['trigger', 'reply'], 'executer': Callable[[RMessage], None], 'level': float})
+
+
+class RExecute(object):
+    """
+    Rey's `execute` type.
+    """
+
+
+    def __init__(
+        self,
+        rreceive: RReceive
+    ) -> None:
+        """
+        Build `execute` attributes.
+
+        Parameters
+        ----------
+        rreceive : `RReceive` instance.
+        """
+
+        # Set attribute.
+        self.rreceive = rreceive
+        self.rules: list[Rule] = []
+
+        # Add handler.
+        self.handler = self._execute_by_rule()
+
+        # Add executer.
+        self._add_execute_valid()
+
+
+    def _execute_by_rule(self) -> Callable[[RMessage], None]:
+        """
+        Add handler, execute message by rules.
+
+        Returns
+        -------
+        Handler.
+        """
+
+
+        # Define.
+        def handler_execute_by_rule(rmessage: RMessage) -> None:
+            """
+            Execute message by rules.
+
+            Parameters
+            ----------
+            rmessage : `RMessage` instance.
+            """
+
+            # Loop.
+            for rule in self.rules:
+                rmessage.ruling = rule
+
+                # Break.
+                if (
+                    rule['mode'] == 'reply'
+                    and rmessage.replied
+                ):
+                    break
+
+                # Execute.
+                try:
+                    rule['executer'](rmessage)
+
+                # Continue.
+                except RWeChatExecuteContinueError:
+                    continue
+
+                # Break.
+                except RWeChatExecuteBreakError:
+                    break
+
+                # Exception.
+                except:
+
+                    ## Catch exception.
+                    exc_report, *_ = catch_exc()
+
+                    ## Save.
+                    rmessage.exc_reports.append(exc_report)
+
+                finally:
+                    rmessage.ruling = None
+
+
+        # Add handler.
+        self.rreceive.add_handler(handler_execute_by_rule)
+
+        return handler_execute_by_rule
+
+
+    def add_rule(
+        self,
+        mode: Literal['trigger', 'reply'],
+        executer: Callable[[RMessage], Any],
+        level: float = 0
+    ) -> None:
+        """
+        Add execute rule.
+
+        Parameters
+        ----------
+        mode : Execute mode.
+        executer : Function of execute. The parameter is the `RMessage` instance.
+            When throw `RWeChatExecuteContinueError` type exception, then continue next execution.
+            When throw `RWeChatExecuteBreakError` type exception, then stop executes.
+        level : Priority level, sort from large to small.
+        """
+
+        # Get parameter.
+        rule = {
+            'mode': mode,
+            'executer': executer,
+            'level': level
+        }
+
+        # Add.
+        self.rules.append(rule)
+
+        # Sort.
+        fund_sort = lambda rule: rule['level']
+        self.rules.sort(
+            key=fund_sort,
+            reverse=True
+        )
+
+
+    def continue_(self) -> NoReturn:
+        """
+        Continue execute by throwing `RWeChatExecuteContinueError` type exception.
+        """
+
+        # Raise.
+        raise RWeChatExecuteContinueError
+
+
+    def break_(self) -> NoReturn:
+        """
+        Break execute by throwing `RWeChatExecuteBreakError` type exception.
+        """
+
+        # Raise.
+        raise RWeChatExecuteBreakError
+
+
+    def _add_execute_valid(self) -> None:
+        """
+        Add executer, execute rule judge valid.
+
+        Returns
+        -------
+        Handler.
+        """
+
+
+        # Define.
+        def execute_valid(rmessage: RMessage) -> None:
+            """
+            Execute rule judge valid.
+
+            Parameters
+            ----------
+            rmessage : `RMessage` instance.
+            """
+
+            # Judge.
+            if not rmessage.valid:
+
+                # Break.
+                rmessage.execute_break()
+
+
+        # Add.
+        self.add_rule('trigger', execute_valid, float('inf'))

reywechat/rlog.py

@@ -0,0 +1,198 @@
+# !/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+@Time    : 2023-10-19 11:33:45
+@Author  : Rey
+@Contact : reyxbo@163.com
+@Explain : Log methods.
+"""
+
+
+from os.path import join as os_join
+from reykit.rlog import RLog as RRLog
+
+from .rreceive import RMessage
+from .rsend import RSendParam
+from .rwechat import RWeChat
+
+
+__all__ = (
+    'RLog',
+)
+
+
+class RLog(object):
+    """
+    Rey's `log` type.
+    """
+
+
+    def __init__(
+        self,
+        rwechat: RWeChat
+    ) -> None:
+        """
+        Build `log` attributes.
+
+        Parameters
+        ----------
+        rwechat : `RClient` instance.
+        """
+
+        # Set attribute.
+        self.rwechat = rwechat
+
+        # Logger.
+        self.rrlog = RRLog('WeChat')
+        self.rrlog_print = RRLog('WeChat.WeChatPrint')
+        self.rrlog_file = RRLog('WeChat.WeChatFile')
+
+        # Add handler.
+        self._add_handler()
+
+
+    def _add_handler(self) -> None:
+        """
+        Add log handler.
+        """
+
+        # Set parameter.
+        format_ = (
+            '%(format_time)s | '
+            '%(format_levelname)s | '
+            '%(format_message_)s'
+        )
+
+        # Add.
+
+        ## Reset.
+        self.rrlog_print.clear_handler()
+
+        ## Add handler print.
+        self.rrlog_print.add_print(format_=format_)
+
+        ## Add handler file.
+        file_path = os_join(self.rwechat.dir_log, 'WeChat')
+        self.rrlog_file.add_file(
+            file_path,
+            time='m',
+            format_=format_
+        )
+
+
+    @property
+    def print_colour(self) -> bool:
+        """
+        Whether print colour.
+
+        Returns
+        -------
+        Result.
+        """
+
+        # Get parameter.
+        result = self.rrlog.print_colour
+
+        return result
+
+
+    @print_colour.setter
+    def print_colour(self, value: bool) -> None:
+        """
+        Set whether print colour.
+
+        Parameters
+        ----------
+        value : Set value.
+        """
+
+        # Set.
+        self.rrlog.print_colour = value
+        self.rrlog_print.print_colour = value
+        self.rrlog_file.print_colour = value
+
+
+    def log_receive(
+        self,
+        rmessage: RMessage
+    ) -> None:
+        """
+        Log receive message.
+
+        Parameters
+        ----------
+        rmessage : `RMessage` instance.
+        """
+
+        # Generate record.
+        if rmessage.room is None:
+            message_object = rmessage.user
+        else:
+            message_object = rmessage.room
+        content_print = 'RECEIVE | %-20s' % message_object
+        content_file = 'RECEIVE | %s' % rmessage.params
+        if rmessage.exc_reports == []:
+            level = self.rrlog.INFO
+        else:
+            level = self.rrlog.ERROR
+            exc_report = '\n'.join(rmessage.exc_reports)
+            content_print = '%s\n%s' % (content_print, exc_report)
+            content_file = '%s\n%s' % (content_file, exc_report)
+
+        ## Add color.
+        if self.rrlog.print_colour:
+            color_code = self.rrlog.get_level_color_ansi(level)
+            content_print = f'{color_code}{content_print}\033[0m'
+
+        # Log.
+        self.rrlog_print.log(
+            format_message_=content_print,
+            level=level
+        )
+        self.rrlog_file.log(
+            format_message_=content_file,
+            level=level
+        )
+
+
+    def log_send(
+        self,
+        rsparam: RSendParam
+    ) -> None:
+        """
+        Log send message.
+
+        Parameters
+        ----------
+        rsparam : `RSendParams` instance.
+        """
+
+        # Generate record.
+        content_print = 'SEND    | %-20s' % rsparam.receive_id
+        content_file = 'SEND    | %s' % {
+            'receive_id': rsparam.receive_id,
+            **rsparam.params
+        }
+        if rsparam.exc_reports == []:
+            level = self.rrlog.INFO
+        else:
+            level = self.rrlog.ERROR
+            exc_report = '\n'.join(rsparam.exc_reports)
+            content_print = '%s\n%s' % (content_print, exc_report)
+            content_file = '%s\n%s' % (content_file, exc_report)
+
+        ## Add color.
+        if self.rrlog.print_colour:
+            color_code = self.rrlog.get_level_color_ansi(level)
+            content_print = f'{color_code}{content_print}\033[0m'
+
+        # Log.
+        self.rrlog_print.log(
+            format_message_=content_print,
+            level=level
+        )
+        self.rrlog_file.log(
+            format_message_=content_file,
+            level=level
+        )