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

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,12 +35,16 @@ class GroupCallParticipant(PyObject):
         volume: int,
         joined: bool,
         left: bool,
+        source: int,
+        video_info: Optional[SourceInfo],
+        presentation_info: Optional[SourceInfo],
     ):
         self.user_id: int = user_id
         self.muted: bool = muted
         self.muted_by_admin: bool = muted_by_admin
         self.video: bool = video
         self.screen_sharing: bool = screen_sharing
+        self.source: int = source
         self.video_camera: bool = video_camera
         self.raised_hand: bool = raised_hand
         self.volume: int = volume
@@ -37,3 +54,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/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/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

pytgcalls/types/raw/video_stream.py

@@ -1,17 +1,18 @@
-from ntgcalls import InputMode
+from ntgcalls import MediaSource
 
 from ...statictypes import statictypes
+from ..py_object import PyObject
 from .video_parameters import VideoParameters
 
 
-class VideoStream:
+class VideoStream(PyObject):
     @statictypes
     def __init__(
         self,
-        input_mode: InputMode,
+        media_source: MediaSource,
         path: str,
         parameters: VideoParameters = VideoParameters(),
     ):
-        self.input_mode: InputMode = input_mode
+        self.media_source: MediaSource = media_source
         self.path: str = path
         self.parameters: VideoParameters = parameters

pytgcalls/types/stream/__init__.py

@@ -1,13 +1,23 @@
 from .audio_quality import AudioQuality
+from .device import Device
+from .direction import Direction
+from .external_media import ExternalMedia
+from .frame import Frame
 from .media_stream import MediaStream
-from .stream_audio_ended import StreamAudioEnded
-from .stream_video_ended import StreamVideoEnded
+from .record_stream import RecordStream
+from .stream_ended import StreamEnded
+from .stream_frames import StreamFrames
 from .video_quality import VideoQuality
 
 __all__ = (
     'AudioQuality',
+    'Device',
+    'Direction',
+    'ExternalMedia',
+    'Frame',
     'MediaStream',
-    'StreamAudioEnded',
-    'StreamVideoEnded',
+    'RecordStream',
+    'StreamEnded',
+    'StreamFrames',
     'VideoQuality',
 )

pytgcalls/types/stream/device.py

@@ -0,0 +1,36 @@
+from enum import auto
+
+from ntgcalls import StreamDevice
+
+from ..flag import Flag
+
+
+class Device(Flag):
+    MICROPHONE = auto()
+    SPEAKER = auto()
+    CAMERA = auto()
+    SCREEN = auto()
+
+    @staticmethod
+    def from_raw(device: StreamDevice):
+        if device == StreamDevice.MICROPHONE:
+            return Device.MICROPHONE
+        if device == StreamDevice.SPEAKER:
+            return Device.SPEAKER
+        if device == StreamDevice.CAMERA:
+            return Device.CAMERA
+        if device == StreamDevice.SCREEN:
+            return Device.SCREEN
+        return None
+
+    @staticmethod
+    def to_raw(device: 'Device'):
+        if device == Device.MICROPHONE:
+            return StreamDevice.MICROPHONE
+        if device == Device.SPEAKER:
+            return StreamDevice.SPEAKER
+        if device == Device.CAMERA:
+            return StreamDevice.CAMERA
+        if device == Device.SCREEN:
+            return StreamDevice.SCREEN
+        return None

pytgcalls/types/stream/direction.py

@@ -0,0 +1,25 @@
+from enum import auto
+
+from ntgcalls import StreamMode
+
+from ..flag import Flag
+
+
+class Direction(Flag):
+    OUTGOING = auto()
+    INCOMING = auto()
+
+    @staticmethod
+    def from_raw(direction: StreamMode):
+        if direction == StreamMode.CAPTURE:
+            return Direction.OUTGOING
+        if direction == StreamMode.PLAYBACK:
+            return Direction.INCOMING
+        return None
+
+    def to_raw(self):
+        if self is Direction.OUTGOING:
+            return StreamMode.CAPTURE
+        if self is Direction.INCOMING:
+            return StreamMode.PLAYBACK
+        return None

pytgcalls/types/stream/external_media.py

@@ -0,0 +1,8 @@
+from enum import auto
+
+from ..flag import Flag
+
+
+class ExternalMedia(Flag):
+    AUDIO = auto()
+    VIDEO = auto()

