ventimath 0.1.0__py3-none-any.whl

ventimath/__init__.py

@@ -0,0 +1,25 @@
+"""VentiMath REST client. No inference providers or runtime dependencies."""
+
+from .client import (
+    DEFAULT_BASE_URL,
+    VentiMathAPIError,
+    VentiMathClient,
+    VentiMathConnectionError,
+    VentiMathError,
+    VentiMathImportError,
+    VentiMathProtocolError,
+    load_classification_files,
+    load_vocabulary_csv,
+)
+
+__all__ = [
+    "DEFAULT_BASE_URL",
+    "VentiMathAPIError",
+    "VentiMathClient",
+    "VentiMathConnectionError",
+    "VentiMathError",
+    "VentiMathImportError",
+    "VentiMathProtocolError",
+    "load_classification_files",
+    "load_vocabulary_csv",
+]

ventimath/client.py

@@ -0,0 +1,441 @@
+"""Thin JSON client for the answerKeys and problemTags Cloud Functions."""
+
+from __future__ import annotations
+
+import csv
+import json
+import os
+from collections.abc import Iterable, Mapping
+from http.client import HTTPException
+from pathlib import Path
+from typing import Any, Literal
+from urllib.error import HTTPError, URLError
+from urllib.parse import quote, urlencode, urlsplit
+from urllib.request import HTTPRedirectHandler, Request, build_opener
+
+DEFAULT_BASE_URL = "https://us-central1-ventimath.cloudfunctions.net"
+MAX_IMPORT_RECORDS = 200
+MAX_IMPORT_BYTES = 2 * 1024 * 1024
+
+
+class _NoRedirectHandler(HTTPRedirectHandler):
+    def redirect_request(self, request, response, code, message, headers, new_url):
+        # Function endpoints are direct: never forward a token or change a write's method.
+        raise HTTPError(request.full_url, code, message, headers, response)
+
+
+urlopen = build_opener(_NoRedirectHandler()).open
+
+
+class VentiMathError(Exception):
+    """Base class for transport, protocol, and aggregate import failures."""
+
+
+class VentiMathAPIError(VentiMathError):
+    def __init__(self, status: int, payload: Any, url: str):
+        self.status = status
+        self.payload = payload
+        self.url = url
+        super().__init__(f"HTTP {status}: {payload}")
+
+
+class VentiMathConnectionError(VentiMathError):
+    """The request could not complete; the server may have received it."""
+
+
+class VentiMathProtocolError(VentiMathError):
+    """The server returned an unexpected response shape."""
+
+
+class VentiMathImportError(VentiMathError):
+    """An import stopped; report contains counts from completed requests only."""
+
+    def __init__(self, report: dict[str, Any], cause: VentiMathError):
+        self.report = report
+        self.cause = cause
+        self.status = getattr(cause, "status", None)
+        self.payload = getattr(cause, "payload", None)
+        super().__init__(
+            f"Import stopped after {report['processed']}/{report['total']} records: {cause}. "
+            "The last request may have committed. Retry the same records safely; "
+            "unchanged classifications are not written again."
+        )
+
+
+def _json_bytes(value: Any) -> bytes:
+    return json.dumps(value, ensure_ascii=False, allow_nan=False, separators=(",", ":")).encode(
+        "utf-8"
+    )
+
+
+def _set_path(set_id: str) -> str:
+    if not isinstance(set_id, str) or not set_id.strip() or "/" in set_id:
+        raise ValueError("set_id must be a nonempty document ID without slashes")
+    return f"problemTags/sets/{quote(set_id, safe='')}"
+
+
+def _page_query(limit: int | None, cursor: str | None) -> dict[str, Any]:
+    if limit is not None and (type(limit) is not int or not 1 <= limit <= 100):
+        raise ValueError("limit must be an integer from 1 to 100")
+    return {"limit": limit, "cursor": cursor}
+
+
+def load_vocabulary_csv(path: str | os.PathLike[str]) -> list[dict[str, str]]:
+    """Read category/skill/description CSV, including BOM and quoted newlines."""
+    with Path(path).open(encoding="utf-8-sig", newline="") as source:
+        reader = csv.reader(source, strict=True)
+        try:
+            headers = [value.strip().lower() for value in next(reader)]
+            fields = ("skill", "category", "description")
+            if any(headers.count(field) != 1 for field in fields):
+                raise ValueError("CSV needs one each of skill, category, description headers")
+            entries = []
+            for row in reader:
+                if not any(value.strip() for value in row):
+                    continue
+                if len(row) != len(headers):
+                    raise ValueError(f"CSV line {reader.line_num} has an incorrect column count")
+                entry = {field: row[headers.index(field)].strip() for field in fields}
+                if not entry["skill"] or not entry["category"]:
+                    raise ValueError(f"CSV line {reader.line_num} needs a skill and category")
+                entries.append(entry)
+        except StopIteration as error:
+            raise ValueError("vocabulary CSV is empty") from error
+        except csv.Error as error:
+            raise ValueError(f"invalid vocabulary CSV: {error}") from error
+    if not 1 <= len(entries) <= 500:
+        raise ValueError("vocabulary CSV must contain 1–500 skills")
+    return entries
+
+
+def load_classification_files(
+    paths: Iterable[str | os.PathLike[str]],
+) -> list[Any]:
+    """Load individual {result} records or combined arrays with {llmResult}."""
+    records = []
+    for path in paths:
+        with Path(path).open(encoding="utf-8-sig") as source:
+            data = json.load(source)
+        if isinstance(data, list):
+            records.extend(data)
+        elif isinstance(data, dict) and "problemId" in data:
+            records.append(data)
+        else:
+            raise ValueError(f"{path} must hold a classifier record or an array of records")
+    return records
+
+
+class VentiMathClient:
+    """Explicit-token client; token=None is anonymous and never reads credentials."""
+
+    def __init__(
+        self,
+        token: str | None = None,
+        *,
+        base_url: str = DEFAULT_BASE_URL,
+        timeout: float = 60,
+    ):
+        parsed = urlsplit(base_url)
+        if parsed.scheme not in {"https", "http"} or not parsed.netloc:
+            raise ValueError("base_url must be an HTTP(S) URL")
+        if parsed.username or parsed.password or parsed.query or parsed.fragment:
+            raise ValueError("base_url cannot contain credentials, a query, or a fragment")
+        if timeout <= 0:
+            raise ValueError("timeout must be positive")
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+        self._token = token
+
+    @classmethod
+    def from_env(cls, *, timeout: float = 60) -> VentiMathClient:
+        """Read VENTI_API_KEY/VENTI_API_URL without writing a credential file."""
+        return cls(
+            token=os.environ.get("VENTI_API_KEY"),
+            base_url=os.environ.get("VENTI_API_URL") or DEFAULT_BASE_URL,
+            timeout=timeout,
+        )
+
+    def _request(
+        self,
+        method: str,
+        path: str,
+        *,
+        query: Mapping[str, Any] | None = None,
+        body: Any = None,
+        public: bool = False,
+        require_token: bool = False,
+    ) -> dict[str, Any]:
+        if require_token and not self._token:
+            raise ValueError("this write requires your own VentiMath token with tags.write")
+        url = f"{self.base_url}/{path}"
+        if query:
+            encoded = urlencode({key: value for key, value in query.items() if value is not None})
+            if encoded:
+                url += f"?{encoded}"
+        headers = {"Accept": "application/json", "User-Agent": "ventimath-python/0.1.0"}
+        if self._token and not public:
+            headers["Authorization"] = f"Bearer {self._token}"
+        data = None
+        if body is not None:
+            data = _json_bytes(body)
+            headers["Content-Type"] = "application/json"
+        request = Request(url, data=data, headers=headers, method=method)
+        try:
+            with urlopen(request, timeout=self.timeout) as response:
+                text = response.read().decode("utf-8")
+        except HTTPError as error:
+            try:
+                with error:
+                    text = error.read().decode("utf-8", errors="replace")
+            except (URLError, OSError, HTTPException) as read_error:
+                raise VentiMathConnectionError(
+                    f"request to {url} failed while reading HTTP {error.code}: {read_error}"
+                ) from read_error
+            try:
+                payload = json.loads(text)
+            except ValueError:
+                payload = text
+            raise VentiMathAPIError(error.code, payload, url) from error
+        except (URLError, OSError, HTTPException) as error:
+            raise VentiMathConnectionError(f"request to {url} failed: {error}") from error
+        except UnicodeError as error:
+            raise VentiMathProtocolError(f"invalid UTF-8 response from {url}") from error
+        try:
+            payload = json.loads(text)
+        except ValueError as error:
+            raise VentiMathProtocolError(f"invalid JSON response from {url}") from error
+        if not isinstance(payload, dict):
+            raise VentiMathProtocolError(f"expected a JSON object from {url}")
+        return payload
+
+    def answer_keys(
+        self, *, ids: Iterable[str] | str | None = None, exam: str | None = None
+    ) -> dict[str, Any]:
+        """Public {problems, missing, unavailable}; exactly one selector is required."""
+        if (ids is None) == (exam is None):
+            raise ValueError("provide exactly one of ids or exam")
+        query = {"exam": exam}
+        if ids is not None:
+            values = ids.split(",") if isinstance(ids, str) else list(ids)
+            if not 1 <= len(values) <= 100 or any(
+                not isinstance(value, str) or not value.strip() or "," in value for value in values
+            ):
+                raise ValueError("ids must contain 1–100 nonempty canonical problem IDs")
+            query = {"ids": ",".join(value.strip() for value in values)}
+        elif not isinstance(exam, str) or not exam.strip():
+            raise ValueError("exam must be a nonempty exam ID")
+        return self._request("GET", "answerKeys", query=query, public=True)
+
+    def download_answer_key(
+        self,
+        path: str | os.PathLike[str],
+        *,
+        ids: Iterable[str] | str | None = None,
+        exam: str | None = None,
+    ) -> dict[str, Any]:
+        """Save JSON accepted by the classifier's existing local --answer-key option."""
+        payload = self.answer_keys(ids=ids, exam=exam)
+        destination = Path(path)
+        destination.parent.mkdir(parents=True, exist_ok=True)
+        destination.write_text(
+            json.dumps(payload, ensure_ascii=False, indent=2) + "\n", encoding="utf-8"
+        )
+        return payload
+
+    def list_tag_sets(
+        self,
+        *,
+        owner: str | None = None,
+        limit: int | None = None,
+        cursor: str | None = None,
+        public: bool = False,
+    ) -> dict[str, Any]:
+        """One {sets, nextCursor} page; omit vocabulary until get_tag_set is called."""
+        return self._request(
+            "GET",
+            "problemTags/sets",
+            query={"owner": owner, **_page_query(limit, cursor)},
+            public=public,
+        )
+
+    def list_public_tag_sets(self, **kwargs: Any) -> dict[str, Any]:
+        """Discover public sets anonymously, even if this client has a token."""
+        return self.list_tag_sets(**{**kwargs, "public": True})
+
+    def get_tag_set(self, set_id: str, *, public: bool = False) -> dict[str, Any]:
+        """Return {set}, including vocabulary."""
+        return self._request("GET", _set_path(set_id), public=public)
+
+    def create_tag_set(
+        self,
+        slug: str,
+        name: str,
+        *,
+        public: bool = True,
+        vocabulary: Iterable[Mapping[str, str]] | None = None,
+    ) -> dict[str, Any]:
+        """Create a public set on the token owner's profile; use public=False for private."""
+        if type(public) is not bool:
+            raise ValueError("public must be a boolean")
+        body: dict[str, Any] = {
+            "slug": slug,
+            "name": name,
+            "visibility": "public" if public else "private",
+        }
+        if vocabulary is not None:
+            body["vocabulary"] = list(vocabulary)
+        return self._request("POST", "problemTags/sets", body=body, require_token=True)
+
+    def update_tag_set(
+        self,
+        set_id: str,
+        *,
+        name: str | None = None,
+        public: Literal[True] | None = None,
+        vocabulary: Iterable[Mapping[str, str]] | None = None,
+    ) -> dict[str, Any]:
+        """Update metadata or publish with public=True; publication is permanent.
+
+        Vocabulary replaces the list. Private visibility is only chosen at creation.
+        """
+        body: dict[str, Any] = {}
+        if name is not None:
+            body["name"] = name
+        if public is not None:
+            if public is not True:
+                raise ValueError("public must be True to publish; choose private at creation")
+            body["visibility"] = "public"
+        if vocabulary is not None:
+            body["vocabulary"] = list(vocabulary)
+        if not body:
+            raise ValueError("provide name, public, or vocabulary to update")
+        return self._request("PATCH", _set_path(set_id), body=body, require_token=True)
+
+    def import_classifications(
+        self,
+        set_id: str,
+        records: Iterable[Any] | Mapping[str, Any],
+        *,
+        vocabulary: Iterable[Mapping[str, str]] | None = None,
+        dry_run: bool = False,
+        model: str | None = None,
+        reasoning_effort: str | None = None,
+    ) -> dict[str, Any]:
+        """Import saved records with bounded requests and one aggregate report.
+
+        Individual `result` and combined `llmResult` shapes pass through unchanged.
+        Row-level rejection details pass through, with indices adjusted globally.
+        Dry runs preview each batch against currently persisted state.
+        """
+        if not self._token:
+            raise ValueError("imports require your own VentiMath token with tags.write")
+        if type(dry_run) is not bool:
+            raise ValueError("dry_run must be a boolean")
+        path = f"{_set_path(set_id)}/import"
+        items = [records] if isinstance(records, Mapping) else list(records)
+        if not items:
+            raise ValueError("no classifier records supplied")
+        options: dict[str, Any] = {"dryRun": dry_run}
+        if vocabulary is not None:
+            options["vocabulary"] = list(vocabulary)
+        if model is not None:
+            options["model"] = model
+        if reasoning_effort is not None:
+            options["reasoningEffort"] = reasoning_effort
+        batches: list[list[Any]] = []
+        batch: list[Any] = []
+        for index, record in enumerate(items):
+            if len(_json_bytes({**options, "records": [record]})) > MAX_IMPORT_BYTES:
+                raise ValueError(f"record {index} plus vocabulary exceeds the 2 MiB request limit")
+            candidate = [*batch, record]
+            if batch and (
+                len(candidate) > MAX_IMPORT_RECORDS
+                or len(_json_bytes({**options, "records": candidate})) > MAX_IMPORT_BYTES
+            ):
+                batches.append(batch)
+                batch = []
+            batch.append(record)
+        batches.append(batch)
+        report: dict[str, Any] = {
+            "imported": 0,
+            "unchanged": 0,
+            "rejected": [],
+            "dryRun": dry_run,
+            "total": len(items),
+            "processed": 0,
+            "remaining": len(items),
+        }
+        for chunk in batches:
+            try:
+                result = self._request(
+                    "POST", path, body={**options, "records": chunk}, require_token=True
+                )
+                if (
+                    type(result.get("imported")) is not int
+                    or type(result.get("unchanged")) is not int
+                    or result["imported"] < 0
+                    or result["unchanged"] < 0
+                    or not isinstance(result.get("rejected"), list)
+                    or result["imported"] + result["unchanged"] + len(result["rejected"])
+                    != len(chunk)
+                    or any(
+                        not isinstance(rejected, dict)
+                        or type(rejected.get("index")) is not int
+                        or not 0 <= rejected["index"] < len(chunk)
+                        for rejected in result["rejected"]
+                    )
+                ):
+                    raise VentiMathProtocolError(
+                        "invalid import response; inspect server state before retrying"
+                    )
+            except VentiMathError as error:
+                raise VentiMathImportError(report, error) from error
+            report["imported"] += result["imported"]
+            report["unchanged"] += result["unchanged"]
+            report["rejected"].extend(
+                {**rejected, "index": report["processed"] + rejected["index"]}
+                for rejected in result["rejected"]
+            )
+            report["processed"] += len(chunk)
+            report["remaining"] = len(items) - report["processed"]
+        return report
+
+    def tagged_problems(
+        self,
+        set_id: str,
+        *,
+        skill: str | None = None,
+        importance: str | None = None,
+        limit: int | None = None,
+        cursor: str | None = None,
+        public: bool = False,
+    ) -> dict[str, Any]:
+        """One {set, problems, nextCursor} page with each problem's classification."""
+        if importance is not None and importance not in {"essential", "time-saving", "helpful"}:
+            raise ValueError("importance must be essential, time-saving, or helpful")
+        if importance and not skill:
+            raise ValueError("importance requires a skill")
+        return self._request(
+            "GET",
+            f"{_set_path(set_id)}/problems",
+            query={"skill": skill, "importance": importance, **_page_query(limit, cursor)},
+            public=public,
+        )
+
+    def iter_tagged_problems(self, set_id: str, **kwargs: Any) -> Iterable[dict[str, Any]]:
+        """Yield problems across pages, including empty pages with a next cursor."""
+        cursor = kwargs.pop("cursor", None)
+        seen = {cursor} if cursor else set()
+        while True:
+            page = self.tagged_problems(set_id, cursor=cursor, **kwargs)
+            if not isinstance(page.get("problems"), list):
+                raise VentiMathProtocolError("tagged-problem response needs a problems list")
+            yield from page["problems"]
+            cursor = page.get("nextCursor")
+            if not cursor:
+                break
+            if not isinstance(cursor, str) or cursor in seen:
+                raise VentiMathProtocolError(
+                    "server returned an invalid or repeated pagination cursor"
+                )
+            seen.add(cursor)

