238 lines
8.2 KiB
Python
Executable File
238 lines
8.2 KiB
Python
Executable File
#!/usr/bin/env python
|
|
"""
|
|
CHURCH CALENDAR CSV GENERATOR
|
|
"""
|
|
|
|
import calendar
|
|
from dataclasses import dataclass
|
|
from datetime import date, datetime
|
|
from pprint import pprint
|
|
import sys
|
|
import click
|
|
from dataclass_csv import DataclassWriter
|
|
from events import EVENT_LIST
|
|
|
|
|
|
|
|
|
|
"""
|
|
build a list of months / weeks / day of the month in those weeks
|
|
months 1-12, weeks 0-5 days of week 5 6 are the 1st and 2nd of month
|
|
MONTHS[1] [0] [ 0 0 0 0 0 1 2 ]
|
|
|
|
due to how months work
|
|
week 0 can have null days (represented by 0's)
|
|
weeks 1 - 4 will have all 7 days present
|
|
week 5 may have 7 days or nulls
|
|
week 6 can have a monday and/or tuesday in them if the 1st falls on a
|
|
saturday or sunday in week 0
|
|
|
|
EVENT_LIST has weeks as 1-6 while MONTHS has weeks as 0-5, offsetting will
|
|
be necessary
|
|
"""
|
|
|
|
def initalize_events(event_list):
|
|
""" convert EVENT_LIST into monthly_events """
|
|
monthly_events = [[] for _ in range(7)]
|
|
for event in event_list:
|
|
monthly_events[event[0]].append(event[1:])
|
|
return monthly_events
|
|
|
|
|
|
def debug_print(data, condition=True, end="\n"):
|
|
"""Conditionally print data using pprint.
|
|
|
|
Args:
|
|
data: The data to be printed.
|
|
condition: A boolean value. If True, the data will be printed.
|
|
"""
|
|
if condition:
|
|
print(data, end=end)
|
|
|
|
def initalize_year(year: int) -> dict[int, list[list[int]]]:
|
|
months = dict(enumerate
|
|
([calendar.monthcalendar(year, month) for month in range(1, 13)],
|
|
start=1))
|
|
return months
|
|
|
|
@dataclass
|
|
class Event():
|
|
"""Event for CSV export"""
|
|
# pylint: disable=too-many-instance-attributes
|
|
event_name: str
|
|
venue_name: str
|
|
organizer_name: str
|
|
start_date: str
|
|
start_time: str
|
|
end_date: str
|
|
end_time: str
|
|
all_day_event: str
|
|
categories: str
|
|
event_cost: str
|
|
event_phone: str
|
|
event_website: str
|
|
show_map_link: str
|
|
show_map: str
|
|
event_description: str
|
|
|
|
def suffix(day: int) -> str:
|
|
"""convert day to suffix"""
|
|
result: str = 'th'
|
|
if day in [1, 21, 31]:
|
|
result = 'st'
|
|
elif day in [2, 22]:
|
|
result = 'nd'
|
|
elif day in [3, 23]:
|
|
result = 'rd'
|
|
return result
|
|
|
|
|
|
def sort_events(events: list[Event]) -> list[Event]:
|
|
"""sort events"""
|
|
events = sorted(events, key=lambda k: (k.start_date, k.start_time))
|
|
return events
|
|
|
|
def create_event(name: str,
|
|
location: str,
|
|
categories: str,
|
|
description: str,
|
|
start,
|
|
finish) -> None:
|
|
"""create event"""
|
|
# pylint: disable=too-many-arguments
|
|
event = Event(name,
|
|
location,
|
|
"",
|
|
start.strftime("%Y-%m-%d"),
|
|
start.strftime("%I:%M %p"),
|
|
finish.strftime("%Y-%m-%d"),
|
|
finish.strftime("%I:%M %p"),
|
|
"FALSE",
|
|
categories,
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
description)
|
|
return event
|
|
# events.append(event)
|
|
|
|
|
|
def write_calendar(events: list[Event], filename) -> None:
|
|
"""write calendar to csv file"""
|
|
with open(filename, "w", encoding="utf-8", newline="") as handle:
|
|
writer =DataclassWriter(handle, events, Event)
|
|
writer.map("event_name").to("EVENT NAME")
|
|
writer.map("venue_name").to("VENUE NAME")
|
|
writer.map("organizer_name").to("ORGANIZER NAME")
|
|
writer.map("start_date").to("START DATE")
|
|
writer.map("start_time").to("START TIME")
|
|
writer.map("end_date").to("END DATE")
|
|
writer.map("end_time").to("END TIME")
|
|
writer.map("all_day_event").to("ALL DAY EVENT")
|
|
writer.map("categories").to("CATEGORIES")
|
|
writer.map("event_cost").to("EVENT COST")
|
|
writer.map("event_phone").to("EVENT PHONE")
|
|
writer.map("event_website").to("EVENT_WEBSITE")
|
|
writer.map("show_map_link").to("SHOW MAP LINK?")
|
|
writer.map("show_map").to("SHOW MAP?")
|
|
writer.map("event_description").to("EVENT DESCRIPTION")
|
|
writer.write()
|
|
|
|
|
|
def process_day(events, year, month, day, day_events):
|
|
"""process all events for one day"""
|
|
for event_item in day_events:
|
|
start = datetime(year, month, day, event_item[0], event_item[1])
|
|
finish = datetime(year, month, day, event_item[2], event_item[3])
|
|
debug_print(f" {start:%H:%M}-{finish:%H:%M} {event_item[6]:25} {event_item[4]:11} {event_item[5]:16} {event_item[7]:70.70}", DEBUG)
|
|
event = create_event(event_item[6], event_item[4], event_item[5], event_item[7].replace("\n","\\n"), start, finish)
|
|
events.append(event)
|
|
return events
|
|
|
|
def process_month(months, monthly_events, year, month, week_of_month, week, events):
|
|
"""process one months of events"""
|
|
for day_of_week, day in enumerate(week):
|
|
if day > 0:
|
|
"""
|
|
month, week_of_month, day_of_week, day
|
|
use monthly_events[day_of_week]
|
|
"""
|
|
debug_print(f" {day_of_week}-{day:02d}", DEBUG)
|
|
day_events = [x[1:] for x in monthly_events[day_of_week] if week_of_month + 1 in x[0]]
|
|
events = process_day(events, year, month, day, day_events)
|
|
debug_print("", DEBUG)
|
|
return events
|
|
|
|
def process_months(months, monthly_events, year, month_range):
|
|
"""process full year of months and return list of events"""
|
|
events = []
|
|
for month in range(1, 13):
|
|
if month not in month_range:
|
|
continue
|
|
debug_print(f"MONTH: {month}", DEBUG)
|
|
for week_of_month, week in enumerate(months[month]):
|
|
debug_print(f"{week_of_month} {week}", DEBUG)
|
|
events = process_month(months, monthly_events, year, month, week_of_month, week, events)
|
|
return events
|
|
|
|
def validate_months(ctx, param, value):
|
|
"""
|
|
Validates and processes the --months option.
|
|
Accepts a single number (1-12) or a range (1-3).
|
|
Defaults to 1-12 if no value is provided.
|
|
"""
|
|
if value is None:
|
|
return list(range(1, 13)) # Default behavior
|
|
|
|
parts = value.split('-')
|
|
|
|
if len(parts) == 1:
|
|
# Handle single month input
|
|
try:
|
|
month = int(parts[0])
|
|
if 1 <= month <= 12:
|
|
return [month]
|
|
else:
|
|
raise click.BadParameter("Month must be between 1 and 12.", param=param)
|
|
except ValueError:
|
|
raise click.BadParameter("Invalid month format. Please use an integer between 1 and 12.", param=param)
|
|
|
|
elif len(parts) == 2:
|
|
# Handle range input
|
|
try:
|
|
start, end = int(parts[0]), int(parts[1])
|
|
if 1 <= start <= 12 and 1 <= end <= 12 and start <= end:
|
|
return list(range(start, end + 1))
|
|
else:
|
|
raise click.BadParameter("Invalid month range. Both months must be between 1 and 12, and the start month must be less than or equal to the end month.", param=param)
|
|
except ValueError:
|
|
raise click.BadParameter("Invalid range format. Please use two integers separated by a hyphen (e.g., 1-3).", param=param)
|
|
|
|
else:
|
|
# Handle invalid format
|
|
raise click.BadParameter("Invalid format. Use a single number (e.g., 3) or a range (e.g., 1-3).", param=param)
|
|
|
|
# @click.argument('filename', type=click.File('w'), default="calendar.csv", required=False)
|
|
@click.command()
|
|
@click.option("--debug", "-d", is_flag=True, default=False, help="Print debug output")
|
|
@click.option('--year', "-y", type=int, default=date.today().year, help='Specify the year.')
|
|
@click.option('--months', '-m', 'month_range', callback=validate_months, default=None,
|
|
help='A single month (1-12) or a range (e.g., 1-3). Defaults to all months (1-12).')
|
|
@click.argument('filename', default="calendar.csv", required=False)
|
|
def main(debug, year, month_range, filename):
|
|
"""Create a .csv file of church events for the year. Modify events.py to change events"""
|
|
global DEBUG
|
|
DEBUG = debug
|
|
months = initalize_year(year)
|
|
monthly_events = initalize_events(EVENT_LIST)
|
|
events = process_months(months, monthly_events, year, month_range)
|
|
# events = sort_events(events)
|
|
write_calendar(events, filename)
|
|
sys.exit(0)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main() # pylint: disable=E1120
|