edcli 0.1.0__tar.gz

edcli-0.1.0/PKG-INFO

@@ -0,0 +1,14 @@
+Metadata-Version: 2.3
+Name: edcli
+Version: 0.1.0
+Summary: CLI for EdStem/EdDiscussion
+Author: gluck
+Author-email: gluck <gluck@kelliher.info>
+Requires-Dist: click>=8.1
+Requires-Dist: httpx>=0.27
+Requires-Dist: rich>=13.0
+Requires-Dist: platformdirs>=4.0
+Requires-Dist: tomli-w>=1.0
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+

edcli-0.1.0/pyproject.toml

@@ -0,0 +1,30 @@
+[project]
+name = "edcli"
+version = "0.1.0"
+description = "CLI for EdStem/EdDiscussion"
+readme = "README.md"
+authors = [
+    { name = "gluck", email = "gluck@kelliher.info" }
+]
+requires-python = ">=3.13"
+dependencies = [
+    "click>=8.1",
+    "httpx>=0.27",
+    "rich>=13.0",
+    "platformdirs>=4.0",
+    "tomli-w>=1.0",
+]
+
+[project.scripts]
+edcli = "edcli.cli:cli"
+
+[build-system]
+requires = ["uv_build>=0.9.26,<0.10.0"]
+build-backend = "uv_build"
+
+[dependency-groups]
+dev = [
+    "pytest>=8.0",
+    "pytest-httpx>=0.35",
+    "ruff>=0.4",
+]

edcli-0.1.0/src/edcli/__init__.py

@@ -0,0 +1 @@
+"""EdStem Discussion CLI."""

edcli-0.1.0/src/edcli/cli.py

@@ -0,0 +1,240 @@
+"""CLI commands for edcli."""
+
+from __future__ import annotations
+
+import sys
+
+import click
+
+from edcli.config import Config
+from edcli.display import (
+    console,
+    print_categories,
+    print_course_info,
+    print_courses,
+    print_json,
+    print_thread_detail,
+    print_threads,
+)
+from edcli.exceptions import EdCliError
+
+
+@click.group()
+@click.option("--format", "output_format", type=click.Choice(["table", "json"]), default=None,
+              help="Output format (default: table)")
+@click.pass_context
+def cli(ctx: click.Context, output_format: str | None) -> None:
+    """EdStem Discussion CLI."""
+    ctx.ensure_object(dict)
+    cfg = Config.load()
+    if output_format:
+        cfg.output_format = output_format
+    ctx.obj["config"] = cfg
+
+
+def _client(ctx: click.Context):
+    from edcli.client import EdClient
+    cfg: Config = ctx.obj["config"]
+    return EdClient(cfg.require_token(), cfg.base_url)
+
+
+# -- configure -------------------------------------------------------------
+
+@cli.command()
+@click.pass_context
+def configure(ctx: click.Context) -> None:
+    """Set API token and default course (interactive)."""
+    from edcli.client import EdClient
+
+    cfg: Config = ctx.obj["config"]
+    token = click.prompt("Ed API token (JWT)", hide_input=True)
+    cfg.token = token.strip()
+
+    try:
+        with EdClient(cfg.token, cfg.base_url) as client:
+            user, courses = client.get_user()
+        console.print(f"Authenticated as [bold]{user.name}[/bold] ({user.email})")
+    except EdCliError as e:
+        console.print(f"[red]Error:[/red] {e}")
+        sys.exit(1)
+
+    if courses:
+        console.print("\nAvailable courses:")
+        for i, c in enumerate(courses, 1):
+            console.print(f"  {i}. [{c.id}] {c.code} - {c.name}")
+        choice = click.prompt(
+            "Default course number (or 0 for none)",
+            type=int,
+            default=1,
+        )
+        if 1 <= choice <= len(courses):
+            cfg.default_course_id = courses[choice - 1].id
+
+    cfg.save()
+    console.print("[green]Configuration saved.[/green]")
+
+
+# -- courses ---------------------------------------------------------------
+
+@cli.command()
+@click.pass_context
+def courses(ctx: click.Context) -> None:
+    """List enrolled courses."""
+    cfg: Config = ctx.obj["config"]
+    with _client(ctx) as client:
+        _, course_list = client.get_user()
+    if cfg.output_format == "json":
+        print_json(course_list)
+    else:
+        print_courses(course_list)
+
+
+# -- threads ---------------------------------------------------------------
+
+@cli.command()
+@click.option("-c", "--course", "course_id", type=int, default=None, help="Course ID")
+@click.option("--type", "thread_type", multiple=True,
+              type=click.Choice(["announcement", "question", "post"]),
+              help="Filter by thread type (repeatable)")
+@click.option("--category", multiple=True, help="Filter by category name (repeatable)")
+@click.option("--pinned", is_flag=True, help="Show only pinned threads")
+@click.option("--answered", is_flag=True, help="Show only answered threads")
+@click.option("--unread", is_flag=True, help="Show only unread threads")
+@click.option("--limit", "-n", type=int, default=30, help="Max threads to fetch (default 30)")
+@click.option("--sort", type=click.Choice(["new"]), default="new", help="Sort order")
+@click.pass_context
+def threads(
+    ctx: click.Context,
+    course_id: int | None,
+    thread_type: tuple[str, ...],
+    category: tuple[str, ...],
+    pinned: bool,
+    answered: bool,
+    unread: bool,
+    limit: int,
+    sort: str,
+) -> None:
+    """List discussion threads."""
+    cfg: Config = ctx.obj["config"]
+    cid = cfg.require_course(course_id)
+
+    with _client(ctx) as client:
+        items = client.list_threads(cid, limit=limit, sort=sort)
+
+    # Client-side filtering
+    if thread_type:
+        items = [t for t in items if t.type in thread_type]
+    if category:
+        cat_lower = {c.lower() for c in category}
+        items = [t for t in items if t.category.lower() in cat_lower]
+    if pinned:
+        items = [t for t in items if t.is_pinned]
+    if answered:
+        items = [t for t in items if t.is_answered or t.is_staff_answered or t.is_student_answered]
+    if unread:
+        items = [t for t in items if not t.is_seen]
+
+    if cfg.output_format == "json":
+        print_json(items)
+    else:
+        print_threads(items)
+
+
+# -- search ----------------------------------------------------------------
+
+@cli.command()
+@click.argument("query")
+@click.option("-c", "--course", "course_id", type=int, default=None, help="Course ID")
+@click.option("-n", "--limit", type=int, default=20, help="Max results (default 20)")
+@click.option("--sort", type=click.Choice(["relevance", "new"]), default="relevance")
+@click.pass_context
+def search(ctx: click.Context, query: str, course_id: int | None, limit: int, sort: str) -> None:
+    """Search discussion threads."""
+    cfg: Config = ctx.obj["config"]
+    cid = cfg.require_course(course_id)
+
+    with _client(ctx) as client:
+        results = client.search_threads(cid, query, limit=limit, sort=sort)
+
+    if cfg.output_format == "json":
+        print_json(results)
+    else:
+        print_threads(results)
+
+
+# -- thread detail ---------------------------------------------------------
+
+@cli.command()
+@click.argument("thread_id", type=int)
+@click.pass_context
+def thread(ctx: click.Context, thread_id: int) -> None:
+    """Show full thread detail with answers and comments."""
+    cfg: Config = ctx.obj["config"]
+    with _client(ctx) as client:
+        t = client.get_thread(thread_id)
+    if cfg.output_format == "json":
+        print_json(t)
+    else:
+        print_thread_detail(t)
+
+
+# -- categories ------------------------------------------------------------
+
+@cli.command()
+@click.option("-c", "--course", "course_id", type=int, default=None, help="Course ID")
+@click.pass_context
+def categories(ctx: click.Context, course_id: int | None) -> None:
+    """List discussion categories for a course."""
+    cfg: Config = ctx.obj["config"]
+    cid = cfg.require_course(course_id)
+
+    with _client(ctx) as client:
+        _, course_list = client.get_user()
+
+    course = next((c for c in course_list if c.id == cid), None)
+    if not course:
+        console.print(f"[red]Course {cid} not found in your enrollments.[/red]")
+        sys.exit(1)
+
+    if cfg.output_format == "json":
+        print_json(course.categories)
+    else:
+        print_categories(course.categories)
+
+
+# -- info ------------------------------------------------------------------
+
+@cli.command()
+@click.option("-c", "--course", "course_id", type=int, default=None, help="Course ID")
+@click.pass_context
+def info(ctx: click.Context, course_id: int | None) -> None:
+    """Show course info."""
+    cfg: Config = ctx.obj["config"]
+    cid = cfg.require_course(course_id)
+
+    with _client(ctx) as client:
+        _, course_list = client.get_user()
+
+    course = next((c for c in course_list if c.id == cid), None)
+    if not course:
+        console.print(f"[red]Course {cid} not found in your enrollments.[/red]")
+        sys.exit(1)
+
+    if cfg.output_format == "json":
+        print_json(course)
+    else:
+        print_course_info(course)
+
+
+# -- renew -----------------------------------------------------------------
+
+@cli.command()
+@click.pass_context
+def renew(ctx: click.Context) -> None:
+    """Renew/refresh the JWT token."""
+    cfg: Config = ctx.obj["config"]
+    with _client(ctx) as client:
+        new_token = client.renew_token()
+    cfg.token = new_token
+    cfg.save()
+    console.print("[green]Token renewed and saved.[/green]")

