hprof-parser 0.1.0__tar.gz

hprof_parser-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Artem
+
+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.

hprof_parser-0.1.0/PKG-INFO

@@ -0,0 +1,76 @@
+Metadata-Version: 2.4
+Name: hprof-parser
+Version: 0.1.0
+Summary: Hobby Project Profiler — track time, progress, and stats across your side projects
+Project-URL: Homepage, https://github.com/brnv/hprof-parser
+Author-email: Artem <brnv@canva.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: hobby,profiler,projects,side-project,time,tracker
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# hprof-parser
+
+**H**obby **Prof**iler — track time, progress, and stats across your side projects.
+
+## Installation
+
+```bash
+pip install hprof-parser
+```
+
+## Usage
+
+```python
+from hprof_parser import Tracker, Project, Report
+
+tracker = Tracker(storage_path="~/.hprof.json")
+
+# Add projects
+tracker.add_project(Project(name="rust-raytracer", tags=["rust", "graphics"]))
+tracker.add_project(Project(name="arduino-plant-watering", tags=["hardware"]))
+
+# Track time
+tracker.start_session("rust-raytracer", "implementing BVH")
+# ... work ...
+tracker.stop_session()
+
+# Goals
+p = tracker.get_project("rust-raytracer")
+p.add_goal("Basic sphere rendering")
+p.add_goal("BVH acceleration")
+p.add_goal("Materials & textures")
+p.check_goal(0)  # done!
+
+# Reports
+report = Report(tracker)
+print(report.weekly())
+print(report.project_report("rust-raytracer"))
+print(report.graveyard())  # RIP abandoned projects
+print(report.completion_rate())
+print(tracker.streak())  # consecutive days
+```
+
+## CLI
+
+```bash
+hprof add "rust-raytracer" --tags rust graphics
+hprof start rust-raytracer --desc "BVH implementation"
+hprof stop
+hprof status
+hprof goal rust-raytracer "Add texture support"
+hprof check rust-raytracer 0
+hprof weekly
+hprof report rust-raytracer
+hprof set-status rust-raytracer complete
+hprof graveyard
+```
+
+## License
+
+MIT

hprof_parser-0.1.0/README.md

@@ -0,0 +1,60 @@
+# hprof-parser
+
+**H**obby **Prof**iler — track time, progress, and stats across your side projects.
+
+## Installation
+
+```bash
+pip install hprof-parser
+```
+
+## Usage
+
+```python
+from hprof_parser import Tracker, Project, Report
+
+tracker = Tracker(storage_path="~/.hprof.json")
+
+# Add projects
+tracker.add_project(Project(name="rust-raytracer", tags=["rust", "graphics"]))
+tracker.add_project(Project(name="arduino-plant-watering", tags=["hardware"]))
+
+# Track time
+tracker.start_session("rust-raytracer", "implementing BVH")
+# ... work ...
+tracker.stop_session()
+
+# Goals
+p = tracker.get_project("rust-raytracer")
+p.add_goal("Basic sphere rendering")
+p.add_goal("BVH acceleration")
+p.add_goal("Materials & textures")
+p.check_goal(0)  # done!
+
+# Reports
+report = Report(tracker)
+print(report.weekly())
+print(report.project_report("rust-raytracer"))
+print(report.graveyard())  # RIP abandoned projects
+print(report.completion_rate())
+print(tracker.streak())  # consecutive days
+```
+
+## CLI
+
+```bash
+hprof add "rust-raytracer" --tags rust graphics
+hprof start rust-raytracer --desc "BVH implementation"
+hprof stop
+hprof status
+hprof goal rust-raytracer "Add texture support"
+hprof check rust-raytracer 0
+hprof weekly
+hprof report rust-raytracer
+hprof set-status rust-raytracer complete
+hprof graveyard
+```
+
+## License
+
+MIT

hprof_parser-0.1.0/pyproject.toml

@@ -0,0 +1,27 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "hprof-parser"
+version = "0.1.0"
+description = "Hobby Project Profiler — track time, progress, and stats across your side projects"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.10"
+authors = [
+    { name = "Artem", email = "brnv@canva.com" },
+]
+keywords = ["hobby", "projects", "profiler", "tracker", "time", "side-project"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: End Users/Desktop",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+]
+
+[project.urls]
+Homepage = "https://github.com/brnv/hprof-parser"
+
+[project.scripts]
+hprof = "hprof_parser.cli:main"

hprof_parser-0.1.0/src/hprof_parser/__init__.py

@@ -0,0 +1,10 @@
+"""hprof-parser: Hobby Project Profiler."""
+
+__version__ = "0.1.0"
+
+from .project import Project, ProjectStatus
+from .session import Session
+from .tracker import Tracker
+from .report import Report
+
+__all__ = ["Project", "ProjectStatus", "Session", "Tracker", "Report"]

hprof_parser-0.1.0/src/hprof_parser/cli.py

@@ -0,0 +1,122 @@
+"""CLI for hprof-parser."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+
+DEFAULT_STORE = Path.home() / ".hprof.json"
+
+
+def main(argv: list[str] | None = None) -> None:
+    parser = argparse.ArgumentParser(prog="hprof", description="Hobby Project Profiler")
+    parser.add_argument("--store", default=str(DEFAULT_STORE), help="Storage file path")
+    sub = parser.add_subparsers(dest="command")
+
+    # Add project
+    a_p = sub.add_parser("add", help="Add a new project")
+    a_p.add_argument("name")
+    a_p.add_argument("--desc", default="")
+    a_p.add_argument("--tags", nargs="*", default=[])
+
+    # Start session
+    s_p = sub.add_parser("start", help="Start working on a project")
+    s_p.add_argument("project")
+    s_p.add_argument("--desc", default="")
+
+    # Stop session
+    sub.add_parser("stop", help="Stop current session")
+
+    # Status
+    sub.add_parser("status", help="Show tracker summary")
+
+    # Weekly report
+    sub.add_parser("weekly", help="Weekly time report")
+
+    # Project report
+    r_p = sub.add_parser("report", help="Detailed project report")
+    r_p.add_argument("project")
+
+    # Goal
+    g_p = sub.add_parser("goal", help="Add a goal to a project")
+    g_p.add_argument("project")
+    g_p.add_argument("goal")
+
+    # Check goal
+    c_p = sub.add_parser("check", help="Mark a goal as done")
+    c_p.add_argument("project")
+    c_p.add_argument("index", type=int, help="Goal index (0-based)")
+
+    # Graveyard
+    sub.add_parser("graveyard", help="List abandoned projects")
+
+    # Set status
+    st_p = sub.add_parser("set-status", help="Change project status")
+    st_p.add_argument("project")
+    st_p.add_argument("new_status", choices=["idea", "active", "paused", "abandoned", "complete"])
+
+    args = parser.parse_args(argv)
+
+    from .tracker import Tracker
+    from .project import Project, ProjectStatus
+    from .report import Report
+
+    tracker = Tracker(storage_path=Path(args.store))
+
+    if args.command == "add":
+        tracker.add_project(Project(name=args.name, description=args.desc, tags=args.tags))
+        print(f"Added: {args.name}")
+
+    elif args.command == "start":
+        session = tracker.start_session(args.project, args.desc)
+        print(f"Started session on {args.project}")
+
+    elif args.command == "stop":
+        session = tracker.stop_session()
+        if session:
+            print(f"Stopped: {session.project_name} ({session.hours:.1f}h)")
+        else:
+            print("No running session")
+
+    elif args.command == "status":
+        print(tracker.summary())
+
+    elif args.command == "weekly":
+        print(Report(tracker).weekly())
+
+    elif args.command == "report":
+        print(Report(tracker).project_report(args.project))
+
+    elif args.command == "goal":
+        p = tracker.get_project(args.project)
+        p.add_goal(args.goal)
+        tracker._save()
+        print(f"Goal added to {args.project}")
+
+    elif args.command == "check":
+        p = tracker.get_project(args.project)
+        p.check_goal(args.index)
+        tracker._save()
+        print(f"Goal {args.index} checked off")
+
+    elif args.command == "graveyard":
+        print(Report(tracker).graveyard())
+
+    elif args.command == "set-status":
+        p = tracker.get_project(args.project)
+        p.status = ProjectStatus(args.new_status)
+        if args.new_status == "active":
+            p.start()
+        elif args.new_status == "complete":
+            p.complete()
+        tracker._save()
+        print(f"{args.project} → {args.new_status}")
+
+    else:
+        parser.print_help()
+
+
+if __name__ == "__main__":
+    main()

hprof_parser-0.1.0/src/hprof_parser/project.py

@@ -0,0 +1,97 @@
+"""Project model."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import date, datetime
+from enum import Enum
+from typing import Any
+
+
+class ProjectStatus(str, Enum):
+    IDEA = "idea"
+    ACTIVE = "active"
+    PAUSED = "paused"
+    ABANDONED = "abandoned"
+    COMPLETE = "complete"
+
+
+@dataclass
+class Project:
+    """A hobby project to track."""
+
+    name: str
+    description: str = ""
+    status: ProjectStatus = ProjectStatus.IDEA
+    tags: list[str] = field(default_factory=list)
+    started: date | None = None
+    completed: date | None = None
+    goals: list[str] = field(default_factory=list)
+    goals_done: list[bool] = field(default_factory=list)
+    links: list[str] = field(default_factory=list)
+    notes: str = ""
+
+    def start(self) -> None:
+        self.status = ProjectStatus.ACTIVE
+        if not self.started:
+            self.started = date.today()
+
+    def pause(self) -> None:
+        self.status = ProjectStatus.PAUSED
+
+    def abandon(self) -> None:
+        self.status = ProjectStatus.ABANDONED
+
+    def complete(self) -> None:
+        self.status = ProjectStatus.COMPLETE
+        self.completed = date.today()
+
+    def add_goal(self, goal: str) -> None:
+        self.goals.append(goal)
+        self.goals_done.append(False)
+
+    def check_goal(self, index: int) -> None:
+        if 0 <= index < len(self.goals_done):
+            self.goals_done[index] = True
+
+    @property
+    def progress(self) -> float:
+        if not self.goals_done:
+            return 0.0
+        return sum(self.goals_done) / len(self.goals_done)
+
+    @property
+    def days_active(self) -> int:
+        if not self.started:
+            return 0
+        end = self.completed or date.today()
+        return (end - self.started).days
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "name": self.name,
+            "description": self.description,
+            "status": self.status.value,
+            "tags": self.tags,
+            "started": self.started.isoformat() if self.started else None,
+            "completed": self.completed.isoformat() if self.completed else None,
+            "goals": self.goals,
+            "goals_done": self.goals_done,
+            "links": self.links,
+            "notes": self.notes,
+        }
+
+    @classmethod
+    def from_dict(cls, d: dict[str, Any]) -> Project:
+        return cls(
+            name=d["name"],
+            description=d.get("description", ""),
+            status=ProjectStatus(d.get("status", "idea")),
+            tags=d.get("tags", []),
+            started=date.fromisoformat(d["started"]) if d.get("started") else None,
+            completed=date.fromisoformat(d["completed"]) if d.get("completed") else None,
+            goals=d.get("goals", []),
+            goals_done=d.get("goals_done", []),
+            links=d.get("links", []),
+            notes=d.get("notes", ""),
+        )