ventimath-0.1.0.dist-info/METADATA

@@ -0,0 +1,214 @@
+Metadata-Version: 2.4
+Name: ventimath
+Version: 0.1.0
+Summary: Small standard-library client for VentiMath answer keys and profile skill tags
+Project-URL: Repository, https://github.com/VentiMath/venti-sdk
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# VentiMath Python SDK
+
+Download answer keys, import your problem classifications, and find problems by skill.
+Requires Python 3.10 or newer, with no runtime dependencies.
+
+## Install
+
+```sh
+pip install ventimath
+# Or add it to a uv project:
+uv add ventimath
+```
+
+The default API base URL is
+`https://us-central1-ventimath.cloudfunctions.net`; use `base_url=` for a deployed
+test environment or functions emulator.
+
+## Download answer keys for the existing classifier
+
+Answer-key reads are public and always omit authentication, even when the client
+has a token. Download a file; the classifier's existing `--answer-key` reads a
+local JSON path, not a URL.
+
+```python
+from ventimath import VentiMathClient
+
+public = VentiMathClient()
+result = public.download_answer_key("answer-key.json", exam="EXAM_ID")
+print("Missing problems:", result["missing"])
+print("No usable key:", result["unavailable"])
+
+# Or select up to 100 canonical problem IDs:
+keys = public.answer_keys(ids=["PROBLEM_ID_1", "PROBLEM_ID_2"])
+```
+
+```sh
+python classify_skills.py PROBLEM_ID --answer-key answer-key.json
+```
+
+The response and saved file have the same shape:
+
+```json
+{
+  "problems": {
+    "PROBLEM_ID": {"correctChoice": "B", "answerText": "2"}
+  },
+  "missing": [],
+  "unavailable": []
+}
+```
+
+Text-answer records carry `answerText`; accepted alternatives may also appear in
+`allowedAnswers`. Exam requests are bounded to 500 placements. Unknown canonical
+IDs appear in `missing`; proofs, absent keys, and placeholders appear in
+`unavailable`.
+
+## Import classifications on your own profile
+
+Create your VentiMath account and mint **your own** personal access token in
+Settings → Developer. Select `tags.read` and `tags.write`. Keep the token in your
+environment rather than in source files. The authenticated account owns the set;
+there is no option to assign your upload to someone else's account.
+
+`VentiMathClient(token=...)` uses an explicit token. `VentiMathClient.from_env()`
+reads `VENTI_API_KEY` and optionally `VENTI_API_URL`. Neither stores credentials.
+The ordinary `VentiMathClient()` constructor remains anonymous even if a token
+environment variable exists.
+
+Sets are **public by default**. Pass `public=False` at creation to keep a set
+private to your account. Publishing a private set is permanent; public sets cannot
+be made private. This import example creates a private set:
+
+```python
+from pathlib import Path
+from ventimath import (
+    VentiMathClient,
+    load_classification_files,
+    load_vocabulary_csv,
+)
+
+client = VentiMathClient.from_env()
+vocabulary = load_vocabulary_csv("skill-lists/skills-merged.csv")
+created = client.create_tag_set(
+    "amc-skills",
+    "My AMC skill classifications",
+    public=False,
+    vocabulary=vocabulary,
+)
+set_id = created["set"]["id"]
+
+# Use saved per-problem output from a single classifier run folder.
+records = load_classification_files(sorted(Path("output/skills/MODEL_DIRECTORY").glob("*.json")))
+
+# Or use the classifier's combined output instead:
+# records = load_classification_files(["combined.json"])
+
+preview = client.import_classifications(set_id, records, dry_run=True)
+print(preview)
+
+# After inspecting the preview, upload the same records.
+report = client.import_classifications(set_id, records)
+print("Imported:", report["imported"], "unchanged:", report["unchanged"])
+for rejected in report["rejected"]:
+    print(rejected)
+```
+
+Individual records use `{problemId, result, model, reasoningEffort}`. Combined
+files use `{problemId, llmResult}` and usually omit model provenance; supply
+`model="MODEL_USED"` and `reasoning_effort="EFFORT_USED"` to `import_classifications`
+when those values are known. Per-record values take precedence. Both shapes pass
+through to the API unchanged. The server validates each classification and
+discards copied prompts, raw replies, statements, and answer fields.
+
+Vocabulary CSV headers are `category`, `skill`, and `description`, in any order.
+Quoted commas/newlines, escaped quotes, and a UTF-8 BOM are supported. On import,
+`vocabulary=` merges by skill name; supplied entries update matching descriptions
+and categories. Accepted records add unseen skill names. To explicitly replace
+the vocabulary, use `update_tag_set(set_id, vocabulary=...)`.
+
+## Retrieve problems by skill
+
+```python
+# Your own sets, including private sets; needs tags.read.
+mine = client.list_tag_sets()
+
+# Public discovery always omits the token, even on an authenticated client.
+shared = client.list_public_tag_sets(owner="OWNER_NUMERIC_ID", limit=20)
+# Pass shared["nextCursor"] as cursor= to request the next page.
+
+# Set listing returns metadata. Fetch a set to get its vocabulary.
+tag_set = client.get_tag_set(set_id)
+print(tag_set["set"]["vocabulary"])
+
+# One page, preserving the response envelope and pagination cursor:
+page = client.tagged_problems(
+    set_id, skill="Casework", importance="essential", limit=25
+)
+
+# Or iterate across every page:
+for problem in client.iter_tagged_problems(set_id, skill="Casework"):
+    print(problem["id"], problem["details"]["statement"])
+    print(problem["classification"])
+```
+
+Skill names match exactly. Importance is `essential`, `time-saving`, or `helpful`
+and requires a skill filter.
+Use `public=True` on `get_tag_set`, `tagged_problems`, or `iter_tagged_problems`
+to read a public set without sending the client's token. Public problem records
+omit catalog answer fields; their attached classifications remain attributed to
+the set owner.
+
+## Reports, errors, and retries
+
+Imports are split into requests of at most 200 records and 2 MiB of UTF-8 JSON.
+All input is checked for JSON encodability and individual request size before
+any request is sent. The aggregate response contains `imported`, `unchanged`,
+`rejected`, `dryRun`, `total`, `processed`, and `remaining`. Rejected entries retain
+the server's error code and problem ID; their zero-based `index` refers to your
+complete input sequence. Row rejections do not raise an exception; inspect them.
+
+Dry runs validate each batch against the currently stored set without writing.
+For imports spanning batches, repeated problem IDs or the cumulative vocabulary
+limit can make actual counts differ from the preview. Inspect the final report.
+
+```python
+from ventimath import VentiMathAPIError, VentiMathImportError
+
+try:
+    report = client.import_classifications(set_id, records)
+except VentiMathImportError as error:
+    print("Completed requests:", error.report)
+    print("HTTP status, if available:", error.status)
+    print("Server payload, if available:", error.payload)
+    # A failed response does not prove the last request was uncommitted.
+    # Retrying the identical input is safe; unchanged records are not rewritten.
+except VentiMathAPIError as error:
+    print(error.status, error.payload)
+```
+
+Other methods raise `VentiMathAPIError` with the original HTTP status and server
+payload for HTTP failures. `VentiMathConnectionError` covers transport failures,
+including interrupted response bodies;
+`VentiMathProtocolError` covers unexpected responses. Invalid local arguments
+raise `ValueError`. Imports wrap transport/protocol/HTTP failures in
+`VentiMathImportError` to preserve the counts from completed requests.
+
+These methods call the actual REST routes: `GET /answerKeys`,
+`GET|POST /problemTags/sets`, `GET|PATCH /problemTags/sets/{id}`,
+`POST /problemTags/sets/{id}/import`, and
+`GET /problemTags/sets/{id}/problems`. You can call those endpoints directly from
+your existing Python HTTP code; the SDK is optional.
+
+## Development
+
+Install from a source checkout with `python -m pip install .`.
+
+From this package directory, without installing or contacting a server:
+
+```sh
+PYTHONPATH=src python -B -m unittest discover -s tests -v
+```
+
+All transport calls in these tests are mocked. They exercise exact URLs and
+headers, anonymous discovery, private ownership request shaping, both classifier
+record formats, CSV parsing, Unicode batch limits, pagination, rejected redirects,
+and partial-failure reports.

ventimath-0.1.0.dist-info/RECORD

@@ -0,0 +1,6 @@
+ventimath/__init__.py,sha256=m7hDvQqqguH6xPRMU-OdLEuSKy8TL2qt57PBmnPMoUg,587
+ventimath/client.py,sha256=9Un81c8Q-Al77T6sRclDnrb3NViCKu-pXJM9uJVf15w,18305
+ventimath-0.1.0.dist-info/METADATA,sha256=I8FLapqHmBI1ZBq4Katu2Fnm7aT2b_2LY6cXTTTcu7I,8283
+ventimath-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+ventimath-0.1.0.dist-info/top_level.txt,sha256=0G5b1NL6nlsVycAkb2myss6CWJymFE0j7eRzzI6mor8,10
+ventimath-0.1.0.dist-info/RECORD,,

ventimath-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

ventimath-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+ventimath