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

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
@@ -166,7 +168,7 @@ 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),
                     )
@@ -319,15 +321,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 +404,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 +418,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,
@@ -554,8 +594,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 +606,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,
@@ -187,16 +211,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:

pytgcalls/mtproto/pyrogram_client.py

@@ -21,7 +21,9 @@ from pyrogram.raw.functions.phone import EditGroupCallParticipant
 from pyrogram.raw.functions.phone import GetGroupCall
 from pyrogram.raw.functions.phone import GetGroupParticipants
 from pyrogram.raw.functions.phone import JoinGroupCall
+from pyrogram.raw.functions.phone import JoinGroupCallPresentation
 from pyrogram.raw.functions.phone import LeaveGroupCall
+from pyrogram.raw.functions.phone import LeaveGroupCallPresentation
 from pyrogram.raw.functions.phone import RequestCall
 from pyrogram.raw.functions.phone import SendSignalingData
 from pyrogram.raw.types import Channel
@@ -174,7 +176,7 @@ class PyrogramClient(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),
                     )
@@ -327,15 +329,22 @@ class PyrogramClient(BridgedClient):
             ).full_chat.call
 
         if input_call is not None:
-            call: GroupCall = (
+            raw_call = (
                 await self._app.send(
                     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
 
@@ -403,12 +412,12 @@ class PyrogramClient(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),
                         )
@@ -417,6 +426,37 @@ class PyrogramClient(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.send(
+                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.send(
+                LeaveGroupCallPresentation(
+                    call=chat_call,
+                ),
+            )
+
     async def request_call(
         self,
         user_id: int,
@@ -562,8 +602,9 @@ class PyrogramClient(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)
@@ -573,8 +614,9 @@ class PyrogramClient(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/telethon_client.py

@@ -17,7 +17,9 @@ from telethon.tl.functions.phone import DiscardCallRequest
 from telethon.tl.functions.phone import EditGroupCallParticipantRequest
 from telethon.tl.functions.phone import GetGroupCallRequest
 from telethon.tl.functions.phone import GetGroupParticipantsRequest
+from telethon.tl.functions.phone import JoinGroupCallPresentationRequest
 from telethon.tl.functions.phone import JoinGroupCallRequest
+from telethon.tl.functions.phone import LeaveGroupCallPresentationRequest
 from telethon.tl.functions.phone import LeaveGroupCallRequest
 from telethon.tl.functions.phone import RequestCallRequest
 from telethon.tl.functions.phone import SendSignalingDataRequest
@@ -164,7 +166,7 @@ class TelethonClient(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),
                     )
@@ -294,20 +296,27 @@ class TelethonClient(BridgedClient):
                     GetFullChatRequest(chat_id),
                 )
             ).full_chat.call
+
         if input_call is not None:
-            try:
-                call: GroupCall = (
-                    await self._app(
-                        GetGroupCallRequest(
-                            call=input_call,
-                            limit=-1,
-                        ),
-                    )
-                ).call
-                if call.schedule_date is not None:
-                    return None
-            except Exception as e:
-                print(e)
+            raw_call = (
+                await self._app(
+                    GetGroupCallRequest(
+                        call=input_call,
+                        limit=-1,
+                    ),
+                )
+            )
+            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
+
         return input_call
 
     async def get_dhc(self) -> DhConfig:
@@ -377,7 +386,7 @@ class TelethonClient(BridgedClient):
                 ):
                     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),
                         )
