first commit

.gitignore

@@ -0,0 +1,2 @@
+/.venv
+credentials.json

README.md

@@ -9,4 +9,8 @@ app_file: app.py
 pinned: false
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+Demonstrates the following:
+
+- Connecting to the Google APIs via OAuth2
+- Generating a DALL-E image
+- Basic submission form

app.py

@@ -0,0 +1,146 @@
+from datetime import date
+from typing import cast
+
+import openai
+import streamlit as st
+
+import gcal
+import google_oauth
+
+st.title(":calendar: Creative Calendar")
+st.subheader("Illustrate a month from your Google calendar")
+
+
+client: openai.OpenAI | None = None
+month_date: date | None = None
+name: str | None = None
+gender: str | None = None
+genre: str | None = None
+submitted = False
+
+creds = google_oauth.load_creds()
+
+# no Google credentials? we need to authenticate
+if creds is None:
+    flow = google_oauth.get_flow()
+    url = google_oauth.get_auth_url(flow)
+    st.link_button("Authenticate with Google", url=url)
+
+    auth_code = st.text_input("Google auth code", type="password")
+    if auth_code:
+        creds = google_oauth.get_creds(flow, auth_code)
+        st.rerun()
+
+# we have Google credentials, make sure we have the other things
+else:
+    st.checkbox("Authenticated with Google", value=True, disabled=True)
+    openapi_key = st.text_input("OpenAI API key", type="password")
+    if openapi_key:
+        client = openai.OpenAI(api_key=openapi_key)
+
+        with st.form("my_form"):
+            name = st.text_input("Your name")
+            gender = st.radio("Your gender", ["Male", "Female"]) or "Male"
+            genre = st.text_input("Illustration genre", value="fantasy")
+            month_date = cast(date, st.date_input("Select month"))
+            submitted = st.form_submit_button("Submit")
+
+
+def compose_story_prompt(
+    *,
+    name: str,
+    gender: str,
+    events: list[gcal.Event],
+    genre: str,
+) -> str:
+    prompt_events = []
+    for ev in events:
+        dt = ev.start.strftime("%B %d, %Y")
+        line = f"{dt}: {ev.title}"
+        if ev.description:
+            line += f" ({ev.description})"
+        prompt_events.append(line)
+
+    event_str = "\n".join(["-" + ev for ev in prompt_events])
+    prompt = f"""Consider the following events from my Google calendar:
+
+    {event_str}
+
+    Write a description for a short {genre} story that captures the major events
+    from my calendar. The description should cover only the major themes from my
+    calendar. Do not write the story itself, just a description of the story. Do
+    not include any references to a calendar or specific dates, just the major
+    themes from my calendar.
+    
+    The main character is a {gender} named {name}.
+    """
+    return prompt
+
+
+def compose_picture_prompt(story: str, genre: str) -> str:
+    prompt = f"""For the following short {genre} story description, create a single
+    {genre}-style image that captures the major events in the story. Do not
+    include any text in the illustration.
+    -----
+
+    {story}
+    """
+    return prompt
+
+
+@st.cache_data(show_spinner="Writing the story...")
+def write_story(story_prompt):
+    completion = client.chat.completions.create(
+        model="gpt-4",
+        messages=[
+            {
+                "role": "user",
+                "content": [
+                    {"type": "text", "text": story_prompt},
+                ],
+            }
+        ],
+    )
+    content = completion.choices[0].message.content
+    return content
+
+
+@st.cache_data(show_spinner="Illustrating the cover...")
+def draw_picture(picture_prompt: str) -> str:
+    response = client.images.generate(
+        model="dall-e-3",
+        prompt=picture_prompt,
+        size="1024x1024",
+        quality="standard",
+        n=1,
+    )
+    image_url = response.data[0].url
+    return cast(str, image_url)
+
+
+if client and creds and submitted:
+    cal_service = gcal.build_calendar_api(creds)
+    calendars = gcal.get_calendars(cal_service)
+
+    month_start, month_end = gcal.get_start_and_end(cast(date, month_date))
+    events = gcal.get_events(cal_service, month_start, month_end, calendars)
+
+    st.write(
+        f":white_check_mark: Fetched {len(events)} events from "
+        f"{len(calendars)} calendars"
+    )
+
+    story_prompt = compose_story_prompt(
+        name=cast(str, name),
+        gender=cast(str, gender),
+        events=events,
+        genre=cast(str, genre),
+    )
+    story = write_story(story_prompt)
+
+    with st.expander("See the story"):
+        st.write(story)
+
+    picture_prompt = compose_picture_prompt(story, genre)
+    image_url = draw_picture(picture_prompt)
+    st.image(image_url)

gcal.py

