dimp 2.2.2__tar.gz → 2.3.1__tar.gz

dimp-2.3.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 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.

dimp-2.3.1/PKG-INFO

@@ -0,0 +1,248 @@
+Metadata-Version: 2.1
+Name: dimp
+Version: 2.3.1
+Summary: Decentralized Instant Messaging Protocol
+Home-page: https://github.com/dimchat/core-py
+Author: Albert Moky
+Author-email: albert.moky@gmail.com
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# Decentralized Instant Messaging Protocol (Python)
+
+[![License](https://img.shields.io/github/license/dimchat/core-py)](https://github.com/dimchat/core-py/blob/master/LICENSE)
+[![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)](https://github.com/dimchat/core-py/pulls)
+[![Platform](https://img.shields.io/badge/Platform-Python%203-brightgreen.svg)](https://github.com/dimchat/core-py/wiki)
+[![Issues](https://img.shields.io/github/issues/dimchat/core-py)](https://github.com/dimchat/core-py/issues)
+[![Repo Size](https://img.shields.io/github/repo-size/dimchat/core-py)](https://github.com/dimchat/core-py/archive/refs/heads/main.zip)
+[![Tags](https://img.shields.io/github/tag/dimchat/core-py)](https://github.com/dimchat/core-py/tags)
+[![Version](https://img.shields.io/pypi/v/dimp)](https://pypi.org/project/dimp)
+
+[![Watchers](https://img.shields.io/github/watchers/dimchat/core-py)](https://github.com/dimchat/core-py/watchers)
+[![Forks](https://img.shields.io/github/forks/dimchat/core-py)](https://github.com/dimchat/core-py/forks)
+[![Stars](https://img.shields.io/github/stars/dimchat/core-py)](https://github.com/dimchat/core-py/stargazers)
+[![Followers](https://img.shields.io/github/followers/dimchat)](https://github.com/orgs/dimchat/followers)
+
+## Dependencies
+
+| Name | Version | Description |
+|------|---------|-------------|
+| [Ming Ke Ming (名可名)](https://github.com/dimchat/mkm-py) | [![Version](https://img.shields.io/pypi/v/mkm)](https://pypi.org/project/mkm) | Decentralized User Identity Authentication |
+| [Dao Ke Dao (道可道)](https://github.com/dimchat/dkd-py) | [![Version](https://img.shields.io/pypi/v/dkd)](https://pypi.org/project/dkd) | Universal Message Module |
+
+## Examples
+
+### extends Command
+
+* _Handshake Command Protocol_
+  0. (C-S) handshake start
+  1. (S-C) handshake again with new session
+  2. (C-S) handshake restart with new session
+  3. (S-C) handshake success
+
+```python
+from enum import IntEnum
+from typing import Optional, Any, Dict
+
+from dimp import Command, BaseCommand
+
+
+class HandshakeState(IntEnum):
+    Start = 0    # C -> S, without session key(or session expired)
+    Again = 1    # S -> C, with new session key
+    Restart = 2  # C -> S, with new session key
+    Success = 3  # S -> C, handshake accepted
+
+
+class HandshakeCommand(BaseCommand):
+    """
+        Handshake Command
+        ~~~~~~~~~~~~~~~~~
+
+        data format: {
+            type : 0x88,
+            sn   : 123,
+
+            command : "handshake",    // command name
+            title   : "Hello world!", // "DIM?", "DIM!"
+            session : "{SESSION_ID}", // session key
+        }
+    """
+    HANDSHAKE = 'handshake'
+
+    def __init__(self, content: Dict[str, Any] = None, title: str = None, session: str = None):
+        if content is None:
+            # 1. new command with title & session key
+            assert title is not None, 'handshake command error: %s' % session
+            cmd = self.HANDSHAKE
+            super().__init__(cmd=cmd)
+            self['title'] = title
+            self['message'] = title  # TODO: remove after all clients upgraded
+            if session is not None:
+                self['session'] = session
+        else:
+            # 2. command info from network
+            assert title is None and session is None, 'params error: %s, %s, %s' % (content, title, session)
+            super().__init__(content)
+
+    @property
+    def title(self) -> str:
+        # TODO: modify after all clients upgraded
+        text = self.get_str(key='title', default=None)
+        if text is None:
+            # compatible with v1.0
+            text = self.get_str(key='message', default='')
+        return text
+
+    @property
+    def session(self) -> Optional[str]:
+        return self.get_str(key='session', default=None)
+
+    @property
+    def state(self) -> HandshakeState:
+        return handshake_state(title=self.title, session=self.session)
+
+    @classmethod
+    def offer(cls, session: str = None) -> Command:
+        """
+        Create client-station handshake offer
+
+        :param session: Old session key
+        :return: HandshakeCommand object
+        """
+        return HandshakeCommand(title='Hello world!', session=session)
+
+    @classmethod
+    def ask(cls, session: str) -> Command:
+        """
+        Create station-client handshake again with new session
+
+        :param session: New session key
+        :return: HandshakeCommand object
+        """
+        return HandshakeCommand(title='DIM?', session=session)
+
+    @classmethod
+    def accepted(cls, session: str = None) -> Command:
+        """
+        Create station-client handshake success notice
+
+        :return: HandshakeCommand object
+        """
+        return HandshakeCommand(title='DIM!', session=session)
+
+    start = offer       # (1. C->S) first handshake, without session
+    again = ask         # (2. S->C) ask client to handshake with new session key
+    restart = offer     # (3. C->S) handshake with new session key
+    success = accepted  # (4. S->C) notice the client that handshake accepted
+
+
+def handshake_state(title: str, session: str = None) -> HandshakeState:
+    # Server -> Client
+    if title == 'DIM!':  # or title == 'OK!':
+        return HandshakeState.Success
+    if title == 'DIM?':
+        return HandshakeState.Again
+    # Client -> Server: "Hello world!"
+    if session is None or len(session) == 0:
+        return HandshakeState.Start
+    else:
+        return HandshakeState.Restart
+```
+
+### extends Content
+
+```python
+from abc import ABC, abstractmethod
+from typing import Any, Dict
+
+from dimp import ContentType
+from dimp import Content
+from dimp import BaseContent
+
+
+class CustomizedContent(Content, ABC):
+    """
+        Application Customized message
+        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+        data format: {
+            type : 0xCC,
+            sn   : 123,
+
+            app   : "{APP_ID}",  // application (e.g.: "chat.dim.sechat")
+            mod   : "{MODULE}",  // module name (e.g.: "drift_bottle")
+            act   : "{ACTION}",  // action name (e.g.: "throw")
+            extra : info         // action parameters
+        }
+    """
+
+    @property
+    @abstractmethod
+    def application(self) -> str:
+        """ App ID """
+        raise NotImplemented
+
+    @property
+    @abstractmethod
+    def module(self) -> str:
+        """ Module Name """
+        raise NotImplemented
+
+    @property
+    @abstractmethod
+    def action(self) -> str:
+        """ Action Name """
+        raise NotImplemented
+
+    @classmethod
+    def create(cls, app: str, mod: str, act: str):
+        return AppCustomizedContent(app=app, mod=mod, act=act)
+
+
+class AppCustomizedContent(BaseContent, CustomizedContent):
+
+    def __init__(self, content: Dict[str, Any] = None,
+                 msg_type: int = None,
+                 app: str = None, mod: str = None, act: str = None):
+        if content is None:
+            # 1. new content with type, application, module & action
+            assert app is not None and mod is not None and act is not None, \
+                'customized content error: %s, %s, %s, %s' % (msg_type, app, mod, act)
+            if msg_type is None:
+                msg_type = ContentType.CUSTOMIZED.value
+            super().__init__(None, msg_type)
+            self['app'] = app
+            self['mod'] = mod
+            self['act'] = act
+        else:
+            # 2. content info from network
+            assert msg_type is None and app is None and mod is None and act is None, \
+                'params error: %s, %s, %s, %s, %s' % (content, msg_type, app, mod, act)
+            super().__init__(content)
+
+    @property  # Override
+    def application(self) -> str:
+        return self.get_str(key='app', default='')
+
+    @property  # Override
+    def module(self) -> str:
+        return self.get_str(key='mod', default='')
+
+    @property  # Override
+    def action(self) -> str:
+        return self.get_str(key='act', default='')
+```
+
+### extends ID Address
+
+* Examples in [dim plugins](https://pypi.org/project/dimplugins)
+
+----
+
+Copyright © 2018 Albert Moky
+[![Followers](https://img.shields.io/github/followers/moky)](https://github.com/moky?tab=followers)

{dimp-2.2.2 → dimp-2.3.1}/dimp/__init__.py

@@ -52,7 +52,8 @@ __all__ = [
 
     'URI', 'DateTime',
 
-    'Converter', 'Copier',
+    'Converter', 'DataConverter', 'BaseConverter',
+    'Copier',
     'Wrapper', 'Stringer', 'Mapper',
     'ConstantString',  # 'String',
     'Dictionary',
@@ -102,6 +103,12 @@ __all__ = [
     'BaseDataWrapper',
     'BaseFileWrapper',
 
+    #
+    #   Algorithm
+    #
+    'AsymmetricAlgorithms', 'SymmetricAlgorithms',
+    'EncodeAlgorithms',
+
     #
     #   MingKeMing
     #
@@ -125,6 +132,8 @@ __all__ = [
     'BaseMeta',
     'BaseDocument', 'BaseVisa', 'BaseBulletin',
 
+    'MetaType', 'DocumentType',
+
     #
     #   DaoKeDao
     #

{dimp-2.2.2 → dimp-2.3.1}/dimp/crypto/__init__.py

@@ -30,6 +30,9 @@
 
 from mkm.crypto import *
 
+from .algorithms import AsymmetricAlgorithms, SymmetricAlgorithms
+from .algorithms import EncodeAlgorithms
+
 from .keys import BaseKey, BaseSymmetricKey
 from .keys import BaseAsymmetricKey, BasePublicKey, BasePrivateKey
 
@@ -57,6 +60,12 @@ __all__ = [
 
     'SymmetricKeyFactory', 'PrivateKeyFactory', 'PublicKeyFactory',
 
+    #
+    #   Algorithm
+    #
+    'AsymmetricAlgorithms', 'SymmetricAlgorithms',
+    'EncodeAlgorithms',
+
     #
     #   Base Keys
     #

dimp-2.3.1/dimp/crypto/algorithms.py

@@ -0,0 +1,57 @@
+# -*- coding: utf-8 -*-
+#
+#   DIMP : Decentralized Instant Messaging Protocol
+#
+#                                Written in 2025 by Moky <albert.moky@gmail.com>
+#
+# ==============================================================================
+# MIT License
+#
+# Copyright (c) 2025 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.
+# ==============================================================================
+
+
+class AsymmetricAlgorithms:
+    """ Algorithms for Asymmetric Key """
+
+    RSA = 'RSA'  # -- "RSA/ECB/PKCS1Padding", "SHA256withRSA"
+    ECC = 'ECC'
+
+
+class SymmetricAlgorithms:
+    """ Algorithms for Symmetric Key """
+
+    AES = 'AES'  # -- "AES/CBC/PKCS7Padding"
+    DES = 'DES'
+
+    # Symmetric key algorithm for broadcast message,
+    # which will do nothing when en/decoding message data
+    PLAIN = 'PLAIN'
+
+
+class EncodeAlgorithms:
+    """ Algorithms for Encoding Data """
+
+    DEFAULT = 'base64'
+
+    BASE_64 = 'base64'
+    BASE_58 = 'base58'
+    HEX = 'hex'

{dimp-2.2.2 → dimp-2.3.1}/dimp/crypto/keys.py

@@ -29,7 +29,7 @@
 # ==============================================================================
 
 from abc import ABC
-from typing import Optional, Any, Dict
+from typing import Any, Dict
 
 from mkm.types import Dictionary
 from mkm.crypto import CryptographyKey, EncryptKey, DecryptKey, SignKey, VerifyKey
@@ -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, Any]) -> 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:

{dimp-2.2.2 → dimp-2.3.1}/dimp/crypto/ted.py

@@ -33,9 +33,10 @@ from typing import Optional, Any, Dict
 from mkm.format import base64_encode, base64_decode
 from mkm.format import base58_encode, base58_decode
 from mkm.format import hex_encode, hex_decode
-from mkm.format import TransportableData
 from mkm.types import Dictionary
 
+from .algorithms import EncodeAlgorithms
+
 
 class BaseDataWrapper(Dictionary):
     """
@@ -68,11 +69,11 @@ class BaseDataWrapper(Dictionary):
 
     # 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 == TransportableData.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}"
@@ -84,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)
@@ -97,14 +98,14 @@ class BaseDataWrapper(Dictionary):
 
     @property
     def algorithm(self) -> str:
-        alg = self.get_str(key='algorithm', default='')
-        if len(alg) == 0:
-            alg = TransportableData.DEFAULT
+        alg = self.get_str(key='algorithm', default=None)
+        if alg is None or len(alg) == 0:
+            alg = EncodeAlgorithms.DEFAULT
         return alg
 
     @algorithm.setter
     def algorithm(self, name: str):
-        if name is None:  # or name == TransportableData.DEFAULT:
+        if name is None:  # or name == EncodeAlgorithms.DEFAULT:
             self.pop('algorithm', None)
         else:
             self['algorithm'] = name
@@ -117,14 +118,17 @@ 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 == TransportableData.BASE_64:
+                if alg == EncodeAlgorithms.BASE_64:
                     binary = base64_decode(string=text)
-                elif alg == TransportableData.BASE_58:
+                elif alg == EncodeAlgorithms.BASE_58:
                     binary = base58_decode(string=text)
-                elif alg == TransportableData.HEX:
+                elif alg == EncodeAlgorithms.HEX:
                     binary = hex_decode(string=text)
                 else:
                     assert False, 'data algorithm not support: %s' % alg
@@ -137,13 +141,14 @@ class BaseDataWrapper(Dictionary):
             self.pop('data', None)
         else:
             alg = self.algorithm
-            if alg == TransportableData.BASE_64:
+            if alg == EncodeAlgorithms.BASE_64:
                 text = base64_encode(data=binary)
-            elif alg == TransportableData.BASE_58:
+            elif alg == EncodeAlgorithms.BASE_58:
                 text = base58_encode(data=binary)
-            elif alg == TransportableData.HEX:
+            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.2.2 → dimp-2.3.1}/dimp/dkd/base.py

@@ -33,10 +33,11 @@ from typing import Optional, Any, Dict
 from mkm.types import DateTime
 from mkm.types import Dictionary
 from mkm import ID
-from dkd import ContentType, Content
+from dkd import Content
 from dkd import InstantMessage
 from dkd.plugins import SharedMessageExtensions
 
+from ..protocol import ContentType
 from ..protocol import Command
 
 from ..plugins import SharedCommandExtensions
@@ -52,11 +53,11 @@ from ..plugins import SharedCommandExtensions
 
 class BaseContent(Dictionary, Content):
 
-    def __init__(self, content: Dict[str, Any] = None, msg_type: int = None):
+    def __init__(self, content: Dict[str, Any] = None, msg_type: str = None):
         # check parameters
         if content is None:
             # 1. new content with type
-            assert msg_type is not None and msg_type > 0, 'content type error: %s' % msg_type
+            assert msg_type is not None and len(msg_type) > 0, 'content type error: %s' % msg_type
             time = DateTime.now()
             sn = InstantMessage.generate_serial_number(msg_type, time)
             content = {
@@ -77,11 +78,11 @@ class BaseContent(Dictionary, Content):
         self.__time = time
 
     @property  # Override
-    def type(self) -> int:
+    def type(self) -> str:
         """ message content type: text, image, ... """
         if self.__type is None:
             ext = SharedMessageExtensions()
-            self.__type = ext.helper.get_content_type(content=self.dictionary, default=0)
+            self.__type = ext.helper.get_content_type(content=self.dictionary, default='')
             # self.__type = self.get_int(key='type', default=0)
         return self.__type
 
@@ -114,18 +115,18 @@ class BaseContent(Dictionary, Content):
 
 class BaseCommand(BaseContent, Command):
 
-    def __init__(self, content: Dict[str, Any] = None, msg_type: int = None, cmd: str = None):
+    def __init__(self, content: Dict[str, Any] = None, msg_type: str = None, cmd: str = None):
         # check parameters
         if content is None:
             # 1. new command with type & name
             if msg_type is None:
-                msg_type = ContentType.COMMAND.value
+                msg_type = ContentType.COMMAND
             assert cmd is not None and len(cmd) > 0, 'command name should not empty'
             super().__init__(None, msg_type)
             self['command'] = cmd
         else:
             # 2. command info from network
-            assert msg_type is None and cmd is None, 'params error: %d, %s' % (msg_type, cmd)
+            assert msg_type is None and cmd is None, 'params error: %s, %s' % (msg_type, cmd)
             super().__init__(content)
 
     @property  # Override