studystreak 0.1.0__py3-none-any.whl

studystreak/accounts.py

@@ -0,0 +1,192 @@
+import json
+import re
+from pathlib import Path
+from typing import Any
+
+from cryptography.fernet import InvalidToken
+
+from studystreak.security import (
+    hash_password,
+    verify_password,
+    generate_salt,
+    encrypt_text,
+    decrypt_text,
+)
+
+
+ACCOUNTS_FILE = Path("accounts.json")
+
+def get_empty_private_data() -> dict[str, Any]:
+    return{
+        "sessions": [],
+        "weekly_goal": 300,
+        "subjects": [],
+        "subject_websites": {},
+        "leaderboard_opt_in": False,
+        "public_summary": {
+            "weekly_minutes": 0,
+            "current_streak": 0,
+            "average_focsu_score": 0,
+        },
+    }
+
+def get_default_accounts_data() -> dict[str, Any]:
+    return {
+        "current_user": None,
+        "users": {},
+    }
+
+def load_account_data() -> dict[str, Any]:
+    if not ACCOUNTS_FILE.exists():
+        return get_default_accounts_data()
+    
+    try:
+        with open(ACCOUNTS_FILE, "r", encoding="utf-8") as file:
+            data = json.load(file)
+    except json.JSONDecodeError:
+        return get_default_accounts_data()
+
+    if "current_user" not in data:
+        data["current_user"] = None
+    
+    if "users" not in data:
+        data["users"] = {}
+    
+    return data
+
+def save_accounts_data(data: dict[str, Any]) -> None:
+    with open(ACCOUNTS_FILE, "w", encoding="utf-8") as file:
+        json.dump(data, file, indent=4)
+    
+
+def normalise_username(username: str) -> str:
+    return username.strip().lower()
+
+def validate_username(username: str) -> None:
+    if username == "":
+        raise ValueError("Username cannot be empty")
+    
+    if len(username) < 3:
+        raise ValueError("Username must be at least 3 characters long.")
+    
+    if len(username) > 24:
+        raise ValueError("Username must be 24 characters or fewer.")
+
+    if not re.fullmatch(r"[a-zA-Z0-9_-]+", username):
+        raise ValueError("Username can only contain letters, numbers, underscores and hyphens.")
+
+def validate_password(password: str) -> None:
+    if len(password) < 8:
+        raise ValueError("Password must be at least 8 characters long.")
+    if len(password) > 128:
+        raise ValueError("Password must be 128 characters or fewer.")
+    
+    if password.strip() == "":
+        raise ValueError("Password cannot be blank.")
+
+def create_account(username: str, password: str, display_name: str | None = None) -> None:
+    username = normalise_username(username)
+    validate_username(username)
+    validate_password(password)
+
+    data = load_account_data()
+
+    if username in data["users"]:
+        raise ValueError("That username already exist.")
+    
+    encryption_salt = generate_salt()
+    private_data = get_empty_private_data()
+    private_data_json = json.dumps(private_data)
+
+    encrypted_private_data = encrypt_text(
+        text=private_data_json,
+        password=password,
+        salt=encryption_salt,
+    )
+
+    data["users"][username] = {
+        "display_name": display_name.strip() if display_name else username,
+        "password_hash": hash_password(password),
+        "encryption_salt": encryption_salt,
+        "encrypted_private_data": encrypted_private_data,
+    }
+
+    if data["current_user"] is None:
+        data["current_user"] = username
+    
+    save_accounts_data(data)
+
+
+def login_account(username: str, password: str) -> dict[str, Any]:
+    username = normalise_username(username)
+    data = load_account_data()
+
+    if username not in data["users"]:
+        raise ValueError("Username or password is incorrect.")
+    
+    user_record = data["users"][username]
+
+    password_is_valid = verify_password(
+        password_hash=user_record["password_hash"],
+        password=password,
+    )
+
+    if not password_is_valid:
+        raise ValueError("Username or password is incorrect.")
+    
+    try:
+        decrypt_json = decrypt_text(
+            encrypted_text=user_record["encrypted_private_data"],
+            password=password,
+            salt=user_record["encryption_salt"],
+        )
+
+    except InvalidToken:
+        raise ValueError("Could not decrypt user data. The password may be incorrect.")
+    
+    private_data = json.loads(decrypt_json)
+
+    data["current_user"] = username
+    save_accounts_data(data)
+
+    return private_data
+
+def save_user_private_data(username: str, password: str, private_data: dict[str, Any]) -> None:
+    username = normalise_username(username)
+    data = load_account_data()
+
+    if username not in data["users"]:
+        raise ValueError("User does not exist")
+    
+    user_record = data["users"][username]
+
+    if not verify_password(user_record["password_hash"], password):
+        raise ValueError("Password is incorrect")
+    
+    private_data_json = json.dumps(private_data)
+
+    encrypted_private_data = encrypt_text(
+        text=private_data_json,
+        password=password,
+        salt=user_record["encryption_salt"],
+    )
+
+    user_record["encrypted_private_data"] = encrypted_private_data
+    save_accounts_data(data)
+
+def get_current_user() -> str | None:
+    data = load_account_data()
+    return data["current_user"]
+
+def list_accounts() -> list[str]:
+    data = load_account_data()
+    return sorted(data["users"].keys())
+
+def logout_account() -> None:
+    data = load_account_data()
+    data["current_user"] = None
+    save_accounts_data(data)
+
+
+    
+

