main.py

import requests
import os
from dotenv import load_dotenv
from pprint import pprint
from datetime import datetime, timezone

load_dotenv()

class Event:
    def __init__(self, data: dict):
        self.uid = self.parse_data(data=data, key="UID")
        self.event_created = self.parse_datetime(
            date_str=self.parse_data(data=data, key="DTSTAMP"))
        self.event_start = self.parse_datetime(
            date_str=self.parse_data(data=data, key="DTSTART"))
        self.event_end = self.parse_datetime(
            date_str=self.parse_data(data=data, key="DTEND"))
        self.title = self.parse_data(data=data, key="SUMMARY")

    def parse_data(self, data: dict, key: str) -> str:
        return data[key] if key in data else "" # type: ignore
    
    def parse_datetime(self, date_str: str) -> float:
        if date_str != "":
            format_string = "%Y%m%dT%H%M%SZ"
            naive_dt = datetime.strptime(date_str, format_string)
            aware_dt = naive_dt.replace(tzinfo=timezone.utc).timestamp()
            return aware_dt
        return 0
    
    def __gt__(self, other):
        # Overloads >
        if self.event_start > other.event_start:
            return True
        return False
    
    def __lt__(self, other) -> bool:
        # Overloads <
        if self.event_start < other.event_start:
            return True
        return False
    
    def __eq__(self, other) -> bool:
        # Overloads ==
        if self.uid == other.uid:
            return True
        return False
    
class Metadata:
    def __init__(self, data: dict):
        self.cal_scale = self.parse_data(data=data, key="CALSCALE")
        self.description = self.parse_data(data=data, key="X-WR-CALDESC")
        self.description = self.parse_data(data=data, key="X-WR-CALNAME")
    def parse_data(self, data: dict, key: str):
        return data[key] if key in data else None # type: ignore

def get_raw_ICS_content(url: str) -> tuple[str, str]:
    res = requests.get(url)
    res = res.text.strip() # Removes whitespace
    start_phrase = "BEGIN:VCALENDAR"
    end_phrase = "END:VCALENDAR"
    res_stripped = res[len(start_phrase):].strip() # strips beginning vcalendar
    calendar_raw = res_stripped[:res_stripped.index("BEGIN:")]
    events_raw = res_stripped[res_stripped.index("BEGIN:"):res_stripped.index(end_phrase)]
    return calendar_raw, events_raw

def check_line(line: str) -> int:
    index = -1
    not_found = True
    while (not_found and index < len(line) - 1):
        index += 1
        # if (line[index].isalnum() == False) and (line[index] not in exceptions):
        if (line[index] == ":"):
            not_found = False
    if line[:index] != line[:index].upper():
        return -1
    return index

def split_ICS_content(raw_text: str) -> list[dict]:
    lines = raw_text.split("\n")
    lines = [line.strip() for line in lines if line] # Checks each line is non-empty
    events = []
    line_num = 0
    while line_num < len(lines):
        event = {}
        prev_key = ""
        while lines[line_num][:3] != "END" and line_num < len(lines):
            index = check_line(lines[line_num])
            if index > 0:
                key = lines[line_num][:index]
                value = lines[line_num][index+1:]
                event[key] = value
                prev_key = key
                # print(prev_key)
            else:
                event[prev_key] += lines[line_num]
            line_num += 1
        events.append(event)
        line_num += 1
    return events

def split_metadata(raw_text: str) -> dict:
    lines = raw_text.split("\n")
    lines = [line.strip() for line in lines if line] # Checks each line is non-empty
    metadata = {}
    for line in lines:
        index = check_line(line)
        key = line[:index]
        value = line[index+1:]
        metadata[key] = value
    return metadata

def clean_metadata(raw_metadata: dict) -> Metadata:
    return Metadata(data=raw_metadata)

def clean_raw_events(raw_events: list[dict]) -> list[Event]:
    clean_events = []
    for event in raw_events:
        if event != {}:
            clean_events.append(Event(data=event))
    return clean_events

def get_ics_from_url(url: str) -> tuple[Metadata, list[Event]]:
    calendar_raw, events_raw = get_raw_ICS_content(url=url)
    raw_split_calendar = split_metadata(raw_text=calendar_raw)
    raw_split_events = split_ICS_content(raw_text=events_raw)
    cleaned_metadata = clean_metadata(raw_metadata=raw_split_calendar)
    cleaned_events = clean_raw_events(raw_events=raw_split_events)
    return cleaned_metadata, cleaned_events

def sort_events(events: list) -> list[Event]:
    # Simple bubble sort
    for i in range(len(events) - 1):
        for i in range(len(events) - 1):
            if events[i+1] > events[i]:
                temp = events[i]
                events[i] = events[i+1]
                events[i+1] = temp
    return events

def get_relevant_events(sorted_events: list, threshold: float) -> list[Event]:
    relevant_events = []
    greater_than = True
    index = 0
    while greater_than:
        event = sorted_events[index]
        if event.event_start > threshold:
            relevant_events.append(event)
            index += 1
        else:
            greater_than = False
    return relevant_events

example_url = os.getenv("ICAL_EXAMPLE_URL")
if example_url != None:
    metadata, events = get_ics_from_url(url=example_url)
    sorted_events = sort_events(events=events)
    threshold = datetime.now().timestamp()
    relevant_events = get_relevant_events(
        sorted_events=sorted_events, threshold=threshold)
    pprint(metadata.__dict__)
    for event in relevant_events:
        pprint(event.__dict__)
    # pprint(events)