reydb 1.1.59__py3-none-any.whl → 1.1.61__py3-none-any.whl

reydb/rconfig.py

@@ -9,8 +9,7 @@
 """
 
 
-from typing import TypedDict, TypeVar
-import datetime
+from typing import TypedDict, TypeVar, Generic
 from datetime import (
     datetime as Datetime,
     date as Date,
@@ -24,7 +23,9 @@ from .rbase import DatabaseBase
 
 
 __all__ = (
+    'DatabaseConfigSuper',
     'DatabaseConfig',
+    'DatabaseConfigAsync'
 )
 
 
@@ -32,11 +33,12 @@ type ConfigValue = bool | str | int | float | list | tuple | dict | set | Dateti
 ConfigRow = TypedDict('ConfigRow', {'key': str, 'value': ConfigValue, 'type': str, 'note': str | None})
 type ConfigTable = list[ConfigRow]
 ConfigValueT = TypeVar('T', bound=ConfigValue) # Any.
+DatabaseT = TypeVar('DatabaseT', 'rdb.Database', 'rdb.DatabaseAsync')
 
 
-class DatabaseConfig(DatabaseBase):
+class DatabaseConfigSuper(DatabaseBase, Generic[DatabaseT]):
     """
-    Database config type.
+    Database config super type.
     Can create database used `self.build_db` method.
 
     Examples
@@ -49,115 +51,75 @@ class DatabaseConfig(DatabaseBase):
     """
 
 
-    def __init__(self, db: 'rdb.Database') -> None:
+    def __init__(
+        self,
+        db: DatabaseT,
+        db_names: dict[str, str] | None = None
+    ) -> None:
         """
         Build instance attributes.
 
         Parameters
         ----------
         db: Database instance.
+        db_names: Update build database table names.
         """
 
         # Build.
         self.db = db
-
-        ## Database path name.
         self.db_names = {
-            'base': 'base',
-            'base.config': 'config',
-            'base.stats_config': 'stats_config'
+            'config': 'config',
+            'stats_config': 'stats_config'
         }
+        if db_names is not None:
+            self.db_names.update(db_names)
+
+
+class DatabaseConfig(DatabaseConfigSuper['rdb.Database']):
+    """
+    Database config type.
+    Can create database used `self.build_db` method.
+
+    Examples
+    --------
+    >>> config = DatabaseConfig()
+    >>> config['key1'] = 1
+    >>> config['key2', 'note'] = 2
+    >>> config['key1'], config['key2']
+    (1, 2)
+    """
 
 
     def build_db(self) -> None:
         """
