logion-cli 0.1.0__py3-none-any.whl

cli/commands/courses/_purchase.py

@@ -0,0 +1,76 @@
+# SPDX-License-Identifier: MIT
+"""Course purchase handler — credit-spend gated by ``--yes``."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+
+from cli._config import resolve_config_from_args
+from cli._confirm import require_yes
+from cli._context import make_client
+from cli._errors import handle_error, print_err, validate_uuid_id
+from cli._output import emit, emit_json, to_data
+
+
+def handle_purchase(args: argparse.Namespace) -> int:
+    """Execute the courses purchase command."""
+    bad_id = validate_uuid_id(args.course_id, "COURSE_ID")
+    if bad_id is not None:
+        return bad_id
+    refusal = require_yes(args.yes, "spend credits and purchase this course")
+    if refusal is not None:
+        return refusal
+    config = resolve_config_from_args(args)
+    client = make_client(config)
+    try:
+        result = client.v1.courses.purchase(
+            course_id=args.course_id,
+            expected_price_cents=args.expected_price_cents,
+            idempotency_key=args.idempotency_key,
+        )
+        data = to_data(result)
+        if config.json_output:
+            emit_json("logion.courses.purchase", data)
+        else:
+            _emit_purchase_human(data)
+    except Exception as exc:
+        if _is_insufficient_credit_error(exc):
+            print_err(
+                "Insufficient credits. Check `logion credits balance` and "
+                "create a user-approved top-up with `logion credits top-up`."
+            )
+        return handle_error(exc)
+    else:
+        return 0
+    finally:
+        client.close()
+
+
+def _is_insufficient_credit_error(exc: Exception) -> bool:
+    """Return whether an API error reports an insufficient credit balance."""
+    detail = getattr(exc, "detail", "")
+    text = str(detail).lower()
+    return "insufficient" in text and "credit" in text
+
+
+def _emit_purchase_human(data: dict[str, object]) -> None:
+    """Render course purchase result with explicit credit spend lines."""
+    lines: list[str] = []
+    amount = data.get("amount_cents")
+    if amount is not None:
+        lines.append(f"cost_cents: {amount}")
+    before = data.get("balance_before_cents")
+    after = data.get("balance_after_cents")
+    if before is not None and after is not None:
+        lines.append(f"balance_cents: {before} -> {after}")
+    flow = data.get("purchase_flow")
+    if flow is not None:
+        lines.append(f"purchase_flow: {flow}")
+    entitlement = data.get("entitlement_granted")
+    if entitlement is not None:
+        lines.append(f"entitlement_granted: {entitlement}")
+    if lines:
+        sys.stdout.write("\n".join(lines) + "\n")
+    else:
+        emit(data, json_output=False)

cli/commands/courses/_review_helpers.py

@@ -0,0 +1,93 @@
+# SPDX-License-Identifier: MIT
+"""Helper functions for courses reviews commands."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from cli._output import to_data, truncate_summary
+
+
+def data_or_model_dump(result: object) -> dict[str, Any]:
+    """Return model_dump() for Pydantic models, else to_data."""
+    if hasattr(result, "model_dump"):
+        return result.model_dump(mode="json")  # type: ignore[union-attr]
+    return to_data(result)
+
+
+def collect_reviews(
+    client: object,
+    course_id: str,
+    version: str | None,
+    limit: int | None,
+) -> list[dict[str, Any]]:
+    """Paginate through list_reviews and return all review dicts."""
+    from cli._utils import only_not_none
+
+    reviews: list[dict[str, Any]] = []
+    cursor: str | None = None
+    page_size = limit or 100
+    while True:
+        kwargs = only_not_none(
+            {"course_id": course_id},
+            version=version,
+            limit=page_size,
+            cursor=cursor,
+        )
+        result = client.v1.courses.list_reviews(**kwargs)  # type: ignore[attr-defined]
+        if hasattr(result, "model_dump"):
+            data: dict[str, Any] = result.model_dump(mode="json")
+        elif isinstance(result, dict):
+            data = result
+        else:
+            import json
+
+            data = json.loads(json.dumps(result, default=str))
+        batch = data.get("reviews", [])
+        reviews.extend(batch)
+        next_cursor = data.get("next_cursor")
+        if not next_cursor or (limit and len(reviews) >= limit):
+            break
+        cursor = next_cursor
+    return reviews[:limit] if limit is not None else reviews
+
+
+def compute_summary(
+    course_id: str,
+    all_reviews: list[dict[str, Any]],
+) -> dict[str, Any]:
+    """Build the summary dict from a list of review dicts."""
+    counted = [r for r in all_reviews if r.get("counts_toward_rating", True)]
+    review_count = len(counted)
+    rating_histogram = {str(score): 0 for score in range(1, 6)}
+    for review in counted:
+        rating = review.get("rating")
+        if isinstance(rating, int) and 1 <= rating <= 5:
+            rating_histogram[str(rating)] += 1
+
+    summary: dict[str, Any] = {
+        "course_id": course_id,
+        "review_count": review_count,
+        "rating_avg": None,
+        "rating_histogram": rating_histogram,
+    }
+    if review_count > 0:
+        avg_rating = sum(r.get("rating", 0) for r in counted) / review_count
+        summary["rating_avg"] = round(avg_rating, 2)
+    return summary
+
+
+def compact_review(review: dict[str, Any]) -> dict[str, Any]:
+    """Build the compact review payload required by the CLI contract."""
+    return {
+        "review_id": review.get("review_id", review.get("id")),
+        "rating": review.get("rating"),
+        "body_excerpt": truncate_summary(
+            review.get("body") if isinstance(review.get("body"), str) else None
+        ),
+        "agent_id": review.get("agent_id", review.get("reviewer_agent_id")),
+        "version_id": review.get(
+            "version_id", review.get("course_version_id")
+        ),
+        "created_at": review.get("created_at", review.get("submitted_at")),
+    }

