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

pytgcalls/methods/utilities/start.py

@@ -1,309 +1,19 @@
 import asyncio
 import logging
-from typing import List
 
-from ntgcalls import ConnectionError
-from ntgcalls import ConnectionNotFound
-from ntgcalls import ConnectionState
-from ntgcalls import Frame as RawFrame
-from ntgcalls import MediaState
-from ntgcalls import NetworkInfo
-from ntgcalls import StreamDevice
-from ntgcalls import StreamMode
-from ntgcalls import StreamType
-from ntgcalls import TelegramServerError
-
-from ...exceptions import CallBusy
-from ...exceptions import CallDeclined
-from ...exceptions import CallDiscarded
 from ...exceptions import PyTgCallsAlreadyRunning
-from ...mtproto import BridgedClient
 from ...pytgcalls_session import PyTgCallsSession
 from ...scaffold import Scaffold
-from ...types import CallData
-from ...types import ChatUpdate
-from ...types import Device
-from ...types import Direction
-from ...types import Frame
-from ...types import GroupCallParticipant
-from ...types import RawCallUpdate
-from ...types import StreamEnded
-from ...types import StreamFrames
-from ...types import Update
-from ...types import UpdatedGroupCallParticipant
 
 py_logger = logging.getLogger('pytgcalls')
 
 
 class Start(Scaffold):
     async def start(self):
-
-        @self._app.on_update()
-        async def update_handler(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 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 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
-                        ):
-                            try:
-                                await update_status(
-                                    chat_id,
-                                    await self._binding.get_state(chat_id),
-                                )
-                            except ConnectionNotFound:
-                                pass
-
-                        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,
-                )
-
-        async def clear_call(chat_id) -> bool:
-            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
-            await clear_cache(chat_id)
-            return res
-
-        async def update_status(chat_id: int, state: MediaState):
-            try:
-                await self._app.set_call_status(
-                    chat_id,
-                    state.muted,
-                    state.video_paused,
-                    state.video_stopped,
-                    state.presentation_paused,
-                    self._cache_user_peer.get(chat_id),
-                )
-            except Exception as e:
-                py_logger.debug(f'SetVideoCallStatus: {e}')
-
-        async def stream_ended(
-            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,
-            )
-
-        async def emit_sig_data(chat_id: int, data: bytes):
-            try:
-                await self._app.send_signaling(
-                    chat_id,
-                    data,
-                )
-            except (ConnectionError, ConnectionNotFound):
-                pass
-
-        async def stream_frame(
-            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,
-            )
-
-        async def connection_changed(
-            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)
-                await clear_cache(chat_id)
-
-        async def clear_cache(chat_id: int):
-            self._p2p_configs.pop(chat_id, None)
-            self._cache_user_peer.pop(chat_id)
-            self._need_unmute.discard(chat_id)
-
         if not self._is_running:
             self._is_running = True
             self._env_checker.check_environment()
+            self._app.add_handler(self._handle_mtproto_updates)
             if not self._app.is_connected:
                 await self._app.start()
 
@@ -324,33 +34,33 @@ class Start(Scaffold):
             self._binding.on_stream_end(
                 lambda chat_id, stream_type, device:
                 asyncio.run_coroutine_threadsafe(
-                    stream_ended(chat_id, stream_type, device),
+                    self._handle_stream_ended(chat_id, stream_type, device),
                     self.loop,
                 ),
             )
             self._binding.on_upgrade(
                 lambda chat_id, state:
                 asyncio.run_coroutine_threadsafe(
-                    update_status(chat_id, state),
+                    self._update_status(chat_id, state),
                     self.loop,
                 ),
             )
             self._binding.on_connection_change(
                 lambda chat_id, net_state: asyncio.run_coroutine_threadsafe(
-                    connection_changed(chat_id, net_state),
+                    self._handle_connection_changed(chat_id, net_state),
                     self.loop,
                 ),
             )
             self._binding.on_signaling(
                 lambda chat_id, data: asyncio.run_coroutine_threadsafe(
-                    emit_sig_data(chat_id, data),
+                    self._emit_sig_data(chat_id, data),
                     self.loop,
                 ),
             )
             self._binding.on_frames(
                 lambda chat_id, mode, device, frames:
                 asyncio.run_coroutine_threadsafe(
-                    stream_frame(
+                    self._handle_stream_frame(
                         chat_id,
                         mode,
                         device,
@@ -359,6 +69,23 @@ class Start(Scaffold):
                     self.loop,
                 ),
             )
+            self._binding.on_request_broadcast_part(
+                lambda chat_id, part_request:
+                asyncio.run_coroutine_threadsafe(
+                    self._request_broadcast_part(
+                        chat_id,
+                        part_request,
+                    ),
+                    self.loop,
+                ),
+            )
+            self._binding.on_request_broadcast_timestamp(
+                lambda chat_id:
+                asyncio.run_coroutine_threadsafe(
+                    self._request_broadcast_timestamp(chat_id),
+                    self.loop,
+                ),
+            )
             await PyTgCallsSession().start()
         else:
             raise PyTgCallsAlreadyRunning()

pytgcalls/mtproto/bridged_client.py

@@ -1,9 +1,9 @@
 import random
 from typing import Any
-from typing import Callable
 from typing import List
 from typing import Optional
 
+from ntgcalls import MediaSegmentQuality
 from ntgcalls import Protocol
 from ntgcalls import RTCServer
 from ntgcalls import SsrcGroup
@@ -109,6 +109,22 @@ class BridgedClient(HandlersHolder):
     ):
         pass
 
+    async def download_stream(
+        self,
+        chat_id: int,
+        timestamp: int,
+        limit: int,
+        video_channel: Optional[int],
+        video_quality: MediaSegmentQuality,
+    ):
+        pass
+
+    async def get_stream_timestamp(
+        self,
+        chat_id: int,
+    ):
+        pass
+
     async def set_call_status(
         self,
         chat_id: int,
@@ -233,6 +249,17 @@ class BridgedClient(HandlersHolder):
             for server in servers
         ]
 
+    @staticmethod
+    def parse_quality(quality: MediaSegmentQuality) -> Optional[int]:
+        if quality == MediaSegmentQuality.THUMBNAIL:
+            return 0
+        elif quality == MediaSegmentQuality.MEDIUM:
+            return 1
+        elif quality == MediaSegmentQuality.FULL:
+            return 2
+        else:
+            return None
+
     @staticmethod
     def rnd_id() -> int:
         return random.randint(0, 0x7FFFFFFF - 1)
@@ -240,12 +267,6 @@ class BridgedClient(HandlersHolder):
     async def get_dhc(self):
         pass
 
-    def on_update(self) -> Callable:
-        def decorator(func: Callable) -> Callable:
-            return self.add_handler(func)
-
-        return decorator
-
     async def get_id(self):
         pass
 

pytgcalls/mtproto/client_cache.py

@@ -30,7 +30,6 @@ class ClientCache:
     ) -> Optional[Any]:
         full_chat = self._full_chat_cache.get(chat_id)
         if full_chat is not None:
-            py_logger.debug('FullChat cache hit for %d', chat_id)
             return full_chat
         else:
             # noinspection PyBroadException

pytgcalls/mtproto/hydrogram_client.py

@@ -6,6 +6,7 @@ from typing import Union
 
 from hydrogram import Client
 from hydrogram import ContinuePropagation
+from hydrogram.errors import FloodWait
 from hydrogram.raw.base import InputPeer
 from hydrogram.raw.base import InputUser
 from hydrogram.raw.functions.channels import GetFullChannel
@@ -17,6 +18,7 @@ from hydrogram.raw.functions.phone import CreateGroupCall
 from hydrogram.raw.functions.phone import DiscardCall
 from hydrogram.raw.functions.phone import EditGroupCallParticipant
 from hydrogram.raw.functions.phone import GetGroupCall
+from hydrogram.raw.functions.phone import GetGroupCallStreamChannels
 from hydrogram.raw.functions.phone import GetGroupParticipants
 from hydrogram.raw.functions.phone import JoinGroupCall
 from hydrogram.raw.functions.phone import JoinGroupCallPresentation
@@ -24,6 +26,7 @@ from hydrogram.raw.functions.phone import LeaveGroupCall
 from hydrogram.raw.functions.phone import LeaveGroupCallPresentation
 from hydrogram.raw.functions.phone import RequestCall
 from hydrogram.raw.functions.phone import SendSignalingData
+from hydrogram.raw.functions.upload import GetFile
 from hydrogram.raw.types import Channel
 from hydrogram.raw.types import ChannelForbidden
 from hydrogram.raw.types import Chat
@@ -33,6 +36,7 @@ from hydrogram.raw.types import GroupCall
 from hydrogram.raw.types import GroupCallDiscarded
 from hydrogram.raw.types import InputChannel
 from hydrogram.raw.types import InputGroupCall
+from hydrogram.raw.types import InputGroupCallStream
 from hydrogram.raw.types import InputPeerChannel
 from hydrogram.raw.types import InputPhoneCall
 from hydrogram.raw.types import MessageActionChatDeleteUser
@@ -58,6 +62,7 @@ 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 ntgcalls import MediaSegmentQuality
 from ntgcalls import Protocol
 
 from ..types import CallProtocol
@@ -612,6 +617,58 @@ class HydrogramClient(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.invoke(
+                        GetFile(
+                            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,
+                        ),
+                        sleep_threshold=0,
+                    )
+                ).bytes
+            except FloodWait:
+                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.invoke(
+                    GetGroupCallStreamChannels(
+                        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/mtproto/mtproto_client.py

@@ -3,6 +3,7 @@ from typing import Callable
 from typing import List
 from typing import Optional
 
+from ntgcalls import MediaSegmentQuality
 from ntgcalls import Protocol
 
 from ..exceptions import InvalidMTProtoClient
@@ -211,6 +212,36 @@ class MtProtoClient:
         else:
             raise InvalidMTProtoClient()
 
+    async def download_stream(
+        self,
+        chat_id: int,
+        timestamp: int,
+        limit: int,
+        video_channel: Optional[int],
+        video_quality: MediaSegmentQuality,
+    ):
+        if self._bind_client is not None:
+            return await self._bind_client.download_stream(
+                chat_id,
+                timestamp,
+                limit,
+                video_channel,
+                video_quality,
+            )
+        else:
+            raise InvalidMTProtoClient()
+
+    async def get_stream_timestamp(
+        self,
+        chat_id: int,
+    ):
+        if self._bind_client is not None:
+            return await self._bind_client.get_stream_timestamp(
+                chat_id,
+            )
+        else:
+            raise InvalidMTProtoClient()
+
     async def set_call_status(
         self,
         chat_id: int,
@@ -281,7 +312,7 @@ class MtProtoClient:
         else:
             raise InvalidMTProtoClient()
 
-    def on_update(self) -> Callable:
+    def add_handler(self, func: Callable):
         if self._bind_client is not None:
-            return self._bind_client.on_update()
+            return self._bind_client.add_handler(func)
         raise InvalidMTProtoClient()