Wood Wide AI

https://docs.woodwide.ai
Admin
Wood Wide AI is an API-first numeric intelligence layer for structured data that transforms tables...
Tokens:46,802
Snippets:175
Trust Score:3.3
Update:9 months ago
Show doc for...
Tokens:
Raw
### Example Training and Inference Script Execution (Shell)

Source: https://docs.woodwide.ai/Quickstart

This shell script provides an example of how to execute the Woodwide AI training and inference process from the command line. It sets environment variables, parses arguments, validates inputs, and checks for required tools like 'jq'.

```shell
#!/bin/sh

export BASE_URL="https://beta.woodwide.ai/"
export WOODWIDE_API_KEY="sk_your_api_key_here"
usage() {
    echo "Usage: $0 -k WOODWIDE_API_KEY -m MODEL_NAME -d DATASET_NAME -r TRAIN_DATA -t TEST_DATA -l LABEL_COLUMN [-o OUTPUT_FILE]"
    echo "  -k WOODWIDE_API_KEY    Woodwide API Key"
    echo "  -m MODEL_NAME          Name for the model"
    echo "  -d DATASET_NAME        Name for the dataset"
    echo "  -r TRAIN_DATA          Path to the training CSV file"
    echo "  -t TEST_DATA           Path to the testing CSV file"
    echo "  -l LABEL_COLUMN        Name of the label column for training"
    echo "  -o OUTPUT_FILE         (Optional) File path to save inference results"
    exit 1
}

# Check if jq is installed
if ! command -v jq > /dev/null 2>&1;
    echo "Error: jq is required but not installed."
    exit 1
fi

while getopts ":k:m:d:r:t:l:o:" opt; do
  case $opt in
    k) WOODWIDE_API_KEY="$OPTARG" ;; 
    m) MODEL_NAME="$OPTARG" ;; 
    d) DATASET_NAME="$OPTARG" ;; 
    r) TRAIN_DATA="$OPTARG" ;; 
    t) TEST_DATA="$OPTARG" ;; 
    l) LABEL_COLUMN="$OPTARG" ;; 
    o) OUTPUT_FILE="$OPTARG" ;; 
    \?) echo "Invalid option: -$OPTARG" >&2; usage ;; 
    :) echo "Option -$OPTARG requires an argument." >&2; usage ;; 
  esac
done

if [ -z "$WOODWIDE_API_KEY" ] || [ -z "$MODEL_NAME" ] || [ -z "$DATASET_NAME" ] || [ -z "$TRAIN_DATA" ] || [ -z "$TEST_DATA" ] || [ -z "$LABEL_COLUMN" ]; then
    echo "Error: Missing required arguments."
    usage
fi

if [ ! -f "$TRAIN_DATA" ]; then
    echo "Error: Training data file '$TRAIN_DATA' not found."
    exit 1
fi

if [ ! -f "$TEST_DATA" ]; then
    echo "Error: Test data file '$TEST_DATA' not found."
    exit 1
fi

```

--------------------------------

### End-to-End Script Setup (Python)

Source: https://docs.woodwide.ai/Quickstart

Sets up the environment for an end-to-end script using Python. It specifies the required Python version and lists necessary dependencies like 'ucimlrepo', 'pandas', and 'woodwide'.

```python
# /// script
# requires-python = ">=3.11"
# dependencies = [
#   "ucimlrepo",
#   "pandas",
#   "woodwide",
# ]
# ///
import argparse
import os
import sys
import time
import json
import pandas as pd
from ucimlrepo import fetch_ucirepo
from woodwide import WoodWide

```

--------------------------------

### Environment Variables Setup

Source: https://docs.woodwide.ai/Quickstart

Sets up necessary environment variables for API authentication and base URL configuration. These variables are crucial for making authenticated requests to the Wood Wide AI API.

```bash
export WOODWIDE_API_KEY="sk_your_api_key_here"
export BASE_URL="https://beta.woodwide.ai"
```

--------------------------------

### List Datasets

Source: https://docs.woodwide.ai/Quickstart

Retrieves a list of all uploaded datasets. Requires authentication.

```APIDOC
## GET /api/datasets

### Description
Retrieves a list of all uploaded datasets. Requires authentication.

### Method
GET

### Endpoint
/api/datasets

### Parameters
#### Query Parameters
None

#### Request Body
None

### Request Example
```bash
curl -X GET "https://beta.woodwide.ai/api/datasets" \
  -H "accept: application/json" \
  -H "Authorization: Bearer sk_your_api_key_here"
```

### Response
#### Success Response (200)
- **datasets** (array) - A list of dataset objects.
  - **id** (string) - The unique identifier for the dataset.
  - **name** (string) - The name of the dataset.
  - **created_at** (string) - The timestamp when the dataset was created.

#### Response Example
```json
{
  "datasets": [
    {
      "id": "dataset_123",
      "name": "mydata",
      "created_at": "2023-10-27T10:00:00Z"
    }
  ]
}
```
```

--------------------------------

### Get Model Status

Source: https://docs.woodwide.ai/Quickstart

Retrieves the current training status and other details of a specific model.

