dimp 2.2.2__tar.gz → 2.3.0__tar.gz

dimp-2.3.0/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.0/PKG-INFO

@@ -0,0 +1,248 @@
+Metadata-Version: 2.1
+Name: dimp
+Version: 2.3.0
+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.0}/dimp/__init__.py

@@ -102,6 +102,12 @@ __all__ = [
     'BaseDataWrapper',
     'BaseFileWrapper',
 
+    #
+    #   Algorithm
+    #
+    'AsymmetricAlgorithms', 'SymmetricAlgorithms',
+    'EncodeAlgorithms',
+
     #
     #   MingKeMing
     #
@@ -125,6 +131,8 @@ __all__ = [
     'BaseMeta',
     'BaseDocument', 'BaseVisa', 'BaseBulletin',
 
+    'MetaType', 'DocumentType',
+
     #
     #   DaoKeDao
     #

{dimp-2.2.2 → dimp-2.3.0}/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.0/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.0}/dimp/crypto/pnf.py

@@ -35,6 +35,8 @@ from mkm.types import URI
 from mkm.types import Dictionary
 from mkm.crypto import DecryptKey, SymmetricKey
 
+from .algorithms import EncodeAlgorithms
+
 
 class BaseFileWrapper(Dictionary):
     """
@@ -90,7 +92,7 @@ class BaseFileWrapper(Dictionary):
             ted = None
             self.pop('data', None)
         else:
-            ted = TransportableData.create(data=binary)
+            ted = TransportableData.create(data=binary, algorithm=EncodeAlgorithms.DEFAULT)
             self['data'] = ted.object
         self.__attachment = ted
 

{dimp-2.2.2 → dimp-2.3.0}/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):
     """
@@ -72,7 +73,7 @@ class BaseDataWrapper(Dictionary):
         if len(text) == 0:
             return text
         alg = self.get_str(key='algorithm', default='')
-        if alg == TransportableData.DEFAULT:
+        if alg == EncodeAlgorithms.DEFAULT:
             alg = ''
         if len(alg) == 0:
             # 0. "{BASE64_ENCODE}"
@@ -99,12 +100,12 @@ class BaseDataWrapper(Dictionary):
     def algorithm(self) -> str:
         alg = self.get_str(key='algorithm', default='')
         if len(alg) == 0:
-            alg = TransportableData.DEFAULT
+            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
@@ -120,11 +121,11 @@ class BaseDataWrapper(Dictionary):
             text = self.get_str(key='data', default='')
             if len(text) > 0:
                 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,11 +138,11 @@ 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

{dimp-2.2.2 → dimp-2.3.0}/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

{dimp-2.2.2 → dimp-2.3.0}/dimp/dkd/commands.py

@@ -32,11 +32,11 @@
     Meta Command Protocol
     ~~~~~~~~~~~~~~~~~~~~~
 
-    1. contains 'ID' only, means query meta for ID
+    1. contains 'did' only, means query meta for ID
     2. contains 'meta' (must match), means reply
 """
 
-from typing import Optional, Any, Dict
+from typing import Optional, Any, List, Dict
 
 from mkm.types import DateTime
 from mkm import ID, Meta, Document
@@ -52,11 +52,11 @@ class BaseMetaCommand(BaseCommand, MetaCommand):
         ~~~~~~~~~~~~
 
         data format: {
-            type : 0x88,
+            type : i2s(0x88),
             sn   : 123,
 
             command : "meta", // command name
-            ID      : "{ID}", // contact's ID
+            did     : "{ID}", // contact's ID
             meta    : {...}   // When meta is empty, means query meta for ID
         }
     """
@@ -71,7 +71,7 @@ class BaseMetaCommand(BaseCommand, MetaCommand):
             if cmd is None:
                 cmd = Command.META
             super().__init__(cmd=cmd)
-            self.set_string(key='ID', value=identifier)
+            self.set_string(key='did', value=identifier)
             if meta is not None:
                 self.set_map(key='meta', value=meta)
         else:
@@ -89,7 +89,7 @@ class BaseMetaCommand(BaseCommand, MetaCommand):
     @property  # Override
     def identifier(self) -> ID:
         if self.__id is None:
-            self.__id = ID.parse(identifier=self.get('ID'))
+            self.__id = ID.parse(identifier=self.get('did'))
         return self.__id
 
     #
@@ -108,14 +108,14 @@ class BaseDocumentCommand(BaseMetaCommand, DocumentCommand):
         ~~~~~~~~~~~~~~~~
 
         data format: {
-            type : 0x88,
+            type : i2s(0x88),
             sn   : 123,
 
             command   : "document", // command name
-            ID        : "{ID}",     // entity ID
+            did       : "{ID}",     // entity ID
             meta      : {...},      // only for handshaking with new friend
-            document  : {...},      // when document is empty, means query for ID
-            signature : "..."       // old document's signature for querying
+            documents : [...],      // when document is empty, means query for ID
+            last_time : 12345       // old document time for querying
         }
 
     """
@@ -123,38 +123,37 @@ class BaseDocumentCommand(BaseMetaCommand, DocumentCommand):
     def __init__(self, content: Dict[str, Any] = None,
                  identifier: ID = None,
                  meta: Optional[Meta] = None,
-                 document: Optional[Document] = None,
+                 documents: List[Document] = None,
                  last_time: Optional[DateTime] = None):
         if content is None:
             # 1. new command with ID, meta, document & signature
-            if identifier is None:
-                assert document is not None, 'document command error: %s, %s' % (meta, last_time)
-                identifier = document.identifier
-            assert identifier is not None, 'document command error: %s, %s, %s' % (meta, document, last_time)
-            cmd = Command.DOCUMENT
+            assert identifier is not None, 'document command error: %s, %s, %s' % (meta, documents, last_time)
+            cmd = Command.DOCUMENTS
             super().__init__(cmd=cmd, identifier=identifier, meta=meta)
             # respond with document info
-            if document is not None:
-                self['document'] = document.dictionary
+            if documents is not None:
+                self['documents'] = Document.revert(documents=documents)
             # query with last document time
             if last_time is not None:
                 self.set_datetime(key='last_time', value=last_time)
         else:
             # 2. command info from network
-            assert identifier is None and meta is None and document is None and last_time is None, \
-                'params error: %s, %s, %s, %s, %s' % (content, identifier, meta, document, last_time)
+            assert identifier is None and meta is None and documents is None and last_time is None, \
+                'params error: %s, %s, %s, %s, %s' % (content, identifier, meta, documents, last_time)
             super().__init__(content)
         # lazy load
-        self.__doc = document
+        self.__docs = documents
 
     #
     #   document
     #
     @property  # Override
-    def document(self) -> Optional[Document]:
-        if self.__doc is None:
-            self.__doc = Document.parse(document=self.get('document'))
-        return self.__doc
+    def documents(self) -> Optional[List[Document]]:
+        if self.__docs is None:
+            docs = self.get('documents')
+            if docs is not None:
+                self.__docs = Document.convert(array=docs)
+        return self.__docs
 
     @property  # Override
     def last_time(self) -> Optional[DateTime]: