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

pytgcalls/mtproto/pyrogram_client.py

@@ -5,9 +5,11 @@ from typing import Optional
 from typing import Union
 
 import pyrogram
+from ntgcalls import MediaSegmentQuality
 from ntgcalls import Protocol
 from pyrogram import Client
 from pyrogram import ContinuePropagation
+from pyrogram.errors import FloodWait
 from pyrogram.raw.base import InputPeer
 from pyrogram.raw.base import InputUser
 from pyrogram.raw.functions.channels import GetFullChannel
@@ -19,6 +21,7 @@ from pyrogram.raw.functions.phone import CreateGroupCall
 from pyrogram.raw.functions.phone import DiscardCall
 from pyrogram.raw.functions.phone import EditGroupCallParticipant
 from pyrogram.raw.functions.phone import GetGroupCall
+from pyrogram.raw.functions.phone import GetGroupCallStreamChannels
 from pyrogram.raw.functions.phone import GetGroupParticipants
 from pyrogram.raw.functions.phone import JoinGroupCall
 from pyrogram.raw.functions.phone import JoinGroupCallPresentation
@@ -26,6 +29,7 @@ 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.functions.upload import GetFile
 from pyrogram.raw.types import Channel
 from pyrogram.raw.types import ChannelForbidden
 from pyrogram.raw.types import Chat
@@ -35,6 +39,7 @@ from pyrogram.raw.types import GroupCall
 from pyrogram.raw.types import GroupCallDiscarded
 from pyrogram.raw.types import InputChannel
 from pyrogram.raw.types import InputGroupCall
+from pyrogram.raw.types import InputGroupCallStream
 from pyrogram.raw.types import InputPeerChannel
 from pyrogram.raw.types import InputPhoneCall
 from pyrogram.raw.types import MessageActionChatDeleteUser
@@ -44,6 +49,7 @@ from pyrogram.raw.types import PeerChat
 from pyrogram.raw.types import PhoneCall
 from pyrogram.raw.types import PhoneCallAccepted
 from pyrogram.raw.types import PhoneCallDiscarded
+from pyrogram.raw.types import PhoneCallDiscardReasonBusy
 from pyrogram.raw.types import PhoneCallDiscardReasonHangup
 from pyrogram.raw.types import PhoneCallDiscardReasonMissed
 from pyrogram.raw.types import PhoneCallProtocol
@@ -137,10 +143,16 @@ class PyrogramClient(BridgedClient):
                         self._cache.drop_phone_call(
                             user_id,
                         )
+                        reason = ChatUpdate.Status.DISCARDED_CALL
+                        if isinstance(
+                            update.phone_call.reason,
+                            PhoneCallDiscardReasonBusy,
+                        ):
+                            reason |= ChatUpdate.Status.BUSY_CALL
                         await self._propagate(
                             ChatUpdate(
                                 user_id,
-                                ChatUpdate.Status.DISCARDED_CALL,
+                                reason,
                             ),
                         )
                 if isinstance(update.phone_call, PhoneCallRequested):
@@ -396,7 +408,7 @@ class PyrogramClient(BridgedClient):
         chat_id: int,
         json_join: str,
         invite_hash: str,
-        have_video: bool,
+        video_stopped: bool,
         join_as: InputPeer,
     ) -> str:
         chat_call = await self._cache.get_full_chat(chat_id)
@@ -407,7 +419,7 @@ class PyrogramClient(BridgedClient):
                     params=DataJSON(data=json_join),
                     muted=False,
                     join_as=join_as,
-                    video_stopped=have_video,
+                    video_stopped=video_stopped,
                     invite_hash=invite_hash,
                 ),
             )
@@ -463,14 +475,22 @@ class PyrogramClient(BridgedClient):
         user_id: int,
         g_a_hash: bytes,
         protocol: Protocol,
+        has_video: bool,
     ):
