reydb 1.1.60__py3-none-any.whl → 1.2.0__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,
@@ -21,10 +20,13 @@ from reykit.rbase import Null, throw
 
 from . import rdb
 from .rbase import DatabaseBase
+from .rorm import DatabaseORM as orm
 
 
 __all__ = (
+    'DatabaseConfigSuper',
     'DatabaseConfig',
+    'DatabaseConfigAsync'
 )
 
 
@@ -32,35 +34,23 @@ 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
-    --------
-    >>> config = DatabaseConfig()
-    >>> config['key1'] = 1
-    >>> config['key2', 'note'] = 2
-    >>> config['key1'], config['key2']
-    (1, 2)
     """
 
 
-    def __init__(
-        self,
-        db: 'rdb.Database',
-        db_names: dict[str, str] | None = None
-    ) -> None:
+    def __init__(self, db: DatabaseT) -> None:
         """
         Build instance attributes.
 
         Parameters
         ----------
         db: Database instance.
-        db_names: Update build database table names.
         """
 
         # Build.
@@ -69,27 +59,25 @@ class DatabaseConfig(DatabaseBase):
             'config': 'config',
             'stats_config': 'stats_config'
         }
-        if db_names is not None:
-            self.db_names.update(db_names)
 
 
-    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`.
         """
 
         # Handle parameter.
 
         ## Table.
-        class Config(self.db.orm.Model, table=True):
+        class Config(orm.Model, table=True):
             __name__ = self.db_names['config']
-            __commment__ = '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 = self.db.orm.Field(type=self.db.orm.types.VARCHAR(50), key=True, not_null=True, comment='Config key.')
-            value = self.db.orm.Field(type=self.db.orm.types.TEXT, not_null=True, comment='Config value.')
-            type = self.db.orm.Field(type=self.db.orm.types.VARCHAR(50), not_null=True, comment='Config value type.')
-            note = self.db.orm.Field(type=self.db.orm.types.VARCHAR(500), comment='Config note.')
+            __comment__ = 'Config data table.'
+            create_time: Datetime = orm.Field(field_default='CURRENT_TIMESTAMP', not_null=True, index_n=True, comment='Config create time.')
+            update_time: Datetime = orm.Field(field_default='CURRENT_TIMESTAMP', index_n=True, comment='Config update time.')
+            key: str = orm.Field(field_type=orm.types.VARCHAR(50), key=True, not_null=True, comment='Config key.')
+            value: str = orm.Field(field_type=orm.types.TEXT, not_null=True, comment='Config value.')
+            type: str = orm.Field(field_type=orm.types.VARCHAR(50), not_null=True, comment='Config value type.')
+            note: str = orm.Field(field_type=orm.types.VARCHAR(500), comment='Config note.')
 
         tables = [Config]
 
@@ -102,7 +90,7 @@ class DatabaseConfig(DatabaseBase):
                         'name': 'count',
                         'select': (
                             'SELECT COUNT(1)\n'
-                            f'FROM `{self.db_names['base']}`.`{self.db_names['base.config']}`'
+                            f'FROM `{self.db.database}`.`{self.db_names['config']}`'
                         ),
                         'comment': 'Config count.'
                     },
@@ -110,7 +98,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.database}`.`{self.db_names['config']}`'
                         ),
                         'comment': 'Config last record create time.'
                     },
@@ -118,20 +106,44 @@ 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.database}`.`{self.db_names['config']}`'
                         ),
                         'comment': 'Config last record update time.'
                     }
                 ]
             }
-
         ]
 
+        return tables, views_stats
+
+
+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 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)
+        self.db.build.build(tables=tables, views_stats=views_stats, skip=True)
 
 
-    @property
     def data(self) -> ConfigTable:
         """
         Get config data table.
@@ -149,7 +161,7 @@ class DatabaseConfig(DatabaseBase):
         )
 
         # Convert.
-        global_dict = {'datetime': datetime}
+        global_dict = {'datetime': Datetime}
         result = [
             {
                 'key': row['key'],
@@ -191,7 +203,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
@@ -204,7 +216,7 @@ class DatabaseConfig(DatabaseBase):
         default_note: str | None = None
     ) -> ConfigValue | ConfigValueT:
         """
-        Set config value.
+        Set config default value.
 
         Parameters
         ----------
@@ -316,7 +328,7 @@ class DatabaseConfig(DatabaseBase):
         )
 
         # Convert.
-        global_dict = {'datetime': datetime}
+        global_dict = {'datetime': Datetime}
         result = result.to_dict('key', 'value')
         result = {
             key: eval(value, global_dict)
@@ -342,7 +354,7 @@ class DatabaseConfig(DatabaseBase):
         )
 
         # Convert.
-        global_dict = {'datetime': datetime}
+        global_dict = {'datetime': Datetime}
         result = [
             eval(value, global_dict)
             for value in result
@@ -367,7 +379,7 @@ class DatabaseConfig(DatabaseBase):
         )
 
         # Convert.
-        global_dict = {'datetime': datetime}
+        global_dict = {'datetime': Datetime}
         result = [
             eval(value, global_dict)
             for value in result
@@ -428,3 +440,328 @@ class DatabaseConfig(DatabaseBase):
             data,
             'update'
         )
+
+
+class DatabaseConfigAsync(DatabaseConfigSuper['rdb.DatabaseAsync']):
+    """
+    Asynchronous database config type.
+    Can create database used `self.build_db` method.
+
+    Examples
+    --------
+    >>> config = DatabaseConfig()
+    >>> await config['key1'] = 1
+    >>> await config['key2', 'note'] = 2
+    >>> await config['key1'], config['key2']
+    (1, 2)
+    """
+
+
+    async def build_db(self) -> None:
+        """
+        Asynchronous 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 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'
+        )