py-tgcalls 2.1.0rc7__py3-none-any.whl → 2.1.2b1__py3-none-any.whl

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,
+        )

pytgcalls/methods/internal/join_presentation.py

@@ -0,0 +1,58 @@
+from typing import Union
+
+from ntgcalls import ConnectionError
+from ntgcalls import ConnectionMode
+from ntgcalls import TelegramServerError
+
+from ...scaffold import Scaffold
+
+
+class JoinPresentation(Scaffold):
+    async def _join_presentation(
+        self,
+        chat_id: Union[int, str],
+        join: bool,
+    ):
+        connection_mode = await self._binding.get_connection_mode(
+            chat_id,
+        )
+        if connection_mode == ConnectionMode.STREAM:
+            if chat_id in self._pending_connections:
+                self._pending_connections[chat_id].presentation = join
+        elif connection_mode == ConnectionMode.RTC:
+            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)

pytgcalls/methods/internal/request_broadcast_part.py

@@ -0,0 +1,42 @@
+from ntgcalls import ConnectionError
+from ntgcalls import ConnectionNotFound
+from ntgcalls import MediaSegmentStatus
+from ntgcalls import SegmentPartRequest
+
+from ...scaffold import Scaffold
+
+
+class RequestBroadcastPart(Scaffold):
+    async def _request_broadcast_part(
+        self,
+        chat_id: int,
+        part_request: SegmentPartRequest,
+    ):
+        part_status = MediaSegmentStatus.NOT_READY
+        # noinspection PyBroadException
+        try:
+            part = await self._app.download_stream(
+                chat_id,
+                part_request.timestamp,
+                part_request.limit,
+                part_request.channel_id
+                if part_request.channel_id > 0 else None,
+                part_request.quality,
+            )
+            if part is not None:
+                part_status = MediaSegmentStatus.SUCCESS
+        except Exception:
+            part = None
+            part_status = MediaSegmentStatus.RESYNC_NEEDED
+
+        try:
+            await self._binding.send_broadcast_part(
+                chat_id,
+                part_request.segment_id,
+                part_request.part_id,
+                part_status,
+                part_request.quality_update,
+                part,
+            )
+        except (ConnectionError, ConnectionNotFound):
+            pass

pytgcalls/methods/internal/request_broadcast_timestamp.py

@@ -0,0 +1,25 @@
+from ntgcalls import ConnectionError
+from ntgcalls import ConnectionNotFound
+
+from ...scaffold import Scaffold
+
+
+class RequestBroadcastTimestamp(Scaffold):
+    async def _request_broadcast_timestamp(
+        self,
+        chat_id: int,
+    ):
+        # noinspection PyBroadException
+        try:
+            time = await self._app.get_stream_timestamp(
+                chat_id,
+            )
+        except Exception:
+            time = 0
+        try:
+            await self._binding.send_broadcast_timestamp(
+                chat_id,
+                time,
+            )
+        except (ConnectionError, ConnectionNotFound):
+            pass

pytgcalls/methods/internal/switch_connection.py

@@ -0,0 +1,35 @@
+import logging
+
+from ntgcalls import ConnectionMode
+
+from ...scaffold import Scaffold
+from ...types.calls import CallSources
+
+py_logger = logging.getLogger('pytgcalls')
+
+
+class SwitchConnection(Scaffold):
+    async def _switch_connection(self, chat_id: int):
+        try:
+            connection_mode = await self._binding.get_connection_mode(
+                chat_id,
+            )
+            if connection_mode == ConnectionMode.STREAM and \
+                    chat_id in self._pending_connections:
+                connection = self._pending_connections[chat_id]
+                await self._connect_call(
+                    chat_id,
+                    connection.media_description,
+                    connection.config,
+                    connection.payload,
+                )
+                if connection.presentation:
+                    await self._join_presentation(
+                        chat_id,
+                        True,
+                    )
+                self._call_sources[chat_id] = CallSources()
+                await self._update_sources(chat_id)
+                self._pending_connections.pop(chat_id)
+        except Exception as e:
+            py_logger.debug(f'SetPresentationStatus: {e}')

