udemy-userAPI 0.1.5__py3-none-any.whl → 0.1.7__py3-none-any.whl

udemy_userAPI/__version__.py

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

udemy_userAPI/api.py

@@ -1,7 +1,13 @@
 import json
-import requests
 from .exeptions import UdemyUserApiExceptions, UnhandledExceptions
 from .authenticate import UdemyAuth
+import os.path
+from pywidevine.cdm import Cdm
+from pywidevine.device import Device
+from pywidevine.pssh import PSSH
+import requests
+import base64
+import logging
 
 AUTH = UdemyAuth()
 COOKIES = AUTH.load_cookies
@@ -38,6 +44,142 @@ HEADERS_octet_stream = {
     'accept-language': 'en-US,en;q=0.9',
 }
 
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.WARNING)
+# Obtém o diretório do arquivo em execução
+locate = os.path.dirname(__file__)
+# Cria o caminho para o arquivo bin.wvd na subpasta bin
+WVD_FILE_PATH = os.path.join(locate, 'bin.wvd')
+device = Device.load(WVD_FILE_PATH)
+cdm = Cdm.from_device(device)
+
+
+def read_pssh_from_bytes(bytes):
+    pssh_offset = bytes.rfind(b'pssh')
+    _start = pssh_offset - 4
+    _end = pssh_offset - 4 + bytes[pssh_offset - 1]
+    pssh = bytes[_start:_end]
+    return pssh
+
+
+def get_pssh(init_url):
+    logger.info(f"INIT URL: {init_url}")
+    res = requests.get(init_url, headers=HEADERS_octet_stream)
+    if not res.ok:
+        logger.exception("Could not download init segment: " + res.text)
+        return
+    pssh = read_pssh_from_bytes(res.content)
+    return base64.b64encode(pssh).decode("utf-8")
+
+
+def get_highest_resolution(resolutions):
+    """
+    Retorna a maior resolução em uma lista de resoluções.
+
+    Args:
+        resolutions (list of tuple): Lista de resoluções, onde cada tupla representa (largura, altura).
+
+    Returns:
+        tuple: A maior resolução em termos de largura e altura.
+    """
+    if not resolutions:
+        return None
+    return max(resolutions, key=lambda res: (res[0], res[1]))
+
+
+def organize_streams(streams):
+    organized_streams = {
+        'dash': [],
+        'hls': []
+    }
+
+    best_video = None
+
+    for stream in streams:
+        # Verifica e adiciona streams DASH
+        if stream['type'] == 'application/dash+xml':
+            organized_streams['dash'].append({
+                'src': stream['src'],
+                'label': stream.get('label', 'unknown')
+            })
+
+        # Verifica e adiciona streams HLS (m3u8)
+        elif stream['type'] == 'application/x-mpegURL':
+            organized_streams['hls'].append({
+                'src': stream['src'],
+                'label': stream.get('label', 'auto')
+            })
+
+        # Verifica streams de vídeo (mp4)
+        elif stream['type'] == 'video/mp4':
+            # Seleciona o vídeo com a maior resolução (baseado no label)
+            if best_video is None or int(stream['label']) > int(best_video['label']):
+                best_video = {
+                    'src': stream['src'],
+                    'label': stream['label']
+                }
+
+    # Adiciona o melhor vídeo encontrado na lista 'hls'
+    if best_video:
+        organized_streams['hls'].append(best_video)
+
+    return organized_streams
+
+
+def extract(pssh, license_token):
+    license_url = (f"https://www.udemy.com/api-2.0/media-license-server/validate-auth-token?drm_type=widevine"
+                   f"&auth_token={license_token}")
+    logger.info(f"License URL: {license_url}")
+    session_id = cdm.open()
+    challenge = cdm.get_license_challenge(session_id, PSSH(pssh))
+    logger.info("Sending license request now")
+    license = requests.post(license_url, headers=HEADERS_octet_stream, data=challenge)
+    try:
+        str(license.content, "utf-8")
+    except:
+        base64_license = base64.b64encode(license.content).decode()
+        logger.info("[+] Acquired license sucessfully!")
+    else:
+        if "CAIS" not in license.text:
+            logger.exception("[-] Couldn't to get license: [{}]\n{}".format(license.status_code, license.text))
+            return
+
+    logger.info("Trying to get keys now")
+    cdm.parse_license(session_id, license.content)
+    final_keys = ""
+    for key in cdm.get_keys(session_id):
+        logger.info(f"[+] Keys: [{key.type}] - {key.kid.hex}:{key.key.hex()}")
+        if key.type == "CONTENT":
+            final_keys += f"{key.kid.hex}:{key.key.hex()}"
+    cdm.close(session_id)
+
+    if final_keys == "":
+        logger.exception("Keys were not extracted sucessfully.")
+        return
+    return final_keys.strip()
+
+
+def get_mpd_file(mpd_url):
+    try:
+        # Faz a solicitação GET com os cabeçalhos
+        response = requests.get(mpd_url, headers=HEADERS_USER)
+        data = []
+        # Exibe o código de status
+        if response.status_code == 200:
+            return response.content
+        else:
+            UnhandledExceptions(f"erro ao obter dados de aulas!! {response.status_code}")
+    except requests.ConnectionError as e:
+        UdemyUserApiExceptions(f"Erro de conexão: {e}")
+    except requests.Timeout as e:
+        UdemyUserApiExceptions(f"Tempo de requisição excedido: {e}")
+    except requests.TooManyRedirects as e:
+        UdemyUserApiExceptions(f"Limite de redirecionamentos excedido: {e}")
+    except requests.HTTPError as e:
+        UdemyUserApiExceptions(f"Erro HTTP: {e}")
+    except Exception as e:
+        UnhandledExceptions(f"Errro Ao Obter Mídias:{e}")
+
 
 def parser_chapers(results):
     """
@@ -67,19 +209,57 @@ def parser_chapers(results):
         elif _class == 'lecture' and current_chapter is not None:
             asset = dictionary.get('asset')
             if asset:
-                video_title = asset.get('title', None)
+                video_title = dictionary.get('title', None)
                 if not video_title:
                     video_title = 'Files'
                 current_chapter['videos_in_chapter'].append({
                     'video_title': video_title,
                     'title_lecture': dictionary.get('title'),
-                    'id_lecture': dictionary.get('id'),
-                    'id_asset': asset.get('id')
+                    'lecture_id': dictionary.get('id'),
+                    'asset_id': asset.get('id')
                 })
-
     return chapters_dict
 
 
+def get_add_files(course_id: int):
+    url = (f'https://www.udemy.com/api-2.0/courses/{course_id}/subscriber-curriculum-items/?page_size=2000&fields['
+           f'lecture]=title,object_index,is_published,sort_order,created,asset,supplementary_assets,is_free&fields['
+           f'quiz]=title,object_index,is_published,sort_order,type&fields[practice]=title,object_index,is_published,'
+           f'sort_order&fields[chapter]=title,object_index,is_published,sort_order&fields[asset]=title,filename,'
+           f'asset_type,status,time_estimation,is_external&caching_intent=True')
+    try:
+        # Faz a solicitação GET com os cabeçalhos
+        response = requests.get(url, headers=HEADERS_USER)
+        data = []
+        # Exibe o código de status
+        if response.status_code == 200:
+            a = json.loads(response.text)
+            return a
+        else:
+            UnhandledExceptions(f"erro ao obter dados de aulas!! {response.status_code}")
+
+    except requests.ConnectionError as e:
+        UdemyUserApiExceptions(f"Erro de conexão: {e}")
+    except requests.Timeout as e:
+        UdemyUserApiExceptions(f"Tempo de requisição excedido: {e}")
+    except requests.TooManyRedirects as e:
+        UdemyUserApiExceptions(f"Limite de redirecionamentos excedido: {e}")
+    except requests.HTTPError as e:
+        UdemyUserApiExceptions(f"Erro HTTP: {e}")
+    except Exception as e:
+        UnhandledExceptions(f"Errro Ao Obter Mídias:{e}")
+
+
+def get_files_aule(lecture_id_filter, data: list):
+    files = []
+    # print(f'DEBUG:\n\n{data}')
+    for files_data in data:
+        lecture_id = files_data.get('lecture_id')
+        if lecture_id == lecture_id_filter:
+            files.append(files_data)
+    return files
+
+
 def get_links(course_id: int, id_lecture: int):
     """
         :param course_id: id do curso