cli/commands/courses/_taxonomy_data.py

@@ -0,0 +1,173 @@
+# SPDX-License-Identifier: MIT
+"""Static keyword mappings for deterministic taxonomy suggestions.
+
+Kept separate from the suggestion logic to respect the CLI architecture
+source-file size limit.
+"""
+
+from __future__ import annotations
+
+# Deterministic keyword → category mapping. Order matters only for
+# readability; each keyword set is disjoint in practice.
+CATEGORY_KEYWORDS: dict[str, frozenset[str]] = {
+    "automation": frozenset({
+        "automation",
+        "automate",
+        "workflow",
+        "pipeline",
+        "ci",
+        "cd",
+    }),
+    "code-review": frozenset({
+        "review",
+        "pr",
+        "pull-request",
+        "lint",
+        "linter",
+        "code-review",
+    }),
+    "data": frozenset({
+        "data",
+        "dataset",
+        "database",
+        "sql",
+        "etl",
+        "warehouse",
+    }),
+    "devops": frozenset({
+        "devops",
+        "terraform",
+        "kubernetes",
+        "docker",
+        "helm",
+        "deploy",
+    }),
+    "documentation": frozenset({
+        "docs",
+        "documentation",
+        "readme",
+        "manual",
+        "guide",
+    }),
+    "finance": frozenset({
+        "finance",
+        "accounting",
+        "invoice",
+        "ledger",
+        "payment",
+    }),
+    "marketing": frozenset({
+        "marketing",
+        "seo",
+        "campaign",
+        "email",
+        "newsletter",
+    }),
+    "media": frozenset({
+        "video",
+        "audio",
+        "image",
+        "media",
+        "transcode",
+        "editing",
+    }),
+    "productivity": frozenset({
+        "productivity",
+        "task",
+        "todo",
+        "notes",
+        "calendar",
+        "schedule",
+    }),
+    "research": frozenset({
+        "research",
+        "analysis",
+        "survey",
+        "study",
+        "literature",
+    }),
+    "security": frozenset({
+        "security",
+        "vulnerability",
+        "cve",
+        "pentest",
+        "audit",
+    }),
+    "testing": frozenset({
+        "test",
+        "testing",
+        "qa",
+        "unit-test",
+        "integration-test",
+        "pytest",
+    }),
+    "writing": frozenset({
+        "writing",
+        "blog",
+        "article",
+        "content",
+        "copy",
+        "prose",
+    }),
+}
+
+# Words that appear frequently but carry no taxonomy signal.
+STOP_WORDS: frozenset[str] = frozenset({
+    "the",
+    "and",
+    "for",
+    "with",
+    "your",
+    "this",
+    "that",
+    "from",
+    "into",
+    "using",
+    "use",
+    "can",
+    "will",
+    "you",
+    "are",
+    "not",
+    "but",
+    "how",
+    "what",
+    "when",
+    "who",
+    "all",
+    "new",
+    "one",
+    "two",
+    "get",
+    "set",
+    "run",
+    "make",
+    "via",
+    "out",
+    "our",
+    "own",
+    "any",
+    "has",
+    "had",
+    "was",
+    "were",
+    "been",
+    "have",
+    "they",
+    "them",
+    "their",
+    "there",
+    "here",
+    "some",
+    "such",
+    "than",
+    "then",
+    "also",
+    "only",
+    "just",
+    "like",
+    "able",
+    "over",
+    "more",
+    "most",
+})

cli/commands/courses/_upload_bundle_validation.py

