studylife-cli 1.3.0__py3-none-any.whl

studylife_cli/client.py

@@ -0,0 +1,169 @@
+"""Typed HTTP client for the StudyLife REST API, scoped to what
+ApiKeyScopes.PubliclyGrantable actually allows a third-party client to do.
+
+No internal-CA-trust handling here (unlike studylife-mcp's client.py) - this talks to the
+instance's public-facing HTTPS endpoint, the same one a browser would use, so plain httpx
+default TLS verification is enough.
+"""
+
+from __future__ import annotations
+
+import httpx
+
+from studylife_cli.models import (
+    Course,
+    CourseGoal,
+    Note,
+    Session,
+    StudyProgramDetail,
+    StudyProgramSummary,
+    TimerState,
+    Webhook,
+)
+
+
+class ApiError(Exception):
+    """Raised for any non-2xx response, carrying the status code and response body."""
+
+    def __init__(self, status_code: int, body: str) -> None:
+        super().__init__(f"StudyLife API returned {status_code}: {body.strip()}")
+        self.status_code = status_code
+        self.body = body
+
+
+class StudyLifeClient:
+    def __init__(self, instance_url: str, api_key: str, timeout: float = 15.0) -> None:
+        self._http = httpx.Client(
+            base_url=instance_url.rstrip("/"),
+            headers={"X-Api-Key": api_key},
+            timeout=timeout,
+        )
+
+    def close(self) -> None:
+        self._http.close()
+
+    def __enter__(self) -> StudyLifeClient:
+        return self
+
+    def __exit__(self, *exc_info: object) -> None:
+        self.close()
+
+    def _request(self, method: str, path: str, **kwargs: object) -> httpx.Response:
+        response = self._http.request(method, path, **kwargs)
+        if response.status_code >= 400:
+            raise ApiError(response.status_code, response.text)
+        return response
+
+    # -- Notes ------------------------------------------------------------------
+
+    def list_notes(self) -> list[Note]:
+        return [Note.model_validate(item) for item in self._request("GET", "/api/notes").json()]
+
+    def search_notes(self, query: str) -> list[Note]:
+        response = self._request("GET", "/api/notes/search", params={"q": query})
+        return [Note.model_validate(item) for item in response.json()]
+
+    def create_note(self, note: Note) -> Note:
+        response = self._request(
+            "POST",
+            "/api/notes",
+            json=note.model_dump(mode="json", by_alias=True, exclude_none=True),
+        )
+        return Note.model_validate(response.json())
+
+    def update_note(self, note_id: int, note: Note) -> Note:
+        response = self._request(
+            "PUT",
+            f"/api/notes/{note_id}",
+            json=note.model_dump(mode="json", by_alias=True, exclude_none=True),
+        )
+        return Note.model_validate(response.json())
+
+    def delete_note(self, note_id: int) -> None:
+        self._request("DELETE", f"/api/notes/{note_id}")
+
+    # -- Sessions -----------------------------------------------------------------
+
+    def list_sessions(self) -> list[Session]:
+        return [
+            Session.model_validate(item) for item in self._request("GET", "/api/sessions").json()
+        ]
+
+    def session_history(
+        self, days: int | None = None, only_completed: bool | None = None
+    ) -> list[Session]:
+        params: dict[str, object] = {}
+        if days is not None:
+            params["days"] = days
+        if only_completed is not None:
+            params["onlyCompleted"] = only_completed
+        response = self._request("GET", "/api/sessions/history", params=params)
+        return [Session.model_validate(item) for item in response.json()]
+
+    def create_session(self, session: Session) -> Session:
+        response = self._request(
+            "POST",
+            "/api/sessions",
+            json=session.model_dump(mode="json", by_alias=True, exclude_none=True),
+        )
+        return Session.model_validate(response.json())
+
+    def update_session(self, session_id: int, session: Session) -> Session:
+        response = self._request(
+            "PUT",
+            f"/api/sessions/{session_id}",
+            json=session.model_dump(mode="json", by_alias=True, exclude_none=True),
+        )
+        return Session.model_validate(response.json())
+
+    def delete_session(self, session_id: int) -> None:
+        self._request("DELETE", f"/api/sessions/{session_id}")
+
+    # -- Course goals ---------------------------------------------------------------
+
+    def list_course_goals(self) -> list[CourseGoal]:
+        response = self._request("GET", "/api/coursegoals")
+        return [CourseGoal.model_validate(item) for item in response.json()]
+
+    def save_course_goal(self, course_id: int, goal: CourseGoal) -> CourseGoal:
+        response = self._request(
+            "PUT",
+            f"/api/coursegoals/{course_id}",
+            json=goal.model_dump(mode="json", by_alias=True, exclude_none=True),
+        )
+        return CourseGoal.model_validate(response.json())
+
+    def delete_course_goal(self, course_id: int) -> None:
+        self._request("DELETE", f"/api/coursegoals/{course_id}")
+
+    # -- Timer / courses / study programs (read-only) -------------------------------
+
+    def get_timer_state(self) -> TimerState:
+        return TimerState.model_validate(self._request("GET", "/api/timerstate").json())
+
+    def list_courses(self) -> list[Course]:
+        return [Course.model_validate(item) for item in self._request("GET", "/api/courses").json()]
+
+    def list_study_programs(self) -> list[StudyProgramSummary]:
+        response = self._request("GET", "/api/studyprograms")
+        return [StudyProgramSummary.model_validate(item) for item in response.json()]
+
+    def get_study_program(self, program_id: int) -> StudyProgramDetail:
+        response = self._request("GET", f"/api/studyprograms/{program_id}")
+        return StudyProgramDetail.model_validate(response.json())
+
+    # -- Webhooks -------------------------------------------------------------------
+
+    def list_webhooks(self) -> list[Webhook]:
+        return [
+            Webhook.model_validate(item) for item in self._request("GET", "/api/webhooks").json()
+        ]
+
+    def create_webhook(self, target_url: str, events: list[str]) -> Webhook:
+        response = self._request(
+            "POST", "/api/webhooks", json={"targetUrl": target_url, "events": events}
+        )
+        return Webhook.model_validate(response.json())
+
+    def delete_webhook(self, webhook_id: str) -> None:
+        self._request("DELETE", f"/api/webhooks/{webhook_id}")

studylife_cli/credentials.py

@@ -0,0 +1,54 @@
+"""Local credential storage for `studylife login`.
+
+Deliberately plaintext, like every other satellite's own key store in this ecosystem
+(studylife-developers' KeyStore, studylife-mcp's .env) - the key this file holds is already
+narrowly scoped by ApiKeyScopes.PubliclyGrantable server-side (no settings writes, no admin
+actions possible even if this file leaked), not a master credential.
+
+Uses a global config directory rather than a per-directory .env (unlike studylife-mcp, which
+always runs from one project checkout) - a CLI is invoked from anywhere, so `studylife notes list`
+needs to find the same credential regardless of the current working directory.
+"""
+
+from __future__ import annotations
+
+import contextlib
+import os
+import stat
+from pathlib import Path
+
+from pydantic import BaseModel
+
+
+def default_credentials_path() -> Path:
+    config_home = os.environ.get("XDG_CONFIG_HOME")
+    base = Path(config_home) if config_home else Path.home() / ".config"
+    return base / "studylife-cli" / "credentials.json"
+
+
+class Credentials(BaseModel):
+    instance_url: str
+    client_id: str
+    api_key: str
+
+
+def load_credentials(path: Path | None = None) -> Credentials | None:
+    path = path or default_credentials_path()
+    if not path.exists():
+        return None
+    return Credentials.model_validate_json(path.read_text(encoding="utf-8"))
+
+
+def save_credentials(credentials: Credentials, path: Path | None = None) -> None:
+    path = path or default_credentials_path()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(credentials.model_dump_json(indent=2), encoding="utf-8")
+    # Best-effort on POSIX (no-op on Windows, which has no chmod bit semantics here) -
+    # restrict to the owner only, same intent as ssh's own ~/.ssh/id_* permissions.
+    with contextlib.suppress(OSError):
+        path.chmod(stat.S_IRUSR | stat.S_IWUSR)
+
+
+def clear_credentials(path: Path | None = None) -> None:
+    path = path or default_credentials_path()
+    path.unlink(missing_ok=True)

studylife_cli/login.py

