dimples 0.5.8__tar.gz → 1.0.0__tar.gz

{dimples-0.5.8 → dimples-1.0.0}/PKG-INFO

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

{dimples-0.5.8 → dimples-1.0.0}/dimples/client/archivist.py

@@ -75,7 +75,7 @@ class ClientArchivist(CommonArchivist, ABC):
         self.__last_active_members[group] = member
 
     # Override
-    def query_meta(self, identifier: ID) -> bool:
+    async def query_meta(self, identifier: ID) -> bool:
         if not self.is_meta_query_expired(identifier=identifier):
             # query not expired yet
             self.info(msg='meta query not expired yet: %s' % identifier)
@@ -86,11 +86,11 @@ class ClientArchivist(CommonArchivist, ABC):
             return False
         self.info(msg='querying meta for: %s' % identifier)
         command = MetaCommand.query(identifier=identifier)
-        _, r_msg = messenger.send_content(sender=None, receiver=Station.ANY, content=command, priority=1)
+        _, r_msg = await messenger.send_content(sender=None, receiver=Station.ANY, content=command, priority=1)
         return r_msg is not None
 
     # Override
-    def query_documents(self, identifier: ID, documents: List[Document]) -> bool:
+    async def query_documents(self, identifier: ID, documents: List[Document]) -> bool:
         if not self.is_documents_query_expired(identifier=identifier):
             # query not expired yet
             self.info(msg='document query not expired yet: %s' % identifier)
@@ -99,14 +99,14 @@ class ClientArchivist(CommonArchivist, ABC):
         if messenger is None:
             self.warning(msg='messenger not ready yet')
             return False
-        last_time = self.get_last_document_time(identifier=identifier, documents=documents)
+        last_time = await self.get_last_document_time(identifier=identifier, documents=documents)
         self.info(msg='querying document for: %s, last time: %s' % (identifier, last_time))
         command = DocumentCommand.query(identifier=identifier, last_time=last_time)
-        _, r_msg = messenger.send_content(sender=None, receiver=Station.ANY, content=command, priority=1)
+        _, r_msg = await messenger.send_content(sender=None, receiver=Station.ANY, content=command, priority=1)
         return r_msg is not None
 
     # Override
-    def query_members(self, group: ID, members: List[ID]) -> bool:
+    async def query_members(self, group: ID, members: List[ID]) -> bool:
         if not self.is_members_query_expired(group=group):
             # query not expired yet
             self.info('members query not expired yet: %s' % group)
@@ -121,20 +121,20 @@ class ClientArchivist(CommonArchivist, ABC):
             self.error(msg='failed to get current user')
             return False
         me = user.identifier
-        last_time = self.get_last_group_history_time(group=group)
+        last_time = await self.get_last_group_history_time(group=group)
         self.info(msg='querying members for group: %s, last time: %s' % (group, last_time))
         # build query command for group members
         command = GroupCommand.query(group=group, last_time=last_time)
         # 1. check group bots
-        ok = self.query_members_from_assistants(command=command, sender=me, group=group)
+        ok = await self.query_members_from_assistants(command=command, sender=me, group=group)
         if ok:
             return True
         # 2. check administrators
-        ok = self.query_members_from_administrators(command=command, sender=me, group=group)
+        ok = await self.query_members_from_administrators(command=command, sender=me, group=group)
         if ok:
             return True
         # 3. check group owner
-        ok = self.query_members_from_owner(command=command, sender=me, group=group)
+        ok = await self.query_members_from_owner(command=command, sender=me, group=group)
         if ok:
             return True
         # all failed, try last active member
@@ -143,18 +143,18 @@ class ClientArchivist(CommonArchivist, ABC):
             r_msg = None
         else:
             self.info(msg='querying members from: %s, group: %s' % (last_member, group))
-            _, r_msg = messenger.send_content(sender=me, receiver=last_member, content=command, priority=1)
+            _, r_msg = await messenger.send_content(sender=me, receiver=last_member, content=command, priority=1)
         self.error(msg='group not ready: %s' % group)
         return r_msg is not None
 
     # protected
-    def query_members_from_assistants(self, command: QueryCommand, sender: ID, group: ID) -> bool:
+    async def query_members_from_assistants(self, command: QueryCommand, sender: ID, group: ID) -> bool:
         facebook = get_facebook(archivist=self)
         messenger = get_messenger(archivist=self)
         if facebook is None or messenger is None:
             self.warning(msg='facebook messenger not ready yet')
             return False
