first commit

.gitignore

@@ -0,0 +1,3 @@
+trash
+.conda
+flagged

create_dbs.py

@@ -0,0 +1,73 @@
+import requests
+from bs4 import BeautifulSoup
+import re
+import json
+
+regionCode = 'CO-ANT'
+ebird_api_key = 'dj45pbobk3g5'
+
+
+def get_region_species_list():
+    url = f'https://api.ebird.org/v2/product/spplist/{regionCode}'
+    headers = {'x-ebirdapitoken':ebird_api_key}
+    response = requests.get(url, headers=headers)
+    if response.status_code == 200:
+        data = response.json()
+        return data
+    else:
+        return None
+    
+def get_species_name(taxonCode):
+    url = f'https://api.ebird.org/v2/ref/taxonomy/ebird?species={taxonCode}&fmt=json'
+    response = requests.get(url)
+    if response.status_code == 200:
+        data = response.json()
+        return data[0]['sciName']
+    else:
+        return None
+
+def get_image_url(regionCode, taxonCode):
+    # url = f"https://search.macaulaylibrary.org/catalog?regionCode={regionCode}&taxonCode={taxonCode}&sort=rating_rank_desc&mediaType=photo"
+    url = f"https://search.macaulaylibrary.org/catalog?taxonCode={taxonCode}&sort=rating_rank_desc&mediaType=photo"
+    
+    response = requests.get(url)
+    if response.status_code == 200:
+        soup = BeautifulSoup(response.content, 'html.parser')
+        script_str = soup.find_all('script')
+        # enlace = soup.find('meta', {'property': 'og:image'})['content']
+        # print('enlace: ', enlace)
+        match = re.search(r'assetId:(\d+),', str(script_str))
+        if match:
+            asset_id = match.group(1)
+            enlace = f"https://cdn.download.ams.birds.cornell.edu/api/v1/asset/{asset_id}"
+            print(enlace)
+            return enlace
+        else:
+            return None
+    else:
+        return None
+
+
+species = []
+
+species_codes = get_region_species_list()
+print('len of species codes: ', len(species_codes))
+if species_codes:
+    for ind, species_code in enumerate(species_codes):
+        print(ind + 1, 'of', len(species_codes))
+        species_name = get_species_name(species_code)
+        if not species_code:
+            print('error with: ', species_code)
+
+        image_url = get_image_url(regionCode, species_code)
+        if not image_url:
+            print('error with image url: ', species_code)
+
+        species.append({'code':species_code, 'name':species_name, 'image_url':image_url})
+
+# save to json:
+
+with open('species.json', 'w') as f:
+    json.dump(species, f)
+
+print('len of species: ', len(species))

main.py