pytgcalls/methods/internal/update_status.py

@@ -0,0 +1,22 @@
+import logging
+
+from ntgcalls import MediaState
+
+from ...scaffold import Scaffold
+
+py_logger = logging.getLogger('pytgcalls')
+
+
+class UpdateStatus(Scaffold):
+    async def _update_status(self, 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}')

pytgcalls/methods/stream/play.py

@@ -1,27 +1,19 @@
-import asyncio
 import logging
 from pathlib import Path
 from typing import Optional
 from typing import Union
 
-from ntgcalls import ConnectionNotFound
 from ntgcalls import FileError
 from ntgcalls import StreamMode
-from ntgcalls import TelegramServerError
-from ntgcalls import TransportParseException
 
 from ...exceptions import NoActiveGroupCall
-from ...exceptions import TimedOutAnswer
-from ...exceptions import UnMuteNeeded
 from ...media_devices.input_device import InputDevice
 from ...mtproto_required import mtproto_required
 from ...mutex import mutex
 from ...scaffold import Scaffold
 from ...statictypes import statictypes
 from ...types import CallConfig
-from ...types import CallData
 from ...types import GroupCallConfig
-from ...types import RawCallUpdate
 from ...types.raw import Stream
 from ..utilities.stream_params import StreamParams
 
@@ -29,9 +21,9 @@ py_logger = logging.getLogger('pytgcalls')
 
 
 class Play(Scaffold):
-    @mutex
     @statictypes
     @mtproto_required
+    @mutex
     async def play(
         self,
         chat_id: Union[int, str],
@@ -79,101 +71,12 @@ class Play(Scaffold):
                     raise NoActiveGroupCall()
 
         try:
-            for retries in range(4):
-                try:
-                    self._wait_connect[chat_id] = self.loop.create_future()
-                    if isinstance(config, GroupCallConfig):
-                        payload: str = 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,
-                        )
-                    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(),
-                            )
-
-                        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 is_p2p:
-                        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)
-
+            await self._connect_call(
+                chat_id,  # type: ignore
+                media_description,
+                config,
+                None,
+            )
             if isinstance(config, GroupCallConfig):
                 await self._join_presentation(
                     chat_id,
@@ -182,8 +85,6 @@ class Play(Scaffold):
                 await self._update_sources(chat_id)
         except FileError as e:
             raise FileNotFoundError(e)
-        except TransportParseException:
-            raise UnMuteNeeded()
         except Exception:
             if isinstance(config, GroupCallConfig):
                 self._cache_user_peer.pop(chat_id)

pytgcalls/methods/stream/record.py

@@ -39,11 +39,5 @@ class Record(Scaffold):
                 StreamMode.PLAYBACK,
                 media_description,
             )
-            if isinstance(chat_id, int) and chat_id < 0:
-                await self._join_presentation(
-                    chat_id,
-                    media_description.screen is not None,
-                )
-                await self._update_sources(chat_id)
         except FileError as e:
             raise FileNotFoundError(e)

pytgcalls/methods/utilities/__init__.py

@@ -1,25 +1,19 @@
 from .cache_peer import CachePeer
 from .call_holder import CallHolder
 from .cpu_usage import CpuUsage
-from .join_presentation import JoinPresentation
-from .log_retries import LogRetries
 from .ping import Ping
 from .resolve_chat_id import ResolveChatID
 from .run import Run
 from .start import Start
-from .update_sources import UpdateSources
 
 
 class Utilities(
     CachePeer,
     CallHolder,
     CpuUsage,
-    JoinPresentation,
-    LogRetries,
     Ping,
     ResolveChatID,
     Run,
     Start,
-    UpdateSources,
 ):
     pass