-        bots = facebook.assistants(group)
+        bots = await facebook.get_assistants(group)
         if len(bots) == 0:
             self.warning(msg='assistants not designated for group: %s' % group)
             return False
@@ -165,7 +165,7 @@ class ClientArchivist(CommonArchivist, ABC):
             if receiver == sender:
                 self.warning(msg='ignore cycled querying: %s, group: %s' % (receiver, group))
                 continue
-            _, r_msg = messenger.send_content(sender=sender, receiver=receiver, content=command, priority=1)
+            _, r_msg = await messenger.send_content(sender=sender, receiver=receiver, content=command, priority=1)
             if r_msg is not None:
                 success += 1
         if success == 0:
@@ -177,17 +177,17 @@ class ClientArchivist(CommonArchivist, ABC):
             pass
         else:
             self.info(msg='querying members from: %s, group: %s' % (last_member, group))
-            messenger.send_content(sender=sender, receiver=last_member, content=command, priority=1)
+            await messenger.send_content(sender=sender, receiver=last_member, content=command, priority=1)
         return True
 
     # protected
-    def query_members_from_administrators(self, command: QueryCommand, sender: ID, group: ID) -> bool:
+    async def query_members_from_administrators(self, command: QueryCommand, sender: ID, group: ID) -> bool:
         facebook = get_facebook(archivist=self)
         messenger = get_messenger(archivist=self)
         if facebook is None or messenger is None:
             self.warning(msg='facebook messenger not ready yet')
             return False
-        admins = facebook.administrators(group)
+        admins = await facebook.get_administrators(group)
         if len(admins) == 0:
             self.warning(msg='administrators not found for group: %s' % group)
             return False
@@ -198,7 +198,7 @@ class ClientArchivist(CommonArchivist, ABC):
             if receiver == sender:
                 self.warning(msg='ignore cycled querying: %s, group: %s' % (receiver, group))
                 continue
-            _, r_msg = messenger.send_content(sender=sender, receiver=receiver, content=command, priority=1)
+            _, r_msg = await messenger.send_content(sender=sender, receiver=receiver, content=command, priority=1)
             if r_msg is not None:
                 success += 1
         if success == 0:
@@ -210,17 +210,17 @@ class ClientArchivist(CommonArchivist, ABC):
             pass
         else:
             self.info(msg='querying members from: %s, group: %s' % (last_member, group))
-            messenger.send_content(sender=sender, receiver=last_member, content=command, priority=1)
+            await messenger.send_content(sender=sender, receiver=last_member, content=command, priority=1)
         return True
 
     # protected
-    def query_members_from_owner(self, command: QueryCommand, sender: ID, group: ID) -> bool:
+    async def query_members_from_owner(self, command: QueryCommand, sender: ID, group: ID) -> bool:
         facebook = get_facebook(archivist=self)
         messenger = get_messenger(archivist=self)
         if facebook is None or messenger is None:
             self.warning(msg='facebook messenger not ready yet')
             return False
-        owner = facebook.owner(group)
+        owner = await facebook.get_owner(group)
         if owner is None:
             self.warning(msg='owner not found for group: %s' % group)
             return False
@@ -229,7 +229,7 @@ class ClientArchivist(CommonArchivist, ABC):
             return False
         # querying members from owner
         self.info(msg='querying members from owner: %s, group: %s' % (owner, group))
-        _, r_msg = messenger.send_content(sender=sender, receiver=owner, content=command, priority=1)
+        _, r_msg = await messenger.send_content(sender=sender, receiver=owner, content=command, priority=1)
         if r_msg is None:
             # failed
             return False
@@ -239,5 +239,5 @@ class ClientArchivist(CommonArchivist, ABC):
             pass
         else:
             self.info(msg='querying members from: %s, group: %s' % (last_member, group))
-            messenger.send_content(sender=sender, receiver=last_member, content=command, priority=1)
+            await messenger.send_content(sender=sender, receiver=last_member, content=command, priority=1)
         return True

{dimples-0.5.8 → dimples-1.0.0}/dimples/client/cpu/commands.py

@@ -43,7 +43,7 @@ from ...common import LoginCommand
 class LoginCommandProcessor(BaseCommandProcessor):
 
     # Override
