py-tgcalls 2.2.3__py3-none-any.whl → 2.2.5__py3-none-any.whl

{py_tgcalls-2.2.3.dist-info → py_tgcalls-2.2.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: py-tgcalls
-Version: 2.2.3
+Version: 2.2.5
 Summary: Async client API for the Telegram Calls.
 Author-email: Laky-64 <iraci.matteo@gmail.com>
 Project-URL: Homepage, https://pytgcalls.github.io/
@@ -20,7 +20,7 @@ Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: aiohttp>=3.9.3
-Requires-Dist: ntgcalls<3.0.0,>=2.0.3
+Requires-Dist: ntgcalls<3.0.0,>=2.0.5
 Requires-Dist: deprecation
 Provides-Extra: pyrogram
 Requires-Dist: pyrogram>=1.2.20; extra == "pyrogram"

{py_tgcalls-2.2.3.dist-info → py_tgcalls-2.2.5.dist-info}/RECORD

@@ -1,20 +1,21 @@
-py_tgcalls-2.2.3.dist-info/licenses/LICENSE,sha256=46mU2C5kSwOnkqkw9XQAJlhBL2JAf1_uCD8lVcXyMRg,7652
+py_tgcalls-2.2.5.dist-info/licenses/LICENSE,sha256=46mU2C5kSwOnkqkw9XQAJlhBL2JAf1_uCD8lVcXyMRg,7652
 pytgcalls/__init__.py,sha256=qbfwN7rYwIdCegMOzdcbvwazeNjDzgmowgcqLFNqKIM,308
-pytgcalls/__version__.py,sha256=imyOcBgptJng0fWUAVwWSHYVE3csDgLCIYFSbnvEA-U,22
+pytgcalls/__version__.py,sha256=btKTVVdL8jf2J-q4jm7Otknf3xzOoPGoGVBFald8zts,22
+pytgcalls/chat_lock.py,sha256=u3t0G3EQ20zn89Sn5s-GWFFX9Xmu4gYWkAgzHJOk0Mc,762
 pytgcalls/environment.py,sha256=ctCHACvG6l8SdpPewSBhOvc70kbwpv18maC0TwLvZ08,1924
 pytgcalls/exceptions.py,sha256=Rijc-8T93WEWJxNW9jncU8_M6mYZZZcs8F2bqitEIeI,3787
 pytgcalls/ffmpeg.py,sha256=CZvSyuztc-TGKbKI9_2G7CLITe1ITf315YPyprWu_Pg,8645
 pytgcalls/filters.py,sha256=8Fq_gvHHdqhIk_XwMJ9wneeZOwrvBkSOKaMJ60r3bZU,6157
 pytgcalls/list_to_cmd.py,sha256=rGJLsejbAQdDb8pctMbLnwea5NkitlfVKc3IpoGi4V4,240
 pytgcalls/mtproto_required.py,sha256=6B-31p5qH_6oekUgypV4nK3hqPS6Nr-pA8S81wjnbaY,630
-pytgcalls/mutex.py,sha256=vWqji9IAHtAc61FUTVXncx5rZ3rVf5qG_7PI4LmuYmU,733
-pytgcalls/pytgcalls.py,sha256=DxCE0--mb53vyDXLLBAwy1cPrJgLsyC9rba_h2OzR2o,1608
+pytgcalls/mutex.py,sha256=hs92-LcyIkt76cTWb-czuq1PyF89GSvxpmt3h1K8l3U,381
+pytgcalls/pytgcalls.py,sha256=SZeslmHnPjCNOiC7_3imeXstM8VQwPSN3yRDn6t1v28,1512
 pytgcalls/pytgcalls_session.py,sha256=_BGJWvf7t3mki2DhlEPjh9cypvYuSFkMSxzTsfepwUk,2719
-pytgcalls/scaffold.py,sha256=Gahln5l70FJZwo1KGqv1A7K9Vn_ozAATpADGFJuPhKA,3162
+pytgcalls/scaffold.py,sha256=1qSSTZ6Y-rXyQ65saq0yXzgeE_6iaeUjN76QQtIRb4g,3193
 pytgcalls/statictypes.py,sha256=CdlqgQNhTZ_uTE8-B8m01fJ7TlD2B42EI2QBPxDdAtA,3842
 pytgcalls/sync.py,sha256=IsOH3TD7cxUg_-zdGt12HoS8sBlXvcGayPZAoxxKM48,3396
 pytgcalls/version_manager.py,sha256=egeGgvb66zWlLTMuw2U-b0x8MfnRzMm1xAEVN87HF5c,296
-pytgcalls/wait_counter_lock.py,sha256=J-KCWUBCt7ktKQKyIseNG0RfXDVRh-h0wKhaZlf4aFs,437
+pytgcalls/wait_counter_lock.py,sha256=dA_FbmHS1wCwtGhSAEfQrA94J9OUVhPRNcaX4vK8NRA,622
 pytgcalls/ytdlp.py,sha256=MEPkVlFdbexbgqVRMt7C1YadPIER2R-4oN03osl5vq8,2473
 pytgcalls/custom_api/__init__.py,sha256=ZT8d0lc2YrDuw_YSFAXXHHMewoXGFZ-ANOBIAr0vGFQ,60
 pytgcalls/custom_api/custom_api.py,sha256=Ko3aS6psrwPmOhRPxvG0fepXt4STrA0StvINSxz4Cj8,1890
@@ -35,11 +36,11 @@ pytgcalls/methods/decorators/__init__.py,sha256=TCGaEVZnHjtOwv-3PNfaCVm0kyFhJApU
 pytgcalls/methods/decorators/on_update.py,sha256=ZTL4YcQk0N4Ru56a5WItUvkSN5SAqr6_RDZvXmZMIHs,316
 pytgcalls/methods/internal/__init__.py,sha256=fcgIxUJKT6QJD30ltnOfzKsLhzTTTklD2qxKlwCvyv0,1057
 pytgcalls/methods/internal/clear_cache.py,sha256=IbcDOGiBJbmqOnGJWkIe8c6P_Y6e0YPkui4Hg4PAZlA,334
-pytgcalls/methods/internal/clear_call.py,sha256=u84SdZb5z6lGRxf7dbrcAcf-xObGVgMsHqSmvdzoAbQ,487
-pytgcalls/methods/internal/connect_call.py,sha256=fRQYfDzpwyCXHDOTDSxPdzFu8bmeNf9hvP6c6lpNS-k,5739
+pytgcalls/methods/internal/clear_call.py,sha256=r9v2oPGrDfplxqlfKxT95JjOijm6daIpQjisOyKDBrA,542
+pytgcalls/methods/internal/connect_call.py,sha256=wgRtcY-YxGDFCJcLkSIqgc81DdoA9osQ_iEErqbBH7E,5770
 pytgcalls/methods/internal/emit_sig_data.py,sha256=ucIsknhJHB-0x7lcymXvwQ647AJQ852zH2W6MdlC3ws,216
 pytgcalls/methods/internal/handle_connection_changed.py,sha256=_1u3J6_Pjl1Gs1u_WkhG2FAUl_hxlHUiflaMkKkJDsc,866
-pytgcalls/methods/internal/handle_mtproto_updates.py,sha256=mdj8N4GXX1J650dE7OThSAVCmtB4wwByqd95P6vmbU8,7461
+pytgcalls/methods/internal/handle_mtproto_updates.py,sha256=I8l9n4t2haN3wR3cCWqynIBsilN1XazuLC9l8aS7Rhw,7812
 pytgcalls/methods/internal/handle_stream_ended.py,sha256=DllD1ZfGQbwVh-S0neocwnN-8lQtwwyrzWl9teSrZbY,561
 pytgcalls/methods/internal/handle_stream_frame.py,sha256=_FA782qlOT3tUqnySm7RBpjbgfEEzt1oEBDm-iADsbQ,1145
 pytgcalls/methods/internal/join_presentation.py,sha256=sXhmzbLWwVFi3gFl1rv0OgJsRJBrvjzRcl60N6ydNW8,2184
@@ -116,7 +117,7 @@ pytgcalls/types/stream/record_stream.py,sha256=f4VQ6MY8HtOxt7vz0hWBFmbbAIvTRHpAI
 pytgcalls/types/stream/stream_ended.py,sha256=xR_kZwFf03hA6rw_nvI7Be7GwoCKzQf_1MKaGpPDXqY,716
 pytgcalls/types/stream/stream_frames.py,sha256=028ZhNV-mN3BGqMlmxusAV1xDQpXRYCeM0WXBZhRUhA,446
 pytgcalls/types/stream/video_quality.py,sha256=eMCBFPwh5meX3UVEaozcGlwmgaujfpiTa3vBVSBBP_8,275
-py_tgcalls-2.2.3.dist-info/METADATA,sha256=F0k9s4eJBmRk4UcmwLMBwuEFx6UG-1Od7pJLf2KemCU,5280
-py_tgcalls-2.2.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-py_tgcalls-2.2.3.dist-info/top_level.txt,sha256=IUDUwn0KkcbUYZbCe9R5AUb2Ob-lmllNUGQqyeXXd8A,10
-py_tgcalls-2.2.3.dist-info/RECORD,,
+py_tgcalls-2.2.5.dist-info/METADATA,sha256=z5H1ZrBVTaaYMqaL4L__jniTrocWWAkdUcnF-FOCEPs,5280
+py_tgcalls-2.2.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+py_tgcalls-2.2.5.dist-info/top_level.txt,sha256=IUDUwn0KkcbUYZbCe9R5AUb2Ob-lmllNUGQqyeXXd8A,10
+py_tgcalls-2.2.5.dist-info/RECORD,,

pytgcalls/__version__.py

@@ -1 +1 @@
-__version__ = '2.2.3'
+__version__ = '2.2.5'

pytgcalls/chat_lock.py

@@ -0,0 +1,25 @@
+import asyncio
+from typing import Dict
+
+from .wait_counter_lock import WaitCounterLock
+
+
+class ChatLock:
+    def __init__(self):
+        self._main_lock = asyncio.Lock()
+        self._chat_lock: Dict[int, WaitCounterLock] = {}
+
+    async def _remove_callback(self, chat_id: int):
+        async with self._main_lock:
+            if not self._chat_lock[chat_id].waiters():
+                self._chat_lock.pop(chat_id, None)
+
+    async def acquire(self, chat_id: int) -> WaitCounterLock:
+        async with self._main_lock:
+            self._chat_lock[chat_id] = self._chat_lock.get(
+                chat_id,
+            ) or WaitCounterLock(
+                self._remove_callback,
+                chat_id,
+            )
+            return self._chat_lock[chat_id]

pytgcalls/methods/internal/clear_call.py

@@ -6,7 +6,8 @@ from ...scaffold import Scaffold
 
 class ClearCall(Scaffold):
     async def _clear_call(self, chat_id: int):
-        if chat_id in self._wait_connect:
+        if chat_id in self._wait_connect and \
+                chat_id not in self._p2p_configs:
             self._wait_connect[chat_id].set_exception(
                 TelegramServerError(),
             )

pytgcalls/methods/internal/connect_call.py

@@ -131,6 +131,7 @@ class ConnectCall(Scaffold):
                 if retries == 3 or chat_id > 0:
                     raise
                 self._log_retries(retries)
+                payload = None
             except Exception:
                 try:
                     await self._binding.stop(chat_id)

pytgcalls/methods/internal/handle_mtproto_updates.py

@@ -43,7 +43,8 @@ class HandleMTProtoUpdates(Scaffold):
                             ),
                         )
         if chat_id in self._wait_connect and \