@@ -0,0 +1,142 @@
+import gradio as gr
+import random
+import json
+
+with open('species.json') as f:
+    lista = json.load(f)
+
+
+
+def inicializar_preguntas():
+    num_questions = 20
+
+    muestra_juego = random.sample(lista, num_questions)
+
+    questions = []
+
+    for especie in muestra_juego:
+        correcta = especie['name']
+        revision = True
+        while revision:
+            opciones = random.sample(lista, 3)
+            op_names = [op['name'] for op in opciones]
+            if not correcta in op_names:
+                op_names.append(correcta)
+                random.shuffle(op_names)
+                revision = False
+
+        # posicion_ultima_barra = especie['image_url'].rfind('/')
+        # enlace_recortado = especie['image_url'][:posicion_ultima_barra]
+        questions.append({"image": especie['image_url'], "options": op_names, "answer": correcta})
+    return questions
+
+def check_question(option, ind, score, questions):
+    try:
+        questions = questions.value
+    except:
+        questions = questions
+
+    try:
+        score = score.value
+    except:
+        score = score
+
+    try:
+        ind = ind.value
+    except:
+        ind = ind
+
+    
+
+    if ind == len(questions) - 1:
+        # # _, ind, score, image, options, _ = fin_preguntas()# restart_quiz()
+        # questions_list = inicializar_preguntas()
+        # questions = gr.State(questions_list)
+        # #ind = gr.State(0)
+        image = gr.Image(height=300, width=300)
+        options = gr.Radio() #choices=questions[ind.value]["options"])
+
+        if option == questions[ind]["answer"]:
+            score += 1
+            texto_corr = "Correcto"
+        else:
+            texto_corr = "Incorrecto\nLa respuesta correcta es: " + questions[ind]["answer"]
+
+        # try:
+        return texto_corr, ind, score, image, options, f"Terminó el quiz\nTuviste {score} de {ind} preguntas correctas\nScore: {int(score/len(questions)*100)}\nReinicie para empezar de nuevo"
+        # except:
+        #     return texto_corr, ind, score, image, options, f"Terminó el quiz\nScore: {int(score.value/len(questions)*100)}\nReinicie para empezar de nuevo"
+        
+
+
+    if option == questions[ind]["answer"]:
+        score += 1
+        texto_corr = "Correcto"
+    else:
+        texto_corr = "Incorrecto\nLa respuesta correcta es: " + questions[ind]["answer"]
+    
+    ind += 1
+    image = gr.Image(value=questions[ind]["image"], height=300, width=300)
+    options = gr.Radio(choices=questions[ind]["options"])
+
+    return texto_corr, ind, score, image, options, f"Llevas: {score} de {ind} preguntas"
+
+def restart_quiz():
+    score = gr.State(0)
+    questions_list = inicializar_preguntas()
+    questions = gr.State(questions_list)
+    try:
+        questions = questions.value
+    except:
+        questions = questions
+
+    try:
+        score = score.value
+    except:
+        score = score
+
+    
+    # questions, ind, image, options = inicializar_preguntas()
+    
+    ind = gr.State(0)
+    try:
+        ind = ind.value
+    except:
+        ind = ind
+
+    image = gr.Image(value=questions[ind]["image"], height=300, width=300)
+    options = gr.Radio(choices=questions[ind]["options"])
+
+    output = ""
+    return output, ind, score, image, options, f"", questions
+
+def fin_preguntas():
+    # score = gr.State(0)
+    questions_list = inicializar_preguntas()
+    questions = gr.State(questions_list)
+    # questions, ind, image, options = inicializar_preguntas()
+    
+    return "Fin", ind, score, image, options, f"Score: {int(score.value/len(questions)*100)}"
+
+
+with gr.Blocks() as demo:
+    # Preguntas al azar
+    questions_list = inicializar_preguntas()
+    questions = gr.State(questions_list)
+    # Variables 
+    score = gr.State(0)
+    ind = gr.State(0)
+    # Componentes
+    image = gr.Image(value=questions.value[ind.value]["image"], height=300, width=300)
+    options = gr.Radio(choices=questions.value[ind.value]["options"])
+    button = gr.Button("Siguiente pregunta")
+    output = gr.Textbox(label="Output Box")
+    output_score = gr.Textbox(label="Output Box")
+    restart_button = gr.Button("Restart")
+    # Funciones
+    button.click(fn=check_question, inputs=[options, ind, score, questions], outputs=[output, ind, score, image, options, output_score])
+    restart_button.click(fn=restart_quiz, inputs=[], outputs=[output, ind, score, image, options, output_score, questions])
+
+
+if __name__ == "__main__":
+    demo.launch(share=True)

prueba_html_gradio.py

@@ -0,0 +1,20 @@
+import gradio as gr
+
+title = "test"
+
+def inference(text):
+    html = (
+            "<div >"
+            "<img  src='file/lion.jpg' alt='image One'>"
+            + "</div>"
+    )
+    return html
+
+gr.Interface(
+    inference,
+    gr.inputs.Textbox(placeholder="Enter sentence here..."),
+    outputs=["html"],
+    title=title,
+    allow_flagging="never",
+
+).launch(enable_queue=True)

quiz.py