edcli-0.1.0/src/edcli/client.py

@@ -0,0 +1,106 @@
+"""Synchronous HTTP client for the EdStem API."""
+
+from __future__ import annotations
+
+import time
+
+import httpx
+
+from edcli.exceptions import ApiError, AuthenticationError
+from edcli.models import Course, Thread, User
+
+
+class EdClient:
+    """Sync EdStem API client."""
+
+    def __init__(self, token: str, base_url: str = "https://us.edstem.org"):
+        self.base_url = base_url.rstrip("/")
+        self._client = httpx.Client(
+            base_url=self.base_url,
+            headers={"X-Token": token},
+            timeout=30.0,
+        )
+
+    def close(self) -> None:
+        self._client.close()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *args):
+        self.close()
+
+    # -- low-level ---------------------------------------------------------
+
+    def _request(self, method: str, path: str, **kwargs) -> httpx.Response:
+        """Make a request with retry on 429 and 5xx."""
+        last_exc: Exception | None = None
+        for attempt in range(3):
+            try:
+                resp = self._client.request(method, path, **kwargs)
+            except httpx.TransportError as exc:
+                last_exc = exc
+                time.sleep(2**attempt)
+                continue
+
+            if resp.status_code == 401:
+                raise AuthenticationError("Token expired or invalid. Run 'edcli renew' or 'edcli configure'.")
+            if resp.status_code == 429 or resp.status_code >= 500:
+                last_exc = ApiError(resp.status_code, resp.text)
+                time.sleep(2**attempt)
+                continue
+            if resp.status_code >= 400:
+                raise ApiError(resp.status_code, resp.text)
+            return resp
+
+        raise last_exc  # type: ignore[misc]
+
+    def _get(self, path: str, **params) -> dict:
+        resp = self._request("GET", path, params=params)
+        return resp.json()
+
+    def _post(self, path: str, **kwargs) -> dict:
+        resp = self._request("POST", path, **kwargs)
+        if resp.headers.get("content-type", "").startswith("application/json"):
+            return resp.json()
+        return {}
+
+    # -- endpoints ---------------------------------------------------------
+
+    def get_user(self) -> tuple[User, list[Course]]:
+        """GET /api/user -> (user, courses)."""
+        data = self._get("/api/user")
+        user = User.from_dict(data["user"])
+        courses = [Course.from_dict(e) for e in data.get("courses", [])]
+        return user, courses
+
+    def list_threads(
+        self, course_id: int, limit: int = 30, sort: str = "new"
+    ) -> list[Thread]:
+        """GET /api/courses/{id}/threads."""
+        data = self._get(f"/api/courses/{course_id}/threads", limit=limit, sort=sort)
+        return [Thread.from_dict(t) for t in data.get("threads", [])]
+
+    def search_threads(
+        self, course_id: int, query: str, limit: int = 20, sort: str = "relevance"
+    ) -> list[Thread]:
+        """GET /api/courses/{id}/threads/search."""
+        data = self._get(
+            f"/api/courses/{course_id}/threads/search",
+            query=query,
+            limit=limit,
+            sort=sort,
+        )
+        return [Thread.from_dict(t) for t in data.get("threads", [])]
+
+    def get_thread(self, thread_id: int) -> Thread:
+        """GET /api/threads/{id}?view=1 -> thread with answers/comments."""
+        data = self._get(f"/api/threads/{thread_id}", view=1)
+        users_list = data.get("users", [])
+        users = {u["id"]: User.from_dict(u) for u in users_list}
+        return Thread.from_dict(data["thread"], users)
+
+    def renew_token(self) -> str:
+        """POST /api/renew_token -> new JWT string."""
+        data = self._post("/api/renew_token")
+        return data["token"]

