udemy-userAPI 0.2.8__py3-none-any.whl → 0.2.9__py3-none-any.whl

udemy_userAPI/__version__.py

@@ -1,4 +1,4 @@
-__version__ = '0.2.8'
+__version__ = '0.2.9'
 __lib_name__ = 'udemy_userAPI'  # local name
 __repo_name__ = 'udemy-userAPI'
 __autor__ = 'PauloCesar-dev404'

udemy_userAPI/api.py

@@ -168,7 +168,7 @@ def get_mpd_file(mpd_url):
         data = []
         # Exibe o código de status
         if response.status_code == 200:
-            return response.content
+            return response.text
         else:
             UnhandledExceptions(f"erro ao obter dados de aulas!! {response.status_code}")
     except requests.ConnectionError as e:
@@ -186,7 +186,6 @@ def get_mpd_file(mpd_url):
 def parser_chapers(results):
     """
     :param results:
-    :param tip: chaper,videos
     :return:
     """
     if not results:

udemy_userAPI/bultins.py

@@ -9,32 +9,35 @@ from .mpd_analyzer import MPDParser
 
 class DRM:
     def __init__(self, license_token: str, get_media_sources: list):
-        self.__mpd_content = None
+        self.__mpd_file_path = None
         self.__token = license_token
         self.__dash_url = organize_streams(streams=get_media_sources).get('dash', {})
-        if not license_token or not get_media_sources or not self.__dash_url:
+        if not license_token or get_media_sources:
             return
 
     def get_key_for_lesson(self):
         """get keys for lesson"""
-        if self.__dash_url:
-            self.__mpd_content = get_mpd_file(mpd_url=self.__dash_url[0].get('src'))
-            parser = MPDParser(mpd_file_path=self.__mpd_content, is_file=True, headers=HEADERS_USER)
-            resolutions = get_highest_resolution(parser.get_all_video_resolutions())
-            parser.set_selected_resolution(resolution=resolutions)
-            init_url = parser.get_selected_video_init_url()
-            if init_url:
-                pssh = get_pssh(init_url=init_url)
-                if pssh:
-                    keys = extract(pssh=pssh, license_token=self.__token)
-                    if keys:
-                        return keys
-                    else:
-                        return None
+        try:
+            if self.__dash_url:
+                self.__mpd_file_path = get_mpd_file(mpd_url=self.__dash_url[0].get('src'))
+                parser = MPDParser(mpd_content=self.__mpd_file_path)
+                resolutions = get_highest_resolution(parser.get_all_video_resolutions())
+                parser.set_selected_resolution(resolution=resolutions)
+                init_url = parser.get_selected_video_init_url()
+                if init_url:
+                    pssh = get_pssh(init_url=init_url)
+                    if pssh:
+                        keys = extract(pssh=pssh, license_token=self.__token)
+                        if keys:
+                            return keys
+                        else:
+                            return None
+                else:
+                    return None
             else:
                 return None
-        else:
-            return None
+        except Exception as e:
+            raise Exception(f"Não foi possível obter as chaves!\n{e}")
 
 
 class Files:
@@ -44,8 +47,7 @@ class Files:
 
     @property
     def get_download_url(self) -> dict[str, Any | None] | list[dict[str, Any | None]]:
-        """obter url de download de um arquivo quando disponivel(geralemnete para arquivos esta opção é valida"""
-        da = {}
+        """Obter url de ‘download’ de um arquivo quando disponivel(geralemnete para arquivos esta opção é valida"""
         download_urls = []
         for files in self.__data:
             lecture_id = files.get('lecture_id', None)
@@ -68,6 +70,7 @@ class Files:
                     headers=HEADERS_USER)
                 if resp.status_code == 200:
                     da = json.loads(resp.text)
+                    # para cdaa dict de um fle colocar seu titulo:
                     dt_file = {'title-file': title,
                                'lecture_title': lecture_title,
                                'lecture_id': lecture_id,
@@ -84,12 +87,12 @@ class Lecture:
         self.__course_id = course_id
         self.__data = data
         self.__additional_files = additional_files
-        self.__asset = self.__data.get("asset")
+        self.__asset = self.__data.get("asset", {})
 
     @property
     def get_lecture_id(self) -> int:
         """Obtém o ID da lecture"""
-        return self.__data.get('id')
+        return self.__data.get('id', 0)
 
     @property
     def get_description(self) -> str:
@@ -138,10 +141,12 @@ class Lecture:
     def course_is_drmed(self) -> DRM:
         """verifica se a aula possui DRM se sim retorna as keys da aula...
          retorna 'kid:key' or None"""
-        if self.__asset.get('course_is_drmed', {}):
+        try:
             d = DRM(license_token=self.get_media_license_token,
                     get_media_sources=self.get_media_sources)
             return d
+        except Exception as e:
+            DeprecationWarning(e)
 
     @property
     def get_download_urls(self) -> list:
@@ -271,16 +276,15 @@ class Course:
     def get_additional_files(self) -> list[Any]:
         """Retorna a lista de arquivos adcionais de um curso."""
         supplementary_assets = []
-        files_downloader = []
         for item in self.__additional_files_data.get('results', []):
             # Check if the item is a lecture with supplementary assets
             if item.get('_class') == 'lecture':
-                id = item.get('id', {})
+                id_l = item.get('id', {})
                 title = item.get('title', {})
                 assets = item.get('supplementary_assets', [])
                 for asset in assets:
                     supplementary_assets.append({
-                        'lecture_id': id,
+                        'lecture_id': id_l,
                         'lecture_title': title,
                         'asset': asset
                     })
@@ -292,16 +296,15 @@ class Course:
     def __load_assets(self):
         """Retorna a lista de arquivos adcionais de um curso."""
         supplementary_assets = []
-        files_downloader = []
         for item in self.__additional_files_data.get('results', []):
             # Check if the item is a lecture with supplementary assets
             if item.get('_class') == 'lecture':
-                id = item.get('id')
+                id_l = item.get('id')
                 title = item.get('title')
                 assets = item.get('supplementary_assets', [])
                 for asset in assets:
                     supplementary_assets.append({
-                        'lecture_id': id,
+                        'lecture_id': id_l,
                         'lecture_title': title,
                         'asset': asset
                     })

udemy_userAPI/mpd_analyzer/mpd_parser.py

@@ -1,304 +1,191 @@
 import re
-import xml.etree.ElementTree as ET
+import xml.etree.ElementTree as Et
+
+
+def calculate_segment_url2(media_template, segment_number, segment_time, rep_id):
+    """
+    Calcula a URL de um segmento específico, substituindo variáveis no template.
+    """
+    url = media_template.replace('$Number$', str(segment_number))
+    url = url.replace('$RepresentationID$', rep_id)
+    if '$Time$' in url:
+        url = url.replace('$Time$', str(segment_time))
+    return url
+
+
+def build_url2(template, rep_id):
+    """
+    Constrói a URL substituindo variáveis no template com base nos atributos.
+    """
+    if '$RepresentationID$' in template:
+        template = template.replace('$RepresentationID$', rep_id)
+    return template
+
+
+def parse_duration(duration_str):
+    """
+    Converte uma duração em formato ISO 8601 (ex: "PT163.633S") para segundos (float).
+    """
+    match = re.match(r'PT(?:(\d+)H)?(?:(\d+)M)?(?:(\d+(?:\.\d+)?)S)?', duration_str)
+    if match:
+        hours = int(match.group(1)) if match.group(1) else 0
+        minutes = int(match.group(2)) if match.group(2) else 0
+        seconds = float(match.group(3)) if match.group(3) else 0.0
+        return hours * 3600 + minutes * 60 + seconds
+    return 0.0
 
 
 class MPDParser:
     """
     Classe para analisar e extrair informações de manifestos MPD (Media Presentation Description),
-    com foco em arquivos VOD (Video on Demand). Atualmente, não oferece suporte para transmissões ao vivo
+    com foco em arquivos VOD (Video on Demand). Atualmente, não oferece suporte para transmissões ao vivo.
     """
 
-    def __init__(self, mpd_file_path: str, headers=None,is_file=None):
+    def __init__(self, mpd_content: str):
         """
-        Inicializa o parser para um arquivo MPD a partir de um caminho de arquivo.
+        Inicializa o parser para um arquivo MPD.
 
         Args:
-            mpd_file_path (str): Caminho do arquivo MPD.
-            headers (dict, opcional): Headers HTTP adicionais para requisição, caso necessário.
+            mpd_content (str): Caminho do arquivo MPD ou conteúdo bruto.
         """
-        self.is_file = is_file
-        self.availability_start_time = None
-        self.mpd_file_path = mpd_file_path
-        self.headers = headers if headers else {}
-        self.video_representations = {}  # Armazena representações de vídeo, organizadas por resolução
-        self.audio_representations = {}  # Armazena representações de áudio, organizadas por taxa de bits
-        self.content_protection = {}  # Armazena informações de proteção de conteúdo
-        self.selected_resolution = None  # Resolução selecionada para recuperação de segmentos de vídeo
-        self.initi = self.__parse_mpd2()
-        if not self.initi:
-            initi = self.__parse_mpd()
-
-    def __parse_mpd(self):
+        self._mpd_content = mpd_content
+        self._video_representations = {}
+        self._audio_representations = {}
+        self._content_protection = {}
+        self._selected_resolution = None
+
+        # Tenta fazer o parsing com diferentes métodos
+        if not self.__parse_mpd_v2():
+            self.__parse_mpd_v1()
+
+    def __parse_mpd_v1(self):
         """
-        Faz o parsing do arquivo MPD localizado no caminho especificado e
-        extrai informações sobre segmentos de vídeo e áudio, além de proteção de conteúdo.
+        Parsing básico do MPD (versão 1).
         """
-        mpd_content = ''
-        if not self.is_file:
-            try:
-                    with open(self.mpd_file_path, 'r', encoding='utf-8') as file:
-                        mpd_content = file.read()
-            except FileNotFoundError:
-                    print(f"Erro: Arquivo '{self.mpd_file_path}' não encontrado.")
-                    return
-            except IOError:
-                    print(f"Erro ao ler o arquivo '{self.mpd_file_path}'.")
-                    return
-        else:
-            mpd_content = self.mpd_file_path
-        # Analisa o conteúdo MPD usando namespaces XML para acessar nós DASH
-        root = ET.fromstring(mpd_content)
+        content = self._mpd_content
+        root = Et.fromstring(content)
         ns = {'dash': 'urn:mpeg:dash:schema:mpd:2011'}
 
-        # Processa cada AdaptationSet para extração de representações de áudio e vídeo
         for adaptation_set in root.findall('.//dash:AdaptationSet', ns):
             mime_type = adaptation_set.attrib.get('mimeType', '')
-            # Extrai informações de proteção de conteúdo, se presentes
-            for content_protection in adaptation_set.findall('dash:ContentProtection', ns):
-                scheme_id_uri = content_protection.attrib.get('schemeIdUri', '')
-                value = content_protection.attrib.get('value', '')
-                self.content_protection[scheme_id_uri] = value
-
-            # Extrai informações de cada representação de mídia
-            for representation in adaptation_set.findall('dash:Representation', ns):
-                rep_id = representation.attrib.get('id')
-                width = int(representation.attrib.get('width', 0))
-                height = int(representation.attrib.get('height', 0))
-                resolution = (width, height) if width and height else None
-                bandwidth = int(representation.attrib.get('bandwidth', 0))
-                # Obtém a quantidade de canais de áudio, se disponível
-                audio_channels = representation.find('dash:AudioChannelConfiguration', ns)
-                audio_channels_count = int(audio_channels.attrib.get('value', 0)) if audio_channels is not None else 0
-
-                # Processa SegmentTemplate para URLs de inicialização e segmentos
-                segment_template = representation.find('dash:SegmentTemplate', ns)
-                if segment_template is not None:
-                    init_template = segment_template.get('initialization')
-                    init_url = self.__build_url(init_template, rep_id, bandwidth) if init_template else None
-
-                    media_url_template = segment_template.get('media')
-                    timescale = int(segment_template.get('timescale', 1))
-
-                    # Processa SegmentTimeline para obtenção de segmentos individuais
-                    segment_timeline = segment_template.find('dash:SegmentTimeline', ns)
-                    segments = []
-                    if segment_timeline is not None:
-                        segment_number = int(segment_template.get('startNumber', 1))
-                        start_time = 0
-                        for segment in segment_timeline.findall('dash:S', ns):
-                            t = int(segment.get('t', start_time))
-                            d = int(segment.get('d'))
-                            r = int(segment.get('r', 0))
-
-                            # Adiciona segmentos repetidos se necessário
-                            for _ in range(r + 1):
-                                segments.append(
-                                    self.__calculate_segment_url(media_url_template, segment_number, t, rep_id,
-                                                                 bandwidth)
-                                )
-                                t += d
-                                segment_number += 1
-
-                    # Armazena informações de representação com resolução ou taxa de bits como chave
-                    representation_info = {
-                        'id': rep_id,
-                        'resolution': resolution,
-                        'bandwidth': bandwidth,
-                        'audio_channels': audio_channels_count,
-                        'init_url': init_url,
-                        'segments': segments,
-                    }
-                    if 'video' in mime_type:
-                        self.video_representations[resolution] = representation_info
-                    elif 'audio' in mime_type:
-                        self.audio_representations[bandwidth] = representation_info
-
-    def __parse_mpd2(self):
+            self.__parse_adaptation_set(adaptation_set, mime_type, ns)
+
+    def __parse_mpd_v2(self):
         """
-        Faz o parsing do arquivo MPD localizado no caminho especificado e
-        extrai informações sobre segmentos de vídeo e áudio, além de proteção de conteúdo.
+        Parsing avançado do MPD (versão 2).
         """
-        mpd_content = ''
-        if not self.is_file:
-            try:
-                    with open(self.mpd_file_path, 'r', encoding='utf-8') as file:
-                        mpd_content = file.read()
-            except FileNotFoundError:
-                    print(f"Erro: Arquivo '{self.mpd_file_path}' não encontrado.")
-                    return
-            except IOError:
-                    print(f"Erro ao ler o arquivo '{self.mpd_file_path}'.")
-                    return
-        else:
-            mpd_content = self.mpd_file_path
-
-        # Analisar o conteúdo MPD
-        root = ET.fromstring(mpd_content)
+        content = self._mpd_content
+        root = Et.fromstring(content)
         ns = {'dash': 'urn:mpeg:dash:schema:mpd:2011'}
 
-        # Extrai a duração total da apresentação em segundos
-        self.media_presentation_duration = self.parse_duration(root.attrib.get('mediaPresentationDuration', 'PT0S'))
-
         for adaptation_set in root.findall('.//dash:AdaptationSet', ns):
             mime_type = adaptation_set.attrib.get('mimeType', '')
+            self.__parse_adaptation_set(adaptation_set, mime_type, ns)
+        return True
 
-            # Extrai proteção de conteúdo
-            for content_protection in adaptation_set.findall('dash:ContentProtection', ns):
-                scheme_id_uri = content_protection.attrib.get('schemeIdUri', '')
-                value = content_protection.attrib.get('value', '')
-                self.content_protection[scheme_id_uri] = value
-
-            # Extrai representações de vídeo e áudio
-            for representation in adaptation_set.findall('dash:Representation', ns):
-                rep_id = representation.attrib.get('id')
-                width = int(representation.attrib.get('width', 0))
-                height = int(representation.attrib.get('height', 0))
-                resolution = (width, height) if width and height else None
-                bandwidth = int(representation.attrib.get('bandwidth', 0))
-
-                # SegmentTemplate e SegmentTimeline
-                segment_template = adaptation_set.find('dash:SegmentTemplate', ns)
-                if segment_template is not None:
-                    init_template = segment_template.get('initialization')
-                    media_template = segment_template.get('media')
-                    timescale = int(segment_template.get('timescale', 1))
-                    start_number = int(segment_template.get('startNumber', 1))
-
-                    # Processa SegmentTimeline
-                    segment_timeline = segment_template.find('dash:SegmentTimeline', ns)
-                    segments = []
-                    if segment_timeline is not None:
-                        segment_number = start_number
-                        for segment in segment_timeline.findall('dash:S', ns):
-                            t = int(segment.get('t', 0))
-                            d = int(segment.get('d'))
-                            r = int(segment.get('r', 0))  # Quantidade de repetições
-
-                            for i in range(r + 1):  # Inclui o segmento e suas repetições
-                                segment_time = t + i * d
-                                segment_url = self.__calculate_segment_url2(media_template, segment_number, segment_time,
-                                                                         rep_id)
-                                segments.append(segment_url)
-                                segment_number += 1
-                    else:
-                        # No SegmentTimeline, gera segmentos contínuos
-                        duration = int(segment_template.get('duration', 1))
-                        total_segments = int((self.media_presentation_duration * timescale) // duration)
-                        for segment_number in range(start_number, start_number + total_segments):
-                            segment_time = (segment_number - 1) * duration
-                            segment_url = self.__calculate_segment_url2(media_template, segment_number, segment_time,
-                                                                     rep_id)
-                            segments.append(segment_url)
-
-                    # Armazena representações de vídeo e áudio com URLs de segmentos
-                    representation_info = {
-                        'id': rep_id,
-                        'resolution': resolution,
-                        'bandwidth': bandwidth,
-                        'init_url': self.__build_url2(init_template, rep_id),
-                        'segments': segments,
-                    }
-                    if 'video' in mime_type:
-                        self.video_representations[resolution] = representation_info
-                    elif 'audio' in mime_type:
-                        self.audio_representations[bandwidth] = representation_info
-    def parse_duration(self, duration_str):
+    def __parse_adaptation_set(self, adaptation_set, mime_type, ns):
         """
-        Converte uma duração em formato ISO 8601 (ex: "PT163.633S") para segundos (float).
+        Analisa um AdaptationSet para representações de vídeo ou áudio.
+
+        Args:
+            adaptation_set (ET.Element): Elemento do AdaptationSet.
+            mime_type (str): Tipo MIME (vídeo ou áudio).
+            ns (dict): Namespace para parsing do XML.
         """
-        match = re.match(r'PT(?:(\d+)H)?(?:(\d+)M)?(?:(\d+(?:\.\d+)?)S)?', duration_str)
-        if match:
-            hours = int(match.group(1)) if match.group(1) else 0
-            minutes = int(match.group(2)) if match.group(2) else 0
-            seconds = float(match.group(3)) if match.group(3) else 0.0
-            return hours * 3600 + minutes * 60 + seconds
-        return 0.0
+        # Extrai informações de proteção de conteúdo
+        for content_protection in adaptation_set.findall('dash:ContentProtection', ns):
+            scheme_id_uri = content_protection.attrib.get('schemeIdUri', '')
+            value = content_protection.attrib.get('value', '')
+            self._content_protection[scheme_id_uri] = value
 
-    @staticmethod
-    def __build_url(template, rep_id, bandwidth):
+        # Processa representações dentro do AdaptationSet
+        for representation in adaptation_set.findall('dash:Representation', ns):
+            self.__process_representation(representation, mime_type, ns)
+
+    def __process_representation(self, representation, mime_type, ns):
         """
-        Constrói uma URL substituindo placeholders em um template de URL.
+        Processa uma representação de mídia (vídeo ou áudio).
 
         Args:
-            template (str): Template de URL com placeholders.
+            representation (ET.Element): Elemento da Representação.
+            mime_type (str): Tipo MIME da mídia.
+            ns (dict): Namespace para parsing do XML.
+        """
+        rep_id = representation.attrib.get('id')
+        width = int(representation.attrib.get('width', 0))
+        height = int(representation.attrib.get('height', 0))
+        resolution = (width, height) if width and height else None
+        bandwidth = int(representation.attrib.get('bandwidth', 0))
+
+        # Extrai informações do SegmentTemplate
+        segment_template = representation.find('dash:SegmentTemplate', ns)
+        if segment_template:
+            init_url = self.__build_url(segment_template.get('initialization'), rep_id, bandwidth)
+            segments = self.__generate_segments(segment_template, ns, rep_id, bandwidth)
+
+            representation_info = {
+                'id': rep_id,
+                'resolution': resolution,
+                'bandwidth': bandwidth,
+                'init_url': init_url,
+                'segments': segments,
+            }
+            if 'video' in mime_type:
+                self._video_representations[resolution] = representation_info
+            elif 'audio' in mime_type:
+                self._audio_representations[bandwidth] = representation_info
+
+    def __generate_segments(self, segment_template, ns, rep_id, bandwidth):
+        """
+        Gera a lista de URLs de segmentos com base no SegmentTemplate.
+
+        Args:
+            segment_template (ET.Element): Elemento do SegmentTemplate.
+            ns (dict): Namespace para parsing do XML.
             rep_id (str): ID da representação.
             bandwidth (int): Largura de banda da representação.
 
         Returns:
-            str: URL formatada com placeholders substituídos.
-        """
-        if '$RepresentationID$' in template:
-            template = template.replace('$RepresentationID$', rep_id)
-        if '$Bandwidth$' in template:
-            template = template.replace('$Bandwidth$', str(bandwidth))
-        return template
-
-    def __build_url2(self, template, rep_id):
-        """
-        Constrói a URL substituindo variáveis no template com base nos atributos.
-        """
-        if '$RepresentationID$' in template:
-            template = template.replace('$RepresentationID$', rep_id)
-        return template
+            list: URLs dos segmentos.
+        """
+        segments = []
+        media_template = segment_template.get('media')
+        segment_timeline = segment_template.find('dash:SegmentTimeline', ns)
+
+        if segment_timeline:
+            segment_number = int(segment_template.get('startNumber', 1))
+            for segment in segment_timeline.findall('dash:S', ns):
+                t = int(segment.get('t', 0))
+                d = int(segment.get('d'))
+                r = int(segment.get('r', 0))
+                for i in range(r + 1):
+                    segment_time = t + i * d
+                    segments.append(self.__build_url(media_template, rep_id, bandwidth, segment_time, segment_number))
+                    segment_number += 1
+        return segments
 
     @staticmethod
-    def __calculate_segment_url(media_template, segment_number, segment_time, rep_id, bandwidth):
+    def __build_url(template, rep_id, bandwidth, segment_time=None, segment_number=None):
         """
-        Constrói a URL de um segmento substituindo placeholders por valores reais.
+        Constrói uma URL substituindo placeholders.
 
         Args:
-            media_template (str): Template de URL do segmento.
-            segment_number (int): Número do segmento.
-            segment_time (int): Timestamp do segmento.
+            template (str): Template de URL.
             rep_id (str): ID da representação.
-            bandwidth (int): Largura de banda da representação.
+            bandwidth (int): Largura de banda.
+            segment_time (int, opcional): Timestamp do segmento.
+            segment_number (int, opcional): Número do segmento.
 
         Returns:
-            str: URL do segmento com placeholders substituídos.
+            str: URL formatada.
         """
-        url = media_template.replace('$Number$', str(segment_number))
-        url = url.replace('$RepresentationID$', rep_id).replace('$Bandwidth$', str(bandwidth))
-        if '$Time$' in url:
+        url = template.replace('$RepresentationID$', rep_id).replace('$Bandwidth$', str(bandwidth))
+        if segment_time is not None:
             url = url.replace('$Time$', str(segment_time))
+        if segment_number is not None:
+            url = url.replace('$Number$', str(segment_number))
         return url
 
-    def __calculate_segment_url2(self, media_template, segment_number, segment_time, rep_id):
-        """
-        Calcula a URL de um segmento específico, substituindo variáveis no template.
-        """
-        url = media_template.replace('$Number$', str(segment_number))
-        url = url.replace('$RepresentationID$', rep_id)
-        if '$Time$' in url:
-            url = url.replace('$Time$', str(segment_time))
-        return url
-
-    def get_video_representations(self):
-        """
-        Retorna as representações de vídeo extraídas do arquivo MPD.
-
-        Returns:
-            dict: Representações de vídeo com resoluções como chaves.
-        """
-        return self.video_representations
-
-    def get_audio_representations(self):
-        """
-        Retorna as representações de áudio extraídas do arquivo MPD.
-
-        Returns:
-            dict: Representações de áudio com taxas de bits como chaves.
-        """
-        return self.audio_representations
-
-    def get_content_protection_info(self):
-        """
-        Retorna as informações de proteção de conteúdo extraídas do MPD.
-
-        Returns:
-            dict: Dados de proteção de conteúdo com URI do esquema como chaves.
-        """
-        return self.content_protection
-
     def set_selected_resolution(self, resolution: tuple):
         """
         Define a resolução selecionada para a recuperação de segmentos de vídeo.
@@ -309,23 +196,12 @@ class MPDParser:
         Raises:
             Exception: Se a resolução não estiver disponível no manifesto.
         """
-        if resolution in self.video_representations:
-            self.selected_resolution = resolution
+        if resolution in self._video_representations:
+            self._selected_resolution = resolution
         else:
             raise Exception(
-                f'A resolução {resolution} não está disponível!\n\n\t=> Resoluções disponíveis no arquivo: {self.get_all_video_resolutions()}')
-
-    def get_selected_video_segments(self):
-        """
-        Retorna os URLs dos segmentos de vídeo para a resolução selecionada.
-
-        Returns:
-            list: URLs dos segmentos de vídeo para a resolução selecionada.
-        """
-        if self.selected_resolution:
-            return self.video_representations[self.selected_resolution].get('segments', [])
-        else:
-            raise Exception(f'Você deve selecioanar uma resolução no método self.set_selected_resolution()')
+                f'A resolução {resolution} não está disponível!\n\n'
+                f'\t=> Resoluções disponíveis no arquivo: {self.get_all_video_resolutions()}')
 
     def get_selected_video_init_url(self):
         """
@@ -334,8 +210,8 @@ class MPDParser:
         Returns:
             str: URL de inicialização do vídeo, ou None se não houver resolução selecionada.
         """
-        if self.selected_resolution:
-            return self.video_representations[self.selected_resolution].get('init_url')
+        if self._selected_resolution:
+            return self._video_representations[self._selected_resolution].get('init_url')
         return None
 
     def get_all_video_resolutions(self):
@@ -343,15 +219,6 @@ class MPDParser:
         Retorna uma lista de todas as resoluções de vídeo disponíveis.
 
         Returns:
-            list: Lista de tuplas com resoluções de vídeo (largura, altura).
-        """
-        return list(self.video_representations.keys())
-
-    def get_audio_channels_count(self):
-        """
-        Retorna um dicionário com a quantidade de canais de áudio para cada taxa de bits de áudio.
-
-        Returns:
-            dict: Quantidade de canais de áudio para cada taxa de bits.
+            list: lista de tuplas com resoluções de vídeo (largura, altura).
         """
-        return {bandwidth: info['audio_channels'] for bandwidth, info in self.audio_representations.items()}
+        return list(self._video_representations.keys())

{udemy_userAPI-0.2.8.dist-info → udemy_userAPI-0.2.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: udemy_userAPI
-Version: 0.2.8
+Version: 0.2.9
 Summary: Obtenha detalhes de cursos que o usuário esteja inscrito da plataforma Udemy,usando o EndPoint de usuário o mesmo que o navegador utiliza para acessar e redenrizar os cursos.
 Author: PauloCesar-dev404
 Author-email: paulocesar0073dev404@gmail.com
@@ -19,7 +19,7 @@ Requires-Dist: pywidevine
 # udemy-userAPI
 
 
-![Versão](https://img.shields.io/badge/version-0.2.8-orange)
+![Versão](https://img.shields.io/badge/version-0.2.9-orange)
 ![Licença](https://img.shields.io/badge/license-MIT-orange)
 [![Sponsor](https://img.shields.io/badge/💲Donate-yellow)](https://apoia.se/paulocesar-dev404)
 [![Sponsor](https://img.shields.io/badge/Documentation-green)](https://github.com/PauloCesar-dev404/udemy-userAPI/blob/main/docs/iniciando.md)

{udemy_userAPI-0.2.8.dist-info → udemy_userAPI-0.2.9.dist-info}/RECORD

@@ -11,19 +11,19 @@ m3u8_analyzer/__init__.py,sha256=v7CiVqsCq2YH347C-QR1kHPJtXFFdru8qole3E9adCY,217
 m3u8_analyzer/__version__.py,sha256=YP3yT87ZKrU3eARUUdQ_pg4xAXLGfBXjH4ZgEoZSq1I,25
 m3u8_analyzer/exeptions.py,sha256=fK6bU3YxNSbfsPmCp4yudUvmwy_g6dj2KwIkH0dW4LI,3672
 udemy_userAPI/__init__.py,sha256=BPle89xE_CMTKKe_Lw6jioYLgpH-q_Lpho2S-n1PIUA,206
-udemy_userAPI/__version__.py,sha256=vx5RTMBCZ8TPFvdbHibhAEl83lKiEzlCu5oYTGRiPQg,405
-udemy_userAPI/api.py,sha256=dpwFtXewQmKwgG1IvzDFYZoEHNTwZbLIuv4WKgbqjOg,18817
+udemy_userAPI/__version__.py,sha256=ddg6Jc4hdL3Ucjndnb_uXJAIG6W_GhKfswf9LQ5rImo,405
+udemy_userAPI/api.py,sha256=M061zpgrwigktMeb9JINmblqsojkSdTwdzeRwimlGlw,18783
 udemy_userAPI/authenticate.py,sha256=84frcOMfOzfCBfXDtoTa3POqkwWwuqgJ6h4ROF0TVAM,13850
-udemy_userAPI/bultins.py,sha256=_-CM8Y-EuOEyg3kbNI2LKUONdCn2d1El1AmoNqFo0EU,12426
+udemy_userAPI/bultins.py,sha256=Z3Jw-e4HUE-5LGfOtAkoyHFGfdyOSXpAinsaNPa41Bc,12597
 udemy_userAPI/exeptions.py,sha256=nuZoAt4i-ctrW8zx9LZtejrngpFXDHOVE5cEXM4RtrY,508
 udemy_userAPI/sections.py,sha256=zPyDhvTIQCL0nbf7OJZG28Kax_iooILQ_hywUwvHoL8,4043
 udemy_userAPI/udemy.py,sha256=KMWMmid0zC9pUCULjLSAOK0P7yvCOtdShXpT6Q-fhro,2127
 udemy_userAPI/.cache/.udemy_userAPI,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 udemy_userAPI/mpd_analyzer/__init__.py,sha256=i3JVWyvcFLaj5kPmx8c1PgjsLht7OUIQQClD4yqYbo8,102
 udemy_userAPI/mpd_analyzer/bin.wvd,sha256=1rAJdCc120hQlX9qe5KUS628eY2ZHYxQSmyhGNefSzo,2956
-udemy_userAPI/mpd_analyzer/mpd_parser.py,sha256=_vw1feJXDjw5fQLOmA5-H3UklX_30Pbl__HtDUqvp3c,17283
-udemy_userAPI-0.2.8.dist-info/LICENSE,sha256=l4jdKYt8gSdDFOGr09vCKnMn_Im55XIcQKqTDEtFfNs,1095
-udemy_userAPI-0.2.8.dist-info/METADATA,sha256=rOApAgyamEEbPBHpoE7JDYl1RjPryfsCr3e3aPl_LCY,1417
-udemy_userAPI-0.2.8.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-udemy_userAPI-0.2.8.dist-info/top_level.txt,sha256=ijTINaSDRKhdahY_X7dmSRFTxBIwQErWv9ATCG55mog,14
-udemy_userAPI-0.2.8.dist-info/RECORD,,
+udemy_userAPI/mpd_analyzer/mpd_parser.py,sha256=PgUkHc5x8FTuXFCuYkWPZr9TaO_nsKalb02EFYl_zeA,8926
+udemy_userAPI-0.2.9.dist-info/LICENSE,sha256=l4jdKYt8gSdDFOGr09vCKnMn_Im55XIcQKqTDEtFfNs,1095
+udemy_userAPI-0.2.9.dist-info/METADATA,sha256=nFDTysEImMWRp_2-d9VreIuk7TAkWMkAa6p35KHjJy4,1417
+udemy_userAPI-0.2.9.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+udemy_userAPI-0.2.9.dist-info/top_level.txt,sha256=ijTINaSDRKhdahY_X7dmSRFTxBIwQErWv9ATCG55mog,14
+udemy_userAPI-0.2.9.dist-info/RECORD,,