@@ -0,0 +1,66 @@
+import gradio as gr
+import random
+import json
+
+with open('species.json') as f:
+    lista = json.load(f)
+
+def inicializar_preguntas(num_questions=30):
+    muestra_juego = random.sample(lista, num_questions)
+    questions = []
+    for especie in muestra_juego:
+        correcta = especie['name']
+        revision = True
+        while revision:
+            opciones = random.sample(lista, 3)
+            op_names = [op['name'] for op in opciones]
+            if correcta not in op_names:
+                op_names.append(correcta)
+                random.shuffle(op_names)
+                revision = False
+        questions.append({"image": especie['image_url'], "options": op_names, "answer": correcta})
+    return questions
+
+def check_question(option, ind, score, questions):
+    if ind == len(questions) - 1:
+        return f"Puntuación: {int(score/len(questions)*100)}%", None, None, None, score
+
+    if option == questions[ind]["answer"]:
+        score += 1
+        texto_corr = "Correcto"
+    else:
+        texto_corr = f"Incorrecto\nLa respuesta correcta es: {questions[ind]['answer']}"
+    
+    ind += 1
+    image = gr.Image(value=questions[ind]["image"], height=300, width=300)
+    options = gr.Radio(choices=questions[ind]["options"])
+
+    return texto_corr, ind, image, options, score
+
+with gr.Blocks() as demo:
+    ind = gr.State(0)
+    score = gr.State(0)
+    questions = gr.State()
+
+    @gr.on("load")  # Esta función se ejecuta cada vez que se carga la interfaz
+    def on_load():
+        return {'questions': inicializar_preguntas(), 'ind': 0, 'score': 0}
+
+    image = gr.Image(height=300, width=300)
+    options = gr.Radio()
+    button = gr.Button("Siguiente pregunta")
+    output = gr.Textbox(label="Output Box")
+
+    def update_ui(questions, ind):
+        if questions and ind < len(questions):
+            image.update(value=questions[ind]["image"])
+            options.update(choices=questions[ind]["options"])
+        else:
+            image.update(value=None)
+            options.update(choices=[])
+
+    button.click(fn=check_question, inputs=[options, ind, score, questions], outputs=[output, ind, image, options, score])
+    demo.on("load")(update_ui)  # Actualiza la UI al cargar basándose en las preguntas generadas
+
+if __name__ == "__main__":
+    demo.launch(share=True)

reload_test.py

@@ -0,0 +1,26 @@
+import gradio as gr
+import random
+
+def generate_random_number():
+    """
+    Generates a random number between 1 and 100.
+    Takes a dummy argument to comply with Gradio's expectations when triggered by a button.
+    """
+    return random.randint(1, 100)
+
+# The 'Button' component triggers the action. In Gradio 4.5.0, components are more streamlined,
+# and you might not need to specify the input component type as explicitly.
+# Here, the button is directly linked to the action function.
+# Note: Unlike previous versions, if your function expects an argument from an input component,
+# you must ensure the function can accept it, even if the input is not used.
+# Hence, the dummy parameter in 'generate_random_number' function.
+
+with gr.Blocks() as demo:
+    gr.Markdown("# Random Number Generator")
+    gr.Markdown("Click the button to generate a new random number.")
+    button = gr.Button("Refresh Number")
+    output = gr.Number(label="Random Number")
+
+    button.click(fn=generate_random_number, inputs=[], outputs=output)
+
+demo.launch()

scrapper.py

@@ -0,0 +1,77 @@
+import requests
+from bs4 import BeautifulSoup
+import re
+
+
+def get_image_url(regionCode, taxonCode):
+    url = f"https://search.macaulaylibrary.org/catalog?regionCode={regionCode}&taxonCode={taxonCode}&sort=rating_rank_desc&mediaType=photo"
+    response = requests.get(url)
+    if response.status_code == 200:
+        soup = BeautifulSoup(response.content, 'html.parser')
+        script_str = soup.find_all('script')
+        match = re.search(r'assetId:(\d+),', str(script_str))
+        if match:
+            asset_id = match.group(1)
+            return asset_id
+        else:
+            return None
+    else:
+        return None
+
+
+# Set the URL of the webpage to be scraped
+
+url = "https://search.macaulaylibrary.org/catalog?regionCode=CO-ANT&taxonCode=bertin1&sort=rating_rank_desc&mediaType=photo"
+
+# Send a GET request to the URL
+response = requests.get(url)
+
+# Check if the request was successful (status code 200)
+if response.status_code == 200:
+    # print('ok')
+    # Parse the HTML content
+    soup = BeautifulSoup(response.content, 'html.parser')
+    script_str = soup.find_all('script')
+    with open('prueba4.html', 'w', encoding='utf-8') as f:
+        f.write(str(script_str))
+
+    # Extract the image URL from the HTML content)
+    # enlace = soup.find('meta', {'property': 'og:image'})['content']
+    enlace = soup.find_all('div', {'id': 'ResultsGallery-row'})
+    
+
+    # Imprimir el enlace
+    print(enlace)
+
+    # with open('prueba2.html', 'w', encoding='utf-8') as f:
+    #     f.write(str(soup))
+
+    #print(soup.prettify())
+    # prueba = soup.find_all('div', {'class': 'ResultsGallery'})
+    prueba = soup.find_all('script')
+    # print(str(prueba))
+    
+
+    match = re.search(r'assetId:(\d+),', str(prueba))
+
+    if match:
+        asset_id = match.group(1)
+        print(f"Asset ID: {asset_id}")
+    else:
+        print("Asset ID not found.")
+
+    # ---------------
+
+
+    # with open('prueba.html', 'w', encoding='utf-8') as f:
+    #     f.write(str(prueba))
+
+    # # Now you can use BeautifulSoup to extract information from the HTML
+    # # For example, let's extract all image URLs
+    # image_urls = [img['src'] for img in soup.find_all('data-asset-id')]
+
+    # # Print the extracted image URLs
+    # for i, url in enumerate(image_urls, start=1):
+    #     print(f"Image {i}: {url}")
+else:
+    print(f"Failed to retrieve the webpage. Status code: {response.status_code}")