hprof_parser-0.1.0/src/hprof_parser/report.py

@@ -0,0 +1,87 @@
+"""Generate reports from tracker data."""
+
+from __future__ import annotations
+
+from datetime import datetime, timedelta, date
+from typing import Any
+
+from .tracker import Tracker
+
+
+class Report:
+    """Generate reports from a Tracker."""
+
+    def __init__(self, tracker: Tracker) -> None:
+        self.tracker = tracker
+
+    def weekly(self) -> str:
+        hours = self.tracker.hours_this_week()
+        total = sum(hours.values())
+        lines = [f"Weekly Report — {total:.1f}h total", ""]
+        for proj, h in sorted(hours.items(), key=lambda x: -x[1]):
+            bar = "█" * int(h * 4) + "░" * max(0, 20 - int(h * 4))
+            lines.append(f"  {proj:>20}  {bar}  {h:.1f}h")
+        if not hours:
+            lines.append("  No sessions this week")
+        return "\n".join(lines)
+
+    def project_report(self, project_name: str) -> str:
+        p = self.tracker.get_project(project_name)
+        sessions = self.tracker.sessions_for(project_name)
+        total_h = sum(s.hours for s in sessions)
+
+        lines = [
+            f"Project: {p.name}",
+            f"Status: {p.status.value}  |  Days active: {p.days_active}",
+            f"Total time: {total_h:.1f}h across {len(sessions)} sessions",
+            f"Avg session: {total_h / len(sessions):.1f}h" if sessions else "No sessions yet",
+            "",
+        ]
+
+        if p.goals:
+            lines.append("Goals:")
+            for i, (goal, done) in enumerate(zip(p.goals, p.goals_done)):
+                mark = "✓" if done else "○"
+                lines.append(f"  {mark} {goal}")
+            lines.append(f"  Progress: {p.progress:.0%}")
+            lines.append("")
+
+        if sessions:
+            lines.append("Recent sessions:")
+            for s in sessions[-5:]:
+                dur = f"{s.hours:.1f}h"
+                desc = f" — {s.description}" if s.description else ""
+                lines.append(f"  {s.start.strftime('%Y-%m-%d %H:%M')}  {dur}{desc}")
+
+        return "\n".join(lines)
+
+    def graveyard(self) -> str:
+        """List abandoned projects — a moment of silence."""
+        from .project import ProjectStatus
+        abandoned = self.tracker.by_status(ProjectStatus.ABANDONED)
+        if not abandoned:
+            return "No abandoned projects — impressive!"
+        lines = ["Project Graveyard", ""]
+        for p in abandoned:
+            hours = self.tracker.total_hours(p.name)
+            lines.append(f"  ✝ {p.name} — {hours:.1f}h invested, {p.days_active} days")
+            if p.description:
+                lines.append(f"    {p.description}")
+        lines.append(f"\n  Total time in the graveyard: {sum(self.tracker.total_hours(p.name) for p in abandoned):.1f}h")
+        return "\n".join(lines)
+
+    def completion_rate(self) -> dict[str, Any]:
+        from .project import ProjectStatus
+        total = self.tracker.total_projects
+        if total == 0:
+            return {"total": 0, "completion_rate": 0}
+        complete = len(self.tracker.by_status(ProjectStatus.COMPLETE))
+        abandoned = len(self.tracker.by_status(ProjectStatus.ABANDONED))
+        return {
+            "total": total,
+            "complete": complete,
+            "abandoned": abandoned,
+            "active": len(self.tracker.active_projects()),
+            "completion_rate": complete / total if total else 0,
+            "abandonment_rate": abandoned / total if total else 0,
+        }

