Susanna Dancy

import os
import random
import re
import requests
import streamlit as st
from dotenv import load_dotenv
from google import genai
import resend

# ---------------------------
# CONFIG
# ---------------------------
load_dotenv()

client = genai.Client(
    api_key=os.getenv("GEMINI_API_KEY")
)

resend.api_key = os.getenv(
    "RESEND_API_KEY"
)

ARTIC_API_URL = (
    "https://api.artic.edu/api/v1/artworks"
)

session = requests.Session()

# ---------------------------
# HEALTH CHECK MODE
# ---------------------------
query_params = st.query_params

if "health" in query_params:
    st.write("ok")
    st.stop()

# ---------------------------
# SESSION STATE
# ---------------------------
DEFAULT_STATE = {
    "artwork": None,
    "description": "",
    "interpretation": "",
    "reflection_text": "",
    "user_input": "",
    "show_email_input": False
}

for key, value in DEFAULT_STATE.items():

    if key not in st.session_state:

        st.session_state[key] = value

# ---------------------------
# HELPERS
# ---------------------------
def build_image_url(image_id):

    return (
        f"https://www.artic.edu/iiif/2/"
        f"{image_id}/full/843,/0/default.jpg"
    )


def valid_email(email):

    pattern = r"^[^@]+@[^@]+\.[^@]+$"

    return re.match(pattern, email)


def ask_gemini(prompt):

    try:

        response = client.models.generate_content(
            model="gemini-2.5-flash",
            contents=prompt
        )

        if (
            response
            and hasattr(response, "text")
            and response.text
        ):

            return response.text.strip()

    except Exception as e:

        print(f"Gemini error: {e}")

    return "The archive remains quiet."

# ---------------------------
# UI
# ---------------------------
st.title("Echo Archive")

st.write(
    "An artwork is drawn from the archive "
    "of the Art Institute of Chicago and "
    "connected to the concepts you bring into it."
)

# ---------------------------
# INPUT FORM
# ---------------------------
with st.form("archive_form"):

    user_input = st.text_area(
        "Share a concept that's been on your mind, then discover an artwork from the Art Institute of Chicago.",
        placeholder=(
            "A concept, memory, tension, idea, or feeling..."
        ),
        height=80
    )

    submitted = st.form_submit_button(
        "Find an Artwork"
    )

# ---------------------------
# SUBMISSION (user must submit concepts)
# ---------------------------
if submitted:

    if not user_input.strip():

        st.warning(
            "Please enter a thought first."
        )

        st.stop()

    st.session_state.user_input = (
        user_input
    )

    st.session_state.description = ""
    st.session_state.interpretation = ""
    st.session_state.reflection_text = ""
    st.session_state.show_email_input = False

    with st.spinner(
        "Searching the archive..."
    ):

        artwork = get_random_artwork()

    if artwork is None:

        st.error(
            "The archive returned nothing."
        )

        st.stop()

    st.session_state.artwork = artwork

# ---------------------------
# DISPLAY
# ---------------------------
if st.session_state.artwork:

    art = st.session_state.artwork

    st.image(
        art["image"],
        use_container_width=True
    )

    st.markdown(
        f"### {art['title']}"
    )

    st.caption(
        f"{art['artist']} · {art['date']}"
    )

    st.caption(
        art["medium"]
    )

# ---------------------------
# ARTWORK RETRIEVAL
# ---------------------------
def get_random_artwork(retries=5):

    for _ in range(retries):

        random_page = random.randint(1, 500)

        try:

            response = session.get(
                ARTIC_API_URL,
                params={
                    "page": random_page,
                    "limit": 25,
                    "fields": (
                        "id,title,image_id,artist_title,"
                        "artist_display,date_display,"
                        "medium_display,dimensions,"
                        "description,classification_title,"
                        "style_title,theme_titles,"
                        "provenance_text,exhibition_history"
                    )
                },
                timeout=10
            )

            response.raise_for_status()

            data = response.json().get(
                "data",
                []
            )

        except Exception as e:

            print(f"ARTIC API error: {e}")

            continue

        artworks = []

        for obj in data:

            image_id = obj.get("image_id")

            if not image_id:
                continue

            has_context = any([
                obj.get("description"),
                obj.get("provenance_text"),
                obj.get("artist_display"),
                obj.get("exhibition_history")
            ])

            if not has_context:
                continue

            artworks.append({
                "id": obj.get("id"),
                "title": obj.get("title") or "Untitled",
                "artist": (
                    obj.get("artist_title")
                    or "Unknown Artist"
                ),
                "artist_display": (
                    obj.get("artist_display")
                    or ""
                ),
                "date": (
                    obj.get("date_display")
                    or "Unknown Date"
                ),
                "medium": (
                    obj.get("medium_display")
                    or "Unknown Medium"
                ),
                "dimensions": (
                    obj.get("dimensions")
                    or ""
                ),
                "description": (
                    obj.get("description")
                    or ""
                ),
                "classification": (
                    obj.get("classification_title")
                    or ""
                ),
                "style": (
                    obj.get("style_title")
                    or ""
                ),
                "themes": (
                    obj.get("theme_titles")
                    or []
                ),
                "provenance": (
                    obj.get("provenance_text")
                    or ""
                ),
                "exhibition_history": (
                    obj.get("exhibition_history")
                    or ""
                ),
                "image": build_image_url(
                    image_id
                )
            })

        if artworks:

            return random.choice(
                artworks
            )

    return None