```APIDOC
## GET /api/models/{model_id}

### Description
Retrieves the current training status and other details of a specific model.

### Method
GET

### Endpoint
/api/models/{model_id}

### Parameters
#### Path Parameters
- **model_id** (string) - Required - The unique identifier of the model to check.

#### Query Parameters
None

#### Request Body
None

### Request Example
```bash
curl -X GET "https://beta.woodwide.ai/api/models/model_xyz" \
  -H "accept: application/json" \
  -H "Authorization: Bearer sk_your_api_key_here"
```

### Response
#### Success Response (200)
- **model_id** (string) - The unique identifier of the model.
- **model_name** (string) - The name of the model.
- **task_type** (string) - The type of task the model is trained for.
- **training_status** (string) - The current status of the model training (e.g., 'PENDING', 'RUNNING', 'COMPLETE', 'FAILED').
- **created_at** (string) - The timestamp when the model was created.

#### Response Example
```json
{
  "model_id": "model_xyz",
  "model_name": "my_model_name",
  "task_type": "prediction",
  "training_status": "COMPLETE",
  "created_at": "2023-10-27T10:05:00Z"
}
```
```

--------------------------------

### Train Model using cURL

Source: https://docs.woodwide.ai/Quickstart

Initiates a model training job via a cURL POST request. This example specifies the task type (prediction), dataset name, model name, label column, and overwrite option.

```bash
curl -X POST "$BASE_URL/api/models/prediction/train?dataset_name=my_dataset_name" \
  -H "accept: application/json" \
  -H "Authorization: Bearer $WOODWIDE_API_KEY" \
  -H "Content-Type: application/x-www-form-urlencoded" \
  -d "model_name=my_model_name" \
  -d "label_column=my_label_column_name" \
  -d "overwrite=false"
```

--------------------------------

### GET /api/models/{model_id}

Source: https://docs.woodwide.ai/Quickstart

Retrieves the current status and details of a specific model training job.

```APIDOC
## GET /api/models/{model_id}

### Description
Retrieves the current status and details of a specific model training job.

### Method
GET

### Endpoint
/api/models/{model_id}

### Parameters
#### Path Parameters
- **model_id** (string) - Required - The unique identifier of the model to query.

#### Query Parameters
None

#### Request Body
None

### Request Example
```bash
curl -X GET "https://your-woodwide-api-url/api/models/model_def456uvw" \
  -H "accept: application/json" \
  -H "Authorization: Bearer YOUR_API_KEY"
```

### Response
#### Success Response (200)
- **id** (string) - The model's unique identifier.
- **model_name** (string) - The name of the model.
- **training_status** (string) - The current status of the training job (e.g., "PENDING", "IN_PROGRESS", "COMPLETE", "FAILED").
- Other relevant model training details.

#### Response Example
```json
{
  "id": "model_def456uvw",
  "model_name": "my_prediction_model",
  "training_status": "COMPLETE",
  "created_at": "2023-10-27T10:00:00Z",
  "completed_at": "2023-10-27T10:30:00Z"
}
```
```

--------------------------------

### Create Dataset

Source: https://docs.woodwide.ai/Quickstart

Uploads a new tabular dataset for use with the API. The dataset can be referenced later by its assigned name.

```APIDOC
## POST /api/datasets

### Description
Uploads a new tabular dataset for use with the API. The dataset can be referenced later by its assigned name.

### Method
POST

### Endpoint
/api/datasets

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **file** (file) - Required - The CSV file containing the tabular data.
- **name** (string) - Required - A unique name to identify this dataset.
- **overwrite** (boolean) - Optional - If true, overwrite an existing dataset with the same name. Defaults to false.

### Request Example
```bash
curl -X POST "https://beta.woodwide.ai/api/datasets" \
  -H "accept: application/json" \
  -H "Authorization: Bearer sk_your_api_key_here" \
  -H "Content-Type: multipart/form-data" \
  -F "file=@mydata.csv;type=text/csv" \
  -F "name=mydata" \
  -F "overwrite=false"
```

### Response
#### Success Response (200)
- **dataset_id** (string) - The unique identifier assigned to the uploaded dataset.
- **message** (string) - A confirmation message.

#### Response Example
```json
{
  "dataset_id": "dataset_abc",
  "message": "Dataset uploaded successfully."
}
```
```

--------------------------------

### Train Model

Source: https://docs.woodwide.ai/Quickstart

Initiates the training of a new model for a specified task type using an existing dataset.

```APIDOC
## POST /api/models/{task_type}/train

### Description
Initiates the training of a new model for a specified task type using an existing dataset.

### Method
POST

### Endpoint
/api/models/{task_type}/train

### Parameters
#### Path Parameters
- **task_type** (string) - Required - The type of task for the model (e.g., 'prediction', 'clustering').

#### Query Parameters
- **dataset_name** (string) - Required - The name of the dataset to use for training.
- **model_name** (string) - Optional - A custom name for the model. If not provided, a default name will be generated.
- **label_column** (string) - Required for 'prediction' task - The name of the column to predict.
- **overwrite** (boolean) - Optional - If true, overwrite an existing model with the same name. Defaults to false.

### Request Body
None (parameters are passed as query parameters or form data)

### Request Example
```bash
curl -X POST "https://beta.woodwide.ai/api/models/prediction/train?dataset_name=my_dataset_name" \
  -H "accept: application/json" \
  -H "Authorization: Bearer sk_your_api_key_here" \
  -H "Content-Type: application/x-www-form-urlencoded" \
  -d "model_name=my_model_name" \
  -d "label_column=my_label_column_name" \
  -d "overwrite=false"
```

### Response
#### Success Response (200)
- **model_id** (string) - The unique identifier for the newly created model.
- **status** (string) - The initial training status (e.g., 'PENDING').

#### Response Example
```json
{
  "model_id": "model_xyz",
  "status": "PENDING"
}
```
```

--------------------------------

### Run Inference and Format Results (Python)

Source: https://docs.woodwide.ai/Quickstart

This Python code snippet demonstrates how to run inference using a trained model and a test dataset. It handles formatting the results, whether they are Pydantic models, dictionaries, or lists, and optionally saves them to a file.

```python
result = client.api.models.prediction.infer(
            model_id=model_id,
            dataset_id=test_dataset_id
        )

    elapsed = time.time() - start_time
    print(f"Inference took {elapsed:.2f}s")

    # Assuming result is a dict or list, or a Pydantic model we can dump
    try:
        # If it's a Pydantic model
        if hasattr(result, "model_dump_json"):
             formatted_result = result.model_dump_json(indent=2)
        # If it's a dict
        elif isinstance(result, (dict, list)):
            formatted_result = json.dumps(result, indent=2)
        else:
            formatted_result = str(result)
    except Exception:
        formatted_result = str(result)

    if output_file:
        with open(output_file, "w") as f:
            f.write(formatted_result)
        print(f"Inference results saved to {output_file}")
    else:
        print("Inference Response:")
        print(formatted_result)
    print("")
```

--------------------------------

### POST /api/models/prediction/train

Source: https://docs.woodwide.ai/Quickstart

Initiates the training of a prediction model. Requires a dataset name and specifies the label column for training.

```APIDOC
## POST /api/models/prediction/train

### Description
Initiates the training of a prediction model. Requires a dataset name and specifies the label column for training.

### Method
POST

### Endpoint
/api/models/prediction/train

### Parameters
#### Query Parameters
- **dataset_name** (string) - Required - The name of the dataset to use for training.

#### Request Body
- **model_name** (string) - Required - The desired name for the model.
- **label_column** (string) - Required - The name of the column in the dataset to be used as the label.
- **overwrite** (boolean) - Optional - If true, overwrites an existing model with the same name.

### Request Example
```bash
curl -X POST "https://your-woodwide-api-url/api/models/prediction/train?dataset_name=my_dataset_name" \
  -H "accept: application/json" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/x-www-form-urlencoded" \
  -d "model_name=my_prediction_model" \
  -d "label_column=target_variable" \
  -d "overwrite=true"
```

### Response
#### Success Response (200)
- **id** (string) - The unique identifier for the initiated model training job.

#### Response Example
```json
{
  "id": "model_def456uvw"
}
```
```

--------------------------------

### POST /api/datasets

Source: https://docs.woodwide.ai/Quickstart

Uploads a dataset (training or testing) to the Woodwide AI platform. This endpoint supports multipart/form-data and allows overwriting existing datasets with the same name.

```APIDOC
## POST /api/datasets

### Description
Uploads a dataset (training or testing) to the Woodwide AI platform. This endpoint supports multipart/form-data and allows overwriting existing datasets with the same name.

### Method
POST

### Endpoint
/api/datasets

### Parameters
#### Query Parameters
None

#### Request Body
- **file** (file) - Required - The dataset file to upload (e.g., text/csv).
- **name** (string) - Required - The name for the dataset.
- **overwrite** (boolean) - Optional - If true, overwrites an existing dataset with the same name.

### Request Example
```bash
curl -X POST "https://your-woodwide-api-url/api/datasets" \
  -H "accept: application/json" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: multipart/form-data" \
  -F "file=@path/to/your/data.csv;type=text/csv" \
  -F "name=my_dataset_name" \
  -F "overwrite=true"
```

### Response
#### Success Response (200)
- **id** (string) - The unique identifier for the uploaded dataset.

#### Response Example
```json
{
  "id": "dataset_abc123xyz"
}
```
```

--------------------------------

### Main Training and Inference Workflow (Python)

Source: https://docs.woodwide.ai/Quickstart

This Python function orchestrates the entire process of training a model and running inference. It includes steps for argument parsing, client initialization, data fetching and uploading, model training, waiting for completion, and running inference, followed by cleanup.

```python
def main():
    args = setup_args()

    # Initialize SDK Client
    client = WoodWide(
        api_key=args.api_key,
        base_url=args.base_url
    )
    # 1. Fetch Data
    train_path, test_path, label_column = fetch_and_prepare_data()

    try:
        # 2. Upload Train
        train_dataset_id = upload_dataset(
            client, train_path, args.dataset_name
        )

        # 3. Upload Test
        test_dataset_name = f"{args.dataset_name}_test"
        test_dataset_id = upload_dataset(
            client, test_path, test_dataset_name
        )

        # 4. Train Model
        model_id = train_model(
            client,
            args.dataset_name,
            args.model_name,
            label_column,
            is_clustering=args.clustering,
        )

        # 5. Wait for Training
        wait_for_training(client, model_id)

        # 6. Run Inference
        run_inference(
            client, model_id, test_dataset_id, args.output_file, is_clustering=args.clustering
        )

    finally:
        # Cleanup temp files
        if os.path.exists(train_path):
            os.remove(train_path)
        if os.path.exists(test_path):
            os.remove(test_path)


if __name__ == "__main__":
    main()
```

--------------------------------

### Infer with Model

Source: https://docs.woodwide.ai/Quickstart

Uses a trained model to perform inference (e.g., make predictions, generate embeddings) on a specified dataset.

```APIDOC
## POST /api/models/{task_type}/{model_id}/infer

### Description
Uses a trained model to perform inference (e.g., make predictions, generate embeddings) on a specified dataset.

### Method
POST

### Endpoint
/api/models/{task_type}/{model_id}/infer

### Parameters
#### Path Parameters
- **task_type** (string) - Required - The type of task the model is trained for (e.g., 'prediction', 'clustering').
- **model_id** (string) - Required - The unique identifier of the trained model.

#### Query Parameters
- **dataset_id** (string) - Required - The unique identifier of the dataset to perform inference on.

#### Request Body
None (parameters are passed as query parameters or form data)

### Request Example
```bash
curl -X POST "https://beta.woodwide.ai/api/models/prediction/model_xyz/infer?dataset_id=dataset_abc" \
  -H "accept: application/json" \
  -H "Authorization: Bearer sk_your_api_key_here" \
  -H "Content-Type: application/x-www-form-urlencoded"
```

### Response
#### Success Response (200)
- **results** (object or array) - The inference results. The structure depends on the task type.
  - For prediction: Typically an array of predicted values.
  - For clustering: Typically an array of cluster assignments.

#### Response Example (Prediction)
```json
{
  "results": [
    10.5,
    12.1,
    9.8
  ]
}
```

#### Response Example (Clustering)
```json
{
  "results": [
    0,
    1,
    0,
    2
  ]
}
```
```

--------------------------------

### Parse Command-Line Arguments for Woodwide API Testing (Python)

Source: https://docs.woodwide.ai/Quickstart

Sets up command-line argument parsing for testing the Woodwide API. It accepts arguments for API key, model and dataset names, output file, base URL, and a flag for clustering mode. Requires the 'argparse' library.

```python
import argparse

# Defaults
DEFAULT_BASE_URL = "https://beta.woodwide.ai/"
UCI_DATASET_ID = 2  # Adult dataset

def setup_args():
    parser = argparse.ArgumentParser(
        description="Test Woodwide API with UCI Adult dataset"
    )
    parser.add_argument("-k", "--api-key", required=True, help="Woodwide API Key")
    parser.add_argument(
        "-m", "--model-name", default="uci_adult_model", help="Name for the model"
    )
    parser.add_argument(
        "-d", "--dataset-name", default="uci_adult", help="Name for the dataset"
    )
    parser.add_argument(
        "-o", "--output-file", help="File path to save inference results"
    )
    parser.add_argument(
        "--base-url", default=DEFAULT_BASE_URL, help="Base URL for API"
    )
    parser.add_argument(
        "-c", "--clustering", action="store_true", help="Run clustering instead of prediction"
    )
    return parser.parse_args()
```

--------------------------------

### POST /api/models/prediction/{model_id}/infer

Source: https://docs.woodwide.ai/Quickstart

Runs inference using a trained model on a specified dataset. The results can be saved to an output file if provided.

```APIDOC
## POST /api/models/prediction/{model_id}/infer

### Description
Runs inference using a trained model on a specified dataset. The results can be saved to an output file if provided.

### Method
POST

### Endpoint
/api/models/prediction/{model_id}/infer

### Parameters
#### Path Parameters
- **model_id** (string) - Required - The unique identifier of the trained model to use for inference.

#### Query Parameters
- **dataset_id** (string) - Required - The unique identifier of the dataset to run inference on.

#### Request Body
None

### Request Example
```bash
curl -N -s -X POST "https://your-woodwide-api-url/api/models/prediction/model_def456uvw/infer?dataset_id=dataset_abc123xyz" \
  -H "accept: application/json" \
  -H "Authorization: Bearer YOUR_API_KEY"
```

### Response
#### Success Response (200)
- The response will contain the inference results, typically in JSON format, or raw output if JSON parsing fails.

#### Response Example
```json
{
  "predictions": [
    {"feature1": 10, "prediction": "ClassA"},
    {"feature1": 25, "prediction": "ClassB"}
  ]
}
```
```

--------------------------------

### Prepare UCI Adult Dataset for Woodwide API (Python)

Source: https://docs.woodwide.ai/Quickstart

Fetches the UCI Adult dataset using 'fetch_ucirepo', splits it into training and testing sets (80/20 split), and saves them as CSV files. It identifies and returns the label column name. Requires 'pandas' and 'ucimlrepo' libraries.

```python
import pandas as pd
from ucimlrepo import fetch_ucirepo

# Defaults
UCI_DATASET_ID = 2  # Adult dataset

def fetch_and_prepare_data():
    print(f"Fetching UCI dataset ID={UCI_DATASET_ID}...")
    dataset = fetch_ucirepo(id=UCI_DATASET_ID)

    X = dataset.data.features
    y = dataset.data.targets

    # Combine features and targets
    df = pd.concat([X, y], axis=1)

    # Simple train/test split (80/20)
    train_df = df.sample(frac=0.8, random_state=42)
    test_df = df.drop(train_df.index)

    # Save to temporary CSV files
    train_path = "uci_train.csv"
    test_path = "uci_test.csv"

    train_df.to_csv(train_path, index=False)
    test_df.to_csv(test_path, index=False)

    label_column = y.columns[0]
    print(f"Data prepared. Label column: '{label_column}'")
    print(f"Train shape: {train_df.shape}, Test shape: {test_df.shape}")

    return train_path, test_path, label_column
```

--------------------------------

### Woodwide AI API Workflow (Bash)

Source: https://docs.woodwide.ai/Quickstart

A comprehensive Bash script demonstrating a typical workflow with the Woodwide AI API. It includes uploading training and testing datasets, initiating model training, polling for training completion or failure, and running inference on the trained model. It utilizes the `get_id_or_fail` and `curl_with_time` functions.

```bash
echo "Uploading Training Dataset ($TRAIN_DATA) with name '$DATASET_NAME' நான்கோ..."
TRAIN_UPLOAD_RESPONSE=$(curl_with_time -s -X POST "$BASE_URL/api/datasets" 
  -H "accept: application/json" 
  -H "Authorization: Bearer $WOODWIDE_API_KEY" 
  -H "Content-Type: multipart/form-data" 
  -F "file=@$TRAIN_DATA;type=text/csv" 
  -F "name=$DATASET_NAME" 
  -F "overwrite=true")

# Validate training upload by checking for ID
TRAIN_DATASET_ID=$(get_id_or_fail "$TRAIN_UPLOAD_RESPONSE" "training dataset upload")
echo "Training Dataset Uploaded. ID: $TRAIN_DATASET_ID"
echo ""

TEST_DATASET_NAME="${DATASET_NAME}_test"
echo "Uploading Test Dataset ($TEST_DATA) with name '$TEST_DATASET_NAME' நான்கோ..."
TEST_UPLOAD_RESPONSE=$(curl_with_time -s -X POST "$BASE_URL/api/datasets" 
  -H "accept: application/json" 
  -H "Authorization: Bearer $WOODWIDE_API_KEY" 
  -H "Content-Type: multipart/form-data" 
  -F "file=@$TEST_DATA;type=text/csv" 
  -F "name=$TEST_DATASET_NAME" 
  -F "overwrite=true")

TEST_DATASET_ID=$(get_id_or_fail "$TEST_UPLOAD_RESPONSE" "test dataset upload")
echo "Test Dataset Uploaded. ID: $TEST_DATASET_ID"
echo ""

echo "Training Model '$MODEL_NAME' using dataset '$DATASET_NAME' நான்கோ..."
TRAIN_RESPONSE=$(curl_with_time -s -X POST "$BASE_URL/api/models/prediction/train?dataset_name=$DATASET_NAME" 
  -H "accept: application/json" 
  -H "Authorization: Bearer $WOODWIDE_API_KEY" 
  -H "Content-Type: application/x-www-form-urlencoded" 
  -d "model_name=$MODEL_NAME" 
  -d "label_column=$LABEL_COLUMN" 
  -d "overwrite=true")

MODEL_ID=$(get_id_or_fail "$TRAIN_RESPONSE" "model training")
echo "Model Training Started. ID: $MODEL_ID"
echo ""

echo "Waiting for Model Training to Complete (ID: $MODEL_ID)..."
START_TIME=$(date +%s)
TIMEOUT=3000

while true; do
    STATUS_RESPONSE=$(curl_with_time -s -X GET "$BASE_URL/api/models/$MODEL_ID" 
      -H "accept: application/json" 
      -H "Authorization: Bearer $WOODWIDE_API_KEY")

    TRAINING_STATUS=$(echo "$STATUS_RESPONSE" | jq -r '.training_status // empty')

    if [ "$TRAINING_STATUS" = "COMPLETE" ]; then
        echo "Training Complete."
        echo "$STATUS_RESPONSE" | jq .
        break
    elif [ "$TRAINING_STATUS" = "FAILED" ]; then
        echo "Error: Model Training Failed."
        echo "$STATUS_RESPONSE" | jq .
        exit 1
    fi

    CURRENT_TIME=$(date +%s)
    ELAPSED_TIME=$((CURRENT_TIME - START_TIME))

    if [ $ELAPSED_TIME -ge $TIMEOUT ]; then
        echo "Error: Model Training Timed Out after ${TIMEOUT} seconds."
        echo "Last Status Response:"
        echo "$STATUS_RESPONSE" | jq .
        exit 1
    fi

    echo "Status: $TRAINING_STATUS. Waiting..."
    sleep 2
done

CURRENT_TIME=$(date +%s)
ELAPSED_TIME=$((CURRENT_TIME - START_TIME))

echo "Success: Took ${ELAPSED_TIME} seconds to train model."

echo ""

echo "Running Inference on Model $MODEL_ID with Test Dataset ID $TEST_DATASET_ID நான்கோ..."
INFER_RESPONSE=$(curl_with_time -N -s -X POST "$BASE_URL/api/models/prediction/$MODEL_ID/infer?dataset_id=$TEST_DATASET_ID" 
  -H "accept: application/json" 
  -H "Authorization: Bearer $WOODWIDE_API_KEY" 
  -H "Content-Type: application/x-www-form-urlencoded")

if [ ! -z "$OUTPUT_FILE" ]; then
	if echo "$INFER_RESPONSE" | jq . > "$OUTPUT_FILE" 2>/dev/null; then
        echo "Inference results saved (JSON formatted) to $OUTPUT_FILE"
    else
        echo "$INFER_RESPONSE" > "$OUTPUT_FILE"
        echo "Inference results saved (Raw output - JSON parsing failed) to $OUTPUT_FILE"
    fi
else
    echo "Inference Response:"
    echo "$INFER_RESPONSE" | jq . 2>/dev/null || echo "$INFER_RESPONSE"
fi
echo ""

```

--------------------------------

### Train Model with Woodwide API (Python)

Source: https://docs.woodwide.ai/Quickstart

Initiates model training on the Woodwide API, supporting both prediction and clustering models. It constructs the appropriate API endpoint and data payload based on the 'is_clustering' flag. Includes error handling for API responses and returns the model ID. Requires 'time' and 'sys' libraries.

```python
import time
import sys

def train_model(client, dataset_name, model_name, label_column, is_clustering=False):
    if is_clustering:
        print(f"Training Clustering Model '{model_name}' using dataset '{dataset_name}'...")
        endpoint = "/api/models/clustering/train"
        data = {
            "model_name": model_name,
            "overwrite": "true",
        }
    else:
        print(f"Training Prediction Model '{model_name}' using dataset '{dataset_name}'...")
        endpoint = "/api/models/prediction/train"
        data = {
            "model_name": model_name,
            "label_column": label_column,
            "overwrite": "true",
        }

    start_time = time.time()

    # Make the raw HTTP request for this endpoint, it's having issues
    response = client._client.post(
        endpoint,
        params={"dataset_name": dataset_name},
        data=data,
        headers=client.auth_headers,
    )

    elapsed = time.time() - start_time
    print(f"Request took {elapsed:.2f}s")

    if response.status_code != 200:
        print(f"Error starting training: {response.status_code}")
        print(response.text)
        sys.exit(1)

    response_json = response.json()
    model_id = response_json.get("id")
    if not model_id:
        print("Error: No Model ID returned")
        print(response_json)
        sys.exit(1)

    print(f"Model Training Started. ID: {model_id}\n")
    return model_id
```

--------------------------------

### Upload Dataset to Woodwide API (Python)

Source: https://docs.woodwide.ai/Quickstart

Uploads a dataset file to the Woodwide API using the provided client. It opens the file in binary read mode and uses the client's API to perform the upload, overwriting if a dataset with the same name exists. It returns the ID of the uploaded dataset. Requires 'time' library.

```python
import time

def upload_dataset(client, file_path, name):
    print(f"Uploading {file_path} as '{name}'...")
    start_time = time.time()

    with open(file_path, "rb") as f:
        # Note: The SDK typically handles file opening, but if it takes binary IO:
        dataset = client.api.datasets.upload(
            file=f,
            name=name,
            overwrite=True
        )

    elapsed = time.time() - start_time
    print(f"Upload took {elapsed:.2f}s")

    # Accessing ID directly assuming the SDK returns a Pydantic model
    dataset_id = dataset.id
    print(f"Dataset Uploaded. ID: {dataset_id}\n")
    return dataset_id
```

--------------------------------

### GET /api/datasets

Source: https://docs.woodwide.ai/api-reference/api/upload-dataset

Lists all uploaded datasets.

```APIDOC
## GET /api/datasets

### Description
Lists all uploaded datasets.

### Method
GET

### Endpoint
/api/datasets

### Parameters
None

### Request Example
```bash
curl -X GET "$BASE_URL/api/datasets" \
  -H "accept: application/json" \
  -H "Authorization: Bearer $WOODWIDE_API_KEY"
```

### Response
#### Success Response (200)
- **datasets** (array) - A list of dataset objects, each containing 'id' and 'name'.

#### Response Example
```json
{
  "datasets": [
    {
      "id": "dataset-12345",
      "name": "mydata"
    },
    {
      "id": "dataset-67890",
      "name": "another_dataset"
    }
  ]
}
```
```

--------------------------------

### GET /websites/woodwide_ai/models/{model_id}

Source: https://docs.woodwide.ai/api-reference/api/get-model

Retrieves detailed information for a specific model by its ID. Fails if the model is not found or does not belong to the user.

```APIDOC
## GET /websites/woodwide_ai/models/{model_id}

### Description
Retrieves detailed information for a specific model by its ID. Fails if the model is not found or does not belong to the user.

### Method
GET

### Endpoint
/websites/woodwide_ai/models/{model_id}

### Parameters
#### Path Parameters
- **model_id** (string) - Required - The unique identifier of the model to retrieve.

### Response
#### Success Response (200)
- **model_id** (string) - The unique identifier of the model.
- **name** (string) - The name of the model.
- **description** (string) - A detailed description of the model.
- **created_at** (string) - The timestamp when the model was created.
- **updated_at** (string) - The timestamp when the model was last updated.

#### Response Example
```json
{
  "model_id": "model_123",
  "name": "Example Model",
  "description": "This is a sample model for demonstration purposes.",
  "created_at": "2023-10-27T10:00:00Z",
  "updated_at": "2023-10-27T10:00:00Z"
}
```

#### Error Response (404)
- **error** (string) - Description of the error, e.g., "Model not found."

#### Error Response Example
```json
{
  "error": "Model not found."
}
```
```

