parcae 0.1.1__py3-none-any.whl → 0.2.0__py3-none-any.whl

parcae/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.1.1"
+__version__ = "0.2.0"
 
 from .api import Parcae
 

parcae/api.py

@@ -51,6 +51,22 @@ def _viterbi(obs, log_trans, log_emit, log_init):
     return path, best
 
 
+def _parse_timestamps(timestamps):
+    out = []
+    for t in timestamps:
+        if isinstance(t, datetime):
+            out.append(t)
+        else:
+            out.append(datetime.fromisoformat(str(t)))
+    return sorted(out)
+
+
+def _downsample(x, k):
+    n = len(x)
+    idx = np.linspace(0, n, k + 1, dtype=int)
+    return np.array([x[idx[i] : idx[i + 1]].mean() for i in range(k)], dtype=np.float32)
+
+
 class Parcae:
     def __init__(self, model_path=None, bin_minutes=15):
         if model_path is None:
@@ -72,15 +88,6 @@ class Parcae:
         self.sleep_state = int(np.argmin(self.emissionprob[:, 1]))
         self.awake_state = 1 - self.sleep_state
 
-    def _parse_timestamps(self, timestamps):
-        out = []
-        for t in timestamps:
-            if isinstance(t, datetime):
-                out.append(t)
-            else:
-                out.append(datetime.fromisoformat(str(t)))
-        return sorted(out)
-
     def _bin(self, timestamps):
         start = timestamps[0].replace(hour=0, minute=0, second=0, microsecond=0)
         end = timestamps[-1].replace(
@@ -100,7 +107,7 @@ class Parcae:
         return start, bins
 
     def analyze(self, timestamps, tz_range=range(-12, 13)):
-        ts = self._parse_timestamps(timestamps)
+        ts = _parse_timestamps(timestamps)
 
         span = ts[-1] - ts[0]
         if span < timedelta(days=2):  # arbitrary number that seems fine
@@ -134,6 +141,13 @@ class Parcae:
         shift_bins = int(best_phi * bins_per_day / 24)
         best_bins = np.roll(bins, shift_bins)
 
+        days = len(best_bins) // bins_per_day
+        day_matrix = best_bins[: days * bins_per_day].reshape(days, bins_per_day)
+
+        profile = day_matrix.mean(axis=0)
+        profile = profile / (profile.sum() + 1e-8)
+        profile_24h = _downsample(profile, 24)
+
         states, _ = _viterbi(
             best_bins, self.log_transmat, self.log_emissionprob, self.log_startprob
         )
@@ -158,6 +172,29 @@ class Parcae:
         else:
             awake_blocks.append((block_start, len(states)))
 
+        sleep_durations = [(b - a) * self.bin_minutes for a, b in sleep_blocks]
+
+        if sleep_durations:
+            dur = np.array(sleep_durations, dtype=np.float32)
+            sleep_stats = np.array([dur.mean(), dur.std(), np.median(dur)]) / 1440.0
+        else:
+            sleep_stats = np.zeros(3, dtype=np.float32)
+
+        if sleep_blocks:
+            starts = np.array([a for a, _ in sleep_blocks]) * self.bin_minutes
+            ends = np.array([b for _, b in sleep_blocks]) * self.bin_minutes
+
+            start_m = starts.mean()
+            end_m = ends.mean()
+
+            def circ(m):
+                ang = 2 * np.pi * m / 1440.0
+                return np.sin(ang), np.cos(ang)
+
+            sleep_phase = np.array([*circ(start_m), *circ(end_m)], dtype=np.float32)
+        else:
+            sleep_phase = np.zeros(4, dtype=np.float32)
+
         def blocks_to_time(blocks):
             out = []
             for a, b in blocks:
@@ -170,4 +207,8 @@ class Parcae:
             "timezone_offset_hours": int(best_phi),
             "sleep_blocks": blocks_to_time(sleep_blocks),
             "awake_blocks": blocks_to_time(awake_blocks),
+            "profile_24h": profile_24h,
+            "sleep_phase": sleep_phase,
+            "sleep_stats": sleep_stats.astype(np.float32),
+            "days": int(days),
         }

parcae/cli.py

@@ -1,8 +1,9 @@
 import argparse
+import base64
 import csv
 import math
-from collections import defaultdict
-from datetime import datetime, timedelta
+
+import numpy as np
 
 from parcae import Parcae
 
@@ -31,82 +32,137 @@ def format_hm(minutes):
     return f"{h:02d}:{m:02d}"
 
 
-def circular_mean_minutes(values):
-    angles = [2 * math.pi * v / 1440.0 for v in values]
+def angle_to_minutes(sin_v, cos_v):
+    ang = math.atan2(sin_v, cos_v)
+    if ang < 0:
+        ang += 2 * math.pi
+    return int(round(ang * 1440 / (2 * math.pi)))
+
+
+def decode_fp(s):
+    s = s.split(":", 2)[2]
+    raw = base64.urlsafe_b64decode(s)
+    q = np.frombuffer(raw, dtype=np.int16)
+    return q.astype(np.float32) / 4096.0
+
+
+def cosine(a, b):
+    return float(np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b)))
+
+
+def sparkline(x):
+    ticks = "▁▂▃▄▅▆▇█"
+    x = np.asarray(x, dtype=float)
 
-    x = sum(math.cos(a) for a in angles)
-    y = sum(math.sin(a) for a in angles)
+    lo = x.min()
+    hi = x.max()
 
-    if x == 0 and y == 0:
-        return int(values[0])
+    if hi == lo:
+        return ticks[0] * len(x)
 
-    mean_angle = math.atan2(y, x)
-    if mean_angle < 0:
-        mean_angle += 2 * math.pi
+    scaled = (x - lo) / (hi - lo) * (len(ticks) - 1)
+    idx = np.round(scaled).astype(int)
 
-    mean_minutes = int(round(mean_angle * 1440.0 / (2 * math.pi)))
-    return mean_minutes % 1440
+    return "".join(ticks[i] for i in idx)
+
+
+def hour_axis(n=24, marks=(0, 6, 12, 18, 24)):
+    row = [" "] * n
+    for m in marks:
+        if m < n:
+            row[m] = "|"
+    return "".join(row)
+
+
+def hour_labels(n=24, marks=(0, 6, 12, 18, 24)):
+    row = [" "] * n
+    for m in marks:
+        s = f"{m:02d}"
+        if m < n:
+            for i, c in enumerate(s):
+                if m + i < n:
+                    row[m + i] = c
+    return "".join(row)
 
 
 def main():
     parser = argparse.ArgumentParser(prog="parcae")
-    parser.add_argument("csv", help="CSV file with a 'timestamp' column")
-    parser.add_argument("-v", "--version", action="version", version="%(prog)s 0.1.1")
+    sub = parser.add_subparsers(dest="cmd")
+
+    p_analyze = sub.add_parser("analyze")
+    p_analyze.add_argument("csv", help="CSV file with a 'timestamp' column")
+
+    p_cmp = sub.add_parser("compare")
+    p_cmp.add_argument("fp1")
+    p_cmp.add_argument("fp2")
+
+    parser.add_argument("-v", "--version", action="version", version="%(prog)s 0.2.0")
+
     args = parser.parse_args()
 
     print("+ Parcae analysis\n")
 
+    if args.cmd == "compare":
+        v1 = decode_fp(args.fp1)
+        v2 = decode_fp(args.fp2)
+        sim = cosine(v1, v2)
+
+        print("+ fingerprint comparison:")
+        print(f"\tcosine similarity: {sim:.4f}")
+
+        if sim > 0.95:
+            print("\tmatch: very likely same user")
+        elif sim > 0.90:
+            print("\tmatch: probable")
+        else:
+            print("\tmatch: unlikely")
+
+        return
+
     timestamps = parse_csv(args.csv)
 
     p = Parcae()
     result = p.analyze(timestamps)
 
     tz = result["timezone_offset_hours"]
-    sleep_blocks = result["sleep_blocks"]
+    days = result["days"]
 
     print(f"~ inferred timezone: UTC{tz:+d}\n")
 
-    offset = timedelta(hours=tz)
-
-    local_blocks = []
-    for b in sleep_blocks:
-        start = datetime.fromisoformat(b["start"]) + offset
-        end = datetime.fromisoformat(b["end"]) + offset
-        local_blocks.append((start, end))
-
-    by_day = defaultdict(list)
+    sleep_phase = result["sleep_phase"]
+    sleep_stats = result["sleep_stats"]
 
-    for start, end in local_blocks:
-        day = start.date()
-        dur = (end - start).total_seconds()
-        by_day[day].append((dur, start, end))
+    profile_24h = result["profile_24h"]
 
-    main_sleeps = []
-    for day, blocks in by_day.items():
-        blocks.sort(reverse=True)
-        _, start, end = blocks[0]
-        main_sleeps.append((start, end))
+    mean_start = angle_to_minutes(sleep_phase[0], sleep_phase[1])
+    mean_end = angle_to_minutes(sleep_phase[2], sleep_phase[3])
 
-    if not main_sleeps:
-        print("! no sleep blocks detected")
-        return
+    std_dur = int(round(sleep_stats[1] * 1440))
+    med_dur = int(round(sleep_stats[2] * 1440))
 
-    sleep_starts = [minutes_since_midnight(s) for s, e in main_sleeps]
-    sleep_ends = [minutes_since_midnight(e) for s, e in main_sleeps]
-    durations = [int((e - s).total_seconds() / 60) for s, e in main_sleeps]
+    vec = np.concatenate(
+        [profile_24h, result["sleep_phase"], result["sleep_stats"]]
+    ).astype(np.float32)
 