scrapper2.py

@@ -0,0 +1,38 @@
+from selenium import webdriver
+from bs4 import BeautifulSoup
+
+url = "https://search.macaulaylibrary.org/catalog?regionCode=CO-ANT&taxonCode=bltfly1&sort=rating_rank_desc&mediaType=photo"
+
+# Set up the ChromeDriver (you need to have ChromeDriver installed and its path added to your system PATH)
+driver = webdriver.Chrome()
+
+# Load the webpage
+driver.get(url)
+
+# Get the page source after the dynamic content has loaded
+page_source = driver.page_source
+
+# Parse the HTML content
+soup = BeautifulSoup(page_source, 'html.parser')
+
+# Now you can use BeautifulSoup to extract information from the HTML
+# For example, let's extract all image URLs
+# print(soup.find_all('img'))
+
+image_urls = [img['src'] for img in soup.find_all('img')]
+
+
+# Print the extracted image URLs
+for i, url in enumerate(image_urls, start=1):
+    print(f"Image {i}: {url}")
+    print(url.split('/asset/')[-1].split('/')[0])
+    break
+
+# Close the browser window
+driver.quit()
+
+
+
+def get_image_asset(url):
+
+    return url.split('/asset/')[-1].split('/')[0]

test.py

@@ -0,0 +1,36 @@
+import gradio as gr
+
+
+questions = [
+    {"image": "imgs/IMG_1.jpg", "options": ["a", "b", "c", "d"], "answer": "b"},
+    {"image": "imgs/IMG_2.jpg", "options": ["w", "x", "y", "z"], "answer": "y"},
+]
+
+
+def check_question(option, ind):
+
+    print(option)
+    print(questions[ind]["answer"])
+
+    if option == questions[ind]["answer"]:
+        return "Correcto"
+    else:
+        return "Incorrecto"
+
+
+ind = 0
+with gr.Blocks() as demo:
+    # image = gr.Image(value="imgs/IMG_1.jpg", height=200, width=200)
+    # name = gr.Textbox(label="Name")
+    # output = gr.Textbox(label="Output Box")
+
+    image = gr.Image(value=questions[ind]["image"])
+    options = gr.Radio(choices=questions[ind]["options"]) 
+    button = gr.Button("Siguiente pregunta")
+    output = gr.Textbox(label="Output Box")
+
+
+    button.click(fn=check_question, inputs=[options, ind], outputs=output)
+    ind += 1
+
+demo.launch()

test2.py

