# Run the Apollo model on existing recordings

POST /v1/models/apollo
Content-Type: application/json

Create a new run of the Apollo model for a specific user. Model runs require two recordings:
1. A mood question recording - for example, the user's response to "How are you feeling today?"
2. A read-aloud recording - for example, the user reading a standard passage

- For assistance, please contact our support team.

The response contains:
 * Upload urls for both recordings which can be uploaded to via `PUT` requests
 * The id of the new model run which can be used to poll for results **after both recordings have been uploaded**

> **Note**:
> * Both recordings must be uploaded for the model to start processing
> * Each recording must contain at least 15 seconds of speech and be under 3 minutes in length
> * Supported audio formats are FLAC, MP3, MP4, Ogg, WebM, WAV
> * Each upload URL is valid for 1 hour

Reference: https://docs.thymia.ai/api-reference/plant-store-api/apollo/create-apollo-model-run-v-1-models-apollo-post

## OpenAPI Specification

```yaml
openapi: 3.1.0
info:
  title: Thymia API
  version: 1.0.0
paths:
  /v1/models/apollo:
    post:
      operationId: create-apollo-model-run-v-1-models-apollo-post
      summary: Run the Apollo model on existing recordings
      description: >-
        Create a new run of the Apollo model for a specific user. Model runs
        require two recordings:

        1. A mood question recording - for example, the user's response to "How
        are you feeling today?"

        2. A read-aloud recording - for example, the user reading a standard
        passage


        - For assistance, please contact our support team.


        The response contains:
         * Upload urls for both recordings which can be uploaded to via `PUT` requests
         * The id of the new model run which can be used to poll for results **after both recordings have been uploaded**

        > **Note**:

        > * Both recordings must be uploaded for the model to start processing

        > * Each recording must contain at least 15 seconds of speech and be
        under 3 minutes in length

        > * Supported audio formats are FLAC, MP3, MP4, Ogg, WebM, WAV

        > * Each upload URL is valid for 1 hour
      tags:
        - subpackage_apollo
      parameters:
        - name: x-api-key
          in: header
          description: Your API Activation Key
          required: true
          schema:
            type: string
      responses:
        '200':
          description: >-
            Details of new model run created, including upload links for the two
            required recordings
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ApolloModelRunCreateResponse'
        '422':
          description: Validation Error
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/HTTPValidationError'
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/ApolloModelRunCreate'
components:
  schemas:
    BirthSex:
      type: string
      enum:
        - MALE
        - FEMALE
        - INTERSEX
        - UNKNOWN
      description: An enumeration.
      title: BirthSex
    UserDetails:
      type: object
      properties:
        userLabel:
          type: string
          description: A unique label identifying a user that all model input refers to
        dateOfBirth:
          type: string
          format: date
          description: >-
            An ISO 8601 date; if day or month are unknown, supply the parts
            which *are* known and use `01` for the rest
        birthSex:
          $ref: '#/components/schemas/BirthSex'
          description: The sex assigned to a user at birth
      required:
        - userLabel
        - dateOfBirth
        - birthSex
      title: UserDetails
    LanguageCode:
      type: string
      enum:
        - en
        - en-AU
        - en-GB
        - en-IE
        - en-IN
        - en-US
        - en-ZA
        - es-ES
        - es-US
        - id-ID
        - ja-JP
      description: An enumeration.
      title: LanguageCode
    ApolloModelRunCreate:
      type: object
      properties:
        user:
          $ref: '#/components/schemas/UserDetails'
          description: The user that this model run is being submitted for
        language:
          $ref: '#/components/schemas/LanguageCode'
          description: >-
            The code of the language being spoken by the user in the recordings
            to be uploaded
        deleteData:
          type: boolean
          default: false
          description: >-
            Boolean flag indicating if user data is to be deleted after the
            completion of the model run. If True, the recordings, model inputs
            and model results will be deleted 12 hrs after the model run
            completes. Attempts to retrieve results after this time will receive
            a 404 error.
      required:
        - user
        - language
      title: ApolloModelRunCreate
    ApolloUploadUrls:
      type: object
      properties:
        moodQuestionUploadUrl:
          type: string
          description: >-
            The url to upload the mood question recording to via a `PUT`
            request. Valid for 1 hour
        readAloudUploadUrl:
          type: string
          description: >-
            The url to upload the read-aloud recording to via a `PUT` request.
            Valid for 1 hour
      required:
        - moodQuestionUploadUrl
        - readAloudUploadUrl
      title: ApolloUploadUrls
    ApolloModelRunCreateResponse:
      type: object
      properties:
        id:
          type: string
          format: uuid
          description: The id of the newly created model run
        uploadUrls:
          $ref: '#/components/schemas/ApolloUploadUrls'
      required:
        - id
        - uploadUrls
      title: ApolloModelRunCreateResponse
    ValidationErrorLocItems:
      oneOf:
        - type: string
        - type: integer
      title: ValidationErrorLocItems
    ValidationError:
      type: object
      properties:
        loc:
          type: array
          items:
            $ref: '#/components/schemas/ValidationErrorLocItems'
        msg:
          type: string
        type:
          type: string
      required:
        - loc
        - msg
        - type
      title: ValidationError
    HTTPValidationError:
      type: object
      properties:
        detail:
          type: array
          items:
            $ref: '#/components/schemas/ValidationError'
      title: HTTPValidationError
  securitySchemes:
    APIKeyHeader:
      type: apiKey
      in: header
      name: x-api-key
      description: Your API Activation Key

```

