py-tgcalls 2.1.2b3__py3-none-any.whl → 2.2.0__py3-none-any.whl

pytgcalls/mtproto/hydrogram_client.py

@@ -6,9 +6,14 @@ from typing import Union
 
 from hydrogram import Client
 from hydrogram import ContinuePropagation
+from hydrogram.errors import AuthBytesInvalid
+from hydrogram.errors import BadRequest
+from hydrogram.errors import FileMigrate
 from hydrogram.errors import FloodWait
 from hydrogram.raw.base import InputPeer
 from hydrogram.raw.base import InputUser
+from hydrogram.raw.functions.auth import ExportAuthorization
+from hydrogram.raw.functions.auth import ImportAuthorization
 from hydrogram.raw.functions.channels import GetFullChannel
 from hydrogram.raw.functions.messages import GetDhConfig
 from hydrogram.raw.functions.messages import GetFullChat
@@ -16,6 +21,7 @@ from hydrogram.raw.functions.phone import AcceptCall
 from hydrogram.raw.functions.phone import ConfirmCall
 from hydrogram.raw.functions.phone import CreateGroupCall
 from hydrogram.raw.functions.phone import DiscardCall
+from hydrogram.raw.functions.phone import DiscardGroupCall
 from hydrogram.raw.functions.phone import EditGroupCallParticipant
 from hydrogram.raw.functions.phone import GetGroupCall
 from hydrogram.raw.functions.phone import GetGroupCallStreamChannels
@@ -62,6 +68,8 @@ from hydrogram.raw.types import UpdatePhoneCall
 from hydrogram.raw.types import UpdatePhoneCallSignalingData
 from hydrogram.raw.types import Updates
 from hydrogram.raw.types.messages import DhConfig
+from hydrogram.session import Auth
+from hydrogram.session import Session
 from ntgcalls import MediaSegmentQuality
 from ntgcalls import Protocol
 
@@ -69,7 +77,6 @@ from ..types import CallProtocol
 from ..types import ChatUpdate
 from ..types import GroupCallParticipant
 from ..types import RawCallUpdate
-from ..types import UpdatedGroupCallParticipant
 from .bridged_client import BridgedClient
 from .client_cache import ClientCache
 
@@ -87,7 +94,7 @@ class HydrogramClient(BridgedClient):
             self,
         )
 
-        @self._app.on_raw_update(group=-1)
+        @self._app.on_raw_update(group=-9999)
         async def on_update(_, update, __, chats):
             if isinstance(
                 update,
@@ -179,19 +186,22 @@ class HydrogramClient(BridgedClient):
                 update,
                 UpdateGroupCallParticipants,
             ):
