dimwit 0.2.26__tar.gz → 0.2.28__tar.gz

{dimwit-0.2.26 → dimwit-0.2.28}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dimwit
-Version: 0.2.26
+Version: 0.2.28
 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

{dimwit-0.2.26 → dimwit-0.2.28}/dimwit/main.py

@@ -225,112 +225,149 @@ def get_moving_average_trend(data, k, padding="copy-on"):
     return rolling_average
 
 
-def get_basic_sleep_dataframe(
-    ts: list[tuple],
-    durations: list[str],
-    target_sleep_start: str = "22:30:00",
-    target_sleep_end: str = "06:30:00",
-):
-    N = len(ts)
-    starts, ends = zip(*ts)
-    all_aligned = len(starts) == len(ends) == len(durations) == N
-    if not all_aligned:
-        raise Exception(
-            f"Unaligned start ({len(starts)} values), "
-            f"end ({len(ends)} values), "
-            f"duration ({len(durations)} values) columns"
+# TODO: Figure out how to append to KDE plots so that the lines all start and
+# end at the same place.
+# TODO: Figure out how to 'project'/'predict' for recent data. Look into
+# conditional density estimation.
+def kde_over_all_categories(ts, events, bw_vals, exclude):
+    # Share the same axes across the various plots.
+    _, ax = plt.subplots(1)
+    for category, bw in zip(set(events), bw_vals):
+        if category in exclude:
+            continue
+        # Fetch all timestamps where the event matches the category.
+        cat_ts = list(
+            map(
+                lambda tup: tup[1],
+                filter(lambda tup: tup[0] == category, zip(events, ts)),
+            )
+        )
+        cat_timeframe = cat_ts[-1] - cat_ts[0]
+        total_timeframe = ts[-1] - ts[0]
+        # Exclude short-lived KDEs - these tend to skew the graphs.
+        if cat_timeframe < (0.3 * total_timeframe):
+            continue
+        df = pd.DataFrame(cat_ts, columns=["dates"])
+        df["ordinal"] = [x.toordinal() for x in df.dates]
+        ax = df["ordinal"].plot(
+            kind="kde",
+            bw_method=bw,
+            ax=ax,
+            label=category,
         )
-    data = {
-        "start_date": starts,
-        "end_date": ends,
-        "durations": durations,
-        "target_sleep_start": [target_sleep_start] * N,
-        "target_sleep_end": [target_sleep_end] * N,
-    }
-    df = pd.DataFrame(data)
-    return df
 
+    ax.set_xlabel("Time")
+    ax.set_ylabel("Density")
+    ax.set_xlim(ts[0].toordinal(), ts[-1].toordinal())
+
+    # Take every other tick to reduce clutter.
+    x_ticks = ax.get_xticks()[::2]
+    ax.set_xticks(x_ticks)
+    xlabels = list(
+        map(
+            lambda x: dat.datetime.fromordinal(int(x)).strftime("%Y-%m-%d"),
+            x_ticks,
+        )
+    )
+    ax.set_xticklabels(xlabels)
+    ax.legend()
+    return ax
 
-def compute_rounded_matrix(ts, events, rounding_unit, rounding_size):
-    """
-    Compute a matrix where each (sorted, ascending) row corresponds to a
-    timestamp, and the columns the types of events, rounding timestamps
-    according to `rounding_unit` and `rounding_size`.
 
-    Each entry corresponds to the number of events of a particular type
-    occurring to the nearest rounded timestamp.
+def kde_over_combined_categories(ts, bw):
+    df = pd.DataFrame(set(ts), columns=["dates"])
+    df["ordinal"] = [x.toordinal() for x in df.dates]
+    ax = df["ordinal"].plot(kind="kde", bw_method=bw, label="Combined")
 
-    Any NaNs are converted to 0s.
-    """
-    data = {"value": [1] * len(events), "categories": events, "date": ts}
-    df = pd.DataFrame(data)
-    # Make sure to set the date column to datetimes recognisable by pandas.
-    df["date"] = pd.to_datetime(df["date"], utc=True)
-    rounding_string = str(rounding_size) + rounding_unit
-    # Need to use dt field, or else more lengthy to work with native datetimes.
-    df["date"] = df["date"].dt.round(rounding_string)
-    df = df.pivot_table(
-        index="date", columns="categories", values="value", aggfunc="sum"
+    ax.set_xlabel("Time")
+    ax.set_ylabel("Density")
+    ax.set_xlim(ts[0].toordinal(), ts[-1].toordinal())
+
+    # Take every other tick to reduce clutter.
+    x_ticks = ax.get_xticks()[::2]
+    ax.set_xticks(x_ticks)
+    xlabels = list(
+        map(
+            lambda x: dat.datetime.fromordinal(int(x)).strftime("%Y-%m-%d"),
+            x_ticks,
+        )
     )
-    return df.fillna(0)
+    ax.set_xticklabels(xlabels)
+    ax.legend()
+    return ax
 
 
-def zero_padded_df(num_rows, num_cols, index):
-    return pd.DataFrame([[0] * num_cols] * num_rows, index=index)
+def day_kde_over_all_categories(ts, events, bw_vals, exclude):
+    # Share the same axes across the various plots.
+    _, ax = plt.subplots(1, figsize=(8, 6))
+    for category, bw in zip(set(events), bw_vals):
+        if category in exclude:
+            continue
+        # Fetch all timestamps where the event matches the category.
+        cat_ts = list(
+            map(
+                lambda tup: tup[1],
+                filter(lambda tup: tup[0] == category, zip(events, ts)),
+            )
+        )
+        cat_timeframe = cat_ts[-1] - cat_ts[0]
+        total_timeframe = ts[-1] - ts[0]
+        # Exclude short-lived KDEs - these tend to skew the graphs.
+        if cat_timeframe < (0.3 * total_timeframe):
+            continue
 
+        df = pd.DataFrame(cat_ts, columns=["dates"])
+        df["time"] = pd.to_datetime(df["dates"], utc=True).dt.time
+        df["time_delta"] = pd.to_timedelta([str(t) for t in df["time"]])
+        df["time_delta_float"] = df["time_delta"] // pd.Timedelta(minutes=1)
+        # Default size of the graph makes the labels too large, might as well
+        # have a bigger plot.
+        ax = df["time_delta_float"].plot(
+            kind="kde",
+            bw_method=bw,
+            label=category,
+            ax=ax,
+        )
 
-def pad_out_table(df, pad_t, unit, pad_before=True, pad_after=True):
-    # Pad out df with entries before and after boundary rows, to ensure correct
-    # same- (or zero-) padding.
-    pad_t_days = pd.Timedelta(pad_t, unit=unit)
-    pad_before_start = df.index[0] - pad_t_days
-    pad_after_start = df.index[-1] + pd.Timedelta(1, unit=unit)
+    ax.set_xlabel("Time (Clock)")
+    ax.set_ylabel("Density")
 
-    # The index in df cannot yet be assumed to be dense - so use a date range
-    # with the earliest and latest entries as reference points.
-    index_before = pd.date_range(pad_before_start, periods=pad_t, freq=unit)
-    index_after = pd.date_range(pad_after_start, periods=pad_t, freq=unit)
+    ax.set_xlim(0, pd.Timedelta(days=1) // pd.Timedelta(minutes=1))
+    hours = [i for i in range(0, 25, 2)]
+    ax.set_xticks(
+        [i * 60 for i in hours], [str(i).rjust(2, "0") + ":00" for i in hours]
+    )
+    ax.set_yticks([])
+    ax.legend()
+    return ax
 
-    num_rows, num_cols = pad_t, len(df.columns)
-    if pad_before:
-        df = pd.concat([zero_padded_df(num_rows, num_cols, index_before), df])
-    if pad_after:
-        df = pd.concat([zero_padded_df(num_rows, num_cols, index_after), df])
 
-    return df
+def day_kde_over_combined_categories(ts, bw):
+    df = pd.DataFrame(set(ts), columns=["dates"])
+    df["time"] = pd.to_datetime(df["dates"], utc=True).dt.time
+    df["time_delta"] = pd.to_timedelta([str(t) for t in df["time"]])
+    df["time_delta_float"] = df["time_delta"] // pd.Timedelta(minutes=1)
+    # Default size of the graph makes the labels too large, might as well have
+    # a bigger plot.
+    _, ax = plt.subplots(1, figsize=(8, 6))
+    ax = df["time_delta_float"].plot(
+        kind="kde",
+        bw_method=bw,
+        label="Combined",
+        ax=ax,
+    )
 
+    ax.set_xlabel("Time (Clock)")
+    ax.set_ylabel("Density")
 
-# TODO: Enable different window sizes for different columns.
-# Either this means returning a set of Series objects, or padding values in a
-# single dataframe.
-def compute_moving_average_matrix(
-    ts, events, rounding_unit, rounding_size, window_size
-):
-    df = compute_rounded_matrix(ts, events, rounding_unit, rounding_size)
-    categories = df.columns
-
-    df_needs_padding = window_size > 1
-    if df_needs_padding:
-        pad_t = (window_size - 1) // 2
-        df = pad_out_table(df, pad_t, rounding_unit)
-
-    window_string = str(rounding_size) + rounding_unit
-    dense_series = []
-    for column in categories:
-        # TODO: Fix annoying ImportError involving 'freq_to_period_freqstr'.
-        sparse_column: pd.Series = df[column]
-        dense_column = sparse_column.asfreq(freq=window_string)
-        dense_column_no_nans = dense_column.fillna(0)
-        dense_series.append(dense_column_no_nans)
-
-    dense_df = pd.DataFrame(dense_series).T
-
-    if not df_needs_padding:
-        return dense_df
-
-    averaged_df = dense_df.rolling(window_size, center=True).mean()
-    # Skip the padding rows since they don't make much sense in the charts.
-    return averaged_df.iloc[pad_t:-pad_t]
+    ax.set_xlim(0, pd.Timedelta(days=1) // pd.Timedelta(minutes=1))
+    hours = [i for i in range(0, 25, 2)]
+    ax.set_xticks(
+        [i * 60 for i in hours], [str(i).rjust(2, "0") + ":00" for i in hours]
+    )
+    ax.set_yticks([])
+    ax.legend()
+    return ax
 
 
 def get_aggregated_event_counts(ts, events, period):

{dimwit-0.2.26 → dimwit-0.2.28}/dimwit/pomodoro.py

@@ -118,18 +118,6 @@ def generate_cumulative_df_for_kth_latest_week(df, 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)
 

{dimwit-0.2.26 → dimwit-0.2.28}/dimwit/sleep.py

@@ -101,9 +101,10 @@ def fill_sleep_entries(
 def create_sleep_df(ts, durations):
     starts, ends = zip(*ts)
 
-    # Cast the timezone to UTC, ensuring that UTC offsets are removed.
-    starts = [start.astimezone(dat.timezone.utc) for start in starts]
-    ends = [end.astimezone(dat.timezone.utc) for end in ends]
+    # Replace the timezone with UTC, ensuring that UTC offsets are removed.
+    # TODO: For some reason this breaks older data until around mid-Nov 2023.
+    starts = [start.replace(tzinfo=dat.timezone.utc) for start in starts]
+    ends = [end.replace(tzinfo=dat.timezone.utc) for end in ends]
 
     start_dates = get_start_date(starts, ends, first_after_midnight=False)
     end_dates = start_dates.shift(1, freq="D")

{dimwit-0.2.26 → dimwit-0.2.28}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "dimwit"
-version = "0.2.26"
+version = "0.2.28"
 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"