pytgcalls/types/stream/frame.py

@@ -0,0 +1,26 @@
+from ...types.update import PyObject
+
+
+class Frame(PyObject):
+    class Info(PyObject):
+        def __init__(
+            self,
+            capture_time: int = 0,
+            width: int = 0,
+            height: int = 0,
+            rotation: int = 0,
+        ):
+            self.capture_time = capture_time
+            self.width = width
+            self.height = height
+            self.rotation = rotation
+
+    def __init__(
+        self,
+        ssrc: int,
+        frame: bytes,
+        info: Info,
+    ):
+        self.ssrc = ssrc
+        self.frame = frame
+        self.info = info

pytgcalls/types/stream/media_stream.py

@@ -1,10 +1,11 @@
+import logging
 from enum import auto
 from pathlib import Path
 from typing import Dict
 from typing import Optional
 from typing import Union
 
-from ntgcalls import InputMode
+from ntgcalls import MediaSource
 
 from ...exceptions import ImageSourceFound
 from ...exceptions import LiveStreamFound
@@ -12,8 +13,8 @@ from ...exceptions import NoAudioSourceFound
 from ...exceptions import NoVideoSourceFound
 from ...ffmpeg import build_command
 from ...ffmpeg import check_stream
-from ...media_devices import DeviceInfo
-from ...media_devices import ScreenInfo
+from ...media_devices.input_device import InputDevice
+from ...media_devices.screen_device import ScreenDevice
 from ...statictypes import statictypes
 from ...ytdlp import YtDlp
 from ..flag import Flag
@@ -24,6 +25,9 @@ from ..raw.video_parameters import VideoParameters
 from ..raw.video_stream import VideoStream
 from ..stream.audio_quality import AudioQuality
 from ..stream.video_quality import VideoQuality
+from .external_media import ExternalMedia
+
+py_logger = logging.getLogger('pytgcalls')
 
 
 class MediaStream(Stream):
@@ -31,12 +35,11 @@ class MediaStream(Stream):
         AUTO_DETECT = auto()
         REQUIRED = auto()
         IGNORE = auto()
