parcae 0.1.1__tar.gz → 0.2.0__tar.gz

{parcae-0.1.1/parcae.egg-info → parcae-0.2.0}/PKG-INFO

@@ -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.1.1 → parcae-0.2.0}/README.md

@@ -85,8 +85,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.1.1 → parcae-0.2.0}/parcae/__init__.py

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

{parcae-0.1.1 → parcae-0.2.0}/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-0.2.0/parcae/cli.py

@@ -0,0 +1,170 @@
+import argparse
+import base64
+import csv
+import math
+
+import numpy as np
+
+from parcae import Parcae
+
+
+def parse_csv(path):
+    timestamps = []
+    with open(path, "r", encoding="utf-8") as f:
+        reader = csv.DictReader(f)
+        fieldnames = reader.fieldnames
+        if fieldnames is None or "timestamp" not in fieldnames:
+            raise ValueError("! CSV must have a 'timestamp' column")
+
+        for row in reader:
+            timestamps.append(row["timestamp"])
+
+    return timestamps
+
+
+def minutes_since_midnight(dt):
+    return dt.hour * 60 + dt.minute
+
+
+def format_hm(minutes):
+    h = (minutes // 60) % 24
+    m = minutes % 60
+    return f"{h:02d}:{m:02d}"
+
+
+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)
+
+    lo = x.min()
+    hi = x.max()
+
+    if hi == lo:
+        return ticks[0] * len(x)
+
+    scaled = (x - lo) / (hi - lo) * (len(ticks) - 1)
+    idx = np.round(scaled).astype(int)
+
+    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")
+    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"]
+    days = result["days"]
+
+    print(f"~ inferred timezone: UTC{tz:+d}\n")
+
+    sleep_phase = result["sleep_phase"]
+    sleep_stats = result["sleep_stats"]
+
+    profile_24h = result["profile_24h"]
+
+    mean_start = angle_to_minutes(sleep_phase[0], sleep_phase[1])
+    mean_end = angle_to_minutes(sleep_phase[2], sleep_phase[3])
+
+    std_dur = int(round(sleep_stats[1] * 1440))
+    med_dur = int(round(sleep_stats[2] * 1440))
+
+    vec = np.concatenate(
+        [profile_24h, result["sleep_phase"], result["sleep_stats"]]
+    ).astype(np.float32)
+
+    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)}")
+    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 {days} days of data")
+    print(f"~ bin size: {p.bin_minutes} minutes")
+
+
+if __name__ == "__main__":
+    main()

{parcae-0.1.1 → parcae-0.2.0/parcae.egg-info}/PKG-INFO

@@ -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.1.1 → parcae-0.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "parcae"
-version = "0.1.1"
+version = "0.2.0"
 description = "Infer daily rhythm and sleep schedule from message timestamps"
 readme = "README.md"
 requires-python = ">=3.13"

parcae-0.1.1/parcae/cli.py

@@ -1,114 +0,0 @@
-import argparse
-import csv
-import math
-from collections import defaultdict
-from datetime import datetime, timedelta
-
-from parcae import Parcae
-
-
-def parse_csv(path):
-    timestamps = []
-    with open(path, "r", encoding="utf-8") as f:
-        reader = csv.DictReader(f)
-        fieldnames = reader.fieldnames
-        if fieldnames is None or "timestamp" not in fieldnames:
-            raise ValueError("! CSV must have a 'timestamp' column")
-
-        for row in reader:
-            timestamps.append(row["timestamp"])
-
-    return timestamps
-
-
-def minutes_since_midnight(dt):
-    return dt.hour * 60 + dt.minute
-
-
-def format_hm(minutes):
-    h = (minutes // 60) % 24
-    m = minutes % 60
-    return f"{h:02d}:{m:02d}"
-
-
-def circular_mean_minutes(values):
-    angles = [2 * math.pi * v / 1440.0 for v in values]
-
-    x = sum(math.cos(a) for a in angles)
-    y = sum(math.sin(a) for a in angles)
-
-    if x == 0 and y == 0:
-        return int(values[0])
-
-    mean_angle = math.atan2(y, x)
-    if mean_angle < 0:
-        mean_angle += 2 * math.pi
-
-    mean_minutes = int(round(mean_angle * 1440.0 / (2 * math.pi)))
-    return mean_minutes % 1440
-
-
-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")
-    args = parser.parse_args()
-
-    print("+ Parcae analysis\n")
-
-    timestamps = parse_csv(args.csv)
-
-    p = Parcae()
-    result = p.analyze(timestamps)
-
-    tz = result["timezone_offset_hours"]
-    sleep_blocks = result["sleep_blocks"]
-
-    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)
-
-    for start, end in local_blocks:
-        day = start.date()
-        dur = (end - start).total_seconds()
-        by_day[day].append((dur, start, end))
-
-    main_sleeps = []
-    for day, blocks in by_day.items():
-        blocks.sort(reverse=True)
-        _, start, end = blocks[0]
-        main_sleeps.append((start, end))
-
-    if not main_sleeps:
-        print("! no sleep blocks detected")
-        return
-
-    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]
-
-    mean_start = circular_mean_minutes(sleep_starts)
-    mean_end = circular_mean_minutes(sleep_ends)
-    durations.sort()
-    med_dur = durations[len(durations) // 2]
-
-    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"~ based on {len(main_sleeps)} days of data")
-    print(f"~ bin size: {p.bin_minutes} minutes")
-
-
-if __name__ == "__main__":
-    main()