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

pytgcalls/mtproto/telethon_client.py

@@ -3,9 +3,11 @@ from typing import List
 from typing import Optional
 from typing import Union
 
+from ntgcalls import MediaSegmentQuality
 from ntgcalls import Protocol
 from telethon import TelegramClient
 from telethon.errors import ChannelPrivateError
+from telethon.errors import FloodWaitError
 from telethon.events import Raw
 from telethon.tl.functions.channels import GetFullChannelRequest
 from telethon.tl.functions.messages import GetDhConfigRequest
@@ -16,6 +18,7 @@ from telethon.tl.functions.phone import CreateGroupCallRequest
 from telethon.tl.functions.phone import DiscardCallRequest
 from telethon.tl.functions.phone import EditGroupCallParticipantRequest
 from telethon.tl.functions.phone import GetGroupCallRequest
+from telethon.tl.functions.phone import GetGroupCallStreamChannelsRequest
 from telethon.tl.functions.phone import GetGroupParticipantsRequest
 from telethon.tl.functions.phone import JoinGroupCallPresentationRequest
 from telethon.tl.functions.phone import JoinGroupCallRequest
@@ -23,12 +26,14 @@ from telethon.tl.functions.phone import LeaveGroupCallPresentationRequest
 from telethon.tl.functions.phone import LeaveGroupCallRequest
 from telethon.tl.functions.phone import RequestCallRequest
 from telethon.tl.functions.phone import SendSignalingDataRequest
+from telethon.tl.functions.upload import GetFileRequest
 from telethon.tl.types import ChatForbidden
 from telethon.tl.types import DataJSON
 from telethon.tl.types import GroupCall
 from telethon.tl.types import GroupCallDiscarded
 from telethon.tl.types import InputChannel
 from telethon.tl.types import InputGroupCall
+from telethon.tl.types import InputGroupCallStream
 from telethon.tl.types import InputPeerChannel
 from telethon.tl.types import InputPhoneCall
 from telethon.tl.types import MessageActionChatDeleteUser
@@ -604,6 +609,58 @@ class TelethonClient(BridgedClient):
                 ),
             )
 