-    mean_start = circular_mean_minutes(sleep_starts)
-    mean_end = circular_mean_minutes(sleep_ends)
-    durations.sort()
-    med_dur = durations[len(durations) // 2]
+    q = np.round(vec * 4096).astype(np.int16)
+    fp = base64.urlsafe_b64encode(q.tobytes()).decode()
 
     print("+ typical schedule:")
     print(
         f"\t- sleep: {format_hm(mean_start)} -> {format_hm(mean_end)}  (≈ {med_dur // 60}h {med_dur % 60:02d}m)"
     )
-    print(f"\t- awake: {format_hm(mean_end)} -> {format_hm(mean_start)}\n")
+    print(f"\t- awake: {format_hm(mean_end)} -> {format_hm(mean_start)}")
+    print(f"\t- variability: ±{std_dur}m\n")
+
+    print("+ activity profile (24h):")
+    print(f"\t{sparkline(profile_24h)}")
+    print(f"\t{hour_axis(len(profile_24h))}")
+    print(f"\t{hour_labels(len(profile_24h))}\n")
+
+    print("+ fingerprint:")
+    print(f"\tparcae:v1:{fp}\n")
 
-    print(f"~ based on {len(main_sleeps)} days of data")
+    print(f"~ based on {days} days of data")
     print(f"~ bin size: {p.bin_minutes} minutes")
 
 

{parcae-0.1.1.dist-info → parcae-0.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: parcae
-Version: 0.1.1
+Version: 0.2.0
 Summary: Infer daily rhythm and sleep schedule from message timestamps
 Project-URL: Homepage, https://github.com/jeremyctrl/parcae
 Project-URL: Repository, https://github.com/jeremyctrl/parcae
@@ -102,8 +102,17 @@ parcae user_timestamps.csv
 ~ inferred timezone: UTC+3
 
 + typical schedule:
-        - sleep: 02:46 -> 11:38  (≈ 8h 45m)
-        - awake: 11:38 -> 02:46
+        - sleep: 23:52 -> 06:34  (≈ 8h 30m)
+        - awake: 06:34 -> 23:52
+        - variability: ±175m
+
++ activity profile (24h):
+        ▁▁▁▁▁▁▁▁▅▇▅█▆▁▅▄▅▆▁▇▇▆▆▇
+        |     |     |     |     
+        00    06    12    18    
+
++ fingerprint:
+        parcae:v1:AAAAAAAAAAAAAAAAAAAAAD0AWQA6AGMAQQAAADoAMAA6AEcAAABWAFUATgBMAFsAd__-D9QPqP12BPEBqwU=
 
 ~ based on 30 days of data
 ~ bin size: 15 minutes

parcae-0.2.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+parcae/__init__.py,sha256=RWBvxIWTjlhW31HwPJFBhJtCByRYynX-H__Cuz5H_yU,69
+parcae/api.py,sha256=8wXm2VqMxu4UqjmeN63I37_43XQsapbpuJr8KccKwM0,6558
+parcae/cli.py,sha256=VUSOUOuCvA261jBKRg7wGftUCogvGrHhtZG5l0tStNA,4186
+parcae-0.2.0.data/data/models/hmm.npz,sha256=EQ-azTtEJ9ZkAWldyjp3pe-kd9W0gdesGSv05LPLyrg,1118
+parcae-0.2.0.dist-info/licenses/LICENSE,sha256=lkt0mQbom19fj92XgwyoYS3T2ES7S6F4aqV2-53AksA,1075
+parcae-0.2.0.dist-info/METADATA,sha256=0N6BXvzOqIYAD9XeU1FUw-hgF9yLD5SbU0rciTtd0lE,3162
+parcae-0.2.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+parcae-0.2.0.dist-info/entry_points.txt,sha256=okhIV74Y1DqE8UGhVycpEU2NTwq3ReBkaoxfm7BBsrI,43
+parcae-0.2.0.dist-info/top_level.txt,sha256=S_O9fdoifLS3yrrHeidB6sQ61r8l6KBvSHZ0arhaGoE,7
+parcae-0.2.0.dist-info/RECORD,,

parcae-0.1.1.dist-info/RECORD

@@ -1,10 +0,0 @@
-parcae/__init__.py,sha256=kaQjVqPuTAVsSpYJazu-jx-zKLSXqsmOgjtB0iadAWY,69
-parcae/api.py,sha256=O-JZw_HvZzC2yXSZGDgLMntwqnxaJs8edxEuTpAWCIw,5132
-parcae/cli.py,sha256=NVpDsp-yMvgoeoTbyJjVpqK-iCc-Mcz7pzjCinbXg40,3115
-parcae-0.1.1.data/data/models/hmm.npz,sha256=EQ-azTtEJ9ZkAWldyjp3pe-kd9W0gdesGSv05LPLyrg,1118
-parcae-0.1.1.dist-info/licenses/LICENSE,sha256=lkt0mQbom19fj92XgwyoYS3T2ES7S6F4aqV2-53AksA,1075
-parcae-0.1.1.dist-info/METADATA,sha256=h6-wrFE0A_jk2TBnTwmqtfOxNpKcer4oC7sm4x83aUY,2839
-parcae-0.1.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-parcae-0.1.1.dist-info/entry_points.txt,sha256=okhIV74Y1DqE8UGhVycpEU2NTwq3ReBkaoxfm7BBsrI,43
-parcae-0.1.1.dist-info/top_level.txt,sha256=S_O9fdoifLS3yrrHeidB6sQ61r8l6KBvSHZ0arhaGoE,7
-parcae-0.1.1.dist-info/RECORD,,