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

pytgcalls/methods/utilities/stream_params.py

@@ -1,42 +1,89 @@
+from pathlib import Path
 from typing import Optional
+from typing import Union
 
 from ntgcalls import AudioDescription
 from ntgcalls import MediaDescription
 from ntgcalls import VideoDescription
 
-from ...types.raw.stream import Stream
+from ...media_devices.input_device import InputDevice
+from ...media_devices.speaker_device import SpeakerDevice
+from ...types import RecordStream
+from ...types.raw import AudioStream
+from ...types.raw import Stream
+from ...types.raw import VideoStream
 from ...types.stream.media_stream import MediaStream
 
 
 class StreamParams:
     @staticmethod
-    async def get_stream_params(stream: Optional[Stream]) -> MediaDescription:
-        audio_description = None
-        video_description = None
-
+    async def get_stream_params(
+        stream: Optional[Union[str, Path, InputDevice, Stream]],
+    ) -> MediaDescription:
         if stream is not None:
+            if isinstance(stream, (str, Path, InputDevice)):
+                stream = MediaStream(stream)
             if isinstance(stream, MediaStream):
                 await stream.check_stream()
-
-            if stream.stream_audio is not None:
-                audio_description = AudioDescription(
-                    input_mode=stream.stream_audio.input_mode,
-                    input=stream.stream_audio.path,
-                    sample_rate=stream.stream_audio.parameters.bitrate,
-                    bits_per_sample=16,
-                    channel_count=stream.stream_audio.parameters.channels,
+            elif isinstance(stream, RecordStream):
+                raise ValueError(
+                    'Stream should be an instance of '
+                    'MediaStream or a raw Stream',
                 )
 
-            if stream.stream_video is not None:
-                video_description = VideoDescription(
-                    input_mode=stream.stream_video.input_mode,
-                    input=stream.stream_video.path,
-                    width=stream.stream_video.parameters.width,
-                    height=stream.stream_video.parameters.height,
-                    fps=stream.stream_video.parameters.frame_rate,
+        return StreamParams._parse_stream_description(stream)
+
+    @staticmethod
+    def _parse_media_description(
+        media: Optional[Union[AudioStream, VideoStream]],
+    ) -> Optional[Union[AudioDescription, VideoDescription]]:
+        if media is not None:
+            if isinstance(media, AudioStream):
+                return AudioDescription(
+                    media_source=media.media_source,
+                    input=media.path,
+                    sample_rate=media.parameters.bitrate,
+                    channel_count=media.parameters.channels,
+                )
+            elif isinstance(media, VideoStream):
+                return VideoDescription(
+                    media_source=media.media_source,
+                    input=media.path,
+                    width=media.parameters.width,
+                    height=media.parameters.height,
+                    fps=media.parameters.frame_rate,
                 )
+        return None
 
+    @staticmethod
+    def _parse_stream_description(
+        stream: Optional[Stream],
+    ) -> MediaDescription:
         return MediaDescription(
-            audio=audio_description,
-            video=video_description,
+            microphone=StreamParams._parse_media_description(
+                None if stream is None else stream.microphone,
+            ),
+            speaker=StreamParams._parse_media_description(
+                None if stream is None else stream.speaker,
+            ),
+            camera=StreamParams._parse_media_description(
+                None if stream is None else stream.camera,
+            ),
+            screen=StreamParams._parse_media_description(
+                None if stream is None else stream.screen,
+            ),
         )
+
+    @staticmethod
+    async def get_record_params(
+        stream: Optional[Union[str, Path, Stream, SpeakerDevice]],
+    ) -> MediaDescription:
+        if stream is not None:
+            if isinstance(stream, (str, Path, SpeakerDevice)):
+                stream = RecordStream(stream)
+            if isinstance(stream, MediaStream):
+                raise ValueError(
+                    'Stream should be an instance of '
+                    'RecordStream or a raw Stream',
+                )
+        return StreamParams._parse_stream_description(stream)  # type: ignore

pytgcalls/methods/utilities/update_sources.py

@@ -0,0 +1,42 @@
+from typing import Union
+
+from ...mtproto import BridgedClient
+from ...scaffold import Scaffold
+from ...types.calls import CallSources
+
+
+class UpdateSources(Scaffold):
+    async def _update_sources(
+        self,
+        chat_id: Union[int, str],
+    ):
+        participants = await self._app.get_group_call_participants(
+            chat_id,
+        )
+        if chat_id not in self._call_sources:
+            self._call_sources[chat_id] = CallSources()
+        for x in participants:
+            if x.video_info is not None and \
+                    x.user_id not in self._call_sources[chat_id].camera:
+                self._call_sources[chat_id].camera[
+                    x.user_id
+                ] = x.video_info.endpoint
+                await self._binding.add_incoming_video(
+                    chat_id,
+                    x.video_info.endpoint,
+                    x.video_info.sources,
+                )
+            if x.presentation_info is not None and \
+                    x.user_id not in self._call_sources[chat_id].presentation:
+                self._call_sources[chat_id].presentation[
+                    x.user_id
+                ] = x.presentation_info.endpoint
+                await self._binding.add_incoming_video(
+                    chat_id,
+                    x.presentation_info.endpoint,
+                    x.presentation_info.sources,
+                )
+            if x.user_id == BridgedClient.chat_id(
+                self._cache_local_peer,
+            ) and x.muted_by_admin:
+                self._need_unmute.add(chat_id)

pytgcalls/mtproto/bridged_client.py

@@ -6,6 +6,7 @@ from typing import Optional
 
 from ntgcalls import Protocol
 from ntgcalls import RTCServer
+from ntgcalls import SsrcGroup
 
 from ..handlers import HandlersHolder
 from ..types import GroupCallParticipant
@@ -29,6 +30,19 @@ class BridgedClient(HandlersHolder):
     ):
         pass
 
+    async def join_presentation(
+        self,
+        chat_id: int,
+        json_join: str,
+    ):
+        pass
+
+    async def leave_presentation(
+        self,
+        chat_id: int,
+    ):
+        pass
+
     async def request_call(
         self,
         user_id: int,
@@ -64,6 +78,7 @@ class BridgedClient(HandlersHolder):
     async def discard_call(
         self,
         chat_id: int,
+        is_missed: bool,
     ):
         pass
 
@@ -97,8 +112,9 @@ class BridgedClient(HandlersHolder):
         self,
         chat_id: int,
         muted_status: Optional[bool],
-        paused_status: Optional[bool],
-        stopped_status: Optional[bool],
+        video_paused: Optional[bool],
+        video_stopped: Optional[bool],
+        presentation_paused: Optional[bool],
         participant: Any,
     ):
         pass
@@ -128,6 +144,21 @@ class BridgedClient(HandlersHolder):
     def package_name(obj):
         return str(obj.__class__.__module__).split('.')[0]
 
+    @staticmethod
+    def parse_source(source) -> Optional[GroupCallParticipant.SourceInfo]:
+        if not source:
+            return None
+        return GroupCallParticipant.SourceInfo(
+            source.endpoint,
+            [
+                SsrcGroup(
+                    source_group.semantics,
+                    [(ssrc & 0xFFFFFFFF) for ssrc in source_group.sources],
+                )
+                for source_group in source.source_groups
+            ],
+        )
+
     @staticmethod
     def parse_participant(participant):
         return GroupCallParticipant(
@@ -143,6 +174,9 @@ class BridgedClient(HandlersHolder):
             if participant.volume is not None else 100,
             bool(participant.just_joined),
             bool(participant.left),
+            participant.source,
+            BridgedClient.parse_source(participant.video),
+            BridgedClient.parse_source(participant.presentation),
         )
 
     @staticmethod

pytgcalls/mtproto/client_cache.py

@@ -46,23 +46,52 @@ class ClientCache:
                 pass
         return None
 
-    def set_participants_cache(
+    def set_participants_cache_call(
         self,
         input_id: int,
         participant: GroupCallParticipant,
     ) -> Optional[GroupCallParticipant]:
         chat_id = self.get_chat_id(input_id)
         if chat_id is not None:
-            participants: Optional[
-                ParticipantList
-            ] = self._call_participants_cache.get(
+            return self._internal_set_participants_cache(
                 chat_id,
+                participant,
             )
-            if participants is not None:
-                participants.last_mtproto_update = (
-                    int(time()) + self._cache_duration
-                )
-                return participants.update_participant(participant)
+        return None
+
+    def set_participants_cache_chat(
+        self,
+        chat_id: int,
+        call_id: int,
+        participant: GroupCallParticipant,
+    ) -> Optional[GroupCallParticipant]:
+        if self._call_participants_cache.get(chat_id) is None:
+            self._call_participants_cache.put(
+                chat_id,
+                ParticipantList(
+                    call_id,
+                ),
+            )
+        return self._internal_set_participants_cache(
+            chat_id,
+            participant,
+        )
+
+    def _internal_set_participants_cache(
+        self,
+        chat_id: int,
+        participant: GroupCallParticipant,
+    ) -> Optional[GroupCallParticipant]:
+        participants: Optional[
+            ParticipantList
+        ] = self._call_participants_cache.get(
+            chat_id,
+        )
+        if participants is not None:
+            participants.last_mtproto_update = (
+                int(time()) + self._cache_duration
+            )
+            return participants.update_participant(participant)
         return None
 
     async def get_participant_list(
@@ -90,7 +119,7 @@ class ClientCache:
                             input_call,
                         )
                         for participant in list_participants:
-                            self.set_participants_cache(
+                            self.set_participants_cache_call(
                                 input_call.id,
                                 participant,
                             )
@@ -122,12 +151,13 @@ class ClientCache:
             input_call,
             self._cache_duration,
         )
-        self._call_participants_cache.put(
-            chat_id,
-            ParticipantList(
-                input_call.id,
-            ),
-        )
+        if self._call_participants_cache.get(chat_id) is None:
+            self._call_participants_cache.put(
+                chat_id,
+                ParticipantList(
+                    input_call.id,
+                ),
+            )
 
     def drop_cache(
         self,

pytgcalls/mtproto/hydrogram_client.py

@@ -19,7 +19,9 @@ from hydrogram.raw.functions.phone import EditGroupCallParticipant
 from hydrogram.raw.functions.phone import GetGroupCall
 from hydrogram.raw.functions.phone import GetGroupParticipants
 from hydrogram.raw.functions.phone import JoinGroupCall
+from hydrogram.raw.functions.phone import JoinGroupCallPresentation
 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.types import Channel
@@ -41,6 +43,7 @@ from hydrogram.raw.types import PhoneCall
 from hydrogram.raw.types import PhoneCallAccepted
 from hydrogram.raw.types import PhoneCallDiscarded
 from hydrogram.raw.types import PhoneCallDiscardReasonHangup
+from hydrogram.raw.types import PhoneCallDiscardReasonMissed
 from hydrogram.raw.types import PhoneCallProtocol
 from hydrogram.raw.types import PhoneCallRequested
 from hydrogram.raw.types import PhoneCallWaiting
@@ -86,7 +89,7 @@ class HydrogramClient(BridgedClient):
             ):
                 user_id = self._cache.get_user_id(update.phone_call_id)
                 if user_id is not None:
-                    await self.propagate(
+                    await self._propagate(
                         RawCallUpdate(
                             user_id,
                             RawCallUpdate.Type.SIGNALING_DATA,
@@ -110,7 +113,7 @@ class HydrogramClient(BridgedClient):
                         ),
                     )
                 if isinstance(update.phone_call, PhoneCallAccepted):
-                    await self.propagate(
+                    await self._propagate(
                         RawCallUpdate(
                             self.user_from_call(update.phone_call),
                             RawCallUpdate.Type.ACCEPTED,
@@ -126,14 +129,14 @@ class HydrogramClient(BridgedClient):
                         self._cache.drop_phone_call(
                             user_id,
                         )
-                        await self.propagate(
+                        await self._propagate(
                             ChatUpdate(
                                 user_id,
                                 ChatUpdate.Status.DISCARDED_CALL,
                             ),
                         )
                 if isinstance(update.phone_call, PhoneCallRequested):
-                    await self.propagate(
+                    await self._propagate(
                         RawCallUpdate(
                             self.user_from_call(update.phone_call),
                             RawCallUpdate.Type.REQUESTED,
@@ -144,7 +147,7 @@ class HydrogramClient(BridgedClient):
                         ),
                     )
                 if isinstance(update.phone_call, PhoneCall):
-                    await self.propagate(
+                    await self._propagate(
                         RawCallUpdate(
                             self.user_from_call(update.phone_call),
                             RawCallUpdate.Type.CONFIRMED,
@@ -166,12 +169,12 @@ class HydrogramClient(BridgedClient):
             ):
                 participants = update.participants
                 for participant in participants:
-                    result = self._cache.set_participants_cache(
+                    result = self._cache.set_participants_cache_call(
                         update.call.id,
                         self.parse_participant(participant),
                     )
                     if result is not None:
-                        await self.propagate(
+                        await self._propagate(
                             UpdatedGroupCallParticipant(
                                 self._cache.get_chat_id(update.call.id),
                                 result,
@@ -199,7 +202,7 @@ class HydrogramClient(BridgedClient):
                     GroupCallDiscarded,
                 ):
                     self._cache.drop_cache(chat_id)
-                    await self.propagate(
+                    await self._propagate(
                         ChatUpdate(
                             chat_id,
                             ChatUpdate.Status.CLOSED_VOICE_CHAT,
@@ -216,7 +219,7 @@ class HydrogramClient(BridgedClient):
                         ChannelForbidden,
                     ):
                         self._cache.drop_cache(chat_id)
-                        await self.propagate(
+                        await self._propagate(
                             ChatUpdate(
                                 chat_id,
                                 ChatUpdate.Status.KICKED,
@@ -239,7 +242,7 @@ class HydrogramClient(BridgedClient):
                             update.message.peer_id,
                             PeerChat,
                         ):
-                            await self.propagate(
+                            await self._propagate(
                                 ChatUpdate(
                                     chat_id,
                                     ChatUpdate.Status.INVITED_VOICE_CHAT,
@@ -259,7 +262,7 @@ class HydrogramClient(BridgedClient):
                                 ChatForbidden,
                             ):
                                 self._cache.drop_cache(chat_id)
-                                await self.propagate(
+                                await self._propagate(
                                     ChatUpdate(
                                         chat_id,
                                         ChatUpdate.Status.KICKED,
@@ -287,7 +290,7 @@ class HydrogramClient(BridgedClient):
                                     self._cache.drop_cache(
                                         chat_id,
                                     )
-                                    await self.propagate(
+                                    await self._propagate(
                                         ChatUpdate(
                                             chat_id,
                                             ChatUpdate.Status.LEFT_GROUP,
@@ -319,15 +322,22 @@ class HydrogramClient(BridgedClient):
             ).full_chat.call
 
         if input_call is not None:
-            call: GroupCall = (
+            raw_call = (
                 await self._app.invoke(
                     GetGroupCall(
                         call=input_call,
                         limit=-1,
                     ),
                 )
-            ).call
-
+            )
+            call: GroupCall = raw_call.call
+            participants: List[GroupCallParticipant] = raw_call.participants
+            for participant in participants:
+                self._cache.set_participants_cache_chat(
+                    chat_id,
+                    call.id,
+                    self.parse_participant(participant),
+                )
             if call.schedule_date is not None:
                 return None
 
@@ -395,12 +405,12 @@ class HydrogramClient(BridgedClient):
             )
             for update in result.updates:
                 if isinstance(
-                        update,
-                        UpdateGroupCallParticipants,
+                    update,
+                    UpdateGroupCallParticipants,
                 ):
                     participants = update.participants
                     for participant in participants:
-                        self._cache.set_participants_cache(
+                        self._cache.set_participants_cache_call(
                             update.call.id,
                             self.parse_participant(participant),
                         )
@@ -409,6 +419,37 @@ class HydrogramClient(BridgedClient):
 
         return json.dumps({'transport': None})
 
+    async def join_presentation(
+        self,
+        chat_id: int,
+        json_join: str,
+    ):
+        chat_call = await self._cache.get_full_chat(chat_id)
+        if chat_call is not None:
+            result: Updates = await self._app.invoke(
+                JoinGroupCallPresentation(
+                    call=chat_call,
+                    params=DataJSON(data=json_join),
+                ),
+            )
+            for update in result.updates:
+                if isinstance(update, UpdateGroupCallConnection):
+                    return update.params.data
+
+        return json.dumps({'transport': None})
+
+    async def leave_presentation(
+        self,
+        chat_id: int,
+    ):
+        chat_call = await self._cache.get_full_chat(chat_id)
+        if chat_call is not None:
+            await self._app.invoke(
+                LeaveGroupCallPresentation(
+                    call=chat_call,
+                ),
+            )
+
     async def request_call(
         self,
         user_id: int,
@@ -518,15 +559,21 @@ class HydrogramClient(BridgedClient):
     async def discard_call(
         self,
         chat_id: int,
+        is_missed: bool,
     ):
         peer = self._cache.get_phone_call(chat_id)
         if peer is None:
             return
+        reason = (
+            PhoneCallDiscardReasonMissed()
+            if is_missed
+            else PhoneCallDiscardReasonHangup()
+        )
         await self._app.invoke(
             DiscardCall(
                 peer=peer,
                 duration=0,
-                reason=PhoneCallDiscardReasonHangup(),
+                reason=reason,
                 connection_id=0,
                 video=False,
             ),
@@ -554,8 +601,9 @@ class HydrogramClient(BridgedClient):
         self,
         chat_id: int,
         muted_status: Optional[bool],
-        paused_status: Optional[bool],
-        stopped_status: Optional[bool],
+        video_paused: Optional[bool],
+        video_stopped: Optional[bool],
+        presentation_paused: Optional[bool],
         participant: InputPeer,
     ):
         chat_call = await self._cache.get_full_chat(chat_id)
@@ -565,8 +613,9 @@ class HydrogramClient(BridgedClient):
                     call=chat_call,
                     participant=participant,
                     muted=muted_status,
-                    video_stopped=stopped_status,
-                    video_paused=paused_status,
+                    video_paused=video_paused,
+                    video_stopped=video_stopped,
+                    presentation_paused=presentation_paused,
                 ),
             )
 

pytgcalls/mtproto/mtproto_client.py

@@ -69,6 +69,30 @@ class MtProtoClient:
         else:
             raise InvalidMTProtoClient()
 
+    async def join_presentation(
+        self,
+        chat_id: int,
+        json_join: str,
+    ):
+        if self._bind_client is not None:
+            return await self._bind_client.join_presentation(
+                chat_id,
+                json_join,
+            )
+        else:
+            raise InvalidMTProtoClient()
+
+    async def leave_presentation(
+        self,
+        chat_id: int,
+    ):
+        if self._bind_client is not None:
+            return await self._bind_client.leave_presentation(
+                chat_id,
+            )
+        else:
+            raise InvalidMTProtoClient()
+
     async def request_call(
         self,
         user_id: int,
@@ -102,10 +126,12 @@ class MtProtoClient:
     async def discard_call(
         self,
         user_id: int,
+        is_missed: bool,
     ):
         if self._bind_client is not None:
             return await self._bind_client.discard_call(
                 user_id,
+                is_missed,
             )
         else:
             raise InvalidMTProtoClient()
@@ -187,16 +213,18 @@ class MtProtoClient:
         self,
         chat_id: int,
         muted_status: Optional[bool],
-        paused_status: Optional[bool],
-        stopped_status: Optional[bool],
+        video_paused: Optional[bool],
+        video_stopped: Optional[bool],
+        presentation_paused: Optional[bool],
         participant: Any,
     ):
         if self._bind_client is not None:
             await self._bind_client.set_call_status(
                 chat_id,
                 muted_status,
-                paused_status,
-                stopped_status,
+                video_paused,
+                video_stopped,
+                presentation_paused,
                 participant,
             )
         else: