udemy-userAPI 0.3.2__py3-none-any.whl

udemy_userAPI/mpd_analyzer/mpd_parser.py

@@ -0,0 +1,224 @@
+import re
+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.
+    """
+
+    def __init__(self, mpd_content: str):
+        """
+        Inicializa o parser para um arquivo MPD.
+
+        Args:
+            mpd_content (str): Caminho do arquivo MPD ou conteúdo bruto.
+        """
+        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):
+        """
+        Parsing básico do MPD (versão 1).
+        """
+        content = self._mpd_content
+        root = Et.fromstring(content)
+        ns = {'dash': 'urn:mpeg:dash:schema:mpd:2011'}
+
+        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)
+
+    def __parse_mpd_v2(self):
+        """
+        Parsing avançado do MPD (versão 2).
+        """
+        content = self._mpd_content
+        root = Et.fromstring(content)
+        ns = {'dash': 'urn:mpeg:dash:schema:mpd:2011'}
+
+        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
+
+    def __parse_adaptation_set(self, adaptation_set, mime_type, ns):
+        """
+        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.
+        """
+        # 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
+
+        # 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):
+        """
+        Processa uma representação de mídia (vídeo ou áudio).
+
+        Args:
+            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:
+            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 __build_url(template, rep_id, bandwidth, segment_time=None, segment_number=None):
+        """
+        Constrói uma URL substituindo placeholders.
+
+        Args:
+            template (str): Template de URL.
+            rep_id (str): ID 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 formatada.
+        """
+        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 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'
+                f'\t=> Resoluções disponíveis no arquivo: {self.get_all_video_resolutions()}')
+
+    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())

udemy_userAPI/sections.py

@@ -0,0 +1,117 @@
+import json
+import requests
+from .exeptions import UdemyUserApiExceptions, LoginException
+
+
+def get_courses_plan(tipe: str) -> list:
+    """ Obtém uma lista de cursos com base no tipo de plano.
+
+    Args: tipe (str): Tipo de plano ('default' ou 'plan'). Returns: list: Lista de cursos. Raises: LoginException: Se
+    a sessão estiver expirada. UdemyUserApiExceptions: Se houver erro ao obter os cursos."""
+    from .api import HEADERS_USER
+    from .authenticate import UdemyAuth
+    auth = UdemyAuth()
+    if not auth.verif_login():
+        raise LoginException("Sessão expirada!")
+    courses_data = []
+    if tipe == 'default':
+        response = requests.get(f"https://www.udemy.com/api-2.0/users/me/subscribed-courses/?page_size=1000"
+                                f"&ordering=-last_accessed&fields[course]=image_240x135,title,completion_ratio&"
+                                f"is_archived=false",
+                                headers=HEADERS_USER)
+        if response.status_code == 200:
+            r = json.loads(response.text)
+            results = r.get("results", None)
+            if results:
+                courses_data.append(results)
+        else:
+            r = json.loads(response.text)
+            raise UdemyUserApiExceptions(f"Error obtain courses 'default' -> {r}")
+    elif tipe == 'plan':
+        response2 = requests.get(
+            url="https://www.udemy.com/api-2.0/users/me/subscription-course-enrollments/?"
+                "fields[course]=@min,visible_instructors,image_240x135,image_480x270,completion_ratio,"
+                "last_accessed_time,enrollment_time,is_practice_test_course,features,num_collections,"
+                "published_title,buyable_object_type,remaining_time,is_assigned,next_to_watch_item,"
+                "is_in_user_subscription&fields[user]=@min&ordering=-last_accessed&page_size=1000&"
+                "max_progress=99.9&fields[lecture]=@min,content_details,asset,url,thumbnail_url,"
+                "last_watched_second,object_index&fields[quiz]=@min,content_details,asset,url,object_index&"
+                "fields[practice]=@min,content_details,asset,estimated_duration,learn_url,object_index",
+            headers=HEADERS_USER)
+        if response2.status_code == 200:
+            r = json.loads(response2.text)
+            results2 = r.get("results", None)
+            if results2:
+                courses_data.append(results2)
+        else:
+            r = json.loads(response2.text)
+            raise UdemyUserApiExceptions(f"Error obtain courses 'plan' -> {r}")
+    else:
+        raise UdemyUserApiExceptions("Atenção dev! os parametros são : 'plan' e 'default'")
+    return courses_data
+
+
+def get_details_courses(course_id):
+    """
+    Obtém detalhes de um curso específico.
+
+    Args:
+        course_id (int): ID do curso.
+
+    Returns:
+        dict: Dicionário contendo os detalhes do curso.
+
+    Raises:
+        LoginException: Se a sessão estiver expirada.
+        UdemyUserApiExceptions: Se houver erro ao obter os detalhes do curso.
+    """
+    from .api import HEADERS_USER
+    from .authenticate import UdemyAuth
+    auth = UdemyAuth()
+    if not auth.verif_login():
+        raise LoginException("Sessão expirada!")
+    response = requests.get(
+        f"https://www.udemy.com/api-2.0/courses/{course_id}/subscriber-curriculum-items/?"
+        f"caching_intent=True&fields%5Basset%5D=title%2Cfilename%2Casset_type%2Cstatus%2Ctime_estimation%2"
+        f"Cis_external&fields%5Bchapter%5D=title%2Cobject_index%2Cis_published%2Csort_order&fields%5Blecture"
+        f"%5D=title%2Cobject_index%2Cis_published%2Csort_order%2Ccreated%2Casset%2Csupplementary_assets%2"
+        f"Cis_free&fields%5Bpractice%5D=title%2Cobject_index%2Cis_published%2Csort_order&fields%5Bquiz%5D="
+        f"title%2Cobject_index%2Cis_published%2Csort_order%2Ctype&pages&page_size=400&fields[lecture]=asset,"
+        f"description,download_url,is_free,last_watched_second&fields[asset]=asset_type,length,"
+        f"media_license_token,course_is_drmed,external_url&q=0.3108014137011559",
+        headers=HEADERS_USER)
+    if response.status_code == 200:
+        resposta = json.loads(response.text)
+        return resposta
+    else:
+        raise UdemyUserApiExceptions(f"Erro ao obter detalhes do curso! Código de status: {response.status_code}")
+
+
+def get_course_infor(course_id):
+    """
+    Obtém informações de um curso específico.
+
+    Args:
+        course_id (int): ID do curso.
+
+    Returns:
+        dict: Dicionário contendo as informações do curso.
+
+    Raises:
+        LoginException: Se a sessão estiver expirada.
+        UdemyUserApiExceptions: Se houver erro ao obter as informações do curso.
+    """
+    from .api import HEADERS_USER
+    from .authenticate import UdemyAuth
+    auth = UdemyAuth()
+    if not auth.verif_login():
+        raise LoginException("Sessão expirada!")
+    end_point = (
+        f'https://www.udemy.com/api-2.0/courses/{course_id}/?fields[course]=title,context_info,primary_category,'
+        'primary_subcategory,avg_rating_recent,visible_instructors,locale,estimated_content_length,'
+        'num_subscribers')
+    response = requests.get(end_point, headers=HEADERS_USER)
+    if response.status_code == 200:
+        return json.loads(response.text)
+    else:
+        raise UdemyUserApiExceptions("Erro ao obter informações do curso!")

udemy_userAPI/udemy.py

@@ -0,0 +1,93 @@
+from .exeptions import UdemyUserApiExceptions, UnhandledExceptions, LoginException
+from .sections import get_courses_plan, get_details_courses
+from .api import HEADERS_USER
+from .bultins import Course
+from .authenticate import UdemyAuth
+
+auth = UdemyAuth()
+verif_login = auth.verif_login()
+
+
+class Udemy:
+    """Wrapper para API de usuário da plataforma Udemy"""
+
+    def __init__(self):
+        """
+        Inicializa o objeto Udemy.
+
+        Raises:
+            LoginException: Se a sessão estiver expirada.
+        """
+        self.__headers = HEADERS_USER
+        if not verif_login:
+            raise LoginException("Sessão expirada!")
+
+    @staticmethod
+    def my_subscribed_courses_by_plan() -> list[dict]:
+        """
+        Obtém os cursos que o usuário está inscrito, obtidos através de planos (assinatura).
+
+        Returns:
+            list[dict]: Lista de cursos inscritos através de planos.
+
+        Raises:
+            UdemyUserApiExceptions: Se houver erro ao obter os cursos.
+        """
+        try:
+            courses = get_courses_plan(tipe='plan')
+            return courses
+        except UdemyUserApiExceptions as e:
+            raise UnhandledExceptions(e)
+
+    @staticmethod
+    def my_subscribed_courses() -> list[dict]:
+        """
+        Obtém os cursos que o usuário está inscrito, excluindo listas vazias ou nulas.
+
+        Returns:
+            list[dict]: Lista de todos os cursos inscritos.
+
+        Raises:
+            UdemyUserApiExceptions: Se houver erro ao obter os cursos.
+        """
+        try:
+            # 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:
+            raise UnhandledExceptions(e)
+
+    @staticmethod
+    def get_details_course(course_id):
+        """
+        Obtém detalhes de um curso através do ID.
+
+        Args:
+            course_id: O ID do curso.
+
+        Returns:
+            Course: Um objeto Course contendo os detalhes do curso.
+
+        Raises:
+            UnhandledExceptions: Se houver erro ao obter os detalhes do curso.
+        """
+        try:
+            d = get_details_courses(course_id)
+            b = Course(course_id=course_id, results=d)
+            return b
+        except UnhandledExceptions as e:
+            raise UnhandledExceptions(e)

udemy_userAPI-0.3.2.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 PauloCesar-dev404
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

udemy_userAPI-0.3.2.dist-info/METADATA

@@ -0,0 +1,34 @@
+Metadata-Version: 2.1
+Name: udemy_userAPI
+Version: 0.3.2
+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
+License: MIT
+Project-URL: GitHub, https://github.com/PauloCesar-dev404/udemy-userAPI
+Project-URL: Bugs/Melhorias, https://github.com/PauloCesar-dev404/udemy-userAPI/issues
+Project-URL: Documentação, https://github.com/PauloCesar-dev404/udemy-userAPI/wiki
+Keywords: udemy,udemy python,pyudemy,udemy_userAPI,udemy api
+Platform: any
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests
+Requires-Dist: cloudscraper
+Requires-Dist: pywidevine
+
+# udemy-userAPI
+
+
+![Versão](https://img.shields.io/badge/version-0.3.2-orange)
+![Licença](https://img.shields.io/badge/license-MIT-orange)
+[![Sponsor](https://img.shields.io/badge/💲Donate-yellow)](https://paulocesar-dev404.github.io/me-apoiando-online/)
+[![Sponsor](https://img.shields.io/badge/Documentation-green)](https://github.com/PauloCesar-dev404/udemy-userAPI/blob/main/docs/iniciando.md)
+
+
+Obtenha detalhes de cursos da plataforma udemy com a api de usuário,usando esta lib
+
+
+- [x] Obter cursos inscritos(acesso por plano ou cursos free)
+- [x] Obter detalhes de Aulas
+- [x] Obter detalhes de um Curso
+

udemy_userAPI-0.3.2.dist-info/RECORD

@@ -0,0 +1,29 @@
+animation_consoles/__init__.py,sha256=5uHhe-PVZ54FHWxbF1sNvNt4fuQf3FtZWVo2Mjo11a8,40
+animation_consoles/animation.py,sha256=ZreNtdD0HYeqlRx-f1d1twUU4sOFTR7vJ3S6tMQpnHM,2122
+ffmpeg_for_python/__config__.py,sha256=nCPrYs1NkMnyfyg5ITw9wOar4nUJOxwONrItVpVBVBM,4719
+ffmpeg_for_python/__init__.py,sha256=-BMtoX8Yof_pnHra2OzoV3faxMubpMvUedMy8TqI8dc,214
+ffmpeg_for_python/__utils.py,sha256=Qy3J5f4lOIPcSNbTwiawfiHjYPdZ_tq7hafStnnqwA4,3263
+ffmpeg_for_python/__version__.py,sha256=HLFuN4n_leeJE5twr7yH2AAFyfIcEHzxElLRP1FUKmQ,422
+ffmpeg_for_python/exeptions.py,sha256=tg-TBdaq_NHxZOCAhkMttzwtJVILPAQPLOKqofe5PPA,3627
+ffmpeg_for_python/ffmpeg.py,sha256=G2VGHOIhErsqQI4OVlUnIQGmleNCjxyFqzNAMNnoD6I,7920
+m3u8_analyzer/M3u8Analyzer.py,sha256=aUgxk2jS84MFDNbjlOT8FRiJerFI_jGcKMu9uv1EwcE,36620
+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=aMKbixxAkks_VfsbQJs0sU6jFllEvVm4k3e-E32e5u8,405
+udemy_userAPI/api.py,sha256=oDVylMQ6CsMeJ7V7FKdjjjvY0GrHHqJdVMTTptQmSiE,24277
+udemy_userAPI/authenticate.py,sha256=gpHwS34WboQCpktQg6NsvLBJzX9AL8Do3Gk08PLR4GY,14133
+udemy_userAPI/bultins.py,sha256=ZEksThVSaDe7jsyeCqhCiFLJsy-pIN8EdnJ6Aoh4s9k,16428
+udemy_userAPI/exeptions.py,sha256=kfnPdZpqYY8nd0gnl6_Vh-MIz-XupmmbRPIuFnyXupk,692
+udemy_userAPI/sections.py,sha256=oP3jvbsWocemqhzzOAOoeL7ICF1f4gNvjL4FJBt47pE,5474
+udemy_userAPI/udemy.py,sha256=SpK0LI4hjO45nZDz5waw-Py-d0uulBb28TVjltyWBxM,2920
+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=PgUkHc5x8FTuXFCuYkWPZr9TaO_nsKalb02EFYl_zeA,8926
+udemy_userAPI-0.3.2.dist-info/LICENSE,sha256=l4jdKYt8gSdDFOGr09vCKnMn_Im55XIcQKqTDEtFfNs,1095
+udemy_userAPI-0.3.2.dist-info/METADATA,sha256=ir_5qB1Q1qu66M3pCaL9VN7BUZBX0MwStZg0iQ0r03k,1438
+udemy_userAPI-0.3.2.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+udemy_userAPI-0.3.2.dist-info/top_level.txt,sha256=ijTINaSDRKhdahY_X7dmSRFTxBIwQErWv9ATCG55mog,14
+udemy_userAPI-0.3.2.dist-info/RECORD,,

udemy_userAPI-0.3.2.dist-info/WHEEL

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

udemy_userAPI-0.3.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+udemy_userAPI