studystreak/api_client.py

@@ -0,0 +1,292 @@
+import os
+from pathlib import Path
+
+from dotenv import load_dotenv
+import requests
+
+
+PROJECT_ROOT = Path(__file__).resolve().parents[1]
+load_dotenv(PROJECT_ROOT / ".env")
+
+BASE_URL = os.getenv("STUDYSTREAK_API_URL", "http://127.0.0.1:8000")
+
+
+def get_error_detail(response: requests.Response) -> str:
+    #return the useful FastAPI error instead of hiding it behind a generic message
+    try:
+        data = response.json()
+    except ValueError:
+        return response.text.strip() or response.reason
+
+    detail = data.get("detail")
+
+    if isinstance(detail, str):
+        return detail
+
+    if isinstance(detail, list):
+        messages = []
+
+        for item in detail:
+            if isinstance(item, dict):
+                message = item.get("msg", str(item))
+                location = item.get("loc", [])
+
+                if location:
+                    messages.append(f"{'.'.join(str(part) for part in location)}: {message}")
+                else:
+                    messages.append(message)
+            else:
+                messages.append(str(item))
+
+        return "; ".join(messages)
+
+    if detail is not None:
+        return str(detail)
+
+    return response.text.strip() or response.reason
+
+
+def raise_server_error(action: str, response: requests.Response) -> None:
+    detail = get_error_detail(response)
+    raise ValueError(f"{action} failed ({response.status_code}): {detail}")
+
+
+def login_to_server(username: str, password: str) -> str:
+    #login to backend server
+    try:
+        response = requests.post(
+            f"{BASE_URL}/login",
+            json={
+                "username": username,
+                "password": password,
+            },
+            timeout=10,
+        )
+
+    except requests.RequestException as error:
+        raise ValueError(f"Could not connect to server at {BASE_URL}: {error}") from error
+
+    if response.status_code != 200:
+        raise_server_error("Server login", response)
+
+    data = response.json()
+    return data["access_token"]
+
+
+def signup_to_server(username: str, password: str, display_name: str | None = None) -> None:
+    #create backend server account
+    try:
+        response = requests.post(
+            f"{BASE_URL}/signup",
+            json={
+                "username": username,
+                "password": password,
+                "display_name": display_name,
+            },
+            timeout=10,
+        )
+
+    except requests.RequestException as error:
+        raise ValueError(f"Could not connect to server at {BASE_URL}: {error}") from error
+
+    if response.status_code != 200:
+        raise_server_error("Server signup", response)
+
+
+def upload_focus_session(token: str, subject: str, minutes: int, website: str | None) -> None:
+    #upload completed focus session
+    try:
+        response = requests.post(
+            f"{BASE_URL}/focus-sessions",
+            headers={
+                "Authorization": f"Bearer {token}",
+            },
+            json={
+                "subject": subject,
+                "minutes": minutes,
+                "website": website,
+                "completed": True,
+                "source": "focus_cli",
+            },
+            timeout=10,
+        )
+
+    except requests.RequestException as error:
+        raise ValueError(f"Could not connect to server at {BASE_URL}: {error}") from error
+
+    if response.status_code != 200:
+        raise_server_error("Focus upload", response)
+
+
+def get_leaderboard(period="all") -> list[dict]:
+    #get server leaderboard
+    try:
+        response = requests.get(
+            f"{BASE_URL}/leaderboard",
+            params={"period": period},
+            timeout=10,
+        )
+
+    except requests.RequestException as error:
+        raise ValueError(f"Could not connect to server at {BASE_URL}: {error}") from error
+
+    if response.status_code != 200:
+        raise_server_error("Leaderboard load", response)
+
+    return response.json()
+
+
+def check_server_status() -> bool:
+    #check if backend server is online
+    try:
+        response = requests.get(
+            f"{BASE_URL}/",
+            timeout=5,
+        )
+
+        return response.status_code == 200
+
+    except requests.RequestException:
+        return False
+    
+def get_profile_data(token: str) -> str | None:
+    #get encrypted profile data from server
+    try:
+        response = requests.get(
+            f"{BASE_URL}/profile-data",
+            headers={
+                "Authorization": f"Bearer {token}",
+            },
+            timeout=10,
+        )
+
+    except requests.RequestException as error:
+        raise ValueError(f"Could not connect to server at {BASE_URL}: {error}") from error
+
+    if response.status_code != 200:
+        raise_server_error("Profile load", response)
+
+    data = response.json()
+    return data["encrypted_profile_data"]
+
+
+def upload_profile_data(token: str, encrypted_profile_data: str) -> None:
+    #upload encrypted profile data to server
+    try:
+        response = requests.put(
+            f"{BASE_URL}/profile-data",
+            headers={
+                "Authorization": f"Bearer {token}",
+            },
+            json={
+                "encrypted_profile_data": encrypted_profile_data,
+            },
+            timeout=10,
+        )
+
+    except requests.RequestException as error:
+        raise ValueError(f"Could not connect to server at {BASE_URL}: {error}") from error
+
+    if response.status_code != 200:
+        raise_server_error("Profile upload", response)
+
+
+def upload_subjects(token: str, subjects: list[str]) -> None:
+    #upload subject list for the Chrome extension
+    try:
+        response = requests.put(
+            f"{BASE_URL}/subjects",
+            headers={
+                "Authorization": f"Bearer {token}",
+            },
+            json={
+                "subjects": subjects,
+            },
+            timeout=10,
+        )
+
+    except requests.RequestException as error:
+        raise ValueError(f"Could not connect to server at {BASE_URL}: {error}") from error
+
+    if response.status_code != 200:
+        raise_server_error("Subject sync", response)
+
+
+def upload_subject_websites(token: str, subject_websites: dict[str, list[str]]) -> None:
+    #upload subject website lists for the Chrome extension
+    try:
+        response = requests.put(
+            f"{BASE_URL}/subject-websites",
+            headers={
+                "Authorization": f"Bearer {token}",
+            },
+            json={
+                "subject_websites": subject_websites,
+            },
+            timeout=10,
+        )
+
+    except requests.RequestException as error:
+        raise ValueError(f"Could not connect to server at {BASE_URL}: {error}") from error
+
+    if response.status_code != 200:
+        raise_server_error("Subject website sync", response)
+
+
+def upload_timetable(token: str, timetable: list[dict]) -> None:
+    #upload timetable list for Chrome extension reminders
+    try:
+        response = requests.put(
+            f"{BASE_URL}/timetable",
+            headers={
+                "Authorization": f"Bearer {token}",
+            },
+            json={
+                "timetable": timetable,
+            },
+            timeout=10,
+        )
+
+    except requests.RequestException as error:
+        raise ValueError(f"Could not connect to server at {BASE_URL}: {error}") from error
+
+    if response.status_code != 200:
+        raise_server_error("Timetable sync", response)
+
+
+def get_focus_quality_sessions(token: str) -> list[dict]:
+    #download rich Chrome focus-quality summaries for the logged-in user
+    try:
+        response = requests.get(
+            f"{BASE_URL}/focus-quality-sessions",
+            headers={
+                "Authorization": f"Bearer {token}",
+            },
+            timeout=10,
+        )
+
+    except requests.RequestException as error:
+        raise ValueError(f"Could not connect to server at {BASE_URL}: {error}") from error
+
+    if response.status_code != 200:
+        raise_server_error("Focus quality sync", response)
+
+    return response.json()
+
+def upload_streak(token: str, current_streak: int) -> None:
+    try:
+        response = requests.put(
+            f"{BASE_URL}/streak",
+            headers={
+                "Authorization": f"Bearer {token}",
+            },
+            json={
+                "current_streak": current_streak,
+            },
+            timeout=10,
+        )
+    except requests.RequestException as error:
+        raise ValueError(f"Could not connect to server at {BASE_URL}: {error}") from error
+    
+    if response.status_code !=200:
+        raise_server_error("Streak sync", response)