hprof_parser-0.1.0/src/hprof_parser/session.py

@@ -0,0 +1,58 @@
+"""Time tracking sessions."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import datetime, timedelta
+from typing import Any
+
+
+@dataclass
+class Session:
+    """A work session on a project."""
+
+    project_name: str
+    start: datetime
+    end: datetime | None = None
+    description: str = ""
+    tags: list[str] = field(default_factory=list)
+
+    @classmethod
+    def now(cls, project_name: str, description: str = "") -> Session:
+        return cls(project_name=project_name, start=datetime.now(), description=description)
+
+    def stop(self) -> None:
+        if not self.end:
+            self.end = datetime.now()
+
+    @property
+    def duration(self) -> timedelta:
+        end = self.end or datetime.now()
+        return end - self.start
+
+    @property
+    def hours(self) -> float:
+        return self.duration.total_seconds() / 3600
+
+    @property
+    def is_running(self) -> bool:
+        return self.end is None
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "project_name": self.project_name,
+            "start": self.start.isoformat(),
+            "end": self.end.isoformat() if self.end else None,
+            "description": self.description,
+            "tags": self.tags,
+        }
+
+    @classmethod
+    def from_dict(cls, d: dict[str, Any]) -> Session:
+        return cls(
+            project_name=d["project_name"],
+            start=datetime.fromisoformat(d["start"]),
+            end=datetime.fromisoformat(d["end"]) if d.get("end") else None,
+            description=d.get("description", ""),
+            tags=d.get("tags", []),
+        )

hprof_parser-0.1.0/src/hprof_parser/tracker.py

@@ -0,0 +1,170 @@
+"""Tracker — the main hub for managing projects and sessions."""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, field
+from datetime import datetime, date, timedelta
+from pathlib import Path
+from typing import Any
+
+from .project import Project, ProjectStatus
+from .session import Session
+
+
+@dataclass
+class Tracker:
+    """Central tracker for all hobby projects and time sessions.
+
+    Parameters
+    ----------
+    storage_path : Path | None
+        JSON file for persistence. Auto-saves on changes.
+    """
+
+    projects: dict[str, Project] = field(default_factory=dict)
+    sessions: list[Session] = field(default_factory=list)
+    storage_path: Path | None = None
+
+    def __post_init__(self):
+        if self.storage_path:
+            self.storage_path = Path(self.storage_path)
+            if self.storage_path.exists():
+                self._load()
+
+    # ── Projects ──
+
+    def add_project(self, project: Project) -> None:
+        self.projects[project.name] = project
+        self._save()
+
+    def get_project(self, name: str) -> Project:
+        if name not in self.projects:
+            raise KeyError(f"Project '{name}' not found")
+        return self.projects[name]
+
+    def remove_project(self, name: str) -> None:
+        self.projects.pop(name, None)
+        self._save()
+
+    def active_projects(self) -> list[Project]:
+        return [p for p in self.projects.values() if p.status == ProjectStatus.ACTIVE]
+
+    def by_status(self, status: ProjectStatus) -> list[Project]:
+        return [p for p in self.projects.values() if p.status == status]
+
+    def by_tag(self, tag: str) -> list[Project]:
+        return [p for p in self.projects.values() if tag.lower() in [t.lower() for t in p.tags]]
+
+    # ── Sessions ──
+
+    def start_session(self, project_name: str, description: str = "") -> Session:
+        if project_name not in self.projects:
+            raise KeyError(f"Project '{project_name}' not found")
+        # Auto-stop any running session
+        for s in self.sessions:
+            if s.is_running:
+                s.stop()
+        session = Session.now(project_name, description)
+        self.sessions.append(session)
+        # Mark project active
+        self.projects[project_name].start()
+        self._save()
+        return session
+
+    def stop_session(self) -> Session | None:
+        for s in reversed(self.sessions):
+            if s.is_running:
+                s.stop()
+                self._save()
+                return s
+        return None
+
+    def current_session(self) -> Session | None:
+        for s in reversed(self.sessions):
+            if s.is_running:
+                return s
+        return None
+
+    def sessions_for(self, project_name: str) -> list[Session]:
+        return [s for s in self.sessions if s.project_name == project_name]
+
+    def total_hours(self, project_name: str) -> float:
+        return sum(s.hours for s in self.sessions_for(project_name))
+
+    def hours_this_week(self) -> dict[str, float]:
+        week_start = datetime.now() - timedelta(days=datetime.now().weekday())
+        week_start = week_start.replace(hour=0, minute=0, second=0)
+        result: dict[str, float] = {}
+        for s in self.sessions:
+            if s.start >= week_start:
+                result[s.project_name] = result.get(s.project_name, 0) + s.hours
+        return result
+
+    # ── Stats ──
+
+    @property
+    def total_projects(self) -> int:
+        return len(self.projects)
+
+    @property
+    def total_sessions(self) -> int:
+        return len(self.sessions)
+
+    @property
+    def total_hours_all(self) -> float:
+        return sum(s.hours for s in self.sessions)
+
+    def streak(self) -> int:
+        """How many consecutive days you've logged sessions."""
+        if not self.sessions:
+            return 0
+        dates = sorted(set(s.start.date() for s in self.sessions), reverse=True)
+        streak = 0
+        expected = date.today()
+        for d in dates:
+            if d == expected:
+                streak += 1
+                expected -= timedelta(days=1)
+            elif d < expected:
+                break
+        return streak
+
+    # ── Persistence ──
+
+    def _save(self) -> None:
+        if not self.storage_path:
+            return
+        data = {
+            "projects": {k: v.to_dict() for k, v in self.projects.items()},
+            "sessions": [s.to_dict() for s in self.sessions],
+        }
+        self.storage_path.write_text(json.dumps(data, indent=2))
+
+    def _load(self) -> None:
+        data = json.loads(self.storage_path.read_text())
+        self.projects = {k: Project.from_dict(v) for k, v in data.get("projects", {}).items()}
+        self.sessions = [Session.from_dict(s) for s in data.get("sessions", [])]
+
+    def summary(self) -> str:
+        lines = [
+            f"Hobby Profiler — {self.total_projects} projects, "
+            f"{self.total_hours_all:.1f}h logged, {self.streak()} day streak",
+            "",
+        ]
+        current = self.current_session()
+        if current:
+            lines.append(f"  ▶ Working on: {current.project_name} ({current.hours:.1f}h)")
+            lines.append("")
+
+        for status in ProjectStatus:
+            projs = self.by_status(status)
+            if projs:
+                lines.append(f"  [{status.value.upper()}]")
+                for p in projs:
+                    hours = self.total_hours(p.name)
+                    progress = f" {p.progress:.0%}" if p.goals else ""
+                    lines.append(f"    {p.name} — {hours:.1f}h{progress}")
+                lines.append("")
+
+        return "\n".join(lines)