py-tgcalls 2.1.1__py3-none-any.whl → 2.1.2b2__py3-none-any.whl

{py_tgcalls-2.1.1.dist-info → py_tgcalls-2.1.2b2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: py-tgcalls
-Version: 2.1.1
+Version: 2.1.2b2
 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<1.4.0,>=1.3.2
+Requires-Dist: ntgcalls<1.4.0,>=1.3.5b3
 Requires-Dist: deprecation
 Provides-Extra: pyrogram
 Requires-Dist: pyrogram>=1.2.20; extra == "pyrogram"

{py_tgcalls-2.1.1.dist-info → py_tgcalls-2.1.2b2.dist-info}/RECORD

@@ -1,15 +1,15 @@
-py_tgcalls-2.1.1.dist-info/licenses/LICENSE,sha256=46mU2C5kSwOnkqkw9XQAJlhBL2JAf1_uCD8lVcXyMRg,7652
+py_tgcalls-2.1.2b2.dist-info/licenses/LICENSE,sha256=46mU2C5kSwOnkqkw9XQAJlhBL2JAf1_uCD8lVcXyMRg,7652
 pytgcalls/__init__.py,sha256=qbfwN7rYwIdCegMOzdcbvwazeNjDzgmowgcqLFNqKIM,308
-pytgcalls/__version__.py,sha256=Aht2295j8FswZ-nPYofCYr3fBZ6Uyf0thTfl5Oc2mWA,22
+pytgcalls/__version__.py,sha256=FprLafBuvz-hzBW23aNWsGkjU3pSVyK0rnV3nOorhlc,24
 pytgcalls/environment.py,sha256=ctCHACvG6l8SdpPewSBhOvc70kbwpv18maC0TwLvZ08,1924
-pytgcalls/exceptions.py,sha256=CoYSQAzRWIkyJVpHw8Q4zUhM9Sh3uwm6-1AB5ks_2iU,3924
+pytgcalls/exceptions.py,sha256=Rijc-8T93WEWJxNW9jncU8_M6mYZZZcs8F2bqitEIeI,3787
 pytgcalls/ffmpeg.py,sha256=tm6DBxyNfPh3h3an-b2s9x1UyX-cvkCdov9prlXxVZY,8649
 pytgcalls/filters.py,sha256=qTFDlt-23xnMh_Ug2WmmOUf13JPX6_yacrv7c3F9Pp0,6125
 pytgcalls/mtproto_required.py,sha256=6B-31p5qH_6oekUgypV4nK3hqPS6Nr-pA8S81wjnbaY,630
 pytgcalls/mutex.py,sha256=6hOwGnUTNUJliJ1GGhk47D0A3KEn8eVd-kjZq_1DdZY,670
 pytgcalls/pytgcalls.py,sha256=DxCE0--mb53vyDXLLBAwy1cPrJgLsyC9rba_h2OzR2o,1608
 pytgcalls/pytgcalls_session.py,sha256=_BGJWvf7t3mki2DhlEPjh9cypvYuSFkMSxzTsfepwUk,2719
-pytgcalls/scaffold.py,sha256=SwePuT9V8LdOFy0KRlAnRSbsB2zeGQ4fs9ilrq7HZYI,1353
+pytgcalls/scaffold.py,sha256=Gahln5l70FJZwo1KGqv1A7K9Vn_ozAATpADGFJuPhKA,3162
 pytgcalls/statictypes.py,sha256=CdlqgQNhTZ_uTE8-B8m01fJ7TlD2B42EI2QBPxDdAtA,3842
 pytgcalls/sync.py,sha256=IsOH3TD7cxUg_-zdGt12HoS8sBlXvcGayPZAoxxKM48,3396
 pytgcalls/version_manager.py,sha256=egeGgvb66zWlLTMuw2U-b0x8MfnRzMm1xAEVN87HF5c,296
@@ -25,44 +25,57 @@ pytgcalls/media_devices/input_device.py,sha256=-Z5hjhdc1Y68mZQpVW-QgMePKGe_c5zJc
 pytgcalls/media_devices/media_devices.py,sha256=ZgRF8j4jCJNWrW1HCUUWZMcZ9V7LOcvm_jJmy8g7ieQ,1333
 pytgcalls/media_devices/screen_device.py,sha256=B1MCpcqW-QXKcVafNdPQfd2Es6-ejkX2NdwbfuYmhv4,201
 pytgcalls/media_devices/speaker_device.py,sha256=39aAE2oEvlhRiUwHlIJCrSUPWIy-8J9_oq1TmCq5IjA,200
-pytgcalls/methods/__init__.py,sha256=hk1blAT5u_Isemdrg0nqInLsdRzTTZnak5NdAfkBPAk,217
+pytgcalls/methods/__init__.py,sha256=KKnG3uI_3oKKBByQ96kHJiabjxk2J6YLs4HDfOKvQ0A,262
 pytgcalls/methods/calls/__init__.py,sha256=xg4DZZClEnxwaj-DAq3e8gSR-g-MiYBdUEBth64lSXA,214
 pytgcalls/methods/calls/change_volume_call.py,sha256=xMUszg44Gs1RgTXGCwcWEESnwu3XVkW8Kx9HGLDGSEo,842
 pytgcalls/methods/calls/get_participants.py,sha256=HDEMwZwNZM7KSb76P5XVH46qNONvBEVg4x_e-rgJscI,716
 pytgcalls/methods/calls/leave_call.py,sha256=Q7v0xT_CjbMIUBrugtvKbZqbSgmw5laMQYVhrMcaD1U,1475
 pytgcalls/methods/decorators/__init__.py,sha256=TCGaEVZnHjtOwv-3PNfaCVm0kyFhJApUPUNntt6MwyM,78
 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=qgG-oubmdtnefnXSiHSPHyBTyXypiLDC7G8l3FzjNw8,236
+pytgcalls/methods/internal/clear_call.py,sha256=yElvn3i6_j14Q7n9kcLSl-muYAGcaIZaEFHdp6MrN0g,549
+pytgcalls/methods/internal/connect_call.py,sha256=2DRmsILPyGNxV2880tVsQ2XUwd89iSIqVWHl5AkgEaE,5393
+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=Ev2Jake6Z_SrBodnjO5N16YiYaEY3Ti4tkU1pKOsJVM,7747
+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=dLB2kolIIm2KQH8yBQbEPJi_y1_cVLWpE52_Rwjn_KE,2178
+pytgcalls/methods/internal/log_retries.py,sha256=6nD9J3350t82I0PKzK1pVx3ZaCBHATReiXYMs3PuVhQ,342
+pytgcalls/methods/internal/request_broadcast_part.py,sha256=oh-SqMCuQQErpF9Gd8ubPDoZeaz4bKw0dK--JrjXK9s,1313
+pytgcalls/methods/internal/request_broadcast_timestamp.py,sha256=yEEmtyLR-EsEO1aXMcRAD34LRH63gY6ZQvn_Sw9quLk,642
+pytgcalls/methods/internal/switch_connection.py,sha256=Yyh7vJLgoR_jZNpUbOKTiXSt2KkpKPmyr20heSJncn0,1221
+pytgcalls/methods/internal/update_sources.py,sha256=ISF6u3rk4IcVrPOEOB-uZUDfnwUp2_y1_2g9GboXpWM,1562
+pytgcalls/methods/internal/update_status.py,sha256=6zH7oMM_qPE-88mdC5CBhT07gPvayBrmMAvDWwCDFtc,608
 pytgcalls/methods/stream/__init__.py,sha256=mAcOih0-NT6T_Gspej6mySpJNPuEe46sUwgKV3vSvYM,336
 pytgcalls/methods/stream/mute.py,sha256=ZrZS_EeNUeUxb6UgbdhwXUdRX826u-qSjH5a6sg7LsE,557
 pytgcalls/methods/stream/pause.py,sha256=-kNvWQuv5VlssNcL-M6rkT5TKFmXlbOzJrDny95qsUc,560
-pytgcalls/methods/stream/play.py,sha256=vMmGgqhbHU_N6khfAa3ztil7wFuz_JmhjYTmMGV5CyM,7666
-pytgcalls/methods/stream/record.py,sha256=p9td2tZ4-QMpY8I8LDc1PrFVN3g-vlDINF5I7CmLsvA,1567
+pytgcalls/methods/stream/play.py,sha256=fTZS-XHF50Wo9BNOZ373n4YhGqRuu7uZR-GJEACjqYY,2935
+pytgcalls/methods/stream/record.py,sha256=geYSVtSbp0yRIR1Nmj-L1s-6nqQAh0x0IcA1OuFvuyA,1306
 pytgcalls/methods/stream/resume.py,sha256=AUHU3AtpXO2rtp2V1EKSC_KAWTk2KHMiHaqHluYy31M,563
 pytgcalls/methods/stream/send_frame.py,sha256=Kj9R8OqUM-g7pt-FiWP-US7sCFkH5ciPr9S8v-WPtLg,1062
 pytgcalls/methods/stream/time.py,sha256=65Hc5pQaN6z6nxgwT9Zxgsnl_UosvMkcICqE2hisNWA,659
 pytgcalls/methods/stream/unmute.py,sha256=wgWpxakIPLzZCgojC-cIkDSnF9LtDZwdTsBOctdHibQ,563
-pytgcalls/methods/utilities/__init__.py,sha256=HHAkTQEX_23uwo1fxnCIoE2rLBm7fKSQa52SwBLudTI,522
+pytgcalls/methods/utilities/__init__.py,sha256=JcKwqNo6fFXXfuab94fNEraKF1P9fnSSgr0WQDRjF2w,339
 pytgcalls/methods/utilities/cache_peer.py,sha256=Ylt0wCCJOoNKf1wZEXjfE8aBZKUIIgdRUFOMTGA5DfE,140
 pytgcalls/methods/utilities/call_holder.py,sha256=MhIbwCG6DROd9_bHGa6aqu-rB0y4sngzPBj82zLtAXU,1068
 pytgcalls/methods/utilities/compose.py,sha256=Nzdv8orMmka5NIBZ1SW1nsqXRzArZl4m6FdZU7syaR4,334
 pytgcalls/methods/utilities/cpu_usage.py,sha256=Mbga4MFCIwuh7WC8sqBbv1Pa6ALcp5AIDyfYMH_Bix4,162
 pytgcalls/methods/utilities/idle.py,sha256=MDdzHTv1ws2yBhsvhBUnssGdghkZ2KwR0HUCPOwV38o,814
-pytgcalls/methods/utilities/join_presentation.py,sha256=gvxmFVzf6xsQZ4bPOz5wK8oZ0up1QD0DB2HpO5JcpGw,1671
-pytgcalls/methods/utilities/log_retries.py,sha256=6nD9J3350t82I0PKzK1pVx3ZaCBHATReiXYMs3PuVhQ,342
 pytgcalls/methods/utilities/ping.py,sha256=hhIMSHk2BzMB-IKpwLdZFVrsEvGm2ftJwKLs1k4anh8,244
 pytgcalls/methods/utilities/resolve_chat_id.py,sha256=92x2LHbUlnJMm-kS3fXOYmzYpY2TZbqtQD2rw3eBXDY,382
 pytgcalls/methods/utilities/run.py,sha256=cnYQd2xB5Cr_WS0Q2cXJZPGiN6JOCULzj1r4xXVyrlg,152
-pytgcalls/methods/utilities/start.py,sha256=F6Jkq1R8dRm5yRAPGETbgL9A2QORc66nFYc-snoDiCk,14736
+pytgcalls/methods/utilities/start.py,sha256=mn0kQZhTUuc-9CCJDbFIVsEtJ8kfnfZOGbVC505qVRM,3232
 pytgcalls/methods/utilities/stream_params.py,sha256=fOSloo1A7WTxaZEtOiPXjdexMeoJjq8CZtfHuIFX7Ns,3325
-pytgcalls/methods/utilities/update_sources.py,sha256=ISF6u3rk4IcVrPOEOB-uZUDfnwUp2_y1_2g9GboXpWM,1562
 pytgcalls/mtproto/__init__.py,sha256=X4zvzFG7km7qHyE0fdvA550WcOVO_xl_p__gvIfDGmw,130
-pytgcalls/mtproto/bridged_client.py,sha256=oXPEv7pFAgW1PKq__4HS0f-OuNUzE-D3tzmuo2FmRSs,5943
-pytgcalls/mtproto/client_cache.py,sha256=Mt0827e_T8DXJHOTkXhkIQUT9EUBWjoLcFcXP1gBnZY,5973
-pytgcalls/mtproto/hydrogram_client.py,sha256=xWcdtknbkvJm0bZWzMDEpkRURus-aTPD8bCCoAS4A9A,23626
-pytgcalls/mtproto/mtproto_client.py,sha256=YOCJlTxDB210R7xbdp6cHBEGy5-dCtU3SBDTSeWrrRM,7674
-pytgcalls/mtproto/pyrogram_client.py,sha256=WYwhm4ESeWKz9BgK36951M-7D3XBYHbiCXYyNBRfIP4,23807
-pytgcalls/mtproto/telethon_client.py,sha256=j7IwOz3cgUmLIfppSWPt8FTV8Qbv98MK5qWE1vpPvgM,23037
-pytgcalls/types/__init__.py,sha256=iXAzXG5WgbICLQV1JT_F4QtOqKWC8X3334-MOv2SXW4,1127
+pytgcalls/mtproto/bridged_client.py,sha256=svXufZkCj7WM9XOWkuk5oJVQxgL1Bg_8rz7w_ZKWlQg,6451
+pytgcalls/mtproto/client_cache.py,sha256=fpmZhRUGD3G2t2LjEK0z4OPLmWVhJQZUvDW6bgr6StI,5907
+pytgcalls/mtproto/hydrogram_client.py,sha256=pSEtHowL833-vD5ppm78eBe7_Ik0pumChbDTMLsyP5Y,25553
+pytgcalls/mtproto/mtproto_client.py,sha256=95A13HsNJfpNslsY_gWiqYXj_Vvo-pl3rVrsJGxftgg,8517
+pytgcalls/mtproto/pyrogram_client.py,sha256=linvRHAxZCb4PenJEN9-OtjQm7Go9OONyDotZcMydNY,25710
+pytgcalls/mtproto/telethon_client.py,sha256=iDMAAKvvFVigOrLPusG9ytiswxM2UCp4KZZuwtT-vKo,24987
+pytgcalls/types/__init__.py,sha256=GlgBBXAwbNopXSeTTmiXktrEJhhN_rMBtuAllTBbN3k,1189
 pytgcalls/types/browsers.py,sha256=47Kr5q96n4Q4WvVhA6IUlS2egEcA9GRLlDeFcQYyc9M,9545
 pytgcalls/types/cache.py,sha256=FfsOcmYnsBGPlJoTPIXXYcUSpGE3rhx6cjIH77hyUL0,1059
 pytgcalls/types/dict.py,sha256=lAo9hu4VlVJa9S7P8Y81BYmKtvz0rH7hwpGcH3ynHUw,78
@@ -72,13 +85,14 @@ pytgcalls/types/participant_list.py,sha256=LmGjU63MK1v3SS2_4xNbk04OOjmukNdAXYLRn
 pytgcalls/types/py_object.py,sha256=__GNXgffGK4jhdF4QPqIknd0k2myObJf_7fW3pNGpbU,836
 pytgcalls/types/update.py,sha256=wPCzWLhrsScZ3ksRTyt8IuDaaG5YI-ItG_Yw-OqzK2Y,157
 pytgcalls/types/user_agent.py,sha256=sSfeGqUe0v0wqBgdVszNFK0iOC_0Tdyto9CglBXlY4U,1086
-pytgcalls/types/calls/__init__.py,sha256=f0zMKm_mwvNsDRPgs8IopuCEefU3V0-kuHAFsTMBoAc,403
+pytgcalls/types/calls/__init__.py,sha256=lgFG89_NGhWHOQqhfw3adPaQZMzsMKI1f-MyZW3TBBU,478
 pytgcalls/types/calls/call.py,sha256=n7LW7FRNT2qJzbYC3D312judOlVUuocQ1eW9l9scGCo,546
 pytgcalls/types/calls/call_config.py,sha256=b6P43YTGF2t7E2CyD1mSYPJDUBvYYeHoxB3hSbTVyOY,120
 pytgcalls/types/calls/call_data.py,sha256=-qPj2QhWv32Xs7LyFQY4hiWDqJ21B8VBvdzREK8bDvY,544
 pytgcalls/types/calls/call_protocol.py,sha256=OVIQs1VgdY-DWbZbNr41hjLA4pGQvHx8Rgom1_NhJxQ,408
 pytgcalls/types/calls/call_sources.py,sha256=sBhumPgEaN8uAKjBwb1Zf_Ag0qrceti2mURXqMhBusg,107
 pytgcalls/types/calls/group_call_config.py,sha256=auKH-hZJWj8PhTkyeQ_VK2z9NpNvNC7Scl_IhEUMnQM,353
+pytgcalls/types/calls/pending_connection.py,sha256=qRRmutInj70rtzbThM7CNznFhEPqTNZQc6LUWnqpZ9I,432
 pytgcalls/types/calls/raw_call_update.py,sha256=hpNw6HrTW8Z36Lh2HinS-wzprryRtsIxyIFbIfjGgeI,795
 pytgcalls/types/chats/__init__.py,sha256=v8pUp_vbr2kQpyHtAQc80N-YqzmXHe9SbllUsa6njkU,261
 pytgcalls/types/chats/chat_update.py,sha256=lzrqNDPv4a_yXpKIfUnhocXqZyIy8XgZladOQTYrrYA,730
@@ -101,7 +115,7 @@ pytgcalls/types/stream/record_stream.py,sha256=RWeD9U-sqUmb_PuZQxYnExZyoibepU_8o
 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=HBfWq005kh-D19MaVE9VzVdnODzrXf4IJUimCfslfiU,231
-py_tgcalls-2.1.1.dist-info/METADATA,sha256=TrhFZ_S_GpSn7T2mGGjfYS5eIodswvwZJm60AYobo74,5280
-py_tgcalls-2.1.1.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-py_tgcalls-2.1.1.dist-info/top_level.txt,sha256=IUDUwn0KkcbUYZbCe9R5AUb2Ob-lmllNUGQqyeXXd8A,10
-py_tgcalls-2.1.1.dist-info/RECORD,,
+py_tgcalls-2.1.2b2.dist-info/METADATA,sha256=GxtcdfoQ7YJZWo5rwwvc1IDUdK4dR7teugIeXM80NLQ,5284
+py_tgcalls-2.1.2b2.dist-info/WHEEL,sha256=wXxTzcEDnjrTwFYjLPcsW_7_XihufBwmpiBeiXNBGEA,91
+py_tgcalls-2.1.2b2.dist-info/top_level.txt,sha256=IUDUwn0KkcbUYZbCe9R5AUb2Ob-lmllNUGQqyeXXd8A,10
+py_tgcalls-2.1.2b2.dist-info/RECORD,,

{py_tgcalls-2.1.1.dist-info → py_tgcalls-2.1.2b2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (78.1.0)
+Generator: setuptools (80.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

pytgcalls/__version__.py

@@ -1 +1 @@
-__version__ = '2.1.1'
+__version__ = '2.1.2b2'

pytgcalls/exceptions.py

@@ -157,13 +157,6 @@ class YtDlpError(Exception):
         )
 
 
-class UnMuteNeeded(Exception):
-    def __init__(self):
-        super().__init__(
-            'Needed to unmute the userbot',
-        )
-
-
 class MTProtoClientNotConnected(Exception):
     def __init__(self):
         super().__init__(

pytgcalls/methods/__init__.py

@@ -1,5 +1,6 @@
 from .calls import Calls
 from .decorators import Decorators
+from .internal import Internal
 from .stream import StreamMethods
 from .utilities import Utilities
 
@@ -7,6 +8,7 @@ from .utilities import Utilities
 class Methods(
     Calls,
     Decorators,
+    Internal,
     StreamMethods,
     Utilities,
 ):

pytgcalls/methods/internal/__init__.py

@@ -0,0 +1,35 @@
+from .clear_cache import ClearCache
+from .clear_call import ClearCall
+from .connect_call import ConnectCall
+from .emit_sig_data import EmitSigData
+from .handle_connection_changed import HandleConnectionChanged
+from .handle_mtproto_updates import HandleMTProtoUpdates
+from .handle_stream_ended import HandleStreamEnded
+from .handle_stream_frame import HandleStreamFrame
+from .join_presentation import JoinPresentation
+from .log_retries import LogRetries
+from .request_broadcast_part import RequestBroadcastPart
+from .request_broadcast_timestamp import RequestBroadcastTimestamp
+from .switch_connection import SwitchConnection
+from .update_sources import UpdateSources
+from .update_status import UpdateStatus
+
+
+class Internal(
+    ClearCache,
+    ClearCall,
+    ConnectCall,
+    EmitSigData,
+    HandleConnectionChanged,
+    HandleMTProtoUpdates,
+    HandleStreamEnded,
+    HandleStreamFrame,
+    JoinPresentation,
+    LogRetries,
+    RequestBroadcastPart,
+    RequestBroadcastTimestamp,
+    SwitchConnection,
+    UpdateSources,
+    UpdateStatus,
+):
+    pass

pytgcalls/methods/internal/clear_cache.py

@@ -0,0 +1,8 @@
+from ...scaffold import Scaffold
+
+
+class ClearCache(Scaffold):
+    def _clear_cache(self, chat_id: int):
+        self._p2p_configs.pop(chat_id, None)
+        self._cache_user_peer.pop(chat_id)
+        self._need_unmute.discard(chat_id)

pytgcalls/methods/internal/clear_call.py

@@ -0,0 +1,20 @@
+from ntgcalls import ConnectionNotFound
+from ntgcalls import TelegramServerError
+
+from ...scaffold import Scaffold
+
+
+class ClearCall(Scaffold):
+    async def _clear_call(self, chat_id: int):
+        res = False
+        if chat_id in self._wait_connect:
+            self._wait_connect[chat_id].set_exception(
+                TelegramServerError(),
+            )
+        try:
+            await self._binding.stop(chat_id)
+            res = True
+        except ConnectionNotFound:
+            pass
+        self._clear_cache(chat_id)
+        return res

pytgcalls/methods/internal/connect_call.py

@@ -0,0 +1,133 @@
+import asyncio
+from typing import Optional
+from typing import Union
+
+from ntgcalls import ConnectionMode
+from ntgcalls import ConnectionNotFound
+from ntgcalls import MediaDescription
+from ntgcalls import TelegramServerError
+
+from ...exceptions import TimedOutAnswer
+from ...scaffold import Scaffold
+from ...types import CallConfig
+from ...types import CallData
+from ...types import GroupCallConfig
+from ...types import PendingConnection
+from ...types import RawCallUpdate
+
+
+class ConnectCall(Scaffold):
+    async def _connect_call(
+        self,
+        chat_id: int,
+        media_description: MediaDescription,
+        config: Union[CallConfig, GroupCallConfig],
+        payload: Optional[str],
+    ):
+        for retries in range(4):
+            try:
+                self._wait_connect[chat_id] = self.loop.create_future()
+                if isinstance(config, GroupCallConfig):
+                    if not payload:
+                        payload = await self._binding.create_call(
+                            chat_id,
+                            media_description,
+                        )
+                    result_params = await self._app.join_group_call(
+                        chat_id,
+                        payload,
+                        config.invite_hash,
+                        media_description.camera is None and
+                        media_description.screen is None,
+                        self._cache_user_peer.get(chat_id),
+                    )
+                    await self._binding.connect(
+                        chat_id,
+                        result_params,
+                        False,
+                    )
+                    connection_mode = await self._binding.get_connection_mode(
+                        chat_id,
+                    )
+                    if connection_mode == ConnectionMode.STREAM and payload:
+                        self._pending_connections[chat_id] = PendingConnection(
+                            media_description,
+                            config,
+                            payload,
+                            False,
+                        )
+                else:
+                    data = self._p2p_configs.setdefault(
+                        chat_id,
+                        CallData(await self._app.get_dhc(), self.loop),
+                    )
+                    await self._binding.create_p2p_call(
+                        chat_id,
+                        media_description,
+                    )
+                    data.g_a_or_b = await self._binding.init_exchange(
+                        chat_id,
+                        data.dh_config,
+                        data.g_a_or_b,
+                    )
+                    if not data.outgoing:
+                        await self._app.accept_call(
+                            chat_id,
+                            data.g_a_or_b,
+                            self._binding.get_protocol(),
+                        )
+                    else:
+                        await self._app.request_call(
+                            chat_id,
+                            data.g_a_or_b,
+                            self._binding.get_protocol(),
+                            media_description.camera is not None or
+                            media_description.screen is not None,
+                        )
+
+                    try:
+                        result: RawCallUpdate = await asyncio.wait_for(
+                            data.wait_data,
+                            timeout=config.timeout,
+                        )
+                        auth_params = await self._binding.exchange_keys(
+                            chat_id,
+                            result.g_a_or_b,
+                            result.fingerprint,
+                        )
+                        if result.status & RawCallUpdate.Type.ACCEPTED:
+                            result.protocol = await self._app.confirm_call(
+                                chat_id,
+                                auth_params.g_a_or_b,
+                                auth_params.key_fingerprint,
+                                self._binding.get_protocol(),
+                            )
+                        await self._binding.connect_p2p(
+                            chat_id,
+                            result.protocol.rtc_servers,
+                            result.protocol.library_versions,
+                            result.protocol.p2p_allowed,
+                        )
+                    except asyncio.TimeoutError:
+                        try:
+                            await self._binding.stop(chat_id)
+                        except ConnectionNotFound:
+                            pass
+                        await self._app.discard_call(chat_id, True)
+                        raise TimedOutAnswer()
+                    finally:
+                        self._p2p_configs.pop(chat_id, None)
+                await self._wait_connect[chat_id]
+                break
+            except TelegramServerError:
+                if retries == 3 or chat_id > 0:
+                    raise
+                self._log_retries(retries)
+            except Exception:
+                try:
+                    await self._binding.stop(chat_id)
+                except ConnectionNotFound:
+                    pass
+                raise
+            finally:
+                self._wait_connect.pop(chat_id, None)

pytgcalls/methods/internal/emit_sig_data.py

@@ -0,0 +1,9 @@
+from ...scaffold import Scaffold
+
+
+class EmitSigData(Scaffold):
+    async def _emit_sig_data(self, chat_id: int, data: bytes):
+        await self._app.send_signaling(
+            chat_id,
+            data,
+        )

pytgcalls/methods/internal/handle_connection_changed.py

@@ -0,0 +1,27 @@
+from ntgcalls import ConnectionState
+from ntgcalls import NetworkInfo
+from ntgcalls import TelegramServerError
+
+from ...scaffold import Scaffold
+
+
+class HandleConnectionChanged(Scaffold):
+    async def _handle_connection_changed(
+        self,
+        chat_id: int,
+        net_state: NetworkInfo,
+    ):
+        state = net_state.state
+        if state == ConnectionState.CONNECTING:
+            return
+        if chat_id in self._wait_connect:
+            if state == ConnectionState.CONNECTED:
+                self._wait_connect[chat_id].set_result(None)
+            else:
+                self._wait_connect[chat_id].set_exception(
+                    TelegramServerError(),
+                )
+        elif state != ConnectionState.CONNECTED:
+            if chat_id > 0:
+                await self._app.discard_call(chat_id)
+            self._clear_cache(chat_id)

pytgcalls/methods/internal/handle_mtproto_updates.py

@@ -0,0 +1,175 @@
+from ntgcalls import ConnectionError
+from ntgcalls import ConnectionNotFound
+
+from ...exceptions import CallBusy
+from ...exceptions import CallDeclined
+from ...exceptions import CallDiscarded
+from ...mtproto import BridgedClient
+from ...scaffold import Scaffold
+from ...types import CallData
+from ...types import ChatUpdate
+from ...types import GroupCallParticipant
+from ...types import RawCallUpdate
+from ...types import Update
+from ...types import UpdatedGroupCallParticipant
+
+
+class HandleMTProtoUpdates(Scaffold):
+    async def _handle_mtproto_updates(self, update: Update):
+        chat_id = update.chat_id
+        if update.chat_id in self._p2p_configs:
+            p2p_config = self._p2p_configs[chat_id]
+            if not p2p_config.wait_data.done():
+                if isinstance(update, RawCallUpdate):
+                    if update.status & RawCallUpdate.Type.UPDATED_CALL:
+                        p2p_config.wait_data.set_result(
+                            update,
+                        )
+                if isinstance(update, ChatUpdate) and \
+                        p2p_config.outgoing:
+                    if update.status & ChatUpdate.Status.DISCARDED_CALL:
+                        self._wait_connect.pop(chat_id, None)
+                        p2p_config.wait_data.set_exception(
+                            CallBusy(
+                                chat_id,
+                            ) if update.status &
+                            ChatUpdate.Status.BUSY_CALL else
+                            CallDeclined(
+                                chat_id,
+                            ),
+                        )
+        if chat_id in self._wait_connect and \
+                not self._wait_connect[chat_id].done():
+            if isinstance(update, ChatUpdate):
+                if update.status & ChatUpdate.Status.DISCARDED_CALL:
+                    self._wait_connect[chat_id].set_exception(
+                        CallDiscarded(
+                            chat_id,
+                        ),
+                    )
+        if isinstance(update, RawCallUpdate):
+            if update.status & RawCallUpdate.Type.REQUESTED:
+                self._p2p_configs[chat_id] = CallData(
+                    await self._app.get_dhc(),
+                    self.loop,
+                    update.g_a_or_b,
+                )
+                update = ChatUpdate(
+                    chat_id,
+                    ChatUpdate.Status.INCOMING_CALL,
+                )
+        if isinstance(update, RawCallUpdate):
+            if update.status & RawCallUpdate.Type.SIGNALING_DATA:
+                try:
+                    await self._binding.send_signaling(
+                        update.chat_id,
+                        update.signaling_data,
+                    )
+                except (ConnectionNotFound, ConnectionError):
+                    pass
+        if isinstance(update, ChatUpdate):
+            if update.status & ChatUpdate.Status.LEFT_CALL:
+                await self._clear_call(chat_id)
+        if isinstance(update, UpdatedGroupCallParticipant):
+            participant = update.participant
+            action = participant.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,
+                        )
+
+                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,
+                        )
+
+            if chat_peer:
+                is_self = BridgedClient.chat_id(
+                    chat_peer,
+                ) == participant.user_id if chat_peer else False
+                if is_self:
+                    if action == GroupCallParticipant.Action.LEFT:
+                        if await self._clear_call(chat_id):
+                            await self._propagate(
+                                ChatUpdate(
+                                    chat_id,
+                                    ChatUpdate.Status.KICKED,
+                                ),
+                                self,
+                            )
+                    if (
+                            chat_id in self._need_unmute and
+                            action == GroupCallParticipant.Action.UPDATED and
+                            not participant.muted_by_admin
+                    ):
+                        await self._update_status(
+                            chat_id,
+                            await self._binding.get_state(chat_id),
+                        )
+                        await self._switch_connection(chat_id)
+
+                    if (
+                            participant.muted_by_admin and
+                            action != GroupCallParticipant.Action.LEFT
+                    ):
+                        self._need_unmute.add(chat_id)
+                    else:
+                        self._need_unmute.discard(chat_id)
+        if not isinstance(update, RawCallUpdate):
+            await self._propagate(
+                update,
+                self,
+            )

pytgcalls/methods/internal/handle_stream_ended.py

@@ -0,0 +1,23 @@
+from ntgcalls import StreamDevice
+from ntgcalls import StreamType
+
+from ...scaffold import Scaffold
+from ...types import Device
+from ...types import StreamEnded
+
+
+class HandleStreamEnded(Scaffold):
+    async def _handle_stream_ended(
+        self,
+        chat_id: int,
+        stream_type: StreamType,
+        device: StreamDevice,
+    ):
+        await self._propagate(
+            StreamEnded(
+                chat_id,
+                StreamEnded.Type.from_raw(stream_type),
+                Device.from_raw(device),
+            ),
+            self,
+        )

pytgcalls/methods/internal/handle_stream_frame.py

@@ -0,0 +1,41 @@
+from typing import List
+
+from ntgcalls import Frame as RawFrame
+from ntgcalls import StreamDevice
+from ntgcalls import StreamMode
+
+from ...scaffold import Scaffold
+from ...types import Device
+from ...types import Direction
+from ...types import Frame
+from ...types import StreamFrames
+
+
+class HandleStreamFrame(Scaffold):
+    async def _handle_stream_frame(
+        self,
+        chat_id: int,
+        mode: StreamMode,
+        device: StreamDevice,
+        frames: List[RawFrame],
+    ):
+        await self._propagate(
+            StreamFrames(
+                chat_id,
+                Direction.from_raw(mode),
+                Device.from_raw(device),
+                [
+                    Frame(
+                        x.ssrc,
+                        x.data,
+                        Frame.Info(
+                            x.frame_data.absolute_capture_timestamp_ms,
+                            x.frame_data.width,
+                            x.frame_data.height,
+                            x.frame_data.rotation,
+                        ),
+                    ) for x in frames
+                ],
+            ),
+            self,
+        )