@@ -0,0 +1,28 @@
+# SPDX-License-Identifier: MIT
+"""Course-bundle validation for upload-time CLI flows."""
+
+from __future__ import annotations
+
+import tempfile
+from pathlib import Path
+
+from cli._course_bundle import CourseBundleError, validate_course_bundle
+
+
+def validate_bundle_files_for_upload(
+    *,
+    file_map: dict[str, Path],
+    paid: bool,
+) -> tuple[bool, str | None]:
+    """Validate the local upload set as a publishable course bundle."""
+    with tempfile.TemporaryDirectory() as tmp:
+        bundle_dir = Path(tmp)
+        for upload_path, local_path in file_map.items():
+            target = bundle_dir / upload_path
+            target.parent.mkdir(parents=True, exist_ok=True)
+            target.write_bytes(local_path.read_bytes())
+        try:
+            validate_course_bundle(bundle_dir, paid=paid)
+        except CourseBundleError as exc:
+            return False, str(exc)
+    return True, None

cli/commands/courses/_uploads_push.py

@@ -0,0 +1,243 @@
+# SPDX-License-Identifier: MIT
+"""Push bytes to S3 for a previously created upload session."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+import time
+from pathlib import Path
+from typing import Any
+
+from cli._config import resolve_config_from_args
+from cli._context import make_client
+from cli._errors import print_err, validate_uuid_id
+from cli._output import emit_json
+
+from ._upload_bundle_validation import validate_bundle_files_for_upload
+from .uploads import _resolve_upload_files
+
+# Exit codes used by ``handle_uploads_push``.
+EXIT_OK = 0
+EXIT_BAD_ARGS = 2
+EXIT_SESSION_MISMATCH = 3
+EXIT_MISSING_FILES = 4
+EXIT_UPLOAD_FAILED = 6
+
+DEFAULT_MAX_RETRIES = 3
+DEFAULT_TIMEOUT_S = 60.0
+
+
+def _read_session(path: str) -> dict[str, Any] | None:
+    """Load the upload-session JSON from *path* (``-`` for stdin)."""
+    try:
+        raw = (
+            sys.stdin.read()
+            if path == "-"
+            else Path(path).read_text(encoding="utf-8")
+        )
+    except OSError as exc:
+        print_err(f"could not read session file: {exc}")
+        return None
+    try:
+        data = json.loads(raw)
+    except json.JSONDecodeError as exc:
+        print_err(f"session file is not valid JSON: {exc}")
+        return None
+    if not isinstance(data, dict):
+        print_err("session JSON must be an object")
+        return None
+    return data
+
+
+def _put_one(
+    upload: dict[str, Any],
+    local_path: Path,
+    max_retries: int,
+    timeout: float,
+) -> tuple[bool, str]:
+    """PUT *local_path* to ``upload['put_url']`` with retries.
+
+    Returns ``(success, message)``.  Retries on transient httpx
+    errors and HTTP 5xx; aborts immediately on 4xx (presigned URL
+    rejected — usually a content-length / header mismatch).
+    """
+    import httpx
+
+    url = upload.get("put_url")
+    headers = upload.get("required_headers") or {}
+    if not isinstance(url, str) or not url:
+        return False, "missing put_url"
+
+    last_err = ""
+    for attempt in range(max_retries + 1):
+        try:
+            with local_path.open("rb") as fh:
+                response = httpx.request(
+                    upload.get("method", "PUT"),
+                    url,
+                    content=fh,
+                    headers=headers,
+                    timeout=timeout,
+                )
+        except httpx.RequestError as exc:
+            last_err = f"network error: {exc}"
+        else:
+            if 200 <= response.status_code < 300:
+                return True, f"HTTP {response.status_code}"
+            if 400 <= response.status_code < 500:
+                # Client errors won't recover on retry.
+                return False, (
+                    f"HTTP {response.status_code}: {response.text[:200]}"
+                )
+            last_err = f"HTTP {response.status_code}"
+        if attempt < max_retries:
+            # Linear backoff is enough — presigned URLs are short-lived.
+            time.sleep(0.5 * (attempt + 1))
+    return False, last_err or "exhausted retries"
+
+
+def _build_filename_map(
+    file_specs: list[str],
+) -> dict[str, Path] | None:
+    """Resolve --file specs to a ``{upload_path: local_path}`` map."""
+    resolved = _resolve_upload_files(file_specs)
+    if resolved is None:
+        return None
+    return dict(resolved)
+
+
+def _validate_session_ids(
+    session: dict[str, Any],
+    course_id: str,
+    version_id: str,
+) -> bool:
+    """Refuse to push if the session is for a different course/version."""
+    s_course = str(session.get("course_id", ""))
+    s_version = str(session.get("version_id", ""))
+    if s_course and s_course != course_id:
+        print_err(
+            f"session is for course {s_course}, "
+            f"but command was invoked with {course_id}"
+        )
+        return False
+    if s_version and s_version != version_id:
+        print_err(
+            f"session is for version {s_version}, "
+            f"but command was invoked with {version_id}"
+        )
+        return False
+    return True
+
+
+def _prepare_push(
+    args: argparse.Namespace,
+) -> tuple[int, list[dict[str, Any]] | None, dict[str, Path] | None]:
+    """Validate args + session and return ``(rc, uploads, file_map)``.
+
+    On any validation failure the returned ``rc`` is non-zero and the
+    other two values are ``None``.  Split out of ``handle_uploads_push``
+    purely to keep the handler under the project's cyclomatic-complexity
+    budget — the logic is otherwise sequential.
+    """
+    bad_id = validate_uuid_id(args.course_id, "COURSE_ID")
+    if bad_id is not None:
+        return bad_id, None, None
+    bad_id = validate_uuid_id(args.version_id, "VERSION_ID")
+    if bad_id is not None:
+        return bad_id, None, None
+    if not args.files:
+        print_err("Error: at least one --file is required")
+        return EXIT_BAD_ARGS, None, None
+    session = _read_session(args.session_file)
+    if session is None:
+        return EXIT_BAD_ARGS, None, None
+    if not _validate_session_ids(session, args.course_id, args.version_id):
+        return EXIT_SESSION_MISMATCH, None, None
+    file_map = _build_filename_map(args.files)
+    if file_map is None:
+        return EXIT_BAD_ARGS, None, None
+    uploads = session.get("uploads") or []
+    if not isinstance(uploads, list) or not uploads:
+        print_err("session has no uploads to push")
+        return EXIT_BAD_ARGS, None, None
+    missing = [
+        u.get("filename")
+        for u in uploads
+        if isinstance(u, dict) and u.get("filename") not in file_map
+    ]
+    if missing:
+        print_err(
+            "no local file provided for: " + ", ".join(str(m) for m in missing)
+        )
+        return EXIT_MISSING_FILES, None, None
+    return EXIT_OK, uploads, file_map
+
+
+def _emit_results(
+    results: list[dict[str, Any]],
+    failures: int,
+    json_output: bool,
+) -> None:
+    payload = {"results": results, "failures": failures}
+    if json_output:
+        emit_json("logion.courses.uploads.push", payload)
+        return
+    for r in results:
+        status = "OK" if r["ok"] else "FAIL"
+        print(f"  [{status}] {r['filename']}: {r['detail']}")
+    print(f"Pushed {len(results) - failures}/{len(results)} files.")
+
+
+def _course_price_cents(course: Any) -> int:
+    """Read ``price_cents`` from a SDK response object or plain dict."""
+    if isinstance(course, dict):
+        return int(course.get("price_cents", 0) or 0)
+    return int(getattr(course, "price_cents", 0) or 0)
+
+
+def handle_uploads_push(args: argparse.Namespace) -> int:
+    """Push every file in the upload session to its presigned URL."""
+    rc, uploads, file_map = _prepare_push(args)
+    if rc != EXIT_OK or uploads is None or file_map is None:
+        return rc
+
+    config = resolve_config_from_args(args)
+    client = make_client(config)
+    try:
+        course = client.v1.courses.get(course_id=args.course_id)
+    except Exception as exc:
+        print_err(f"could not fetch course metadata: {exc}")
+        return EXIT_BAD_ARGS
+    finally:
+        client.close()
+
+    ok, error = validate_bundle_files_for_upload(
+        file_map=file_map,
+        paid=_course_price_cents(course) > 0,
+    )
+    if not ok:
+        print_err(f"invalid course bundle for upload: {error}")
+        return EXIT_BAD_ARGS
+
+    results: list[dict[str, Any]] = []
+    failures = 0
+    # COMMON_PARSER leaves --max-retries / --timeout as None when the
+    # caller omits them; fall back to push-specific defaults.
+    max_retries = (
+        args.max_retries
+        if args.max_retries is not None
+        else DEFAULT_MAX_RETRIES
+    )
+    timeout = args.timeout if args.timeout is not None else DEFAULT_TIMEOUT_S
+    for upload in uploads:
+        filename = upload.get("filename", "")
+        local = file_map[filename]
+        ok, msg = _put_one(upload, local, max_retries, timeout)
+        results.append({"filename": filename, "ok": ok, "detail": msg})
+        if not ok:
+            failures += 1
+
+    _emit_results(results, failures, config.json_output)
+    return EXIT_OK if failures == 0 else EXIT_UPLOAD_FAILED