dimp 2.3.0__tar.gz → 2.3.2__tar.gz

{dimp-2.3.0 → dimp-2.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dimp
-Version: 2.3.0
+Version: 2.3.2
 Summary: Decentralized Instant Messaging Protocol
 Home-page: https://github.com/dimchat/core-py
 Author: Albert Moky

{dimp-2.3.0 → dimp-2.3.2}/dimp/__init__.py

@@ -34,7 +34,7 @@ from mkm.crypto import *
 from mkm import *
 from dkd import *
 
-from .protocol.commands import CommandFactory
+from .protocol.base import CommandFactory
 from .protocol import *
 from .crypto import *
 from .mkm import *
@@ -52,7 +52,8 @@ __all__ = [
 
     'URI', 'DateTime',
 
-    'Converter', 'Copier',
+    'Converter', 'DataConverter', 'BaseConverter',
+    'Copier',
     'Wrapper', 'Stringer', 'Mapper',
     'ConstantString',  # 'String',
     'Dictionary',

{dimp-2.3.0 → dimp-2.3.2}/dimp/crypto/keys.py

@@ -29,9 +29,9 @@
 # ==============================================================================
 
 from abc import ABC
-from typing import Optional, Any, Dict
+from typing import Dict
 
-from mkm.types import Dictionary
+from mkm.types import Mapper, Dictionary
 from mkm.crypto import CryptographyKey, EncryptKey, DecryptKey, SignKey, VerifyKey
 from mkm.crypto import SymmetricKey, AsymmetricKey, PublicKey, PrivateKey
 from mkm.plugins import SharedCryptoExtensions
@@ -46,7 +46,7 @@ from mkm.plugins import SharedCryptoExtensions
 # noinspection PyAbstractClass
 class BaseKey(Dictionary, CryptographyKey, ABC):
 
-    def __init__(self, key: Dict[str, Any]):
+    def __init__(self, key: Dict):
         super().__init__(dictionary=key)
 
     @property  # Override
@@ -58,9 +58,10 @@ class BaseKey(Dictionary, CryptographyKey, ABC):
     #
 
     @classmethod
-    def get_key_algorithm(cls, key: Dict[str, Any]) -> Optional[str]:
+    def get_key_algorithm(cls, key: Dict) -> str:
         ext = SharedCryptoExtensions()
-        return ext.helper.get_key_algorithm(key=key, default='')
+        algorithm = ext.helper.get_key_algorithm(key=key, default=None)
+        return '' if algorithm is None else algorithm
 
     @classmethod
     def match_encrypt_key(cls, encrypt_key: EncryptKey, decrypt_key: DecryptKey) -> bool:
@@ -96,20 +97,32 @@ class BaseKey(Dictionary, CryptographyKey, ABC):
 # noinspection PyAbstractClass
 class BaseSymmetricKey(Dictionary, SymmetricKey, ABC):
 
-    def __init__(self, key: Dict[str, Any]):
+    def __init__(self, key: Dict):
         super().__init__(dictionary=key)
 
     # Override
     def __eq__(self, other) -> bool:
-        if isinstance(other, SymmetricKey):
-            return BaseKey.symmetric_keys_equal(other, self)
+        if isinstance(other, Mapper):
+            if self is other:
+                # same object
+                return True
+            elif isinstance(other, SymmetricKey):
+                return BaseKey.symmetric_keys_equal(other, self)
+            # compare with inner map
+            other = other.dictionary
+        return self.dictionary.__eq__(other)
 
     # Override
     def __ne__(self, other) -> bool:
-        if isinstance(other, SymmetricKey):
-            return not BaseKey.symmetric_keys_equal(other, self)
-        else:
-            return True
+        if isinstance(other, Mapper):
+            if self is other:
+                # same object
+                return False
+            elif isinstance(other, SymmetricKey):
+                return not BaseKey.symmetric_keys_equal(other, self)
+            # compare with inner map
+            other = other.dictionary
+        return self.dictionary.__ne__(other)
 
     @property  # Override
     def algorithm(self) -> str:
@@ -123,7 +136,7 @@ class BaseSymmetricKey(Dictionary, SymmetricKey, ABC):
 # noinspection PyAbstractClass
 class BaseAsymmetricKey(Dictionary, AsymmetricKey, ABC):
 
-    def __init__(self, key: Dict[str, Any]):
+    def __init__(self, key: Dict):
         super().__init__(dictionary=key)
 
     @property  # Override
@@ -134,7 +147,7 @@ class BaseAsymmetricKey(Dictionary, AsymmetricKey, ABC):
 # noinspection PyAbstractClass
 class BasePublicKey(Dictionary, PublicKey, ABC):
 
-    def __init__(self, key: Dict[str, Any]):
+    def __init__(self, key: Dict):
         super().__init__(dictionary=key)
 
     @property  # Override
@@ -149,20 +162,32 @@ class BasePublicKey(Dictionary, PublicKey, ABC):
 # noinspection PyAbstractClass
 class BasePrivateKey(Dictionary, PrivateKey, ABC):
 
-    def __init__(self, key: Dict[str, Any]):
+    def __init__(self, key: Dict):
         super().__init__(dictionary=key)
 
     # Override
     def __eq__(self, other) -> bool:
-        if isinstance(other, PrivateKey):
-            return BaseKey.private_keys_equal(other, self)
+        if isinstance(other, Mapper):
+            if self is other:
+                # same object
+                return True
+            elif isinstance(other, PrivateKey):
+                return BaseKey.private_keys_equal(other, self)
+            # compare with inner map
+            other = other.dictionary
+        return self.dictionary.__eq__(other)
 
     # Override
     def __ne__(self, other) -> bool:
-        if isinstance(other, PrivateKey):
-            return not BaseKey.private_keys_equal(other, self)
-        else:
-            return True
+        if isinstance(other, Mapper):
+            if self is other:
+                # same object
+                return False
+            elif isinstance(other, PrivateKey):
+                return not BaseKey.private_keys_equal(other, self)
+            # compare with inner map
+            other = other.dictionary
+        return self.dictionary.__ne__(other)
 
     @property  # Override
     def algorithm(self) -> str:

{dimp-2.3.0 → dimp-2.3.2}/dimp/crypto/pnf.py

@@ -28,15 +28,13 @@
 # SOFTWARE.
 # ==============================================================================
 
-from typing import Optional, Any, Dict
+from typing import Optional, Dict
 
 from mkm.format import TransportableData
 from mkm.types import URI
 from mkm.types import Dictionary
 from mkm.crypto import DecryptKey, SymmetricKey
 
-from .algorithms import EncodeAlgorithms
-
 
 class BaseFileWrapper(Dictionary):
     """
@@ -57,7 +55,7 @@ class BaseFileWrapper(Dictionary):
             }
     """
 
-    def __init__(self, dictionary: Dict[str, Any]):
+    def __init__(self, dictionary: Dict):
         super().__init__(dictionary=dictionary)
         # file data (not encrypted)
         self.__attachment: Optional[TransportableData] = None
@@ -92,7 +90,7 @@ class BaseFileWrapper(Dictionary):
             ted = None
             self.pop('data', None)
         else:
-            ted = TransportableData.create(data=binary, algorithm=EncodeAlgorithms.DEFAULT)
+            ted = TransportableData.create(data=binary)
             self['data'] = ted.object
         self.__attachment = ted
 
@@ -117,11 +115,12 @@ class BaseFileWrapper(Dictionary):
 
     @property
     def url(self) -> Optional[URI]:
-        if self.__url is None:
+        remote = self.__url
+        if remote is None:
             remote = self.get_str(key='URL', default=None)
             # TODO: convert str to URI
             self.__url = remote
-        return self.__url
+        return remote
 
     @url.setter
     def url(self, remote: Optional[URI]):
@@ -138,10 +137,12 @@ class BaseFileWrapper(Dictionary):
 
     @property
     def password(self) -> Optional[DecryptKey]:
-        if self.__password is None:
+        key = self.__password
+        if key is None:
             info = self.get('key')
-            self.__password = SymmetricKey.parse(key=info)
-        return self.__password
+            key = SymmetricKey.parse(key=info)
+            self.__password = key
+        return key
 
     @password.setter
     def password(self, key: Optional[DecryptKey]):

{dimp-2.3.0 → dimp-2.3.2}/dimp/crypto/ted.py

@@ -28,7 +28,7 @@
 # SOFTWARE.
 # ==============================================================================
 
-from typing import Optional, Any, Dict
+from typing import Optional, Dict
 
 from mkm.format import base64_encode, base64_decode
 from mkm.format import base58_encode, base58_decode
@@ -54,26 +54,26 @@ class BaseDataWrapper(Dictionary):
             2. "data:image/png;base64,{BASE64_ENCODE}"
     """
 
-    def __init__(self, dictionary: Dict[str, Any]):
+    def __init__(self, dictionary: Dict):
         super().__init__(dictionary=dictionary)
         # binary data
         self.__data: Optional[bytes] = None
 
-    # Override
-    def __len__(self) -> int:
-        """ return len(self) """
-        # if super().__len__() == 0:
-        #     return 0
-        data = self.data
-        return 0 if data is None else len(data)
+    # # Override
+    # def __len__(self) -> int:
+    #     """ return len(self) """
+    #     if super().__len__() == 0:
+    #         return 0
+    #     data = self.data
+    #     return 0 if data is None else len(data)
 
     # Override
     def __str__(self) -> str:
-        text = self.get_str(key='data', default='')
-        if len(text) == 0:
-            return text
-        alg = self.get_str(key='algorithm', default='')
-        if alg == EncodeAlgorithms.DEFAULT:
+        text = self.get_str(key='data', default=None)
+        if text is None:  # or len(text) == 0:
+            return ''
+        alg = self.get_str(key='algorithm', default=None)
+        if alg is None or alg == EncodeAlgorithms.DEFAULT:
             alg = ''
         if len(alg) == 0:
             # 0. "{BASE64_ENCODE}"
@@ -85,9 +85,9 @@ class BaseDataWrapper(Dictionary):
     def encode(self, mime_type: str) -> str:
         """ toString(mimeType) """
         # get encoded data
-        text = self.get_str(key='data', default='')
-        if len(text) == 0:
-            return text
+        text = self.get_str(key='data', default=None)
+        if text is None:  # or len(text) == 0:
+            return ''
         alg = self.algorithm
         # 2. "data:image/png;base64,{BASE64_ENCODE}"
         return 'data:%s;%s,%s' % (mime_type, alg, text)
@@ -98,8 +98,8 @@ class BaseDataWrapper(Dictionary):
 
     @property
     def algorithm(self) -> str:
-        alg = self.get_str(key='algorithm', default='')
-        if len(alg) == 0:
+        alg = self.get_str(key='algorithm', default=None)
+        if alg is None or len(alg) == 0:
             alg = EncodeAlgorithms.DEFAULT
         return alg
 
@@ -118,8 +118,11 @@ class BaseDataWrapper(Dictionary):
     def data(self) -> Optional[bytes]:
         binary = self.__data
         if binary is None:
-            text = self.get_str(key='data', default='')
-            if len(text) > 0:
+            text = self.get_str(key='data', default=None)
+            if text is None or len(text) == 0:
+                # assert False, 'TED data empty: %s' % self.dictionary
+                return None
+            else:
                 alg = self.algorithm
                 if alg == EncodeAlgorithms.BASE_64:
                     binary = base64_decode(string=text)
@@ -145,6 +148,7 @@ class BaseDataWrapper(Dictionary):
             elif alg == EncodeAlgorithms.HEX:
                 text = hex_encode(data=binary)
             else:
-                assert False, 'data algorithm not support: %s' % alg
+                raise ArithmeticError('data algorithm not support: %s' % alg)
+                # assert False, 'data algorithm not support: %s' % alg
             self['data'] = text
         self.__data = binary

{dimp-2.3.0 → dimp-2.3.2}/dimp/dkd/__init__.py

@@ -31,22 +31,23 @@
 from dkd import *
 from ..protocol import *
 
-from .base import BaseContent, BaseCommand
-from .contents import BaseTextContent, ListContent, SecretContent
-from .contents import WebPageContent, NameCardContent
-from .files import BaseFileContent, ImageFileContent, AudioFileContent, VideoFileContent
-from .money import BaseMoneyContent, TransferMoneyContent
-from .quote import BaseQuoteContent, CombineForwardContent
-
-from .commands import BaseMetaCommand, BaseDocumentCommand
-from .receipt import BaseReceiptCommand
-
-from .groups import BaseHistoryCommand, BaseGroupCommand
-from .groups import InviteGroupCommand, ExpelGroupCommand, JoinGroupCommand
-from .groups import QuitGroupCommand, QueryGroupCommand, ResetGroupCommand
-from .group_admins import HireGroupCommand, FireGroupCommand, ResignGroupCommand
-
-# from ..protocol.commands import CommandHelper
+from ..protocol.base import BaseContent
+from ..protocol.contents import BaseTextContent, WebPageContent, NameCardContent
+from ..protocol.forward import SecretContent, CombineForwardContent, ListContent
+from ..protocol.files import BaseFileContent, ImageFileContent, AudioFileContent, VideoFileContent
+from ..protocol.money import BaseMoneyContent, TransferMoneyContent
+from ..protocol.quote import BaseQuoteContent
+
+from ..protocol.base import BaseCommand
+from ..protocol.commands import BaseMetaCommand, BaseDocumentCommand
+from ..protocol.receipt import BaseReceiptCommand
+
+from ..protocol.groups import BaseHistoryCommand, BaseGroupCommand
+from ..protocol.groups import InviteGroupCommand, ExpelGroupCommand, JoinGroupCommand
+from ..protocol.groups import QuitGroupCommand, QueryGroupCommand, ResetGroupCommand
+from ..protocol.groups import HireGroupCommand, FireGroupCommand, ResignGroupCommand
+
+# from ..protocol.base import CommandHelper
 # from ..protocol.helpers import CommandExtensions
 
 __all__ = [

{dimp-2.3.0 → dimp-2.3.2}/dimp/mkm/docs.py

@@ -28,7 +28,7 @@
 # SOFTWARE.
 # ==============================================================================
 
-from typing import Optional, Any, Dict, List
+from typing import Optional, Dict, List
 
 from mkm.crypto import PublicKey, EncryptKey
 from mkm.format import TransportableData
@@ -43,7 +43,7 @@ from .document import BaseDocument
 
 class BaseVisa(BaseDocument, Visa):
 
-    def __init__(self, document: Optional[Dict[str, Any]] = None,
+    def __init__(self, document: Optional[Dict] = None,
                  identifier: ID = None, data: Optional[str] = None, signature: Optional[TransportableData] = None):
         if document is None:
             # 1. document from local
@@ -68,15 +68,17 @@ class BaseVisa(BaseDocument, Visa):
 
     @property  # Override
     def public_key(self) -> Optional[EncryptKey]:
-        if self.__key is None:
+        visa_key = self.__key
+        if visa_key is None:
             info = self.get_property(name='key')
             # assert info is not None, 'visa key not found: %s' % self.dictionary
             pub = PublicKey.parse(key=info)
             if isinstance(pub, EncryptKey):
-                self.__key = pub
+                visa_key = pub
+                self.__key = visa_key
             else:
                 assert info is None, 'visa key error: %s' % info
-        return self.__key
+        return visa_key
 
     @public_key.setter  # Override
     def public_key(self, key: EncryptKey):
@@ -91,25 +93,27 @@ class BaseVisa(BaseDocument, Visa):
 
     @property  # Override
     def avatar(self) -> Optional[PortableNetworkFile]:
-        if self.__avatar is None:
+        img = self.__avatar
+        if img is None:
             url = self.get_property(name='avatar')
             if isinstance(url, str) and len(url) == 0:
                 # ignore empty URL
                 pass
             else:
-                self.__avatar = PortableNetworkFile.parse(url)
-        return self.__avatar
+                img = PortableNetworkFile.parse(url)
+                self.__avatar = img
+        return img
 
     @avatar.setter  # Override
-    def avatar(self, url: PortableNetworkFile):
-        info = None if url is None else url.object
+    def avatar(self, img: PortableNetworkFile):
+        info = None if img is None else img.object
         self.set_property(name='avatar', value=info)
-        self.__avatar = url
+        self.__avatar = img
 
 
 class BaseBulletin(BaseDocument, Bulletin):
 
-    def __init__(self, document: Optional[Dict[str, Any]] = None,
+    def __init__(self, document: Optional[Dict] = None,
                  identifier: ID = None,
                  data: Optional[str] = None, signature: Optional[TransportableData] = None):
         if document is None:
@@ -134,13 +138,13 @@ class BaseBulletin(BaseDocument, Bulletin):
     def assistants(self) -> Optional[List[ID]]:
         if self.__bots is None:
             bots = self.get_property(name='assistants')
-            if bots is None:
+            if isinstance(bots, List):
+                self.__bots = ID.convert(array=bots)
+            else:
                 # get from 'assistant'
                 single = self.get_property(name='assistant')
                 single = ID.parse(identifier=single)
                 self.__bots = [] if single is None else [single]
-            else:
-                self.__bots = ID.convert(array=bots)
         return self.__bots
 
     @assistants.setter  # Override

{dimp-2.3.0 → dimp-2.3.2}/dimp/mkm/document.py

@@ -37,8 +37,6 @@ from mkm.format import TransportableData
 from mkm.format import json_encode, json_decode, utf8_encode
 from mkm import ID, Document
 
-from ..crypto import EncodeAlgorithms
-
 
 """
     Base Documents
@@ -50,7 +48,7 @@ from ..crypto import EncodeAlgorithms
 
 class BaseDocument(Dictionary, Document):
 
-    def __init__(self, document: Dict[str, Any] = None,
+    def __init__(self, document: Dict = None,
                  doc_type: str = None, identifier: ID = None,
                  data: Optional[str] = None, signature: Optional[TransportableData] = None):
         # check parameters
@@ -102,15 +100,6 @@ class BaseDocument(Dictionary, Document):
         self.__properties = properties
         self.__status = status  # 1 for valid, -1 for invalid
 
-    # @property  # Override
-    # def type(self) -> Optional[str]:
-    #     doc_type = self.get_property(name='type')  # deprecated
-    #     if doc_type is None:
-    #         ext = SharedAccountExtensions()
-    #         doc_type = ext.helper.get_document_type(document=self.dictionary, default=None)
-    #         # doc_type = self.get_str(key='type', default=None)
-    #     return doc_type
-
     @property  # Override
     def identifier(self) -> ID:
         if self.__identifier is None:
@@ -200,17 +189,13 @@ class BaseDocument(Dictionary, Document):
         # 2. encode & sign
         info = self.properties
         if info is None:
-            # assert False, 'should not happen'
+            # assert False, 'document invalid: %s' % self.dictionary
             return None
         data = json_encode(info)
-        if len(data) == 0:
-            # properties error
-            return None
+        assert len(data) > 0, 'should not happen: %s' % info
         signature = private_key.sign(data=utf8_encode(string=data))
-        if len(signature) == 0:
-            # assert False, 'should not happen'
-            return None
-        ted = TransportableData.create(data=signature, algorithm=EncodeAlgorithms.DEFAULT)
+        assert len(signature) > 0, 'should not happen: %s' % info
+        ted = TransportableData.create(data=signature)
         # 3. update 'data' & 'signature' fields
         self['data'] = data             # JsON string
         self['signature'] = ted.object  # BASE-64
@@ -225,7 +210,7 @@ class BaseDocument(Dictionary, Document):
     #
 
     @property  # Override
-    def properties(self) -> Optional[Dict[str, Any]]:
+    def properties(self) -> Optional[Dict]:
         """ Load properties from data """
         if self.__status < 0:
             # invalid

{dimp-2.3.0 → dimp-2.3.2}/dimp/mkm/meta.py

@@ -29,7 +29,7 @@
 # ==============================================================================
 
 from abc import ABC, abstractmethod
-from typing import Optional, Any, Dict
+from typing import Optional, Dict
 
 from mkm.format import utf8_encode
 from mkm.format import TransportableData
@@ -45,10 +45,10 @@ from mkm import Meta
     This class is used to generate entity ID
 
     data format: {
-        type       : 1,              // meta version
-        seed       : "moKy",         // user/group name
-        key        : "{public key}", // PK = secp256k1(SK);
-        fingerprint: "..."           // CT = sign(seed, SK);
+        type        : 1,              // meta version
+        key         : "{public key}", // PK = secp256k1(SK);
+        seed        : "moKy",         // user/group name
+        fingerprint : "..."           // CT = sign(seed, SK);
     }
 
     algorithm:
@@ -59,10 +59,9 @@ from mkm import Meta
 """
 
 
-# noinspection PyAbstractClass
 class BaseMeta(Dictionary, Meta, ABC):
 
-    def __init__(self, meta: Dict[str, Any] = None,
+    def __init__(self, meta: Dict = None,
                  version: str = None, public_key: VerifyKey = None,
                  seed: Optional[str] = None, fingerprint: Optional[TransportableData] = None):
         # check parameters
@@ -143,7 +142,7 @@ class BaseMeta(Dictionary, Meta, ABC):
         ted = self.__fingerprint
         if ted is None and self.has_seed:
             base64 = self.get('fingerprint')
-            assert base64 is not None, 'meta.fingerprint should not be empty: %s' % self
+            assert base64 is not None, 'meta.fingerprint should not be empty: %s' % self.dictionary
             self.__fingerprint = ted = TransportableData.parse(base64)
             assert ted is not None, 'meta.fingerprint error: %s' % base64
         if ted is not None:

{dimp-2.3.0 → dimp-2.3.2}/dimp/msg/base.py

@@ -50,7 +50,7 @@
 """
 
 
-from typing import Optional, Any, Dict
+from typing import Optional, Dict
 
 from mkm.types import DateTime
 from mkm.types import Dictionary
@@ -61,7 +61,7 @@ from dkd import Envelope, Message
 
 class BaseMessage(Dictionary, Message):
 
-    def __init__(self, msg: Dict[str, Any] = None, head: Envelope = None):
+    def __init__(self, msg: Dict = None, head: Envelope = None):
         if msg is None:
             # 1. new message with envelope
             assert head is not None, 'message envelope should not be empty'

{dimp-2.3.0 → dimp-2.3.2}/dimp/msg/envelope.py

@@ -28,7 +28,7 @@
 # SOFTWARE.
 # ==============================================================================
 
-from typing import Optional, Any, Dict
+from typing import Optional, Dict
 
 from mkm.types import DateTime
 from mkm.types import Dictionary
@@ -53,7 +53,7 @@ from dkd import Envelope
 
 class MessageEnvelope(Dictionary, Envelope):
 
-    def __init__(self, envelope: Dict[str, Any] = None,
+    def __init__(self, envelope: Dict = None,
                  sender: ID = None, receiver: Optional[ID] = None, time: Optional[DateTime] = None):
         if envelope is None:
             # 1. new envelope with sender, receiver & time
@@ -80,21 +80,24 @@ class MessageEnvelope(Dictionary, Envelope):
 
     @property  # Override
     def sender(self) -> ID:
-        if self.__sender is None:
-            identifier = self.get('sender')
-            self.__sender = ID.parse(identifier=identifier)
-        return self.__sender
+        did = self.__sender
+        if did is None:
+            did = self.get('sender')
+            did = ID.parse(identifier=did)
+            assert did is not None, 'message sender error: %s' % self.dictionary
+            self.__sender = did
+        return did
 
     @property  # Override
     def receiver(self) -> ID:
-        if self.__receiver is None:
-            identifier = self.get('receiver')
-            identifier = ID.parse(identifier=identifier)
-            if identifier is None:
-                self.__receiver = ANYONE
-            else:
-                self.__receiver = identifier
-        return self.__receiver
+        did = self.__receiver
+        if did is None:
+            did = self.get('receiver')
+            did = ID.parse(identifier=did)
+            if did is None:
+                did = ANYONE
+            self.__receiver = did
+        return did
 
     @property  # Override
     def time(self) -> Optional[DateTime]: