deepmirror 0.0.0__tar.gz

deepmirror-0.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 deepmirror
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

deepmirror-0.0.0/PKG-INFO

@@ -0,0 +1,20 @@
+Metadata-Version: 2.4
+Name: deepmirror
+Version: 0.0.0
+Summary: Command line interface for the deepmirror public API
+Requires-Python: >=3.12
+License-File: LICENSE
+Requires-Dist: click>=8.1.8
+Requires-Dist: requests>=2.31.0
+Requires-Dist: pandas>=2.2.2
+Requires-Dist: pydantic>=2.6.3
+Requires-Dist: pydantic-settings>=2.9.1
+Requires-Dist: scikit-learn>=1.6.1
+Requires-Dist: matplotlib>=3.10.3
+Requires-Dist: tqdm>=4.67.1
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: pre-commit>=3.6.0; extra == "dev"
+Requires-Dist: pylint>=3.3.6; extra == "dev"
+Requires-Dist: ruff>=0.11.0; extra == "dev"
+Dynamic: license-file

deepmirror-0.0.0/README.md

@@ -0,0 +1,120 @@
+# deepmirror-client
+
+`deepmirror-cli` is a command-line interface for interacting with the [deepmirror API](https://api.app.deepmirror.ai/public/docs). It allows you to train models, run predictions, and submit structure prediction jobs directly from your terminal.
+
+---
+
+## 🚀 Installation
+
+```bash
+pip install deepmirror
+```
+
+---
+
+## 🔐 Authentication
+
+Before using most commands, you need to log in to get your API token:
+
+```bash
+dm login EMAIL
+```
+
+This saves your token and host in `~/.config/deepmirror/` for reuse.
+
+---
+
+## 🧠 Model Commands
+
+### 📋 List Available Models
+
+```bash
+dm model list
+```
+
+### 📄 View Model Metadata
+
+```bash
+dm model metadata MODEL_ID
+```
+
+### 🔎 Get Full Model Info
+
+```bash
+dm model info MODEL_ID
+```
+
+---
+
+## 🏋️ Train a Custom Model
+
+```bash
+dm train --model-name mymodel \
+  --csv-file path/to/data.csv \
+  --smiles-column smiles \
+  --value-column target \
+  [--classification]
+```
+
+- `--classification` enables classification mode.
+- Default SMILES column is `smiles`, target column is `target`.
+
+---
+
+## 🔮 Run Inference
+
+You can run inference using either a CSV file or direct SMILES input:
+
+```bash
+# From a CSV or TXT file
+dm predict --model-name mymodel --csv-file inputs.csv
+
+# Direct SMILES
+dm predict --model-name mymodel --smiles "CCO"
+```
+
+---
+
+## 🧬 Structure Prediction
+
+### 🧠 Predict Protein-Ligand Structure
+
+```bash
+dm structure predict protein.pdb ligand.sdf --model chai
+```
+
+- Default model is `chai`.
+- Protein and ligand must be valid file paths.
+
+### 📦 Download Prediction Result
+
+```bash
+dm structure download TASK_ID result.zip
+```
+
+### 📃 List Submitted Jobs
+
+```bash
+dm structure list
+```
+
+---
+
+## ⚙️ Configuration
+
+- API host and token are saved under `~/.config/deepmirror/`.
+- You can override the API host:
+
+  - via `--host` option on any command
+  - or by setting `DEEPMIRROR_API_ENV=local`
+
+---
+
+## 💡 Tips
+
+- If a token is missing or expired, commands will prompt you to log in again.
+- Use `--help` on any command for more details, e.g.:
+
+  ```bash
+  dm train --help
+  ```

deepmirror-0.0.0/deepmirror/__init__.py

@@ -0,0 +1,31 @@
+"""deepmirror CLI package."""
+
+from .api import (
+    authenticate,
+    download_structure_prediction,
+    get_predict_hlm,
+    list_models,
+    list_structure_tasks,
+    model_info,
+    model_metadata,
+    predict,
+    predict_hlm,
+    save_token,
+    structure_predict,
+    train,
+)
+
+__all__ = [
+    "authenticate",
+    "list_models",
+    "predict",
+    "save_token",
+    "list_structure_tasks",
+    "download_structure_prediction",
+    "structure_predict",
+    "train",
+    "model_metadata",
+    "predict_hlm",
+    "get_predict_hlm",
+    "model_info",
+]

deepmirror-0.0.0/deepmirror/api.py

@@ -0,0 +1,264 @@
+"""deepmirror API client for interacting with the deepmirror platform.
+
+This module provides functions for authentication, model management, and inference
+using the deepmirror API. It handles API token management and provides a clean
+interface for making API requests.
+"""
+
+from typing import Any
+
+import pandas as pd
+import requests
+
+from .config import settings
+
+
+def save_token(token: str) -> None:
+    """Save the API token to the config directory."""
+    settings.CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    settings.TOKEN_FILE.write_text(token)
+    settings.TOKEN_FILE.chmod(0o600)
+    print(f"API token saved to {settings.TOKEN_FILE}")
+
+
+def load_token() -> str:
+    """Load the API token from the config directory."""
+    if not settings.TOKEN_FILE.exists():
+        raise RuntimeError("API token not found; please login or provide one")
+    return settings.TOKEN_FILE.read_text().strip()
+
+
+def authenticate(username: str, password: str) -> str:
+    """Authenticate with the deepmirror API."""
+    host = settings.HOST
+    url = f"{host}/api/v3/public/authenticate?token_lifetime_minutes=720"
+    data = {
+        "grant_type": "password",
+        "username": username,
+        "password": password,
+        "scope": "",
+        "client_id": "string",
+        "client_secret": "string",
+    }
+    headers = {
+        "accept": "application/json",
+        "Content-Type": "application/x-www-form-urlencoded",
+    }
+    response = requests.post(url, data=data, headers=headers, timeout=29)
+    if response.status_code != 200:
+        raise RuntimeError(f"Login failed: {response.text}")
+    return response.json().get("api_token")
+
+
+def list_models() -> Any:
+    """List all models."""
+    token = load_token()
+    url = f"{settings.HOST}/api/v3/public/models/"
+    response = requests.post(url, json={"api_token": token}, timeout=29)
+    if response.status_code != 200:
+        raise RuntimeError(response.text)
+    return response.json()
+
+
+def train(
+    model_name: str,
+    csv_file: str,
+    smiles_column: str,
+    value_column: str,
+    classification: bool = False,
+) -> Any:
+    """Train a model."""
+    token = load_token()
+    df = pd.read_csv(csv_file)
+    if smiles_column not in df.columns or value_column not in df.columns:
+        raise ValueError("CSV missing required columns")
+    x = df[smiles_column].astype(str).tolist()
+    y = df[value_column].astype(float).tolist()
+    payload = {
+        "model_name": model_name,
+        "api_token": token,
+        "x": x,
+        "y": y,
+        "is_classification": classification,
+    }
+    response = requests.post(
+        f"{settings.HOST}/api/v3/public/train/", json=payload, timeout=29
+    )
+    if response.status_code != 200:
+        raise RuntimeError(response.text)
+    return response.json()
+
+
+def predict_hlm(
+    smiles: list[str],
+) -> Any:
+    """Predict using HLM."""
+    token = load_token()
+    payload = {
+        "api_token": token,
+        "x": smiles,
+    }
+
+    response = requests.post(
+        f"{settings.HOST}/api/v3/public/predict-hlm/", json=payload, timeout=29
+    )
+    if response.status_code != 200:
+        raise RuntimeError(response.text)
+    return response.json()
+
+
+def get_predict_hlm(
+    task_id: str,
+) -> Any:
+    """Get predictions from HLM."""
+    token = load_token()
+    response = requests.post(
+        f"{settings.HOST}/api/v3/public/predict-hlm/{task_id}",
+        json={"api_token": token},
+        timeout=29,
+    )
+
+    if response.status_code not in [200, 202]:
+        raise RuntimeError(response.text)
+    return response.json()
+
+
+def predict(
+    model_name: str,
+    csv_file: str | None = None,
+    smiles_column: str | None = None,
+    smiles: list[str] | None = None,
+) -> Any:
+    """Predict using a model."""
+    token = load_token()
+    # Handle direct SMILES input
+    if smiles is not None:
+        inputs = smiles
+    # Handle CSV input with pandas
+    elif csv_file and csv_file.endswith(".csv") and smiles_column:
+        df = pd.read_csv(csv_file)
+        if smiles_column not in df.columns:
+            raise ValueError(f"CSV missing required column: {smiles_column}")
+        inputs = df[smiles_column].astype(str).tolist()
+    else:
+        raise ValueError(
+            "Either csv_file & smiles_column or smiles must be provided"
+        )
+
+    payload = {"model_name": model_name, "input": inputs, "api_token": token}
+    response = requests.post(
+        f"{settings.HOST}/api/v3/public/inference/", json=payload, timeout=29
+    )
+    if response.status_code != 200:
+        raise RuntimeError(response.text)
+
+    predictions = response.json()
+
+    # Add predictions to CSV if using CSV input
+    if csv_file and csv_file.endswith(".csv") and smiles_column:
+        df["prediction"] = predictions["prediction"]
+        df["confidence"] = predictions["confidence"]
+        output_file = csv_file.replace(".csv", "_predictions.csv")
+        df.to_csv(output_file, index=False)
+        print(f"Predictions saved to {output_file}")
+        return {"output_file": output_file}
+
+    # Create predictions DataFrame for text file or direct SMILES input
+    results_df = pd.DataFrame(
+        {
+            "smiles": inputs,
+            "prediction": predictions["prediction"],
+            "confidence": predictions["confidence"],
+        }
+    )
+
+    if csv_file:
+        output_file = csv_file.rsplit(".", 1)[0] + "_predictions.csv"
+        results_df.to_csv(output_file, index=False)
+        return {"output_file": output_file}
+
+    return predictions
+
+
+def structure_predict(
+    protein: str,
+    ligand: str,
+    model: str,
+) -> Any:
+    """Predict a structure."""
+    token = load_token()
+    payload = {
+        "protein": protein,
+        "ligand": ligand,
+        "model": model,
+        "api_token": token,
+    }
+    response = requests.post(
+        f"{settings.HOST}/api/v3/public/structure_prediction/",
+        json=payload,
+        timeout=29,
+    )
+    if response.status_code != 200:
+        raise RuntimeError(response.text)
+    return response.json()
+
+
+def list_structure_tasks() -> Any:
+    """List all structure prediction tasks."""
+    token = load_token()
+    payload = {"api_token": token}
+    response = requests.post(
+        f"{settings.HOST}/api/v3/public/structure_prediction/get_all_tasks/",
+        json=payload,
+        timeout=29,
+    )
+    if response.status_code != 200:
+        raise RuntimeError(response.text)
+    return response.json()
+
+
+def download_structure_prediction(
+    task_id: str,
+) -> bytes:
+    """Download a structure prediction task."""
+    token = load_token()
+    response = requests.post(
+        f"{settings.HOST}/api/v3/public/structure_prediction/download/{task_id}",
+        headers={
+            "accept": "application/json",
+            "Content-Type": "application/json",
+        },
+        json={
+            "api_token": token,
+        },
+        timeout=29,
+    )
+    if response.status_code != 200:
+        raise RuntimeError(response.text)
+    return response.content
+
+
+def model_metadata(model_id: str) -> Any:
+    """Get metadata for a specific model."""
+    token = load_token()
+    response = requests.post(
+        f"{settings.HOST}/api/v3/public/models/metadata/{model_id}",
+        json={"api_token": token},
+        timeout=29,
+    )
+    if response.status_code != 200:
+        raise RuntimeError(response.text)
+    return response.json()
+
+
+def model_info(model_id: str) -> Any:
+    """Get detailed information for a specific model."""
+    token = load_token()
+    response = requests.post(
+        f"{settings.HOST}/api/v3/public/models/{model_id}",
+        json={"api_token": token},
+        timeout=29,
+    )
+    if response.status_code != 200:
+        raise RuntimeError(response.text)
+    return response.json()

deepmirror-0.0.0/deepmirror/cli.py

@@ -0,0 +1,193 @@
+"""Command line interface for interacting with the deepmirror API.
+
+This module provides a CLI for authenticating, managing models, and making
+predictions using the deepmirror platform. It wraps the API client functionality
+in an easy-to-use command line tool.
+"""
+
+import getpass
+import json
+
+import click
+
+from . import api
+
+
+def _save_token(token: str) -> None:
+    api.save_token(token)
+
+
+def _load_token(token: str | None) -> str:
+    if token:
+        return token
+    try:
+        return api.load_token()
+    except RuntimeError as exc:
+        raise click.UsageError(
+            "API token required. Please login or pass --token"
+        ) from exc
+
+
+@click.group()
+def cli() -> None:
+    """Interact with the deepmirror public API."""
+
+
+@cli.command()
+@click.argument("username", required=True)
+def login(username: str) -> None:
+    """Authenticate and obtain an API token."""
+    if not username:
+        username = input("Email: ")
+    password = getpass.getpass("Password: ")
+
+    try:
+        token = api.authenticate(username, password)
+    except RuntimeError as exc:
+        raise click.ClickException(str(exc)) from exc
+    _save_token(token)
+
+
+@cli.group()
+def model() -> None:
+    """Model operations."""
+
+
+@model.command("list")
+def model_list() -> None:
+    """List available models for inference."""
+    try:
+        data = api.list_models()
+    except RuntimeError as exc:
+        raise click.ClickException(str(exc)) from exc
+    click.echo(json.dumps(data, indent=2))
+
+
+@model.command()
+@click.argument("model_id")
+def metadata(model_id: str) -> None:
+    """Get metadata for a specific model."""
+    try:
+        data = api.model_metadata(model_id)
+    except RuntimeError as exc:
+        raise click.ClickException(str(exc)) from exc
+    click.echo(json.dumps(data, indent=2))
+
+
+@model.command()
+@click.argument("model_id")
+def info(model_id: str) -> None:
+    """Get detailed information for a specific model."""
+    try:
+        data = api.model_info(model_id)
+    except RuntimeError as exc:
+        raise click.ClickException(str(exc)) from exc
+    click.echo(json.dumps(data, indent=2))
+
+
+@cli.command()
+@click.option("--model-name", required=True)
+@click.option("--csv-file", type=click.Path(exists=True), required=True)
+@click.option("--smiles-column", default="smiles", show_default=True)
+@click.option("--value-column", default="target", show_default=True)
+@click.option("--classification", is_flag=True, default=False)
+def train(
+    model_name: str,
+    csv_file: str,
+    smiles_column: str,
+    value_column: str,
+    classification: bool,
+) -> None:
+    """Train a custom model from a CSV file."""
+    try:
+        data = api.train(
+            model_name,
+            csv_file,
+            smiles_column,
+            value_column,
+            classification,
+        )
+    except (ValueError, RuntimeError) as exc:
+        raise click.ClickException(str(exc)) from exc
+    click.echo(json.dumps(data, indent=2))
+
+
+@cli.command()
+@click.option("--model-name", required=True)
+@click.option("--input-file", type=click.Path(exists=True))
+@click.option(
+    "--input-header",
+    default="smiles",
+    help="Column name for SMILES in CSV input",
+)
+@click.option("--input-smiles", multiple=True, help="Direct SMILES input")
+def predict(
+    model_name: str,
+    csv_file: str | None,
+    smiles_column: str | None,
+    smiles: tuple[str, ...] | None,
+) -> None:
+    """Run prediction using a trained model.
+
+    Takes input as either a CSV file with SMILES column, a text file with SMILES per line,
+    or direct SMILES strings via --input-smiles.
+    """
+    if not csv_file and not smiles:
+        raise click.UsageError("Either --csv-file or --smiles must be provided")
+
+    try:
+        data = api.predict(
+            model_name,
+            csv_file=csv_file,
+            smiles_column=smiles_column,
+            smiles=list(smiles) if smiles else None,
+        )
+    except (ValueError, RuntimeError) as exc:
+        raise click.ClickException(str(exc)) from exc
+    click.echo(json.dumps(data, indent=2))
+
+
+@cli.group()
+def structure() -> None:
+    """Structure prediction operations."""
+
+
+@structure.command("predict")
+@click.argument("protein")
+@click.argument("ligand")
+@click.option("--model-name", default="chai", show_default=True)
+def structure_predict(protein: str, ligand: str, model_name: str) -> None:
+    """Submit a structure prediction job."""
+    try:
+        data = api.structure_predict(protein, ligand, model_name)
+    except RuntimeError as exc:
+        raise click.ClickException(str(exc)) from exc
+    click.echo(json.dumps(data, indent=2))
+
+
+@structure.command("list")
+def structure_list() -> None:
+    """List submitted structure prediction tasks."""
+    try:
+        data = api.list_structure_tasks()
+    except RuntimeError as exc:
+        raise click.ClickException(str(exc)) from exc
+    click.echo(json.dumps(data, indent=2))
+
+
+@structure.command("download")
+@click.argument("task_id")
+@click.argument("output_file", type=click.Path())
+def structure_download(task_id: str, output_file: str) -> None:
+    """Download structure prediction results."""
+    try:
+        data = api.download_structure_prediction(task_id)
+        with open(output_file, "wb") as f:
+            f.write(data)
+    except RuntimeError as exc:
+        raise click.ClickException(str(exc)) from exc
+    click.echo(f"Downloaded structure prediction to {output_file}")
+
+
+if __name__ == "__main__":
+    cli()

deepmirror-0.0.0/deepmirror/config.py

@@ -0,0 +1,31 @@
+"""Configuration for the deepmirror CLI.
+
+This module defines the settings for the deepmirror CLI, including the API host,
+and the directory where the API token is stored.
+"""
+
+import os
+from pathlib import Path
+
+from pydantic_settings import BaseSettings
+
+
+# pylint: disable=too-few-public-methods
+class Settings(BaseSettings):
+    """Settings for the deepmirror CLI."""
+
+    HOST: str = "https://api.app.deepmirror.ai"
+
+    if os.name == "nt":
+        BASE_DIR: Path = Path(os.getenv("APPDATA", str(Path.home()))) / "Local"
+    else:
+        BASE_DIR: Path = Path(
+            os.getenv("XDG_CONFIG_HOME", str(Path.home() / ".config"))
+        )
+
+    CONFIG_DIR: Path = BASE_DIR / "deepmirror"
+    TOKEN_FILE: Path = CONFIG_DIR / "token"
+    HOST_FILE: Path = CONFIG_DIR / "host"
+
+
+settings = Settings()

deepmirror-0.0.0/deepmirror.egg-info/PKG-INFO

@@ -0,0 +1,20 @@
+Metadata-Version: 2.4
+Name: deepmirror
+Version: 0.0.0
+Summary: Command line interface for the deepmirror public API
+Requires-Python: >=3.12
+License-File: LICENSE
+Requires-Dist: click>=8.1.8
+Requires-Dist: requests>=2.31.0
+Requires-Dist: pandas>=2.2.2
+Requires-Dist: pydantic>=2.6.3
+Requires-Dist: pydantic-settings>=2.9.1
+Requires-Dist: scikit-learn>=1.6.1
+Requires-Dist: matplotlib>=3.10.3
+Requires-Dist: tqdm>=4.67.1
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: pre-commit>=3.6.0; extra == "dev"
+Requires-Dist: pylint>=3.3.6; extra == "dev"
+Requires-Dist: ruff>=0.11.0; extra == "dev"
+Dynamic: license-file

deepmirror-0.0.0/deepmirror.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+LICENSE
+README.md
+pyproject.toml
+deepmirror/__init__.py
+deepmirror/api.py
+deepmirror/cli.py
+deepmirror/config.py
+deepmirror.egg-info/PKG-INFO
+deepmirror.egg-info/SOURCES.txt
+deepmirror.egg-info/dependency_links.txt
+deepmirror.egg-info/entry_points.txt
+deepmirror.egg-info/requires.txt
+deepmirror.egg-info/top_level.txt
+tests/test_train.py

deepmirror-0.0.0/deepmirror.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

deepmirror-0.0.0/deepmirror.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+dm = deepmirror.cli:cli

deepmirror-0.0.0/deepmirror.egg-info/requires.txt

@@ -0,0 +1,14 @@
+click>=8.1.8
+requests>=2.31.0
+pandas>=2.2.2
+pydantic>=2.6.3
+pydantic-settings>=2.9.1
+scikit-learn>=1.6.1
+matplotlib>=3.10.3
+tqdm>=4.67.1
+
+[dev]
+pytest>=8.0.0
+pre-commit>=3.6.0
+pylint>=3.3.6
+ruff>=0.11.0

deepmirror-0.0.0/deepmirror.egg-info/top_level.txt

@@ -0,0 +1 @@
+deepmirror

deepmirror-0.0.0/pyproject.toml

@@ -0,0 +1,40 @@
+[project]
+name = "deepmirror"
+version = "0.0.0"
+description = "Command line interface for the deepmirror public API"
+requires-python = ">=3.12"
+
+dependencies = [
+  "click>=8.1.8",             # BSD-3
+  "requests>=2.31.0",         # Apache-2.0
+  "pandas>=2.2.2",            # BSD-3
+  "pydantic>=2.6.3",          # MIT
+  "pydantic-settings>=2.9.1", # MIT
+  "scikit-learn>=1.6.1",      # BSD-3
+  "matplotlib>=3.10.3",       # PSF
+  "tqdm>=4.67.1",             # MPL-2.0
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0.0",
+    "pre-commit>=3.6.0",
+    "pylint>=3.3.6",
+    "ruff>=0.11.0",
+]
+
+
+[project.scripts]
+dm = "deepmirror.cli:cli"
+
+[build-system]
+requires = ["setuptools>=61.2", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools]
+packages = ["deepmirror"]
+
+
+[tool.ruff]
+line-length = 80
+target-version = 'py313'

deepmirror-0.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

deepmirror-0.0.0/tests/test_train.py

@@ -0,0 +1,47 @@
+"""Test that the train functionality can correcelty load data from a CSV file."""
+
+from pathlib import Path
+from unittest import mock
+
+import pytest
+
+from deepmirror import api
+
+
+@pytest.fixture
+def csv_path(tmp_path):
+    """Create a temporary CSV file for testing."""
+    path = tmp_path / "data.csv"
+    return path
+
+
+def test_train_valid_columns(test_csv_path: Path) -> None:
+    """Test training with valid columns."""
+    test_csv_path.write_text("smiles,value\nCCO,1\n")
+    with mock.patch("deepmirror.api.requests.post") as mock_post:
+        mock_post.return_value.status_code = 200
+        mock_post.return_value.json.return_value = {"ok": True}
+        result = api.train(
+            "mymodel",
+            str(test_csv_path),
+            "smiles",
+            "value",
+            False,
+        )
+        assert result == {"ok": True}
+        payload = mock_post.call_args.kwargs["json"]
+        assert payload["x"] == ["CCO"]
+        assert payload["y"] == [1.0]
+
+
+def test_train_missing_columns(test_csv_path: Path) -> None:
+    """Test training with missing columns."""
+    test_csv_path.write_text("a,b\n1,2\n")
+    with pytest.raises(ValueError):
+        api.train(
+            "mymodel",
+            str(test_csv_path),
+            "smiles",
+            "value",
+            False,
+        )