reydb 1.1.60__py3-none-any.whl → 1.2.0__py3-none-any.whl

reydb/rerror.py

@@ -9,29 +9,37 @@
 """
 
 
-from typing import Any
+from typing import Any, NoReturn, TypeVar, Generic
 from collections.abc import Callable
+from inspect import iscoroutinefunction
 from traceback import StackSummary
 from functools import wraps as functools_wraps
+from datetime import datetime as Datetime
 from reykit.rbase import T, Exit, catch_exc
 
 from . import rdb
 from .rbase import DatabaseBase
+from .rorm import DatabaseORM as orm
 
 
 __all__ = (
+    'DatabaseErrorSuper',
     'DatabaseError',
+    'DatabaseErrorAsync'
 )
 
 
-class DatabaseError(DatabaseBase):
+DatabaseT = TypeVar('DatabaseT', 'rdb.Database', 'rdb.DatabaseAsync')
+
+
+class DatabaseErrorSuper(DatabaseBase, Generic[DatabaseT]):
     """
-    Database error type.
+    Database error super type.
     Can create database used `self.build_db` method.
     """
 
 
-    def __init__(self, db: 'rdb.Database') -> None:
+    def __init__(self, db: DatabaseT) -> None:
         """
         Build instance attributes.
 
@@ -42,102 +50,41 @@ class DatabaseError(DatabaseBase):
 
         # Build.
         self.db = db
-
-        ## Database path name.
         self.db_names = {
-            'base': 'base',
-            'base.error': 'error',
-            'base.stats_error': 'stats_error'
+            'error': 'error',
+            'stats_error': 'stats_error'
         }
 
 
-    def build_db(self) -> None:
+    def handle_build_db(self) -> None:
         """
-        Check and build database tables, by `self.db_names`.
+        Handle method of check and build database tables, by `self.db_names`.
         """
 
-        # Set parameter.
-
-        ## Database.
-        databases = [
-            {
-                'name': self.db_names['base']
-            }
-        ]
+        # Handle parameter.
 
         ## Table.
