.POSIX:

# Used to activate pyenv-virtualenv
project_name = kpis-dashboard
# Not used in makefile but handy for documentation purposes
python_version = 3.12.1

help:
	@echo "help here"

test:
	python -m pytest -s

activate:
	@echo pyenv activate $(project_name)

run:
	python -m streamlit run dashboard.py

format:
	find . -name '[a-z]*.py' | xargs python -m black -l 140
	find . -name '[a-z]*.ipynb' | xargs python -m black -l 140

requirements:
	pip freeze > requirements.txt

# If run with no arguments it will build and then run

.POSIX:

# Define the name of the go binary here
GO = go
TARGET = netpage

# Run server with low priority; we use sudo so we can listen on port 80
run: $(TARGET)
	sudo nice -n 20 ./$(TARGET)

# Build if cmd/netpage/netpage.go is newer than ./netpage
netpage: cmd/$(TARGET)/$(TARGET).go
	$(GO) build cmd/$(TARGET)/$(TARGET).go

from mypythonfile import *

# To test some_function which is defined in my_python_file
# for the sake of exposition we assume some_function(s: str) -> str
def test_some_function() -> None:
    input_ = "Input passed to function"
    expectaton = "Value I expect to return"
    assert some_function(input_) == expectation

import pydantic
from datetime import date

class Person(pydantic.BaseModel):
    model_config = pydantic.ConfigDict(arbitrary_types_allowed=True)

    name: str
    title: str
    date_of_birth: date

bob = Person(name='Bob', title='Mr.', date_of_birth=date.today())

import pandas as pd
import sqlalchemy
import os
from sqlalchemy.orm import sessionmaker

user = os.environ["USER"]
password = os.environ["PASS"]
host = os.environ["HOST"]
db = os.environ["DB"]

engine = sqlalchemy.create_engine(f"postgresql://{user}:{password}@{host}/{db}")

def q(s: str, engine: sqlalchemy.engine.base.Engine=engine):
    with engine.connect() as con:
        ret = con.execute(sqlalchemy.text(s)).fetchone()[0]
    return ret

max_date = q("select max(date) from table_name")

import sqlalchemy
import datetime
import pydantic
import sqlalchemy.orm
import functools
from typing import Any, Final

default_db_name: Final[str] = "punch-card"
default_db_url: Final[str] = f"sqlite:///{default_db_name}.sqlite3"

# Metadata for sqlalchemy tables
metadata = sqlalchemy.MetaData()

# Delcarative base class for sqlalchmey
Base = sqlalchemy.orm.declarative_base()


class TimerLogPydantic(pydantic.BaseModel):
    label: str
    state: str
    date: datetime.date
    ts: datetime.datetime


timer_log_table = sqlalchemy.Table(
    "timer_log",
    metadata,
    sqlalchemy.Column("label", sqlalchemy.Text, nullable=False),
    sqlalchemy.Column("state", sqlalchemy.Text, nullable=False),
    sqlalchemy.Column("date", sqlalchemy.Date, nullable=False),
    sqlalchemy.Column("ts", sqlalchemy.DateTime(timezone=True), primary_key=True),
)


class TimerLogBase(Base):
    __tablename__ = "timer_log"

    label = sqlalchemy.Column(sqlalchemy.Text, nullable=False)
    state = sqlalchemy.Column(sqlalchemy.Text, nullable=False)
    date = sqlalchemy.Column(sqlalchemy.Date, nullable=False)
    ts = sqlalchemy.Column(sqlalchemy.DateTime(timezone=True), primary_key=True)

    def __repr__(self) -> str:
        return f"TimerLogDB(label={self.label!r}, state={self.state!r}), date={self.date!r}), ts={self.ts!r})"


def get_engine_and_ddl(conn_str: str) -> sqlalchemy.engine.base.Engine:
    engine = sqlalchemy.create_engine(conn_str)

    # Check we have what we expect from the matadata, otherwise create
    expected_tables = metadata.tables.keys()
    inspector = sqlalchemy.inspect(engine)
    have_tables = inspector.get_table_names()

    if set(have_tables) == set(expected_tables):
        # Expected tables are the same as existing tables"
        pass
    else:
        # Have {have_tables} tables, expect {expected_tables} tables, will create
        metadata.create_all(engine)

    return engine


def get_session(conn_str: str) -> sqlalchemy.orm.session.Session:
    engine = get_engine_and_ddl(conn_str=conn_str)
    Session = sqlalchemy.orm.sessionmaker(engine)
    return Session()


def write_timer_log(row: dict[Any], conn_str: str = default_db_url) -> None:
    # Put into pydantic class first so we catch any issues
    stg = TimerLogPydantic(**row)
    insert_data = TimerLogBase(label=stg.label, state=stg.state, date=stg.date, ts=stg.ts)
    with get_session(conn_str=conn_str) as session:
        session.add(insert_data)
        session.commit()


def read_timer_log(conn_str: str = default_db_url) -> list[TimerLogBase]:
    with get_session(conn_str=conn_str) as session:
        statement = sqlalchemy.select(TimerLogBase).order_by(TimerLogBase.ts)
        ret = session.scalars(statement).all()
    return ret