py-tgcalls 2.0.5__py3-none-any.whl → 2.1.0__py3-none-any.whl

pytgcalls/methods/stream/__init__.py

@@ -1,17 +1,21 @@
-from .mute_stream import MuteStream
-from .pause_stream import PauseStream
+from .mute import Mute
+from .pause import Pause
 from .play import Play
-from .played_time import PlayedTime
-from .resume_stream import ResumeStream
-from .unmute_stream import UnMuteStream
+from .record import Record
+from .resume import Resume
+from .send_frame import SendFrame
+from .time import Time
+from .unmute import UnMute
 
 
 class StreamMethods(
-    MuteStream,
-    PauseStream,
+    Mute,
+    Pause,
     Play,
-    PlayedTime,
-    ResumeStream,
-    UnMuteStream,
+    Record,
+    SendFrame,
+    Time,
+    Resume,
+    UnMute,
 ):
     pass

pytgcalls/methods/stream/{mute_stream.py → mute.py}

@@ -8,10 +8,10 @@ from ...scaffold import Scaffold
 from ...statictypes import statictypes
 
 
-class MuteStream(Scaffold):
+class Mute(Scaffold):
     @statictypes
     @mtproto_required
-    async def mute_stream(
+    async def mute(
         self,
         chat_id: Union[int, str],
     ):

pytgcalls/methods/stream/{pause_stream.py → pause.py}

@@ -8,10 +8,10 @@ from ...scaffold import Scaffold
 from ...statictypes import statictypes
 
 
-class PauseStream(Scaffold):
+class Pause(Scaffold):
     @statictypes
     @mtproto_required
-    async def pause_stream(
+    async def pause(
         self,
         chat_id: Union[int, str],
     ):

pytgcalls/methods/stream/play.py

@@ -1,17 +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 InvalidParams
+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 ...mtproto import BridgedClient
+from ...media_devices.input_device import InputDevice
 from ...mtproto_required import mtproto_required
 from ...mutex import mutex
 from ...scaffold import Scaffold
@@ -33,7 +35,7 @@ class Play(Scaffold):
     async def play(
         self,
         chat_id: Union[int, str],
-        stream: Optional[Stream] = None,
+        stream: Optional[Union[str, Path, InputDevice, Stream]] = None,
         config: Optional[Union[CallConfig, GroupCallConfig]] = None,
     ):
         chat_id = await self.resolve_chat_id(chat_id)
@@ -50,8 +52,9 @@ class Play(Scaffold):
 
         if chat_id in await self._binding.calls():
             try:
-                return await self._binding.change_stream(
+                return await self._binding.set_stream_sources(
                     chat_id,
+                    StreamMode.CAPTURE,
                     media_description,
                 )
             except FileError as e:
@@ -80,31 +83,36 @@ class Play(Scaffold):
                 try:
                     self._wait_connect[chat_id] = self.loop.create_future()
                     if isinstance(config, GroupCallConfig):
-                        call_params: str = await self._binding.create_call(
+                        payload: str = await self._binding.create_call(
                             chat_id,
                             media_description,
                         )
                         result_params = await self._app.join_group_call(
                             chat_id,
-                            call_params,
+                            payload,
                             config.invite_hash,
-                            media_description.video is None,
+                            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),
                         )
-                        data.g_a_or_b = await self._binding.create_p2p_call(
+                        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,
-                            media_description,
                         )
                         if not data.outgoing:
                             await self._app.accept_call(
@@ -143,7 +151,11 @@ class Play(Scaffold):
                                 result.protocol.p2p_allowed,
                             )
                         except asyncio.TimeoutError:
-                            self._binding.stop(chat_id)
+                            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)
@@ -152,10 +164,7 @@ class Play(Scaffold):
                 except TelegramServerError:
                     if retries == 3 or is_p2p:
                         raise
-                    (py_logger.warning if retries >= 1 else py_logger.info)(
-                        f'Telegram is having some internal server issues. '
-                        f'Retrying {retries + 1} of 3',
-                    )
+                    self._log_retries(retries)
                 except Exception:
                     try:
                         await self._binding.stop(chat_id)
@@ -166,17 +175,14 @@ class Play(Scaffold):
                     self._wait_connect.pop(chat_id, None)
 
             if isinstance(config, GroupCallConfig):
-                participants = await self._app.get_group_call_participants(
+                await self._join_presentation(
                     chat_id,
+                    media_description.screen is not None,
                 )
-                for x in participants:
-                    if x.user_id == BridgedClient.chat_id(
-                        self._cache_local_peer,
-                    ) and x.muted_by_admin:
-                        self._need_unmute.add(chat_id)
+                await self._update_sources(chat_id)
         except FileError as e:
             raise FileNotFoundError(e)
-        except InvalidParams:
+        except TransportParseException:
             raise UnMuteNeeded()
         except Exception:
             if isinstance(config, GroupCallConfig):

pytgcalls/methods/stream/record.py

@@ -0,0 +1,49 @@
+import logging
+from pathlib import Path
+from typing import Optional
+from typing import Union
+
+from ntgcalls import FileError
+from ntgcalls import StreamMode
+
+from ...media_devices import SpeakerDevice
+from ...mtproto_required import mtproto_required
+from ...scaffold import Scaffold
+from ...statictypes import statictypes
+from ...types import CallConfig
+from ...types import GroupCallConfig
+from ...types.raw import Stream
+from ..utilities.stream_params import StreamParams
+
+py_logger = logging.getLogger('pytgcalls')
+
+
+class Record(Scaffold):
+    @statictypes
+    @mtproto_required
+    async def record(
+        self,
+        chat_id: Union[int, str],
+        stream: Optional[Union[str, Path, Stream, SpeakerDevice]] = None,
+        config: Optional[Union[CallConfig, GroupCallConfig]] = None,
+    ):
+        chat_id = await self.resolve_chat_id(chat_id)
+        media_description = await StreamParams.get_record_params(
+            stream,
+        )
+        if chat_id not in await self._binding.calls():
+            await self.play(chat_id, config=config)
+        try:
+            await self._binding.set_stream_sources(
+                chat_id,
+                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/stream/{resume_stream.py → resume.py}

@@ -8,10 +8,10 @@ from ...scaffold import Scaffold
 from ...statictypes import statictypes
 
 
-class ResumeStream(Scaffold):
+class Resume(Scaffold):
     @statictypes
     @mtproto_required
-    async def resume_stream(
+    async def resume(
         self,
         chat_id: Union[int, str],
     ):

pytgcalls/methods/stream/send_frame.py

@@ -0,0 +1,38 @@
+from typing import Union
+
+from ntgcalls import ConnectionNotFound
+from ntgcalls import FrameData
+
+from ...exceptions import NotInCallError
+from ...mtproto_required import mtproto_required
+from ...scaffold import Scaffold
+from ...statictypes import statictypes
+from ...types import Device
+from ...types import Frame
+
+
+class SendFrame(Scaffold):
+    @statictypes
+    @mtproto_required
+    async def send_frame(
+        self,
+        chat_id: Union[int, str],
+        device: Device,
+        data: bytes,
+        frame_data: Frame.Info = Frame.Info(),
+    ):
+        chat_id = await self.resolve_chat_id(chat_id)
+        try:
+            return await self._binding.send_external_frame(
+                chat_id,
+                Device.to_raw(device),
+                data,
+                FrameData(
+                    frame_data.capture_time,
+                    frame_data.rotation,
+                    frame_data.width,
+                    frame_data.height,
+                ),
+            )
+        except ConnectionNotFound:
+            raise NotInCallError()

pytgcalls/methods/stream/{played_time.py → time.py}

@@ -6,17 +6,19 @@ from ...exceptions import NotInCallError
 from ...mtproto_required import mtproto_required
 from ...scaffold import Scaffold
 from ...statictypes import statictypes
+from ...types import Direction
 
 
-class PlayedTime(Scaffold):
+class Time(Scaffold):
     @statictypes
     @mtproto_required
-    async def played_time(
+    async def time(
         self,
         chat_id: Union[int, str],
+        direction: Direction = Direction.OUTGOING,
     ):
         chat_id = await self.resolve_chat_id(chat_id)
         try:
-            return await self._binding.time(chat_id)
+            return await self._binding.time(chat_id, direction.to_raw())
         except ConnectionNotFound:
             raise NotInCallError()

pytgcalls/methods/stream/{unmute_stream.py → unmute.py}

@@ -8,10 +8,10 @@ from ...scaffold import Scaffold
 from ...statictypes import statictypes
 
 
-class UnMuteStream(Scaffold):
+class UnMute(Scaffold):
     @statictypes
     @mtproto_required
-    async def unmute_stream(
+    async def unmute(
         self,
         chat_id: Union[int, str],
     ):

pytgcalls/methods/utilities/__init__.py

@@ -1,19 +1,25 @@
 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

pytgcalls/methods/utilities/call_holder.py

@@ -9,7 +9,7 @@ class CallHolder(Scaffold):
     def __init__(self):
         super().__init__()
         self._conversions = {
-            StreamStatus.PLAYING: Call.Status.PLAYING,
+            StreamStatus.ACTIVE: Call.Status.ACTIVE,
             StreamStatus.PAUSED: Call.Status.PAUSED,
             StreamStatus.IDLING: Call.Status.IDLE,
         }
@@ -18,7 +18,10 @@ class CallHolder(Scaffold):
     async def calls(self):
         calls_list = await self._binding.calls()
         return Dict({
-            x: Call(x, self._conversions[calls_list[x]])
+            x: Call(
+                x, self._conversions[calls_list[x].playback],
+                self._conversions[calls_list[x].capture],
+            )
             for x in calls_list
         })
 

pytgcalls/methods/utilities/join_presentation.py

@@ -0,0 +1,50 @@
+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)

pytgcalls/methods/utilities/log_retries.py

@@ -0,0 +1,14 @@
+import logging
+
+from ...scaffold import Scaffold
+
+py_logger = logging.getLogger('pytgcalls')
+
+
+class LogRetries(Scaffold):
+    @staticmethod
+    def _log_retries(r: int):
+        (py_logger.warning if r >= 1 else py_logger.info)(
+            f'Telegram is having some internal server issues. '
+            f'Retrying {r + 1} of 3',
+        )

pytgcalls/methods/utilities/start.py

@@ -1,10 +1,15 @@
 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
 
@@ -16,10 +21,13 @@ 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 StreamAudioEnded
-from ...types import StreamVideoEnded
+from ...types import StreamEnded
+from ...types import StreamFrames
 from ...types import Update
 from ...types import UpdatedGroupCallParticipant
 
@@ -43,6 +51,7 @@ class Start(Scaffold):
                     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(
                                 CallDeclined(
                                     chat_id,
@@ -84,6 +93,68 @@ class Start(Scaffold):
                 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,
@@ -91,7 +162,7 @@ class Start(Scaffold):
                     if is_self:
                         if action == GroupCallParticipant.Action.LEFT:
                             if await clear_call(chat_id):
-                                await self.propagate(
+                                await self._propagate(
                                     ChatUpdate(
                                         chat_id,
                                         ChatUpdate.Status.KICKED,
@@ -119,7 +190,7 @@ class Start(Scaffold):
                         else:
                             self._need_unmute.discard(chat_id)
             if not isinstance(update, RawCallUpdate):
-                await self.propagate(
+                await self._propagate(
                     update,
                     self,
                 )
@@ -141,18 +212,22 @@ class Start(Scaffold):
                     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: StreamType):
-            await self.propagate(
-                StreamAudioEnded(
-                    chat_id,
-                ) if stream == StreamType.AUDIO else
-                StreamVideoEnded(
+        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,
             )
@@ -166,7 +241,38 @@ class Start(Scaffold):
             except (ConnectionError, ConnectionNotFound):
                 pass
 
-        async def connection_changed(chat_id: int, state: ConnectionState):
+        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:
@@ -209,20 +315,22 @@ class Start(Scaffold):
                 self._handle_mtproto()
 
             self._binding.on_stream_end(
-                lambda chat_id, stream: asyncio.run_coroutine_threadsafe(
-                    stream_ended(chat_id, stream),
+                lambda chat_id, stream_type, device:
+                asyncio.run_coroutine_threadsafe(
+                    stream_ended(chat_id, stream_type, device),
                     self.loop,
                 ),
             )
             self._binding.on_upgrade(
-                lambda chat_id, state: asyncio.run_coroutine_threadsafe(
+                lambda chat_id, state:
+                asyncio.run_coroutine_threadsafe(
                     update_status(chat_id, state),
                     self.loop,
                 ),
             )
             self._binding.on_connection_change(
-                lambda chat_id, state: asyncio.run_coroutine_threadsafe(
-                    connection_changed(chat_id, state),
+                lambda chat_id, net_state: asyncio.run_coroutine_threadsafe(
+                    connection_changed(chat_id, net_state),
                     self.loop,
                 ),
             )
@@ -232,6 +340,18 @@ class Start(Scaffold):
                     self.loop,
                 ),
             )
+            self._binding.on_frames(
+                lambda chat_id, mode, device, frames:
+                asyncio.run_coroutine_threadsafe(
+                    stream_frame(
+                        chat_id,
+                        mode,
+                        device,
+                        frames,
+                    ),
+                    self.loop,
+                ),
+            )
             await PyTgCallsSession().start()
         else:
             raise PyTgCallsAlreadyRunning()