edcli-0.1.0/src/edcli/config.py

@@ -0,0 +1,68 @@
+"""Config management: ~/.config/edcli/config.toml"""
+
+from __future__ import annotations
+
+import os
+import stat
+import tomllib
+from dataclasses import dataclass
+from pathlib import Path
+
+import tomli_w
+from platformdirs import user_config_dir
+
+from edcli.exceptions import ConfigError
+
+CONFIG_DIR = Path(user_config_dir("edcli"))
+CONFIG_FILE = CONFIG_DIR / "config.toml"
+
+
+@dataclass
+class Config:
+    token: str = ""
+    base_url: str = "https://us.edstem.org"
+    default_course_id: int | None = None
+    output_format: str = "table"
+
+    @classmethod
+    def load(cls) -> Config:
+        """Load config from disk, returning defaults if file doesn't exist."""
+        if not CONFIG_FILE.exists():
+            return cls()
+        with open(CONFIG_FILE, "rb") as f:
+            data = tomllib.load(f)
+        return cls(
+            token=data.get("token", ""),
+            base_url=data.get("base_url", "https://us.edstem.org"),
+            default_course_id=data.get("default_course_id"),
+            output_format=data.get("output_format", "table"),
+        )
+
+    def save(self) -> None:
+        """Save config to disk with restricted permissions."""
+        CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+        data: dict = {
+            "token": self.token,
+            "base_url": self.base_url,
+            "output_format": self.output_format,
+        }
+        if self.default_course_id is not None:
+            data["default_course_id"] = self.default_course_id
+        with open(CONFIG_FILE, "wb") as f:
+            tomli_w.dump(data, f)
+        os.chmod(CONFIG_FILE, stat.S_IRUSR | stat.S_IWUSR)
+
+    def require_token(self) -> str:
+        if not self.token:
+            raise ConfigError(
+                "No token configured. Run 'edcli configure' first."
+            )
+        return self.token
+
+    def require_course(self, course_id: int | None) -> int:
+        cid = course_id or self.default_course_id
+        if cid is None:
+            raise ConfigError(
+                "No course specified. Use -c COURSE_ID or set a default with 'edcli configure'."
+            )
+        return cid

edcli-0.1.0/src/edcli/content.py

@@ -0,0 +1,33 @@
+"""XML document to plaintext extraction."""
+
+from __future__ import annotations
+
+import html
+import re
+
+
+def strip_xml_tags(text: str) -> str:
+    """Strip XML tags from EdStem document content, returning plaintext."""
+    if not text:
+        return ""
+    # Unescape HTML entities
+    text = html.unescape(text)
+    # Remove web-snippet blocks entirely
+    text = re.sub(r"<web-snippet[^>]*>.*?</web-snippet>", "", text, flags=re.DOTALL)
+    # Replace <break/> with newline
+    text = re.sub(r"<break\s*/?>", "\n", text)
+    # Replace block-level closing tags with newlines
+    text = re.sub(r"</(?:paragraph|heading|list-item)>", "\n", text)
+    # Strip remaining tags
+    text = re.sub(r"<[^>]+>", "", text)
+    # Collapse multiple blank lines
+    text = re.sub(r"\n{3,}", "\n\n", text)
+    return text.strip()
+
+
+def truncate(text: str, max_len: int = 80) -> str:
+    """Truncate text to max_len, adding ellipsis if needed."""
+    text = text.replace("\n", " ").strip()
+    if len(text) <= max_len:
+        return text
+    return text[: max_len - 1] + "\u2026"

edcli-0.1.0/src/edcli/display.py

