Added locks for modifying and iterating handlers

Added `remove_handler` method
Made `add_handler` return a (handler, group) tuple

pyrogram/client/client.py

@@ -245,7 +245,7 @@ class Client:
         return decorator
 
     def add_handler(self, handler, group: int = 0):
-        """Use this method to register an event handler.
+        """Use this method to register an update handler.
 
         You can register multiple handlers, but at most one handler within a group
         will be used for a single event. To handle the same event more than once, register
@@ -260,6 +260,22 @@ class Client:
         """
         self.dispatcher.add_handler(handler, group)
 
+    def remove_handler(self, handler, group: int = 0):
+        """Removes a previously-added update handler.
+
+        Make sure to provide the right group that the handler was added in. You can use
+        the return value of the ``add_handler`` method, a tuple of (handler, group), and
+        pass it directly.
+
+        Args:
+            handler (``Handler``):
+                The handler to be removed.
+
+            group (``int``, optional):
+                The group identifier, defaults to 0.
+        """
+        self.dispatcher.remove_handler(handler, group)
+
     def start(self, debug: bool = False):
         """Use this method to start the Client after creating it.
         Requires no parameters.

pyrogram/client/dispatcher/dispatcher.py

@@ -50,6 +50,8 @@ class Dispatcher:
         self.updates = Queue()
         self.groups = OrderedDict()
 
+        self._handler_lock = threading.Lock()
+
     def start(self):
         for i in range(self.workers):
             self.workers_list.append(
@@ -69,36 +71,45 @@ class Dispatcher:
             i.join()
 
     def add_handler(self, handler, group: int):
-        if group not in self.groups:
+        with self._handler_lock:
-            self.groups[group] = []
+            if group not in self.groups:
-            self.groups = OrderedDict(sorted(self.groups.items()))
+                self.groups[group] = []
+                self.groups = OrderedDict(sorted(self.groups.items()))
 
-        self.groups[group].append(handler)
+            self.groups[group].append(handler)
+
+    def remove_handler(self, handler, group: int):
+        with self._handler_lock:
+            if group not in self.groups:
+                raise ValueError("Group {} does not exist. "
+                                 "Handler was not removed.".format(group))
+            self.groups[group].remove(handler)
 
     def dispatch(self, update, users: dict = None, chats: dict = None, is_raw: bool = False):
-        for group in self.groups.values():
+        with self._handler_lock:
-            for handler in group:
+            for group in self.groups.values():
-                if is_raw:
+                for handler in group:
-                    if not isinstance(handler, RawUpdateHandler):
+                    if is_raw:
-                        continue
+                        if not isinstance(handler, RawUpdateHandler):
+                            continue
 
-                    args = (self.client, update, users, chats)
+                        args = (self.client, update, users, chats)
-                else:
+                    else:
-                    if not isinstance(handler, MessageHandler):
+                        if not isinstance(handler, MessageHandler):
-                        continue
+                            continue
 
-                    message = (update.message
+                        message = (update.message
-                               or update.channel_post
+                                   or update.channel_post
-                               or update.edited_message
+                                   or update.edited_message
-                               or update.edited_channel_post)
+                                   or update.edited_channel_post)
 
-                    if not handler.check(message):
+                        if not handler.check(message):
-                        continue
+                            continue
 
-                    args = (self.client, message)
+                        args = (self.client, message)
 
-                handler.callback(*args)
+                    handler.callback(*args)
-                break
+                    break
 
     def update_worker(self):
         name = threading.current_thread().name