@@ -120,10 +300,37 @@ def remove_tag(d: str):
     return new
 
 
+def get_external_liks(course_id: int, id_lecture, asset_id):
+    url = (f'https://www.udemy.com/api-2.0/users/me/subscribed-courses/{course_id}/lectures/{id_lecture}/'
+           f'supplementary-assets/{asset_id}/?fields[asset]=external_url')
+    try:
+        # Faz a solicitação GET com os cabeçalhos
+        response = requests.get(url, headers=HEADERS_USER)
+        data = []
+        # Exibe o código de status
+        if response.status_code == 200:
+            a = json.loads(response.text)
+            return a
+        else:
+            UnhandledExceptions(f"erro ao obter dados de aulas!! {response.status_code}")
+
+    except requests.ConnectionError as e:
+        UdemyUserApiExceptions(f"Erro de conexão: {e}")
+    except requests.Timeout as e:
+        UdemyUserApiExceptions(f"Tempo de requisição excedido: {e}")
+    except requests.TooManyRedirects as e:
+        UdemyUserApiExceptions(f"Limite de redirecionamentos excedido: {e}")
+    except requests.HTTPError as e:
+        UdemyUserApiExceptions(f"Erro HTTP: {e}")
+    except Exception as e:
+        UnhandledExceptions(f"Errro Ao Obter Mídias:{e}")
+
+
 def extract_files(supplementary_assets: list) -> list:
     """Obtém o ID da lecture, o ID do asset, o asset_type e o filename."""
     files = []
     for item in supplementary_assets:
+        # print(f'DEBUG files:\n{item}\n\n')
         lecture_title = item.get('lecture_title')
         lecture_id = item.get('lecture_id')
         asset = item.get('asset', {})
@@ -131,14 +338,15 @@ def extract_files(supplementary_assets: list) -> list:
         asset_type = asset.get('asset_type')
         filename = asset.get('filename')
         title = asset.get('title')
-
+        external_url = asset.get('is_external', None)
         files.append({
             'lecture_id': lecture_id,
             'asset_id': asset_id,
             'asset_type': asset_type,
             'filename': filename,
             'title': title,
-            'lecture_title': lecture_title
+            'lecture_title': lecture_title,
+            'ExternalLink': external_url
         })
     return files
 
@@ -257,3 +465,37 @@ def format_size(byte_size):
             return f"{byte_size / TB:.2f} TB"
     except Exception as e:
         return byte_size
+
+
+def lecture_infor(course_id: int, id_lecture: int):
+    edpoint = (f"https://www.udemy.com/api-2.0/users/me/subscribed-courses/{course_id}/lectures/{id_lecture}/?"
+               f"fields[asset]=media_license_token&q=0.06925737374647678")
+    r = requests.get(edpoint, headers=HEADERS_USER)
+    if r.status_code == 200:
+        return json.loads(r.text)
+
+
+def assets_infor(course_id: int, id_lecture: int, assets_id: int):
+    endpoint = (f'https://www.udemy.com/api-2.0/assets/{assets_id}/?fields[asset]=@min,status,delayed_asset_message,'
+                f'processing_errors,body&course_id={course_id}&lecture_id={id_lecture}')
+    r = requests.get(endpoint, headers=HEADERS_USER)
+    if r.status_code == 200:
+        dt = json.loads(r.text)
+        body = dt.get("body")
+        title = lecture_infor(course_id=course_id, id_lecture=id_lecture).get("title")
+        return save_html(body, title_lecture=title)
+
+
+def save_html(body, title_lecture):
+    html_content = f"""<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <title>{title_lecture}</title>
+</head>
+<body>
+{body}
+</body>
+</html>"""
+
+    return html_content

udemy_userAPI/authenticate.py

@@ -11,9 +11,17 @@ class UdemyAuth:
         """Autenticação na plataforma udemy de maneira segura, atencao ao limite de logins,recomendo que apos logar
         nao use novamnete o metodo login use apenas o verifcador de login para evitar bloqueios temporários..."""
         self.__cookie_dict = {}
-        dir_out = '.udemy_userAPI'
-        os.makedirs(os.path.join(os.path.expanduser('~'), dir_out), exist_ok=True)
-        self.__user_dir = os.path.join(os.path.expanduser('~'), dir_out)
+        # Diretório do arquivo atual
+        current_directory = os.path.dirname(__file__)
+        # dir cache
+        cache = '.cache'
+        cache_dir = os.path.join(current_directory, cache)
+        os.makedirs(cache_dir, exist_ok=True)
+        # Cria o diretório completo para a API do usuário
+        self.__user_dir = os.path.join(cache_dir)
+        # Cria o caminho completo para um arquivo específico
+        file_name = '.udemy_userAPI'  # Nome do arquivo
+        self.__file_path = os.path.join(self.__user_dir, file_name)
 
     def __make_cookies(self, client_id: str, access_token: str, csrf_token: str):
         self.__cookie_dict = {
@@ -29,12 +37,12 @@ class UdemyAuth:
         def verif_config():
             # Verificar se o arquivo .userLogin existe e carregar cookies se existir
             try:
-                with open(fr'{self.__user_dir}\.Udemy_userLogin', 'rb') as f:
+                with open(fr'{self.__file_path}', 'rb') as f:
                     cookies = pickle.load(f)
                     cookies_dict = {cookie.name: cookie.value for cookie in cookies}
                     cookies_str = "; ".join([f"{key}={value}" for key, value in cookies_dict.items()])
                     return cookies_str
-            except FileNotFoundError:
+            except Exception as e:
                 return False
 
         log = verif_config()
@@ -81,82 +89,94 @@ class UdemyAuth:
 
     def login(self, email: str, password: str):
         """efetuar login na udemy"""
-        # Inicializa uma sessão usando cloudscraper para contornar a proteção Cloudflare
-        s = cloudscraper.create_scraper()
-
-        # Faz uma requisição GET à página de inscrição para obter o token CSRF
-        r = s.get(
-            "https://www.udemy.com/join/signup-popup/",
-            headers={"User-Agent": "okhttp/4.9.2 UdemyAndroid 8.9.2(499) (phone)"},
-        )
-
-        # Extrai o token CSRF dos cookies
-        csrf_token = r.cookies["csrftoken"]
-
-        # Prepara os dados para o login
-        data = {
-            "csrfmiddlewaretoken": csrf_token,
-            "locale": "pt_BR",
-            "email": email,
-            "password": password,
-        }
-
-        # Atualiza os cookies e cabeçalhos da sessão
-        s.cookies.update(r.cookies)
-        s.headers.update(
-            {
-                "User-Agent": "okhttp/4.9.2 UdemyAndroid 8.9.2(499) (phone)",
-                "Accept": "application/json, text/plain, */*",
-                "Accept-Language": "en-GB,en;q=0.5",
-                "Referer": "https://www.udemy.com/join/login-popup/?locale=en_US&response_type=html&next=https%3A%2F"
-                           "%2Fwww.udemy.com%2F",
-                "Origin": "https://www.udemy.com",
-                "DNT": "1",
-                "Connection": "keep-alive",
-                "Sec-Fetch-Dest": "empty",
-                "Sec-Fetch-Mode": "cors",
-                "Sec-Fetch-Site": "same-origin",
-                "Pragma": "no-cache",
-                "Cache-Control": "no-cache",
+        try:
+            # Inicializa uma sessão usando cloudscraper para contornar a proteção Cloudflare
+            s = cloudscraper.create_scraper()
+
+            # Faz uma requisição GET à página de inscrição para obter o token CSRF
+            r = s.get(
+                "https://www.udemy.com/join/signup-popup/",
+                headers={"User-Agent": "okhttp/4.9.2 UdemyAndroid 8.9.2(499) (phone)"},
+            )
+
+            # Extrai o token CSRF dos cookies
+            csrf_token = r.cookies["csrftoken"]
+
+            # Prepara os dados para o login
+            data = {
+                "csrfmiddlewaretoken": csrf_token,
+                "locale": "pt_BR",
+                "email": email,
+                "password": password,
             }
-        )
-
-        # Tenta fazer login com as credenciais fornecidas
-        r = s.post(
-            "https://www.udemy.com/join/login-popup/?response_type=json",
-            data=data,
-            allow_redirects=False,
-        )
-
-        # Verifica a resposta para determinar se o login foi bem-sucedido
-        if "returnUrl" in r.text:
-            self.__make_cookies(r.cookies.get("client_id"), r.cookies.get("access_token"), csrf_token)
-            self.__save_cookies(s.cookies)
-        else:
-            login_error = r.json().get("error", {}).get("data", {}).get("formErrors", [])[0]
-            if login_error[0] == "Y":
-                raise LoginException("Você excedeu o número máximo de solicitações por hora.")
-            elif login_error[0] == "T":
-                raise LoginException("Email ou senha incorretos")
-            else:
-                raise UnhandledExceptions(login_error)
 
-        return s
+            # Atualiza os cookies e cabeçalhos da sessão
+            s.cookies.update(r.cookies)
+            s.headers.update(
+                {
+                    "User-Agent": "okhttp/4.9.2 UdemyAndroid 8.9.2(499) (phone)",
+                    "Accept": "application/json, text/plain, */*",
+                    "Accept-Language": "en-GB,en;q=0.5",
+                    "Referer": "https://www.udemy.com/join/login-popup/?locale=en_US&response_type=html&next=https%3A%2F"
+                               "%2Fwww.udemy.com%2F",
+                    "Origin": "https://www.udemy.com",
+                    "DNT": "1",
+                    "Connection": "keep-alive",
+                    "Sec-Fetch-Dest": "empty",
+                    "Sec-Fetch-Mode": "cors",
+                    "Sec-Fetch-Site": "same-origin",
+                    "Pragma": "no-cache",
+                    "Cache-Control": "no-cache",
+                }
+            )
+
+            # Tenta fazer login com as credenciais fornecidas
+            r = s.post(
+                "https://www.udemy.com/join/login-popup/?response_type=json",
+                data=data,
+                allow_redirects=False,
+            )
+
+            # Verifica a resposta para determinar se o login foi bem-sucedido
+            if "returnUrl" in r.text:
+                self.__make_cookies(r.cookies.get("client_id"), r.cookies.get("access_token"), csrf_token)
+                self.__save_cookies(s.cookies)
+            else:
+                login_error = r.json().get("error", {}).get("data", {}).get("formErrors", [])[0]
+                if login_error[0] == "Y":
+                    raise LoginException("Você excedeu o número máximo de solicitações por hora.")
+                elif login_error[0] == "T":
+                    raise LoginException("Email ou senha incorretos")
+                else:
+                    raise UnhandledExceptions(login_error)
+
+            return s
+        except Exception as e:
+            LoginException(e)
 
     def __save_cookies(self, cookies):
-        with open(fr'{self.__user_dir}\.Udemy_userLogin', 'wb') as f:
-            pickle.dump(cookies, f)
+        try:
+            with open(fr'{self.__file_path}', 'wb') as f:
+                pickle.dump(cookies, f)
+        except Exception as e:
+            LoginException(e)
 
     @property
     def load_cookies(self) -> str:
         """carrega cookies e retorna-os em uma string formatada"""
-        file = os.path.join(fr'{self.__user_dir}\.Udemy_userLogin')
-        if os.path.exists(file):
-            with open(fr'{self.__user_dir}\.Udemy_userLogin', 'rb') as f:
-                cookies = pickle.load(f)
-            cookies_dict = {cookie.name: cookie.value for cookie in cookies}
-            cookies_str = "; ".join([f"{key}={value}" for key, value in cookies_dict.items()])
-            return cookies_str
-        else:
-            raise LoginException()
+        try:
+            file = os.path.join(fr'{self.__file_path}')
+            if os.path.exists(file):
+                with open(fr'{self.__file_path}', 'rb') as f:
+                    cookies = pickle.load(f)
+                cookies_dict = {cookie.name: cookie.value for cookie in cookies}
+                cookies_str = "; ".join([f"{key}={value}" for key, value in cookies_dict.items()])
+                return cookies_str
+            else:
+                return 'None'
+        except Exception as e:
+            LoginException(e)
 
+    def remove_cookies(self):
+        if os.path.exists(self.__file_path):
+            os.remove(self.__file_path)

udemy_userAPI/bultins.py

@@ -1,8 +1,33 @@
-import requests
 import json
+from typing import Any
+import requests
+from .api import get_links, remove_tag, parser_chapers, extract_files, HEADERS_USER, assets_infor, get_add_files, \
+    get_files_aule, get_external_liks, extract, get_pssh, organize_streams, get_mpd_file, get_highest_resolution
 from .sections import get_course_infor
-from .api import get_links, remove_tag, parser_chapers, extract_files, HEADERS_USER
-
+from .mpd_analyzer import MPDParser
+
+
+class DRM:
+    def __init__(self, license_token: str, get_media_sources: list):
+        self.__mpd_content = None
+        self.__dash_url = organize_streams(streams=get_media_sources).get('dash')
+        self.__token = license_token
+        self.get_key_for_lesson()
+
+    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
 
 
 class Files:
@@ -11,29 +36,44 @@ class Files:
         self.__id_course = id_course
 
     @property
-    def get_download_url(self) -> dict[list]:
+    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 = {}
-        download_urls = ''
+        download_urls = []
         for files in self.__data:
             lecture_id = files.get('lecture_id', None)
             asset_id = files.get('asset_id', None)
             title = files.get("title", None)
-            if asset_id and title and lecture_id:
+            lecture_title = files.get('lecture_title')
+            external_link = files.get('ExternalLink')
+            if external_link:
+                lnk = get_external_liks(course_id=self.__id_course, id_lecture=lecture_id, asset_id=asset_id)
+                dt_file = {'title-file': title, 'lecture_title': lecture_title, 'lecture_id': lecture_id,
+                           'external_link': external_link,
+                           'data-file': lnk.get('external_url', None)}
+                return dt_file
+            if asset_id and title and lecture_id and not external_link:
                 resp = requests.get(
-                    f"https://www.udemy.com/api-2.0/users/me/subscribed-courses/{self.__id_course}/lectures/{lecture_id}/supplementary-assets/{asset_id}/?fields[asset]=download_urls",
+                    f"https://www.udemy.com/api-2.0/users/me/subscribed-courses/{self.__id_course}/lectures/"
+                    f"{lecture_id}/supplementary-assets/{asset_id}/?fields[asset]=download_urls",
                     headers=HEADERS_USER)
                 if resp.status_code == 200:
                     da = json.loads(resp.text)
-                    download_urls = da['download_urls']
+                    ## para cdaa dict de um fle colocar seu titulo:
+                    dt_file = {'title-file': title, 'lecture_title': lecture_title, 'lecture_id': lecture_id,
+                               'external_link': external_link,
+                               'data-file': da['download_urls']}
+                    download_urls.append(dt_file)
         return download_urls
 
 
 class Lecture:
     """CRIAR objetos aula(lecture) do curso e extrair os dados.."""
 
-    def __init__(self, data: dict):
+    def __init__(self, data: dict, course_id: int, additional_files):
+        self.__course_id = course_id
         self.__data = data
+        self.__additional_files = additional_files
         self.__asset = self.__data.get("asset")
 
     @property
@@ -86,9 +126,15 @@ class Lecture:
         return self.__asset.get('media_license_token')
 
     @property
-    def course_is_drmed(self) -> bool:
-        """verifica se possui DRM.."""
-        return self.__asset.get('course_is_drmed')
+    def course_is_drmed(self):
+        """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'):
+            d = DRM(license_token=self.get_media_license_token,
+                    get_media_sources=self.get_media_sources)
+            return d
+        else:
+            return self.__asset.get('course_is_drmed')
 
     @property
     def get_download_urls(self) -> list:
@@ -105,6 +151,18 @@ class Lecture:
         """obtem slides se tiver.."""
         return self.__asset.get('slides')
 
+    @property
+    def get_articles(self):
+        d = assets_infor(course_id=self.__course_id, id_lecture=self.get_lecture_id, assets_id=self.__asset.get("id"))
+        return d
+
+    @property
+    def get_resources(self):
+        """obtem os recurso adconais reaioanddos a aula"""
+        files_add = get_files_aule(lecture_id_filter=self.get_lecture_id, data=self.__additional_files)
+        f = Files(files=files_add, id_course=self.__course_id).get_download_url
+        return f
+
 
 class Course:
     """receb um dict com os dados do curso"""
@@ -114,6 +172,7 @@ class Course:
         self.__data = self.__parser_chapers
         self.__course_id = course_id
         self.__results = results
+        self.__additional_files_data = get_add_files(course_id)
         self.__information = self.__load_infor_course()
 
     def __load_infor_course(self) -> dict:
@@ -172,28 +231,42 @@ class Course:
 
     @property
     def get_lectures(self) -> list:
-        """Obtém uma lista com todos as aulas"""
+        """Obtém uma lista com todas as aulas."""
         videos = []
+        section_order = 1  # Iniciar a numeração das seções (capítulos)
+
         for chapter in self.__data.values():
-            for video in chapter.get('videos_in_chapter', []):
-                title = video['video_title']
-                id_lecture = video['id_lecture']
-                id_asset = video['id_asset']
-                dt = {"title": title, 'id_lecture': id_lecture, 'id_asset': id_asset}
+            for index, video in enumerate(chapter.get('videos_in_chapter', [])):
+                section = f"{section_order} {chapter.get('title_chapter')}"  # Adicionar numeração da seção
+                title = video.get('video_title')
+                id_lecture = video.get('lecture_id')
+                id_asset = video.get('asset_id')
+                dt = {
+                    'section': section,
+                    'title': title,
+                    'lecture_id': id_lecture,
+                    'asset_id': id_asset,
+                    'section_order': section_order,
+                    'lecture_order': index + 1  # Numeração da seção e vídeo
+                }
                 videos.append(dt)
+            section_order += 1  # Incrementar o número da seção após processar os vídeos do capítulo
         return videos
 
     def get_details_lecture(self, lecture_id: int) -> Lecture:
         """obter detalhes de uma aula específica, irá retornar o objeto Lecture"""
         links = get_links(course_id=self.__course_id, id_lecture=lecture_id)
-        lecture = Lecture(data=links)
+        additional_files = self.__load_assets()
+        # print(f'DEBUG files passados a lecture:\n{additional_files}\n\n')
+        lecture = Lecture(data=links, course_id=self.__course_id, additional_files=additional_files)
         return lecture
 
     @property
-    def get_additional_files(self) -> dict[list]:
+    def get_additional_files(self) -> list[Any]:
         """Retorna a lista de arquivos adcionais de um curso."""
         supplementary_assets = []
-        for item in self.__results.get('results', []):
+        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')
@@ -206,5 +279,25 @@ class Course:
                         'asset': asset
                     })
         files = extract_files(supplementary_assets)
+        # print(f'DEBUG files:\n{files}\n\n')
         files_objt = Files(files=files, id_course=self.__course_id).get_download_url
         return files_objt
+
+    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')
+                title = item.get('title')
+                assets = item.get('supplementary_assets', [])
+                for asset in assets:
+                    supplementary_assets.append({
+                        'lecture_id': id,
+                        'lecture_title': title,
+                        'asset': asset
+                    })
+        files = extract_files(supplementary_assets)
+        return files

udemy_userAPI/mpd_analyzer/__init__.py

@@ -0,0 +1,3 @@
+# Biblioteca para análise de arquivos MPD
+from .mpd_parser import MPDParser
+__version__ = '0.1.0'

udemy_userAPI/mpd_analyzer/mpd_parser.py

@@ -0,0 +1,357 @@
+import re
+import xml.etree.ElementTree as ET
+
+
+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
+    """
+
+    def __init__(self, mpd_file_path: str, headers=None,is_file=None):
+        """
+        Inicializa o parser para um arquivo MPD a partir de um caminho de arquivo.
+
+        Args:
+            mpd_file_path (str): Caminho do arquivo MPD.
+            headers (dict, opcional): Headers HTTP adicionais para requisição, caso necessário.
+        """
+        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):
+        """
+        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.
+        """
+        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)
+        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):
+        """
+        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.
+        """
+        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)
+        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', '')
+
+            # 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):
+        """
+        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
+
+    @staticmethod
+    def __build_url(template, rep_id, bandwidth):
+        """
+        Constrói uma URL substituindo placeholders em um template de URL.
+
+        Args:
+            template (str): Template de URL com placeholders.
+            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
+
+    @staticmethod
+    def __calculate_segment_url(media_template, segment_number, segment_time, rep_id, bandwidth):
+        """
+        Constrói a URL de um segmento substituindo placeholders por valores reais.
+
+        Args:
+            media_template (str): Template de URL do segmento.
+            segment_number (int): Número do segmento.
+            segment_time (int): Timestamp do segmento.
+            rep_id (str): ID da representação.
+            bandwidth (int): Largura de banda da representação.
+
+        Returns:
+            str: URL do segmento com placeholders substituídos.
+        """
+        url = media_template.replace('$Number$', str(segment_number))
+        url = url.replace('$RepresentationID$', rep_id).replace('$Bandwidth$', str(bandwidth))
+        if '$Time$' in url:
+            url = url.replace('$Time$', str(segment_time))
+        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.
+
+        Args:
+            resolution (tuple): Resolução desejada (largura, altura).
+
+        Raises:
+            Exception: Se a resolução não estiver disponível no manifesto.
+        """
+        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()')
+
+    def get_selected_video_init_url(self):
+        """
+        Retorna o URL de inicialização para a resolução de vídeo selecionada.
+
+        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')
+        return None
+
+    def get_all_video_resolutions(self):
+        """
+        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.
+        """
+        return {bandwidth: info['audio_channels'] for bandwidth, info in self.audio_representations.items()}

udemy_userAPI/udemy.py

@@ -30,10 +30,25 @@ class Udemy:
 
     @property
     def my_subscribed_courses(self) -> list[dict]:
-        """obtém os cursos que o usuário esatá inscrito"""
+        """Obtém os cursos que o usuário está inscrito, excluindo listas vazias ou nulas"""
         try:
-            courses = get_courses_plan(tipe='default')
-            return courses
+            # Obtém os cursos
+            courses1 = get_courses_plan(tipe='default')  # lista de cursos padrão
+            courses2 = get_courses_plan(tipe='plan')  # lista de cursos de um plano
+
+            # Cria uma lista vazia para armazenar os cursos válidos
+            all_courses = []
+
+            # Adiciona a lista somente se não estiver vazia ou nula
+            if courses1:
+                for i in courses1:
+                    all_courses.extend(i)
+            if courses2:
+                for i in courses2:
+                    all_courses.extend(i)
+
+            return all_courses
+
         except UdemyUserApiExceptions as e:
             UnhandledExceptions(e)
 

{udemy_userAPI-0.1.5.dist-info → udemy_userAPI-0.1.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: udemy_userAPI
-Version: 0.1.5
+Version: 0.1.7
 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
@@ -18,7 +18,7 @@ Requires-Dist: cloudscraper
 # udemy-userAPI
 
 
-![Versão](https://img.shields.io/badge/version-0.1.5-orange)
+![Versão](https://img.shields.io/badge/version-0.1.6-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/wiki)

udemy_userAPI-0.1.7.dist-info/RECORD

@@ -0,0 +1,15 @@
+udemy_userAPI/__init__.py,sha256=BPle89xE_CMTKKe_Lw6jioYLgpH-q_Lpho2S-n1PIUA,206
+udemy_userAPI/__version__.py,sha256=LQkqzSPXq6RAMSeuzbyVp9NNPiqy1dPbWwBYG106raU,404
+udemy_userAPI/api.py,sha256=7wWkuXwBvTpBLsAl7LaZnJKA6If0cL942CMbjY4GZJs,18782
+udemy_userAPI/authenticate.py,sha256=inKtOzVEDExmo88-hq1_WQKrZmPsfx9r93AqCq0vnLo,7720
+udemy_userAPI/bultins.py,sha256=bvgYC8cYMH26kqNzqhFlrCHR3M9aGQV5UsuemjKdM0k,12310
+udemy_userAPI/exeptions.py,sha256=nuZoAt4i-ctrW8zx9LZtejrngpFXDHOVE5cEXM4RtrY,508
+udemy_userAPI/sections.py,sha256=zPyDhvTIQCL0nbf7OJZG28Kax_iooILQ_hywUwvHoL8,4043
+udemy_userAPI/udemy.py,sha256=ceaXVTbQhSYkHnPIpYWUVtT6IT6jBvzYO_k4B7EFyj8,2154
+udemy_userAPI/mpd_analyzer/__init__.py,sha256=i3JVWyvcFLaj5kPmx8c1PgjsLht7OUIQQClD4yqYbo8,102
+udemy_userAPI/mpd_analyzer/mpd_parser.py,sha256=_vw1feJXDjw5fQLOmA5-H3UklX_30Pbl__HtDUqvp3c,17283
+udemy_userAPI-0.1.7.dist-info/LICENSE,sha256=l4jdKYt8gSdDFOGr09vCKnMn_Im55XIcQKqTDEtFfNs,1095
+udemy_userAPI-0.1.7.dist-info/METADATA,sha256=VyI2ApvWAQ3MAMyAyCylR1xlPy8WsxRtPBAHBtRVewU,1368
+udemy_userAPI-0.1.7.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
+udemy_userAPI-0.1.7.dist-info/top_level.txt,sha256=ijTINaSDRKhdahY_X7dmSRFTxBIwQErWv9ATCG55mog,14
+udemy_userAPI-0.1.7.dist-info/RECORD,,

{udemy_userAPI-0.1.5.dist-info → udemy_userAPI-0.1.7.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (74.1.2)
+Generator: setuptools (75.3.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

udemy_userAPI-0.1.5.dist-info/RECORD

@@ -1,13 +0,0 @@
-udemy_userAPI/__init__.py,sha256=BPle89xE_CMTKKe_Lw6jioYLgpH-q_Lpho2S-n1PIUA,206
-udemy_userAPI/__version__.py,sha256=3f2y6FLB2-B7X9VGnzA9QP98hyUkSzMQJL2MbMFp6wY,404
-udemy_userAPI/api.py,sha256=5WRyVWHOCCNC0zFJudA91--7xwGHSmpO1_xcDz7fFqQ,9545
-udemy_userAPI/authenticate.py,sha256=DrO-kBX5GG46cz4cHoTZhDkMkoZB1fxhfUeU9e0wTfY,6832
-udemy_userAPI/bultins.py,sha256=egnphL3M7lEd1Hh80vHRVdAInxAr_YbwNHSwgt8NWec,7503
-udemy_userAPI/exeptions.py,sha256=nuZoAt4i-ctrW8zx9LZtejrngpFXDHOVE5cEXM4RtrY,508
-udemy_userAPI/sections.py,sha256=zPyDhvTIQCL0nbf7OJZG28Kax_iooILQ_hywUwvHoL8,4043
-udemy_userAPI/udemy.py,sha256=VcGcy0nDWTLj5pv51tUtAXmKAGaTauVCnquSdmZWE4Q,1584
-udemy_userAPI-0.1.5.dist-info/LICENSE,sha256=l4jdKYt8gSdDFOGr09vCKnMn_Im55XIcQKqTDEtFfNs,1095
-udemy_userAPI-0.1.5.dist-info/METADATA,sha256=VesuLzA3JqGbJs4yBcfz4lqo0aH_k2x07t-EFdBC03A,1368
-udemy_userAPI-0.1.5.dist-info/WHEEL,sha256=cVxcB9AmuTcXqmwrtPhNK88dr7IR_b6qagTj0UvIEbY,91
-udemy_userAPI-0.1.5.dist-info/top_level.txt,sha256=ijTINaSDRKhdahY_X7dmSRFTxBIwQErWv9ATCG55mog,14
-udemy_userAPI-0.1.5.dist-info/RECORD,,