@@ -0,0 +1,246 @@
+"""Browser-based login (`studylife login`).
+
+Ported from studylife-mcp's own login.py (same repo family, see that file for the original
+identity-contract-v1 §2 round trip this generalizes), with two real differences:
+
+1. Talks to the GENERIC dynamic-client flow (`/connect/client/{client_id}`, `POST
+   /api/auth/connect`/`/api/auth/assertion-exchange`) instead of the hardcoded "mcp" audience -
+   piggybacking on "mcp" would rotate studylife-mcp's own shared key slot out from under it.
+2. Binds one of a small FIXED set of candidate loopback ports instead of an OS-assigned random
+   one. The generic flow validates redirect_uri by EXACT match against the client's own
+   registered AllowedRedirectUris (stricter than the old audiences' blanket https-or-loopback
+   check) - a random port could never match a single pre-registered URI, so this client is
+   registered (once, via studylife-developers) with several fixed candidate ports instead, and
+   tries each in turn until one is free.
+"""
+
+from __future__ import annotations
+
+import hmac
+import secrets
+import sys
+import webbrowser
+from collections.abc import Callable
+from dataclasses import dataclass
+from http.server import BaseHTTPRequestHandler, HTTPServer
+from urllib.parse import parse_qs, urlencode, urlparse
+
+import httpx
+
+from studylife_cli.credentials import Credentials, save_credentials
+
+# Fixed candidate ports, tried in order - must match (a subset of) the AllowedRedirectUris
+# registered for this ClientId on the target instance. Kept small and low-numbered enough to
+# rarely collide with something else already running locally.
+CANDIDATE_PORTS = (8765, 8766, 8767, 8768)
+
+CALLBACK_TIMEOUT_SECONDS = 300.0
+
+DEFAULT_CLIENT_ID = "studylife-cli"
+
+
+class LoginError(Exception):
+    """Raised on any failure of the login round trip, carrying a human-readable reason."""
+
+
+@dataclass
+class CallbackResult:
+    """What the loopback callback received, before any validation - state/assertion default to
+    "" (not missing) so callers can treat "" uniformly as "not provided"."""
+
+    state: str
+    assertion: str
+
+
+def _parse_callback_query(query_string: str) -> CallbackResult:
+    query = parse_qs(query_string)
+    return CallbackResult(
+        state=query.get("state", [""])[0],
+        assertion=query.get("assertion", [""])[0],
+    )
+
+
+def _states_match(received: str, expected: str) -> bool:
+    """Constant-time comparison - the state isn't secret, but there's no reason to prefer a
+    timing-observable comparison over a safe one that's just as easy to write."""
+    return hmac.compare_digest(received, expected)
+
+
+_CALLBACK_PAGE = """<!doctype html>
+<html lang="en">
+<head><meta charset="utf-8"><title>studylife-cli login</title></head>
+<body style="font-family: sans-serif; text-align: center; padding-top: 3rem;">
+<p>Login complete &mdash; you can close this tab and return to the terminal.</p>
+</body>
+</html>
+"""
+
+
+class _CallbackState:
+    """Shared between the HTTP handler (invoked synchronously inside
+    HTTPServer.handle_request()) and the caller waiting on it - a single request is ever served
+    per listener instance, so a plain attribute is enough."""
+
+    def __init__(self) -> None:
+        self.result: CallbackResult | None = None
+
+
+def _make_handler(state: _CallbackState) -> type[BaseHTTPRequestHandler]:
+    class Handler(BaseHTTPRequestHandler):
+        def log_message(self, format: str, *args: object) -> None:
+            pass  # Silence the default stderr access log - nothing useful, just noise.
+
+        def do_GET(self) -> None:
+            parsed = urlparse(self.path)
+            if parsed.path != "/callback":
+                self.send_response(404)
+                self.end_headers()
+                return
+
+            state.result = _parse_callback_query(parsed.query)
+
+            body = _CALLBACK_PAGE.encode("utf-8")
+            self.send_response(200)
+            self.send_header("Content-Type", "text/html; charset=utf-8")
+            self.send_header("Content-Length", str(len(body)))
+            self.end_headers()
+            self.wfile.write(body)
+
+    return Handler
+
+
+class _LoopbackHTTPServer(HTTPServer):
+    """HTTPServer normally sets allow_reuse_address=1, which on Windows lets a second listener
+    silently bind the exact same port instead of raising - the opposite of what
+    `_bind_first_free_port`'s try-the-next-candidate fallback needs. Disabling it makes "is this
+    port already taken" behave the same (a real OSError) on every platform."""
+
+    allow_reuse_address = False
+
+
+class _CallbackHTTPServer:
+    """Localhost-only (127.0.0.1) HTTP listener on one of CANDIDATE_PORTS for the single
+    `/callback` request the generic consent page redirects the browser to. Serves exactly one
+    request: `wait_for_callback()` blocks until it arrives (or the given timeout elapses)."""
+
+    def __init__(self, port: int) -> None:
+        self._state = _CallbackState()
+        self._server = _LoopbackHTTPServer(("127.0.0.1", port), _make_handler(self._state))
+
+    @property
+    def port(self) -> int:
+        return int(self._server.server_address[1])
+
+    def wait_for_callback(self, timeout_seconds: float) -> CallbackResult | None:
+        self._server.timeout = timeout_seconds
+        self._server.handle_request()  # returns on request OR timeout, whichever first
+        self._server.server_close()
+        return self._state.result
+
+
+def _bind_first_free_port(candidates: tuple[int, ...]) -> _CallbackHTTPServer:
+    last_error: OSError | None = None
+    for port in candidates:
+        try:
+            return _CallbackHTTPServer(port)
+        except OSError as exc:
+            last_error = exc
+            continue
+    raise LoginError(
+        f"None of the candidate ports {list(candidates)} are free on 127.0.0.1. "
+        "Close whatever else is using them and try again."
+    ) from last_error
+
+
+def run_login(
+    *,
+    instance_url: str,
+    client_id: str = DEFAULT_CLIENT_ID,
+    candidate_ports: tuple[int, ...] = CANDIDATE_PORTS,
+    timeout_seconds: float = CALLBACK_TIMEOUT_SECONDS,
+    open_browser: Callable[[str], bool] = webbrowser.open,
+) -> Credentials:
+    """Drives one full browser login round trip and returns the resulting Credentials. Raises
+    LoginError on any failure - callers decide how to present that (CLI prints and exits 1)."""
+    base_url = instance_url.rstrip("/")
+    state_token = secrets.token_urlsafe(32)
+
+    callback_server = _bind_first_free_port(candidate_ports)
+    redirect_uri = f"http://127.0.0.1:{callback_server.port}/callback"
+    connect_url = (
+        f"{base_url}/connect/client/{client_id}?"
+        f"{urlencode({'redirect_uri': redirect_uri, 'state': state_token})}"
+    )
+
+    print(f"Opening your browser to log in to StudyLife:\n  {connect_url}")
+    print("Waiting for you to finish logging in and approving the connection...")
+    open_browser(connect_url)
+
+    result = callback_server.wait_for_callback(timeout_seconds)
+    if result is None:
+        raise LoginError(
+            f"Timed out after {int(timeout_seconds)}s waiting for StudyLife to redirect back. "
+            "Either the login/approval wasn't completed in the browser tab, or this client "
+            f"isn't registered on that instance yet - see the README for how to register "
+            f"'{client_id}' via studylife-developers first."
+        )
+
+    if not _states_match(result.state, state_token):
+        raise LoginError(
+            "Rejected the login callback: its state didn't match what this command sent "
+            "(possible cross-request mix-up). Please run this command again."
+        )
+
+    if not result.assertion:
+        raise LoginError(
+            "StudyLife's callback didn't include a login assertion - the connection may have "
+            "been denied."
+        )
+
+    user_id, api_key = _exchange_assertion(base_url, client_id, result.assertion)
+    del user_id  # not needed locally - kept for symmetry with the server's response shape
+    return Credentials(instance_url=base_url, client_id=client_id, api_key=api_key)
+
+
+def _exchange_assertion(base_url: str, client_id: str, assertion: str) -> tuple[int, str]:
+    """Server-to-server exchange of the single-use assertion for the user id and a freshly
+    issued, per-installation API key (generic flow - AuthController.10.OAuthClients.cs). No
+    X-Api-Key is sent: this endpoint is [AllowAnonymous] by design, the assertion itself is the
+    one-time credential."""
+    try:
+        response = httpx.post(
+            f"{base_url}/api/auth/assertion-exchange",
+            json={"clientId": client_id, "assertion": assertion},
+            timeout=10.0,
+        )
+    except httpx.HTTPError as exc:
+        raise LoginError(f"Could not reach StudyLife: {exc}") from exc
+
+    if response.status_code != 200:
+        raise LoginError(
+            f"StudyLife rejected the login ({response.status_code}): {response.text.strip()}"
+        )
+
+    try:
+        data = response.json()
+        return int(data["userId"]), str(data["apiKey"])
+    except (KeyError, TypeError, ValueError) as exc:
+        raise LoginError("StudyLife returned an unexpected response shape.") from exc
+
+
+def login_and_save(instance_url: str, client_id: str = DEFAULT_CLIENT_ID) -> Credentials:
+    credentials = run_login(instance_url=instance_url, client_id=client_id)
+    save_credentials(credentials)
+    return credentials
+
+
+if __name__ == "__main__":
+    if len(sys.argv) < 2:
+        print("usage: python -m studylife_cli.login <instance-url>", file=sys.stderr)
+        sys.exit(1)
+    try:
+        creds = login_and_save(sys.argv[1])
+    except LoginError as exc:
+        print(f"Login failed: {exc}", file=sys.stderr)
+        sys.exit(1)
+    print(f"Login successful - credentials saved for {creds.instance_url}.")

