Dragon-Ball-API-Alejo 0.1__tar.gz

dragon_ball_api_alejo-0.1/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())
+    }

dragon_ball_api_alejo-0.1/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()),
+    }

dragon_ball_api_alejo-0.1/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())
+    }

dragon_ball_api_alejo-0.1/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())
+    }

dragon_ball_api_alejo-0.1/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())
+    }

dragon_ball_api_alejo-0.1/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"

dragon_ball_api_alejo-0.1/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)

dragon_ball_api_alejo-0.1/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)

dragon_ball_api_alejo-0.1/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

dragon_ball_api_alejo-0.1/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)