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

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
 
@@ -79,103 +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(),
-                                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 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,
@@ -184,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