stratyfy-cli 0.1.0__tar.gz

stratyfy_cli-0.1.0/PKG-INFO

@@ -0,0 +1,119 @@
+Metadata-Version: 2.5
+Name: stratyfy-cli
+Version: 0.1.0
+Summary: The pre command: describe a database, train a PRE model, read its rules
+Requires-Python: <4,>=3.11
+Requires-Dist: attrs>=23
+Requires-Dist: httpx<1,>=0.27
+Requires-Dist: psycopg[binary]<4,>=3.1
+Requires-Dist: python-dateutil>=2.8
+Requires-Dist: sqlalchemy<3,>=2.0
+Requires-Dist: typer>=0.12
+Description-Content-Type: text/markdown
+
+# pre-cli
+
+The `pre` command. A coding agent runs it to describe the user's database, train a PRE model, read its rules and
+score cases.
+It talks to the PRE API through `packages/pre-api-client`. It never imports PRE. Its sentences come from
+`packages/pre-words`, so they match the report.
+
+## Install
+
+```bash
+pipx install stratyfy-cli          # or: uv tool install stratyfy-cli
+```
+
+For development, run `poetry install` in this folder, then `poetry run pre --help`. `pre --version` prints the
+version.
+
+The wheel and the sdist bundle `pre_api_client`, `pre_words` and `pre_report` from `packages/`, so the install
+needs nothing else from this repo. `hatch_build.py` copies them in at build time. The CLI uses hatchling to build,
+because poetry-core cannot include files from outside this folder. Poetry still manages the development env.
+
+## Commands
+
+Each command prints a short text result and a next step. Add `--json` to get one JSON object instead. On
+failure the command exits with 1 and prints `code`, `message` and `next_step`.
+
+| Command | What it does |
+| --- | --- |
+| `pre login [--no-wait] [--api-url <url>]` | Signs in as `gh auth login` does. It prints a link and a code. The user signs in with an email code and approves the device. Then it writes a new key for this machine to `.pre/config.json`. With `--no-wait` it prints the link and exits; the next `pre login` waits for that same sign-in. That way an agent can show the user the link first. The default API is `https://api.stratyfy.ai/v1`. |
+| `pre logout` | Removes the key from `.pre/config.json`. The key keeps working until an admin revokes it, so the output names its id. |
+| `pre init --api-key <key> [--api-url <url>]` | Writes a key you already have to `.pre/config.json`. The key can also come from `PRE_API_KEY`. |
+| `pre connect <db>` | Describes a SQLite or Postgres database: tables, row counts, columns, types, null share, sample values and foreign keys. It opens the database read-only. |
+| `pre setup claude [--yes] [--dry-run] [--local]` | For Claude Code. Run it in your own terminal. It adds the API host and a remote Postgres host to Claude Code's sandbox network allowlist. It shows the change and asks first. It refuses to write when an agent runs it. See [Sandboxes](#sandboxes). |
+| `pre status` | Checks that the API answers and accepts the key, and names the workspace. Lists the datasets and models this folder made. |
+| `pre outcome define --name <slug> --sql <query> [--case account --cases accounts --event churn --event-past churned]` | Runs the outcome query and stores it. The query returns one row per case: the case id, then a 0/1 label. It refuses no rows, a label that is not 0 or 1, a repeated case id and a label that is always the same. The words go into every sentence the CLI prints. It guesses each word you leave out from the column names and says so. |
+| `pre outcome show` | Lists the stored outcomes and their queries. |
+| `pre extract --outcome <slug> --features <query>` | Runs the features query (the case id, then the features), joins it to the label and writes `.pre/data/<slug>.csv`. Nothing is sent. |
+| `pre extract --outcome <slug> --upload [--refresh]` | Sends the CSV the dry run wrote, unchanged. With `--refresh`, or with no CSV yet, it runs the queries again first. |
+| `pre train --outcome <slug> [--max-rules N] [--max-conditions N] [--no-wait] [--timeout S]` | Trains on the outcome's uploaded dataset. Every column but `id` is an input. It waits until the model is ready or failed and prints progress to stderr. When ready, it says how well the model predicts on held-out cases: the AUC and how many times the average rate the top 10% hold. |
+| `pre rules --outcome <slug>` or `pre rules --model <id>` | Prints the rules as sentences, strongest first, with points and direction. The baseline shows as the starting rate. `--json` gives the API's rules. |
+| `pre predict --outcome <slug> [--features <query>]` | Scores cases with the outcome's model. The query returns the case id, then the model inputs as of today, for example for the accounts still active. Without `--features` it scores the training cases as of their snapshot date and says so. It writes `.pre/data/<slug>.scores.csv`: the case id, the score, the points and the rules that fired as sentences, highest score first. It also writes `.pre/data/<slug>.scores.json` for `pre report`: the same scores with the rule ids that fired. It refuses a query that lacks an input or repeats a case id. |
+| `pre report --outcome <slug> [--actions <file.json>] [--labels <file.json>] [--top N]` | Writes `.pre/reports/<slug>.html` and `.pre/reports/<slug>.csv` from the scores `pre predict` saved. It sends nothing. The page says how well the model predicts, lists the top rules as sentences and the `N` cases most likely to have the outcome, with their reasons. The CSV holds the same cases. `--actions` maps a rule id to one suggested action. `--labels` maps an input column to a plain label. It refuses a rule id or a column the model lacks. When the scores came from the training cases, the page says so. |
+
+`<db>` is a SQLite file path, `sqlite:///path`, or `postgresql://user:password@host:5432/db`. Use `--schema` for
+a Postgres schema other than `public`.
+
+A `<query>` is the SQL itself or a path that ends in `.sql`. It must be one SELECT or WITH statement. The CLI
+opens SQLite with `mode=ro` and runs Postgres in a read-only transaction, so a query cannot change data. For
+Postgres, a database user with read access only is safer still.
+
+## What leaves the machine
+
+The CSV that `pre extract --upload` sends, and the rows that `pre predict` sends. Before it writes the CSV, `pre extract`:
+
+1. Drops a column when every word of its name is an identifier word and one of them is a core word. Core words
+   are `email`, `phone`, `mobile`, `ip`, `address`, `street`, `ssn`, `name` and `username`. The other identifier
+   words are `mail`, `number`, `first`, `last`, `full`, `user`, `contact`, `home` and `work`. So `work_email` and
+   `first_name` go, and `plan_name` and `address_verified` stay.
+2. Drops a column when a text value holds an email address or looks like a phone number.
+3. Replaces the case id with an HMAC of it in a column named `id`. The key is in `.pre/secret` (mode 600).
+   `.pre/data/<slug>.ids.csv` maps each hash back to the case id. It stays on this machine.
+
+The output names each dropped column and the reason.
+
+`pre predict` sends each case as the same HMAC of its id and the model's inputs, in batches of 1,000. It sends no
+other column. It maps the hashes back to the case ids in memory.
+
+## Sandboxes
+
+`pre setup` writes the smallest change it can. It merges into the file, so a second run changes nothing.
+
+It writes `.claude/settings.json`, key `sandbox.network.allowedDomains`. For a Postgres on this machine, `--local`
+also sets `sandbox.network.allowLocalBinding`, which opens every local port. It never sets `allowAllUnixSockets`.
+Claude Code is the only agent at launch; others are on the roadmap. The onboard skill comes with the plugin
+(`tools/agent-plugin`), not with `pre setup`.
+
+These key names come from secondary sources. They live in `pre_cli/sandbox.py`.
+
+## Local config
+
+`.pre/config.json` holds the API URL, the key and its id, the database URL, the outcome queries and the dataset
+and model ids that later commands create. While a `pre login --no-wait` waits, it also holds that sign-in. The API
+can also list every dataset and model in the workspace. Each command that writes the config also writes
+`.pre/.gitignore`, so git ignores the folder. Set `PRE_DIR` to use another folder.
+
+## Tests
+
+`scripts/check pre-cli` runs ruff and pytest. The `pre status` tests start a Prism mock of
+`services/pre-api/openapi.yaml` with `npx`. They skip when `npx` is missing.
+
+`tests/test_package.py` builds the sdist, a wheel from that sdist and a wheel from this folder. It fails if one
+holds a file outside `pre_cli` and the three bundled packages, a `services`, `apps` or `ground_truth` path, a
+`seed.py` or `check.py`, or the name of the PRE library. PRE must never reach PyPI.
+
+## Release
+
+The CLI is on PyPI as `stratyfy-cli`. The command it installs is `pre`. `.github/workflows/release-cli.yml`
+publishes it with trusted publishing, so no PyPI token is stored.
+
+1. Set the new `version` in `pyproject.toml`. It is the only place that holds the version.
+2. Merge that change to `master`. CI runs `scripts/check pre-cli`, which builds the package and checks its files.
+3. Tag the merge commit and push the tag: `git tag stratyfy-cli-v<version>`, then
+   `git push origin stratyfy-cli-v<version>`.
+4. The workflow checks that the tag matches the version, builds, installs the wheel and runs `pre --version`. Then
+   it publishes in the GitHub environment `pypi`.
+
+Users install it with Python 3.11 or later: `pipx install stratyfy-cli`.

stratyfy_cli-0.1.0/README.md

@@ -0,0 +1,106 @@
+# pre-cli
+
+The `pre` command. A coding agent runs it to describe the user's database, train a PRE model, read its rules and
+score cases.
+It talks to the PRE API through `packages/pre-api-client`. It never imports PRE. Its sentences come from
+`packages/pre-words`, so they match the report.
+
+## Install
+
+```bash
+pipx install stratyfy-cli          # or: uv tool install stratyfy-cli
+```
+
+For development, run `poetry install` in this folder, then `poetry run pre --help`. `pre --version` prints the
+version.
+
+The wheel and the sdist bundle `pre_api_client`, `pre_words` and `pre_report` from `packages/`, so the install
+needs nothing else from this repo. `hatch_build.py` copies them in at build time. The CLI uses hatchling to build,
+because poetry-core cannot include files from outside this folder. Poetry still manages the development env.
+
+## Commands
+
+Each command prints a short text result and a next step. Add `--json` to get one JSON object instead. On
+failure the command exits with 1 and prints `code`, `message` and `next_step`.
+
+| Command | What it does |
+| --- | --- |
+| `pre login [--no-wait] [--api-url <url>]` | Signs in as `gh auth login` does. It prints a link and a code. The user signs in with an email code and approves the device. Then it writes a new key for this machine to `.pre/config.json`. With `--no-wait` it prints the link and exits; the next `pre login` waits for that same sign-in. That way an agent can show the user the link first. The default API is `https://api.stratyfy.ai/v1`. |
+| `pre logout` | Removes the key from `.pre/config.json`. The key keeps working until an admin revokes it, so the output names its id. |
+| `pre init --api-key <key> [--api-url <url>]` | Writes a key you already have to `.pre/config.json`. The key can also come from `PRE_API_KEY`. |
+| `pre connect <db>` | Describes a SQLite or Postgres database: tables, row counts, columns, types, null share, sample values and foreign keys. It opens the database read-only. |
+| `pre setup claude [--yes] [--dry-run] [--local]` | For Claude Code. Run it in your own terminal. It adds the API host and a remote Postgres host to Claude Code's sandbox network allowlist. It shows the change and asks first. It refuses to write when an agent runs it. See [Sandboxes](#sandboxes). |
+| `pre status` | Checks that the API answers and accepts the key, and names the workspace. Lists the datasets and models this folder made. |
+| `pre outcome define --name <slug> --sql <query> [--case account --cases accounts --event churn --event-past churned]` | Runs the outcome query and stores it. The query returns one row per case: the case id, then a 0/1 label. It refuses no rows, a label that is not 0 or 1, a repeated case id and a label that is always the same. The words go into every sentence the CLI prints. It guesses each word you leave out from the column names and says so. |
+| `pre outcome show` | Lists the stored outcomes and their queries. |
+| `pre extract --outcome <slug> --features <query>` | Runs the features query (the case id, then the features), joins it to the label and writes `.pre/data/<slug>.csv`. Nothing is sent. |
+| `pre extract --outcome <slug> --upload [--refresh]` | Sends the CSV the dry run wrote, unchanged. With `--refresh`, or with no CSV yet, it runs the queries again first. |
+| `pre train --outcome <slug> [--max-rules N] [--max-conditions N] [--no-wait] [--timeout S]` | Trains on the outcome's uploaded dataset. Every column but `id` is an input. It waits until the model is ready or failed and prints progress to stderr. When ready, it says how well the model predicts on held-out cases: the AUC and how many times the average rate the top 10% hold. |
+| `pre rules --outcome <slug>` or `pre rules --model <id>` | Prints the rules as sentences, strongest first, with points and direction. The baseline shows as the starting rate. `--json` gives the API's rules. |
+| `pre predict --outcome <slug> [--features <query>]` | Scores cases with the outcome's model. The query returns the case id, then the model inputs as of today, for example for the accounts still active. Without `--features` it scores the training cases as of their snapshot date and says so. It writes `.pre/data/<slug>.scores.csv`: the case id, the score, the points and the rules that fired as sentences, highest score first. It also writes `.pre/data/<slug>.scores.json` for `pre report`: the same scores with the rule ids that fired. It refuses a query that lacks an input or repeats a case id. |
+| `pre report --outcome <slug> [--actions <file.json>] [--labels <file.json>] [--top N]` | Writes `.pre/reports/<slug>.html` and `.pre/reports/<slug>.csv` from the scores `pre predict` saved. It sends nothing. The page says how well the model predicts, lists the top rules as sentences and the `N` cases most likely to have the outcome, with their reasons. The CSV holds the same cases. `--actions` maps a rule id to one suggested action. `--labels` maps an input column to a plain label. It refuses a rule id or a column the model lacks. When the scores came from the training cases, the page says so. |
+
+`<db>` is a SQLite file path, `sqlite:///path`, or `postgresql://user:password@host:5432/db`. Use `--schema` for
+a Postgres schema other than `public`.
+
+A `<query>` is the SQL itself or a path that ends in `.sql`. It must be one SELECT or WITH statement. The CLI
+opens SQLite with `mode=ro` and runs Postgres in a read-only transaction, so a query cannot change data. For
+Postgres, a database user with read access only is safer still.
+
+## What leaves the machine
+
+The CSV that `pre extract --upload` sends, and the rows that `pre predict` sends. Before it writes the CSV, `pre extract`:
+
+1. Drops a column when every word of its name is an identifier word and one of them is a core word. Core words
+   are `email`, `phone`, `mobile`, `ip`, `address`, `street`, `ssn`, `name` and `username`. The other identifier
+   words are `mail`, `number`, `first`, `last`, `full`, `user`, `contact`, `home` and `work`. So `work_email` and
+   `first_name` go, and `plan_name` and `address_verified` stay.
+2. Drops a column when a text value holds an email address or looks like a phone number.
+3. Replaces the case id with an HMAC of it in a column named `id`. The key is in `.pre/secret` (mode 600).
+   `.pre/data/<slug>.ids.csv` maps each hash back to the case id. It stays on this machine.
+
+The output names each dropped column and the reason.
+
+`pre predict` sends each case as the same HMAC of its id and the model's inputs, in batches of 1,000. It sends no
+other column. It maps the hashes back to the case ids in memory.
+
+## Sandboxes
+
+`pre setup` writes the smallest change it can. It merges into the file, so a second run changes nothing.
+
+It writes `.claude/settings.json`, key `sandbox.network.allowedDomains`. For a Postgres on this machine, `--local`
+also sets `sandbox.network.allowLocalBinding`, which opens every local port. It never sets `allowAllUnixSockets`.
+Claude Code is the only agent at launch; others are on the roadmap. The onboard skill comes with the plugin
+(`tools/agent-plugin`), not with `pre setup`.
+
+These key names come from secondary sources. They live in `pre_cli/sandbox.py`.
+
+## Local config
+
+`.pre/config.json` holds the API URL, the key and its id, the database URL, the outcome queries and the dataset
+and model ids that later commands create. While a `pre login --no-wait` waits, it also holds that sign-in. The API
+can also list every dataset and model in the workspace. Each command that writes the config also writes
+`.pre/.gitignore`, so git ignores the folder. Set `PRE_DIR` to use another folder.
+
+## Tests
+
+`scripts/check pre-cli` runs ruff and pytest. The `pre status` tests start a Prism mock of
+`services/pre-api/openapi.yaml` with `npx`. They skip when `npx` is missing.
+
+`tests/test_package.py` builds the sdist, a wheel from that sdist and a wheel from this folder. It fails if one
+holds a file outside `pre_cli` and the three bundled packages, a `services`, `apps` or `ground_truth` path, a
+`seed.py` or `check.py`, or the name of the PRE library. PRE must never reach PyPI.
+
+## Release
+
+The CLI is on PyPI as `stratyfy-cli`. The command it installs is `pre`. `.github/workflows/release-cli.yml`
+publishes it with trusted publishing, so no PyPI token is stored.
+
+1. Set the new `version` in `pyproject.toml`. It is the only place that holds the version.
+2. Merge that change to `master`. CI runs `scripts/check pre-cli`, which builds the package and checks its files.
+3. Tag the merge commit and push the tag: `git tag stratyfy-cli-v<version>`, then
+   `git push origin stratyfy-cli-v<version>`.
+4. The workflow checks that the tag matches the version, builds, installs the wheel and runs `pre --version`. Then
+   it publishes in the GitHub environment `pypi`.
+
+Users install it with Python 3.11 or later: `pipx install stratyfy-cli`.

stratyfy_cli-0.1.0/hatch_build.py

@@ -0,0 +1,20 @@
+"""Bundle the three sibling packages into the sdist and the wheel, so `pipx install` needs nothing from this repo.
+
+In the repo they live in `packages/`. An sdist holds them next to `pre_cli`, so a wheel built from it finds them.
+"""
+
+from pathlib import Path
+
+from hatchling.builders.hooks.plugin.interface import BuildHookInterface
+
+PACKAGES = Path(__file__).resolve().parents[2] / "packages"
+BUNDLED = {"pre_api_client": "pre-api-client", "pre_words": "pre-words", "pre_report": "pre-report"}
+
+
+class CustomBuildHook(BuildHookInterface):
+    def initialize(self, version, build_data):
+        # hatchling puts the repo's .gitignore in the sdist. It is not part of the CLI.
+        build_data["force_include"] = {k: v for k, v in build_data["force_include"].items() if v != ".gitignore"}
+        for name, folder in BUNDLED.items():
+            if not (Path(self.root) / name).is_dir():
+                build_data["force_include"][str(PACKAGES / folder / name)] = name

stratyfy_cli-0.1.0/pre_api_client/__init__.py

@@ -0,0 +1,8 @@
+"""A client library for accessing PRE API"""
+
+from .client import AuthenticatedClient, Client
+
+__all__ = (
+    "AuthenticatedClient",
+    "Client",
+)

stratyfy_cli-0.1.0/pre_api_client/api/__init__.py

@@ -0,0 +1 @@
+"""Contains methods for accessing the API"""

stratyfy_cli-0.1.0/pre_api_client/api/default/__init__.py

@@ -0,0 +1 @@
+"""Contains endpoint functions for accessing the API"""

stratyfy_cli-0.1.0/pre_api_client/api/default/create_dataset.py

@@ -0,0 +1,184 @@
+from http import HTTPStatus
+from typing import Any
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.create_dataset_body import CreateDatasetBody
+from ...models.dataset import Dataset
+from ...models.error import Error
+from ...types import Response
+
+
+def _get_kwargs(
+    *,
+    body: CreateDatasetBody,
+) -> dict[str, Any]:
+    headers: dict[str, Any] = {}
+
+    _kwargs: dict[str, Any] = {
+        "method": "post",
+        "url": "/datasets",
+    }
+
+    _kwargs["files"] = body.to_multipart()
+
+    headers["Content-Type"] = "multipart/form-data; boundary=+++"
+
+    _kwargs["headers"] = headers
+    return _kwargs
+
+
+def _parse_response(
+    *, client: AuthenticatedClient | Client, response: httpx.Response
+) -> Dataset | Error | None:
+    if response.status_code == 201:
+        response_201 = Dataset.from_dict(response.json())
+
+        return response_201
+
+    if response.status_code == 400:
+        response_400 = Error.from_dict(response.json())
+
+        return response_400
+
+    if response.status_code == 401:
+        response_401 = Error.from_dict(response.json())
+
+        return response_401
+
+    if response.status_code == 413:
+        response_413 = Error.from_dict(response.json())
+
+        return response_413
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(
+    *, client: AuthenticatedClient | Client, response: httpx.Response
+) -> Response[Dataset | Error]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: AuthenticatedClient,
+    body: CreateDatasetBody,
+) -> Response[Dataset | Error]:
+    """Upload labelled training data as a CSV or parquet file. The response holds the profile.
+
+     The API takes a file only. It does not take rows as JSON.
+
+    Args:
+        body (CreateDatasetBody):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Dataset | Error]
+    """
+
+    kwargs = _get_kwargs(
+        body=body,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    *,
+    client: AuthenticatedClient,
+    body: CreateDatasetBody,
+) -> Dataset | Error | None:
+    """Upload labelled training data as a CSV or parquet file. The response holds the profile.
+
+     The API takes a file only. It does not take rows as JSON.
+
+    Args:
+        body (CreateDatasetBody):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Dataset | Error
+    """
+
+    return sync_detailed(
+        client=client,
+        body=body,
+    ).parsed
+
+
+async def asyncio_detailed(
+    *,
+    client: AuthenticatedClient,
+    body: CreateDatasetBody,
+) -> Response[Dataset | Error]:
+    """Upload labelled training data as a CSV or parquet file. The response holds the profile.
+
+     The API takes a file only. It does not take rows as JSON.
+
+    Args:
+        body (CreateDatasetBody):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Dataset | Error]
+    """
+
+    kwargs = _get_kwargs(
+        body=body,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    *,
+    client: AuthenticatedClient,
+    body: CreateDatasetBody,
+) -> Dataset | Error | None:
+    """Upload labelled training data as a CSV or parquet file. The response holds the profile.
+
+     The API takes a file only. It does not take rows as JSON.
+
+    Args:
+        body (CreateDatasetBody):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Dataset | Error
+    """
+
+    return (
+        await asyncio_detailed(
+            client=client,
+            body=body,
+        )
+    ).parsed

stratyfy_cli-0.1.0/pre_api_client/api/default/create_model_version.py

@@ -0,0 +1,197 @@
+from http import HTTPStatus
+from typing import Any
+from urllib.parse import quote
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.create_model_version_body import CreateModelVersionBody
+from ...models.error import Error
+from ...models.model import Model
+from ...types import Response
+
+
+def _get_kwargs(
+    model_id: str,
+    *,
+    body: CreateModelVersionBody,
+) -> dict[str, Any]:
+    headers: dict[str, Any] = {}
+
+    _kwargs: dict[str, Any] = {
+        "method": "post",
+        "url": "/models/{model_id}/versions".format(
+            model_id=quote(str(model_id), safe=""),
+        ),
+    }
+
+    _kwargs["json"] = body.to_dict()
+
+    headers["Content-Type"] = "application/json"
+
+    _kwargs["headers"] = headers
+    return _kwargs
+
+
+def _parse_response(
+    *, client: AuthenticatedClient | Client, response: httpx.Response
+) -> Error | Model | None:
+    if response.status_code == 202:
+        response_202 = Model.from_dict(response.json())
+
+        return response_202
+
+    if response.status_code == 400:
+        response_400 = Error.from_dict(response.json())
+
+        return response_400
+
+    if response.status_code == 401:
+        response_401 = Error.from_dict(response.json())
+
+        return response_401
+
+    if response.status_code == 404:
+        response_404 = Error.from_dict(response.json())
+
+        return response_404
+
+    if response.status_code == 409:
+        response_409 = Error.from_dict(response.json())
+
+        return response_409
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(
+    *, client: AuthenticatedClient | Client, response: httpx.Response
+) -> Response[Error | Model]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    model_id: str,
+    *,
+    client: AuthenticatedClient,
+    body: CreateModelVersionBody,
+) -> Response[Error | Model]:
+    """Add, edit or remove rules. This makes a new version and refits it. The old version does not change.
+
+    Args:
+        model_id (str):
+        body (CreateModelVersionBody):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Error | Model]
+    """
+
+    kwargs = _get_kwargs(
+        model_id=model_id,
+        body=body,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    model_id: str,
+    *,
+    client: AuthenticatedClient,
+    body: CreateModelVersionBody,
+) -> Error | Model | None:
+    """Add, edit or remove rules. This makes a new version and refits it. The old version does not change.
+
+    Args:
+        model_id (str):
+        body (CreateModelVersionBody):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Error | Model
+    """
+
+    return sync_detailed(
+        model_id=model_id,
+        client=client,
+        body=body,
+    ).parsed
+
+
+async def asyncio_detailed(
+    model_id: str,
+    *,
+    client: AuthenticatedClient,
+    body: CreateModelVersionBody,
+) -> Response[Error | Model]:
+    """Add, edit or remove rules. This makes a new version and refits it. The old version does not change.
+
+    Args:
+        model_id (str):
+        body (CreateModelVersionBody):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Error | Model]
+    """
+
+    kwargs = _get_kwargs(
+        model_id=model_id,
+        body=body,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    model_id: str,
+    *,
+    client: AuthenticatedClient,
+    body: CreateModelVersionBody,
+) -> Error | Model | None:
+    """Add, edit or remove rules. This makes a new version and refits it. The old version does not change.
+
+    Args:
+        model_id (str):
+        body (CreateModelVersionBody):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Error | Model
+    """
+
+    return (
+        await asyncio_detailed(
+            model_id=model_id,
+            client=client,
+            body=body,
+        )
+    ).parsed