-    def process_content(self, content: Content, r_msg: ReliableMessage) -> List[Content]:
+    async def process_content(self, content: Content, r_msg: ReliableMessage) -> List[Content]:
         assert isinstance(content, LoginCommand), 'login command error: %s' % content
         # return ReceiptCommand.new(message='Login received')
         return []

{dimples-0.5.8 → dimples-1.0.0}/dimples/client/cpu/group.py

@@ -73,7 +73,7 @@ class HistoryCommandProcessor(BaseCommandProcessor, Logging):
         return transceiver
 
     # Override
-    def process_content(self, content: Content, r_msg: ReliableMessage) -> List[Content]:
+    async def process_content(self, content: Content, r_msg: ReliableMessage) -> List[Content]:
         assert isinstance(content, Command), 'history command error: %s' % content
         text = 'Command not support.'
         return self._respond_receipt(text=text, content=content, envelope=r_msg.envelope, extra={
@@ -123,36 +123,36 @@ class HistoryCommandProcessor(BaseCommandProcessor, Logging):
 
 class GroupCommandProcessor(HistoryCommandProcessor):
 
-    def _owner(self, group: ID) -> Optional[ID]:
+    async def _owner(self, group: ID) -> Optional[ID]:
         delegate = self.delegate
-        return delegate.owner(identifier=group)
+        return await delegate.get_owner(identifier=group)
 
-    def _assistants(self, group: ID) -> List[ID]:
+    async def _assistants(self, group: ID) -> List[ID]:
         delegate = self.delegate
-        return delegate.assistants(identifier=group)
+        return await delegate.get_assistants(identifier=group)
 
-    def _administrators(self, group: ID) -> List[ID]:
+    async def _administrators(self, group: ID) -> List[ID]:
         delegate = self.delegate
-        return delegate.administrators(group=group)
+        return await delegate.get_administrators(group=group)
 
-    def _save_administrators(self, administrators: List[ID], group: ID) -> bool:
+    async def _save_administrators(self, administrators: List[ID], group: ID) -> bool:
         delegate = self.delegate
-        return delegate.save_administrators(administrators=administrators, group=group)
+        return await delegate.save_administrators(administrators=administrators, group=group)
 
-    def _members(self, group: ID) -> List[ID]:
+    async def _members(self, group: ID) -> List[ID]:
         delegate = self.delegate
-        return delegate.members(identifier=group)
+        return await delegate.get_members(identifier=group)
 
-    def _save_members(self, members: List[ID], group: ID) -> bool:
+    async def _save_members(self, members: List[ID], group: ID) -> bool:
         delegate = self.delegate
-        return delegate.save_members(members=members, group=group)
+        return await delegate.save_members(members=members, group=group)
 
-    def _save_group_history(self, group: ID, content: GroupCommand, r_msg: ReliableMessage) -> bool:
+    async def _save_group_history(self, group: ID, content: GroupCommand, r_msg: ReliableMessage) -> bool:
         delegate = self.helper
-        return delegate.save_group_history(group=group, content=content, message=r_msg)
+        return await delegate.save_group_history(group=group, content=content, message=r_msg)
 
     # Override
-    def process_content(self, content: Content, r_msg: ReliableMessage) -> List[Content]:
+    async def process_content(self, content: Content, r_msg: ReliableMessage) -> List[Content]:
         assert isinstance(content, GroupCommand), 'group command error: %s' % content
         text = 'Command not support.'
         return self._respond_receipt(text=text, content=content, envelope=r_msg.envelope, extra={
@@ -162,10 +162,10 @@ class GroupCommandProcessor(HistoryCommandProcessor):
             }
         })
 
-    def _check_expired(self, content: GroupCommand, r_msg: ReliableMessage) -> Tuple[Optional[ID], List[Content]]:
+    async def _check_expired(self, content: GroupCommand, r_msg: ReliableMessage) -> Tuple[Optional[ID], List[Content]]:
         group = content.group
         assert group is not None, 'group command error: %s' % content
-        expired = self.helper.is_expired(content=content)
+        expired = await self.helper.is_expired(content=content)
         if expired:
             text = 'Command expired.'
             errors = self._respond_receipt(text=text, content=content, envelope=r_msg.envelope, extra={
@@ -181,7 +181,8 @@ class GroupCommandProcessor(HistoryCommandProcessor):
             errors = None
         return group, errors
 
-    def _check_command_members(self, content: GroupCommand, r_msg: ReliableMessage) -> Tuple[List[ID], List[Content]]:
+    async def _check_command_members(self, content: GroupCommand, r_msg: ReliableMessage
+                                     ) -> Tuple[List[ID], List[Content]]:
         group = content.group
         assert group is not None, 'group command error: %s' % content
         members = self.helper.members_from_command(content=content)
@@ -198,12 +199,12 @@ class GroupCommandProcessor(HistoryCommandProcessor):
             errors = None
         return members, errors
 
-    def _check_group_members(self, content: GroupCommand,
-                             r_msg: ReliableMessage) -> Tuple[Optional[ID], List[ID], List[Content]]:
+    async def _check_group_members(self, content: GroupCommand, r_msg: ReliableMessage
+                                   ) -> Tuple[Optional[ID], List[ID], List[Content]]:
         group = content.group
         assert group is not None, 'group command error: %s' % content
-        owner = self._owner(group=group)
-        members = self._members(group=group)
+        owner = await self._owner(group=group)
+        members = await self._members(group=group)
         if owner is None or len(members) == 0:
             # TODO: query group members?
             text = 'Group empty.'
@@ -219,11 +220,11 @@ class GroupCommandProcessor(HistoryCommandProcessor):
         return owner, members, errors
 
     # protected
-    def send_group_histories(self, group: ID, receiver: ID) -> bool:
-        messages = self.builder.build_group_histories(group=group)
+    async def send_group_histories(self, group: ID, receiver: ID) -> bool:
+        messages = await self.builder.build_group_histories(group=group)
         if len(messages) == 0:
             self.warning(msg='failed to build history for group: %s' % group)
             return False
         content = ForwardContent.create(messages=messages)
-        _, r_msg = self.messenger.send_content(sender=None, receiver=receiver, content=content, priority=1)
+        _, r_msg = await self.messenger.send_content(sender=None, receiver=receiver, content=content, priority=1)
         return r_msg is not None

{dimples-0.5.8 → dimples-1.0.0}/dimples/client/cpu/grp_expel.py

@@ -49,7 +49,7 @@ from .group import GroupCommandProcessor
 class ExpelCommandProcessor(GroupCommandProcessor, Logging):
 
     # Override
-    def process_content(self, content: Content, r_msg: ReliableMessage) -> List[Content]:
+    async def process_content(self, content: Content, r_msg: ReliableMessage) -> List[Content]:
         assert isinstance(content, ExpelCommand), 'expel command error: %s' % content
 
         self.warning(msg='"expel" group command is deprecated, use "reset" instead.')

{dimples-0.5.8 → dimples-1.0.0}/dimples/client/cpu/grp_invite.py

@@ -50,21 +50,21 @@ from .group import GroupCommandProcessor
 class InviteCommandProcessor(GroupCommandProcessor):
 
     # Override
-    def process_content(self, content: Content, r_msg: ReliableMessage) -> List[Content]:
+    async def process_content(self, content: Content, r_msg: ReliableMessage) -> List[Content]:
         assert isinstance(content, InviteCommand), 'invite command error: %s' % content
 
         # 0. check command
-        group, errors = self._check_expired(content=content, r_msg=r_msg)
+        group, errors = await self._check_expired(content=content, r_msg=r_msg)
         if group is None:
             # ignore expired command
             return errors
-        invite_list, errors = self._check_command_members(content=content, r_msg=r_msg)
+        invite_list, errors = await self._check_command_members(content=content, r_msg=r_msg)
         if len(invite_list) == 0:
             # command error
             return errors
 
         # 1. check group
-        trip = self._check_group_members(content=content, r_msg=r_msg)
+        trip = await self._check_group_members(content=content, r_msg=r_msg)
         owner = trip[0]
         members = trip[1]
         errors = trip[2]
@@ -72,7 +72,7 @@ class InviteCommandProcessor(GroupCommandProcessor):
             return errors
 
         sender = r_msg.sender
-        admins = self._administrators(group=group)
+        admins = await self._administrators(group=group)
         is_owner = sender == owner
         is_admin = sender in admins
         is_member = sender in members
@@ -100,9 +100,9 @@ class InviteCommandProcessor(GroupCommandProcessor):
                 # the sender cannot reset the group, means it's an ordinary member now,
                 # and if I am the owner, then send the group history commands
                 # to update the sender's memory.
-                ok = self.send_group_histories(group=group, receiver=sender)
+                ok = await self.send_group_histories(group=group, receiver=sender)
                 assert ok, 'failed to send history for group: %s => %s' % (group, sender)
-        elif not self._save_group_history(group=group, content=content, r_msg=r_msg):
+        elif not await self._save_group_history(group=group, content=content, r_msg=r_msg):
             # here try to append the 'invite' command to local storage as group history
             # it should not failed unless the command is expired
             self.error(msg='failed to save "invite" command for group: %s' % group)
@@ -110,7 +110,7 @@ class InviteCommandProcessor(GroupCommandProcessor):
             # the sender cannot reset the group, means it's invited by ordinary member,
             # and the 'invite' command was saved, now waiting for review.
             self.info(msg='"invite" command saved, waiting review now')
-        elif self._save_members(members=new_members, group=group):
+        elif await self._save_members(members=new_members, group=group):
             # FIXME: this sender has permission to reset the group,
             #        means it must be the owner or an administrator,
             #        usually it should send a 'reset' command instead;

{dimples-0.5.8 → dimples-1.0.0}/dimples/client/cpu/grp_join.py

@@ -48,22 +48,22 @@ from .group import GroupCommandProcessor
 class JoinCommandProcessor(GroupCommandProcessor):
 
     # Override
-    def process_content(self, content: Content, r_msg: ReliableMessage) -> List[Content]:
+    async def process_content(self, content: Content, r_msg: ReliableMessage) -> List[Content]:
         assert isinstance(content, JoinCommand), 'join command error: %s' % content
 
         # 0. check command
-        group, errors = self._check_expired(content=content, r_msg=r_msg)
+        group, errors = await self._check_expired(content=content, r_msg=r_msg)
         if group is None:
             # ignore expired command
             return errors
 
         # 1. check group
-        owner, members, errors = self._check_group_members(content=content, r_msg=r_msg)
+        owner, members, errors = await self._check_group_members(content=content, r_msg=r_msg)
         if owner is None or len(members) == 0:
             return errors
 
         sender = r_msg.sender
-        admins = self._administrators(group=group)
+        admins = await self._administrators(group=group)
         is_owner = sender == owner
         is_admin = sender in admins
         is_member = sender in members
@@ -80,9 +80,9 @@ class JoinCommandProcessor(GroupCommandProcessor):
                 # the sender cannot reset the group, means it's an ordinary member now,
                 # and if I am the owner, then send the group history commands
                 # to update the sender's memory.
-                ok = self.send_group_histories(group=group, receiver=sender)
+                ok = await self.send_group_histories(group=group, receiver=sender)
                 assert ok, 'failed to send history for group: %s => %s' % (group, sender)
-        elif not self._save_group_history(group=group, content=content, r_msg=r_msg):
+        elif not await self._save_group_history(group=group, content=content, r_msg=r_msg):
             # here try to append the 'join' command to local storage as group history
             # it should not failed unless the command is expired
             self.error(msg='failed to save "join" command for group: %s' % group)

{dimples-0.5.8 → dimples-1.0.0}/dimples/client/cpu/grp_query.py

@@ -48,22 +48,22 @@ from .group import GroupCommandProcessor
 class QueryCommandProcessor(GroupCommandProcessor):
 
     # Override
-    def process_content(self, content: Content, r_msg: ReliableMessage) -> List[Content]:
+    async def process_content(self, content: Content, r_msg: ReliableMessage) -> List[Content]:
         assert isinstance(content, QueryCommand), 'query command error: %s' % content
 
         # 0. check command
-        group, errors = self._check_expired(content=content, r_msg=r_msg)
+        group, errors = await self._check_expired(content=content, r_msg=r_msg)
         if group is None:
             # ignore expired command
             return errors
 
         # 1. check group
-        owner, members, errors = self._check_group_members(content=content, r_msg=r_msg)
+        owner, members, errors = await self._check_group_members(content=content, r_msg=r_msg)
         if owner is None or len(members) == 0:
             return errors
 
         sender = r_msg.sender
-        bots = self._assistants(group=group)
+        bots = await self._assistants(group=group)
         is_member = sender in members
         is_bot = sender in bots
         can_query = is_member or is_bot
@@ -83,7 +83,7 @@ class QueryCommandProcessor(GroupCommandProcessor):
         if query_time is not None:
             # check last group history time
             archivist = self.facebook.archivist
-            last_time = archivist.get_last_group_history_time(group=group)
+            last_time = await archivist.get_last_group_history_time(group=group)
             if last_time is None:
                 self.error(msg='group history error: %s' % group)
             elif not last_time.after(query_time):
@@ -98,7 +98,7 @@ class QueryCommandProcessor(GroupCommandProcessor):
                 })
 
         # 3. send newest group history commands
-        ok = self.send_group_histories(group=group, receiver=sender)
+        ok = await self.send_group_histories(group=group, receiver=sender)
         assert ok, 'failed to send history for group: %s => %s' % (group, sender)
 
         # no need to response this group command

{dimples-0.5.8 → dimples-1.0.0}/dimples/client/cpu/grp_quit.py

@@ -48,22 +48,22 @@ from .group import GroupCommandProcessor
 class QuitCommandProcessor(GroupCommandProcessor):
 
     # Override
-    def process_content(self, content: Content, r_msg: ReliableMessage) -> List[Content]:
+    async def process_content(self, content: Content, r_msg: ReliableMessage) -> List[Content]:
         assert isinstance(content, QuitCommand), 'quit command error: %s' % content
 
         # 0. check command
-        group, errors = self._check_expired(content=content, r_msg=r_msg)
+        group, errors = await self._check_expired(content=content, r_msg=r_msg)
         if group is None:
             # ignore expired command
             return errors
 
         # 1. check group
-        owner, members, errors = self._check_group_members(content=content, r_msg=r_msg)
+        owner, members, errors = await self._check_group_members(content=content, r_msg=r_msg)
         if owner is None or len(members) == 0:
             return errors
 
         sender = r_msg.sender
-        admins = self._administrators(group=group)
+        admins = await self._administrators(group=group)
         is_owner = sender == owner
         is_admin = sender in admins
         is_member = sender in members
@@ -95,11 +95,11 @@ class QuitCommandProcessor(GroupCommandProcessor):
             # the sender is not a member now,
             # shall we notify the sender that the member list was updated?
             self.warning(msg='not a member now: %s, %s' % (sender, group))
-        elif not self._save_group_history(group=group, content=content, r_msg=r_msg):
+        elif not await self._save_group_history(group=group, content=content, r_msg=r_msg):
             # here try to append the 'quit' command to local storage as group history
             # it should not failed unless the command is expired
             self.error(msg='failed to save "quit" command for group: %s' % group)
-        elif self._save_members(members=members, group=group):
+        elif await self._save_members(members=members, group=group):
             # here try to remove the sender from member list
             content['removed'] = [str(sender)]
         else:

{dimples-0.5.8 → dimples-1.0.0}/dimples/client/cpu/grp_reset.py

@@ -49,26 +49,26 @@ from .group import GroupCommandProcessor
 class ResetCommandProcessor(GroupCommandProcessor):
 
     # Override
-    def process_content(self, content: Content, r_msg: ReliableMessage) -> List[Content]:
+    async def process_content(self, content: Content, r_msg: ReliableMessage) -> List[Content]:
         assert isinstance(content, ResetCommand), 'group cmd error: %s' % content
 
         # 0. check command
-        group, errors = self._check_expired(content=content, r_msg=r_msg)
+        group, errors = await self._check_expired(content=content, r_msg=r_msg)
         if group is None:
             # ignore expired command
             return errors
-        new_members, errors = self._check_command_members(content=content, r_msg=r_msg)
+        new_members, errors = await self._check_command_members(content=content, r_msg=r_msg)
         if len(new_members) == 0:
             # command error
             return errors
 
         # 1. check group
-        owner, members, errors = self._check_group_members(content=content, r_msg=r_msg)
+        owner, members, errors = await self._check_group_members(content=content, r_msg=r_msg)
         if owner is None or len(members) == 0:
             return errors
 
         sender = r_msg.sender
-        administrators = self._administrators(group=group)
+        administrators = await self._administrators(group=group)
         is_owner = sender == owner
         is_admin = sender in administrators
 
@@ -108,14 +108,14 @@ class ResetCommandProcessor(GroupCommandProcessor):
 
         # 3. do reset
         add_list, remove_list = calculate_reset(old_members=members, new_members=new_members)
-        if not self._save_group_history(group=group, content=content, r_msg=r_msg):
+        if not await self._save_group_history(group=group, content=content, r_msg=r_msg):
             # here try to save the 'reset' command to local storage as group history
             # it should not failed unless the command is expired
             self.error(msg='failed to save "reset" command for group: %s' % group)
         elif len(add_list) == 0 and len(remove_list) == 0:
             # nothing changed
             self.warning(msg='nothing changed for group members: %d, %s' % (len(members), group))
-        elif self._save_members(members=new_members, group=group):
+        elif await self._save_members(members=new_members, group=group):
             self.info(msg='new members saved in group: %s' % group)
             if len(add_list) > 0:
                 content['added'] = ID.revert(add_list)

{dimples-0.5.8 → dimples-1.0.0}/dimples/client/cpu/grp_resign.py

@@ -48,22 +48,22 @@ from .group import GroupCommandProcessor
 class ResignCommandProcessor(GroupCommandProcessor):
 
     # Override
-    def process_content(self, content: Content, r_msg: ReliableMessage) -> List[Content]:
+    async def process_content(self, content: Content, r_msg: ReliableMessage) -> List[Content]:
         assert isinstance(content, ResignCommand), 'resign command error: %s' % content
 
         # 0. check command
-        group, errors = self._check_expired(content=content, r_msg=r_msg)
+        group, errors = await self._check_expired(content=content, r_msg=r_msg)
         if group is None:
             # ignore expired command
             return errors
 
         # 1. check group
-        owner, members, errors = self._check_group_members(content=content, r_msg=r_msg)
+        owner, members, errors = await self._check_group_members(content=content, r_msg=r_msg)
         if owner is None or len(members) == 0:
             return errors
 
         sender = r_msg.sender
-        admins = self._administrators(group=group)
+        admins = await self._administrators(group=group)
         is_owner = sender == owner
         is_admin = sender in admins
 
@@ -86,11 +86,11 @@ class ResignCommandProcessor(GroupCommandProcessor):
             # the sender is not an administrator now,
             # shall we notify the sender that the administrators list was updated?
             self.warning(msg='not an administrator now: %s, %s' % (sender, group))
-        elif not self._save_group_history(group=group, content=content, r_msg=r_msg):
+        elif not await self._save_group_history(group=group, content=content, r_msg=r_msg):
             # here try to append the 'resign' command to local storage as group history
             # it should not failed unless the command is expired
             self.error(msg='failed to save "resign" command for group: %s' % group)
-        elif self._save_administrators(administrators=admins, group=group):
+        elif await self._save_administrators(administrators=admins, group=group):
             # here try to remove the sender from admin list
             content['removed'] = [str(sender)]
         else:

{dimples-0.5.8 → dimples-1.0.0}/dimples/client/cpu/handshake.py

@@ -44,7 +44,7 @@ from ...common import HandshakeCommand
 class HandshakeCommandProcessor(BaseCommandProcessor, Logging):
 
     # Override
-    def process_content(self, content: Content, r_msg: ReliableMessage) -> List[Content]:
+    async def process_content(self, content: Content, r_msg: ReliableMessage) -> List[Content]:
         assert isinstance(content, HandshakeCommand), 'handshake command error: %s' % content
         messenger = get_client_messenger(cpu=self)
         client_session = get_client_session(messenger=messenger)
@@ -68,12 +68,12 @@ class HandshakeCommandProcessor(BaseCommandProcessor, Logging):
             # clear client session key while handshake again
             if old_sess_key is None:
                 # first handshake response with new session key,
-                messenger.handshake(session_key=new_sess_key)
+                await messenger.handshake(session_key=new_sess_key)
             elif old_sess_key == new_sess_key:
                 # duplicated handshake response?
                 # or session expired and the station ask to handshake again?
                 self.warning(msg='session key already set: %s => %s' % (old_sess_key, new_sess_key))
-                messenger.handshake(session_key=new_sess_key)
+                await messenger.handshake(session_key=new_sess_key)
             else:
                 # connection changed?
                 self.error(msg='session key from %s not match: %s => %s' % (sender, old_sess_key, new_sess_key))