Dragon-Ball-API-Alejo 0.1__py3-none-any.whl

DragonBall/Constants/ScrapCharacter.py

@@ -0,0 +1,53 @@
+class ScrapCharacter:
+    # these names have to be exactly the same as the asyde region
+
+    sections = {
+        "names": "Nombres",
+        "data": "Datos",
+        "debut": "Debut"
+    }
+
+    # font for character names section
+
+    names = {
+        "japan_name": "nombre-ja",
+        "latin_name": "nombre-ja_latino",
+        "pronunciation_name": "pronunciación",
+        "other_names": "otros nombres"
+    }
+
+    # font for character data section
+
+    data = {
+        "gender": "sexo",
+        "birthday": "fecha de nacimiento",
+        "deaths": "fecha de muerte",
+        "age": "edad",
+        "species": "raza",
+        "occupation": "ocupación",
+        "origin": "procedencia",
+        "residence": "residencia",
+        "transformations": "transformaciones",
+        "fusion": "fusiones",
+        "family": "familia",
+        "affiliates": "afiliados"
+    }
+
+    # font for character debut section
+
+    debut = {
+        "sagas": "saga",
+        "debut": "Primera aparición",
+        "manga": "manga",
+        "volume": "tomo",
+        "anime": "anime",
+        "introduction": "arco"
+    }
+
+    # list of names to use according to sections
+
+    list_character = {
+        "names": list(names.values()),
+        "data": list(data.values()),
+        "debut": list(debut.values())
+    }

DragonBall/Constants/ScrapFusion.py

@@ -0,0 +1,36 @@
+class ScrapFusion:
+    # these names have to be exactly the same as the asyde region
+
+    sections = {
+        "names": "Nombres",
+        "data": "Otros datos",
+    }
+
+    # font for character names section
+
+    names = {
+        "japan_name": "nombre-ja",
+        "latin_name": "nombre-ja_latino",
+        "pronunciation_name": "pronunciación",
+        "other_names": "otros nombres"
+    }
+
+    # font for character data section
+
+    data = {
+        "gender": "sexo",
+        "date of origin": "fecha de origen",
+        "species": "raza",
+        "fusion": "fusionados",
+        "method_used": "método",
+        "transformations": "transformaciones",
+        "apparition": "aparición",
+        "debut": "Primera aparición"
+    }
+
+    # list of names to use according to sections
+
+    list_character = {
+        "names": list(names.values()),
+        "data": list(data.values()),
+    }

DragonBall/Constants/ScrapGames.py

@@ -0,0 +1,35 @@
+class ScrapGames:
+    # these names have to be exactly the same as the asyde region
+
+    sections = {
+        "names": "Nombres",
+        "data": "Datos",
+    }
+
+    # font for character names section
+
+    names = {
+        "japan_name": "nombre-ja",
+        "latin_name": "nombre-ja_latino",
+    }
+
+    # font for character data section
+
+    data = {
+        "engine_game": "Motor",
+        "platforms": "Plataforma",
+        "developers": "Desarrolladores",
+        "dealers": "Distribuidores",
+        "launch": "Lanzamiento",
+        "game_mode": "Modos de Juego",
+        "gender": "Género",
+        "classification": "Clasificaciones",
+        "sagas": "Sagas"
+    }
+
+    # list of names to use according to sections
+
+    list_character = {
+        "names": list(names.values()),
+        "data": list(data.values())
+    }

DragonBall/Constants/ScrapPlanet.py

@@ -0,0 +1,32 @@
+class ScrapPlanet:
+    # these names have to be exactly the same as the asyde region
+
+    sections = {
+        "names": "Nombres",
+        "data": "Datos",
+    }
+
+    # font for character names section
+
+    names = {
+        "japan_name": "nombre-ja",
+        "latin_name": "nombre-ja_latino",
+    }
+
+    # font for character data section
+
+    data = {
+        "localization": "localización",
+        "gobernant": "gobernante",
+        "residents": "residentes",
+        "especies": "especie",
+        "sagas": "saga",
+        "debut": "aparición",
+    }
+
+    # list of names to use according to sections
+
+    list_character = {
+        "names": list(names.values()),
+        "data": list(data.values())
+    }

DragonBall/Constants/ScrapSagas.py

@@ -0,0 +1,36 @@
+class ScrapSagas:
+    # these names have to be exactly the same as the asyde region
+
+    sections = {
+        "names": "Títulos",
+        "data": "Datos",
+        "serialization": "Serialización"
+    }
+
+    # font for character names section
+
+    names = {
+        "japan_name": "nombre-ja",
+        "latin_name": "nombre-ja_latino",
+    }
+
+    # font for character data section
+
+    data = {
+        "episodes": "número de episodios (Anime)",
+    }
+
+    # font for serialization data section
+
+    serialization = {
+        "first_emision": "primera emisión",
+        "last_emision": "última emisión",
+    }
+
+    # list of names to use according to sections
+
+    list_character = {
+        "names": list(names.values()),
+        "data": list(data.values()),
+        "serialization": list(serialization.values())
+    }

DragonBall/Constants/URLS.py

@@ -0,0 +1,15 @@
+class URL:
+    URL_BASE = "https://dragonball.fandom.com/"
+    URL_WIKI = "https://dragonball.fandom.com/es/wiki/"
+
+    HEADERS = {
+        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36",
+        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8",
+        "Accept-Language": "es-ES,es;q=0.8,en-US;q=0.5,en;q=0.3"
+    }
+
+    URL_LIST_CHARACTERS = URL_WIKI + "Lista_de_personajes"
+    URL_LIST_FUSIONS = URL_WIKI + "Lista_de_fusiones"
+    URL_LIST_PLANETS = URL_WIKI + "Lista_de_planetas"
+    URL_LIST_CHRONO = URL_WIKI + "Cronología"
+    URL_LIST_GAMES = URL_WIKI + "Lista_de_videojuegos"

DragonBall/Data/Characters.py

@@ -0,0 +1,130 @@
+import requests as requests
+from bs4 import BeautifulSoup
+
+from DragonBall.Constants.ScrapCharacter import ScrapCharacter
+from DragonBall.Constants.URLS import URL
+from DragonBall.Data.OutInformation import OutInformation
+from DragonBall.Soup.section import Section
+from DragonBall.Soup.summary import Summary
+from DragonBall.Soup.tags import Tags
+
+
+class Characters:
+    def __init__(self, name: str, all_data=False):
+        self.name = name
+        self.all_data = all_data
+
+    @classmethod
+    def character_list(cls, character_list: list):
+        return [Characters(i).character_information() for i in character_list]
+
+    @staticmethod
+    def list():
+        request = requests.get(URL.URL_LIST_CHARACTERS, headers=URL.HEADERS)
+        soup = BeautifulSoup(request.content.decode('utf-8'), "html.parser")
+        toc = soup.find("div", {"id": "toc"})
+        if not toc:
+            return {}
+        summary_data = toc.text.strip().splitlines()
+        return Summary.clean_list_summary(summary_data, [1, -1])
+
+    def character_information(self):
+        url = URL.URL_WIKI + self.name.replace(" ", "_")
+        request = requests.get(url, headers=URL.HEADERS)
+        soup = BeautifulSoup(request.content.decode('utf-8'), "html.parser")
+        list_section = Section.obtain_section_data(soup, 'aside')
+        basic_dict = self.__obtain_basic_data(soup, url)
+        section_dict = self.__evaluate_scrapper_section(list_section, list(list_section.keys()), ScrapCharacter)
+        return self.__show_information(basic_dict, section_dict)
+
+    def __obtain_basic_data(self, soup: BeautifulSoup, url: str):
+        name = self.__get_official_name(soup, "h1", "id", "firstHeading")
+        image = self.__get_image(soup, "a", "class", "image image-thumbnail")
+        description = self.__get_description_character(soup)
+        return {"url": url, "name": name, "image": image, "descripcion": description}
+
+    @staticmethod
+    def __get_official_name(soup: BeautifulSoup, tag: str, identification: str, element: str):
+        # Intento 1: Buscar el h1 con el id exacto
+        official_name = Tags.custom_catch_error(soup, tag, identification, element)
+        if official_name != OutInformation.RESOURCE_NOT_FOUND:
+            return official_name.get_text(strip=True)
+        
+        # Intento 2: Buscar CUALQUIER etiqueta <h1> en la página
+        h1 = soup.find("h1")
+        if h1:
+            return h1.get_text(strip=True)
+            
+        # Intento 3: Usar el título de la pestaña del navegador
+        if soup.title:
+            return soup.title.text.split("|")[0].strip()
+            
+        return OutInformation.RESOURCE_NOT_FOUND
+
+    @staticmethod
+    def __get_image(soup: BeautifulSoup, tag: str, identification: str, name: str):
+        found = soup.find(tag, attrs={identification: name})
+        if found:
+            return found.get("href")
+        return OutInformation.RESOURCE_NOT_FOUND
+
+    @staticmethod
+    def __get_description_character(soup: BeautifulSoup):
+        [remove_sup.extract() for remove_sup in soup.find_all('sup')]
+        try:
+            return next(
+                p.text.strip() for header in soup.find_all(['h2', 'h3']) if (p := header.find_next_sibling('p')))
+        except StopIteration:
+            return OutInformation.RESOURCE_NOT_FOUND
+
+    def __evaluate_scrapper_section(self, list_dict, list_search, tag_found: ScrapCharacter):
+        empty = self.__return_empty_section(list_dict)
+        if empty:
+            return empty
+
+        section_names = list(tag_found.sections.values())
+        names = list_dict.get(section_names[0], OutInformation.RESOURCE_NOT_FOUND)
+        data = list_dict.get(section_names[1], OutInformation.RESOURCE_NOT_FOUND)
+        debut = list_dict.get(section_names[2], OutInformation.RESOURCE_NOT_FOUND)
+
+        return {
+            "nombres": self.__names_section(names, tag_found.names) if section_names[0] in list_search else names,
+            "data": self.__data_section(data, tag_found.data) if section_names[1] in list_search else data,
+            "debut": self.__debut_section(debut, tag_found.debut) if section_names[2] in list_search else debut,
+        }
+
+    @staticmethod
+    def __return_empty_section(list_dict: dict):
+        if not list_dict:
+            return {
+                "nombres": OutInformation.RESOURCE_NOT_FOUND,
+                "data": OutInformation.RESOURCE_NOT_FOUND,
+                "debut": OutInformation.RESOURCE_NOT_FOUND,
+            }
+        return None
+
+    @staticmethod
+    def __names_section(name, lista_tags):
+        return {key: Tags.clean_text(Tags.catch_error(name, value)) for key, value in lista_tags.items()}
+
+    @staticmethod
+    def __data_section(data, lista_tags):
+        return {key: Tags.clean_text(Tags.catch_error(data, value)) for key, value in lista_tags.items()}
+
+    @staticmethod
+    def __debut_section(debut, lista_tags):
+        return {key: Tags.clean_text(Tags.catch_error(debut, value)) for key, value in lista_tags.items()}
+
+    def __show_information(self, dictionary_basic, dictionary_sections):
+        dictionary = {
+            "name": dictionary_basic['name'],
+            "image": dictionary_basic['image'],
+            "description": dictionary_basic['descripcion'],
+            "names": dictionary_sections['nombres'],
+            "data": dictionary_sections['data'],
+            "debut": dictionary_sections['debut'],
+            "url_scrap": dictionary_basic['url']
+        }
+        if self.all_data:
+            return dictionary
+        return OutInformation.clean_not_found_scrape(dictionary)

DragonBall/Data/Fusions.py

@@ -0,0 +1,122 @@
+import requests as requests
+from bs4 import BeautifulSoup
+
+from DragonBall.Constants.ScrapFusion import ScrapFusion
+from DragonBall.Constants.URLS import URL
+from DragonBall.Data.OutInformation import OutInformation
+from DragonBall.Soup.section import Section
+from DragonBall.Soup.summary import Summary
+from DragonBall.Soup.tags import Tags
+
+
+class Fusions:
+    def __init__(self, name: str, all_data=False):
+        self.name = name
+        self.all_data = all_data
+
+    @classmethod
+    def fusion_list(cls, fusion_list: list):
+        return [Fusions(i).fusion_information() for i in fusion_list]
+
+    @staticmethod
+    def list():
+        request = requests.get(URL.URL_LIST_FUSIONS, headers=URL.HEADERS)
+        soup = BeautifulSoup(request.content.decode('utf-8'), "html.parser")
+        toc = soup.find("div", {"id": "toc"})
+        if not toc:
+            return {}
+        summary_data = toc.text.strip().splitlines()
+        return Summary.clean_list_summary(summary_data, [1, -3])
+
+    def fusion_information(self):
+        url = URL.URL_WIKI + self.name.replace(" ", "_")
+        request = requests.get(url, headers=URL.HEADERS)
+        soup = BeautifulSoup(request.content.decode('utf-8'), "html.parser")
+        list_section = Section.obtain_section_data(soup, 'aside')
+        basic_dict = self.__obtain_basic_data(soup, url)
+        section_dict = self.__evaluate_scrapper_section(list_section, list(list_section.keys()), ScrapFusion)
+        return self.__show_information(basic_dict, section_dict)
+
+    def __obtain_basic_data(self, soup: BeautifulSoup, url: str):
+        name = self.__get_official_name(soup, "h1", "id", "firstHeading")
+        image = self.__get_image(soup, "a", "class", "image image-thumbnail")
+        description = self.__get_description_fusion(soup)
+        return {"url": url, "name": name, "image": image, "descripcion": description}
+
+    @staticmethod
+    def __get_official_name(soup: BeautifulSoup, tag: str, identification: str, element: str):
+        # Intento 1: Buscar el h1 con el id exacto
+        official_name = Tags.custom_catch_error(soup, tag, identification, element)
+        if official_name != OutInformation.RESOURCE_NOT_FOUND:
+            return official_name.get_text(strip=True)
+        
+        # Intento 2: Buscar CUALQUIER etiqueta <h1> en la página
+        h1 = soup.find("h1")
+        if h1:
+            return h1.get_text(strip=True)
+            
+        # Intento 3: Usar el título de la pestaña del navegador
+        if soup.title:
+            return soup.title.text.split("|")[0].strip()
+            
+        return OutInformation.RESOURCE_NOT_FOUND
+
+    @staticmethod
+    def __get_image(soup: BeautifulSoup, tag: str, identification: str, name: str):
+        found = soup.find(tag, attrs={identification: name})
+        if found:
+            return found.get("href")
+        return OutInformation.RESOURCE_NOT_FOUND
+
+    @staticmethod
+    def __get_description_fusion(soup: BeautifulSoup):
+        [remove_sup.extract() for remove_sup in soup.find_all('sup')]
+        try:
+            return next(
+                p.text.strip() for header in soup.find_all(['h2', 'h3']) if (p := header.find_next_sibling('p')))
+        except StopIteration:
+            return OutInformation.RESOURCE_NOT_FOUND
+
+    def __evaluate_scrapper_section(self, list_dict, list_search, tag_found: ScrapFusion):
+        empty = self.__return_empty_section(list_dict)
+        if empty:
+            return empty
+
+        section_names = list(tag_found.sections.values())
+        names = list_dict.get(section_names[0], OutInformation.RESOURCE_NOT_FOUND)
+        data = list_dict.get(section_names[1], OutInformation.RESOURCE_NOT_FOUND)
+
+        return {
+            "nombres": self.__names_section(names, tag_found.names) if section_names[0] in list_search else names,
+            "data": self.__data_section(data, tag_found.data) if section_names[1] in list_search else data,
+        }
+
+    @staticmethod
+    def __return_empty_section(list_dict: dict):
+        if not list_dict:
+            return {
+                "nombres": OutInformation.RESOURCE_NOT_FOUND,
+                "data": OutInformation.RESOURCE_NOT_FOUND,
+            }
+        return None
+
+    @staticmethod
+    def __names_section(name, lista_tags):
+        return {key: Tags.clean_text(Tags.catch_error(name, value)) for key, value in lista_tags.items()}
+
+    @staticmethod
+    def __data_section(data, lista_tags):
+        return {key: Tags.clean_text(Tags.catch_error(data, value)) for key, value in lista_tags.items()}
+
+    def __show_information(self, dictionary_basic, dictionary_sections):
+        dictionary = {
+            "name": dictionary_basic['name'],
+            "image": dictionary_basic['image'],
+            "description": dictionary_basic['descripcion'],
+            "names": dictionary_sections['nombres'],
+            "data": dictionary_sections['data'],
+            "url_scrap": dictionary_basic['url']
+        }
+        if self.all_data:
+            return dictionary
+        return OutInformation.clean_not_found_scrape(dictionary)

DragonBall/Data/OutInformation.py

@@ -0,0 +1,28 @@
+import json
+
+
+class OutInformation:
+    RESOURCE_NOT_FOUND = 'Not Found In Web'
+
+    @staticmethod
+    def beautiful_print_dict(json_dict: dict):
+        beautiful_print = json.dumps(json_dict, indent=4, ensure_ascii=False).encode('utf-8')
+        return beautiful_print.decode('utf-8')
+
+    @classmethod
+    def clean_not_found_scrape(cls, character: dict):
+        for key, value in character.copy().items():
+            if value == cls.RESOURCE_NOT_FOUND:
+                character.pop(key)
+            elif isinstance(value, dict):
+                cls.clean_not_found_scrape(value)
+                # si el dict interno quedó vacío tras la limpieza, elimínalo
+                if not character.get(key):
+                    character.pop(key, None)
+            elif isinstance(value, list):
+                cleaned = [v for v in value if v != cls.RESOURCE_NOT_FOUND]
+                if cleaned:
+                    character[key] = cleaned
+                else:
+                    character.pop(key)
+        return character

DragonBall/Data/Planets.py

@@ -0,0 +1,123 @@
+import requests as requests
+from bs4 import BeautifulSoup
+
+from DragonBall.Constants.ScrapPlanet import ScrapPlanet
+from DragonBall.Constants.URLS import URL
+from DragonBall.Data.OutInformation import OutInformation
+from DragonBall.Soup.section import Section
+from DragonBall.Soup.tags import Tags
+
+
+class Planets:
+    def __init__(self, name: str, all_data=False):
+        self.name = name
+        self.all_data = all_data
+
+    @classmethod
+    def planet_list(cls, planet_list: list):
+        return [Planets(i).planet_information() for i in planet_list]
+
+    @staticmethod
+    def list():
+        request = requests.get(URL.URL_LIST_PLANETS, headers=URL.HEADERS)
+        soup = BeautifulSoup(request.content.decode('utf-8'), "html.parser")
+        ref = soup.find('div', {"class": "mw-parser-output"})
+        if not ref:
+            return []
+        list_planets = [planet.text for planet in ref.find_all('b')]
+        if list_planets:
+            list_planets.pop(0)
+        return list_planets
+
+    def planet_information(self):
+        url = URL.URL_WIKI + self.name.replace(" ", "_")
+        request = requests.get(url, headers=URL.HEADERS)
+        soup = BeautifulSoup(request.content.decode('utf-8'), "html.parser")
+        list_section = Section.obtain_section_data(soup, 'aside')
+        basic_dict = self.__obtain_basic_data(soup, url)
+        section_dict = self.__evaluate_scrapper_section(list_section, list(list_section.keys()), ScrapPlanet)
+        return self.__show_information(basic_dict, section_dict)
+
+    def __obtain_basic_data(self, soup: BeautifulSoup, url: str):
+        name = self.__get_official_name(soup, "h1", "id", "firstHeading")
+        image = self.__get_image(soup, "a", "class", "image image-thumbnail")
+        description = self.__get_description_planet(soup)
+        return {"url": url, "name": name, "image": image, "descripcion": description}
+
+    @staticmethod
+    def __get_official_name(soup: BeautifulSoup, tag: str, identification: str, element: str):
+        # Intento 1: Buscar el h1 con el id exacto
+        official_name = Tags.custom_catch_error(soup, tag, identification, element)
+        if official_name != OutInformation.RESOURCE_NOT_FOUND:
+            return official_name.get_text(strip=True)
+        
+        # Intento 2: Buscar CUALQUIER etiqueta <h1> en la página
+        h1 = soup.find("h1")
+        if h1:
+            return h1.get_text(strip=True)
+            
+        # Intento 3: Usar el título de la pestaña del navegador
+        if soup.title:
+            return soup.title.text.split("|")[0].strip()
+            
+        return OutInformation.RESOURCE_NOT_FOUND
+
+    @staticmethod
+    def __get_image(soup: BeautifulSoup, tag: str, identification: str, name: str):
+        found = soup.find(tag, attrs={identification: name})
+        if found:
+            return found.get("href")
+        return OutInformation.RESOURCE_NOT_FOUND
+
+    @staticmethod
+    def __get_description_planet(soup: BeautifulSoup):
+        [remove_sup.extract() for remove_sup in soup.find_all('sup')]
+        try:
+            return next(
+                p.text.strip() for header in soup.find_all(['h2', 'h3']) if (p := header.find_next_sibling('p')))
+        except StopIteration:
+            return OutInformation.RESOURCE_NOT_FOUND
+
+    def __evaluate_scrapper_section(self, list_dict, list_search, tag_found: ScrapPlanet):
+        empty = self.__return_empty_section(list_dict)
+        if empty:
+            return empty
+
+        section_names = list(tag_found.sections.values())
+        names = list_dict.get(section_names[0], OutInformation.RESOURCE_NOT_FOUND)
+        data = list_dict.get(section_names[1], OutInformation.RESOURCE_NOT_FOUND)
+
+        return {
+            "nombres": self.__names_section(names, tag_found.names) if section_names[0] in list_search else names,
+            "data": self.__data_section(data, tag_found.data) if section_names[1] in list_search else data,
+        }
+
+    @staticmethod
+    def __return_empty_section(list_dict: dict):
+        if not list_dict:
+            return {
+                "nombres": OutInformation.RESOURCE_NOT_FOUND,
+                "data": OutInformation.RESOURCE_NOT_FOUND,
+            }
+        return None
+
+    @staticmethod
+    def __names_section(name, lista_tags):
+        return {key: Tags.clean_text(Tags.catch_error(name, value)) for key, value in lista_tags.items()}
+
+    @staticmethod
+    def __data_section(data, lista_tags):
+        return {key: Tags.clean_text(Tags.catch_error(data, value)) for key, value in lista_tags.items()}
+
+    def __show_information(self, dictionary_basic, dictionary_sections):
+        dictionary = {
+            "name": dictionary_basic['name'],
+            "image": dictionary_basic['image'],
+            "description": dictionary_basic['descripcion'],
+            "names": dictionary_sections['nombres'],
+            "data": dictionary_sections['data'],
+            "url_scrap": dictionary_basic['url']
+        }
+        if self.all_data:
+            return dictionary
+        return OutInformation.clean_not_found_scrape(dictionary)

DragonBall/Data/Sagas.py

@@ -0,0 +1,130 @@
+import requests as requests
+from bs4 import BeautifulSoup
+
+from DragonBall.Constants.ScrapSagas import ScrapSagas
+from DragonBall.Constants.URLS import URL
+from DragonBall.Data.OutInformation import OutInformation
+from DragonBall.Soup.section import Section
+from DragonBall.Soup.summary import Summary
+from DragonBall.Soup.tags import Tags
+
+
+class Sagas:
+    def __init__(self, name: str, all_data=False):
+        self.name = name
+        self.all_data = all_data
+
+    @classmethod
+    def saga_list(cls, saga_list: list):
+        return [Sagas(i).saga_information() for i in saga_list]
+
+    @staticmethod
+    def list():
+        request = requests.get(URL.URL_LIST_CHRONO, headers=URL.HEADERS)
+        soup = BeautifulSoup(request.content.decode('utf-8'), "html.parser")
+        toc = soup.find("div", {"id": "toc"})
+        if not toc:
+            return {}
+        summary_data = toc.text.strip().splitlines()
+        return Summary.clean_list_summary(summary_data, [1, -2])
+
+    def saga_information(self):
+        url = URL.URL_WIKI + self.name.replace(" ", "_")
+        request = requests.get(url, headers=URL.HEADERS)
+        soup = BeautifulSoup(request.content.decode('utf-8'), "html.parser")
+        list_section = Section.obtain_section_data(soup, 'aside')
+        basic_dict = self.__obtain_basic_data(soup, url)
+        section_dict = self.__evaluate_scrapper_section(list_section, list(list_section.keys()), ScrapSagas)
+        return self.__show_information(basic_dict, section_dict)
+
+    def __obtain_basic_data(self, soup: BeautifulSoup, url: str):
+        name = self.__get_official_name(soup, "h1", "id", "firstHeading")
+        image = self.__get_image(soup, "a", "class", "image image-thumbnail")
+        description = self.__get_description_saga(soup)
+        return {"url": url, "name": name, "image": image, "descripcion": description}
+
+    @staticmethod
+    def __get_official_name(soup: BeautifulSoup, tag: str, identification: str, element: str):
+        # Intento 1: Buscar el h1 con el id exacto
+        official_name = Tags.custom_catch_error(soup, tag, identification, element)
+        if official_name != OutInformation.RESOURCE_NOT_FOUND:
+            return official_name.get_text(strip=True)
+        
+        # Intento 2: Buscar CUALQUIER etiqueta <h1> en la página
+        h1 = soup.find("h1")
+        if h1:
+            return h1.get_text(strip=True)
+            
+        # Intento 3: Usar el título de la pestaña del navegador
+        if soup.title:
+            return soup.title.text.split("|")[0].strip()
+            
+        return OutInformation.RESOURCE_NOT_FOUND
+
+    @staticmethod
+    def __get_image(soup: BeautifulSoup, tag: str, identification: str, name: str):
+        found = soup.find(tag, attrs={identification: name})
+        if found:
+            return found.get("href")
+        return OutInformation.RESOURCE_NOT_FOUND
+
+    @staticmethod
+    def __get_description_saga(soup: BeautifulSoup):
+        [remove_sup.extract() for remove_sup in soup.find_all('sup')]
+        try:
+            return next(
+                p.text.strip() for header in soup.find_all(['h2', 'h3']) if (p := header.find_next_sibling('p')))
+        except StopIteration:
+            return OutInformation.RESOURCE_NOT_FOUND
+
+    def __evaluate_scrapper_section(self, list_dict, list_search, tag_found: ScrapSagas):
+        empty = self.__return_empty_section(list_dict)
+        if empty:
+            return empty
+
+        section_names = list(tag_found.sections.values())
+        names = list_dict.get(section_names[0], OutInformation.RESOURCE_NOT_FOUND)
+        data = list_dict.get(section_names[1], OutInformation.RESOURCE_NOT_FOUND)
+        serialization = list_dict.get(section_names[2], OutInformation.RESOURCE_NOT_FOUND)
+
+        return {
+            "nombres": self.__names_section(names, tag_found.names) if section_names[0] in list_search else names,
+            "data": self.__data_section(data, tag_found.data) if section_names[1] in list_search else data,
+            "serializacion": self.__serialization_section(serialization, tag_found.serialization) if section_names[2] in list_search else serialization,
+        }
+
+    @staticmethod
+    def __return_empty_section(list_dict: dict):
+        if not list_dict:
+            return {
+                "nombres": OutInformation.RESOURCE_NOT_FOUND,
+                "data": OutInformation.RESOURCE_NOT_FOUND,
+                "serializacion": OutInformation.RESOURCE_NOT_FOUND,
+            }
+        return None
+
+    @staticmethod
+    def __names_section(name, lista_tags):
+        return {key: Tags.clean_text(Tags.catch_error(name, value)) for key, value in lista_tags.items()}
+
+    @staticmethod
+    def __data_section(data, lista_tags):
+        return {key: Tags.clean_text(Tags.catch_error(data, value)) for key, value in lista_tags.items()}
+
+    @staticmethod
+    def __serialization_section(serialization, lista_tags):
+        return {key: Tags.clean_text(Tags.catch_error(serialization, value)) for key, value in lista_tags.items()}
+
+    def __show_information(self, dictionary_basic, dictionary_sections):
+        dictionary = {
+            "name": dictionary_basic['name'],
+            "image": dictionary_basic['image'],
+            "description": dictionary_basic['descripcion'],
+            "names": dictionary_sections['nombres'],
+            "data": dictionary_sections['data'],
+            "serialization": dictionary_sections['serializacion'],
+            "url_scrap": dictionary_basic['url']
+        }
+        if self.all_data:
+            return dictionary
+        return OutInformation.clean_not_found_scrape(dictionary)

DragonBall/Data/VideoGames.py

@@ -0,0 +1,122 @@
+import requests as requests
+from bs4 import BeautifulSoup
+
+from DragonBall.Constants.ScrapGames import ScrapGames
+from DragonBall.Constants.URLS import URL
+from DragonBall.Data.OutInformation import OutInformation
+from DragonBall.Soup.section import Section
+from DragonBall.Soup.summary import Summary
+from DragonBall.Soup.tags import Tags
+
+
+class VideoGames:
+    def __init__(self, name: str, all_data=False):
+        self.name = name
+        self.all_data = all_data
+
+    @classmethod
+    def game_list(cls, game_list: list):
+        return [VideoGames(i).game_information() for i in game_list]
+
+    @staticmethod
+    def list():
+        request = requests.get(URL.URL_LIST_GAMES, headers=URL.HEADERS)
+        soup = BeautifulSoup(request.content.decode('utf-8'), "html.parser")
+        toc = soup.find("div", {"id": "toc"})
+        if not toc:
+            return {}
+        summary_data = toc.text.strip().splitlines()
+        return Summary.clean_list_summary(summary_data, [1, -4])
+
+    def game_information(self):
+        url = URL.URL_WIKI + self.name.replace(" ", "_")
+        request = requests.get(url, headers=URL.HEADERS)
+        soup = BeautifulSoup(request.content.decode('utf-8'), "html.parser")
+        list_section = Section.obtain_section_data(soup, 'aside')
+        basic_dict = self.__obtain_basic_data(soup, url)
+        section_dict = self.__evaluate_scrapper_section(list_section, list(list_section.keys()), ScrapGames)
+        return self.__show_information(basic_dict, section_dict)
+
+    def __obtain_basic_data(self, soup: BeautifulSoup, url: str):
+        name = self.__get_official_name(soup, "h1", "id", "firstHeading")
+        image = self.__get_image(soup, "a", "class", "image image-thumbnail")
+        description = self.__get_description_game(soup)
+        return {"url": url, "name": name, "image": image, "descripcion": description}
+
+    @staticmethod
+    def __get_official_name(soup: BeautifulSoup, tag: str, identification: str, element: str):
+        # Intento 1: Buscar el h1 con el id exacto
+        official_name = Tags.custom_catch_error(soup, tag, identification, element)
+        if official_name != OutInformation.RESOURCE_NOT_FOUND:
+            return official_name.get_text(strip=True)
+        
+        # Intento 2: Buscar CUALQUIER etiqueta <h1> en la página
+        h1 = soup.find("h1")
+        if h1:
+            return h1.get_text(strip=True)
+            
+        # Intento 3: Usar el título de la pestaña del navegador
+        if soup.title:
+            return soup.title.text.split("|")[0].strip()
+            
+        return OutInformation.RESOURCE_NOT_FOUND
+
+    @staticmethod
+    def __get_image(soup: BeautifulSoup, tag: str, identification: str, name: str):
+        found = soup.find(tag, attrs={identification: name})
+        if found:
+            return found.get("href")
+        return OutInformation.RESOURCE_NOT_FOUND
+
+    @staticmethod
+    def __get_description_game(soup: BeautifulSoup):
+        [remove_sup.extract() for remove_sup in soup.find_all('sup')]
+        try:
+            return next(
+                p.text.strip() for header in soup.find_all(['h2', 'h3']) if (p := header.find_next_sibling('p')))
+        except StopIteration:
+            return OutInformation.RESOURCE_NOT_FOUND
+
+    def __evaluate_scrapper_section(self, list_dict, list_search, tag_found: ScrapGames):
+        empty = self.__return_empty_section(list_dict)
+        if empty:
+            return empty
+
+        section_names = list(tag_found.sections.values())
+        names = list_dict.get(section_names[0], OutInformation.RESOURCE_NOT_FOUND)
+        data = list_dict.get(section_names[1], OutInformation.RESOURCE_NOT_FOUND)
+
+        return {
+            "nombres": self.__names_section(names, tag_found.names) if section_names[0] in list_search else names,
+            "data": self.__data_section(data, tag_found.data) if section_names[1] in list_search else data,
+        }
+
+    @staticmethod
+    def __return_empty_section(list_dict: dict):
+        if not list_dict:
+            return {
+                "nombres": OutInformation.RESOURCE_NOT_FOUND,
+                "data": OutInformation.RESOURCE_NOT_FOUND,
+            }
+        return None
+
+    @staticmethod
+    def __names_section(name, lista_tags):
+        return {key: Tags.clean_text(Tags.catch_error(name, value)) for key, value in lista_tags.items()}
+
+    @staticmethod
+    def __data_section(data, lista_tags):
+        return {key: Tags.clean_text(Tags.catch_error(data, value)) for key, value in lista_tags.items()}
+
+    def __show_information(self, dictionary_basic, dictionary_sections):
+        dictionary = {
+            "name": dictionary_basic['name'],
+            "image": dictionary_basic['image'],
+            "description": dictionary_basic['descripcion'],
+            "names": dictionary_sections['nombres'],
+            "data": dictionary_sections['data'],
+            "url_scrap": dictionary_basic['url']
+        }
+        if self.all_data:
+            return dictionary
+        return OutInformation.clean_not_found_scrape(dictionary)

DragonBall/Soup/section.py

@@ -0,0 +1,17 @@
+from bs4 import BeautifulSoup
+
+
+class Section:
+
+    @classmethod
+    def obtain_section_data(cls, soup: BeautifulSoup, tag: str):
+        data_General = soup.find(tag)
+        if data_General:
+            sections = [i for i in data_General.find_all("section", {'class': 'pi-item pi-group pi-border-color'})]
+            return cls.__find_name_section(sections)
+        else:
+            return dict()
+
+    @staticmethod
+    def __find_name_section(sections: BeautifulSoup):
+        return {i.find('h2').text: i for i in sections if i.find('h2')}

DragonBall/Soup/summary.py

@@ -0,0 +1,18 @@
+class Summary:
+
+    @classmethod
+    def clean_list_summary(cls, list_sumary, remove):
+        summary = [x for x in list_sumary if x != '']
+        return cls.__convert_list_summary_to_dict(summary[remove[0]:remove[1]])
+
+    @staticmethod
+    def __convert_list_summary_to_dict(summary):
+        dictionary = {}
+        current_key = None
+        for item in summary:
+            if "." not in item:
+                current_key = item.lstrip('1234567890.').strip()
+                dictionary[current_key] = []
+            else:
+                dictionary[current_key].append(item.lstrip('1234567890.').strip())
+        return dictionary

DragonBall/Soup/tags.py

@@ -0,0 +1,53 @@
+from bs4 import BeautifulSoup
+
+from DragonBall.Constants.URLS import URL
+from DragonBall.Data.OutInformation import OutInformation
+
+
+class Tags:
+
+    @classmethod
+    def clean_text(cls, elem):
+        if elem is None:
+            return OutInformation.RESOURCE_NOT_FOUND
+        if elem == OutInformation.RESOURCE_NOT_FOUND:
+            return elem
+        return cls.evaluate_clean_text(elem)
+
+    @classmethod
+    def evaluate_clean_text(cls, elem):
+        text = ''
+        [remove_sup.extract() for remove_sup in elem.find_all('sup')]
+        for e in elem.descendants:
+            if isinstance(e, str):
+                text += e
+            elif e.name in ['br', 'p', 'li']:
+                text += '\n'
+
+        list_data = [x for x in text.strip().splitlines() if x != '']
+
+        if not list_data:
+            list_data = cls.__text_and_link(elem)
+
+        return list_data[0] if len(list_data) == 1 else list_data
+
+    @staticmethod
+    def catch_error(section, data_source):
+        # Guarda: si section no es un Tag/BeautifulSoup, no intentes .find()
+        if not hasattr(section, "find"):
+            return OutInformation.RESOURCE_NOT_FOUND
+        div = section.find("div", {"data-source": data_source})
+        if not div:
+            return OutInformation.RESOURCE_NOT_FOUND
+        value = div.find("div", {"class": "pi-data-value pi-font"})
+        return value if value else OutInformation.RESOURCE_NOT_FOUND
+
+    @staticmethod
+    def custom_catch_error(soup: BeautifulSoup, tag: str, identification: str, name: str):
+        div = soup.find(tag, {identification: name})
+        return div if div else OutInformation.RESOURCE_NOT_FOUND
+
+    @staticmethod
+    def __text_and_link(soup: BeautifulSoup):
+        tupla = soup.find_all('a')
+        return [{"title": data.get('title'), "url": URL.URL_BASE[:-1] + data.get('href')} for data in tupla]

DragonBall/__init__.py

@@ -0,0 +1,6 @@
+from DragonBall.Data.Characters import Characters
+from DragonBall.Data.Sagas import Sagas
+from DragonBall.Data.Planets import Planets
+from DragonBall.Data.Fusions import Fusions
+from DragonBall.Data.VideoGames import VideoGames
+from DragonBall.Data.OutInformation import OutInformation

dragon_ball_api_alejo-0.1.dist-info/METADATA