--------------------------------

### Make Predictions using cURL

Source: https://docs.woodwide.ai/Quickstart

Executes inference on a trained model to make predictions on a specified dataset. This cURL command requires the model ID and the dataset ID for inference.

```bash
curl -X POST "$BASE_URL/api/models/prediction/{model_id}/infer?dataset_id={dataset_id}" \
  -H "accept: application/json" \
  -H "Authorization: Bearer $WOODWIDE_API_KEY" \
  -H "Content-Type: application/x-www-form-urlencoded"
```

--------------------------------

### Run Inference with Woodwide API (Python)

Source: https://docs.woodwide.ai/Quickstart

Executes inference on a trained model using a specified test dataset ID. It supports both prediction and clustering inference through the Woodwide API client. The function is designed to return the inference results. Requires 'time' library.

```python
import time

def run_inference(client, model_id, test_dataset_id, output_file, is_clustering=False):
    print(
        f"Running Inference on Model {model_id} with Test Dataset ID {test_dataset_id}..."
    )
    start_time = time.time()

    if is_clustering:
        result = client.api.models.clustering.infer(
            model_id=model_id,
            dataset_id=test_dataset_id
        )
    else:
        # Placeholder for prediction inference, assuming a similar structure
        # result = client.api.models.prediction.infer(
        #     model_id=model_id,
        #     dataset_id=test_dataset_id
        # )
        pass # Replace with actual prediction inference call

    elapsed = time.time() - start_time
    print(f"Inference request took {elapsed:.2f}s")

    # Further processing of 'result' would go here, e.g., saving to output_file
    print("Inference completed.")
    return result
```

--------------------------------

### Extract ID or Fail Function (Bash)

Source: https://docs.woodwide.ai/Quickstart

A Bash function that extracts an 'id' field from a JSON string using `jq`. It handles cases where the ID is missing or null, providing informative error messages and exiting if the ID cannot be retrieved. This is crucial for validating API responses.

```bash
get_id_or_fail() {
	# var name prefix to minimize risk of name collisions
    _giof_response="$1"
    _giof_context="$2"

    # Extract ID using jq. Returns empty string if not found or null.
    _giof_id=$(echo "$_giof_response" | jq -r '.id // empty')

    if [ -z "$_giof_id" ]; then
        echo "Error: Could not retrieve ID for $_giof_context."
        echo "Response from server:"
        echo "$_giof_response" | jq .
        exit 1
    fi
    echo "$_giof_id"
}
```

--------------------------------

### Fetch LLM Data

Source: https://docs.woodwide.ai/api-reference/api/run-clustering-inference

Retrieves navigation and other pages from the documentation by fetching the llms.txt file.

```APIDOC
## Fetch LLM Data

### Description
Retrieves navigation and other pages from the documentation by fetching the llms.txt file.

### Method
GET

### Endpoint
https://docs.woodwide.ai/llms.txt

### Parameters
None

### Request Example
None

### Response
#### Success Response (200)
- **(text)** - The content of the llms.txt file, containing navigation and other page data.

#### Response Example
```text
# Example content of llms.txt (structure may vary)
- Navigation:
  - Home
  - About
- Pages:
  - Getting Started
  - API Reference
```
```

--------------------------------

### Navigation Data Fetching

Source: https://docs.woodwide.ai/api-reference/api/list-models

Instructions on how to fetch navigation and other page data from the documentation.

