dimwit 0.2.7__tar.gz → 0.2.9__tar.gz

{dimwit-0.2.7 → dimwit-0.2.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dimwit
-Version: 0.2.7
+Version: 0.2.9
 Summary: A package containing various functions and classes for fetching, transforming, and visualising data for personal metrics.
 Home-page: https://github.com/danielsoutar/dimwit
 Author: Daniel Soutar
@@ -13,6 +13,8 @@ Classifier: Programming Language :: Python :: 3.12
 Requires-Dist: matplotlib (>=3.8.3,<4.0.0)
 Requires-Dist: pandas (>=2.1.4,<3.0.0)
 Requires-Dist: requests (>=2.31.0,<3.0.0)
+Requires-Dist: scipy (>=1.12.0,<2.0.0)
+Requires-Dist: seaborn (>=0.13.2,<0.14.0)
 Project-URL: Repository, https://github.com/danielsoutar/dimwit
 Description-Content-Type: text/markdown
 

dimwit-0.2.9/dimwit/__init__.py

@@ -0,0 +1,6 @@
+from dimwit.main import *
+import dimwit.airflow
+import dimwit.legacy
+import dimwit.pomodoro
+import dimwit.weight
+import dimwit.air_pollution as ap

dimwit-0.2.9/dimwit/airflow.py

@@ -0,0 +1,277 @@
+from dimwit.main import get_moving_average_trend, populate_with_events
+
+import datetime as dat
+import matplotlib.pyplot as plt
+import numpy as np
+from scipy.stats import norm
+import seaborn as sb
+
+
+def beginning_of_data():
+    uk_with_dst = dat.timezone(dat.timedelta(seconds=3600))
+    return dat.datetime(2023, 8, 21, 0, 0, tzinfo=uk_with_dst)
+
+
+def get_events():
+    uk_with_dst = dat.timezone(dat.timedelta(seconds=3600))
+    dates = [
+        dat.datetime(2023, 9, 12, 13, 40, tzinfo=uk_with_dst),
+        dat.datetime(2024, 2, 4, 0, 0, tzinfo=dat.timezone.utc),
+        dat.datetime(2024, 2, 8, 0, 0, tzinfo=dat.timezone.utc),
+    ]
+    descs = [
+        "Started using inhaler",
+        "Only using inhaler as needed",
+        "Using inhaler unless healthy",
+    ]
+    return [(date, "gray", "--", desc) for date, desc in zip(dates, descs)]
+
+
+def data_over_period(df, from_date, moving_average_window_size, events, title):
+    latest_df = df.loc[from_date:]
+    fig, ax = plt.subplots(1, 1, figsize=(12, 6))
+
+    x = list(latest_df.index)
+
+    ax.scatter(x, latest_df["Recording 1"], label="Point 1", alpha=0.3)
+    ax.scatter(x, latest_df["Recording 2"], label="Point 2", alpha=0.3)
+    ax.scatter(x, latest_df["Recording 3"], label="Point 3", alpha=0.3)
+
+    # Plot a line for the maximum of the points
+    ax.plot(x, latest_df["Max Point"], label="Max", color="red")
+
+    window_size = moving_average_window_size
+
+    # Calculate the rolling average over the max values array
+    # TODO: Figure out whether to use actual data rather than repeating first
+    # point (k - 1) / 2 times, where possible.
+    rolling_average = get_moving_average_trend(
+        np.array(latest_df["Max Point"]), window_size
+    )
+    ax.plot(
+        x,
+        rolling_average,
+        label=f"Rolling Avg ({window_size})",
+        color="green",
+    )
+
+    ax = populate_with_events(ax, events, x[0])
+
+    plt.legend()
+    plt.grid()
+    # Add a title to the entire figure
+    fig.suptitle(title, fontsize=16)
+
+    return fig, ax
+
+
+def differences_over_period(
+    df,
+    from_date,
+    moving_average_window_size,
+    events,
+    title,
+):
+    latest_df = df.loc[from_date:]
+    fig, ax = plt.subplots(1, 1, figsize=(12, 6))
+
+    max_vals = df[["Recording 1", "Recording 2", "Recording 3"]].max(axis=1)
+    min_vals = df[["Recording 1", "Recording 2", "Recording 3"]].min(axis=1)
+    df["Delta"] = max_vals - min_vals
+
+    x = list(latest_df.index)
+
+    ax.scatter(x, df["Delta"], label="Max-Min Difference", alpha=0.3)
+
+    window_size = moving_average_window_size
+
+    # Calculate the rolling average over the max values array
+    # TODO: Figure out whether to use actual data rather than repeating first
+    # point (k - 1) / 2 times, where possible.
+    rolling_average = get_moving_average_trend(
+        np.array(df["Delta"]),
+        window_size,
+    )
+    ax.plot(
+        x,
+        rolling_average,
+        label=f"Rolling Avg ({window_size})",
+        color="green",
+    )
+
+    ax = populate_with_events(ax, events, x[0])
+
+    plt.legend()
+    plt.grid()
+    # Add a title to the entire figure
+    fig.suptitle(title, fontsize=16)
+
+    return fig, ax
+
+
+def get_pretty_image(
+    image_arr,
+    title,
+    colour_bar_title,
+    palette="viridis",
+    foreground_colour="white",
+    background_colour="black",
+):
+    # 'flare_r' is a neat fire-y palette, as an alternative.
+    cmap = sb.color_palette(palette, as_cmap=True)
+
+    fig, ax = plt.subplots(figsize=(24, 4))
+    image = ax.imshow(
+        image_arr,
+        interpolation="nearest",
+        aspect="auto",
+        cmap=cmap,
+    )
+    colour_bar = plt.colorbar(image)
+
+    # set figure facecolor
+    ax.patch.set_facecolor(background_colour)
+
+    # set tick and ticklabel color
+    image.axes.get_xaxis().set_visible(False)
+    image.axes.get_yaxis().set_visible(False)
+
+    # set imshow outline
+    for spine in image.axes.spines.values():
+        spine.set_edgecolor(background_colour)
+
+    # set colorbar label plus label color
+    colour_bar.set_label(colour_bar_title, color=foreground_colour)
+
+    # set colorbar tick color
+    colour_bar.ax.yaxis.set_tick_params(color=foreground_colour)
+
+    # set colorbar edgecolor
+    colour_bar.outline.set_edgecolor(foreground_colour)
+
+    # set colorbar ticklabels
+    plt.setp(
+        plt.getp(colour_bar.ax.axes, "yticklabels"),
+        color=foreground_colour,
+    )
+
+    _ = ax.set_title(title, color=foreground_colour)
+    fig.patch.set_facecolor(background_colour)
+    return fig, ax
+
+
+def generate_month_year_tuples(start=None, end=None):
+    if start is None:
+        start = (2023, 8)
+
+    if end is None:
+        end_date = dat.datetime.now()
+        end = (end_date.year, end_date.month)
+    else:
+        assert end[0] >= start[0]
+        if end[0] == start[0]:
+            assert end[1] > start[1]
+
+    month_names = {
+        1: "Jan",
+        2: "Feb",
+        3: "Mar",
+        4: "Apr",
+        5: "May",
+        6: "Jun",
+        7: "Jul",
+        8: "Aug",
+        9: "Sep",
+        10: "Oct",
+        11: "Nov",
+        12: "Dec",
+    }
+
+    tuples = []
+    current = start
+
+    while current != end:
+        current_year, current_month = current
+        tuples.append((current_year, current_month))
+        increment_year = current_month == 12
+        if increment_year:
+            next_year, next_month = current_year + 1, 1
+        else:
+            next_year, next_month = current_year, current_month + 1
+
+        current = (next_year, next_month)
+
+    tuples.append(end)
+
+    res = list(map(lambda t: (*t, f"{month_names[t[1]]} {str(t[0])}"), tuples))
+
+    return res
+
+
+def get_hist_data_for_month(df, year, month, use_maxes=False):
+    utc = dat.timezone.utc
+
+    dt = dat.datetime(year, month, 1, 0, 0, tzinfo=utc)
+    if month == 12:
+        end_dt = dat.datetime(year + 1, 1, 1, 0, 0, tzinfo=utc)
+    else:
+        end_dt = dat.datetime(year, month + 1, 1, 0, 0, tzinfo=utc)
+
+    month_data = df[["Recording 1", "Recording 2", "Recording 3"]][dt:end_dt]
+    month_data = np.array(month_data).reshape((-1, 3))
+
+    if use_maxes:
+        month_maxes = np.max(month_data, axis=1).reshape((-1, 1))
+        return month_maxes
+
+    return month_data
+
+
+def generate_overlaid_monthly_pdfs(df, xmin=500, xmax=800, num_samples=100):
+    fig, ax = plt.subplots(1, 1)
+
+    for year, month, name in generate_month_year_tuples():
+        all_samples_for_month = get_hist_data_for_month(df, year, month)
+        maxes_for_month = get_hist_data_for_month(
+            df,
+            year,
+            month,
+            use_maxes=True,
+        )
+        mean, std_dev = norm.fit(all_samples_for_month)
+        max_mean, _ = norm.fit(maxes_for_month)
+
+        pdf_x = np.linspace(xmin, xmax, num_samples)
+        pdf_y = norm.pdf(pdf_x, mean, std_dev)
+
+        month_label = f"{name} ({round(mean)}/{round(max_mean)})"
+        ax.plot(pdf_x, pdf_y, linewidth=2, label=month_label)
+
+    ax.legend()
+    ax.set_xlabel("Airflow (L/Min)")
+    ax.set_ylabel("Count")
+    ax.set_title("PDF of data, per month", size=16)
+    ax.set_xlim(xmin, xmax)
+    return fig, ax
+
+
+def create_monthly_airflow_histograms(df, month_year_tuples):
+    # Create a figure with subplots
+    rows = len(month_year_tuples)
+    fig, axes = plt.subplots(rows, 1, figsize=(5, 10), sharex=True)
+
+    # Plot data for each week on separate axes
+    for i, ax in enumerate(axes):
+        year, month, name = month_year_tuples[i]
+        month_data = get_hist_data_for_month(df, year, month)
+        flattened_month_data = month_data.ravel()
+        name = name + f" ({len(flattened_month_data)} samples)"
+        ax.hist(flattened_month_data, label=f"{name}")
+        ax.set_title(f"{name}")
+        ax.set_ylim(0, 50)
+
+    # Add a title to the entire figure
+    fig.suptitle("Distribution of data, per month", fontsize=16)
+    fig.supxlabel("Airflow (L/Min)")
+    fig.supylabel("Count")
+    return fig, axes

{dimwit-0.2.7 → dimwit-0.2.9}/dimwit/main.py

@@ -356,6 +356,9 @@ def get_aggregated_event_counts(ts, events, period):
     return grouped_df
 
 
+# TODO: Add 'get all events where equal to' function. Do not want a dense df.
+
+
 def populate_with_events(ax, events, from_date):
     for event in events:
         event_date, event_colour, event_style, event_label = event

dimwit-0.2.9/dimwit/pomodoro.py

@@ -0,0 +1,168 @@
+import pandas as pd
+from typing_extensions import NamedTuple
+
+
+def is_business_day(date):
+    return bool(len(pd.bdate_range(date, date)))
+
+
+def generate_cumulative_df(df, ref_policy, from_date=None, until_date=None):
+    from_date = df.index[0] if from_date is None else from_date
+    until_date = df.index[-1] if until_date is None else until_date
+    time_range_df = df.copy(deep=True).loc[from_date:until_date]
+
+    exclude_dates = []
+
+    resolution = ref_policy.pomodoro_length + ref_policy.break_length
+    current_time = pd.Timestamp.today().time().replace(second=0, microsecond=0)
+    start_of_business = current_time.replace(hour=9, minute=0)
+    close_of_business = current_time.replace(hour=17, minute=0)
+    ref_entries = get_reference_entries(
+        time_range_df.index,
+        resolution,
+        start_of_business,
+        close_of_business,
+        exclude_dates,
+    )
+
+    target_entries = get_target_entries(time_range_df.index, exclude_dates)
+
+    ref_pom_col = "Reference Pomodoro Lengths " + ref_policy.description
+    ref_break_col = "Reference Break Lengths " + ref_policy.description
+    target_pom_col = "Target Pomodoro Lengths (3x 45+15)"
+    target_break_col = "Target Break Lengths (3x 45+15)"
+
+    time_range_df[ref_pom_col] = 0.0
+    time_range_df[ref_break_col] = 0.0
+    time_range_df[target_pom_col] = 0.0
+    time_range_df[target_break_col] = 0.0
+
+    time_range_df.loc[ref_entries, ref_pom_col] = ref_policy.pomodoro_length
+    time_range_df.loc[ref_entries, ref_break_col] = ref_policy.break_length
+    time_range_df.loc[target_entries, target_pom_col] = 45.0
+    time_range_df.loc[target_entries, target_break_col] = 15.0
+
+    cumulative_df = time_range_df.cumsum()
+
+    return cumulative_df
+
+
+def get_target_entries(index, exclude_dates):
+    valid_entries_for_target = []
+
+    set_times = set([9, 10, 11])
+
+    for i, timestamp in enumerate(index):
+        if timestamp in exclude_dates or not is_business_day(timestamp):
+            continue
+        ts: pd.Timestamp = timestamp
+        if ts.time().hour in set_times and ts.time().minute == 0:
+            valid_entries_for_target.append(ts)
+
+    return valid_entries_for_target
+
+
+def get_reference_entries(
+    index,
+    resolution,
+    start_time,
+    end_time,
+    exclude_dates,
+):
+    valid_entries_for_reference = []
+
+    for i, timestamp in enumerate(index):
+        if timestamp in exclude_dates:
+            continue
+        if is_business_day(timestamp):
+            time = timestamp.time()
+            start_of_day, end_of_day = start_time, end_time
+            if time >= start_of_day and time < end_of_day and time.hour != 13:
+                # Way to fix this would be to check if the latest valid entry
+                # has the delta. Skip this step until len(valid_entries) > 0.
+                if len(valid_entries_for_reference) > 0:
+                    delta = timestamp - valid_entries_for_reference[-1]
+                    if delta < pd.Timedelta(minutes=resolution):
+                        continue
+                valid_entries_for_reference.append(timestamp)
+
+    return valid_entries_for_reference
+
+
+class ReferencePolicy(NamedTuple):
+    pomodoro_length: float
+    break_length: float
+    description: str
+
+
+def get_kth_latest_monday(k=0):
+    today = pd.to_datetime("today", utc=True)
+    latest_monday = today - pd.Timedelta(days=today.weekday(), weeks=k)
+    latest_monday_start_of_day = latest_monday.replace(hour=8, minute=0)
+    return latest_monday_start_of_day
+
+
+def get_kth_latest_sunday(k=0):
+    today = pd.to_datetime("today", utc=True)
+    today_k_weeks_ago = today - pd.Timedelta(weeks=k)
+    latest_sunday = today_k_weeks_ago + pd.Timedelta(
+        days=7 - today.weekday() - 1,
+    )
+    latest_sunday_end_of_day = latest_sunday.replace(hour=18, minute=0)
+    return latest_sunday_end_of_day
+
+
+def generate_cumulative_df_for_kth_latest_week(df, k):
+    pomodoro_date_range = pd.date_range(
+        start=get_kth_latest_monday(k), freq="d", end=get_kth_latest_sunday(k)
+    )
+    start, end = pomodoro_date_range[0], pomodoro_date_range[-1]
+
+    # If end later than latest available entry in df (i.e. start of the week),
+    # then pad out df to generate zero entries.
+    # if end > df.index[-1]:
+    #     num_entries = 0
+    #     latest_val = df.index[-1]
+    #     while end > latest_val:
+    #         latest_val += df.index.freq
+    #         num_entries += 1
+    #     df = dimwit.pad_out_table(
+    #         df, num_entries, df.index.freq, pad_before=False
+    #     )
+
+    ref_policy = ReferencePolicy(45.0, 15.0, "(45+15)")
+    cum_df = generate_cumulative_df(df, ref_policy, start, end)
+
+    return cum_df, ref_policy, start, end
+
+
+def plot_burn_up_plot_for_kth_latest_week(df, k):
+    result = generate_cumulative_df_for_kth_latest_week(df, k)
+    cum_df, ref_policy, start, end = result
+
+    ref_col = "Reference Pomodoro Lengths " + ref_policy.description
+    target_col = "Target Pomodoro Lengths (3x 45+15)"
+
+    ax = cum_df.plot(y=["pomodoro_lengths", ref_col, target_col])
+
+    total_pomodoro_length = cum_df["pomodoro_lengths"].iloc[-1]
+    total_ref_pomodoro_length = cum_df[ref_col].iloc[-1]
+    total_target_pomodoro_length = cum_df[target_col].iloc[-1]
+
+    ax.legend(
+        labels=[
+            f"Pomodoro Lengths (Mixed), total={total_pomodoro_length}",
+            target_col + f", total={total_target_pomodoro_length}",
+            ref_col + f", total={total_ref_pomodoro_length}",
+        ],
+        loc="upper right",
+    )
+    ax.set_ylabel("Cumulative time (minutes)")
+
+    start_str = start.to_pydatetime().strftime("%d/%m")
+    end_str = end.to_pydatetime().strftime("%d/%m")
+
+    ax.set_title(f"Work Pomodoros for week ({start_str}-{end_str})")
+    ax.set_ylim(0, 2100)
+
+    return ax

dimwit-0.2.9/dimwit/weight.py

@@ -0,0 +1,65 @@
+from dimwit import get_moving_average_trend, populate_with_events
+
+from datetime import datetime, timedelta
+
+import datetime as dat
+import matplotlib.pyplot as plt
+import numpy as np
+
+
+def beginning_of_data():
+    dst = dat.timezone(dat.timedelta(seconds=3600))
+    return datetime(2023, 5, 20, 0, 0, tzinfo=dst)
+
+
+def daterange(start_date, end_date, unit, step=1):
+    N = int((end_date - start_date) / timedelta(**{unit: 1}))
+    for n in range(0, N, step):
+        yield start_date + timedelta(**{unit: n})
+
+
+def data_over_period(df, from_date, moving_average_window_size, events, title):
+    fig, ax = plt.subplots(1, 1, figsize=(12, 6))
+    current_target = 68.0
+
+    latest_df = df.loc[from_date:]
+    xs = latest_df.index
+    ys = np.array(latest_df["weight_kg"])
+
+    category_names = ["active-era-ref-scale", "external-scale", "historical"]
+    category_labels = ["Reference", "External", "Historical"]
+
+    for category, label in zip(category_names, category_labels):
+        category_df = latest_df.loc[latest_df["category"] == category]
+        category_xs = category_df.index
+        ax.scatter(category_xs, category_df["weight_kg"], label=label)
+
+    current_target_ys = [current_target] * len(xs)
+    ax.plot(
+        xs,
+        current_target_ys,
+        label=f"Current Target ({current_target}kg)",
+    )
+
+    window_size = moving_average_window_size
+
+    # Calculate the rolling average over the max values array
+    # TODO: Figure out whether to use actual data rather than repeating first
+    # point (k - 1) / 2 times, where possible.
+    rolling_average = get_moving_average_trend(ys, window_size)
+    ax.plot(
+        xs,
+        rolling_average,
+        label=f"Rolling Avg ({window_size})",
+        color="green",
+    )
+
+    ax = populate_with_events(ax, events, xs[0])
+
+    ax.set_ylabel("Weight (kg)")
+    plt.legend()
+    plt.grid()
+    # Add a title to the entire figure
+    fig.suptitle(title, fontsize=16)
+
+    return fig, ax

{dimwit-0.2.7 → dimwit-0.2.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "dimwit"
-version = "0.2.7"
+version = "0.2.9"
 description = "A package containing various functions and classes for fetching, transforming, and visualising data for personal metrics."
 authors = ["Daniel Soutar <danielsoutar144@gmail.com>"]
 readme = "README.md"
@@ -11,6 +11,8 @@ python = "^3.10"
 pandas = "^2.1.4"
 requests = "^2.31.0"
 matplotlib = "^3.8.3"
+seaborn = "^0.13.2"
+scipy = "^1.12.0"
 
 
 [build-system]

dimwit-0.2.7/dimwit/__init__.py

@@ -1,3 +0,0 @@
-from dimwit.main import *
-import dimwit.legacy as legacy
-import dimwit.air_pollution as ap