chrome-time-clock 0.1.0__py3-none-any.whl

chrome_time_clock/__init__.py

@@ -0,0 +1,17 @@
+"""
+Chrome Time Clock
+
+Infer approximate workday start/end from Chrome browser history and plot/merge work hours.
+"""
+
+from chrome_time_clock.extractor import extract_workhours
+from chrome_time_clock.merger import merge_blocks
+from chrome_time_clock.plotter import plot_workhours
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "extract_workhours",
+    "plot_workhours",
+    "merge_blocks",
+]

chrome_time_clock/cli.py

@@ -0,0 +1,228 @@
+"""Unified command-line interface for chrome-time-clock."""
+
+import argparse
+import sys
+from datetime import datetime
+from pathlib import Path
+
+from chrome_time_clock.extractor import DEFAULT_GAP_MINUTES, DEFAULT_OUT_DIR, DEFAULT_PROFILE, DEFAULT_TIMEZONE, extract_workhours, write_csv, write_markdown
+from chrome_time_clock.merger import merge_blocks
+from chrome_time_clock.plotter import plot_workhours
+
+
+def main() -> None:
+    """Main entry point for the unified chrome-time-clock CLI."""
+    parser = argparse.ArgumentParser(
+        prog="chrome-time-clock",
+        description="Chrome Time Clock: Infer, plot, and merge work hours from browser history.",
+    )
+    
+    subparsers = parser.add_subparsers(dest="command", required=True, title="subcommands")
+
+    # ── Extract Subcommand ────────────────────────────────────────────────────
+    extract_parser = subparsers.add_parser(
+        "extract",
+        help="Infer workday start/end from browser history",
+        description="Infer workday start/end from Chrome/Chromium/Brave browser history.",
+    )
+    extract_parser.add_argument(
+        "--profile",
+        default=DEFAULT_PROFILE,
+        help=f"Browser profile name (default: {DEFAULT_PROFILE})",
+    )
+    extract_parser.add_argument(
+        "--browser",
+        default="chrome",
+        choices=["chrome", "chromium", "brave"],
+        help="Browser type (default: chrome)",
+    )
+    extract_parser.add_argument(
+        "--history-db",
+        default=None,
+        help="Direct path to History SQLite file (overrides browser/profile resolution)",
+    )
+    extract_parser.add_argument(
+        "--from",
+        dest="date_from",
+        default=None,
+        help="Start date YYYY-MM-DD (inclusive)",
+    )
+    extract_parser.add_argument(
+        "--to",
+        dest="date_to",
+        default=None,
+        help="End date YYYY-MM-DD (inclusive)",
+    )
+    extract_parser.add_argument(
+        "--timezone",
+        default=DEFAULT_TIMEZONE,
+        help=f"IANA timezone (default: {DEFAULT_TIMEZONE})",
+    )
+    extract_parser.add_argument(
+        "--gap-minutes",
+        type=int,
+        default=DEFAULT_GAP_MINUTES,
+        help=f"Inactivity gap threshold in minutes (default: {DEFAULT_GAP_MINUTES})",
+    )
+    extract_parser.add_argument(
+        "--out",
+        default=DEFAULT_OUT_DIR,
+        help=f"Output directory (default: {DEFAULT_OUT_DIR})",
+    )
+    extract_parser.add_argument(
+        "--markdown",
+        action="store_true",
+        help="Also write daily_summary.md inside the output directory",
+    )
+
+    # ── Plot Subcommand ───────────────────────────────────────────────────────
+    plot_parser = subparsers.add_parser(
+        "plot",
+        help="Work-hour timelines and histograms",
+        description="Generate work-hour timelines and histograms in dark Soilytix style.",
+    )
+    plot_parser.add_argument(
+        "csv",
+        help="Path to the daily summary CSV file",
+    )
+    plot_parser.add_argument(
+        "--from",
+        dest="date_from",
+        default="2026-02-22",
+        help="Start date YYYY-MM-DD (inclusive) (default: 2026-02-22)",
+    )
+    plot_parser.add_argument(
+        "--to",
+        dest="date_to",
+        default=None,
+        help="End date YYYY-MM-DD (inclusive)",
+    )
+    plot_parser.add_argument(
+        "--bins",
+        type=int,
+        default=15,
+        help="Number of bins for histograms (default: 15)",
+    )
+    plot_parser.add_argument(
+        "--out",
+        default="workhours_plot",
+        help="Output file stem — .png and .pdf are appended (default: workhours_plot)",
+    )
+    plot_parser.add_argument(
+        "--show",
+        action="store_true",
+        help="Display the plot window",
+    )
+
+    # ── Merge Subcommand ──────────────────────────────────────────────────────
+    merge_parser = subparsers.add_parser(
+        "merge",
+        help="Merge blocks.csv files",
+        description="Merge multiple blocks.csv files, collapsing overlapping time intervals.",
+    )
+    merge_parser.add_argument(
+        "files",
+        nargs="+",
+        help="List of blocks.csv files to merge",
+    )
+    merge_parser.add_argument(
+        "--out-blocks",
+        default="merged_blocks.csv",
+        help="Output filename for merged blocks (default: merged_blocks.csv)",
+    )
+    merge_parser.add_argument(
+        "--out-daily",
+        default="merged_daily.csv",
+        help="Output filename for derived daily summary (default: merged_daily.csv)",
+    )
+
+    # Parse arguments
+    args = parser.parse_args()
+
+    try:
+        if args.command == "extract":
+            date_from = (
+                datetime.strptime(args.date_from, "%Y-%m-%d").date() if args.date_from else None
+            )
+            date_to = (
+                datetime.strptime(args.date_to, "%Y-%m-%d").date() if args.date_to else None
+            )
+
+            daily_rows, block_rows, warnings = extract_workhours(
+                browser=args.browser,
+                profile=args.profile,
+                history_db=args.history_db,
+                date_from=date_from,
+                date_to=date_to,
+                timezone_str=args.timezone,
+                gap_minutes=args.gap_minutes,
+            )
+
+            if not daily_rows:
+                print("No visits found after filtering. Nothing to do.")
+                return
+
+            print(f"Days summarised: {len(daily_rows)}")
+            for w in warnings:
+                print(f"  {w}")
+
+            out_dir = Path(args.out)
+            out_dir.mkdir(parents=True, exist_ok=True)
+
+            daily_path = out_dir / "daily_summary.csv"
+            blocks_path = out_dir / "blocks.csv"
+
+            write_csv(
+                daily_rows,
+                daily_path,
+                ["date", "first_seen", "last_seen", "gross_span_hours", "active_block_hours", "n_blocks", "n_visits"],
+            )
+            write_csv(
+                block_rows,
+                blocks_path,
+                ["date", "block_start", "block_end", "duration_hours", "n_visits"],
+            )
+
+            if args.markdown:
+                md_path = out_dir / "daily_summary.md"
+                write_markdown(daily_rows, md_path)
+                print(f"Markdown written to:  {md_path}")
+
+            print(f"Output written to: {out_dir.resolve()}")
+            print(f"  {daily_path.name}: {len(daily_rows)} days")
+            print(f"  {blocks_path.name}: {len(block_rows)} blocks")
+
+        elif args.command == "plot":
+            date_from = (
+                datetime.strptime(args.date_from, "%Y-%m-%d").date() if args.date_from else None
+            )
+            date_to = (
+                datetime.strptime(args.date_to, "%Y-%m-%d").date() if args.date_to else None
+            )
+
+            plot_workhours(
+                csv_path=args.csv,
+                date_from=date_from,
+                date_to=date_to,
+                bins=args.bins,
+                out_stem=args.out,
+                show=args.show,
+            )
+
+        elif args.command == "merge":
+            merge_blocks(
+                files=args.files,
+                out_blocks=args.out_blocks,
+                out_daily=args.out_daily,
+            )
+            print(f"Successfully merged {len(args.files)} file(s).")
+            print(f"Written: {args.out_blocks}")
+            print(f"Written: {args.out_daily}")
+
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

chrome_time_clock/extractor.py

@@ -0,0 +1,379 @@
+"""Infer approximate workday start/end from Chrome browser history."""
+
+import argparse
+import csv
+import os
+import shutil
+import sqlite3
+import sys
+import tempfile
+from datetime import date, datetime, timedelta, timezone
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple, Union
+from zoneinfo import ZoneInfo
+
+# Chrome/WebKit epoch: microseconds since 1601-01-01 00:00 UTC
+CHROME_EPOCH = datetime(1601, 1, 1, tzinfo=timezone.utc)
+
+INTERNAL_SCHEMES = ("chrome://", "chrome-extension://", "about:", "file://")
+
+DEFAULT_TIMEZONE = "Europe/Amsterdam"
+DEFAULT_GAP_MINUTES = 60
+DEFAULT_PROFILE = "Default"
+DEFAULT_OUT_DIR = "./chrome_workhours_export"
+
+WARN_MIN_VISITS_PER_DAY = 5
+WARN_MAX_SPAN_HOURS = 16
+WARN_EARLIEST_HOUR = 5
+WARN_LATEST_HOUR_MINUTE = (23, 30)
+
+
+def resolve_history_path(browser: str, profile: str, history_db: Optional[Union[str, Path]]) -> Path:
+    """Resolve the path to the browser history database based on OS and browser."""
+    if history_db:
+        return Path(history_db).expanduser()
+
+    home = Path.home()
+    browser_lower = browser.lower()
+
+    if sys.platform == "darwin":  # macOS
+        roots = {
+            "chrome": home / "Library/Application Support/Google/Chrome",
+            "chromium": home / "Library/Application Support/Chromium",
+            "brave": home / "Library/Application Support/BraveSoftware/Brave-Browser",
+        }
+    elif sys.platform == "win32":  # Windows
+        local_app_data = Path(os.environ.get("LOCALAPPDATA", home / "AppData/Local"))
+        roots = {
+            "chrome": local_app_data / "Google/Chrome/User Data",
+            "chromium": local_app_data / "Chromium/User Data",
+            "brave": local_app_data / "BraveSoftware/Brave-Browser/User Data",
+        }
+    else:  # Linux / other Unix
+        roots = {
+            "chrome": home / ".config/google-chrome",
+            "chromium": home / ".config/chromium",
+            "brave": home / ".config/BraveSoftware/Brave-Browser",
+        }
+
+    root = roots.get(browser_lower)
+    if root is None:
+        raise ValueError(
+            f"Unknown browser '{browser}' on platform '{sys.platform}'. "
+            f"Supported browsers: chrome, chromium, brave. Or use --history-db for a custom path."
+        )
+    return root / profile / "History"
+
+
+def copy_history_db(src: Path) -> Path:
+    """Copy the history database to a temporary location to avoid locking issues."""
+    if not src.exists():
+        raise FileNotFoundError(f"History DB not found: {src}")
+    tmp_dir = Path(tempfile.mkdtemp())
+    tmp_file = tmp_dir / "History"
+    shutil.copy2(src, tmp_file)
+    return tmp_file
+
+
+def read_visits(db_path: Path) -> List[Dict[str, Any]]:
+    """Read visit records from the SQLite history database."""
+    # Use read-only mode to prevent database modification
+    con = sqlite3.connect(f"file:{db_path}?mode=ro", uri=True)
+    try:
+        cur = con.execute(
+            """
+            SELECT
+                visits.id        AS visit_id,
+                visits.visit_time,
+                urls.url,
+                urls.title
+            FROM visits
+            JOIN urls ON urls.id = visits.url
+            WHERE visits.visit_time > 0
+            ORDER BY visits.visit_time ASC
+            """
+        )
+        rows = [
+            {"visit_id": r[0], "visit_time": r[1], "url": r[2], "title": r[3] or ""}
+            for r in cur.fetchall()
+        ]
+    finally:
+        con.close()
+    return rows
+
+
+def chrome_time_to_datetime(value: int) -> datetime:
+    """Convert Chrome WebKit microsecond timestamp to timezone-aware datetime."""
+    return CHROME_EPOCH + timedelta(microseconds=value)
+
+
+def convert_times(visits: List[Dict[str, Any]], tz: ZoneInfo) -> List[Dict[str, Any]]:
+    """Convert raw timestamps to local datetimes and dates."""
+    out = []
+    for v in visits:
+        dt_utc = chrome_time_to_datetime(v["visit_time"])
+        dt_local = dt_utc.astimezone(tz)
+        out.append({**v, "timestamp_local": dt_local, "date_local": dt_local.date()})
+    return out
+
+
+def filter_visits(
+    visits: List[Dict[str, Any]],
+    ignore_schemes: Tuple[str, ...] = INTERNAL_SCHEMES,
+    date_from: Optional[date] = None,
+    date_to: Optional[date] = None,
+) -> List[Dict[str, Any]]:
+    """Filter out internal browser schemes and restrict to date range."""
+    out = []
+    for v in visits:
+        url = v["url"]
+        if any(url.startswith(s) for s in ignore_schemes):
+            continue
+        d = v["date_local"]
+        if date_from and d < date_from:
+            continue
+        if date_to and d > date_to:
+            continue
+        out.append(v)
+    return out
+
+
+def compute_blocks(day_visits: List[Dict[str, Any]], gap_minutes: int) -> List[Dict[str, Any]]:
+    """Cluster visits into active blocks separated by inactivity gaps."""
+    if not day_visits:
+        return []
+    threshold = timedelta(minutes=gap_minutes)
+    blocks = []
+    block_start = day_visits[0]["timestamp_local"]
+    block_end = day_visits[0]["timestamp_local"]
+    block_count = 1
+
+    for v in day_visits[1:]:
+        ts = v["timestamp_local"]
+        if ts - block_end <= threshold:
+            block_end = ts
+            block_count += 1
+        else:
+            blocks.append({"start": block_start, "end": block_end, "n_visits": block_count})
+            block_start = ts
+            block_end = ts
+            block_count = 1
+
+    blocks.append({"start": block_start, "end": block_end, "n_visits": block_count})
+    return blocks
+
+
+def group_daily(
+    visits: List[Dict[str, Any]], gap_minutes: int
+) -> Tuple[List[Dict[str, Any]], List[Dict[str, Any]]]:
+    """Group visits by day and compute daily summaries and block intervals."""
+    by_day: Dict[date, List[Dict[str, Any]]] = {}
+    for v in visits:
+        by_day.setdefault(v["date_local"], []).append(v)
+
+    daily_rows = []
+    block_rows = []
+
+    for d in sorted(by_day):
+        day_visits = sorted(by_day[d], key=lambda x: x["timestamp_local"])
+        blocks = compute_blocks(day_visits, gap_minutes)
+
+        first_seen = day_visits[0]["timestamp_local"]
+        last_seen = day_visits[-1]["timestamp_local"]
+        gross_span = (last_seen - first_seen).total_seconds() / 3600
+
+        active_secs = sum(
+            (b["end"] - b["start"]).total_seconds() for b in blocks
+        )
+        active_hours = active_secs / 3600
+
+        daily_rows.append(
+            {
+                "date": d.isoformat(),
+                "first_seen": first_seen.strftime("%H:%M"),
+                "last_seen": last_seen.strftime("%H:%M"),
+                "gross_span_hours": round(gross_span, 2),
+                "active_block_hours": round(active_hours, 2),
+                "n_blocks": len(blocks),
+                "n_visits": len(day_visits),
+                "_first_dt": first_seen,
+                "_last_dt": last_seen,
+            }
+        )
+
+        for b in blocks:
+            dur = (b["end"] - b["start"]).total_seconds() / 3600
+            block_rows.append(
+                {
+                    "date": d.isoformat(),
+                    "block_start": b["start"].strftime("%H:%M"),
+                    "block_end": b["end"].strftime("%H:%M"),
+                    "duration_hours": round(dur, 2),
+                    "n_visits": b["n_visits"],
+                }
+            )
+
+    return daily_rows, block_rows
+
+
+def write_csv(rows: List[Dict[str, Any]], path: Path, fieldnames: List[str]) -> None:
+    """Write rows to a CSV file."""
+    with open(path, "w", newline="", encoding="utf-8") as f:
+        writer = csv.DictWriter(f, fieldnames=fieldnames, extrasaction="ignore")
+        writer.writeheader()
+        writer.writerows(rows)
+
+
+def write_markdown(daily_rows: List[Dict[str, Any]], path: Path) -> None:
+    """Write daily summaries to a Markdown table file."""
+    lines = [
+        "# Chrome Work Hours Summary",
+        "",
+        f"Generated: {datetime.now().strftime('%Y-%m-%d %H:%M')}",
+        "",
+        "| Date | First | Last | Gross h | Active h | Blocks | Visits |",
+        "|------|-------|------|---------|----------|--------|--------|",
+    ]
+    for r in daily_rows:
+        lines.append(
+            f"| {r['date']} | {r['first_seen']} | {r['last_seen']} "
+            f"| {r['gross_span_hours']:.2f} | {r['active_block_hours']:.2f} "
+            f"| {r['n_blocks']} | {r['n_visits']} |"
+        )
+    path.write_text("\n".join(lines) + "\n", encoding="utf-8")
+
+
+def emit_warnings(daily_rows: List[Dict[str, Any]]) -> List[str]:
+    """Check daily rows for potential anomalies and return a list of warning strings."""
+    warn_late_h, warn_late_m = WARN_LATEST_HOUR_MINUTE
+    warnings = []
+    for r in daily_rows:
+        d_str = r["date"]
+        if r["n_visits"] < WARN_MIN_VISITS_PER_DAY:
+            warnings.append(f"WARN {d_str}: only {r['n_visits']} visits (< {WARN_MIN_VISITS_PER_DAY})")
+        if r["gross_span_hours"] > WARN_MAX_SPAN_HOURS:
+            warnings.append(f"WARN {d_str}: gross span {r['gross_span_hours']:.1f} h > {WARN_MAX_SPAN_HOURS} h")
+        first_h = r["_first_dt"].hour
+        if first_h < WARN_EARLIEST_HOUR:
+            warnings.append(f"WARN {d_str}: first visit at {r['first_seen']} (before 0{WARN_EARLIEST_HOUR}:00)")
+        last_dt = r["_last_dt"]
+        if (last_dt.hour, last_dt.minute) > (warn_late_h, warn_late_m):
+            warnings.append(f"WARN {d_str}: last visit at {r['last_seen']} (after {warn_late_h}:{warn_late_m:02d})")
+    return warnings
+
+
+def extract_workhours(
+    browser: str = "chrome",
+    profile: str = DEFAULT_PROFILE,
+    history_db: Optional[Union[str, Path]] = None,
+    date_from: Optional[date] = None,
+    date_to: Optional[date] = None,
+    timezone_str: str = DEFAULT_TIMEZONE,
+    gap_minutes: int = DEFAULT_GAP_MINUTES,
+) -> Tuple[List[Dict[str, Any]], List[Dict[str, Any]], List[str]]:
+    """
+    Programmatic API to extract work hours from browser history.
+    
+    Returns:
+        Tuple of (daily_rows, block_rows, warnings)
+    """
+    tz = ZoneInfo(timezone_str)
+    src = resolve_history_path(browser, profile, history_db)
+    tmp_db = copy_history_db(src)
+
+    try:
+        raw = read_visits(tmp_db)
+        converted = convert_times(raw, tz)
+        filtered = filter_visits(converted, date_from=date_from, date_to=date_to)
+        
+        if not filtered:
+            return [], [], []
+
+        daily_rows, block_rows = group_daily(filtered, gap_minutes)
+        warnings = emit_warnings(daily_rows)
+        return daily_rows, block_rows, warnings
+    finally:
+        try:
+            shutil.rmtree(tmp_db.parent, ignore_errors=True)
+        except OSError:
+            pass
+
+
+def parse_args() -> argparse.Namespace:
+    p = argparse.ArgumentParser(
+        description="Infer workday start/end from Chrome browser history."
+    )
+    p.add_argument("--profile", default=DEFAULT_PROFILE, help="Chrome profile name (default: Default)")
+    p.add_argument("--browser", default="chrome", choices=["chrome", "chromium", "brave"])
+    p.add_argument("--history-db", default=None, help="Direct path to History SQLite file")
+    p.add_argument("--from", dest="date_from", default=None, help="Start date YYYY-MM-DD (inclusive)")
+    p.add_argument("--to", dest="date_to", default=None, help="End date YYYY-MM-DD (inclusive)")
+    p.add_argument("--timezone", default=DEFAULT_TIMEZONE, help="IANA timezone (default: Europe/Amsterdam)")
+    p.add_argument("--gap-minutes", type=int, default=DEFAULT_GAP_MINUTES, help="Inactivity gap threshold in minutes")
+    p.add_argument("--out", default=DEFAULT_OUT_DIR, help="Output directory")
+    p.add_argument("--markdown", action="store_true", help="Also write daily_summary.md")
+    return p.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+
+    date_from = (
+        datetime.strptime(args.date_from, "%Y-%m-%d").date() if args.date_from else None
+    )
+    date_to = (
+        datetime.strptime(args.date_to, "%Y-%m-%d").date() if args.date_to else None
+    )
+
+    try:
+        daily_rows, block_rows, warnings = extract_workhours(
+            browser=args.browser,
+            profile=args.profile,
+            history_db=args.history_db,
+            date_from=date_from,
+            date_to=date_to,
+            timezone_str=args.timezone,
+            gap_minutes=args.gap_minutes,
+        )
+        
+        if not daily_rows:
+            print("No visits found after filtering. Nothing to do.")
+            return
+
+        print(f"Days summarised: {len(daily_rows)}")
+        for w in warnings:
+            print(f"  {w}")
+
+        out_dir = Path(args.out)
+        out_dir.mkdir(parents=True, exist_ok=True)
+
+        daily_path = out_dir / "daily_summary.csv"
+        blocks_path = out_dir / "blocks.csv"
+
+        write_csv(
+            daily_rows,
+            daily_path,
+            ["date", "first_seen", "last_seen", "gross_span_hours", "active_block_hours", "n_blocks", "n_visits"],
+        )
+        write_csv(
+            block_rows,
+            blocks_path,
+            ["date", "block_start", "block_end", "duration_hours", "n_visits"],
+        )
+
+        if args.markdown:
+            md_path = out_dir / "daily_summary.md"
+            write_markdown(daily_rows, md_path)
+            print(f"Markdown written to:  {md_path}")
+
+        print(f"Output written to: {out_dir.resolve()}")
+        print(f"  {daily_path.name}: {len(daily_rows)} days")
+        print(f"  {blocks_path.name}: {len(block_rows)} blocks")
+
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