```APIDOC
## Fetching Navigation Data

### Description
To retrieve navigation links and other page information, fetch the `llms.txt` file from the specified URL.

### Method
GET

### Endpoint
https://docs.woodwide.ai/llms.txt

### Parameters
None

### Request Example
None

### Response
#### Success Response (200)
- The response will contain the content of the `llms.txt` file, which includes navigation and other page data.

#### Response Example
```
# Example content of llms.txt (structure may vary)
- [Home](https://docs.woodwide.ai/)
- [Models](https://docs.woodwide.ai/models)
- [API Reference](https://docs.woodwide.ai/api)
```
```

--------------------------------

### POST /api/models/prediction/train

Source: https://docs.woodwide.ai/api-reference/api/train-prediction-model

Initiates training for a prediction model (regression or classification). This is an asynchronous operation that returns a model ID immediately. The model status will start as PENDING. You can poll the model status using the GET /models/{model_id} endpoint. Once the status is COMPLETE, you can use the model for inference via /models/prediction/{model_id}/infer.

```APIDOC
## POST /api/models/prediction/train

### Description
Initiates training for a prediction model (regression or classification). This is an asynchronous operation that returns a model ID immediately. The model status will start as PENDING. You can poll the model status using the GET /models/{model_id} endpoint. Once the status is COMPLETE, you can use the model for inference via /models/prediction/{model_id}/infer.

### Method
POST

### Endpoint
/api/models/prediction/train

### Parameters
#### Query Parameters
- **dataset_id** (string) - Optional - The ID of the dataset to use for training.
- **dataset_name** (string) - Optional - The name of the dataset to use for training.

#### Request Body
- **model_name** (string) - Required - The name for the model to be trained.
- **label_column** (string) - Required - The name of the column in the dataset that contains the target variable for prediction.
- **overwrite** (boolean) - Optional - If true, overwrite an existing model with the same name.

### Request Example
```yaml
POST /api/models/prediction/train?dataset_name=my_dataset_name
Content-Type: application/x-www-form-urlencoded
Authorization: Bearer sk_your_api_key_here

model_name=my_model_name
label_column=my_label_column_name
overwrite=false
```

### Response
#### Success Response (200)
- **model_id** (string) - The unique identifier for the trained model.
- **training_status** (string) - The initial status of the training job (e.g., PENDING).

#### Response Example
```json
{
  "model_id": "clt_abc123xyz",
  "training_status": "PENDING"
}
```
```

--------------------------------

### Timed cURL Request Function (Bash)

Source: https://docs.woodwide.ai/Quickstart

A Bash function that wraps the `curl` command to measure and display the total time taken for a request. It saves the output to a temporary file and then prints the time and the content, returning the original exit code of `curl`. This is useful for performance monitoring.

```bash
curl_with_time() {
    _cwt_temp=$(mktemp)
    curl -w "Time: %{time_total}s\n" -o "$_cwt_temp" "$@" >&2
    _cwt_ret=$?
    cat "$_cwt_temp"
    rm "$_cwt_temp"
    return $_cwt_ret
}
```

--------------------------------

### Create Dataset

Source: https://docs.woodwide.ai/api-reference/api/train-embedding-model

Uploads a new dataset for use with the API.

```APIDOC
## POST /api/datasets

### Description
Uploads a new dataset for use with the API.

### Method
POST

### Endpoint
/api/datasets

### Parameters
#### Request Body
- **file** (file) - Required - The CSV file to upload.
- **name** (string) - Required - The name to assign to the dataset.
- **overwrite** (boolean) - Optional - Whether to overwrite an existing dataset with the same name.

### Request Example
```json
{
  "file": "@mydata.csv",
  "name": "mydata",
  "overwrite": false
}
```

### Response
#### Success Response (200)
- **id** (string) - The unique identifier for the created dataset.
- **name** (string) - The name of the dataset.
- **created_at** (string) - The timestamp when the dataset was created.

#### Response Example
```json
{
  "id": "dataset-456",
  "name": "mydata",
  "created_at": "2023-10-27T10:05:00Z"
}
```
```

--------------------------------

### POST /api/models/{task_type}/train

Source: https://docs.woodwide.ai/api-reference/api/get-dataset

Initiates the training of a new model for a specified task. Returns a model ID and initial training status.

```APIDOC
## POST /api/models/{task_type}/train

### Description
Initiates the training of a new model for a specified task. Returns a model ID and initial training status.

### Method
POST

### Endpoint
/api/models/{task_type}/train

### Parameters
#### Path Parameters
- **task_type** (string) - Required - The type of task for which to train the model (e.g., 'prediction', 'clustering').

#### Query Parameters
- **dataset_name** (string) - Required - The name of the dataset to use for training.

#### Request Body
- **model_name** (string) - Required - A name for the model being trained.
- **label_column** (string) - Required - The name of the column to be used as the label for training (for prediction tasks).
- **overwrite** (boolean) - Optional - Whether to overwrite an existing model with the same name.

### Request Example
```bash
curl -X POST "https://beta.woodwide.ai/api/models/prediction/train?dataset_name=my_dataset_name" \
  -H "accept: application/json" \
  -H "Authorization: Bearer sk_your_api_key_here" \
  -H "Content-Type: application/x-www-form-urlencoded" \
  -d "model_name=my_model_name" \
  -d "label_column=my_label_column_name" \
  -d "overwrite=false"
```

### Response
#### Success Response (200)
- **model_id** (string) - The unique identifier of the trained model.
- **training_status** (string) - The initial training status (e.g., 'PENDING').

#### Response Example
```json
{
  "model_id": "string",
  "training_status": "PENDING"
}
```
```

--------------------------------

### Monitor Woodwide API Model Training Status (Python)

Source: https://docs.woodwide.ai/Quickstart

Polls the Woodwide API to check the training status of a model identified by its ID. It continues checking until the status is 'COMPLETE' or 'FAILED', or until a timeout is reached. Prints the model details upon completion or failure. Requires 'time' and 'sys' libraries.

```python
import time
import sys

def wait_for_training(client, model_id):
    print(f"Waiting for Model Training to Complete (ID: {model_id})...")
    start_time = time.time()
    timeout = 3000

    while True:
        model = client.api.models.retrieve(model_id)
        training_status = model.training_status

        if training_status == "COMPLETE":
            print("Training Complete.")
            print(model)
            break
        elif training_status == "FAILED":
            print("Error: Model Training Failed.")
            print(model)
            sys.exit(1)

        elapsed = time.time() - start_time
        if elapsed >= timeout:
            print(f"Error: Training Timed Out after {timeout} seconds.")
            sys.exit(1)

        print(f"Status: {training_status}. Waiting...")
        time.sleep(2)

    print(f"Success: Took {elapsed:.2f} seconds to train model.\n")
```
Tokens:
Raw