-        Check and build all standard databases and tables, by `self.db_names`.
+        Check and build database tables, by `self.db_names`.
         """
 
-        # Set parameter.
-
-        ## Database.
-        databases = [
-            {
-                'name': self.db_names['base']
-            }
-        ]
+        # Handle parameter.
 
         ## Table.
-        tables = [
-
-            ### 'config'.
-            {
-                'path': (self.db_names['base'], self.db_names['base.config']),
-                'fields': [
-                    {
-                        'name': 'create_time',
-                        'type': 'datetime',
-                        'constraint': 'NOT NULL DEFAULT CURRENT_TIMESTAMP',
-                        'comment': 'Config create time.'
-                    },
-                    {
-                        'name': 'update_time',
-                        'type': 'datetime',
-                        'constraint': 'DEFAULT NULL ON UPDATE CURRENT_TIMESTAMP',
-                        'comment': 'Config update time.'
-                    },
-                    {
-                        'name': 'key',
-                        'type': 'varchar(50)',
-                        'constraint': 'NOT NULL',
-                        'comment': 'Config key.'
-                    },
-                    {
-                        'name': 'value',
-                        'type': 'text',
-                        'constraint': 'NOT NULL',
-                        'comment': 'Config value.'
-                    },
-                    {
-                        'name': 'type',
-                        'type': 'varchar(50)',
-                        'constraint': 'NOT NULL',
-                        'comment': 'Config value type.'
-                    },
-                    {
-                        'name': 'note',
-                        'type': 'varchar(500)',
-                        'comment': 'Config note.'
-                    }
-                ],
-                'primary': 'key',
-                'indexes': [
-                    {
-                        'name': 'n_create_time',
-                        'fields': 'create_time',
-                        'type': 'noraml',
-                        'comment': 'Config create time normal index.'
-                    },
-                    {
-                        'name': 'n_update_time',
-                        'fields': 'update_time',
-                        'type': 'noraml',
-                        'comment': 'Config update time normal index.'
-                    }
-                ],
-                'comment': 'Config data table.'
-            }
-
-        ]
+        class Config(self.db.orm.Model, table=True):
+            __name__ = self.db_names['config']
+            __comment__ = 'Config data table.'
+            create_time: Datetime = self.db.orm.Field(not_null=True, field_default='CURRENT_TIMESTAMP', index_n=True, comment='Config create time.')
+            update_time: Datetime = self.db.orm.Field(field_default='CURRENT_TIMESTAMP', index_n=True, comment='Config update time.')
+            key: str = self.db.orm.Field(type=self.db.orm.types.VARCHAR(50), key=True, not_null=True, comment='Config key.')
+            value: str = self.db.orm.Field(type=self.db.orm.types.TEXT, not_null=True, comment='Config value.')
+            type: str = self.db.orm.Field(type=self.db.orm.types.VARCHAR(50), not_null=True, comment='Config value type.')
+            note: str = self.db.orm.Field(type=self.db.orm.types.VARCHAR(500), comment='Config note.')
+
+        tables = [Config]
 
         ## View stats.
         views_stats = [
-
-            ### 'stats_config'.
             {
-                'path': (self.db_names['base'], self.db_names['base.stats_config']),
+                'path': (self.db.database, self.db_names['stats_config']),
                 'items': [
                     {
                         'name': 'count',
                         'select': (
                             'SELECT COUNT(1)\n'
-                            f'FROM `{self.db_names['base']}`.`{self.db_names['base.config']}`'
+                            f'FROM `{self.db_names['config']}`'
                         ),
                         'comment': 'Config count.'
                     },
@@ -165,7 +127,7 @@ class DatabaseConfig(DatabaseBase):
                         'name': 'last_create_time',
                         'select': (
                             'SELECT MAX(`create_time`)\n'
-                            f'FROM `{self.db_names['base']}`.`{self.db_names['base.config']}`'
+                            f'FROM `{self.db_names['config']}`'
                         ),
                         'comment': 'Config last record create time.'
                     },
@@ -173,21 +135,19 @@ class DatabaseConfig(DatabaseBase):
                         'name': 'last_update_time',
                         'select': (
                             'SELECT MAX(`update_time`)\n'
-                            f'FROM `{self.db_names['base']}`.`{self.db_names['base.config']}`'
+                            f'FROM `{self.db_names['config']}`'
                         ),
                         'comment': 'Config last record update time.'
                     }
                 ]
-
             }
 
         ]
 
         # Build.
-        self.db.build.build(databases, tables, views_stats=views_stats)
+        self.db.build.build(tables=tables, views_stats=views_stats, skip=True)
 
 
-    @property
     def data(self) -> ConfigTable:
         """
         Get config data table.
@@ -199,13 +159,13 @@ class DatabaseConfig(DatabaseBase):
 
         # Get.
         result = self.db.execute.select(
-            (self.db_names['base'], self.db_names['base.config']),
+            self.db_names['config'],
             ['key', 'value', 'type', 'note'],
             order='IFNULL(`update_time`, `create_time`) DESC'
         )
 
         # Convert.