-        NO_LATENCY = auto()
 
     @statictypes
     def __init__(
         self,
-        media_path: Union[str, Path, ScreenInfo, DeviceInfo],
+        media_path: Union[str, Path, InputDevice, ExternalMedia],
         audio_parameters: Union[
             AudioParameters,
             AudioQuality,
@@ -44,8 +47,13 @@ class MediaStream(Stream):
         video_parameters: Union[
             VideoParameters,
             VideoQuality,
-        ] = VideoQuality.SD_480p,
-        audio_path: Optional[Union[str, Path, DeviceInfo]] = None,
+        ] = VideoQuality.HD_720p,
+        audio_path: Optional[
+            Union[
+                str, Path,
+                InputDevice, ExternalMedia,
+            ]
+        ] = None,
         audio_flags: Optional[Flags] = Flags.AUTO_DETECT,
         video_flags: Optional[Flags] = Flags.AUTO_DETECT,
         headers: Optional[Dict[str, str]] = None,
@@ -69,35 +77,74 @@ class MediaStream(Stream):
 
         self._media_path: Optional[str] = None
         self._audio_path: Optional[str] = None
+        self._is_media_device: bool = False
+        self._is_audio_device: bool = False
+        self._is_audio_external: bool = False
+        self._is_video_external: bool = False
         if isinstance(media_path, str):
             self._media_path = media_path
         elif isinstance(media_path, Path):
             self._media_path = str(media_path)
-        elif isinstance(media_path, DeviceInfo):
-            self._media_path = media_path.build_ffmpeg_command()
-        elif isinstance(media_path, ScreenInfo):
-            self._media_path = media_path.build_ffmpeg_command(
-                self._video_parameters.frame_rate,
-            )
+        elif isinstance(media_path, ExternalMedia):
+            if media_path & ExternalMedia.AUDIO:
+                self._is_audio_external = True
+            if media_path & ExternalMedia.VIDEO:
+                self._is_video_external = True
+        elif isinstance(media_path, (InputDevice, ScreenDevice)):
+            if media_path.is_video:
+                self._media_path = media_path.metadata
+                self._is_media_device = True
+            else:
+                self._audio_path = media_path.metadata
+                self._is_audio_device = True
 
         if isinstance(audio_path, str):
             self._audio_path = audio_path
         elif isinstance(audio_path, Path):
             self._audio_path = str(audio_path)
-        elif isinstance(audio_path, DeviceInfo):
-            self._audio_path = audio_path.build_ffmpeg_command()
+        elif isinstance(audio_path, ExternalMedia):
+            self._audio_path = ''
+            if audio_path == ExternalMedia.AUDIO:
+                if self._is_audio_external:
+                    py_logger.warning(
+                        'Audio path is already an audio source, '
+                        'ignoring audio path',
+                    )
+                self._is_audio_external = True
+            else:
+                raise ValueError('Audio path must be an audio source')
+        elif isinstance(audio_path, (InputDevice, ScreenDevice)):
+            if audio_path.is_video:
+                raise ValueError('Audio path must be an audio device')
+            self._audio_path = audio_path.metadata
+            self._is_audio_device = True
 
         self._audio_flags = self._filter_flags(audio_flags)
         self._video_flags = self._filter_flags(video_flags)
         self._ffmpeg_parameters = ffmpeg_parameters
         self._ytdlp_parameters = ytdlp_parameters
         self._headers = headers
-
         super().__init__(
-            stream_audio=None
-            if self._audio_flags & MediaStream.Flags.IGNORE else
+            microphone=None
+            if (
+                self._audio_flags & MediaStream.Flags.IGNORE or
+                self._media_path is None and
+                self._audio_path is None
+            ) and not self._is_audio_external else
+            AudioStream(
+                MediaSource.DEVICE,
+                self._audio_path,
+                self._audio_parameters,
+            )
+            if self._is_audio_device else
             AudioStream(
-                self._flags(self._audio_flags),
+                MediaSource.EXTERNAL,
+                '',
+                self._audio_parameters,
+            )
+            if self._is_audio_external else
+            AudioStream(
+                MediaSource.SHELL,
                 ' '.join(
                     build_command(
                         'ffmpeg',
@@ -111,10 +158,26 @@ class MediaStream(Stream):
                 ),
                 self._audio_parameters,
             ),
-            stream_video=None
-            if self._video_flags & MediaStream.Flags.IGNORE else
+            camera=None
+            if (
+                self._video_flags & MediaStream.Flags.IGNORE or
+                self._media_path is None
+            ) and not self._is_video_external else
+            VideoStream(
+                MediaSource.DESKTOP if isinstance(media_path, ScreenDevice)
+                else MediaSource.DEVICE,
+                self._media_path,
+                self._video_parameters,
+            )
+            if self._is_media_device else
             VideoStream(
-                self._flags(self._video_flags),
+                MediaSource.EXTERNAL,
+                '',
+                self._video_parameters,
+            )
+            if self._is_video_external else
+            VideoStream(
+                MediaSource.SHELL,
                 ' '.join(
                     build_command(
                         'ffmpeg',
@@ -131,92 +194,107 @@ class MediaStream(Stream):
         )
 
     async def check_stream(self):
-        if not self._video_flags & MediaStream.Flags.IGNORE:
-            if YtDlp.is_valid(self._media_path):
-                links = await YtDlp.extract(
-                    self._media_path,
-                    self._video_parameters,
-                    self._ytdlp_parameters,
-                )
-                self._media_path = links[0]
-                if not self._audio_path:
-                    self._audio_path = links[1]
-            try:
-                image_commands = []
-                live_stream = False
-                try:
-                    await check_stream(
-                        self._ffmpeg_parameters,
+        if not self._video_flags & MediaStream.Flags.IGNORE and \
+                not self._is_video_external:
+            if self._is_media_device:
+                if not self._media_path:
+                    self.camera = None
+            elif self._media_path:
+                if YtDlp.is_valid(self._media_path):
+                    links = await YtDlp.extract(
                         self._media_path,
                         self._video_parameters,
-                        [],
-                        self._headers,
+                        self._ytdlp_parameters,
                     )
-                except ImageSourceFound:
-                    image_commands = [
-                        '-loop',
-                        '1',
-                        '-framerate',
-                        '1',
-                    ]
-                except LiveStreamFound:
-                    live_stream = True
-                self.stream_video.path = ' '.join(
-                    build_command(
-                        'ffmpeg',
-                        self._ffmpeg_parameters,
-                        self._media_path,
-                        self._video_parameters,
-                        image_commands,
-                        self._headers,
-                        live_stream,
-                    ),
-                )
-            except NoVideoSourceFound as e:
-                if self._video_flags & MediaStream.Flags.REQUIRED:
-                    raise e
-                self.stream_video = None
+                    self._media_path = links[0]
+                    if not self._audio_path:
+                        self._audio_path = links[1]
+                try:
+                    image_commands = []
+                    live_stream = False
+                    try:
+                        await check_stream(
+                            self._ffmpeg_parameters,
+                            self._media_path,
+                            self._video_parameters,
+                            [],
+                            self._headers,
+                        )
+                    except ImageSourceFound:
+                        image_commands = [
+                            '-loop',
+                            '1',
+                            '-framerate',
+                            '1',
+                        ]
+                    except LiveStreamFound:
+                        live_stream = True
+                    self.camera.path = ' '.join(
+                        build_command(
+                            'ffmpeg',
+                            self._ffmpeg_parameters,
+                            self._media_path,
+                            self._video_parameters,
+                            image_commands,
+                            self._headers,
+                            live_stream,
+                        ),
+                    )
+                except NoVideoSourceFound as e:
+                    if self._video_flags & MediaStream.Flags.REQUIRED:
+                        raise e
+                    self.camera = None
+            else:
+                self.camera = None
 
-        self._audio_path = self._audio_path \
-            if self._audio_path else self._media_path
+        if not self._is_media_device:
+            self._audio_path = self._audio_path \
+                if self._audio_path else self._media_path
 
-        if not self._audio_flags & MediaStream.Flags.IGNORE:
-            if YtDlp.is_valid(self._audio_path):
-                self._audio_path = (
-                    await YtDlp.extract(
-                        self._audio_path,
-                        self._video_parameters,
-                        self._ytdlp_parameters,
-                    )
-                )[1]
+        if not self._audio_flags & MediaStream.Flags.IGNORE and \
+                not self._is_audio_external:
+            if self._is_audio_device:
+                if not self._audio_path:
+                    self.microphone = None
+            elif self._audio_path:
+                if YtDlp.is_valid(self._audio_path):
+                    self._audio_path = (
+                        await YtDlp.extract(
+                            self._audio_path,
+                            self._video_parameters,
+                            self._ytdlp_parameters,
+                        )
+                    )[1]
 
-            try:
-                live_stream = False
                 try:
-                    await check_stream(
-                        self._ffmpeg_parameters,
-                        self._audio_path,
-                        self._audio_parameters,
-                        [],
-                        self._headers,
+                    live_stream = False
+                    try:
+                        await check_stream(
+                            self._ffmpeg_parameters,
+                            self._audio_path,
+                            self._audio_parameters,
+                            [],
+                            self._headers,
+                        )
+                    except LiveStreamFound:
+                        live_stream = True
+                    self.microphone.path = ' '.join(
+                        build_command(
+                            'ffmpeg',
+                            self._ffmpeg_parameters,
+                            self._audio_path,
+                            self._audio_parameters,
+                            [],
+                            self._headers,
+                            live_stream,
+                        ),
                     )
-                except LiveStreamFound:
-                    live_stream = True
-                self.stream_audio.path = ' '.join(
-                    build_command(
-                        'ffmpeg',
-                        self._ffmpeg_parameters,
-                        self._audio_path,
-                        self._audio_parameters,
-                        [],
-                        self._headers,
-                        live_stream,
-                    ),
-                )
-            except NoAudioSourceFound as e:
-                if self._audio_flags & MediaStream.Flags.REQUIRED:
-                    raise e
-                self.stream_audio = None
+                except NoAudioSourceFound as e:
+                    if self._audio_flags & MediaStream.Flags.REQUIRED:
+                        raise e
+                    self.microphone = None
+            else:
+                self.microphone = None
 
     @staticmethod
     def _filter_flags(flags: Optional[Flags]) -> Flags:
@@ -236,10 +314,3 @@ class MediaStream(Stream):
             key=lambda flag: flag.value,
         )
         return flags & ~combined_flags_value | potential_flag
-
-    @staticmethod
-    def _flags(flags: Flags) -> InputMode:
-        new_flags = InputMode.SHELL
-        if flags & MediaStream.Flags.NO_LATENCY:
-            new_flags |= InputMode.NO_LATENCY
-        return new_flags