@@ -0,0 +1,121 @@
+import calendar
+from dataclasses import dataclass
+from datetime import date, datetime
+from typing import Generator
+
+import pytz
+import streamlit as st
+from googleapiclient.discovery import build
+
+
+def build_calendar_api(creds):
+    return build("calendar", "v3", credentials=creds)
+
+
+@dataclass
+class Event:
+    id: str
+    title: str
+    description: str | None
+    start: datetime
+
+
+@st.cache_data(ttl=60, show_spinner="Fetching calendars...")
+def get_calendars(_service):
+    calendars = []
+    page_token = None
+    while True:
+        calendar_list = _service.calendarList().list(pageToken=page_token).execute()
+        for entry in calendar_list["items"]:
+            cal_id = entry["id"]
+            calendars.append(cal_id)
+        page_token = calendar_list.get("nextPageToken")
+        if not page_token:
+            break
+
+    return calendars
+
+
+def localize(date_input: datetime | date) -> datetime:
+    local_timezone = pytz.timezone("America/Los_Angeles")
+    timezone_aware_datetime = local_timezone.localize(
+        datetime(date_input.year, date_input.month, date_input.day)
+    )
+    utc_datetime = timezone_aware_datetime.astimezone(pytz.utc)
+    return utc_datetime
+
+
+@st.cache_data(ttl=60, show_spinner="Fetching calendar events...")
+def get_events(
+    _service,
+    start: datetime | date,
+    end: datetime | date,
+    calendar_ids: list[str],
+) -> list[Event]:
+    all_events: list[Event] = []
+    for cal_id in calendar_ids:
+        all_events.extend(
+            _gen_events(
+                _service,
+                calendarId=cal_id,
+                timeMin=localize(start).isoformat(),
+                timeMax=localize(end).isoformat(),
+                singleEvents=True,
+                orderBy="startTime",
+            )
+        )
+    all_events.sort(key=lambda ev: ev.start)
+    return all_events
+
+
+def _gen_events(_service, **kwargs) -> Generator[Event, None, None]:
+    page_token = None
+    while True:
+        events = (
+            _service.events()
+            .list(
+                **kwargs,
+                pageToken=page_token,
+            )
+            .execute()
+        )
+        for event in events["items"]:
+            start = _parse_date(event["start"])
+            ev = Event(
+                id=event["id"],
+                title=event["summary"],
+                description=event.get("description"),
+                start=start,
+            )
+            yield ev
+
+        page_token = events.get("nextPageToken")
+        if not page_token:
+            break
+
+
+def _parse_date(date_obj: dict) -> datetime:
+    if "dateTime" in date_obj:
+        dt = datetime.fromisoformat(date_obj["dateTime"].rstrip("Z"))
+
+    elif "date" in date_obj:
+        dt = datetime.fromisoformat(date_obj["date"])
+    else:
+        raise ValueError("Event has no start date")
+
+    is_naive = dt.tzinfo is None or dt.tzinfo.utcoffset(dt) is None
+    if is_naive:
+        if "timeZone" in date_obj:
+            timezone = pytz.timezone(date_obj["timeZone"])
+            dt = timezone.localize(dt)
+        else:
+            dt = pytz.utc.localize(dt)
+
+    return dt
+
+
+def get_start_and_end(month_date: date) -> tuple[date, date]:
+    start_of_month = date(month_date.year, month_date.month, 1)
+    last_day_of_month = calendar.monthrange(month_date.year, month_date.month)[1]
+    end_of_month = date(month_date.year, month_date.month, last_day_of_month)
+    return start_of_month, end_of_month

google_oauth.py

@@ -0,0 +1,34 @@
+import streamlit as st
+from google_auth_oauthlib.flow import Flow
+
+SCOPES = [
+    "https://www.googleapis.com/auth/calendar.events.readonly",
+    "https://www.googleapis.com/auth/calendar.readonly",
+]
+
+
+@st.cache_resource
+def get_flow():
+    flow = Flow.from_client_secrets_file(
+        "credentials.json",
+        scopes=SCOPES,
+        redirect_uri="urn:ietf:wg:oauth:2.0:oob",
+    )
+    return flow
+
+
+def get_auth_url(flow: Flow) -> str:
+    auth_url, _ = flow.authorization_url(prompt="consent")
+    return auth_url
+
+
+@st.cache_resource
+def get_creds(_flow: Flow, code: str):
+    _flow.fetch_token(code=code)
+    creds = _flow.credentials
+    st.session_state.creds = creds
+    return creds
+
+
+def load_creds() -> str | None:
+    return st.session_state.get("creds", None)

requirements.txt

@@ -0,0 +1,2 @@
+google-auth-oauthlib
+google-api-python-client