@@ -0,0 +1,182 @@
+"""Rich terminal rendering for edcli."""
+
+from __future__ import annotations
+
+import json
+from dataclasses import asdict
+from datetime import datetime
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+
+from edcli.content import strip_xml_tags, truncate
+from edcli.models import Category, Comment, Course, Thread
+
+console = Console()
+
+
+def _parse_ts(ts: str) -> str:
+    """Parse ISO timestamp to a short display string."""
+    if not ts:
+        return ""
+    try:
+        dt = datetime.fromisoformat(ts)
+        return dt.strftime("%Y-%m-%d %H:%M")
+    except (ValueError, TypeError):
+        return ts[:16]
+
+
+def _type_badge(thread_type: str) -> Text:
+    colors = {"announcement": "bold magenta", "question": "bold cyan", "post": "bold green"}
+    return Text(thread_type, style=colors.get(thread_type, ""))
+
+
+def _status_icons(t: Thread) -> str:
+    parts = []
+    if t.is_pinned:
+        parts.append("pinned")
+    if t.is_answered or t.is_staff_answered:
+        parts.append("answered")
+    elif t.is_student_answered:
+        parts.append("student-answered")
+    if t.is_endorsed:
+        parts.append("endorsed")
+    if t.is_locked:
+        parts.append("locked")
+    if not t.is_seen:
+        parts.append("NEW")
+    return " ".join(parts)
+
+
+# -- JSON output -----------------------------------------------------------
+
+def print_json(data) -> None:
+    """Print any data as JSON."""
+    if hasattr(data, "__iter__") and not isinstance(data, dict):
+        items = [asdict(item) if hasattr(item, "__dataclass_fields__") else item for item in data]
+        console.print_json(json.dumps(items, default=str))
+    elif hasattr(data, "__dataclass_fields__"):
+        console.print_json(json.dumps(asdict(data), default=str))
+    else:
+        console.print_json(json.dumps(data, default=str))
+
+
+# -- Courses ---------------------------------------------------------------
+
+def print_courses(courses: list[Course]) -> None:
+    table = Table(title="Enrolled Courses")
+    table.add_column("ID", style="cyan", justify="right")
+    table.add_column("Code", style="bold")
+    table.add_column("Name")
+    table.add_column("Session")
+    table.add_column("Role", style="green")
+    table.add_column("Status")
+    for c in courses:
+        table.add_row(str(c.id), c.code, c.name, f"{c.session} {c.year}".strip(), c.role, c.status)
+    console.print(table)
+
+
+# -- Threads list ----------------------------------------------------------
+
+def print_threads(threads: list[Thread]) -> None:
+    table = Table(title=f"Threads ({len(threads)})")
+    table.add_column("#", style="dim", justify="right")
+    table.add_column("Type", width=14)
+    table.add_column("Title", max_width=50)
+    table.add_column("Category", style="yellow", max_width=25)
+    table.add_column("Replies", justify="right")
+    table.add_column("Votes", justify="right")
+    table.add_column("Status", max_width=30)
+    table.add_column("Date", style="dim")
+    for t in threads:
+        table.add_row(
+            str(t.number),
+            _type_badge(t.type),
+            truncate(t.title, 50),
+            truncate(t.category, 25),
+            str(t.reply_count),
+            str(t.vote_count),
+            _status_icons(t),
+            _parse_ts(t.created_at),
+        )
+    console.print(table)
+
+
+# -- Thread detail ---------------------------------------------------------
+
+def _render_comment(c: Comment, indent: int = 0) -> None:
+    prefix = "  " * indent
+    style = "bold green" if c.is_endorsed else ""
+    endorsed = " [endorsed]" if c.is_endorsed else ""
+    resolved = " [resolved]" if c.is_resolved else ""
+    header = f"{prefix}{c.user_name or f'User {c.user_id}'} ({_parse_ts(c.created_at)}){endorsed}{resolved}"
+    console.print(header, style=style)
+
+    body = c.document or strip_xml_tags(c.content)
+    if body:
+        for line in body.splitlines():
+            console.print(f"{prefix}  {line}")
+    if c.vote_count:
+        console.print(f"{prefix}  [{c.vote_count} votes]", style="dim")
+    console.print()
+
+    for reply in c.comments:
+        _render_comment(reply, indent + 1)
+
+
+def print_thread_detail(t: Thread) -> None:
+    # Header panel
+    status = _status_icons(t)
+    subtitle = f"#{t.number} | {t.type} | {t.category}"
+    if t.subcategory:
+        subtitle += f" > {t.subcategory}"
+    meta_lines = [
+        f"By: {t.user_name or f'User {t.user_id}'}  |  {_parse_ts(t.created_at)}",
+        f"Views: {t.view_count}  |  Votes: {t.vote_count}  |  Replies: {t.reply_count}",
+    ]
+    if status:
+        meta_lines.append(f"Status: {status}")
+    body = t.document or strip_xml_tags(t.content)
+    content = "\n".join(meta_lines) + "\n\n" + body
+    console.print(Panel(content, title=t.title, subtitle=subtitle, expand=True))
+
+    # Answers
+    if t.answers:
+        console.print(f"\n[bold]Answers ({len(t.answers)}):[/bold]")
+        for a in t.answers:
+            _render_comment(a)
+
+    # Comments
+    if t.comments:
+        console.print(f"\n[bold]Comments ({len(t.comments)}):[/bold]")
+        for c in t.comments:
+            _render_comment(c)
+
+
+# -- Categories ------------------------------------------------------------
+
+def print_categories(categories: list[Category]) -> None:
+    table = Table(title="Discussion Categories")
+    table.add_column("Category", style="bold yellow")
+    table.add_column("Subcategories")
+    for cat in categories:
+        subs = ", ".join(cat.subcategories) if cat.subcategories else "-"
+        table.add_row(cat.name, subs)
+    console.print(table)
+
+
+# -- Course info -----------------------------------------------------------
+
+def print_course_info(course: Course) -> None:
+    lines = [
+        f"[bold]ID:[/bold] {course.id}",
+        f"[bold]Code:[/bold] {course.code}",
+        f"[bold]Name:[/bold] {course.name}",
+        f"[bold]Session:[/bold] {course.session} {course.year}",
+        f"[bold]Status:[/bold] {course.status}",
+        f"[bold]Role:[/bold] {course.role}",
+        f"[bold]Categories:[/bold] {len(course.categories)}",
+    ]
+    console.print(Panel("\n".join(lines), title=course.code))