## SDK Code Examples

```python
import requests

url = "https://api.example.com/v1/models/apollo"

payload = {
    "user": {
        "userLabel": "42baba59-fa4a-4a22-ba1c-2e4a88a3badb",
        "dateOfBirth": "1990-08-24",
        "birthSex": "MALE"
    },
    "language": "en-GB"
}
headers = {
    "x-api-key": "<apiKey>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
```

```javascript
const url = 'https://api.example.com/v1/models/apollo';
const options = {
  method: 'POST',
  headers: {'x-api-key': '<apiKey>', 'Content-Type': 'application/json'},
  body: '{"user":{"userLabel":"42baba59-fa4a-4a22-ba1c-2e4a88a3badb","dateOfBirth":"1990-08-24","birthSex":"MALE"},"language":"en-GB"}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://api.example.com/v1/models/apollo"

	payload := strings.NewReader("{\n  \"user\": {\n    \"userLabel\": \"42baba59-fa4a-4a22-ba1c-2e4a88a3badb\",\n    \"dateOfBirth\": \"1990-08-24\",\n    \"birthSex\": \"MALE\"\n  },\n  \"language\": \"en-GB\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-api-key", "<apiKey>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby
require 'uri'
require 'net/http'

url = URI("https://api.example.com/v1/models/apollo")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-api-key"] = '<apiKey>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"user\": {\n    \"userLabel\": \"42baba59-fa4a-4a22-ba1c-2e4a88a3badb\",\n    \"dateOfBirth\": \"1990-08-24\",\n    \"birthSex\": \"MALE\"\n  },\n  \"language\": \"en-GB\"\n}"

response = http.request(request)
puts response.read_body
```

```java
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://api.example.com/v1/models/apollo")
  .header("x-api-key", "<apiKey>")
  .header("Content-Type", "application/json")
  .body("{\n  \"user\": {\n    \"userLabel\": \"42baba59-fa4a-4a22-ba1c-2e4a88a3badb\",\n    \"dateOfBirth\": \"1990-08-24\",\n    \"birthSex\": \"MALE\"\n  },\n  \"language\": \"en-GB\"\n}")
  .asString();
```

```php
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.example.com/v1/models/apollo', [
  'body' => '{
  "user": {
    "userLabel": "42baba59-fa4a-4a22-ba1c-2e4a88a3badb",
    "dateOfBirth": "1990-08-24",
    "birthSex": "MALE"
  },
  "language": "en-GB"
}',
  'headers' => [
    'Content-Type' => 'application/json',
    'x-api-key' => '<apiKey>',
  ],
]);

echo $response->getBody();
```

```csharp
using RestSharp;

var client = new RestClient("https://api.example.com/v1/models/apollo");
var request = new RestRequest(Method.POST);
request.AddHeader("x-api-key", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"user\": {\n    \"userLabel\": \"42baba59-fa4a-4a22-ba1c-2e4a88a3badb\",\n    \"dateOfBirth\": \"1990-08-24\",\n    \"birthSex\": \"MALE\"\n  },\n  \"language\": \"en-GB\"\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = [
  "x-api-key": "<apiKey>",
  "Content-Type": "application/json"
]
let parameters = [
  "user": [
    "userLabel": "42baba59-fa4a-4a22-ba1c-2e4a88a3badb",
    "dateOfBirth": "1990-08-24",
    "birthSex": "MALE"
  ],
  "language": "en-GB"
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://api.example.com/v1/models/apollo")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```