studylife_cli/models.py

@@ -0,0 +1,109 @@
+"""Pydantic models mirroring StudyLife's actual OpenAPI schemas (fetched live from
+`/openapi/v1.json` and cross-checked against StudyLife.Shared/Dtos.cs - not reconstructed from
+memory, which previously produced wrong field names for StudySessionDto/CourseGoalDto).
+
+Field names use snake_case here and are translated to/from the server's camelCase JSON via
+StudyLifeModel's alias generator.
+"""
+
+from __future__ import annotations
+
+from datetime import datetime
+
+from pydantic import BaseModel, ConfigDict
+from pydantic.alias_generators import to_camel
+
+
+class StudyLifeModel(BaseModel):
+    model_config = ConfigDict(alias_generator=to_camel, populate_by_name=True)
+
+
+class Course(StudyLifeModel):
+    id: int
+    semester: int = 1
+    name: str
+    code: str = ""
+    color: str = "#6C5CE7"
+    icon: str = ""
+    topics: list[str] = []
+    ects: int = 5
+    group: str | None = None
+
+
+class Note(StudyLifeModel):
+    id: int | None = None
+    title: str
+    content: str
+    created_at: datetime | None = None
+    updated_at: datetime | None = None
+    course_id: int | None = None
+    session_id: int | None = None
+    is_markdown: bool = False
+    source_url: str | None = None
+    tags: str | None = None
+    summary: str | None = None
+    related_note_ids: list[int] = []
+
+
+class Session(StudyLifeModel):
+    id: int | None = None
+    course_id: int
+    # Ignored by the server for a brand-new session (re-derived from the resolved course) and
+    # frozen/untouched for an existing one - only required to be non-empty by validation, its
+    # actual content never matters once course_id is valid. See SessionsController.Validate.
+    course_name: str = "-"
+    course_color: str | None = None
+    start_time: datetime
+    end_time: datetime
+    topic: str | None = None
+    notes: str | None = None
+    is_completed: bool = False
+    timer_mode_id: int = 0
+    recurrence_group_id: str | None = None
+
+
+class CourseGoal(StudyLifeModel):
+    course_id: int
+    # Same "required non-empty, content ignored/frozen server-side" situation as
+    # Session.course_name above - see CourseGoalsController.Save.
+    course_name: str = "-"
+    target_date: datetime | None = None
+    completion_note: str | None = None
+    completed_at: datetime | None = None
+    grade: float | None = None
+    completed_topics: str = ""
+    tag: str | None = None
+
+
+class TimerState(StudyLifeModel):
+    session_id: int | None = None
+    is_running: bool
+    is_break: bool
+    current_round: int
+    timer_mode_id: int
+    phase_ends_at: datetime | None = None
+    updated_at: datetime | None = None
+    server_now: datetime | None = None
+
+
+class StudyProgramSummary(StudyLifeModel):
+    id: int | None = None
+    name: str
+    is_built_in: bool
+    is_completed: bool
+
+
+class StudyProgramDetail(StudyLifeModel):
+    id: int
+    name: str
+    group_ects_quotas: dict[str, int] = {}
+
+
+class Webhook(StudyLifeModel):
+    """studylife-webhooks' own WebhookOut shape (id is a string there, not an int) - the server's
+    WebhooksProxyController is a pure, un-typed reverse proxy for this, so it never appears in
+    StudyLife's own OpenAPI document."""
+
+    id: str | None = None
+    target_url: str
+    events: list[str]