edcli-0.1.0/src/edcli/exceptions.py

@@ -0,0 +1,21 @@
+"""Exception hierarchy for edcli."""
+
+
+class EdCliError(Exception):
+    """Base exception for edcli."""
+
+
+class ConfigError(EdCliError):
+    """Configuration missing or invalid."""
+
+
+class AuthenticationError(EdCliError):
+    """Token invalid or expired."""
+
+
+class ApiError(EdCliError):
+    """API returned an error response."""
+
+    def __init__(self, status_code: int, message: str = ""):
+        self.status_code = status_code
+        super().__init__(f"HTTP {status_code}: {message}" if message else f"HTTP {status_code}")

edcli-0.1.0/src/edcli/models.py

@@ -0,0 +1,192 @@
+"""Data models for EdStem API responses."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+
+@dataclass
+class User:
+    id: int
+    name: str
+    email: str = ""
+    role: str = ""
+    course_role: str | None = None
+    avatar: str | None = None
+
+    @classmethod
+    def from_dict(cls, d: dict) -> User:
+        return cls(
+            id=d["id"],
+            name=d.get("name", ""),
+            email=d.get("email", ""),
+            role=d.get("role", ""),
+            course_role=d.get("course_role"),
+            avatar=d.get("avatar"),
+        )
+
+
+@dataclass
+class Category:
+    name: str
+    subcategories: list[str] = field(default_factory=list)
+
+    @classmethod
+    def from_dict(cls, d: dict) -> Category:
+        subs = []
+        for s in d.get("subcategories", []):
+            if isinstance(s, str):
+                subs.append(s)
+            elif isinstance(s, dict):
+                subs.append(s.get("name", ""))
+        return cls(name=d["name"], subcategories=subs)
+
+
+@dataclass
+class Course:
+    id: int
+    code: str
+    name: str
+    year: str = ""
+    session: str = ""
+    status: str = ""
+    role: str = ""
+    categories: list[Category] = field(default_factory=list)
+
+    @classmethod
+    def from_dict(cls, enrollment: dict) -> Course:
+        c = enrollment["course"]
+        role_data = enrollment.get("role", {})
+        cats = []
+        try:
+            cat_list = c["settings"]["discussion"]["categories"]
+            cats = [Category.from_dict(cat) for cat in cat_list]
+        except (KeyError, TypeError):
+            pass
+        return cls(
+            id=c["id"],
+            code=c.get("code", ""),
+            name=c.get("name", ""),
+            year=c.get("year", ""),
+            session=c.get("session", ""),
+            status=c.get("status", ""),
+            role=role_data.get("role", "") if role_data else "",
+            categories=cats,
+        )
+
+
+@dataclass
+class Comment:
+    id: int
+    user_id: int
+    type: str  # "comment" or "answer"
+    document: str = ""
+    content: str = ""
+    is_anonymous: bool = False
+    is_endorsed: bool = False
+    is_resolved: bool = False
+    vote_count: int = 0
+    created_at: str = ""
+    user_name: str = ""
+    comments: list[Comment] = field(default_factory=list)
+
+    @classmethod
+    def from_dict(cls, d: dict, users: dict[int, User] | None = None) -> Comment:
+        users = users or {}
+        user_name = ""
+        if d.get("is_anonymous"):
+            user_name = "Anonymous"
+        elif d.get("user_id") and d["user_id"] in users:
+            user_name = users[d["user_id"]].name
+        replies = [cls.from_dict(r, users) for r in d.get("comments", []) or []]
+        return cls(
+            id=d["id"],
+            user_id=d.get("user_id", 0),
+            type=d.get("type", "comment"),
+            document=d.get("document", ""),
+            content=d.get("content", ""),
+            is_anonymous=d.get("is_anonymous", False),
+            is_endorsed=d.get("is_endorsed", False),
+            is_resolved=d.get("is_resolved", False),
+            vote_count=d.get("vote_count", 0),
+            created_at=d.get("created_at", ""),
+            user_name=user_name,
+            comments=replies,
+        )
+
+
+@dataclass
+class Thread:
+    id: int
+    number: int
+    type: str  # "announcement", "question", "post"
+    title: str
+    document: str = ""
+    content: str = ""
+    category: str = ""
+    subcategory: str = ""
+    user_id: int = 0
+    user_name: str = ""
+    vote_count: int = 0
+    reply_count: int = 0
+    view_count: int = 0
+    unique_view_count: int = 0
+    is_pinned: bool = False
+    is_locked: bool = False
+    is_private: bool = False
+    is_answered: bool = False
+    is_student_answered: bool = False
+    is_staff_answered: bool = False
+    is_endorsed: bool = False
+    is_anonymous: bool = False
+    is_seen: bool = False
+    is_starred: bool = False
+    new_reply_count: int = 0
+    unresolved_count: int = 0
+    created_at: str = ""
+    updated_at: str = ""
+    answers: list[Comment] = field(default_factory=list)
+    comments: list[Comment] = field(default_factory=list)
+
+    @classmethod
+    def from_dict(cls, d: dict, users: dict[int, User] | None = None) -> Thread:
+        users = users or {}
+        user_name = ""
+        if d.get("is_anonymous"):
+            user_name = "Anonymous"
+        elif d.get("user_id") and d["user_id"] in users:
+            user_name = users[d["user_id"]].name
+        answers = [Comment.from_dict(a, users) for a in d.get("answers", []) or []]
+        comments = [Comment.from_dict(c, users) for c in d.get("comments", []) or []]
+        return cls(
+            id=d["id"],
+            number=d.get("number", 0),
+            type=d.get("type", ""),
+            title=d.get("title", ""),
+            document=d.get("document", ""),
+            content=d.get("content", ""),
+            category=d.get("category", ""),
+            subcategory=d.get("subcategory", ""),
+            user_id=d.get("user_id", 0),
+            user_name=user_name,
+            vote_count=d.get("vote_count", 0),
+            reply_count=d.get("reply_count", 0),
+            view_count=d.get("view_count", 0),
+            unique_view_count=d.get("unique_view_count", 0),
+            is_pinned=d.get("is_pinned", False),
+            is_locked=d.get("is_locked", False),
+            is_private=d.get("is_private", False),
+            is_answered=d.get("is_answered", False),
+            is_student_answered=d.get("is_student_answered", False),
+            is_staff_answered=d.get("is_staff_answered", False),
+            is_endorsed=d.get("is_endorsed", False),
+            is_anonymous=d.get("is_anonymous", False),
+            is_seen=d.get("is_seen", False),
+            is_starred=d.get("is_starred", False),
+            new_reply_count=d.get("new_reply_count", 0),
+            unresolved_count=d.get("unresolved_count", 0),
+            created_at=d.get("created_at", ""),
+            updated_at=d.get("updated_at", ""),
+            answers=answers,
+            comments=comments,
+        )