-        await self._app.invoke(
+        update = await self._app.invoke(
             RequestCall(
                 user_id=await self.resolve_peer(user_id),
                 random_id=self.rnd_id(),
                 g_a_hash=g_a_hash,
                 protocol=self.parse_protocol(protocol),
-                video=False,
+                video=has_video,
+            ),
+        )
+        self._cache.set_phone_call(
+            user_id,
+            InputPhoneCall(
+                id=update.phone_call.id,
+                access_hash=update.phone_call.access_hash,
             ),
         )
 
@@ -524,8 +544,8 @@ class PyrogramClient(BridgedClient):
         )
 
     async def create_group_call(
-            self,
-            chat_id: int,
+        self,
+        chat_id: int,
     ):
         result: Updates = await self._app.send(
             CreateGroupCall(
@@ -552,8 +572,8 @@ class PyrogramClient(BridgedClient):
                         )
 
     async def leave_group_call(
-            self,
-            chat_id: int,
+        self,
+        chat_id: int,
     ):
         chat_call = await self._cache.get_full_chat(chat_id)
         if chat_call is not None:
@@ -605,6 +625,58 @@ class PyrogramClient(BridgedClient):
                 ),
             )
 
+    async def download_stream(
+        self,
+        chat_id: int,
+        timestamp: int,
+        limit: int,
+        video_channel: Optional[int],
+        video_quality: MediaSegmentQuality,
+    ):
+        chat_call = await self._cache.get_full_chat(chat_id)
+        if chat_call is not None:
+            try:
+                return (
+                    await self._app.send(
+                        GetFile(
+                            location=InputGroupCallStream(
+                                call=chat_call,
+                                time_ms=timestamp,
+                                scale=0,
+                                video_channel=video_channel,
+                                video_quality=BridgedClient.parse_quality(
+                                    video_quality,
+                                ),
+                            ),
+                            offset=0,
+                            limit=limit,
+                        ),
+                        sleep_threshold=0,
+                    )
+                ).bytes
+            except FloodWait:
+                pass
+        return None
+
+    async def get_stream_timestamp(
+        self,
+        chat_id: int,
+    ):
+        chat_call = await self._cache.get_full_chat(chat_id)
+        if chat_call is not None:
+            # noinspection PyBroadException
+            channels = (
+                await self._app.send(
+                    GetGroupCallStreamChannels(
+                        call=chat_call,
+                    ),
+                )
+            ).channels
+            if len(channels) > 0:
+                return channels[0].last_timestamp_ms
+
+        return 0
+
     async def set_call_status(
         self,
         chat_id: int,

pytgcalls/mtproto/telethon_client.py

@@ -3,9 +3,11 @@ from typing import List
 from typing import Optional
 from typing import Union
 
+from ntgcalls import MediaSegmentQuality
 from ntgcalls import Protocol
 from telethon import TelegramClient
 from telethon.errors import ChannelPrivateError
+from telethon.errors import FloodWaitError
 from telethon.events import Raw
 from telethon.tl.functions.channels import GetFullChannelRequest
 from telethon.tl.functions.messages import GetDhConfigRequest
@@ -16,6 +18,7 @@ from telethon.tl.functions.phone import CreateGroupCallRequest
 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 GetGroupCallStreamChannelsRequest
 from telethon.tl.functions.phone import GetGroupParticipantsRequest
 from telethon.tl.functions.phone import JoinGroupCallPresentationRequest
 from telethon.tl.functions.phone import JoinGroupCallRequest
@@ -23,12 +26,14 @@ 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
+from telethon.tl.functions.upload import GetFileRequest
 from telethon.tl.types import ChatForbidden
 from telethon.tl.types import DataJSON
 from telethon.tl.types import GroupCall
 from telethon.tl.types import GroupCallDiscarded
 from telethon.tl.types import InputChannel
 from telethon.tl.types import InputGroupCall
+from telethon.tl.types import InputGroupCallStream
 from telethon.tl.types import InputPeerChannel
 from telethon.tl.types import InputPhoneCall
 from telethon.tl.types import MessageActionChatDeleteUser
@@ -39,6 +44,7 @@ from telethon.tl.types import PeerChat
 from telethon.tl.types import PhoneCall
 from telethon.tl.types import PhoneCallAccepted
 from telethon.tl.types import PhoneCallDiscarded
+from telethon.tl.types import PhoneCallDiscardReasonBusy
 from telethon.tl.types import PhoneCallDiscardReasonHangup
 from telethon.tl.types import PhoneCallDiscardReasonMissed
 from telethon.tl.types import PhoneCallProtocol
@@ -128,10 +134,16 @@ class TelethonClient(BridgedClient):
                         self._cache.drop_phone_call(
                             user_id,
                         )
+                        reason = ChatUpdate.Status.DISCARDED_CALL
+                        if isinstance(
+                            update.phone_call.reason,
+                            PhoneCallDiscardReasonBusy,
+                        ):
+                            reason |= ChatUpdate.Status.BUSY_CALL
                         await self._propagate(
                             ChatUpdate(
                                 user_id,
-                                ChatUpdate.Status.DISCARDED_CALL,
+                                reason,
                             ),
                         )
                 if isinstance(update.phone_call, PhoneCallRequested):
@@ -380,7 +392,7 @@ class TelethonClient(BridgedClient):
         chat_id: int,
         json_join: str,
         invite_hash: str,
-        have_video: bool,
+        video_stopped: bool,
         join_as: TypeInputPeer,
     ) -> str:
         chat_call = await self._cache.get_full_chat(chat_id)