studylife_cli-1.3.0.dist-info/METADATA

@@ -0,0 +1,98 @@
+Metadata-Version: 2.5
+Name: studylife-cli
+Version: 1.3.0
+Summary: Command-line client for StudyLife (self-hosted study organizer) - notes, sessions, course goals, and webhooks from your terminal.
+License-File: LICENSE
+Requires-Python: >=3.12
+Requires-Dist: httpx>=0.27
+Requires-Dist: pydantic-settings>=2.6
+Requires-Dist: pydantic>=2.9
+Requires-Dist: rich>=13.9
+Requires-Dist: typer>=0.15
+Description-Content-Type: text/markdown
+
+# studylife-cli
+
+A command-line client for [StudyLife](https://github.com/lukislp/studylife), the self-hosted
+study organizer. Manage notes, sessions, course goals, and webhooks from your terminal - scripts
+and shells welcome.
+
+## Install
+
+```bash
+pip install git+https://github.com/lukislp/studylife-cli
+```
+
+(PyPI publishing is planned; until then, install straight from GitHub.)
+
+## Register the CLI on your instance
+
+`studylife-cli` connects to your StudyLife instance through the same add-on mechanism any
+third-party integration uses - there is no special-cased server support to set up. Register it
+once via your own [studylife-developers](https://github.com/lukislp/studylife-developers) portal:
+
+1. Open your `studylife-developers` instance and go to **Register new add-on**.
+2. Fill in:
+   - **Client ID**: `studylife-cli`
+   - **Allowed redirect URIs** (one per line):
+     ```
+     http://127.0.0.1:8765/callback
+     http://127.0.0.1:8766/callback
+     http://127.0.0.1:8767/callback
+     http://127.0.0.1:8768/callback
+     ```
+   - **Scopes**: whichever of notes/sessions/course-goals/timer/courses/study-programs/webhooks
+     you want the CLI to be able to use.
+3. Save.
+
+## Log in
+
+```bash
+studylife login https://studylife.example.com
+```
+
+This opens your browser to approve the connection, then stores a scoped API key locally at
+`~/.config/studylife-cli/credentials.json` (owner-readable only, on POSIX).
+
+## Usage
+
+```bash
+studylife notes list
+studylife notes search "exam"
+studylife notes create "Title" "Content" --course-id 1
+
+studylife sessions list
+studylife sessions history --days 7
+studylife sessions create 2026-08-30T14:00:00 --end 2026-08-30T15:00:00 --title "Focus block"
+
+studylife goals list
+studylife goals set 1 --target-ects 5
+
+studylife timer
+studylife courses list
+studylife programs list
+studylife programs get 1
+
+studylife webhooks list
+studylife webhooks create https://example.com/hook session.completed
+studylife webhooks delete 3
+```
+
+Add `--json` to any command for machine-readable output:
+
+```bash
+studylife notes list --json | jq '.[] | .title'
+```
+
+## Development
+
+```bash
+uv sync
+uv run pytest
+uv run ruff check .
+uv run ruff format --check .
+```
+
+## License
+
+AGPL-3.0

studylife_cli-1.3.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+studylife_cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+studylife_cli/_version.py,sha256=kjMXs_RelAfH3nsfXcggy4eqwR8yDdd160wJ9EHB63g,520
+studylife_cli/cli.py,sha256=3eu5Kv4gTD5tOlaAxSXIdyFBoKwrYikjBw_kmniUpck,20601
+studylife_cli/client.py,sha256=XFlWY4vmY8aDSv6zNMxpVB4WcqSrk7OD060qRavBVfw,6380
+studylife_cli/credentials.py,sha256=QsCfdwtc2opCYRsIQahlJghbD2gUNfygy715grj2emE,2007
+studylife_cli/login.py,sha256=sFUpgyoRdCqUBOWnnHiTeRpX3NYQy6IwWUtwNLnfpbc,9777
+studylife_cli/models.py,sha256=wn9TFDaJirQXtSQavT-I5ji8Sps0c18YyTq800zYp1c,3202
+studylife_cli-1.3.0.dist-info/METADATA,sha256=2vMH60uDvP7_tfZ1BPDUUfOEbqERTQN4vzjdaZ6MYj0,2652
+studylife_cli-1.3.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+studylife_cli-1.3.0.dist-info/entry_points.txt,sha256=ZUsMOnXmjztQVEWcuodc2AV7ZL-h7bzeLcrdylSLsU8,52
+studylife_cli-1.3.0.dist-info/licenses/LICENSE,sha256=hIahDEOTzuHCU5J2nd07LWwkLW7Hko4UFO__ffsvB-8,34523
+studylife_cli-1.3.0.dist-info/RECORD,,