@@ -0,0 +1,111 @@
+Metadata-Version: 2.4
+Name: Dragon-Ball-API-Alejo
+Version: 0.1
+Summary: Api unoficial de dragon ball inspirado de la fandom de dragon ball
+Home-page: https://github.com/xtream-club/Dragon-Ball-API
+Download-URL: https://github.com/xtream-club/Dragon-Ball-API/tarball/0.1
+Author: Eduardo Lopez
+Author-email: nanguelulpz@gmail.com
+License: MIT
+Keywords: Dragon-Ball-Api,Dragon Ball,Api Dragon Ball
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: requests<3,>=2.32
+Requires-Dist: beautifulsoup4<4.15,>=4.12
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: download-url
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+Scrapper-DragonBall
+===============
+Scrapper unofficial de Dragon Ball inspirado en su fandom. <https://dragonball.fandom.com/es/wiki/Dragon_Ball_Wiki_Hispano>. Esta api nos permite obtener datos de personajes, sagas, fusiones, lugares y videojuegos de manera sencilla. Para poder utilizarlo en nuestras aplicaciones.
+===============
+Requiere version python 3.9 
+===============
+Requerimientos
+============
+Para instalar los requerimientos instale los requerimientos del archivo requirements.txt con el siguiente comando
+
+    pip install -r requirements.txt
+
+Importaciones
+============
+
+    from DragonBall.Data.Characters import Characters
+    from DragonBall.Data.Sagas import Sagas
+    from DragonBall.Data.Planets import Planets
+    from DragonBall.Data.Fusions import Fusions
+    from DragonBall.Data.VideoGames import VideoGames
+    from DragonBall.Data.OutInformation import OutInformation
+
+Instalación
+============
+
+    pip install Dragon-Ball-API
+
+Usage
+=====
+
+    >>> from DragonBall.Data.Characters import Characters
+    
+    >>> search_goku = Characters('Goku')
+    >>> search_goku.character_information()
+    
+    {
+    'name': 'Son Goku', 'image': 'https://example.com', 'description': 'descripcion', 
+    'names': {'japan_name': '...', 'latin_name': '...', 'pronunciation_name': '...', 'other_names': '...'}, 
+    'data': {'gender': '...', 'birthday': '...', 'origin': '...', 'family': ['...','...'], 'transformations': ['...', '...'], etc.. },
+    'debut': {'sagas': [{'title': '...', 'url': '...'}], 'debut': '...'}
+    }
+    
+
+Algunos personajes tendran más datos que otros. Eso dependera de la información que se encuentre en la wiki de dragon ball en ese momento. Si deseamos podemos pasar una lista de personajes a buscar y usar el método list para devolvernos la información de todos los personajes.
+
+    >>> from DragonBall.Data.Characters import Characters
+    
+    goku_family = ['Son Gohan (abuelo)', 'Bardock', 'Gine', 'Raditz', 'Rey Gyuma', 'Milk', 'Gohan', 'Goten', 'Mr. Satán', 'Videl', 'Pan', 'Son Goku Jr.']
+    
+    >>> character_list = Characters.character_list(goku_family)
+    
+    [{'...'},{'...'}]
+
+   
+
+
+Podemos ver una lista de los personajes usando el método list de la clase. De la siguiente manera.
+
+
+
+    >>> Characters.list()
+    
+    {
+    'Personajes por raza': ['Androides', 'Animales', 'Arlianos', 'Ángeles', '...', '...'],
+    'Personajes por asociación': ['...', '...', '...']
+    }
+
+
+
+Si queremos imprimir los datos de manera más legible podemos utilizar el método beautiful_print_dict de la clase OutInformation
+
+
+    >>> OutInformation.beautiful_print_dict(Characters.list())
+    
+    "Personajes por raza": [
+        "Androides",
+        "Animales",
+        "Arlianos",
+        "Ángeles",
+        "..."
+     ]
+     
+
+
+Todos estos metodos los podemos aplicar en todas sus clases (sagas, juegos, etc).

dragon_ball_api_alejo-0.1.dist-info/RECORD

@@ -0,0 +1,20 @@
+DragonBall/__init__.py,sha256=hhWzNuDPVxtNobvyjKNHv1cUuoyMlep9qGscWkVVUT0,292
+DragonBall/Constants/ScrapCharacter.py,sha256=2vAWDZkf4cCb0DeAULXH_9vHmDCepJIQMu6qlilGQqk,1355
+DragonBall/Constants/ScrapFusion.py,sha256=qWmLG-SUCD_1UJqjeO536hZFVpTgzq7gkM3de7bclE0,929
+DragonBall/Constants/ScrapGames.py,sha256=5aDDG7jip4UI_GVDqSK7L3GqyO0ogQfAJdJHJsTjj5Y,864
+DragonBall/Constants/ScrapPlanet.py,sha256=BC_aE9PDVznQEvJu5_MT2XKDtyP9G4DfPG6rfwtHfjU,742
+DragonBall/Constants/ScrapSagas.py,sha256=nOVRHKnZRw98oIVJVD3SPoy2EFta8Asxko9aYPT2r9Y,858
+DragonBall/Constants/URLS.py,sha256=YsHU38-Q8aZMwnrH7c1QXrvFbwQpjFyL-3pnCRiXMC8,730
+DragonBall/Data/Characters.py,sha256=BJ_jYWmknBO2-bG1oX87EnVPCpzarDp8WEEzQEpxD-c,5726
+DragonBall/Data/Fusions.py,sha256=O9dBaunz9IqxWwDgbxqEF4lM89RGuNBwEl4QD9_qvpA,5199
+DragonBall/Data/OutInformation.py,sha256=pWO5Mu9bGh5k_1l07k9YziUzknfuZppWV7xXaRfzC94,1057
+DragonBall/Data/Planets.py,sha256=89mxwzVJ5RK6-2urWGK4DXKSb2CT8mVfZrfsv9f0u3w,5208
+DragonBall/Data/Sagas.py,sha256=6fuyWwD0CCJ5HbKKj5FaAqmrx6_wPDy733SkVDnKngk,5757
+DragonBall/Data/VideoGames.py,sha256=f341kt5oW_ju6C6QQvgLsU0s1zRf4OeRTz4klepvBxk,5185
+DragonBall/Soup/section.py,sha256=sY3BvJkRPOjg_8odEm-h7ckNl5eMfhrtPXPi8hg8_jE,562
+DragonBall/Soup/summary.py,sha256=ktYxQxvEIUWD2isu_WJQafNoOYQMZmlaEzzDtxEJvpk,654
+DragonBall/Soup/tags.py,sha256=2Ns8DrGPLadbh-dkKIQqjq-dzrMSuS3MucQW31STNgs,1922
+dragon_ball_api_alejo-0.1.dist-info/METADATA,sha256=nejeZwsx2-aVFBNeCL60GbFh_tI4Wk7qPoGPEdox1TY,3746
+dragon_ball_api_alejo-0.1.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+dragon_ball_api_alejo-0.1.dist-info/top_level.txt,sha256=BCa2x7xRYl8q8z_qGMKdG9QweNR81bZwa5-Yj0FVXrc,11
+dragon_ball_api_alejo-0.1.dist-info/RECORD,,

dragon_ball_api_alejo-0.1.dist-info/WHEEL

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

dragon_ball_api_alejo-0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+DragonBall