-                not self._wait_connect[chat_id].done():
+                not self._wait_connect[chat_id].done() and \
+                chat_id not in self._p2p_configs:
             if isinstance(update, ChatUpdate):
                 if update.status & ChatUpdate.Status.DISCARDED_CALL:
                     self._wait_connect[chat_id].set_exception(
@@ -79,66 +80,68 @@ class HandleMTProtoUpdates(Scaffold):
             action = update.action
             chat_peer = self._cache_user_peer.get(chat_id)
             user_id = participant.user_id
-            if chat_id in self._call_sources:
-                call_sources = self._call_sources[chat_id]
-                was_camera = user_id in call_sources.camera
-                was_screen = user_id in call_sources.presentation
 
-                if was_camera != participant.video_camera:
-                    if participant.video_info:
-                        self._call_sources[chat_id].camera[
-                            user_id
-                        ] = participant.video_info.endpoint
-                        try:
-                            await self._binding.add_incoming_video(
-                                chat_id,
-                                participant.video_info.endpoint,
-                                participant.video_info.sources,
-                            )
-                        except (ConnectionNotFound, ConnectionError):
-                            pass
-                    elif user_id in self._call_sources[chat_id].camera:
-                        try:
-                            await self._binding.remove_incoming_video(
-                                chat_id,
-                                self._call_sources[
-                                    chat_id
-                                ].camera[user_id],
-                            )
-                        except (ConnectionNotFound, ConnectionError):
-                            pass
-                        self._call_sources[chat_id].camera.pop(
-                            user_id, None,
-                        )
+            async with await self._chat_lock.acquire(chat_id):
+                if chat_id in self._call_sources:
+                    call_sources = self._call_sources[chat_id]
+                    was_camera = user_id in call_sources.camera
+                    was_screen = user_id in call_sources.presentation
 
-                if was_screen != participant.screen_sharing:
-                    if participant.presentation_info:
-                        self._call_sources[chat_id].presentation[
-                            user_id
-                        ] = participant.presentation_info.endpoint
-                        try:
-                            await self._binding.add_incoming_video(
-                                chat_id,
-                                participant.presentation_info.endpoint,
-                                participant.presentation_info.sources,
+                    if was_camera != participant.video_camera:
+                        if participant.video_info:
+                            self._call_sources[chat_id].camera[
+                                user_id
+                            ] = participant.video_info.endpoint
+                            try:
+                                await self._binding.add_incoming_video(
+                                    chat_id,
+                                    participant.video_info.endpoint,
+                                    participant.video_info.sources,
+                                )
+                            except (ConnectionNotFound, ConnectionError):
+                                pass
+                        elif user_id in self._call_sources[chat_id].camera:
+                            try:
+                                await self._binding.remove_incoming_video(
+                                    chat_id,
+                                    self._call_sources[
+                                        chat_id
+                                    ].camera[user_id],
+                                )
+                            except (ConnectionNotFound, ConnectionError):
+                                pass
+                            self._call_sources[chat_id].camera.pop(
+                                user_id, None,
                             )
-                        except (ConnectionNotFound, ConnectionError):
-                            pass
-                    elif user_id in self._call_sources[
-                        chat_id
-                    ].presentation:
-                        try:
-                            await self._binding.remove_incoming_video(
-                                chat_id,
-                                self._call_sources[
-                                    chat_id
-                                ].presentation[user_id],
+
+                    if was_screen != participant.screen_sharing:
+                        if participant.presentation_info:
+                            self._call_sources[chat_id].presentation[
+                                user_id
+                            ] = participant.presentation_info.endpoint
+                            try:
+                                await self._binding.add_incoming_video(
+                                    chat_id,
+                                    participant.presentation_info.endpoint,
+                                    participant.presentation_info.sources,
+                                )
+                            except (ConnectionNotFound, ConnectionError):
+                                pass
+                        elif user_id in self._call_sources[
+                            chat_id
+                        ].presentation:
+                            try:
+                                await self._binding.remove_incoming_video(
+                                    chat_id,
+                                    self._call_sources[
+                                        chat_id
+                                    ].presentation[user_id],
+                                )
+                            except (ConnectionNotFound, ConnectionError):
+                                pass
+                            self._call_sources[chat_id].presentation.pop(
+                                user_id, None,
                             )
-                        except (ConnectionNotFound, ConnectionError):
-                            pass
-                        self._call_sources[chat_id].presentation.pop(
-                            user_id, None,
-                        )
 
             if chat_peer:
                 is_self = BridgedClient.chat_id(

pytgcalls/mutex.py

@@ -1,7 +1,5 @@
 from functools import wraps
 
-from .wait_counter_lock import WaitCounterLock
-
 
 def mutex(func):
     @wraps(func)
@@ -10,15 +8,6 @@ def mutex(func):
         chat_id = await self.resolve_chat_id(
             args[1] if len(args) > 1 else kwargs['chat_id'],
         )
-        async with self._lock:
-            self._calls_lock[chat_id] = self._calls_lock.get(
-                chat_id,
-            ) or WaitCounterLock()
-        async with self._calls_lock[chat_id]:
-            result = await func(*args, **kwargs)
-
-        async with self._lock:
-            if not self._calls_lock[chat_id].waiters():
-                self._calls_lock.pop(chat_id, None)
-        return result
+        async with await self._chat_lock.acquire(chat_id):
+            return await func(*args, **kwargs)
     return async_wrapper

pytgcalls/pytgcalls.py

@@ -2,17 +2,16 @@ import asyncio
 import os
 from concurrent.futures import ThreadPoolExecutor
 from typing import Any
-from typing import Dict
 
 from ntgcalls import NTgCalls
 
+from .chat_lock import ChatLock
 from .environment import Environment
 from .methods import Methods
 from .mtproto import MtProtoClient
 from .scaffold import Scaffold
 from .statictypes import statictypes
 from .types import Cache
-from .wait_counter_lock import WaitCounterLock
 
 
 class PyTgCalls(Methods, Scaffold):
@@ -43,8 +42,7 @@ class PyTgCalls(Methods, Scaffold):
         self._binding = NTgCalls()
         self.loop = asyncio.get_event_loop()
         self.workers = workers
-        self._lock = asyncio.Lock()
-        self._calls_lock: Dict[str, WaitCounterLock] = {}
+        self._chat_lock = ChatLock()
         self.executor = ThreadPoolExecutor(
             self.workers,
             thread_name_prefix='Handler',

pytgcalls/scaffold.py

@@ -40,6 +40,7 @@ class Scaffold(HandlersHolder):
         self._wait_connect = dict()
         self._presentations = set()
         self._pending_connections = dict()
+        self._chat_lock = None
 
     def _handle_mtproto(self):
         pass

pytgcalls/wait_counter_lock.py

@@ -1,10 +1,13 @@
 import asyncio
+from typing import Callable
 
 
 class WaitCounterLock:
-    def __init__(self):
+    def __init__(self, remove_callback: Callable, *args):
         self._lock = asyncio.Lock()
         self._waiters = 0
+        self._remove_callback = remove_callback
+        self._args = args
 
     def waiters(self):
         return self._waiters
@@ -18,3 +21,4 @@ class WaitCounterLock:
     async def __aexit__(self, exc_type, exc, tb):
         if self._lock.locked():
             self._lock.release()
+        await self._remove_callback(*self._args)