def fill_table(self):
self.itag_list = self.yt.get_itag_list()
self.itag_list.sort()
print(self.itag_list, "before")
for x in self.itag_list:
try:
urllib.request.urlopen(self.yt.streams.get_by_itag(x).url)
# pytube for sometimes gives streams that dont exist, this doesn't allow them through
except:
# self.itag_list.remove(x) - for some reason this doesnt work
print(x, "FAILED!")
continue
else:
if (not (self.yt.streams.get_by_itag(x).parse_codecs()[0] and
self.yt.streams.get_by_itag(x).parse_codecs()[0][0:4]
== "av01")):
# gets rid of av01 codec bc it sucks
print(x, "continuing")
if not (itags.get_format_profile(x)['file_type'] == "webm"
and self.webm == True):
#currently not able to change metadata of webm files, so this gets rid of them
self.items.append(
Item(
x,
itags.get_format_profile(x)['resolution'],
itags.get_format_profile(x)['abr'],
itags.get_format_profile(x)['file_type'],
str(
self.yt.streams.get_by_itag(
x).filesize_approx / 1000000) +
" MB" # sizes are NOT accurate, only estimates
))
print(self.itag_list, "after")
def __init__(self, stream: Dict, player_config_args: Dict, monostate: Monostate):
"""Construct a :class:`Stream <Stream>`.
:param dict stream:
The unscrambled data extracted from YouTube.
:param dict player_config_args:
The data object containing video media data like title and
keywords.
:param dict monostate:
Dictionary of data shared across all instances of
:class:`Stream <Stream>`.
"""
# A dictionary shared between all instances of :class:`Stream <Stream>`
# (Borg pattern).
self._monostate = monostate
self.url = stream["url"] # signed download url
self.itag = int(stream["itag"]) # stream format id (youtube nomenclature)
self.type = stream[
"type"
] # the part of the mime before the slash, overwritten later
self.abr = None # average bitrate (audio streams only)
self.fps = None # frames per second (video streams only)
self.res = None # resolution (e.g.: 480p, 720p, 1080p)
self._filesize: Optional[int] = None # filesize in bytes
self.mime_type = None # content identifier (e.g.: video/mp4)
self.subtype = None # the part of the mime after the slash
self.codecs: List[str] = [] # audio/video encoders (e.g.: vp8, mp4a)
self.audio_codec = None # audio codec of the stream (e.g.: vorbis)
self.video_codec = None # video codec of the stream (e.g.: vp8)
# Iterates over the key/values of stream and sets them as class
# attributes. This is an anti-pattern and should be removed.
self.set_attributes_from_dict(stream)
# Additional information about the stream format, such as resolution,
# frame rate, and whether the stream is live (HLS) or 3D.
self.fmt_profile: Dict = get_format_profile(self.itag)
# Same as above, except for the format profile attributes.
self.set_attributes_from_dict(self.fmt_profile)
# The player configuration which contains information like the video
# title.
# TODO(nficano): this should be moved to the monostate.
self.player_config_args = player_config_args
# 'video/webm; codecs="vp8, vorbis"' -> 'video/webm', ['vp8', 'vorbis']
self.mime_type, self.codecs = extract.mime_type_codec(self.type)
# 'video/webm' -> 'video', 'webm'
self.type, self.subtype = self.mime_type.split("/")
# ['vp8', 'vorbis'] -> video_codec: vp8, audio_codec: vorbis. DASH
# streams return NoneType for audio/video depending.
self.video_codec, self.audio_codec = self.parse_codecs()
def __init__(
self, stream: Dict, player_config_args: Dict, monostate: Monostate
):
"""Construct a :class:`Stream <Stream>`.
:param dict stream:
The unscrambled data extracted from YouTube.
:param dict player_config_args:
The data object containing video media data like title and
keywords.
:param dict monostate:
Dictionary of data shared across all instances of
:class:`Stream <Stream>`.
"""
# A dictionary shared between all instances of :class:`Stream <Stream>`
# (Borg pattern).
self._monostate = monostate
self.url = stream["url"] # signed download url
self.itag = int(
stream["itag"]
) # stream format id (youtube nomenclature)
# set type and codec info
# 'video/webm; codecs="vp8, vorbis"' -> 'video/webm', ['vp8', 'vorbis']
self.mime_type, self.codecs = extract.mime_type_codec(stream["type"])
# 'video/webm' -> 'video', 'webm'
self.type, self.subtype = self.mime_type.split("/")
# ['vp8', 'vorbis'] -> video_codec: vp8, audio_codec: vorbis. DASH
# streams return NoneType for audio/video depending.
self.video_codec, self.audio_codec = self.parse_codecs()
self.is_otf: bool = stream["is_otf"]
self.bitrate: Optional[int] = stream["bitrate"]
self._filesize: Optional[int] = None # filesize in bytes
# Additional information about the stream format, such as resolution,
# frame rate, and whether the stream is live (HLS) or 3D.
itag_profile = get_format_profile(self.itag)
self.is_dash = itag_profile["is_dash"]
self.abr = itag_profile["abr"] # average bitrate (audio streams only)
self.fps = stream[
"fps"
] # frames per second (video streams only)
self.resolution = itag_profile[
"resolution"
] # resolution (e.g.: "480p")
self.is_3d = itag_profile["is_3d"]
self.is_hdr = itag_profile["is_hdr"]
self.is_live = itag_profile["is_live"]
# The player configuration, contains info like the video title.
self.player_config_args = player_config_args
def __init__(self, stream, player_config_args, monostate):
"""Construct a :class:`Stream <Stream>`.
:param dict stream:
The unscrambled data extracted from YouTube.
:param dict player_config_args:
The data object containing video media data like title and
keywords.
:param dict monostate:
Dictionary of data shared across all instances of
:class:`Stream <Stream>`.
"""
# A dictionary shared between all instances of :class:`Stream <Stream>`
# (Borg pattern).
self._monostate = monostate
self.abr = None # average bitrate (audio streams only)
self.fps = None # frames per second (video streams only)
self.itag = None # stream format id (youtube nomenclature)
self.res = None # resolution (e.g.: 480p, 720p, 1080p)
self.url = None # signed download url
self.mime_type = None # content identifier (e.g.: video/mp4)
self.type = None # the part of the mime before the slash
self.subtype = None # the part of the mime after the slash
self.codecs = [] # audio/video encoders (e.g.: vp8, mp4a)
self.audio_codec = None # audio codec of the stream (e.g.: vorbis)
self.video_codec = None # video codec of the stream (e.g.: vp8)
# Iterates over the key/values of stream and sets them as class
# attributes. This is an anti-pattern and should be removed.
self.set_attributes_from_dict(stream)
# Additional information about the stream format, such as resolution,
# frame rate, and whether the stream is live (HLS) or 3D.
self.fmt_profile = get_format_profile(self.itag)
# Same as above, except for the format profile attributes.
self.set_attributes_from_dict(self.fmt_profile)
# The player configuration which contains information like the video
# title.
# TODO(nficano): this should be moved to the monostate.
self.player_config_args = player_config_args
# 'video/webm; codecs="vp8, vorbis"' -> 'video/webm', ['vp8', 'vorbis']
self.mime_type, self.codecs = extract.mime_type_codec(self.type)
# 'video/webm' -> 'video', 'webm'
self.type, self.subtype = self.mime_type.split('/')
# ['vp8', 'vorbis'] -> video_codec: vp8, audio_codec: vorbis. DASH
# streams return NoneType for audio/video depending.
self.video_codec, self.audio_codec = self.parse_codecs()
def fill_table(self):
self.itag_list = self.yt.get_itag_list()
self.itag_list.sort()
print(self.itag_list, "before")
for x in self.itag_list:
print(x, "index")
try:
urllib.request.urlopen(self.yt.streams.get_by_itag(x).url)
# pytube for sometimes gives streams that dont exist, this doesn't allow them through
except:
# self.itag_list.remove(x) - for some reason this doesnt work
print(x, "FAILED!")
continue
else:
print(x,"continuing")
self.items.append(
Item(
x,
itags.get_format_profile(x)['resolution'],
itags.get_format_profile(x)['abr'],
str(self.yt.streams.get_by_itag(x).filesize_approx/1000000) + " MB" # sizes are NOT accurate, only estimates
)
)
print(self.itag_list, "after")
def test_get_format_profile_non_existant():
profile = itags.get_format_profile(2239)
assert profile["resolution"] is None
def test_get_format_profile():
profile = itags.get_format_profile(22)
assert profile["resolution"] == "720p"
def test_get_format_profile_non_existant():
profile = itags.get_format_profile(2239)
assert profile['resolution'] is None
def test_get_format_profile():
profile = itags.get_format_profile(22)
assert profile['resolution'] == '720p'
