o
�J�h9W � @ s� d Z ddlZddlZddlmZ ddlZddlmZmZ ddlm Z m
Z
m Z m Z m
Z
mZ ddlmZ ddlmZ ddlmZ dd lmZmZ dd
lmZ dd lmZ dd l m Z dd
l m Z ddl m!Z! e�"e#�Z$G dd� d�Z%dS )a/
This module contains a container for stream manifest data.
A container object for the media stream (video only / audio only / video+audio
combined). This was referred to as ``Video`` in the legacy pytube version, but
has been renamed to accommodate DASH (which serves the audio and video
separately).
� N)�ceil)�datetime�timezone)�BinaryIO�Dict�Optional�Tuple�Iterator�Callable)� HTTPError)�parse_qs)�Path)�extract�request)�target_directory)�get_format_profile)� Monostate)�file_system_verify)�ServerAbrStreamc @ sz e Zd ZdZdedededefdd�Zede fd d
��Z
ede fd d ��Z ede fd
d��Z e j
dd� �Z ede fdd��Zede fdd��Zdeee ee f fdd�Zedefdd��Zedefdd��Zedefdd��Zedefd d ��Zedefd d ��Zedefd d!��Zedefd"d#��Zedefd$d%��Z ede fd&d'��Z edefd(d)��Z * * * + * , *dNd-ee d.ee d/ee d0e d1ee d2ed3ee g e f dee fd4d5�Z! * * * 6dOd.ee d-ee d/ee d7edef
d8d9�Z"d:ede fd;d<�Z#d=e$dd*fd>d?�Z%d@e&dAe$dBefdCdD�Z'd:ee fdEdF�Z(defdGdH�Z)d@e&dBefdIdJ�Z*dPdKee de+e& fdLdM�Z,d*S )Q�Streamz#Container for stream manifest data.�stream� monostate�po_token� video_playback_ustreamer_configc C s� || _ |d | _t|d �| _d|v r|d nd| _t�|d �\| _| _| j� d�\| _
| _ | � � \| _
| _|d | _|d | _t|�d d
��| _ttt|�d d
��d d �d �| _ttt|�d d
��d d d �d �| _ttt|�d d
��d d d d �d �| _t| j�}|d
| _|d | _d|v r�|d | _|d | _ d|v r�|d nd| _ d|v r�|d nd| _ |d | _ |d | _ |d | _!|�dd�| _"|�dd�| _#|d | _$|d | _%|| _&|| _'d|v | _(| j(�r*d |d d v | _)t*|d d ��+d d �| _,| j,� d �d
| _-t*|d d! �� d"�d
| _.| j.� d#�d
| _/dS | j0�o1| j1 | _)d| _,d| _-d| _.d| _/dS )$a Construct a :class:`Stream <Stream>`.
:param dict stream:
The unscrambled data extracted from YouTube.
:param dict monostate:
Dictionary of data shared across all instances of
:class:`Stream <Stream>`.
�url�itag�xtagsN�mimeType�/�is_otf�bitrateZ
contentLengthr � �� �is_dash�abr�fps�
resolution�width�height�is_3d�is_hdr�is_liveZisDrcF�is_sabrZapproxDurationMs� lastModifiedZ
audioTrack�originalZ displayNamez original� � �id�.�-)2�
_monostater �intr r r Zmime_type_codec� mime_type�codecs�split�type�subtype� parse_codecs� video_codec� audio_codecr r �get� _filesize�floatr � _filesize_kb� _filesize_mb� _filesize_gbr r# r$ r% r& �_width�_heightr) r* r+ Zis_drc�_is_sabrZ
durationMsZ
last_Modifiedr r Z includes_multiple_audio_tracksZis_default_audio_track�str�replaceZ audio_track_name_regionalizedZaudio_track_nameZ$audio_track_language_id_regionalizedZaudio_track_language_id�includes_audio_track�includes_video_track)�selfr r r r Z itag_profile� rL �OC:\pinokio\api\whisper-webui.git\app\env\lib\site-packages\pytubefix\streams.py�__init__" s\
�
&*.
�
zStream.__init__�returnc C s t t| j�d �S )z:Whether the stream is DASH.
:rtype: bool
� )�bool�lenr7 �rK rL rL rM � is_adaptivey s zStream.is_adaptivec C s | j S )zAWhether the stream is progressive.
:rtype: bool
)rT rS rL rL rM �is_progressive� s zStream.is_progressivec C � | j S )z:Whether the stream is SABR.
:rtype: bool
�rF rS rL rL rM r, � s zStream.is_sabrc C s
|| _ d S �NrW )rK �valuerL rL rM r, � s
c C � | j p| jdkS )zFWhether the stream only contains audio.
:rtype: bool
�audio�rU r9 rS rL rL rM rI � � zStream.includes_audio_trackc C rZ )zFWhether the stream only contains video.
:rtype: bool
�videor\ rS rL rL rM rJ � r] zStream.includes_video_trackc C sP d}d}| j s| j\}}||fS | jr | jd }||fS | jr$| jd }||fS )a� Get the video/audio codecs from list of codecs.
Parse a variable length sized list of codecs and returns a
constant two element tuple, with the video codec as the first element
and audio as the second. Returns None if one is not available
(adaptive only).
:rtype: tuple
:returns:
A two element tuple with audio and video codecs.
Nr )rT r7 rJ rI )rK r^ r[ rL rL rM r; � s
�
�
zStream.parse_codecsc C rV )z�Video width. Returns None if it does not have the value.
:rtype: int
:returns:
Returns an int of the video width
)rD rS rL rL rM r' � � z Stream.widthc C rV )z�Video height. Returns None if it does not have the value.
:rtype: int
:returns:
Returns an int of the video height
)rE rS rL rL rM r( � r_ z
Stream.heightc
C sj | j dkr2z t�| j�| _ W | j S ty1 } z|jdkr � t�| j�| _ W Y d}~| j S d}~ww | j S )z�File size of the media stream in bytes.
:rtype: int
:returns:
Filesize (in bytes) of the stream.
r � N)r? r �filesizer r �code� seq_filesize�rK �erL rL rM ra � s
�
��zStream.filesizec
C s� | j dkrFzttt�| j�d d �d �| _ W | j S tyE } z |jdkr(� ttt�| j�d d �d �| _ W Y d}~| j S d}~ww | j S )z�File size of the media stream in kilobytes.
:rtype: float
:returns:
Rounded filesize (in kilobytes) of the stream.
r r! r" r` N) rA r@ r r ra r r rb rc rd rL rL rM � filesize_kb� s
$�
,��zStream.filesize_kbc
C s� | j dkrJzttt�| j�d d d �d �| _ W | j S tyI } z!|jdkr*� ttt�| j�d d d �d �| _ W Y d}~| j S d}~ww | j S )z�File size of the media stream in megabytes.
:rtype: float
:returns:
Rounded filesize (in megabytes) of the stream.
r r! r" r` N) rB r@ r r ra r r rb rc rd rL rL rM � filesize_mb� s
(�
0��zStream.filesize_mbc
C s� | j dkrNzttt�| j�d d d d �d �| _ W | j S tyM } z#|jdkr,� ttt�| j�d d d d �d �| _ W Y d}~| j S d}~ww | j S )z�File size of the media stream in gigabytes.
:rtype: float
:returns:
Rounded filesize (in gigabytes) of the stream.
r r! r" r` N) rC r@ r r ra r r rb rc rd rL rL rM � filesize_gb s
,�
4��zStream.filesize_gbc C s | j jpdS )zbGet title of video
:rtype: str
:returns:
Youtube video title
zUnknown YouTube Video Title)r4 �titlerS rL rL rM ri s z Stream.titlec C s. | j jr| jrd}t| j j| j | �S | jS )z�Get approximate filesize of the video
Falls back to HTTP call if there is not sufficient information to approximate
:rtype: int
:returns: size of video in bytes
� )r4 �durationr r5 ra )rK Z bits_in_byterL rL rM �filesize_approx s �zStream.filesize_approxc C s. t | j�d�d �d d }t�t|�tj�S )N�?� �expirer )r r r8 r �
fromtimestampr5 r �utc)rK ro rL rL rM �
expiration1 s zStream.expirationc C s, d| j v r
d| j vr
d| _| j� d| j� �S )z�Generate filename based on the video title.
:rtype: str
:returns:
An os file system compatible filename.
r[ r^ �m4ar2 )r6 r: ri rS rL rL rM �default_filename6 s zStream.default_filenameNTr � output_path�filename�filename_prefix�
skip_existing�timeout� max_retries�interrupt_checkerc sJ t j}|dkr
d} n |dkrd} nd} t| �}
|du r!�j�|
�}|r(|�|
�}�j|||| d�} |rH��| �rHt�d| � d �� �� | � | S �j
} t�d
�j
� d | � �� � �fd d
�}
t | d���� zD�j s�t
j�j||d�D ]%}|dur�|� dkr�t�d� W W d � dS | t|�8 } |
|| � qqnt�d� t�|
�jd��� W nc ty� } z |jdkr�� W Y d}~nPd}~w t�y �j s�t
j�j||d�D ]%}|dur�|� dkr�t�d� Y W d � dS | t|�8 } |
|| � q�nt�d� t�|
�jd��� Y nw �� | � | W d � S 1 �s w Y dS )a�
Downloads a file from the URL provided by `self.url` and saves it locally with optional configurations.
Args:
output_path (Optional[str]): Directory path where the downloaded file will be saved. Defaults to the current directory if not specified.
filename (Optional[str]): Custom name for the downloaded file. If not provided, a default name is used.
filename_prefix (Optional[str]): Prefix to be added to the filename (if provided).
skip_existing (bool): Whether to skip the download if the file already exists at the target location. Defaults to True.
timeout (Optional[int]): Maximum time, in seconds, to wait for the download request. Defaults to None for no timeout.
max_retries (int): The number of times to retry the download if it fails. Defaults to 0 (no retries).
interrupt_checker (Optional[Callable[[], bool]]): A callable function that is checked periodically during the download. If it returns True, the download will stop without errors.
Returns:
Optional[str]: The full file path of the downloaded file, or None if the download was skipped or failed.
Raises:
HTTPError: Raised if there is an error with the HTTP request during the download process.
Note:
- The `skip_existing` flag avoids redownloading if the file already exists in the target location.
- The `interrupt_checker` allows for the download to be halted cleanly if certain conditions are met during the download process.
- Download progress can be monitored using the `on_progress` callback, and the `on_complete` callback is triggered once the download is finished.
�linuxZext4�darwinZAPFS�NTFSN)rv ru rw � file_systemzfile z already exists, skippingz
downloading (z total bytes) file to c s �� | � |� d S rX )� on_progress)�chunk_Zbytes_remaining_��fhrK rL rM � write_chunk� s z$Stream.download.<locals>.write_chunk�wb)ry rz TzFinterrupt_checker returned True, causing to force stop the downloadingz-This stream is SABR. Starting ServerAbrStream)r r� r r` )�sys�platformr rt � translate�
get_file_path�exists_at_path�logger�debug� on_completera �openr, r r r rR r r4 �startr rb �
StopIteration�
seq_stream)rK ru rv rw rx ry rz r{ �kernelr �translation_table� file_path�bytes_remainingr� �chunkre rL r� rM �downloadC s� #
�
�
� �
�
��
�
� ! �
��
&�zStream.downloadr~ r c C sr |s t |�}| j�|�}|r't |�}d| jv r d| jvs"|�|�}n|�|�}|r/|� |� �}ttt|��| �S )Nr[ r^ )r rt r� r6 rG r
r )rK rv ru rw r r� rL rL rM r� � s
zStream.get_file_pathr� c C s t j�|�ot j�|�| jkS rX )�os�path�isfile�getsizera )rK r� rL rL rM r� � s �zStream.exists_at_path�bufferc C sN | j }t�d| j � t�| j�D ]}|t|�8 }| �|||� q| �d� dS )zLWrite the media stream to buffer
:rtype: io.BytesIO buffer
�+downloading (%s total bytes) file to bufferN) ra r� �infor r r rR r� r� )rK r� r� r� rL rL rM �stream_to_buffer� s � zStream.stream_to_bufferr� � file_handlerr� c C s6 |� |� t�d|� | jjr| j�| ||� dS dS )a� On progress callback function.
This function writes the binary data to the file, then checks if an
additional callback is defined in the monostate. This is exposed to
allow things like displaying a progress bar.
:param bytes chunk:
Segment of media file binary data, not yet written to disk.
:param file_handler:
The file handle where the media is being written to.
:type file_handler:
:py:class:`io.BufferedWriter`
:param int bytes_remaining:
The delta between the total file size in bytes and amount already
downloaded.
:rtype: None
�download remaining: %sN)�writer� r� r4 r� )rK r� r� r� rL rL rM r� � s
�zStream.on_progressc C s4 t �d� | jj}|rt �d|� || |� dS dS )z�On download complete handler function.
:param file_path:
The file handle where the media is being written to.
:type file_path: str
:rtype: None
zdownload finishedz calling on_complete callback %sN)r� r� r4 r� )rK r� r� rL rL rM r� s
�zStream.on_completec C sv ddg}| j r |�ddg� | js|�ddg� n|�dg� n|�ddg� |�g d�� d d
�|�j| d �� d �S )
z�Printable object representation.
:rtype: str
:returns:
A string representation of a :class:`Stream <Stream>` object.
zitag="{s.itag}"zmime_type="{s.mime_type}"zres="{s.resolution}"zfps="{s.fps}fps"zvcodec="{s.video_codec}"zacodec="{s.audio_codec}"z
abr="{s.abr}")z progressive="{s.is_progressive}"zsabr="{s.is_sabr}"ztype="{s.type}"z <Stream: r0 )�s�>)rJ �extendrT �join�format)rK �partsrL rL rM �__repr__ s �zStream.__repr__c C s, t �d|� | jjr| j�| ||� dS dS )a� On progress callback function.
This function checks if an additional callback is defined in the monostate.
This is exposed to allow things like displaying a progress bar.
:param bytes chunk:
Segment of media file binary data, not yet written to disk.
:py:class:`io.BufferedWriter`
:param int bytes_remaining:
The delta between the total file size in bytes and amount already
downloaded.
:rtype: None
r� N)r� r� r4 r� )rK r� r� rL rL rM �on_progress_for_chunks% s �z Stream.on_progress_for_chunks�
chunk_sizec
c s� � | j }|r |t_t�d| j � zt�| j�}W n ty6 } z|jdkr&� t� | j�}W Y d}~nd}~ww |D ]}|t
|�8 }| � ||� |V q9| � d� dS )a� Get the chunks directly
Example:
# Write the chunk by yourself
with open("somefile.mp4") as out_file:
out_file.writelines(stream.iter_chunks(512))
# Another way
# for chunk in stream.iter_chunks(512):
# out_file.write(chunk)
# Or give it external api
external_api.write_media(stream.iter_chunks(512))
:param int chunk size:
The size in the bytes
:rtype: Iterator[bytes]
r� r` N)
ra r Zdefault_range_sizer� r� r r r rb r� rR r� r� )rK r� r� r re r� rL rL rM � iter_chunks9 s* ��
�� zStream.iter_chunks)NNNTNr N)NNNr~ rX )-�__name__�
__module__� __qualname__�__doc__r r rG rN �propertyrQ rT rU r, �setterrI rJ r r r; r5 r' r( ra r@ rf rg rh ri rl r rr rt r
r� r� r� r r� �bytesr� r� r� r� r r� rL rL rL rM r s� ���
�W
��������
�t�����
���
� r )&r� �loggingr� �mathr r� r r �typingr r r r r r
� urllib.errorr � urllib.parser �pathlibr
� pytubefixr r Zpytubefix.helpersr Zpytubefix.itagsr Zpytubefix.monostater Zpytubefix.file_systemr Z%pytubefix.sabr.core.server_abr_streamr � getLoggerr� r� r rL rL rL rM �<module> s$