-        tables = [
-
-            ### 'error'.
-            {
-                'path': (self.db_names['base'], self.db_names['base.error']),
-                'fields': [
-                    {
-                        'name': 'create_time',
-                        'type': 'datetime',
-                        'constraint': 'NOT NULL DEFAULT CURRENT_TIMESTAMP',
-                        'comment': 'Record create time.'
-                    },
-                    {
-                        'name': 'id',
-                        'type': 'int unsigned',
-                        'constraint': 'NOT NULL AUTO_INCREMENT',
-                        'comment': 'ID.'
-                    },
-                    {
-                        'name': 'type',
-                        'type': 'varchar(50)',
-                        'constraint': 'NOT NULL',
-                        'comment': 'Error type.'
-                    },
-                    {
-                        'name': 'data',
-                        'type': 'json',
-                        'comment': 'Error data.'
-                    },
-                    {
-                        'name': 'stack',
-                        'type': 'json',
-                        'comment': 'Error code traceback stack.'
-                    },
-                    {
-                        'name': 'note',
-                        'type': 'varchar(500)',
-                        'comment': 'Error note.'
-                    }
-                ],
-                'primary': 'id',
-                'indexes': [
-                    {
-                        'name': 'n_create_time',
-                        'fields': 'create_time',
-                        'type': 'noraml',
-                        'comment': 'Record create time normal index.'
-                    },
-                    {
-                        'name': 'n_type',
-                        'fields': 'type',
-                        'type': 'noraml',
-                        'comment': 'Error type normal index.'
-                    }
-                ],
-                'comment': 'Error log table.'
-            },
-
-        ]
+        class error(orm.Model, table=True):
+            __name__ = self.db_names['error']
+            __comment__ = 'Error log table.'
+            create_time: Datetime = orm.Field(field_default='CURRENT_TIMESTAMP', not_null=True, index_n=True, comment='Record create time.')
+            id: int = orm.Field(field_name='idd', field_type=orm.types_mysql.INTEGER(unsigned=True), key=True, key_auto=True, not_null=True, comment='ID.')
+            type: str = orm.Field(field_type=orm.types.VARCHAR(50), not_null=True, index_n=True, comment='Error type.')
+            data: str = orm.Field(field_type=orm.types.JSON, comment='Error data.')
+            stack: str = orm.Field(field_type=orm.types.JSON, comment='Error code traceback stack.')
+            note: str = orm.Field(field_type=orm.types.VARCHAR(500), comment='Error note.')
+        tables = [error]
 
         ## View stats.
         views_stats = [
-
-            ### 'stats_error'.
             {
-                'path': (self.db_names['base'], self.db_names['base.stats_error']),
+                'path': self.db_names['stats_error'],
                 'items': [
                     {
                         'name': 'count',
                         'select': (
                             'SELECT COUNT(1)\n'
-                            f'FROM `{self.db_names['base']}`.`{self.db_names['base.error']}`'
+                            f'FROM `{self.db.database}`.`{self.db_names['error']}`'
                         ),
                         'comment': 'Error log count.'
                     },
@@ -145,7 +92,7 @@ class DatabaseError(DatabaseBase):
                         'name': 'past_day_count',
                         'select': (
                             'SELECT COUNT(1)\n'
-                            f'FROM `{self.db_names['base']}`.`{self.db_names['base.error']}`\n'
+                            f'FROM `{self.db.database}`.`{self.db_names['error']}`\n'
                             'WHERE TIMESTAMPDIFF(DAY, `create_time`, NOW()) = 0'
                         ),
                         'comment': 'Error log count in the past day.'
@@ -154,7 +101,7 @@ class DatabaseError(DatabaseBase):
                         'name': 'past_week_count',
                         'select': (
                             'SELECT COUNT(1)\n'
-                            f'FROM `{self.db_names['base']}`.`{self.db_names['base.error']}`\n'
+                            f'FROM `{self.db.database}`.`{self.db_names['error']}`\n'
                             'WHERE TIMESTAMPDIFF(DAY, `create_time`, NOW()) <= 6'
                         ),
                         'comment': 'Error log count in the past week.'
@@ -163,7 +110,7 @@ class DatabaseError(DatabaseBase):
                         'name': 'past_month_count',
                         'select': (
                             'SELECT COUNT(1)\n'
-                            f'FROM `{self.db_names['base']}`.`{self.db_names['base.error']}`\n'
+                            f'FROM `{self.db.database}`.`{self.db_names['error']}`\n'
                             'WHERE TIMESTAMPDIFF(DAY, `create_time`, NOW()) <= 29'
                         ),
                         'comment': 'Error log count in the past month.'
@@ -172,21 +119,18 @@ class DatabaseError(DatabaseBase):
                         'name': 'last_time',
                         'select': (
                             'SELECT MAX(`create_time`)\n'
-                            f'FROM `{self.db_names['base']}`.`{self.db_names['base.error']}`'
+                            f'FROM `{self.db.database}`.`{self.db_names['error']}`'
                         ),
                         'comment': 'Error log last record create time.'
                     }
                 ]
-
             }
-
         ]
 
-        # Build.
-        self.db.build.build(databases, tables, views_stats=views_stats)
+        return tables, views_stats
 
 
-    def record(
+    def handle_record(
         self,
         exc: BaseException,
         stack: StackSummary,
@@ -221,13 +165,87 @@ class DatabaseError(DatabaseBase):
             'note': note
         }
 
+        return data
+
+
+class DatabaseError(DatabaseErrorSuper['rdb.Database']):
+    """
+    Database error type.
+    Can create database used `self.build_db` method.
+    """
+
+
+    def build_db(self) -> None:
+        """
+        Check and build database tables, by `self.db_names`.
+        """
+
+        # Handle parameter.
+        tables, views_stats = self.handle_build_db()
+
+        # Build.
+        self.db.build.build(tables=tables, views_stats=views_stats, skip=True)
+
+
+    def record(
+        self,
+        exc: BaseException,
+        stack: StackSummary,
+        note: str | None = None
+    ) -> None:
+        """
+        Insert exception information into the table of database.
+
+        Parameters
+        ----------
+        exc : Exception instance.
+        stack : Exception traceback stack instance.
+        note : Exception note.
+        """
+
+        # Handle parameter.
+        data = self.handle_record(exc, stack, note)
+
         # Insert.
         self.db.execute.insert(
-            self.db_names['base.error'],
+            self.db_names['error'],
             data=data
         )
 
 
+    __call__ = record
+
+
+    def record_catch(
+        self,
+        note: str | None = None,
+        filter_type : BaseException | tuple[BaseException, ...] = Exit
+    ) -> NoReturn:
+        """
+        Catch and insert exception information into the table of database and throw exception, must used in except syntax.
+
+        Parameters
+        ----------
+        note : Exception note.
+        filter_type : Exception types of not insert, but still throw exception.
+        """
+
+        # Handle parameter.
+        _, exc, stack = catch_exc()
+
+        # Filter.
+        for type_ in filter_type:
+            if isinstance(exc, type_):
+                break
+
+        # Record.
+        else:
+            self.record(exc, stack, note)
+
+        # Throw exception.
+        raise
+
+
     def wrap(
         self,
         func: Callable[..., T] | None = None,
@@ -236,13 +254,13 @@ class DatabaseError(DatabaseBase):
         filter_type : BaseException | tuple[BaseException, ...] = Exit
     ) -> T | Callable[[Callable[..., T]], Callable[..., T]]:
         """
-        Decorator, insert exception information into the table of database, throw exception.
+        Decorator, insert exception information into the table of database and throw exception.
 
         Parameters
         ----------
         func : Function.
         note : Exception note.
-        filter_type : Exception type of not inserted, but still throw exception.
+        filter_type : Exception types of not insert, but still throw exception.
 
         Returns
         -------
@@ -251,21 +269,21 @@ class DatabaseError(DatabaseBase):
         Examples
         --------
         Method one.
-        >>> @wrap_error
+        >>> @wrap
         >>> def func(*args, **kwargs): ...
 
         Method two.
-        >>> @wrap_error(**wrap_kwargs)
+        >>> @wrap(**wrap_kwargs)
         >>> def func(*args, **kwargs): ...
 
         Method three.
         >>> def func(*args, **kwargs): ...
-        >>> func = wrap_error(func, **wrap_kwargs)
+        >>> func = wrap(func, **wrap_kwargs)
 
         Method four.
         >>> def func(*args, **kwargs): ...
-        >>> wrap_error = wrap_error(**wrap_kwargs)
-        >>> func = wrap_error(func)
+        >>> wrap = wrap(**wrap_kwargs)
+        >>> func = wrap(func)
 
         >>> func(*args, **kwargs)
         """
@@ -308,18 +326,191 @@ class DatabaseError(DatabaseBase):
                 try:
                     result = func_(*args, **kwargs)
 
-                # Log.
+                # Record.
                 except BaseException:
-                    _, exc, stack = catch_exc()
+                    self.record_catch(note, filter_type)
+
+                return result
+
+
+            return _func
+
+
+        # Decorator.
+        if func is None:
+            return _wrap
+
+        # Decorated function.
+        else:
+            _func = _wrap(func)
+            return _func
+
+
+class DatabaseErrorAsync(DatabaseErrorSuper['rdb.DatabaseAsync']):
+    """
+    Asynchrouous database error type.
+    Can create database used `self.build_db` method.
+    """
+
+
+    async def build_db(self) -> None:
+        """
+        Asynchrouous check and build database tables, by `self.db_names`.
+        """
+
+        # Handle parameter.
+        tables, views_stats = self.handle_build_db()
+
+        # Build.
+        await self.db.build.build(tables=tables, views_stats=views_stats, skip=True)
+
+
+    async def record(
+        self,
+        exc: BaseException,
+        stack: StackSummary,
+        note: str | None = None
+    ) -> None:
+        """
+        Asynchrouous insert exception information into the table of database.
+
+        Parameters
+        ----------
+        exc : Exception instance.
+        stack : Exception traceback stack instance.
+        note : Exception note.
+        """
+
+        # Handle parameter.
+        data = self.handle_record(exc, stack, note)
+
+        # Insert.
+        await self.db.execute.insert(
+            self.db_names['error'],
+            data=data
+        )
+
+
+    __call__ = record
 
-                    ## Filter.
-                    for type_ in filter_type:
-                        if isinstance(exc, type_):
-                            break
+
+    async def record_catch(
+        self,
+        note: str | None = None,
+        filter_type : BaseException | tuple[BaseException, ...] = Exit
+    ) -> NoReturn:
+        """
+        Asynchrouous catch and insert exception information into the table of database and throw exception, must used in except syntax.
+
+        Parameters
+        ----------
+        note : Exception note.
+        filter_type : Exception types of not insert, but still throw exception.
+        """
+
+        # Handle parameter.
+        _, exc, stack = catch_exc()
+
+        # Filter.
+        for type_ in filter_type:
+            if isinstance(exc, type_):
+                break
+
+        # Record.
+        else:
+            await self.record(exc, stack, note)
+
+        # Throw exception.
+        raise
+
+
+    def wrap(
+        self,
+        func: Callable[..., T] | None = None,
+        *,
+        note: str | None = None,
+        filter_type : BaseException | tuple[BaseException, ...] = Exit
+    ) -> T | Callable[[Callable[..., T]], Callable[..., T]]:
+        """
+        Asynchrouous decorator, insert exception information into the table of database, throw exception.
+
+        Parameters
+        ----------
+        func : Function.
+        note : Exception note.
+        filter_type : Exception types of not insert, but still throw exception.
+
+        Returns
+        -------
+        Decorated function or decorator with parameter.
+
+        Examples
+        --------
+        Method one.
+        >>> @wrap
+        >>> [async ]def func(*args, **kwargs): ...
+
+        Method two.
+        >>> @wrap(**wrap_kwargs)
+        >>> [async ]def func(*args, **kwargs): ...
+
+        Method three.
+        >>> [async ]def func(*args, **kwargs): ...
+        >>> func = wrap(func, **wrap_kwargs)
+
+        Method four.
+        >>> [async ]def func(*args, **kwargs): ...
+        >>> wrap = wrap(**wrap_kwargs)
+        >>> func = wrap(func)
+
+        Must asynchrouous execute.
+        >>> await func(*args, **kwargs)
+        """
+
+        # Handle parameter.
+        if issubclass(filter_type, BaseException):
+            filter_type = (filter_type,)
+
+
+        def _wrap(func_: Callable[..., T]) -> Callable[..., T]:
+            """
+            Decorator, insert exception information into the table of database.
+
+            Parameters
+            ----------
+            _func : Function.
+
+            Returns
+            -------
+            Decorated function.
+            """
+
+
+            @functools_wraps(func_)
+            async def _func(*args, **kwargs) -> Any:
+                """
+                Decorated function.
+
+                Parameters
+                ----------
+                args : Position arguments of function.
+                kwargs : Keyword arguments of function.
+
+                Returns
+                -------
+                Function return.
+                """
+
+                # Try execute.
+                try:
+                    if iscoroutinefunction(func_):
+                        result = await func_(*args, **kwargs)
                     else:
-                        self.record(exc, stack, note)
+                        result = func_(*args, **kwargs)
 
-                    raise
+                # Record.
+                except BaseException:
+                    await self.record_catch(note, filter_type)
 
                 return result
 
@@ -335,5 +526,3 @@ class DatabaseError(DatabaseBase):
         else:
             _func = _wrap(func)
             return _func
-
-    __call__ = record