dimples 1.2.4__tar.gz → 1.2.5__tar.gz

dimples-1.2.5/PKG-INFO

@@ -0,0 +1,22 @@
+Metadata-Version: 2.1
+Name: dimples
+Version: 1.2.5
+Summary: DIMP Library for Edges and Stations
+Home-page: https://github.com/dimchat/demo-py
+Author: Albert Moky
+Author-email: albert.moky@gmail.com
+License: MIT
+Description: # DIMP Library for Edges and Stations (Python version)
+        
+        [![license](https://img.shields.io/github/license/mashape/apistatus.svg)](https://github.com/dimchat/demo-py/blob/master/LICENSE)
+        [![Version](https://img.shields.io/badge/alpha-0.1.0-red.svg)](https://github.com/dimchat/demo-py/wiki)
+        [![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)](https://github.com/dimchat/demo-py/pulls)
+        [![Platform](https://img.shields.io/badge/Platform-Python%203-brightgreen.svg)](https://github.com/dimchat/demo-py/wiki)
+        
+        Copyright © 2018-2022 Albert Moky
+        
+Platform: UNKNOWN
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Description-Content-Type: text/markdown

{dimples-1.2.4 → dimples-1.2.5}/dimples/client/processor.py

@@ -28,7 +28,6 @@
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 """
 
-import time
 from typing import List
 
 from dimsdk import DateTime
@@ -120,14 +119,12 @@ class ClientMessageProcessor(CommonMessageProcessor):
             elif isinstance(res, ReceiptCommand):
                 if sender.type == EntityType.STATION or sender.type == EntityType.BOT:
                     # no need to respond receipt to station
-                    when = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(r_msg.time))
-                    self.info(msg='drop receipt responding to %s, origin msg time=[%s]' % (sender, when))
+                    self.info(msg='drop receipt to %s, origin msg time=[%s]' % (sender, r_msg.time))
                     continue
             elif isinstance(res, TextContent):
                 if sender.type == EntityType.STATION or sender.type == EntityType.BOT:
                     # no need to respond text message to station
-                    when = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(r_msg.time))
-                    self.info(msg='drop text responding to %s, origin time=[%s], text=%s' % (sender, when, res.text))
+                    self.info(msg='drop text to %s, origin time=[%s], text=%s' % (sender, r_msg.time, res.text))
                     continue
             # normal response
             await messenger.send_content(sender=receiver, receiver=sender, content=res)

{dimples-1.2.4 → dimples-1.2.5}/dimples/conn/flexible.py

@@ -122,7 +122,7 @@ class FlexibleDocker(StarDocker, DeparturePacker, Logging):
         cnt = super().purge(now=now)
         docker = self.__docker
         if docker is None:
-            self.warning(msg='docker not ready, failed to purge')
+            self.debug(msg='docker not ready, failed to purge')
         else:
             cnt += docker.purge(now=now)
         return cnt
@@ -139,7 +139,7 @@ class FlexibleDocker(StarDocker, DeparturePacker, Logging):
     async def process(self) -> bool:
         docker = self.__docker
         if docker is None:
-            self.warning(msg='docker not ready, failed to process')
+            self.debug(msg='docker not ready, failed to process')
             return False
         else:
             return await docker.process()

{dimples-1.2.4 → dimples-1.2.5}/dimples/database/__init__.py

@@ -32,6 +32,9 @@
 from ..common.dbi import *
 
 from .dos import *
+from .redis import *
+
+from .t_base import DbInfo, DbTask
 
 from .t_private import PrivateKeyTable
 from .t_meta import MetaTable
@@ -78,9 +81,22 @@ __all__ = [
     'LoginStorage',
     'StationStorage',
 
+    #
+    #   Redis
+    #
+    'RedisConnector', 'RedisCache',
+
+    'MetaCache', 'DocumentCache',
+    'UserCache', 'LoginCache',
+    'GroupCache', 'GroupHistoryCache', 'GroupKeysCache',
+    'MessageCache',
+    'StationCache',
+
     #
     #   Table
     #
+    'DbInfo', 'DbTask',
+
     'PrivateKeyTable', 'MetaTable', 'DocumentTable',
     'UserTable', 'GroupTable', 'GroupHistoryTable',
     'GroupKeysTable',

{dimples-1.2.4 → dimples-1.2.5}/dimples/database/account.py

@@ -32,6 +32,7 @@ from dimsdk import ReliableMessage
 
 from ..common import AccountDBI
 
+from .t_base import DbInfo
 from .t_private import PrivateKeyTable
 from .t_meta import MetaTable
 from .t_document import DocumentTable
@@ -46,22 +47,22 @@ class AccountDatabase(AccountDBI):
         ~~~~~~~~~~~~~~~~~~~~~~~
     """
 
-    def __init__(self, root: str = None, public: str = None, private: str = None):
+    def __init__(self, info: DbInfo):
         super().__init__()
-        self.__private_table = PrivateKeyTable(root=root, public=public, private=private)
-        self.__meta_table = MetaTable(root=root, public=public, private=private)
-        self.__doc_table = DocumentTable(root=root, public=public, private=private)
-        self.__user_table = UserTable(root=root, public=public, private=private)
-        self.__group_table = GroupTable(root=root, public=public, private=private)
-        self.__history_table = GroupHistoryTable(root=root, public=public, private=private)
+        self._private_table = PrivateKeyTable(info=info)
+        self._meta_table = MetaTable(info=info)
+        self._doc_table = DocumentTable(info=info)
+        self._user_table = UserTable(info=info)
+        self._group_table = GroupTable(info=info)
+        self._history_table = GroupHistoryTable(info=info)
 
     def show_info(self):
-        self.__private_table.show_info()
-        self.__meta_table.show_info()
-        self.__doc_table.show_info()
-        self.__user_table.show_info()
-        self.__group_table.show_info()
-        self.__history_table.show_info()
+        self._private_table.show_info()
+        self._meta_table.show_info()
+        self._doc_table.show_info()
+        self._user_table.show_info()
+        self._group_table.show_info()
+        self._history_table.show_info()
 
     #
     #   PrivateKey DBI
@@ -69,19 +70,19 @@ class AccountDatabase(AccountDBI):
 
     # Override
     async def save_private_key(self, key: PrivateKey, user: ID, key_type: str = 'M') -> bool:
-        return await self.__private_table.save_private_key(key=key, user=user, key_type=key_type)
+        return await self._private_table.save_private_key(key=key, user=user, key_type=key_type)
 
     # Override
     async def private_keys_for_decryption(self, user: ID) -> List[DecryptKey]:
-        return await self.__private_table.private_keys_for_decryption(user=user)
+        return await self._private_table.private_keys_for_decryption(user=user)
 
     # Override
     async def private_key_for_signature(self, user: ID) -> Optional[SignKey]:
-        return await self.__private_table.private_key_for_signature(user=user)
+        return await self._private_table.private_key_for_signature(user=user)
 
     # Override
     async def private_key_for_visa_signature(self, user: ID) -> Optional[SignKey]:
-        return await self.__private_table.private_key_for_visa_signature(user=user)
+        return await self._private_table.private_key_for_visa_signature(user=user)
 
     #
     #   Meta DBI
@@ -92,11 +93,11 @@ class AccountDatabase(AccountDBI):
         # check meta with ID
         if not meta.match_identifier(identifier=identifier):
             raise ValueError('meta not match: %s => %s' % (identifier, meta))
-        return await self.__meta_table.save_meta(meta=meta, identifier=identifier)
+        return await self._meta_table.save_meta(meta=meta, identifier=identifier)
 
     # Override
     async def get_meta(self, identifier: ID) -> Optional[Meta]:
-        return await self.__meta_table.get_meta(identifier=identifier)
+        return await self._meta_table.get_meta(identifier=identifier)
 
     #
     #   Document DBI
@@ -105,7 +106,7 @@ class AccountDatabase(AccountDBI):
     # Override
     async def save_document(self, document: Document) -> bool:
         # check meta first
-        meta = await self.__meta_table.get_meta(identifier=document.identifier)
+        meta = await self._meta_table.get_meta(identifier=document.identifier)
         if meta is None:
             raise LookupError('meta not exists: %s' % document.identifier)
         # check document valid before saving it
@@ -115,15 +116,15 @@ class AccountDatabase(AccountDBI):
         if isinstance(document, Bulletin):
             founder = document.founder
             if founder is not None:
-                f_meta = await self.__meta_table.get_meta(identifier=founder)
+                f_meta = await self._meta_table.get_meta(identifier=founder)
                 if f_meta is None or meta.public_key != meta.public_key:
                     raise ValueError('founder error: %s, group: %s' % (founder, document.identifier))
         # document ok, try to save it
-        return await self.__doc_table.save_document(document=document)
+        return await self._doc_table.save_document(document=document)
 
     # Override
     async def get_documents(self, identifier: ID) -> List[Document]:
-        return await self.__doc_table.get_documents(identifier=identifier)
+        return await self._doc_table.get_documents(identifier=identifier)
 
     #
     #   User DBI
@@ -131,19 +132,19 @@ class AccountDatabase(AccountDBI):
 
     # Override
     async def get_local_users(self) -> List[ID]:
-        return await self.__user_table.get_local_users()
+        return await self._user_table.get_local_users()
 
     # Override
     async def save_local_users(self, users: List[ID]) -> bool:
-        return await self.__user_table.save_local_users(users=users)
+        return await self._user_table.save_local_users(users=users)
 
     # Override
     async def get_contacts(self, user: ID) -> List[ID]:
-        return await self.__user_table.get_contacts(user=user)
+        return await self._user_table.get_contacts(user=user)
 
     # Override
     async def save_contacts(self, contacts: List[ID], user: ID) -> bool:
-        return await self.__user_table.save_contacts(contacts=contacts, user=user)
+        return await self._user_table.save_contacts(contacts=contacts, user=user)
 
     #
     #   Group DBI
@@ -151,35 +152,35 @@ class AccountDatabase(AccountDBI):
 
     # Override
     async def get_founder(self, group: ID) -> Optional[ID]:
-        return await self.__group_table.get_founder(group=group)
+        return await self._group_table.get_founder(group=group)
 
     # Override
     async def get_owner(self, group: ID) -> Optional[ID]:
-        return await self.__group_table.get_owner(group=group)
+        return await self._group_table.get_owner(group=group)
 
     # Override
     async def get_members(self, group: ID) -> List[ID]:
-        return await self.__group_table.get_members(group=group)
+        return await self._group_table.get_members(group=group)
 
     # Override
     async def save_members(self, members: List[ID], group: ID) -> bool:
-        return await self.__group_table.save_members(members=members, group=group)
+        return await self._group_table.save_members(members=members, group=group)
 
     # Override
     async def get_assistants(self, group: ID) -> List[ID]:
-        return await self.__group_table.get_assistants(group=group)
+        return await self._group_table.get_assistants(group=group)
 
     # Override
     async def save_assistants(self, assistants: List[ID], group: ID) -> bool:
-        return await self.__group_table.save_assistants(assistants=assistants, group=group)
+        return await self._group_table.save_assistants(assistants=assistants, group=group)
 
     # Override
     async def get_administrators(self, group: ID) -> List[ID]:
-        return await self.__group_table.get_administrators(group=group)
+        return await self._group_table.get_administrators(group=group)
 
     # Override
     async def save_administrators(self, administrators: List[ID], group: ID) -> bool:
-        return await self.__group_table.save_administrators(administrators=administrators, group=group)
+        return await self._group_table.save_administrators(administrators=administrators, group=group)
 
     #
     #   Group History DBI
@@ -187,20 +188,20 @@ class AccountDatabase(AccountDBI):
 
     # Override
     async def save_group_history(self, group: ID, content: GroupCommand, message: ReliableMessage) -> bool:
-        return await self.__history_table.save_group_history(group=group, content=content, message=message)
+        return await self._history_table.save_group_history(group=group, content=content, message=message)
 
     # Override
     async def get_group_histories(self, group: ID) -> List[Tuple[GroupCommand, ReliableMessage]]:
-        return await self.__history_table.get_group_histories(group=group)
+        return await self._history_table.get_group_histories(group=group)
 
     # Override
     async def get_reset_command_message(self, group: ID) -> Tuple[Optional[ResetCommand], Optional[ReliableMessage]]:
-        return await self.__history_table.get_reset_command_message(group=group)
+        return await self._history_table.get_reset_command_message(group=group)
 
     # Override
     async def clear_group_member_histories(self, group: ID) -> bool:
-        return await self.__history_table.clear_group_member_histories(group=group)
+        return await self._history_table.clear_group_member_histories(group=group)
 
     # Override
     async def clear_group_admin_histories(self, group: ID) -> bool:
-        return await self.__history_table.clear_group_admin_histories(group=group)
+        return await self._history_table.clear_group_admin_histories(group=group)

{dimples-1.2.4 → dimples-1.2.5}/dimples/database/dos/document.py

@@ -40,24 +40,19 @@ class DocumentStorage(Storage, DocumentDBI):
         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
         file path: '.dim/public/{ADDRESS}/documents.js'
     """
-    doc_path = '{PUBLIC}/{ADDRESS}/document.js'
-    all_path = '{PUBLIC}/{ADDRESS}/documents.js'
+    docs_path = '{PUBLIC}/{ADDRESS}/documents.js'
 
     def show_info(self):
-        path = self.public_path(self.all_path)
+        path = self.public_path(self.docs_path)
         print('!!!      documents path: %s' % path)
 
-    def __doc_path(self, identifier: ID) -> str:
-        path = self.public_path(self.doc_path)
-        return template_replace(path, key='ADDRESS', value=str(identifier.address))
-
-    def __all_path(self, identifier: ID) -> str:
-        path = self.public_path(self.all_path)
+    def __docs_path(self, identifier: ID) -> str:
+        path = self.public_path(self.docs_path)
         return template_replace(path, key='ADDRESS', value=str(identifier.address))
 
     async def save_documents(self, documents: List[Document], identifier: ID) -> bool:
         """ save documents into file """
-        path = self.__all_path(identifier=identifier)
+        path = self.__docs_path(identifier=identifier)
         self.info(msg='Saving %d document(s) into: %s' % (len(documents), path))
         array = []
         for doc in documents:
@@ -67,7 +62,7 @@ class DocumentStorage(Storage, DocumentDBI):
 
     async def load_documents(self, identifier: ID) -> Optional[List[Document]]:
         """ load documents from file """
-        path = self.__all_path(identifier=identifier)
+        path = self.__docs_path(identifier=identifier)
         self.info(msg='Loading documents from: %s' % path)
         array = await self.read_json(path=path)
         if array is None:
@@ -76,20 +71,11 @@ class DocumentStorage(Storage, DocumentDBI):
         documents = []
         for info in array:
             doc = parse_document(dictionary=info, identifier=identifier)
-            if info is None:
-                assert False, 'document error: %s, %s' % (identifier, info)
+            assert doc is not None, 'document error: %s, %s' % (identifier, info)
             documents.append(doc)
         self.info(msg='Loaded %d documents from: %s' % (len(documents), path))
         return documents
 
-    async def load_document(self, identifier: ID) -> Optional[Document]:
-        """ load document from file """
-        path = self.__doc_path(identifier=identifier)
-        self.info(msg='Loading document from: %s' % path)
-        info = await self.read_json(path=path)
-        if info is not None:
-            return parse_document(dictionary=info, identifier=identifier)
-
     #
     #   Document DBI
     #
@@ -116,12 +102,8 @@ class DocumentStorage(Storage, DocumentDBI):
     # Override
     async def get_documents(self, identifier: ID) -> List[Document]:
         """ load documents from file """
-        all_documents = await self.load_documents(identifier=identifier)
-        if all_documents is not None:
-            return all_documents
-        # try old file
-        doc = await self.load_document(identifier=identifier)
-        return [] if doc is None else [doc]
+        docs = await self.load_documents(identifier=identifier)
+        return [] if docs is None else docs
 
 
 def parse_document(dictionary: dict, identifier: ID = None, doc_type: str = '*') -> Optional[Document]:

{dimples-1.2.4 → dimples-1.2.5}/dimples/database/message.py

@@ -31,6 +31,7 @@ from dimsdk import ReliableMessage
 
 from ..common import MessageDBI
 
+from .t_base import DbInfo
 from .t_group_keys import GroupKeysTable
 from .t_cipherkey import CipherKeyTable
 from .t_message import ReliableMessageTable
@@ -42,27 +43,27 @@ class MessageDatabase(MessageDBI):
         ~~~~~~~~~~~~~~~~~~~~~
     """
 
-    def __init__(self, root: str = None, public: str = None, private: str = None):
+    def __init__(self, info: DbInfo):
         super().__init__()
-        self.__group_keys_table = GroupKeysTable(root=root, public=public, private=private)
-        self.__cipher_table = CipherKeyTable(root=root, public=public, private=private)
-        self.__msg_table = ReliableMessageTable(root=root, public=public, private=private)
+        self._group_keys_table = GroupKeysTable(info=info)
+        self._cipher_table = CipherKeyTable(info=info)
+        self._msg_table = ReliableMessageTable(info=info)
 
     def show_info(self):
-        self.__group_keys_table.show_info()
-        self.__cipher_table.show_info()
-        self.__msg_table.show_info()
+        self._group_keys_table.show_info()
+        self._cipher_table.show_info()
+        self._msg_table.show_info()
 
     #
     #   GroupKeys DBI
 
     # Override
     async def get_group_keys(self, group: ID, sender: ID) -> Optional[Dict[str, str]]:
-        return await self.__group_keys_table.get_group_keys(group=group, sender=sender)
+        return await self._group_keys_table.get_group_keys(group=group, sender=sender)
 
     # Override
     async def save_group_keys(self, group: ID, sender: ID, keys: Dict[str, str]) -> bool:
-        return await self.__group_keys_table.save_group_keys(group=group, sender=sender, keys=keys)
+        return await self._group_keys_table.save_group_keys(group=group, sender=sender, keys=keys)
 
     #
     #   CipherKey DBI
@@ -70,11 +71,11 @@ class MessageDatabase(MessageDBI):
 
     # Override
     async def get_cipher_key(self, sender: ID, receiver: ID, generate: bool = False) -> Optional[SymmetricKey]:
-        return await self.__cipher_table.get_cipher_key(sender=sender, receiver=receiver, generate=generate)
+        return await self._cipher_table.get_cipher_key(sender=sender, receiver=receiver, generate=generate)
 
     # Override
     async def cache_cipher_key(self, key: SymmetricKey, sender: ID, receiver: ID):
-        return await self.__cipher_table.cache_cipher_key(key=key, sender=sender, receiver=receiver)
+        return await self._cipher_table.cache_cipher_key(key=key, sender=sender, receiver=receiver)
 
     #
     #   ReliableMessage DBI
@@ -82,12 +83,12 @@ class MessageDatabase(MessageDBI):
 
     # Override
     async def get_reliable_messages(self, receiver: ID, limit: int = 1024) -> List[ReliableMessage]:
-        return await self.__msg_table.get_reliable_messages(receiver=receiver, limit=limit)
+        return await self._msg_table.get_reliable_messages(receiver=receiver, limit=limit)
 
     # Override
     async def cache_reliable_message(self, msg: ReliableMessage, receiver: ID) -> bool:
-        return await self.__msg_table.cache_reliable_message(msg=msg, receiver=receiver)
+        return await self._msg_table.cache_reliable_message(msg=msg, receiver=receiver)
 
     # Override
     async def remove_reliable_message(self, msg: ReliableMessage, receiver: ID) -> bool:
-        return await self.__msg_table.remove_reliable_message(msg=msg, receiver=receiver)
+        return await self._msg_table.remove_reliable_message(msg=msg, receiver=receiver)

dimples-1.2.5/dimples/database/redis/__init__.py

@@ -0,0 +1,59 @@
+# -*- coding: utf-8 -*-
+# ==============================================================================
+# MIT License
+#
+# Copyright (c) 2021 Albert Moky
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+# ==============================================================================
+
+"""
+    Database module
+    ~~~~~~~~~~~~~~~
+    Redis Client
+"""
+
+from .base import RedisConnector
+from .base import Cache as RedisCache
+
+from .meta import MetaCache
+from .document import DocumentCache
+from .user import UserCache
+from .login import LoginCache
+from .group import GroupCache
+from .grp_history import GroupHistoryCache
+from .grp_keys import GroupKeysCache
+from .message import MessageCache
+from .station import StationCache
+
+
+__all__ = [
+
+    'RedisConnector',
+    'RedisCache',
+
+    'MetaCache',
+    'DocumentCache',
+    'UserCache', 'LoginCache',
+    'GroupCache', 'GroupHistoryCache',
+    'GroupKeysCache',
+    'MessageCache',
+    'StationCache',
+
+]

dimples-1.2.5/dimples/database/redis/base.py

@@ -0,0 +1,105 @@
+# -*- coding: utf-8 -*-
+# ==============================================================================
+# MIT License
+#
+# Copyright (c) 2021 Albert Moky
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+# ==============================================================================
+
+from abc import ABC, abstractmethod
+from typing import Optional
+
+from aiou import Redis
+from aiou import RedisClient
+from aiou import RedisConnector
+
+
+class Cache(RedisClient, ABC):
+
+    @property
+    @abstractmethod
+    def db_name(self) -> Optional[str]:
+        """ database name for redis """
+        raise NotImplemented
+
+    @property
+    @abstractmethod
+    def tbl_name(self) -> str:
+        """ table name for redis """
+        raise NotImplemented
+
+    # protected
+    def get_redis(self, name: str) -> Optional[Redis]:
+        """ Get Redis with name
+
+            0 - default
+            1 - mkm.meta
+            2 - mkm.document
+            3 - mkm.user
+            4 - mkm.group
+            5
+            6
+            7 - mkm.session
+            8 - dkd.msg
+            9 - dkd.key
+        """
+        connector = self.connector
+        if connector is None:
+            return None
+        else:
+            assert isinstance(connector, RedisConnector)
+        if name == 'default':
+            return connector.connect(db=0)
+        #
+        #  MingKeMing
+        #
+        elif name == 'mkm.meta':
+            return connector.connect(db=1)
+        elif name == 'mkm.document':
+            return connector.connect(db=2)
+        elif name == 'mkm.user':
+            return connector.connect(db=3)
+        elif name == 'mkm.group':
+            return connector.connect(db=4)
+        #
+        #  Session
+        #
+        elif name == 'mkm.session':
+            return connector.connect(db=7)
+        #
+        #  DaoKeDao
+        #
+        elif name == 'dkd.msg':
+            return connector.connect(db=8)
+        elif name == 'dkd.key':
+            return connector.connect(db=9)
+
+    @property  # Override
+    def redis(self) -> Optional[Redis]:
+        db_name = self.db_name
+        tbl_name = self.tbl_name
+        db = None
+        if db_name is not None:
+            db = self.get_redis(name='%s.%s' % (db_name, tbl_name))
+        if db is None:
+            db = self.get_redis(name=tbl_name)
+        if db is None:
+            db = super().redis
+        return db