# ---------------------------
# DESCRIPTION
# ---------------------------
def generate_description(artwork):

    prompt = f"""
    You are writing a concise curatorial
    description for a museum visitor. Your goal is 
    to make art more relatbale to the public.
    Always reference principles of art and design
    present in the work, but make it accesible to layman.
    If the style of work is a response to historical events
    or artistic movements, please include that conext. 
    

    Artwork Information:

    Title: {artwork['title']}
    Artist: {artwork['artist']}
    Artist Bio: {artwork['artist_display']}
    Date: {artwork['date']}
    Medium: {artwork['medium']}
    Classification: {artwork['classification']}
    Style: {artwork['style']}

    Themes:
    {
        ', '.join(artwork['themes'])
        if artwork['themes']
        else 'None listed'
    }

    Museum Description:
    {artwork['description']}

    Provenance:
    {artwork['provenance']}

    Exhibition History:
    {artwork['exhibition_history']}


    Guidelines:
    - Maximum 4 sentences
    - Use the archival context when relevant
    - Note the date for historical context
    - Connect visual qualities to material,
      historical, or atmospheric details
    - Allow subtle aesthetic language
    - Do not address the viewer directly
    - Do not over-explain symbolism
    - Avoid academic stiffness
    - Don't be too forceful

    Output only the description.
    """

    return ask_gemini(prompt)

    # ---------------------------
    # INTERPRET BUTTON
    # ---------------------------
    interpret = st.button(
        "Connect my concepts to this artwork"
    )

    if (
        interpret
        and not st.session_state.interpretation
    ):

        with st.spinner(
            "Connecting concepts to the artwork..."
        ):

            st.session_state.interpretation = (
                generate_interpretation(
                    st.session_state.user_input,
                    art,
                    st.session_state.description
                )
            )

# ---------------------------
# INTERPRETATION
# ---------------------------
def generate_interpretation(
    user_input,
    artwork,
    description
):

    prompt = f"""
    A user entered the following concept,
    thought, or tension:

    "{user_input}"

    Artwork:
    {artwork['title']}
    by {artwork['artist']}

    Visual Description:
    "{description}"

    Artwork Context:
    - Date: {artwork['date']}
    - Style: {artwork['style']}
    - Classification: {artwork['classification']}

    Themes:
    {
        ', '.join(artwork['themes'])
        if artwork['themes']
        else 'None listed'
    }

    Write a concise curatorial interpretation
    connecting the user's idea to the artwork. 
    If the connection is loose or unexpected,
    acknowledge the contrast or coincidence 
    rather than forcing coherence. Always end on a question
    that invites the user to reflect on the artwork.

    Guidelines:
    - Use both visual and historical contex
    - Consider artistic movements,
      tensions, and cultural atmosphere
    - Connections may be indirect,
      historical, atmospheric,
      material, or contrasting
    - Allow the artwork to resist,
      complicate, or soften
      the user's concept
    - The relationship does not need
      to be literal
    - Do not force symbolic agreement
      between the artwork and
      the user's idea
    - Do not overstate weak connections.
    - Avoid therapy-like language
    - Avoid mystical narration
    - Sound perceptive, historically aware,
      and aesthetically attentive
    - Maximum 4 sentences

    Output only the interpretation.
    """

    return ask_gemini(prompt)

    # ---------------------------
    # USER REFLECTION
    # ---------------------------
    st.markdown(
        "### Your Reflection"
    )

    reflection_text = st.text_area(
    "Write a reflection on your experience and "
    "email the details of the encounter for your " 
    "records.",
    value=st.session_state.reflection_text
)
        height=140,
        placeholder=(
            "What connections or tensions emerge for you?"
        )
    )

    st.session_state.reflection_text = (
        reflection_text
    )

    st.divider()

    # ---------------------------
    # EMAIL ARCHIVE
    # ---------------------------
    archive = st.button(
        "Email Me Details of This Archive"
    )

    if archive:

        st.session_state.show_email_input = True

    if st.session_state.show_email_input:

        email_input = st.text_input(
            "Enter your email address"
        )

        send = st.button(
            "Send Details to My Email"
        )

        if send:

            if not valid_email(
                email_input
            ):

                st.warning(
                    "Please enter a valid email."
                )

            else:

                with st.spinner(
                    "Archiving reflection..."
                ):

                    success = send_archive_email(
                        recipient_email=email_input,
                        artwork=art,
                        description=(
                            st.session_state.description
                        ),
                        interpretation=(
                            st.session_state.interpretation
                        ),
                        reflection=(
                            st.session_state.reflection_text
                        )
                    )

                if success:

                    st.success(
                        "All details have been sent."
                    )

                else:

                    st.error(
                        "Unable to send email."
                    )

• Structure each record with consistent fields (title, artist, date, medium, classification, image URL) to support reliable downstream use in the app
• Use Gemini to generate short “archive summaries” (50–80 words) that capture emotional tone, visual structure, and conceptual tension
• Store the dataset locally (CSV/Parquet) and treat it as a fixed curatorial archive rather than a constantly expanding or live system
• Use this archive as a mapping layer between modern user inputs (ideas, emotions, abstract motifs) and historical artworks through association rather than exact keyword matching
• Design the dataset specifically to support AI-assisted interpretation and reflection within the Streamlit application