@@ -391,7 +403,7 @@ class TelethonClient(BridgedClient):
                     params=DataJSON(data=json_join),
                     muted=False,
                     join_as=join_as,
-                    video_stopped=have_video,
+                    video_stopped=video_stopped,
                     invite_hash=invite_hash,
                 ),
             )
@@ -447,14 +459,22 @@ class TelethonClient(BridgedClient):
         user_id: int,
         g_a_hash: bytes,
         protocol: Protocol,
+        has_video: bool,
     ):
-        return await self._app(
+        update = await self._app(
             RequestCallRequest(
                 user_id=await self.resolve_peer(user_id),
                 random_id=self.rnd_id(),
                 g_a_hash=g_a_hash,
                 protocol=self.parse_protocol(protocol),
-                video=False,
+                video=has_video,
+            ),
+        )
+        self._cache.set_phone_call(
+            user_id,
+            InputPhoneCall(
+                id=update.phone_call.id,
+                access_hash=update.phone_call.access_hash,
             ),
         )
 
@@ -589,6 +609,58 @@ class TelethonClient(BridgedClient):
                 ),
             )
 
+    async def download_stream(
+        self,
+        chat_id: int,
+        timestamp: int,
+        limit: int,
+        video_channel: Optional[int],
+        video_quality: MediaSegmentQuality,
+    ):
+        chat_call = await self._cache.get_full_chat(chat_id)
+        if chat_call is not None:
+            try:
+                return (
+                    await self._app(
+                        GetFileRequest(
+                            location=InputGroupCallStream(
+                                call=chat_call,
+                                time_ms=timestamp,
+                                scale=0,
+                                video_channel=video_channel,
+                                video_quality=BridgedClient.parse_quality(
+                                    video_quality,
+                                ),
+                            ),
+                            offset=0,
+                            limit=limit,
+                        ),
+                        flood_sleep_threshold=0,
+                    )
+                ).bytes
+            except FloodWaitError:
+                pass
+        return None
+
+    async def get_stream_timestamp(
+        self,
+        chat_id: int,
+    ):
+        chat_call = await self._cache.get_full_chat(chat_id)
+        if chat_call is not None:
+            # noinspection PyBroadException
+            channels = (
+                await self._app(
+                    GetGroupCallStreamChannelsRequest(
+                        call=chat_call,
+                    ),
+                )
+            ).channels
+            if len(channels) > 0:
+                return channels[0].last_timestamp_ms
+
+        return 0
+
     async def set_call_status(
         self,
         chat_id: int,

pytgcalls/mutex.py

@@ -1,10 +1,22 @@
 from functools import wraps
 
+from .wait_counter_lock import WaitCounterLock
+
 
 def mutex(func):
     @wraps(func)
     async def async_wrapper(*args, **kwargs):
         self = args[0]
+        chat_id = await self.resolve_chat_id(args[1])
+        async with self._lock:
+            self._calls_lock[chat_id] = self._calls_lock.get(
+                chat_id,
+            ) or WaitCounterLock()
+        async with self._calls_lock[chat_id]:
+            result = await func(*args, **kwargs)
+
         async with self._lock:
-            return await func(*args, **kwargs)
+            if not self._calls_lock[chat_id].waiters():
+                self._calls_lock.pop(chat_id, None)
+        return result
     return async_wrapper

pytgcalls/pytgcalls.py

@@ -2,6 +2,7 @@ import asyncio
 import os
 from concurrent.futures import ThreadPoolExecutor
 from typing import Any
+from typing import Dict
 
 from ntgcalls import NTgCalls
 
@@ -11,6 +12,7 @@ from .mtproto import MtProtoClient
 from .scaffold import Scaffold
 from .statictypes import statictypes
 from .types import Cache
+from .wait_counter_lock import WaitCounterLock
 
 
 class PyTgCalls(Methods, Scaffold):
@@ -42,6 +44,7 @@ class PyTgCalls(Methods, Scaffold):
         self.loop = asyncio.get_event_loop()
         self.workers = workers
         self._lock = asyncio.Lock()
+        self._calls_lock: Dict[str, WaitCounterLock] = {}
         self.executor = ThreadPoolExecutor(
             self.workers,
             thread_name_prefix='Handler',

pytgcalls/scaffold.py

@@ -1,6 +1,20 @@
+from typing import List
+from typing import Optional
 from typing import Union
 
+from ntgcalls import Frame as RawFrame
+from ntgcalls import MediaDescription
+from ntgcalls import MediaState
+from ntgcalls import NetworkInfo
+from ntgcalls import SegmentPartRequest
+from ntgcalls import StreamDevice
+from ntgcalls import StreamMode
+from ntgcalls import StreamType
+
 from .handlers import HandlersHolder
+from .types import CallConfig
+from .types import GroupCallConfig
+from .types import Update
 
 
 class Scaffold(HandlersHolder):
@@ -25,6 +39,7 @@ class Scaffold(HandlersHolder):
         self._call_sources = dict()
         self._wait_connect = dict()
         self._presentations = set()
+        self._pending_connections = dict()
 
     def _handle_mtproto(self):
         pass
@@ -47,9 +62,73 @@ class Scaffold(HandlersHolder):
     async def _join_presentation(self, chat_id: Union[int, str], join: bool):
         pass
 
+    async def _clear_call(self, chat_id: int):
+        pass
+
+    async def _update_status(self, chat_id: int, state: MediaState):
+        pass
+
+    async def _switch_connection(self, chat_id: int):
+        pass
+
+    async def _handle_stream_ended(
+        self,
+        chat_id: int,
+        stream_type: StreamType,
+        device: StreamDevice,
+    ):
+        pass
+
+    async def _emit_sig_data(self, chat_id: int, data: bytes):
+        pass
+
+    async def _request_broadcast_timestamp(
+        self,
+        chat_id: int,
+    ):
+        pass
+
+    async def _request_broadcast_part(
+        self,
+        chat_id: int,
+        part_request: SegmentPartRequest,
+    ):
+        pass
+
+    async def _handle_stream_frame(
+        self,
+        chat_id: int,
+        mode: StreamMode,
+        device: StreamDevice,
+        frames: List[RawFrame],
+    ):
+        pass
+
+    async def _handle_connection_changed(
+        self,
+        chat_id: int,
+        net_state: NetworkInfo,
+    ):
+        pass
+
+    async def _handle_mtproto_updates(self, update: Update):
+        pass
+
+    async def _connect_call(
+        self,
+        chat_id: int,
+        media_description: MediaDescription,
+        config: Union[CallConfig, GroupCallConfig],
+        payload: Optional[str],
+    ):
+        pass
+
     @staticmethod
     def _log_retries(r: int):
         pass
 
+    def _clear_cache(self, chat_id: int):
+        pass
+
     def on_update(self, filters=None):
         pass

pytgcalls/types/__init__.py

@@ -5,6 +5,7 @@ from .calls import CallConfig
 from .calls import CallData
 from .calls import CallProtocol
 from .calls import GroupCallConfig
+from .calls import PendingConnection
 from .calls import RawCallUpdate
 from .chats import ChatUpdate
 from .chats import GroupCallParticipant
@@ -35,6 +36,7 @@ __all__ = (
     'CallProtocol',
     'CallData',
     'RawCallUpdate',
+    'PendingConnection',
     'GroupCallConfig',
     'GroupCallParticipant',
     'RecordStream',

pytgcalls/types/calls/__init__.py

@@ -4,6 +4,7 @@ from .call_data import CallData
 from .call_protocol import CallProtocol
 from .call_sources import CallSources
 from .group_call_config import GroupCallConfig
+from .pending_connection import PendingConnection
 from .raw_call_update import RawCallUpdate
 
 __all__ = (
@@ -13,5 +14,6 @@ __all__ = (
     'CallProtocol',
     'CallSources',
     'GroupCallConfig',
+    'PendingConnection',
     'RawCallUpdate',
 )

pytgcalls/types/calls/pending_connection.py

@@ -0,0 +1,17 @@
+from ntgcalls import MediaDescription
+
+from .group_call_config import GroupCallConfig
+
+
+class PendingConnection:
+    def __init__(
+        self,
+        media_description: MediaDescription,
+        config: GroupCallConfig,
+        payload: str,
+        presentation: bool,
+    ):
+        self.media_description = media_description
+        self.config = config
+        self.payload = payload
+        self.presentation = presentation

pytgcalls/types/chats/chat_update.py

@@ -13,7 +13,14 @@ class ChatUpdate(Update):
         INVITED_VOICE_CHAT = auto()
         DISCARDED_CALL = auto()
         INCOMING_CALL = auto()
-        LEFT_CALL = KICKED | LEFT_GROUP | CLOSED_VOICE_CHAT | DISCARDED_CALL
+        BUSY_CALL = auto()
+        LEFT_CALL = (
+            KICKED |
+            LEFT_GROUP |
+            CLOSED_VOICE_CHAT |
+            DISCARDED_CALL |
+            BUSY_CALL
+        )
 
     def __init__(
         self,

pytgcalls/types/py_object.py

@@ -13,16 +13,15 @@ class PyObject:
             return repr(obj)
         if isinstance(obj, Enum):
             return repr(obj)
-        if hasattr(obj, '__dict__'):
-            return {
-                '_': obj.__class__.__name__,
-                **{
-                    attr: vars(obj)[attr]
-                    for attr in vars(obj)
-                    if not attr.startswith('_')
-                },
-            }
-        return {}
+        return {
+            '_': obj.__class__.__name__,
+            **{
+                attr: getattr(obj, attr)
+                for attr in dir(obj)
+                if not attr.startswith('_') and
+                not callable(getattr(obj, attr)) and not attr == 'default'
+            },
+        }
 
     def __str__(self) -> str:
         return dumps(

pytgcalls/types/stream/media_stream.py

@@ -47,7 +47,7 @@ class MediaStream(Stream):
         video_parameters: Union[
             VideoParameters,
             VideoQuality,
-        ] = VideoQuality.SD_480p,
+        ] = VideoQuality.HD_720p,
         audio_path: Optional[
             Union[
                 str, Path,

pytgcalls/wait_counter_lock.py

@@ -0,0 +1,20 @@
+import asyncio
+
+
+class WaitCounterLock:
+    def __init__(self):
+        self._lock = asyncio.Lock()
+        self._waiters = 0
+
+    def waiters(self):
+        return self._waiters
+
+    async def __aenter__(self):
+        self._waiters += 1
+        await self._lock.acquire()
+        self._waiters -= 1
+        return self
+
+    async def __aexit__(self, exc_type, exc, tb):
+        if self._lock.locked():
+            self._lock.release()