chrome_time_clock/merger.py

@@ -0,0 +1,147 @@
+"""Merge multiple blocks.csv files, collapsing overlapping intervals."""
+
+import argparse
+import csv
+import sys
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, List, Union
+
+
+def parse_dt(d: str, t: str) -> datetime:
+    """Parse date and time strings into a datetime object."""
+    return datetime.strptime(f"{d} {t}", "%Y-%m-%d %H:%M")
+
+
+def load_blocks(paths: List[Path]) -> List[Dict[str, Any]]:
+    """Load block records from a list of CSV files."""
+    rows = []
+    for p in paths:
+        with open(p, newline="", encoding="utf-8") as f:
+            for row in csv.DictReader(f):
+                rows.append({
+                    "date": row["date"],
+                    "start": parse_dt(row["date"], row["block_start"]),
+                    "end":   parse_dt(row["date"], row["block_end"]),
+                    "n_visits": int(row["n_visits"]),
+                })
+    return rows
+
+
+def merge_intervals(rows: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    """Sort and merge overlapping or adjacent block intervals."""
+    if not rows:
+        return []
+
+    rows.sort(key=lambda r: (r["date"], r["start"]))
+    merged = []
+    cur = dict(rows[0])
+
+    for r in rows[1:]:
+        # extend if overlapping or immediately adjacent (same minute)
+        if r["date"] == cur["date"] and r["start"] <= cur["end"]:
+            cur["end"] = max(cur["end"], r["end"])
+            cur["n_visits"] += r["n_visits"]
+        else:
+            merged.append(cur)
+            cur = dict(r)
+
+    merged.append(cur)
+    return merged
+
+
+def write_blocks(rows: List[Dict[str, Any]], path: Path) -> None:
+    """Write merged blocks to a CSV file."""
+    fieldnames = ["date", "block_start", "block_end", "duration_hours", "n_visits"]
+    with open(path, "w", newline="", encoding="utf-8") as f:
+        w = csv.DictWriter(f, fieldnames=fieldnames)
+        w.writeheader()
+        for r in rows:
+            dur = (r["end"] - r["start"]).total_seconds() / 3600
+            w.writerow({
+                "date": r["date"],
+                "block_start": r["start"].strftime("%H:%M"),
+                "block_end":   r["end"].strftime("%H:%M"),
+                "duration_hours": round(dur, 2),
+                "n_visits": r["n_visits"],
+            })
+
+
+def write_daily(rows: List[Dict[str, Any]], path: Path) -> None:
+    """Derive and write daily summaries from merged blocks to a CSV file."""
+    by_day: Dict[str, List[Dict[str, Any]]] = {}
+    for r in rows:
+        by_day.setdefault(r["date"], []).append(r)
+
+    fieldnames = ["date", "first_seen", "last_seen", "gross_span_hours",
+                  "active_block_hours", "n_blocks", "n_visits"]
+    with open(path, "w", newline="", encoding="utf-8") as f:
+        w = csv.DictWriter(f, fieldnames=fieldnames)
+        w.writeheader()
+        for d in sorted(by_day):
+            day = by_day[d]
+            first = min(r["start"] for r in day)
+            last  = max(r["end"]   for r in day)
+            gross = (last - first).total_seconds() / 3600
+            active = sum((r["end"] - r["start"]).total_seconds() for r in day) / 3600
+            w.writerow({
+                "date": d,
+                "first_seen": first.strftime("%H:%M"),
+                "last_seen":  last.strftime("%H:%M"),
+                "gross_span_hours":  round(gross, 2),
+                "active_block_hours": round(active, 2),
+                "n_blocks": len(day),
+                "n_visits": sum(r["n_visits"] for r in day),
+            })
+
+
+def merge_blocks(
+    files: List[Union[str, Path]],
+    out_blocks: Union[str, Path] = "merged_blocks.csv",
+    out_daily: Union[str, Path] = "merged_daily.csv",
+) -> None:
+    """
+    Programmatic API to merge multiple blocks.csv files and write outputs.
+    """
+    paths = [Path(f) for f in files]
+    missing = [p for p in paths if not p.exists()]
+    if missing:
+        raise FileNotFoundError(f"Files not found: {', '.join(str(m) for m in missing)}")
+
+    rows = load_blocks(paths)
+    merged = merge_intervals(rows)
+
+    write_blocks(merged, Path(out_blocks))
+    write_daily(merged, Path(out_daily))
+
+
+def parse_args() -> argparse.Namespace:
+    p = argparse.ArgumentParser(
+        description="Merge blocks.csv files, collapsing overlapping time intervals."
+    )
+    p.add_argument("files", nargs="+", help="blocks.csv files to merge")
+    p.add_argument("--out-blocks", default="merged_blocks.csv")
+    p.add_argument("--out-daily",  default="merged_daily.csv",
+                   help="Derive a daily summary from merged blocks")
+    return p.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+
+    try:
+        merge_blocks(
+            files=args.files,
+            out_blocks=args.out_blocks,
+            out_daily=args.out_daily,
+        )
+        print(f"Successfully merged {len(args.files)} file(s).")
+        print(f"Written: {args.out_blocks}")
+        print(f"Written: {args.out_daily}")
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

chrome_time_clock/plotter.py

@@ -0,0 +1,377 @@
+"""Work-hours timelines + histograms in dark Soilytix style."""
+
+import argparse
+import csv
+import statistics
+import sys
+from datetime import date, datetime, timedelta
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple, Union
+
+# ── Soilytix dark palette ─────────────────────────────────────────────────────
+
+C = {
+    "fig_bg":    "#111614",
+    "axes_bg":   "#161e1b",
+    "text":      "#fdfefc",
+    "muted":     "#837e75",
+    "dimmed":    "#7d7a75",
+    "border":    "#2a3a34",
+    "grid":      "#1d2b26",
+    "primary":   "#00ff87",   # mint  — weekly line
+    "secondary": "#86eb22",   # lime  — daily bars / histograms
+    "red":       "#b14117",
+    "blue":      "#1a4f8a",
+    "cyan":      "#0f7a65",
+    "weekend":   "#0c1410",   # darker strip for Sat/Sun
+}
+
+STAT_COLORS = {
+    "min":    C["blue"],
+    "max":    C["red"],
+    "mean":   C["cyan"],
+    "median": C["muted"],
+}
+
+# ── Load ──────────────────────────────────────────────────────────────────────
+
+def load_daily(path: Path, date_from: Optional[date], date_to: Optional[date]) -> List[Dict[str, Any]]:
+    """Load daily summary data from CSV file and filter by date range."""
+    rows = []
+    with open(path, newline="", encoding="utf-8") as f:
+        for row in csv.DictReader(f):
+            d = datetime.strptime(row["date"], "%Y-%m-%d").date()
+            if date_from and d < date_from:
+                continue
+            if date_to and d > date_to:
+                continue
+            rows.append({
+                "date":         d,
+                "weekday":      d.weekday(),          # 0=Mon … 6=Sun
+                "iso_week":     d.isocalendar()[:2],  # (year, week)
+                "active_hours": float(row["active_block_hours"]),
+            })
+    return rows
+
+# ── Aggregation ───────────────────────────────────────────────────────────────
+
+def _to_dt(d: date) -> datetime:
+    return datetime(d.year, d.month, d.day)
+
+
+def daily_series(rows: List[Dict[str, Any]], weekdays_only: bool) -> Tuple[List[datetime], List[float]]:
+    """Extract daily dates and active hours series."""
+    out = [(r["date"], r["active_hours"]) for r in rows
+           if not weekdays_only or r["weekday"] < 5]
+    if not out:
+        return [], []
+    dates, hours = zip(*out)
+    return [_to_dt(d) for d in dates], list(hours)
+
+
+def _iso_week_wednesday(year: int, week: int) -> date:
+    jan4 = date(year, 1, 4)
+    monday_w1 = jan4 - timedelta(days=jan4.weekday())
+    return monday_w1 + timedelta(weeks=week - 1, days=2)
+
+
+def weekly_series(rows: List[Dict[str, Any]], weekdays_only: bool) -> Tuple[List[datetime], List[float]]:
+    """Aggregate daily active hours into weekly totals."""
+    by_week: Dict[Tuple[int, int], float] = {}
+    for r in rows:
+        if weekdays_only and r["weekday"] >= 5:
+            continue
+        by_week[r["iso_week"]] = by_week.get(r["iso_week"], 0.0) + r["active_hours"]
+    items = sorted(by_week.items())
+    if not items:
+        return [], []
+    dates = [_to_dt(_iso_week_wednesday(y, w)) for (y, w), _ in items]
+    hours = [v for _, v in items]
+    return dates, hours
+
+
+def hist_values(rows: List[Dict[str, Any]], weekdays_only: bool, is_weekly: bool) -> List[float]:
+    """Get active hours list for histogram plotting."""
+    _, hours = (weekly_series if is_weekly else daily_series)(rows, weekdays_only)
+    return hours
+
+
+def date_range_all(rows: List[Dict[str, Any]]) -> List[datetime]:
+    """Generate every calendar day from the first to the last row date."""
+    first, last = rows[0]["date"], rows[-1]["date"]
+    out, d = [], first
+    while d <= last:
+        out.append(_to_dt(d))
+        d += timedelta(days=1)
+    return out
+
+# ── Theme helpers ─────────────────────────────────────────────────────────────
+
+def apply_style() -> None:
+    """Apply the custom Soilytix dark stylesheet to matplotlib."""
+    import matplotlib.pyplot as plt
+    plt.rcParams.update({
+        "font.family":      "sans-serif",
+        "font.sans-serif":  ["Inter", "Aptos", "Helvetica Neue", "Arial"],
+        "figure.facecolor": C["fig_bg"],
+        "axes.facecolor":   C["axes_bg"],
+        "text.color":       C["text"],
+        "axes.labelcolor":  C["muted"],
+        "xtick.color":      C["muted"],
+        "ytick.color":      C["muted"],
+        "axes.edgecolor":   C["border"],
+        "grid.color":       C["grid"],
+        "grid.linewidth":   0.5,
+        "legend.facecolor": C["axes_bg"],
+        "legend.edgecolor": C["border"],
+        "legend.labelcolor": C["text"],
+    })
+
+
+def dress_axes(ax: Any, xlabel: str = "", ylabel: str = "") -> None:
+    """Style axes spines, ticks, labels, and gridlines."""
+    ax.set_facecolor(C["axes_bg"])
+    for spine in ax.spines.values():
+        spine.set_edgecolor(C["border"])
+    ax.tick_params(colors=C["muted"], labelsize=8)
+    ax.set_xlabel(xlabel, fontsize=8.5, color=C["muted"])
+    ax.set_ylabel(ylabel, fontsize=8.5, color=C["muted"])
+    ax.set_axisbelow(True)
+    ax.grid(axis="y", zorder=1)
+
+
+def shade_weekends(ax: Any, all_dts: List[datetime]) -> None:
+    """Shade weekend days with a darker background strip."""
+    for dt in all_dts:
+        if dt.weekday() >= 5:           # 5=Sat, 6=Sun
+            ax.axvspan(dt - timedelta(hours=12), dt + timedelta(hours=12),
+                       color=C["weekend"], alpha=1.0, zorder=0)
+
+
+def stat_box(ax: Any, values: List[float]) -> None:
+    """Draw vertical lines for min, max, mean, median and display a stats box."""
+    if not values:
+        return
+    stats = {
+        "min":    min(values),
+        "max":    max(values),
+        "mean":   statistics.mean(values),
+        "median": statistics.median(values),
+    }
+    for label, val in stats.items():
+        ax.axvline(val, color=STAT_COLORS[label], linewidth=1.3,
+                   linestyle="--", alpha=0.9, zorder=4)
+    box_text = "\n".join(f"{k:<7}{v:.2f} h" for k, v in stats.items())
+    ax.text(
+        0.97, 0.97, box_text,
+        transform=ax.transAxes, ha="right", va="top",
+        fontsize=8, fontfamily="monospace", color=C["text"],
+        bbox=dict(boxstyle="round,pad=0.4", facecolor=C["fig_bg"],
+                  edgecolor=C["primary"], linewidth=0.9, alpha=0.95),
+        zorder=5,
+    )
+
+# ── Timeline ──────────────────────────────────────────────────────────────────
+
+def plot_timeline(ax: Any, rows: List[Dict[str, Any]]) -> None:
+    """Plot daily active hours as bars and weekly active hours as a line."""
+    import matplotlib.dates as mdates
+    import matplotlib.ticker as ticker
+    import matplotlib.pyplot as plt
+
+    all_dts = date_range_all(rows)
+    shade_weekends(ax, all_dts)
+
+    daily_dates, daily_hours = daily_series(rows, weekdays_only=False)
+    weekly_dates, weekly_hours = weekly_series(rows, weekdays_only=False)
+
+    # Daily bars (lime, left axis)
+    ax.bar(daily_dates, daily_hours,
+           color=C["secondary"], alpha=0.78, width=0.72, zorder=2,
+           label="Daily active h")
+    dress_axes(ax, ylabel="Active hours (day)")
+
+    # Weekly line (mint, right axis)
+    ax_w = ax.twinx()
+    ax_w.plot(weekly_dates, weekly_hours,
+              color=C["primary"], linewidth=2.0, marker="o", markersize=5,
+              markerfacecolor=C["primary"], markeredgecolor=C["fig_bg"],
+              markeredgewidth=1.4, zorder=3, label="Weekly total h")
+    ax_w.tick_params(colors=C["primary"], labelsize=8)
+    ax_w.set_ylabel("Active hours (week)", fontsize=8.5, color=C["primary"])
+    ax_w.spines["right"].set_edgecolor(C["primary"])
+    for s in ("top", "left", "bottom"):
+        ax_w.spines[s].set_visible(False)
+    ax_w.grid(False)
+    ax_w.yaxis.set_major_locator(ticker.MaxNLocator(integer=False, nbins=5))
+
+    # x-axis date formatting
+    span_days = (rows[-1]["date"] - rows[0]["date"]).days
+    if span_days <= 60:
+        ax.xaxis.set_major_locator(mdates.WeekdayLocator(byweekday=mdates.MO))
+        ax.xaxis.set_major_formatter(mdates.DateFormatter("%b %d"))
+    elif span_days <= 180:
+        ax.xaxis.set_major_locator(mdates.WeekdayLocator(byweekday=mdates.MO, interval=2))
+        ax.xaxis.set_major_formatter(mdates.DateFormatter("%b %d"))
+    else:
+        ax.xaxis.set_major_locator(mdates.MonthLocator())
+        ax.xaxis.set_major_formatter(mdates.DateFormatter("%b '%y"))
+    plt.setp(ax.xaxis.get_majorticklabels(), rotation=35, ha="right", fontsize=8)
+
+    # x range with a half-day margin
+    ax.set_xlim(all_dts[0] - timedelta(hours=12), all_dts[-1] + timedelta(hours=12))
+    ax.yaxis.set_major_locator(ticker.MaxNLocator(integer=False, nbins=6))
+
+    # Legend combining both axes
+    h1, l1 = ax.get_legend_handles_labels()
+    h2, l2 = ax_w.get_legend_handles_labels()
+    ax.legend(h1 + h2, l1 + l2, loc="upper left", fontsize=8.5,
+              facecolor=C["axes_bg"], edgecolor=C["border"])
+
+    ax.set_title(
+        "Active hours — daily bars  +  weekly total  (weekends shaded)",
+        fontsize=10.5, color=C["text"], pad=8, fontweight="bold",
+    )
+
+# ── Histogram ─────────────────────────────────────────────────────────────────
+
+HIST_PANELS = [
+    ("Daily — all days",       False, False, "Active hours (day)"),
+    ("Daily — weekdays only",  True,  False, "Active hours (day)"),
+    ("Weekly — all days",      False, True,  "Active hours (week)"),
+    ("Weekly — weekdays only", True,  True,  "Active hours (week)"),
+]
+
+
+def plot_histogram(ax: Any, values: List[float],
+                   title: str, xlabel: str, bins: int) -> None:
+    """Plot a single histogram panel with statistics."""
+    import matplotlib.ticker as ticker
+    if not values:
+        ax.text(0.5, 0.5, "no data", ha="center", va="center",
+                transform=ax.transAxes, color=C["muted"])
+        ax.set_title(title, fontsize=9.5, color=C["text"], pad=6, fontweight="bold")
+        return
+
+    n_bins = min(bins, max(5, len(values) // 2))
+    ax.hist(values, bins=n_bins,
+            color=C["secondary"], edgecolor=C["axes_bg"],
+            linewidth=0.6, alpha=0.88, zorder=2)
+    dress_axes(ax, xlabel=xlabel, ylabel="Count")
+    ax.set_title(title, fontsize=9.5, color=C["text"], pad=6, fontweight="bold")
+    ax.yaxis.set_major_locator(ticker.MaxNLocator(integer=True))
+    ax.text(0.03, 0.97, f"n={len(values)}",
+            transform=ax.transAxes, ha="left", va="top",
+            fontsize=8, color=C["muted"])
+    stat_box(ax, values)
+
+# ── Figure assembly ───────────────────────────────────────────────────────────
+
+def build_figure(
+    rows: List[Dict[str, Any]],
+    date_from: Optional[date],
+    bins: int,
+    out_stem: str,
+    show: bool = False,
+) -> None:
+    """Assemble the timeline and histograms into a single multi-panel figure."""
+    import matplotlib.pyplot as plt
+    from matplotlib.gridspec import GridSpec
+
+    apply_style()
+
+    fig = plt.figure(figsize=(16, 16))
+    gs = GridSpec(
+        3, 2, figure=fig,
+        height_ratios=[1.8, 1.4, 1.4],
+        hspace=0.55, wspace=0.32,
+        left=0.07, right=0.94, top=0.94, bottom=0.05,
+    )
+
+    subtitle = f"after {date_from}" if date_from else "all available history"
+    fig.suptitle(
+        f"Soilytix  ·  Work Hours  ·  {subtitle}",
+        fontsize=14, fontweight="bold", color=C["text"], y=0.975,
+    )
+
+    # Timeline (full width)
+    ax_tl = fig.add_subplot(gs[0, :])
+    plot_timeline(ax_tl, rows)
+
+    # 2 × 2 histograms
+    positions = [(1, 0), (1, 1), (2, 0), (2, 1)]
+    for (r, c), (title, wd_only, is_weekly, xlabel) in zip(positions, HIST_PANELS):
+        ax = fig.add_subplot(gs[r, c])
+        plot_histogram(ax, hist_values(rows, wd_only, is_weekly), title, xlabel, bins)
+
+    # Export
+    out_dir = Path(out_stem).parent
+    if out_dir != Path("."):
+        out_dir.mkdir(parents=True, exist_ok=True)
+
+    for ext in ("png", "pdf"):
+        out = f"{out_stem}.{ext}"
+        fig.savefig(out, dpi=150, bbox_inches="tight",
+                    facecolor=fig.get_facecolor())
+        print(f"Saved: {out}")
+
+    if show:
+        plt.show()
+    else:
+        plt.close(fig)
+
+
+def plot_workhours(
+    csv_path: Union[str, Path],
+    date_from: Optional[date] = None,
+    date_to: Optional[date] = None,
+    bins: int = 15,
+    out_stem: str = "workhours_plot",
+    show: bool = False,
+) -> None:
+    """
+    Programmatic API to plot work hours from a daily summary CSV file.
+    """
+    rows = load_daily(Path(csv_path), date_from, date_to)
+    if not rows:
+        raise ValueError("No data found in the specified date range.")
+
+    build_figure(rows, date_from, bins, out_stem, show=show)
+
+
+def parse_args() -> argparse.Namespace:
+    p = argparse.ArgumentParser(
+        description="Work-hour timelines and histograms in dark Soilytix style."
+    )
+    p.add_argument("csv",              help="daily summary CSV")
+    p.add_argument("--from", dest="date_from", default="2026-02-22")
+    p.add_argument("--to",   dest="date_to",   default=None)
+    p.add_argument("--bins", type=int,          default=15)
+    p.add_argument("--out",  default="workhours_plot",
+                   help="Output file stem — .png and .pdf are appended")
+    p.add_argument("--show", action="store_true", help="Display the plot window")
+    return p.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+
+    date_from = datetime.strptime(args.date_from, "%Y-%m-%d").date() if args.date_from else None
+    date_to   = datetime.strptime(args.date_to,   "%Y-%m-%d").date() if args.date_to   else None
+
+    try:
+        plot_workhours(
+            csv_path=args.csv,
+            date_from=date_from,
+            date_to=date_to,
+            bins=args.bins,
+            out_stem=args.out,
+            show=args.show,
+        )
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

chrome_time_clock-0.1.0.dist-info/METADATA

@@ -0,0 +1,96 @@
+Metadata-Version: 2.4
+Name: chrome-time-clock
+Version: 0.1.0
+Summary: Infer workday start and end from Chrome, Chromium or Brave history, then plot or merge the hours.
+Author-email: Maurice Frank <maurice.frank@posteo.de>
+License: MIT
+Project-URL: Homepage, https://github.com/morris-frank/chrome-time-clock
+Project-URL: Issues, https://github.com/morris-frank/chrome-time-clock/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: matplotlib>=3.5.0
+Dynamic: license-file
+
+<img src="brand/icon/icon-chrome-time-clock-on-obsidian-1024.png" align="left" width="128" hspace="16" alt="chrome-time-clock icon">
+
+<h3>chrome-time-clock</h3>
+
+<p>
+  <sub>YOUR BROWSER ALREADY KEPT THE TIMESHEET</sub>
+  <br>
+  <strong>Infer workday start and end from Chrome, Chromium or Brave history, then plot or merge the hours.</strong>
+  <br>
+  <br>
+  <a href="https://pypi.org/project/chrome-time-clock/"><img src="https://img.shields.io/pypi/v/chrome-time-clock?style=flat-square&amp;color=3775A9&amp;logo=pypi&amp;logoColor=white&amp;labelColor=2D2825" alt="PyPI version"></a>
+  <img src="https://img.shields.io/badge/python-%E2%89%A53.9-D78A7A?style=flat-square&amp;labelColor=2D2825" alt="Python 3.9+">
+  <img src="https://img.shields.io/badge/browsers-Chrome%20%C2%B7%20Chromium%20%C2%B7%20Brave-D78A7A?style=flat-square&amp;labelColor=2D2825" alt="Chrome, Chromium, Brave">
+  <img src="https://img.shields.io/badge/OS-macOS%20%C2%B7%20Windows%20%C2%B7%20Linux-7E9688?style=flat-square&amp;labelColor=2D2825" alt="macOS, Windows, Linux">
+  <img src="https://img.shields.io/badge/license-MIT-7E9688?style=flat-square&amp;labelColor=2D2825" alt="MIT license">
+</p>
+
+<br clear="left">
+
+```sh
+uv tool install chrome-time-clock                      # or: pipx install chrome-time-clock
+chrome-time-clock extract --out ./export --markdown     # history → daily_summary.csv (+ .md)
+chrome-time-clock plot ./export/daily_summary.csv       # timeline + histograms, .png and .pdf
+chrome-time-clock merge laptop.csv desktop.csv          # union of blocks across machines
+```
+
+Everything runs locally against a copy of the browser's History SQLite file; nothing leaves the machine.
+
+## Extract
+
+Groups history visits into active blocks, split wherever the gap exceeds `--gap-minutes`, and reports each day's first and last block.
+
+| Option | Default | |
+|---|---|---|
+| `--browser` | `chrome` | `chrome`, `chromium` or `brave` |
+| `--profile` | `Default` | e.g. `Profile 1` |
+| `--history-db` | — | a History file directly; overrides browser/profile |
+| `--from` / `--to` | — | `YYYY-MM-DD`, inclusive |
+| `--timezone` | `Europe/Amsterdam` | IANA name |
+| `--gap-minutes` | `60` | inactivity that ends a block |
+| `--out` | `./chrome_workhours_export` | CSV output directory |
+| `--markdown` | off | also write `daily_summary.md` |
+
+## Plot
+
+Dark-theme timeline and start/end histograms from `daily_summary.csv`.
+
+| Option | Default | |
+|---|---|---|
+| `--from` / `--to` | `2026-02-22` / — | `YYYY-MM-DD`, inclusive |
+| `--bins` | `15` | histogram bins |
+| `--out` | `workhours_plot` | file stem; `.png` and `.pdf` appended |
+| `--show` | off | open an interactive window |
+
+## Merge
+
+Combines several `blocks.csv` files — one per machine or profile — collapsing overlapping intervals:
+
+```sh
+chrome-time-clock merge a.csv b.csv --out-blocks merged_blocks.csv --out-daily merged_daily.csv
+```
+
+Each subcommand also has a standalone shortcut: `chrome-workhours`, `plot-workhours`, `merge-blocks`.
+
+## Python API
+
+```python
+from datetime import date
+from chrome_time_clock import extract_workhours, plot_workhours, merge_blocks
+
+daily, blocks, warnings = extract_workhours(browser="chrome", profile="Default",
+                                            date_from=date(2026, 6, 1), timezone_str="Europe/Amsterdam")
+plot_workhours(csv_path="./export/daily_summary.csv", date_from=date(2026, 6, 1), out_stem="plot")
+merge_blocks(files=["a.csv", "b.csv"], out_blocks="merged_blocks.csv", out_daily="merged_daily.csv")
+```

chrome_time_clock-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+chrome_time_clock/__init__.py,sha256=LzxYEny3IePm9qtjO37l1wUoeqbiAQRQGbrE_jvsqkQ,385
+chrome_time_clock/cli.py,sha256=7sXBWMumu1LgsoWq-4RaXj0ycUmVBpziI-Vi_nZ_lJs,7844
+chrome_time_clock/extractor.py,sha256=UuKxAXIMm9oLb7Xuq4Cd4q-EOf-dZhNYGG45JCh3yQ0,13569
+chrome_time_clock/merger.py,sha256=l-AkoCH-Ke6AXYqzP7ePlkdm28o34zqKWaeEm6cxh7I,5058
+chrome_time_clock/plotter.py,sha256=Cs3SYP5PxpQTSEy9LS-5VjJh2JRoQfW_42NYzRlvVwE,14664
+chrome_time_clock-0.1.0.dist-info/licenses/LICENSE,sha256=J8UJZvrogVVTgwOaObDrWTucgwAWei_QF9GFevU5iPM,1070
+chrome_time_clock-0.1.0.dist-info/METADATA,sha256=lSaoCzV34Pr7u-kVvHudLp86f3kVCoyt0Ptrx_5UPT0,4406
+chrome_time_clock-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+chrome_time_clock-0.1.0.dist-info/entry_points.txt,sha256=vJStQzAdvSOUGwQ1C2klX-dbZ4i_g78SxpEHFM5peMA,210
+chrome_time_clock-0.1.0.dist-info/top_level.txt,sha256=Q7496CuWQqXp40Oyd9GI2BUbxceLRnm45Ji0ywhj0l4,18
+chrome_time_clock-0.1.0.dist-info/RECORD,,

chrome_time_clock-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

chrome_time_clock-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,5 @@
+[console_scripts]
+chrome-time-clock = chrome_time_clock.cli:main
+chrome-workhours = chrome_time_clock.extractor:main
+merge-blocks = chrome_time_clock.merger:main
+plot-workhours = chrome_time_clock.plotter:main

chrome_time_clock-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Maurice Frank
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

chrome_time_clock-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+chrome_time_clock