-                participants = update.participants
-                for participant in participants:
-                    result = self._cache.set_participants_cache_call(
-                        update.call.id,
-                        self.parse_participant(participant),
+                for participant in update.participants:
+                    chat_id = self._cache.get_chat_id(update.call.id)
+                    p_updates = await self.diff_participants_update(
+                        self._cache,
+                        chat_id,
+                        participant,
                     )
-                    if result is not None:
-                        await self._propagate(
-                            UpdatedGroupCallParticipant(
-                                self._cache.get_chat_id(update.call.id),
-                                result,
-                            ),
+                    for p_update in p_updates:
+                        result = self._cache.set_participants_cache(
+                            chat_id,
+                            update.call.id,
+                            p_update.action,
+                            p_update.participant,
                         )
+                        if result is not None:
+                            await self._propagate(p_update)
             if isinstance(
                 update,
                 UpdateGroupCall,
@@ -317,7 +327,7 @@ class HydrogramClient(BridgedClient):
         chat = await self._app.resolve_peer(chat_id)
         if isinstance(chat, InputPeerChannel):
             input_call = (
-                await self._app.invoke(
+                await self._invoke(
                     GetFullChannel(
                         channel=InputChannel(
                             channel_id=chat.channel_id,
@@ -328,14 +338,14 @@ class HydrogramClient(BridgedClient):
             ).full_chat.call
         else:
             input_call = (
-                await self._app.invoke(
+                await self._invoke(
                     GetFullChat(chat_id=chat.chat_id),
                 )
             ).full_chat.call
 
         if input_call is not None:
             raw_call = (
-                await self._app.invoke(
+                await self._invoke(
                     GetGroupCall(
                         call=input_call,
                         limit=-1,
@@ -345,9 +355,10 @@ class HydrogramClient(BridgedClient):
             call: GroupCall = raw_call.call
             participants: List[GroupCallParticipant] = raw_call.participants
             for participant in participants:
-                self._cache.set_participants_cache_chat(
+                self._cache.set_participants_cache(
                     chat_id,
                     call.id,
+                    self.parse_participant_action(participant),
                     self.parse_participant(participant),
                 )
             if call.schedule_date is not None:
@@ -356,7 +367,7 @@ class HydrogramClient(BridgedClient):
         return input_call
 
     async def get_dhc(self) -> DhConfig:
-        return await self._app.invoke(
+        return await self._invoke(
             GetDhConfig(
                 version=0,
                 random_length=256,
@@ -378,7 +389,7 @@ class HydrogramClient(BridgedClient):
         participants = []
         next_offset = ''
         while True:
-            result = await self._app.invoke(
+            result = await self._invoke(
                 GetGroupParticipants(
                     call=input_call,
                     ids=[],
@@ -405,7 +416,7 @@ class HydrogramClient(BridgedClient):
     ) -> str:
         chat_call = await self._cache.get_full_chat(chat_id)
         if chat_call is not None:
-            result: Updates = await self._app.invoke(
+            result: Updates = await self._invoke(
                 JoinGroupCall(
                     call=chat_call,
                     params=DataJSON(data=json_join),
@@ -422,8 +433,10 @@ class HydrogramClient(BridgedClient):
                 ):
                     participants = update.participants
                     for participant in participants:
-                        self._cache.set_participants_cache_call(
+                        self._cache.set_participants_cache(
+                            chat_id,
                             update.call.id,
+                            self.parse_participant_action(participant),
                             self.parse_participant(participant),
                         )
                 if isinstance(update, UpdateGroupCallConnection):
@@ -438,7 +451,7 @@ class HydrogramClient(BridgedClient):
     ):
         chat_call = await self._cache.get_full_chat(chat_id)
         if chat_call is not None:
-            result: Updates = await self._app.invoke(
+            result: Updates = await self._invoke(
                 JoinGroupCallPresentation(
                     call=chat_call,
                     params=DataJSON(data=json_join),
@@ -456,7 +469,7 @@ class HydrogramClient(BridgedClient):
     ):
         chat_call = await self._cache.get_full_chat(chat_id)
         if chat_call is not None:
-            await self._app.invoke(
+            await self._invoke(
                 LeaveGroupCallPresentation(
                     call=chat_call,
                 ),
@@ -469,7 +482,7 @@ class HydrogramClient(BridgedClient):
         protocol: Protocol,
         has_video: bool,
     ):
-        update = await self._app.invoke(
+        update = await self._invoke(
             RequestCall(
                 user_id=await self.resolve_peer(user_id),
                 random_id=self.rnd_id(),
@@ -492,7 +505,7 @@ class HydrogramClient(BridgedClient):
         g_b: bytes,
         protocol: Protocol,
     ):
-        await self._app.invoke(
+        await self._invoke(
             AcceptCall(
                 peer=self._cache.get_phone_call(user_id),
                 g_b=g_b,
@@ -508,7 +521,7 @@ class HydrogramClient(BridgedClient):
         protocol: Protocol,
     ) -> CallProtocol:
         res = (
-            await self._app.invoke(
+            await self._invoke(
                 ConfirmCall(
                     peer=self._cache.get_phone_call(user_id),
                     g_a=g_a,
@@ -528,7 +541,7 @@ class HydrogramClient(BridgedClient):
         user_id: int,
         data: bytes,
     ):
-        await self._app.invoke(
+        await self._invoke(
             SendSignalingData(
                 peer=self._cache.get_phone_call(user_id),
                 data=data,
@@ -539,7 +552,7 @@ class HydrogramClient(BridgedClient):
         self,
         chat_id: int,
     ):
-        result: Updates = await self._app.invoke(
+        result: Updates = await self._invoke(
             CreateGroupCall(
                 peer=await self.resolve_peer(chat_id),
                 random_id=self.rnd_id(),
@@ -569,13 +582,26 @@ class HydrogramClient(BridgedClient):
     ):
         chat_call = await self._cache.get_full_chat(chat_id)
         if chat_call is not None:
-            await self._app.invoke(
+            await self._invoke(
                 LeaveGroupCall(
                     call=chat_call,
                     source=0,
                 ),
             )
 
+    async def close_voice_chat(
+        self,
+        chat_id: int,
+    ):
+        chat_call = await self._cache.get_full_chat(chat_id)
+        if chat_call is not None:
+            await self._invoke(
+                DiscardGroupCall(
+                    call=chat_call,
+                ),
+            )
+            self._cache.drop_cache(chat_id)
+
     async def discard_call(
         self,
         chat_id: int,
@@ -589,7 +615,7 @@ class HydrogramClient(BridgedClient):
             if is_missed
             else PhoneCallDiscardReasonHangup()
         )
-        await self._app.invoke(
+        await self._invoke(
             DiscardCall(
                 peer=peer,
                 duration=0,
@@ -608,7 +634,7 @@ class HydrogramClient(BridgedClient):
     ):
         chat_call = await self._cache.get_full_chat(chat_id)
         if chat_call is not None:
-            await self._app.invoke(
+            await self._invoke(
                 EditGroupCallParticipant(
                     call=chat_call,
                     participant=participant,
@@ -629,7 +655,7 @@ class HydrogramClient(BridgedClient):
         if chat_call is not None:
             try:
                 return (
-                    await self._app.invoke(
+                    await self._invoke(
                         GetFile(
                             location=InputGroupCallStream(
                                 call=chat_call,
@@ -656,9 +682,8 @@ class HydrogramClient(BridgedClient):
     ):
         chat_call = await self._cache.get_full_chat(chat_id)
         if chat_call is not None:
-            # noinspection PyBroadException
             channels = (
-                await self._app.invoke(
+                await self._invoke(
                     GetGroupCallStreamChannels(
                         call=chat_call,
                     ),
@@ -680,7 +705,7 @@ class HydrogramClient(BridgedClient):
     ):
         chat_call = await self._cache.get_full_chat(chat_id)
         if chat_call is not None:
-            await self._app.invoke(
+            await self._invoke(
                 EditGroupCallParticipant(
                     call=chat_call,
                     participant=participant,
@@ -719,5 +744,77 @@ class HydrogramClient(BridgedClient):
     def no_updates(self):
         return self._app.no_updates
 
+    async def _invoke(
+        self,
+        request,
+        dc_id: Optional[int] = None,
+        chat_id: Optional[int] = None,
+        sleep_threshold: Optional[int] = None,
+    ):
+        if chat_id is not None:
+            dc_id = self._cache.get_dc_call(chat_id)
+        if dc_id is None:
+            session = self._app
+        else:
+            session = self._app.media_sessions.get(dc_id)
+            if not session:
+                session = self._app.media_sessions[dc_id] = Session(
+                    self._app,
+                    dc_id,
+                    await Auth(
+                        self._app,
+                        dc_id,
+                        await self._app.storage.test_mode(),
+                    ).create()
+                    if dc_id != await self._app.storage.dc_id()
+                    else await self._app.storage.auth_key(),
+                    await self._app.storage.test_mode(),
+                    is_media=True,
+                )
+                await session.start()
+                if dc_id != await self._app.storage.dc_id():
+                    for _ in range(3):
+                        exported_auth = await self._invoke(
+                            ExportAuthorization(
+                                dc_id=dc_id,
+                            ),
+                        )
+
+                        try:
+                            await session.invoke(
+                                ImportAuthorization(
+                                    id=exported_auth.id,
+                                    bytes=exported_auth.bytes,
+                                ),
+                            )
+                        except AuthBytesInvalid:
+                            continue
+                        else:
+                            break
+                    else:
+                        raise AuthBytesInvalid
+        try:
+            return await session.invoke(
+                request,
+                sleep_threshold=sleep_threshold,
+            )
+        except (BadRequest, FileMigrate) as e:
+            dc_new = BridgedClient.extract_dc(
+                str(e),
+            )
+            if dc_new is not None:
+                if chat_id is not None:
+                    self._cache.set_dc_call(
+                        chat_id,
+                        dc_new,
+                    )
+                return await self._invoke(
+                    request,
+                    dc_new,
+                    chat_id,
+                    sleep_threshold,
+                )
+            raise
+
     async def start(self):
         await self._app.start()

pytgcalls/mtproto/mtproto_client.py

@@ -197,6 +197,17 @@ class MtProtoClient:
         else:
             raise InvalidMTProtoClient()
 
+    async def close_voice_chat(
+        self,
+        chat_id: int,
+    ):
+        if self._bind_client is not None:
+            await self._bind_client.close_voice_chat(
+                chat_id,
+            )
+        else:
+            raise InvalidMTProtoClient()
+
     async def change_volume(
         self,
         chat_id: int,