# Run the model on an existing recording

POST /v1/models/mental-wellness
Content-Type: application/json

Create a new run of the Mental Wellness model for a specific user, with an existing file as input. Model runs require a
recording of the user speaking, as well as some metadata about the user and the recording.

The response contains:
 * An upload url which the contents of an existing recording can be uploaded to via a `PUT` call.
 * The id of the new model run which can be used to poll for results **after the recording has been uploaded**.

Reference: https://docs.thymia.ai/api-reference/plant-store-api/mental-wellness-thymia-helios/create-model-run-with-upload-v-1-models-mental-wellness-post

## OpenAPI Specification

```yaml
openapi: 3.1.0
info:
  title: Thymia API
  version: 1.0.0
paths:
  /v1/models/mental-wellness:
    post:
      operationId: create-model-run-with-upload-v-1-models-mental-wellness-post
      summary: Run the model on an existing recording
      description: >-
        Create a new run of the Mental Wellness model for a specific user, with
        an existing file as input. Model runs require a

        recording of the user speaking, as well as some metadata about the user
        and the recording.


        The response contains:
         * An upload url which the contents of an existing recording can be uploaded to via a `PUT` call.
         * The id of the new model run which can be used to poll for results **after the recording has been uploaded**.
      tags:
        - subpackage_mentalWellnessThymiaHelios
      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 an upload link for the
            recording to input to the Mental Wellness model
          content:
            application/json:
              schema:
                $ref: >-
                  #/components/schemas/MentalWellnessModelRunCreateUploadResponse
        '422':
          description: Validation Error
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/HTTPValidationError'
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/MentalWellnessModelRunUploadCreate'
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
    Accent:
      type: string
      enum:
        - ID
        - NG
        - KE
      description: An enumeration.
      title: Accent
    Tag:
      type: object
      properties:
        name:
          type: string
        value:
          type: string
      required:
        - name
        - value
      title: Tag
    DataDeletionType:
      type: string
      enum:
        - RECORDINGS
      description: An enumeration.
      title: DataDeletionType
    MentalWellnessModelRunUploadCreate:
      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 recording
            to be uploaded
        accent:
          $ref: '#/components/schemas/Accent'
          description: >-
            The accent of the user speaking, in addition to the language they
            are speaking
        sleepTime:
          type: string
          format: date-time
          description: >-
            When the user fell asleep for their last main sleep before the
            recording was made (as an ISO 8601 datetime). This should <b>not
            include timezone information</b> but it is assumed to be in the
            local timezone of the user in the recording so the time of day can
            be inferred.
        wakeTime:
          type: string
          format: date-time
          description: >-
            When the user woke from their last main sleep before the recording
            was made (as an ISO 8601 datetime). This should <b>not include
            timezone information</b> but it is assumed to be in the local
            timezone of the user in the recording so the time of day can be
            inferred.
        tags:
          type: array
          items:
            $ref: '#/components/schemas/Tag'
          description: |-
            Name/Value pairs to tag a model run for later identification. Note:
            * Tag names must be unique
            * At most 20 tags are allowed per model run
        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. If you wish to be more specific about which types of
            data are deleted, see the `data_to_delete` field below.
        dataToDelete:
          type: array
          items:
            $ref: '#/components/schemas/DataDeletionType'
          description: >-
            An array of data types to indicate which data inputs should be
            deleted after completion of the model run.

            To be used in combination with the `delete_data` boolean flag. Note:

            * If `delete_data` is set to `true` and `data_to_delete` value is
            omitted, all data will be deleted.

            * If `delete_data` is set to `true` and `data_to_delete` value is
            set to one or more data types, only the specified data will be
            deleted.
        recordingTime:
          type: string
          format: date-time
          description: >-
            When the recording was made (as an ISO 8601 datetime). This should
            <b>not include timezone information</b> but it is assumed to be in
            the local timezone of the user in the recording so the time of day
            can be inferred.
      required:
        - user
        - language
      title: MentalWellnessModelRunUploadCreate
    MentalWellnessModelRunCreateUploadResponse:
      type: object
      properties:
        id:
          type: string
          format: uuid
          description: The id of the newly created model run
        recordingUploadUrl:
          type: string
          description: >-
            The url to upload recording contents to via a `PUT` request. Note:

            * Recordings should contain at least 10 seconds of speech and be
            under 3 minutes long

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

            * The upload url is valid for 1 hour
      required:
        - id
        - recordingUploadUrl
      title: MentalWellnessModelRunCreateUploadResponse
    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/mental-wellness"

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/mental-wellness';
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/mental-wellness"

	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/mental-wellness")

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/mental-wellness")
  .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/mental-wellness', [
  '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/mental-wellness");
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/mental-wellness")! 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()
```