@@ -0,0 +1,142 @@
+import gradio as gr
+import random
+import json
+
+with open('species.json') as f:
+    lista = json.load(f)
+
+
+
+def inicializar_preguntas():
+    num_questions = 20
+
+    muestra_juego = random.sample(lista, num_questions)
+
+    questions = []
+
+    for especie in muestra_juego:
+        correcta = especie['name']
+        revision = True
+        while revision:
+            opciones = random.sample(lista, 3)
+            op_names = [op['name'] for op in opciones]
+            if not correcta in op_names:
+                op_names.append(correcta)
+                random.shuffle(op_names)
+                revision = False
+
+        # posicion_ultima_barra = especie['image_url'].rfind('/')
+        # enlace_recortado = especie['image_url'][:posicion_ultima_barra]
+        questions.append({"image": especie['image_url'], "options": op_names, "answer": correcta})
+    return questions
+
+def check_question(option, ind, score, questions):
+    try:
+        questions = questions.value
+    except:
+        questions = questions
+
+    try:
+        score = score.value
+    except:
+        score = score
+
+    try:
+        ind = ind.value
+    except:
+        ind = ind
+
+    
+
+    if ind == len(questions) - 1:
+        # # _, ind, score, image, options, _ = fin_preguntas()# restart_quiz()
+        # questions_list = inicializar_preguntas()
+        # questions = gr.State(questions_list)
+        # #ind = gr.State(0)
+        image = gr.Image(height=300, width=300)
+        options = gr.Radio() #choices=questions[ind.value]["options"])
+
+        if option == questions[ind]["answer"]:
+            score += 1
+            texto_corr = "Correcto"
+        else:
+            texto_corr = "Incorrecto\nLa respuesta correcta es: " + questions[ind]["answer"]
+
+        # try:
+        return texto_corr, ind, score, image, options, f"Terminó el quiz\nTuviste {score} de {ind} preguntas correctas\nScore: {int(score/len(questions)*100)}\nReinicie para empezar de nuevo"
+        # except:
+        #     return texto_corr, ind, score, image, options, f"Terminó el quiz\nScore: {int(score.value/len(questions)*100)}\nReinicie para empezar de nuevo"
+        
+
+
+    if option == questions[ind]["answer"]:
+        score += 1
+        texto_corr = "Correcto"
+    else:
+        texto_corr = "Incorrecto\nLa respuesta correcta es: " + questions[ind]["answer"]
+    
+    ind += 1
+    image = gr.Image(value=questions[ind]["image"], height=300, width=300)
+    options = gr.Radio(choices=questions[ind]["options"])
+
+    return texto_corr, ind, score, image, options, f"Llevas: {score} de {ind} preguntas"
+
+def restart_quiz():
+    score = gr.State(0)
+    questions_list = inicializar_preguntas()
+    questions = gr.State(questions_list)
+    try:
+        questions = questions.value
+    except:
+        questions = questions
+
+    try:
+        score = score.value
+    except:
+        score = score
+
+    
+    # questions, ind, image, options = inicializar_preguntas()
+    
+    ind = gr.State(0)
+    try:
+        ind = ind.value
+    except:
+        ind = ind
+
+    image = gr.Image(value=questions[ind]["image"], height=300, width=300)
+    options = gr.Radio(choices=questions[ind]["options"])
+
+    output = ""
+    return output, ind, score, image, options, f"", questions
+
+def fin_preguntas():
+    # score = gr.State(0)
+    questions_list = inicializar_preguntas()
+    questions = gr.State(questions_list)
+    # questions, ind, image, options = inicializar_preguntas()
+    
+    return "Fin", ind, score, image, options, f"Score: {int(score.value/len(questions)*100)}"
+
+
+with gr.Blocks() as demo:
+    # Preguntas al azar
+    questions_list = inicializar_preguntas()
+    questions = gr.State(questions_list)
+    # Variables 
+    score = gr.State(0)
+    ind = gr.State(0)
+    # Componentes
+    image = gr.Image(value=questions.value[ind.value]["image"], height=300, width=300)
+    options = gr.Radio(choices=questions.value[ind.value]["options"])
+    button = gr.Button("Siguiente pregunta")
+    output = gr.Textbox(label="Output Box")
+    output_score = gr.Textbox(label="Output Box")
+    restart_button = gr.Button("Restart")
+    # Funciones
+    button.click(fn=check_question, inputs=[options, ind, score, questions], outputs=[output, ind, score, image, options, output_score])
+    restart_button.click(fn=restart_quiz, inputs=[], outputs=[output, ind, score, image, options, output_score, questions])
+
+
+if __name__ == "__main__":
+    demo.launch(share=True)

test_streamlit.py

@@ -0,0 +1,16 @@
+import streamlit as st
+import random
+
+# Display a title and instructions
+st.title('Random Number Generator')
+st.write('Click the button to generate a new random number.')
+
+# When the button is clicked, Streamlit reruns the script from the top.
+# Thus, we generate a new random number on each run.
+if st.button('Refresh Number'):
+    random_number = random.randint(1, 100)
+    # Display the random number in the app.
+    st.write(f'Random Number: {random_number}')
+else:
+    # Initial message before button is pressed for the first time.
+    st.write('Press the button to generate a random number.')