dimples 1.2.3__tar.gz → 1.2.5__tar.gz

{dimples-1.2.3 → dimples-1.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dimples
-Version: 1.2.3
+Version: 1.2.5
 Summary: DIMP Library for Edges and Stations
 Home-page: https://github.com/dimchat/demo-py
 Author: Albert Moky

{dimples-1.2.3 → 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.3 → dimples-1.2.5}/dimples/conn/flexible.py

@@ -36,6 +36,7 @@ from startrek import Connection
 from startrek import Arrival, Departure
 from startrek import StarDocker
 
+from ..utils import Logging
 from .protocol import DeparturePacker
 
 from .ws import WSDocker
@@ -43,7 +44,7 @@ from .mtp import MTPStreamDocker, TransactionID, MTPHelper
 from .mars import MarsStreamDocker, MarsHelper
 
 
-class FlexibleDocker(StarDocker, DeparturePacker):
+class FlexibleDocker(StarDocker, DeparturePacker, Logging):
 
     def __init__(self, remote: SocketAddress, local: Optional[SocketAddress]):
         super().__init__(remote=remote, local=local)
@@ -61,7 +62,7 @@ class FlexibleDocker(StarDocker, DeparturePacker):
         elif MarsStreamDocker.check(data=data):
             docker = MarsStreamDocker(remote=self.remote_address, local=self.local_address)
         else:
-            print('[FlexibleDocker] unsupported data format: %s' % data)
+            self.error(msg='unsupported data format: %s' % data)
             return None
         # OK
         docker.delegate = self.delegate
@@ -74,19 +75,26 @@ class FlexibleDocker(StarDocker, DeparturePacker):
     async def set_connection(self, conn: Optional[Connection]):
         await super().set_connection(conn=conn)
         docker = self.__docker
-        if docker is not None:
+        if docker is None:
+            self.error(msg='docker not ready, failed to set connection: %s' % conn)
+        else:
             await docker.set_connection(conn=conn)
 
     # Override
     async def send_ship(self, ship: Departure) -> bool:
         docker = self.__docker
-        if docker is not None:
+        if docker is None:
+            self.error(msg='docker not ready, failed to send ship: %s' % ship)
+            return False
+        else:
             return await docker.send_ship(ship=ship)
 
     # Override
     async def process_received(self, data: bytes):
         docker = self._get_docker(data=data)
-        if docker is not None:
+        if docker is None:
+            self.error(msg='docker not ready, failed to process received: %s' % data)
+        else:
             return await docker.process_received(data=data)
 
     # Override
@@ -113,7 +121,9 @@ class FlexibleDocker(StarDocker, DeparturePacker):
     def purge(self, now: float = 0) -> int:
         cnt = super().purge(now=now)
         docker = self.__docker
-        if docker is not None:
+        if docker is None:
+            self.debug(msg='docker not ready, failed to purge')
+        else:
             cnt += docker.purge(now=now)
         return cnt
 
@@ -128,14 +138,17 @@ class FlexibleDocker(StarDocker, DeparturePacker):
     # Override
     async def process(self) -> bool:
         docker = self.__docker
-        if docker is not None:
+        if docker is None:
+            self.debug(msg='docker not ready, failed to process')
+            return False
+        else:
             return await docker.process()
 
     # Override
     async def send_data(self, payload: Union[bytes, bytearray]) -> bool:
         docker = self.__docker
         if docker is None:
-            # docker not ready
+            self.error(msg='docker not ready, failed to send payload: %s' % payload)
             return False
         elif isinstance(docker, WSDocker):
             ship = docker.pack(payload=payload)
@@ -156,13 +169,16 @@ class FlexibleDocker(StarDocker, DeparturePacker):
     # Override
     async def heartbeat(self):
         docker = self.__docker
-        if docker is not None:
+        if docker is None:
+            self.warning(msg='docker not ready, failed to heart bet')
+        else:
             await docker.heartbeat()
 
     # Override
     def pack(self, payload: bytes, priority: int = 0) -> Optional[Departure]:
         docker = self.__docker
         if docker is None:
+            self.error(msg='docker not ready, failed to pack: %s' % payload)
             return None
         else:
             assert isinstance(docker, DeparturePacker), 'docker error: %s' % docker

{dimples-1.2.3 → 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.3 → 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.3 → 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.3 → 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',
+
+]