@@ -386,6 +395,37 @@ class TelethonClient(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(
+                JoinGroupCallPresentationRequest(
+                    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(
+                LeaveGroupCallPresentationRequest(
+                    call=chat_call,
+                ),
+            )
+
     async def request_call(
         self,
         user_id: int,
@@ -531,8 +571,9 @@ class TelethonClient(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: TypeInputPeer,
     ):
         chat_call = await self._cache.get_full_chat(chat_id)
@@ -542,8 +583,9 @@ class TelethonClient(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/scaffold.py

@@ -22,7 +22,10 @@ class Scaffold(HandlersHolder):
         self.loop = None
         self._need_unmute = set()
         self._p2p_configs = dict()
+        self._videos_id = dict()
+        self._presentations_id = dict()
         self._wait_connect = dict()
+        self._presentations = set()
 
     def _handle_mtproto(self):
         pass
@@ -36,5 +39,8 @@ class Scaffold(HandlersHolder):
     async def start(self):
         pass
 
+    async def play(self, chat_id: Union[int, str], stream=None, config=None):
+        pass
+
     def on_update(self, filters=None):
         pass

pytgcalls/types/__init__.py

@@ -10,14 +10,19 @@ from .chats import ChatUpdate
 from .chats import GroupCallParticipant
 from .chats import UpdatedGroupCallParticipant
 from .stream import AudioQuality
+from .stream import Device
+from .stream import Direction
 from .stream import MediaStream
-from .stream import StreamAudioEnded
-from .stream import StreamVideoEnded
+from .stream import RecordStream
+from .stream import StreamEnded
+from .stream import StreamFrame
 from .stream import VideoQuality
 from .update import Update
 
 __all__ = (
     'AudioQuality',
+    'Device',
+    'Direction',
     'Browsers',
     'Cache',
     'ChatUpdate',
@@ -28,9 +33,10 @@ __all__ = (
     'RawCallUpdate',
     'GroupCallConfig',
     'GroupCallParticipant',
+    'RecordStream',
     'MediaStream',
-    'StreamAudioEnded',
-    'StreamVideoEnded',
+    'StreamEnded',
+    'StreamFrame',
     'Update',
     'UpdatedGroupCallParticipant',
     'VideoQuality',

pytgcalls/types/calls/call.py

@@ -6,7 +6,7 @@ from ..flag import Flag
 
 class Call(PyObject):
     class Status(Flag):
-        PLAYING = auto()
+        ACTIVE = auto()
         PAUSED = auto()
         IDLE = auto()
 
@@ -17,8 +17,10 @@ class Call(PyObject):
     def __init__(
         self,
         chat_id: int,
-        status: Status,
+        playback: Status,
+        capture: Status,
     ):
         self.call_type = Call.Type.GROUP \
             if chat_id < 0 else Call.Type.PRIVATE
-        self.status = status
+        self.playback = playback
+        self.capture = capture

pytgcalls/types/chats/group_call_participant.py

@@ -1,4 +1,8 @@
 from enum import auto
+from typing import List
+from typing import Optional
+
+from ntgcalls import SsrcGroup
 
 from ...types.py_object import PyObject
 from ..flag import Flag
@@ -10,6 +14,15 @@ class GroupCallParticipant(PyObject):
         LEFT = auto()
         UPDATED = auto()
 
+    class SourceInfo(PyObject):
+        def __init__(
+            self,
+            endpoint: str,
+            sources: List[SsrcGroup],
+        ):
+            self.endpoint: str = endpoint
+            self.sources: List[SsrcGroup] = sources
+
     def __init__(
         self,
         user_id: int,
@@ -22,6 +35,8 @@ class GroupCallParticipant(PyObject):
         volume: int,
         joined: bool,
         left: bool,
+        video_info: Optional[SourceInfo],
+        presentation_info: Optional[SourceInfo],
     ):
         self.user_id: int = user_id
         self.muted: bool = muted
@@ -37,3 +52,9 @@ class GroupCallParticipant(PyObject):
             self.action = self.Action.LEFT
         else:
             self.action = self.Action.UPDATED
+        self.video_info: Optional[
+            GroupCallParticipant.SourceInfo
+        ] = video_info
+        self.presentation_info: Optional[
+            GroupCallParticipant.SourceInfo
+        ] = presentation_info

pytgcalls/types/raw/audio_stream.py

@@ -1,4 +1,4 @@
-from ntgcalls import InputMode
+from ntgcalls import MediaSource
 
 from ...statictypes import statictypes
 from ..py_object import PyObject
@@ -9,10 +9,10 @@ class AudioStream(PyObject):
     @statictypes
     def __init__(
         self,
-        input_mode: InputMode,
+        media_source: MediaSource,
         path: str,
         parameters: AudioParameters = AudioParameters(),
     ):
-        self.input_mode: InputMode = input_mode
+        self.media_source: MediaSource = media_source
         self.path: str = path
         self.parameters: AudioParameters = parameters

pytgcalls/types/raw/stream.py

@@ -10,8 +10,12 @@ class Stream(PyObject):
     @statictypes
     def __init__(
         self,
-        stream_audio: Optional[AudioStream] = None,
-        stream_video: Optional[VideoStream] = None,
+        microphone: Optional[AudioStream] = None,
+        speaker: Optional[AudioStream] = None,
+        camera: Optional[VideoStream] = None,
+        screen: Optional[VideoStream] = None,
     ):
-        self.stream_audio: Optional[AudioStream] = stream_audio
-        self.stream_video: Optional[VideoStream] = stream_video
+        self.microphone: Optional[AudioStream] = microphone
+        self.speaker: Optional[AudioStream] = speaker
+        self.camera: Optional[VideoStream] = camera
+        self.screen: Optional[VideoStream] = screen