-        global_dict = {'datetime': datetime}
+        global_dict = {'datetime': Datetime}
         result = [
             {
                 'key': row['key'],
@@ -235,7 +195,7 @@ class DatabaseConfig(DatabaseBase):
         # Get.
         where = '`key` = :key'
         result = self.db.execute.select(
-            (self.db_names['base'], self.db_names['base.config']),
+            self.db_names['config'],
             '`value`',
             where,
             limit=1,
@@ -247,7 +207,7 @@ class DatabaseConfig(DatabaseBase):
         if value is None:
             value = default
         else:
-            global_dict = {'datetime': datetime}
+            global_dict = {'datetime': Datetime}
             value = eval(value, global_dict)
 
         return value
@@ -260,7 +220,7 @@ class DatabaseConfig(DatabaseBase):
         default_note: str | None = None
     ) -> ConfigValue | ConfigValueT:
         """
-        Set config value.
+        Set config default value.
 
         Parameters
         ----------
@@ -281,7 +241,7 @@ class DatabaseConfig(DatabaseBase):
             'note': default_note
         }
         result = self.db.execute.insert(
-            (self.db_names['base'], self.db_names['base.config']),
+            self.db_names['config'],
             data,
             'ignore'
         )
@@ -322,7 +282,7 @@ class DatabaseConfig(DatabaseBase):
 
         # Update.
         self.db.execute.insert(
-            (self.db_names['base'], self.db_names['base.config']),
+            self.db_names['config'],
             data,
             'update'
         )
@@ -345,7 +305,7 @@ class DatabaseConfig(DatabaseBase):
             where = '`key` in :key'
             limit = None
         result = self.db.execute.delete(
-            (self.db_names['base'], self.db_names['base.config']),
+            self.db_names['base.config'],
             where,
             limit=limit,
             key=key
@@ -367,12 +327,12 @@ class DatabaseConfig(DatabaseBase):
 
         # Get.
         result = self.db.execute.select(
-            (self.db_names['base'], self.db_names['base.config']),
+            self.db_names['config'],
             ['key', 'value']
         )
 
         # Convert.
-        global_dict = {'datetime': datetime}
+        global_dict = {'datetime': Datetime}
         result = result.to_dict('key', 'value')
         result = {
             key: eval(value, global_dict)
@@ -393,12 +353,12 @@ class DatabaseConfig(DatabaseBase):
 
         # Get.
         result = self.db.execute.select(
-            (self.db_names['base'], self.db_names['base.config']),
+            self.db_names['config'],
             '`key`'
         )
 
         # Convert.
-        global_dict = {'datetime': datetime}
+        global_dict = {'datetime': Datetime}
         result = [
             eval(value, global_dict)
             for value in result
@@ -418,12 +378,12 @@ class DatabaseConfig(DatabaseBase):
 
         # Get.
         result = self.db.execute.select(
-            (self.db_names['base'], self.db_names['base.config']),
+            self.db_names['config'],
             '`value`'
         )
 
         # Convert.
-        global_dict = {'datetime': datetime}
+        global_dict = {'datetime': Datetime}
         result = [
             eval(value, global_dict)
             for value in result
@@ -480,7 +440,378 @@ class DatabaseConfig(DatabaseBase):
             'note': note
         }
         self.db.execute.insert(
-            (self.db_names['base'], self.db_names['base.config']),
+            self.db_names['config'],
+            data,
+            'update'
+        )
+
+
+class DatabaseConfigAsync(DatabaseConfigSuper['rdb.DatabaseAsync']):
+    """
+    Asynchronous database config type.
+    Can create database used `self.build_db` method.
+
+    Examples
+    --------
+    >>> config = DatabaseConfig()
+    >>> config['key1'] = 1
+    >>> config['key2', 'note'] = 2
+    >>> config['key1'], config['key2']
+    (1, 2)
+    """
+
+
+    async def build_db(self) -> None:
+        """
+        Asynchronous check and build database tables, by `self.db_names`.
+        """
+
+        # Handle parameter.
+
+        ## Table.
+        class Config(self.db.orm.Model, table=True):
+            __name__ = self.db_names['config']
+            __comment__ = 'Config data table.'
+            create_time: Datetime = self.db.orm.Field(not_null=True, field_default='CURRENT_TIMESTAMP', index_n=True, comment='Config create time.')
+            update_time: Datetime = self.db.orm.Field(field_default='CURRENT_TIMESTAMP', index_n=True, comment='Config update time.')
+            key: str = self.db.orm.Field(type=self.db.orm.types.VARCHAR(50), key=True, not_null=True, comment='Config key.')
+            value: str = self.db.orm.Field(type=self.db.orm.types.TEXT, not_null=True, comment='Config value.')
+            type: str = self.db.orm.Field(type=self.db.orm.types.VARCHAR(50), not_null=True, comment='Config value type.')
+            note: str = self.db.orm.Field(type=self.db.orm.types.VARCHAR(500), comment='Config note.')
+
+        tables = [Config]
+
+        ## View stats.
+        views_stats = [
+            {
+                'path': (self.db.database, self.db_names['stats_config']),
+                'items': [
+                    {
+                        'name': 'count',
+                        'select': (
+                            'SELECT COUNT(1)\n'
+                            f'FROM `{self.db_names['config']}`'
+                        ),
+                        'comment': 'Config count.'
+                    },
+                    {
+                        'name': 'last_create_time',
+                        'select': (
+                            'SELECT MAX(`create_time`)\n'
+                            f'FROM `{self.db_names['config']}`'
+                        ),
+                        'comment': 'Config last record create time.'
+                    },
+                    {
+                        'name': 'last_update_time',
+                        'select': (
+                            'SELECT MAX(`update_time`)\n'
+                            f'FROM `{self.db_names['config']}`'
+                        ),
+                        'comment': 'Config last record update time.'
+                    }
+                ]
+            }
+
+        ]
+
+        # Build.
+        await self.db.build.build(tables=tables, views_stats=views_stats, skip=True)
+
+
+    async def data(self) -> ConfigTable:
+        """
+        Asynchronous get config data table.
+
+        Returns
+        -------
+        Config data table.
+        """
+
+        # Get.
+        result = await self.db.execute.select(
+            self.db_names['config'],
+            ['key', 'value', 'type', 'note'],
+            order='IFNULL(`update_time`, `create_time`) DESC'
+        )
+
+        # Convert.
+        global_dict = {'datetime': Datetime}
+        result = [
+            {
+                'key': row['key'],
+                'value': eval(row['value'], global_dict),
+                'note': row['note']
+            }
+            for row in result
+        ]
+
+        return result
+
+
+    async def get(self, key: str, default: ConfigValueT | None = None) -> ConfigValue | ConfigValueT:
+        """
+        Asynchronous get config value, when not exist, then return default value.
+
+        Parameters
+        ----------
+        key : Config key.
+        default : Config default value.
+
+        Returns
+        -------
+        Config value.
+        """
+
+        # Get.
+        where = '`key` = :key'
+        result = await self.db.execute.select(
+            self.db_names['config'],
+            '`value`',
+            where,
+            limit=1,
+            key=key
+        )
+        value = result.scalar()
+
+        # Default.
+        if value is None:
+            value = default
+        else:
+            global_dict = {'datetime': Datetime}
+            value = eval(value, global_dict)
+
+        return value
+
+
+    async def setdefault(
+        self,
+        key: str,
+        default: ConfigValueT | None = None,
+        default_note: str | None = None
+    ) -> ConfigValue | ConfigValueT:
+        """
+        Asynchronous set config default value.
+
+        Parameters
+        ----------
+        key : Config key.
+        default : Config default value.
+        default_note : Config default note.
+
+        Returns
+        -------
+        Config value.
+        """
+
+        # Set.
+        data = {
+            'key': key,
+            'value': repr(default),
+            'type': type(default).__name__,
+            'note': default_note
+        }
+        result = await self.db.execute.insert(
+            self.db_names['config'],
+            data,
+            'ignore'
+        )
+
+        # Get.
+        if result.rowcount == 0:
+            default = await self.get(key)
+
+        return default
+
+
+    async def update(self, data: dict[str, ConfigValue] | ConfigTable) -> None:
+        """
+        Asynchronous update config values.
+
+        Parameters
+        ----------
+        data : Config update data.
+            - `dict[str, Any]`: Config key and value.
+            - `ConfigTable`: Config key and value and note.
+        """
+
+        # Handle parameter.
+        if type(data) == dict:
+            data = [
+                {
+                    'key': key,
+                    'value': repr(value),
+                    'type': type(value).__name__
+                }
+                for key, value in data.items()
+            ]
+        else:
+            data = data.copy()
+            for row in data:
+                row['value'] = repr(row['value'])
+                row['type'] = type(row['value']).__name__
+
+        # Update.
+        await self.db.execute.insert(
+            self.db_names['config'],
+            data,
+            'update'
+        )
+
+
+    async def remove(self, key: str | list[str]) -> None:
+        """
+        Asynchronous remove config.
+
+        Parameters
+        ----------
+        key : Config key or key list.
+        """
+
+        # Remove.
+        if type(key) == str:
+            where = '`key` = :key'
+            limit = 1
+        else:
+            where = '`key` in :key'
+            limit = None
+        result = await self.db.execute.delete(
+            self.db_names['base.config'],
+            where,
+            limit=limit,
+            key=key
+        )
+
+        # Check.
+        if result.rowcount == 0:
+            throw(KeyError, key)
+
+
+    async def items(self) -> dict[str, ConfigValue]:
+        """
+        Asynchronous get all config keys and values.
+
+        Returns
+        -------
+        All config keys and values.
+        """
+
+        # Get.
+        result = await self.db.execute.select(
+            self.db_names['config'],
+            ['key', 'value']
+        )
+
+        # Convert.
+        global_dict = {'datetime': Datetime}
+        result = result.to_dict('key', 'value')
+        result = {
+            key: eval(value, global_dict)
+            for key, value in result.items()
+        }
+
+        return result
+
+
+    async def keys(self) -> list[str]:
+        """
+        Asynchronous get all config keys.
+
+        Returns
+        -------
+        All config keys.
+        """
+
+        # Get.
+        result = await self.db.execute.select(
+            self.db_names['config'],
+            '`key`'
+        )
+
+        # Convert.
+        global_dict = {'datetime': Datetime}
+        result = [
+            eval(value, global_dict)
+            for value in result
+        ]
+
+        return result
+
+
+    async def values(self) -> list[ConfigValue]:
+        """
+        Asynchronous get all config value.
+
+        Returns
+        -------
+        All config values.
+        """
+
+        # Get.
+        result = await self.db.execute.select(
+            self.db_names['config'],
+            '`value`'
+        )
+
+        # Convert.
+        global_dict = {'datetime': Datetime}
+        result = [
+            eval(value, global_dict)
+            for value in result
+        ]
+
+        return result
+
+
+    async def __getitem__(self, key: str) -> ConfigValue:
+        """
+        Asynchronous get config value.
+
+        Parameters
+        ----------
+        key : Config key.
+
+        Returns
+        -------
+        Config value.
+        """
+
+        # Get.
+        value = await self.get(key, Null)
+
+        # Check.
+        if value == Null:
+            throw(KeyError, key)
+
+        return value
+
+
+    async def __setitem__(self, key_note: str | tuple[str, str], value: ConfigValue) -> None:
+        """
+        Asynchronous set config value.
+
+        Parameters
+        ----------
+        key_note : Config key and note.
+        value : Config value.
+        """
+
+        # Handle parameter.
+        if type(key_note) != str:
+            key, note = key_note
+        else:
+            key = key_note
+            note = None
+
+        # Set.
+        data = {
+            'key': key,
+            'value': repr(value),
+            'type': type(value).__name__,
+            'note': note
+        }
+        await self.db.execute.insert(
+            self.db_names['config'],
             data,
             'update'
         )