Anime_ipynb_2_

import pandas as pd
from pytrends.request import TrendReq
import time
import random

# Initialize pytrends
pytrends = TrendReq(hl='en-US', tz=360)

# List of top 100 anime series
top_100_anime = [
    "Naruto", "Attack on Titan", "My Hero Academia", "One Piece", 
    "Demon Slayer", "Dragon Ball Z", "Death Note", "Fullmetal Alchemist",
    "Sword Art Online", "Tokyo Ghoul",  # Add the rest of the anime series
    # ...
]

# Function to get search volume for a keyword over the past day
def get_search_volume(anime):
    pytrends.build_payload([anime], cat=0, timeframe='now 1-d', geo='', gprop='')
    data = pytrends.interest_over_time()
    if not data.empty:
        return data[anime].values[-1]  # Return the most recent data point
    else:
        return 0

# Dictionary to store search volumes
search_volumes = {}

# Fetch search volumes
for anime in top_100_anime:
    try:
        volume = get_search_volume(anime)
        search_volumes[anime] = volume
        print(f"{anime}: {volume}")
        time.sleep(random.randint(5,20))  # Sleep to avoid rate limit issues
    except Exception as e:
        print(f"Error fetching data for {anime}: {e}")

# Convert to DataFrame for easy viewing
df = pd.DataFrame(list(search_volumes.items()), columns=['Anime', 'Search Volume'])
df.sort_values(by='Search Volume', ascending=False, inplace=True)

# Save to CSV
df.to_csv('anime_search_volumes.csv', index=False)
print("Data saved to anime_search_volumes.csv")

import requests
from bs4 import BeautifulSoup

# Make a request to the website
r = requests.get("https://www.imdb.com/title/tt0081595/")  # Replace with your show's URL

# Create an instance of BeautifulSoup
soup = BeautifulSoup(r.text, 'html.parser')

# Find the release date and genre
release_date = soup.find('a', {'title': 'See more release dates'}).text.strip()
genre = [a.text for a in soup.find_all('a', {'href': '/search/title?genres='})]

print(f"Release Date: {release_date}")
print(f"Genre: {', '.join(genre)}")

def fetchAnimeTitles():
    animeTitles = []
    animeReleaseDates = []

    urls = ['https://myanimelist.net/topanime.php?limit=0', 'https://myanimelist.net/topanime.php?limit=50']
    for url in urls:
        response = requests.get(url)

        soup = BeautifulSoup(response.content, 'html.parser')

        blockquote_tags = soup.find_all('h3')

        animeTags = [tag.get_text() for tag in blockquote_tags]

        for i in animeTags:
            animeTitles.append(i)
            animeReleaseDates.append(getReleaseDate(i))

        animeTitles = [item for item in animeTitles if "More" not in item]

    with open('animeTitles.txt', 'a') as file:
        file.write(str(animeTitles))

    with open('animeReleaseDates.txt', 'a') as file:
        file.write(str(animeReleaseDates))


def getReleaseDate(animeTitle):
    search_url = f'https://myanimelist.net/anime.php?q={animeTitle}'
    response = requests.get(search_url)
    soup = BeautifulSoup(response.content, 'html.parser')
    anime_info = soup.find('div', class_='js-scrollfix-bottom-rel')
    release_date = anime_info.find('span', class_='information season').text.strip()
    return release_date

getReleaseDate("naruto")

from bs4 import BeautifulSoup
import requests
import re

# URL of the Wikipedia page
url = 'https://en.wikipedia.org/wiki/One-Punch_Man'

# Send a GET request to the URL
response = requests.get(url)
html_content = response.text

# Parse the HTML content using BeautifulSoup
soup = BeautifulSoup(html_content, 'html.parser')
# Find the infobox and genre row containing the genre information
infobox = soup.find('table', {'class': 'infobox'})
genreRow = infobox.find('th', string='Genre')  
releaseDate = infobox.find('th', string='Original run')

# The genre information is typically in the next <td> tag
# Chatgpt code to remove the citation numbers within wikipedia page
genre = genreRow.find_next_sibling('td').get_text().strip()
cleanedGenre = re.sub(r'\[\d+\]', ', ', genre)
# Remove the trailing comma and space at the end
cleanedGenre = cleanedGenre.rstrip(', ')
# This code I made. It finds the release date within the infobox
releaseDate = releaseDate.find_next_sibling('td').get_text().strip()
releaseDate = releaseDate.split('–')[0].strip()
print(f"Genre: {cleanedGenre}")
print(f"Release Date: {releaseDate}")

from bs4 import BeautifulSoup
import requests
import re

for anime in animeTitles:
    title = anime.replace(' ', '_')
    # URL of the Wikipedia page
    url = f'https://en.wikipedia.org/wiki/{title}'

    # Send a GET request to the URL
    response = requests.get(url)
    html_content = response.text

    # Parse the HTML content using BeautifulSoup
    soup = BeautifulSoup(html_content, 'html.parser')
    # Find the infobox and genre row containing the genre information
    infobox = soup.find('table', {'class': 'infobox'})
    genreRow = infobox.find('th', string='Genre')  
    releaseDate = infobox.find('th', string='Original run')

    # The genre information is typically in the next <td> tag
    # Chatgpt code to remove the citation numbers within wikipedia page
    genre = genreRow.find_next_sibling('td').get_text().strip()
    cleanedGenre = re.sub(r'\[\d+\]', ', ', genre)
    # Remove the trailing comma and space at the end
    cleanedGenre = cleanedGenre.rstrip(', ')
    # This code I made. It finds the release date within the infobox
    releaseDate = releaseDate.find_next_sibling('td').get_text().strip()
    releaseDate = releaseDate.split('–')[0].strip()
    print(f"{anime}: {cleanedGenre}")
    print(f"{anime}: {releaseDate}")

    animeTitles = []

    urls = [
        "https://myanimelist.net/topanime.php?limit=0",
        "https://myanimelist.net/topanime.php?limit=50",
    ]
    for url in urls:
        response = requests.get(url)

        soup = BeautifulSoup(response.content, "html.parser")

        blockquote_tags = soup.find_all("h3")

        animeTags = [tag.get_text() for tag in blockquote_tags]

        for i in animeTags:
            animeTitles.append(i)
        animeTitles = [item for item in animeTitles if "More" not in item]
    print(animeTitles)
    with open("animeTitles.txt", "a") as file:
        file.write(str(animeTitles))

import requests
from bs4 import BeautifulSoup
import re
from datetime import datetime

# List of anime titles to process
animeTitles = ['Naruto', 'Attack on Titan', 'One Piece', 'Invalid Title Example']

# File to store titles that need manual entries
manual_entries_file = 'manualEntries.txt'

with open(manual_entries_file, 'w') as manual_file:
    for anime in animeTitles:
        try:
            title = anime.replace(' ', '_')
            # URL of the Wikipedia page
            url = f'https://en.wikipedia.org/wiki/{title}'

            # Send a GET request to the URL
            response = requests.get(url)
            
            # Check if the page exists
            if response.status_code == 404:
                raise ValueError("Wikipedia page does not exist")

            html_content = response.text

            # Parse the HTML content using BeautifulSoup
            soup = BeautifulSoup(html_content, 'html.parser')
            
            # Find the infobox
            infobox = soup.find('table', {'class': 'infobox'})

            # Handle cases where infobox is not found
            if infobox is None:
                raise ValueError("Infobox not found")

            # Find the genre row and release date row
            genreRow = infobox.find('th', string='Genre')
            releaseDateRow = infobox.find('th', string='Original run')

            # Handle cases where genre or release date rows are not found
            if genreRow is None or releaseDateRow is None:
                raise ValueError("Genre or release date row not found")

            # Get the genre information
            genre = genreRow.find_next_sibling('td').get_text().strip()
            cleanedGenre = re.sub(r'\[\d+\]', ', ', genre)
            # Remove the trailing comma and space at the end
            cleanedGenre = cleanedGenre.rstrip(', ')

            # Get the release date information
            releaseDate = releaseDateRow.find_next_sibling('td').get_text().strip()
            releaseDate = releaseDate.split('–')[0].strip()
            releaseDate = datetime.strptime(releaseDate, '%B %d, %Y')
            # Print the results
            print(f"{anime}: {cleanedGenre}")
            print(f"{anime}: {releaseDate}")

        except Exception as e:
            # Write the title to the manual entries file if there's an error
            manual_file.write(f"{anime}\n")
            print(f"Error processing {anime}: {e}")

import requests
from bs4 import BeautifulSoup
import re
from datetime import datetime

def genreFetch(animeTitles):
    # File to store titles that need manual entries
    manual_entries_file = 'manualEntries.txt'

    # Dictionary to store the results
    anime_data = {}

    with open(manual_entries_file, 'w') as manual_file:
        for anime in animeTitles:
            try:
                title = anime.replace(' ', '_')
                # URL of the Wikipedia page
                url = f'https://en.wikipedia.org/wiki/{title}'

                # Send a GET request to the URL
                response = requests.get(url)
                
                # Check if the page exists
                if response.status_code == 404:
                    raise ValueError("Wikipedia page does not exist")

                html_content = response.text

                # Parse the HTML content using BeautifulSoup
                soup = BeautifulSoup(html_content, 'html.parser')
                
                # Find the infobox
                infobox = soup.find('table', {'class': 'infobox'})

                # Handle cases where infobox is not found
                if infobox is None:
                    raise ValueError("Infobox not found")

                # Find the genre row and release date row
                genreRow = infobox.find('th', string='Genre')
                releaseDateRow = infobox.find('th', string='Original run')

                # Handle cases where genre or release date rows are not found
                if genreRow is None or releaseDateRow is None:
                    raise ValueError("Genre or release date row not found")

                # Get the genre information
                genre = genreRow.find_next_sibling('td').get_text().strip()
                cleanedGenre = re.sub(r'\[\d+\]', ', ', genre)
                # Remove the trailing comma and space at the end
                cleanedGenre = cleanedGenre.rstrip(', ')

                # Get the release date information
                releaseDate = releaseDateRow.find_next_sibling('td').get_text().strip()
                releaseDate = releaseDate.split('–')[0].strip()
                releaseDate = datetime.strptime(releaseDate, '%B %d, %Y')

                # Store the results in the dictionary
                anime_data[anime] = {
                    'genre': cleanedGenre,
                    'release_date': releaseDate
                }

                # Print the results
                print(f"{anime}: Genre: {cleanedGenre}")
                print(f"{anime}: Release Date: {releaseDate}")

            except Exception as e:
                # Write the title to the manual entries file if there's an error
                manual_file.write(f"{anime}\n")
                print(f"Error processing {anime}: {e}")

    return anime_data

# Example usage:
animeTitles = ["Naruto", "Attack on Titan", "One Piece"]
anime_data = genreFetch(animeTitles)
print(anime_data)

import requests
from bs4 import BeautifulSoup
import re
from datetime import datetime

def genreFetch(animeTitles):
    # File to store titles that need manual entries
    manual_entries_file = 'manualEntries.txt'

    # Dictionary to store the results
    anime_data = {}

    with open(manual_entries_file, 'w') as manual_file:
        for anime in animeTitles:
            try:
                title = anime.replace(' ', '_')
                # URL of the Wikipedia page
                url = f'https://en.wikipedia.org/wiki/{title}'

                # Send a GET request to the URL
                response = requests.get(url)
                
                # Check if the page exists
                if response.status_code == 404:
                    raise ValueError("Wikipedia page does not exist")

                html_content = response.text

                # Parse the HTML content using BeautifulSoup
                soup = BeautifulSoup(html_content, 'html.parser')
                
                # Find the infobox
                infobox = soup.find('table', {'class': 'infobox'})

                # Handle cases where infobox is not found
                if infobox is None:
                    raise ValueError("Infobox not found")

                # Find the genre row and release date row
                genreRow = infobox.find('th', string='Genre')
                releaseDateRow = infobox.find('th', string='Original run')

                # Handle cases where genre or release date rows are not found
                if genreRow is None or releaseDateRow is None:
                    raise ValueError("Genre or release date row not found")

                # Get the genre information
                genre = genreRow.find_next_sibling('td').get_text().strip()
                cleanedGenre = re.sub(r'\[\d+\]', '', genre).strip()

                # Get the release date information
                releaseDate = releaseDateRow.find_next_sibling('td').get_text().strip()
                releaseDate = releaseDate.split('–')[0].strip()
                releaseDate = datetime.strptime(releaseDate, '%B %d, %Y')

                # Store the results in the dictionary
                anime_data[anime] = {
                    'genre': cleanedGenre,
                    'release_date': releaseDate
                }

                # Print the results
                print(f"{anime}: Genre: {cleanedGenre}")
                print(f"{anime}: Release Date: {releaseDate}")

            except Exception as e:
                # Write the title to the manual entries file if there's an error
                manual_file.write(f"{anime}\n")
                print(f"Error processing {anime}: {e}")

    return anime_data

# Example usage
animeList = [
    {"name": "Naruto", "searches": 1000},
    {"name": "Attack on Titan", "searches": 1500},
    {"name": "One Piece", "searches": None},
    {"name": "Demon Slayer", "searches": 2000}
]

# Filter entries where searches is not None
data = [entry for entry in animeList if entry["searches"] is not None]

# Fetch genres and release dates for the filtered anime names
stuff = genreFetch([entry["name"] for entry in data])

# Initialize lists to store genres and release dates
genres = []
release_dates = []

# Extract genres and release dates from the fetched data
for anime in stuff:
    genres.append(stuff[anime]['genre'])
    release_dates.append(stuff[anime]['release_date'])

print("Genres:", genres)
print("Release Dates:", release_dates)

import random
from datetime import datetime, timedelta

def generate_random_date(start_year=1985, end_year=2015):
    start_date = datetime(start_year, 1, 1)
    end_date = datetime(end_year, 12, 31)
    
    time_between_dates = end_date - start_date
    days_between_dates = time_between_dates.days
    
    random_number_of_days = random.randrange(days_between_dates)
    random_date = start_date + timedelta(days=random_number_of_days)
    
    return random_date

generate_random_date()