+    async def download_stream(
+        self,
+        chat_id: int,
+        timestamp: int,
+        limit: int,
+        video_channel: Optional[int],
+        video_quality: MediaSegmentQuality,
+    ):
+        chat_call = await self._cache.get_full_chat(chat_id)
+        if chat_call is not None:
+            try:
+                return (
+                    await self._app(
+                        GetFileRequest(
+                            location=InputGroupCallStream(
+                                call=chat_call,
+                                time_ms=timestamp,
+                                scale=0,
+                                video_channel=video_channel,
+                                video_quality=BridgedClient.parse_quality(
+                                    video_quality,
+                                ),
+                            ),
+                            offset=0,
+                            limit=limit,
+                        ),
+                        flood_sleep_threshold=0,
+                    )
+                ).bytes
+            except FloodWaitError:
+                pass
+        return None
+
+    async def get_stream_timestamp(
+        self,
+        chat_id: int,
+    ):
+        chat_call = await self._cache.get_full_chat(chat_id)
+        if chat_call is not None:
+            # noinspection PyBroadException
+            channels = (
+                await self._app(
+                    GetGroupCallStreamChannelsRequest(
+                        call=chat_call,
+                    ),
+                )
+            ).channels
+            if len(channels) > 0:
+                return channels[0].last_timestamp_ms
+
+        return 0
+
     async def set_call_status(
         self,
         chat_id: int,

pytgcalls/scaffold.py

@@ -1,6 +1,20 @@
+from typing import List
+from typing import Optional
 from typing import Union
 
+from ntgcalls import Frame as RawFrame
+from ntgcalls import MediaDescription
+from ntgcalls import MediaState
+from ntgcalls import NetworkInfo
+from ntgcalls import SegmentPartRequest
+from ntgcalls import StreamDevice
+from ntgcalls import StreamMode
+from ntgcalls import StreamType
+
 from .handlers import HandlersHolder
+from .types import CallConfig
+from .types import GroupCallConfig
+from .types import Update
 
 
 class Scaffold(HandlersHolder):
@@ -25,6 +39,7 @@ class Scaffold(HandlersHolder):
         self._call_sources = dict()
         self._wait_connect = dict()
         self._presentations = set()
+        self._pending_connections = dict()
 
     def _handle_mtproto(self):
         pass
@@ -47,9 +62,73 @@ class Scaffold(HandlersHolder):
     async def _join_presentation(self, chat_id: Union[int, str], join: bool):
         pass
 
+    async def _clear_call(self, chat_id: int):
+        pass
+
+    async def _update_status(self, chat_id: int, state: MediaState):
+        pass
+
+    async def _switch_connection(self, chat_id: int):
+        pass
+
+    async def _handle_stream_ended(
+        self,
+        chat_id: int,
+        stream_type: StreamType,
+        device: StreamDevice,
+    ):
+        pass
+
+    async def _emit_sig_data(self, chat_id: int, data: bytes):
+        pass
+
+    async def _request_broadcast_timestamp(
+        self,
+        chat_id: int,
+    ):
+        pass
+
+    async def _request_broadcast_part(
+        self,
+        chat_id: int,
+        part_request: SegmentPartRequest,
+    ):
+        pass
+
+    async def _handle_stream_frame(
+        self,
+        chat_id: int,
+        mode: StreamMode,
+        device: StreamDevice,
+        frames: List[RawFrame],
+    ):
+        pass
+
+    async def _handle_connection_changed(
+        self,
+        chat_id: int,
+        net_state: NetworkInfo,
+    ):
+        pass
+
+    async def _handle_mtproto_updates(self, update: Update):
+        pass
+
+    async def _connect_call(
+        self,
+        chat_id: int,
+        media_description: MediaDescription,
+        config: Union[CallConfig, GroupCallConfig],
+        payload: Optional[str],
+    ):
+        pass
+
     @staticmethod
     def _log_retries(r: int):
         pass
 
+    def _clear_cache(self, chat_id: int):
+        pass
+
     def on_update(self, filters=None):
         pass

pytgcalls/types/__init__.py

@@ -5,6 +5,7 @@ from .calls import CallConfig
 from .calls import CallData
 from .calls import CallProtocol
 from .calls import GroupCallConfig
+from .calls import PendingConnection
 from .calls import RawCallUpdate
 from .chats import ChatUpdate
 from .chats import GroupCallParticipant
@@ -35,6 +36,7 @@ __all__ = (
     'CallProtocol',
     'CallData',
     'RawCallUpdate',
+    'PendingConnection',
     'GroupCallConfig',
     'GroupCallParticipant',
     'RecordStream',

pytgcalls/types/calls/__init__.py

@@ -4,6 +4,7 @@ from .call_data import CallData
 from .call_protocol import CallProtocol
 from .call_sources import CallSources
 from .group_call_config import GroupCallConfig
+from .pending_connection import PendingConnection
 from .raw_call_update import RawCallUpdate
 
 __all__ = (
@@ -13,5 +14,6 @@ __all__ = (
     'CallProtocol',
     'CallSources',
     'GroupCallConfig',
+    'PendingConnection',
     'RawCallUpdate',
 )

pytgcalls/types/calls/pending_connection.py

@@ -0,0 +1,17 @@
+from ntgcalls import MediaDescription
+
+from .group_call_config import GroupCallConfig
+
+
+class PendingConnection:
+    def __init__(
+        self,
+        media_description: MediaDescription,
+        config: GroupCallConfig,
+        payload: str,
+        presentation: bool,
+    ):
+        self.media_description = media_description
+        self.config = config
+        self.payload = payload
+        self.presentation = presentation

pytgcalls/methods/utilities/join_presentation.py

@@ -1,50 +0,0 @@
-from typing import Union
-
-from ntgcalls import ConnectionError
-from ntgcalls import TelegramServerError
-
-from ...scaffold import Scaffold
-
-
-class JoinPresentation(Scaffold):
-    async def _join_presentation(
-        self,
-        chat_id: Union[int, str],
-        join: bool,
-    ):
-        if join:
-            if chat_id in self._presentations:
-                return
-            for retries in range(4):
-                try:
-                    self._wait_connect[
-                        chat_id
-                    ] = self.loop.create_future()
-                    payload = await self._binding.init_presentation(
-                        chat_id,
-                    )
-                    result_params = await self._app.join_presentation(
-                        chat_id,
-                        payload,
-                    )
-                    await self._binding.connect(
-                        chat_id,
-                        result_params,
-                        True,
-                    )
-                    await self._wait_connect[chat_id]
-                    self._presentations.add(chat_id)
-                    break
-                except TelegramServerError:
-                    if retries == 3:
-                        raise
-                    self._log_retries(retries)
-                finally:
-                    self._wait_connect.pop(chat_id, None)
-        elif chat_id in self._presentations:
-            try:
-                await self._binding.stop_presentation(chat_id)
-                await self._app.leave_presentation(chat_id)
-            except ConnectionError:
-                pass
-            self._presentations.discard(chat_id)