Neural Concept API

DataFormats

deleteDatasetFormat

get info for a specific dataset format


/api/dataset/{dataset_uuid}/format/{data_format}

Usage and SDK Samples

curl -X DELETE "https://cloud.neuralconcept.com/api/dataset/{dataset_uuid}/format/{data_format}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DataFormatsApi;

import java.io.File;
import java.util.*;

public class DataFormatsApiExample {

    public static void main(String[] args) {
        
        DataFormatsApi apiInstance = new DataFormatsApi();
        String datasetUuid = datasetUuid_example; // String | dataset uuid or name
        String dataFormat = dataFormat_example; // String | data format
        try {
            inline_response_200 result = apiInstance.deleteDatasetFormat(datasetUuid, dataFormat);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataFormatsApi#deleteDatasetFormat");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DataFormatsApi;

public class DataFormatsApiExample {

    public static void main(String[] args) {
        DataFormatsApi apiInstance = new DataFormatsApi();
        String datasetUuid = datasetUuid_example; // String | dataset uuid or name
        String dataFormat = dataFormat_example; // String | data format
        try {
            inline_response_200 result = apiInstance.deleteDatasetFormat(datasetUuid, dataFormat);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataFormatsApi#deleteDatasetFormat");
            e.printStackTrace();
        }
    }
}
String *datasetUuid = datasetUuid_example; // dataset uuid or name
String *dataFormat = dataFormat_example; // data format

DataFormatsApi *apiInstance = [[DataFormatsApi alloc] init];

// get info for a specific dataset format
[apiInstance deleteDatasetFormatWith:datasetUuid
    dataFormat:dataFormat
              completionHandler: ^(inline_response_200 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.DataFormatsApi()
var datasetUuid = datasetUuid_example; // {{String}} dataset uuid or name
var dataFormat = dataFormat_example; // {{String}} data format

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteDatasetFormat(datasetUuid, dataFormat, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class deleteDatasetFormatExample
    {
        public void main()
        {

            var apiInstance = new DataFormatsApi();
            var datasetUuid = datasetUuid_example;  // String | dataset uuid or name
            var dataFormat = dataFormat_example;  // String | data format

            try
            {
                // get info for a specific dataset format
                inline_response_200 result = apiInstance.deleteDatasetFormat(datasetUuid, dataFormat);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DataFormatsApi.deleteDatasetFormat: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiDataFormatsApi();
$datasetUuid = datasetUuid_example; // String | dataset uuid or name
$dataFormat = dataFormat_example; // String | data format

try {
    $result = $api_instance->deleteDatasetFormat($datasetUuid, $dataFormat);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DataFormatsApi->deleteDatasetFormat: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DataFormatsApi;

my $api_instance = WWW::SwaggerClient::DataFormatsApi->new();
my $datasetUuid = datasetUuid_example; # String | dataset uuid or name
my $dataFormat = dataFormat_example; # String | data format

eval { 
    my $result = $api_instance->deleteDatasetFormat(datasetUuid => $datasetUuid, dataFormat => $dataFormat);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DataFormatsApi->deleteDatasetFormat: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DataFormatsApi()
datasetUuid = datasetUuid_example # String | dataset uuid or name
dataFormat = dataFormat_example # String | data format

try: 
    # get info for a specific dataset format
    api_response = api_instance.delete_dataset_format(datasetUuid, dataFormat)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DataFormatsApi->deleteDatasetFormat: %s\n" % e)

Parameters

Path parameters
Name Description
dataset_uuid*
String
dataset uuid or name
Required
data_format*
String
data format
Required

Responses

Status: 200 - Delete message


getDatasetFormat

get info for a specific dataset format


/api/dataset/{dataset_uuid}/format/{data_format}

Usage and SDK Samples

curl -X GET "https://cloud.neuralconcept.com/api/dataset/{dataset_uuid}/format/{data_format}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DataFormatsApi;

import java.io.File;
import java.util.*;

public class DataFormatsApiExample {

    public static void main(String[] args) {
        
        DataFormatsApi apiInstance = new DataFormatsApi();
        String datasetUuid = datasetUuid_example; // String | dataset uuid or name
        String dataFormat = dataFormat_example; // String | data format
        try {
            Format result = apiInstance.getDatasetFormat(datasetUuid, dataFormat);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataFormatsApi#getDatasetFormat");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DataFormatsApi;

public class DataFormatsApiExample {

    public static void main(String[] args) {
        DataFormatsApi apiInstance = new DataFormatsApi();
        String datasetUuid = datasetUuid_example; // String | dataset uuid or name
        String dataFormat = dataFormat_example; // String | data format
        try {
            Format result = apiInstance.getDatasetFormat(datasetUuid, dataFormat);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataFormatsApi#getDatasetFormat");
            e.printStackTrace();
        }
    }
}
String *datasetUuid = datasetUuid_example; // dataset uuid or name
String *dataFormat = dataFormat_example; // data format

DataFormatsApi *apiInstance = [[DataFormatsApi alloc] init];

// get info for a specific dataset format
[apiInstance getDatasetFormatWith:datasetUuid
    dataFormat:dataFormat
              completionHandler: ^(Format output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.DataFormatsApi()
var datasetUuid = datasetUuid_example; // {{String}} dataset uuid or name
var dataFormat = dataFormat_example; // {{String}} data format

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getDatasetFormat(datasetUuid, dataFormat, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getDatasetFormatExample
    {
        public void main()
        {

            var apiInstance = new DataFormatsApi();
            var datasetUuid = datasetUuid_example;  // String | dataset uuid or name
            var dataFormat = dataFormat_example;  // String | data format

            try
            {
                // get info for a specific dataset format
                Format result = apiInstance.getDatasetFormat(datasetUuid, dataFormat);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DataFormatsApi.getDatasetFormat: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiDataFormatsApi();
$datasetUuid = datasetUuid_example; // String | dataset uuid or name
$dataFormat = dataFormat_example; // String | data format

try {
    $result = $api_instance->getDatasetFormat($datasetUuid, $dataFormat);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DataFormatsApi->getDatasetFormat: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DataFormatsApi;

my $api_instance = WWW::SwaggerClient::DataFormatsApi->new();
my $datasetUuid = datasetUuid_example; # String | dataset uuid or name
my $dataFormat = dataFormat_example; # String | data format

eval { 
    my $result = $api_instance->getDatasetFormat(datasetUuid => $datasetUuid, dataFormat => $dataFormat);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DataFormatsApi->getDatasetFormat: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DataFormatsApi()
datasetUuid = datasetUuid_example # String | dataset uuid or name
dataFormat = dataFormat_example # String | data format

try: 
    # get info for a specific dataset format
    api_response = api_instance.get_dataset_format(datasetUuid, dataFormat)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DataFormatsApi->getDatasetFormat: %s\n" % e)

Parameters

Path parameters
Name Description
dataset_uuid*
String
dataset uuid or name
Required
data_format*
String
data format
Required

Responses

Status: 200 - Format info


listDatasetFormats

List dataset formats


/api/dataset/{dataset_uuid}/format

Usage and SDK Samples

curl -X GET "https://cloud.neuralconcept.com/api/dataset/{dataset_uuid}/format"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DataFormatsApi;

import java.io.File;
import java.util.*;

public class DataFormatsApiExample {

    public static void main(String[] args) {
        
        DataFormatsApi apiInstance = new DataFormatsApi();
        String datasetUuid = datasetUuid_example; // String | dataset uuid or name
        try {
            array[Format] result = apiInstance.listDatasetFormats(datasetUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataFormatsApi#listDatasetFormats");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DataFormatsApi;

public class DataFormatsApiExample {

    public static void main(String[] args) {
        DataFormatsApi apiInstance = new DataFormatsApi();
        String datasetUuid = datasetUuid_example; // String | dataset uuid or name
        try {
            array[Format] result = apiInstance.listDatasetFormats(datasetUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataFormatsApi#listDatasetFormats");
            e.printStackTrace();
        }
    }
}
String *datasetUuid = datasetUuid_example; // dataset uuid or name

DataFormatsApi *apiInstance = [[DataFormatsApi alloc] init];

// List dataset formats
[apiInstance listDatasetFormatsWith:datasetUuid
              completionHandler: ^(array[Format] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.DataFormatsApi()
var datasetUuid = datasetUuid_example; // {{String}} dataset uuid or name

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.listDatasetFormats(datasetUuid, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class listDatasetFormatsExample
    {
        public void main()
        {

            var apiInstance = new DataFormatsApi();
            var datasetUuid = datasetUuid_example;  // String | dataset uuid or name

            try
            {
                // List dataset formats
                array[Format] result = apiInstance.listDatasetFormats(datasetUuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DataFormatsApi.listDatasetFormats: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiDataFormatsApi();
$datasetUuid = datasetUuid_example; // String | dataset uuid or name

try {
    $result = $api_instance->listDatasetFormats($datasetUuid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DataFormatsApi->listDatasetFormats: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DataFormatsApi;

my $api_instance = WWW::SwaggerClient::DataFormatsApi->new();
my $datasetUuid = datasetUuid_example; # String | dataset uuid or name

eval { 
    my $result = $api_instance->listDatasetFormats(datasetUuid => $datasetUuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DataFormatsApi->listDatasetFormats: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DataFormatsApi()
datasetUuid = datasetUuid_example # String | dataset uuid or name

try: 
    # List dataset formats
    api_response = api_instance.list_dataset_formats(datasetUuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DataFormatsApi->listDatasetFormats: %s\n" % e)

Parameters

Path parameters
Name Description
dataset_uuid*
String
dataset uuid or name
Required

Responses

Status: 200 - Formats list


Dataset

addDataset

Add a dataset


/api/dataset

Usage and SDK Samples

curl -X POST "https://cloud.neuralconcept.com/api/dataset"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DatasetApi;

import java.io.File;
import java.util.*;

public class DatasetApiExample {

    public static void main(String[] args) {
        
        DatasetApi apiInstance = new DatasetApi();
        Dataset body = ; // Dataset | Dataset object that needs to be added.
        try {
            Dataset result = apiInstance.addDataset(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatasetApi#addDataset");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DatasetApi;

public class DatasetApiExample {

    public static void main(String[] args) {
        DatasetApi apiInstance = new DatasetApi();
        Dataset body = ; // Dataset | Dataset object that needs to be added.
        try {
            Dataset result = apiInstance.addDataset(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatasetApi#addDataset");
            e.printStackTrace();
        }
    }
}
Dataset *body = ; // Dataset object that needs to be added.

DatasetApi *apiInstance = [[DatasetApi alloc] init];

// Add a dataset
[apiInstance addDatasetWith:body
              completionHandler: ^(Dataset output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.DatasetApi()
var body = ; // {{Dataset}} Dataset object that needs to be added.

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.addDataset(body, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class addDatasetExample
    {
        public void main()
        {

            var apiInstance = new DatasetApi();
            var body = new Dataset(); // Dataset | Dataset object that needs to be added.

            try
            {
                // Add a dataset
                Dataset result = apiInstance.addDataset(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DatasetApi.addDataset: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiDatasetApi();
$body = ; // Dataset | Dataset object that needs to be added.

try {
    $result = $api_instance->addDataset($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DatasetApi->addDataset: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DatasetApi;

my $api_instance = WWW::SwaggerClient::DatasetApi->new();
my $body = WWW::SwaggerClient::Object::Dataset->new(); # Dataset | Dataset object that needs to be added.

eval { 
    my $result = $api_instance->addDataset(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DatasetApi->addDataset: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DatasetApi()
body =  # Dataset | Dataset object that needs to be added.

try: 
    # Add a dataset
    api_response = api_instance.add_dataset(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DatasetApi->addDataset: %s\n" % e)

Parameters

Body parameters
Name Description
body *

Responses

Status: 200 - The new dataset


addFilesToDataset

Add files to dataset


/api/dataset/{dataset_uuid}/files

Usage and SDK Samples

curl -X POST "https://cloud.neuralconcept.com/api/dataset/{dataset_uuid}/files"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DatasetApi;

import java.io.File;
import java.util.*;

public class DatasetApiExample {

    public static void main(String[] args) {
        
        DatasetApi apiInstance = new DatasetApi();
        UUID datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        array[byte[]] filename = ; // array[byte[]] | 
        try {
            Dataset result = apiInstance.addFilesToDataset(datasetUuid, filename);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatasetApi#addFilesToDataset");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DatasetApi;

public class DatasetApiExample {

    public static void main(String[] args) {
        DatasetApi apiInstance = new DatasetApi();
        UUID datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        array[byte[]] filename = ; // array[byte[]] | 
        try {
            Dataset result = apiInstance.addFilesToDataset(datasetUuid, filename);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatasetApi#addFilesToDataset");
            e.printStackTrace();
        }
    }
}
UUID *datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // 
array[byte[]] *filename = ; //  (optional)

DatasetApi *apiInstance = [[DatasetApi alloc] init];

// Add files to dataset
[apiInstance addFilesToDatasetWith:datasetUuid
    filename:filename
              completionHandler: ^(Dataset output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.DatasetApi()
var datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {{UUID}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.addFilesToDataset(datasetUuid, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class addFilesToDatasetExample
    {
        public void main()
        {

            var apiInstance = new DatasetApi();
            var datasetUuid = new UUID(); // UUID | 
            var filename = new array[byte[]](); // array[byte[]] |  (optional) 

            try
            {
                // Add files to dataset
                Dataset result = apiInstance.addFilesToDataset(datasetUuid, filename);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DatasetApi.addFilesToDataset: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiDatasetApi();
$datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$filename = ; // array[byte[]] | 

try {
    $result = $api_instance->addFilesToDataset($datasetUuid, $filename);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DatasetApi->addFilesToDataset: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DatasetApi;

my $api_instance = WWW::SwaggerClient::DatasetApi->new();
my $datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $filename = []; # array[byte[]] | 

eval { 
    my $result = $api_instance->addFilesToDataset(datasetUuid => $datasetUuid, filename => $filename);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DatasetApi->addFilesToDataset: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DatasetApi()
datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | 
filename =  # array[byte[]] |  (optional)

try: 
    # Add files to dataset
    api_response = api_instance.add_files_to_dataset(datasetUuid, filename=filename)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DatasetApi->addFilesToDataset: %s\n" % e)

Parameters

Path parameters
Name Description
dataset_uuid*
UUID (uuid)
Required
Form parameters
Name Description
filename
array[byte[]] (binary)

Responses

Status: 200 - The dataset


convertDataset

Convert a dataset


/api/dataset/{dataset_uuid}/convert

Usage and SDK Samples

curl -X POST "https://cloud.neuralconcept.com/api/dataset/{dataset_uuid}/convert"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DatasetApi;

import java.io.File;
import java.util.*;

public class DatasetApiExample {

    public static void main(String[] args) {
        
        DatasetApi apiInstance = new DatasetApi();
        UUID datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            Conversion result = apiInstance.convertDataset(datasetUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatasetApi#convertDataset");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DatasetApi;

public class DatasetApiExample {

    public static void main(String[] args) {
        DatasetApi apiInstance = new DatasetApi();
        UUID datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            Conversion result = apiInstance.convertDataset(datasetUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatasetApi#convertDataset");
            e.printStackTrace();
        }
    }
}
UUID *datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // 

DatasetApi *apiInstance = [[DatasetApi alloc] init];

// Convert a dataset
[apiInstance convertDatasetWith:datasetUuid
              completionHandler: ^(Conversion output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.DatasetApi()
var datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {{UUID}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.convertDataset(datasetUuid, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class convertDatasetExample
    {
        public void main()
        {

            var apiInstance = new DatasetApi();
            var datasetUuid = new UUID(); // UUID | 

            try
            {
                // Convert a dataset
                Conversion result = apiInstance.convertDataset(datasetUuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DatasetApi.convertDataset: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiDatasetApi();
$datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->convertDataset($datasetUuid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DatasetApi->convertDataset: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DatasetApi;

my $api_instance = WWW::SwaggerClient::DatasetApi->new();
my $datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval { 
    my $result = $api_instance->convertDataset(datasetUuid => $datasetUuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DatasetApi->convertDataset: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DatasetApi()
datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | 

try: 
    # Convert a dataset
    api_response = api_instance.convert_dataset(datasetUuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DatasetApi->convertDataset: %s\n" % e)

Parameters

Path parameters
Name Description
dataset_uuid*
UUID (uuid)
Required

Responses

Status: 200 - The conversion job


deleteDataset

Delete dataset


/api/dataset/{dataset_uuid}

Usage and SDK Samples

curl -X DELETE "https://cloud.neuralconcept.com/api/dataset/{dataset_uuid}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DatasetApi;

import java.io.File;
import java.util.*;

public class DatasetApiExample {

    public static void main(String[] args) {
        
        DatasetApi apiInstance = new DatasetApi();
        UUID datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            inline_response_200 result = apiInstance.deleteDataset(datasetUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatasetApi#deleteDataset");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DatasetApi;

public class DatasetApiExample {

    public static void main(String[] args) {
        DatasetApi apiInstance = new DatasetApi();
        UUID datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            inline_response_200 result = apiInstance.deleteDataset(datasetUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatasetApi#deleteDataset");
            e.printStackTrace();
        }
    }
}
UUID *datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // 

DatasetApi *apiInstance = [[DatasetApi alloc] init];

// Delete dataset
[apiInstance deleteDatasetWith:datasetUuid
              completionHandler: ^(inline_response_200 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.DatasetApi()
var datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {{UUID}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteDataset(datasetUuid, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class deleteDatasetExample
    {
        public void main()
        {

            var apiInstance = new DatasetApi();
            var datasetUuid = new UUID(); // UUID | 

            try
            {
                // Delete dataset
                inline_response_200 result = apiInstance.deleteDataset(datasetUuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DatasetApi.deleteDataset: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiDatasetApi();
$datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->deleteDataset($datasetUuid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DatasetApi->deleteDataset: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DatasetApi;

my $api_instance = WWW::SwaggerClient::DatasetApi->new();
my $datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval { 
    my $result = $api_instance->deleteDataset(datasetUuid => $datasetUuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DatasetApi->deleteDataset: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DatasetApi()
datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | 

try: 
    # Delete dataset
    api_response = api_instance.delete_dataset(datasetUuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DatasetApi->deleteDataset: %s\n" % e)

Parameters

Path parameters
Name Description
dataset_uuid*
UUID (uuid)
Required

Responses

Status: 200 - The delete message


getDataset

Get dataset by id or name.


/api/dataset/{dataset_uuid}

Usage and SDK Samples

curl -X GET "https://cloud.neuralconcept.com/api/dataset/{dataset_uuid}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DatasetApi;

import java.io.File;
import java.util.*;

public class DatasetApiExample {

    public static void main(String[] args) {
        
        DatasetApi apiInstance = new DatasetApi();
        UUID datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            Dataset result = apiInstance.getDataset(datasetUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatasetApi#getDataset");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DatasetApi;

public class DatasetApiExample {

    public static void main(String[] args) {
        DatasetApi apiInstance = new DatasetApi();
        UUID datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            Dataset result = apiInstance.getDataset(datasetUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatasetApi#getDataset");
            e.printStackTrace();
        }
    }
}
UUID *datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // 

DatasetApi *apiInstance = [[DatasetApi alloc] init];

// Get dataset by id or name.
[apiInstance getDatasetWith:datasetUuid
              completionHandler: ^(Dataset output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.DatasetApi()
var datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {{UUID}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getDataset(datasetUuid, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getDatasetExample
    {
        public void main()
        {

            var apiInstance = new DatasetApi();
            var datasetUuid = new UUID(); // UUID | 

            try
            {
                // Get dataset by id or name.
                Dataset result = apiInstance.getDataset(datasetUuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DatasetApi.getDataset: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiDatasetApi();
$datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->getDataset($datasetUuid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DatasetApi->getDataset: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DatasetApi;

my $api_instance = WWW::SwaggerClient::DatasetApi->new();
my $datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval { 
    my $result = $api_instance->getDataset(datasetUuid => $datasetUuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DatasetApi->getDataset: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DatasetApi()
datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | 

try: 
    # Get dataset by id or name.
    api_response = api_instance.get_dataset(datasetUuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DatasetApi->getDataset: %s\n" % e)

Parameters

Path parameters
Name Description
dataset_uuid*
UUID (uuid)
Required

Responses

Status: 200 - The dataset description


getDatasetSample

get a sample in the dataset


/api/dataset/{dataset_uuid}/samples/{sample_id}

Usage and SDK Samples

curl -X GET "https://cloud.neuralconcept.com/api/dataset/{dataset_uuid}/samples/{sample_id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DatasetApi;

import java.io.File;
import java.util.*;

public class DatasetApiExample {

    public static void main(String[] args) {
        
        DatasetApi apiInstance = new DatasetApi();
        UUID datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        String sampleId = sampleId_example; // String | 
        try {
            Sample result = apiInstance.getDatasetSample(datasetUuid, sampleId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatasetApi#getDatasetSample");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DatasetApi;

public class DatasetApiExample {

    public static void main(String[] args) {
        DatasetApi apiInstance = new DatasetApi();
        UUID datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        String sampleId = sampleId_example; // String | 
        try {
            Sample result = apiInstance.getDatasetSample(datasetUuid, sampleId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatasetApi#getDatasetSample");
            e.printStackTrace();
        }
    }
}
UUID *datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // 
String *sampleId = sampleId_example; // 

DatasetApi *apiInstance = [[DatasetApi alloc] init];

// get a sample in the dataset
[apiInstance getDatasetSampleWith:datasetUuid
    sampleId:sampleId
              completionHandler: ^(Sample output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.DatasetApi()
var datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {{UUID}} 
var sampleId = sampleId_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getDatasetSample(datasetUuid, sampleId, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getDatasetSampleExample
    {
        public void main()
        {

            var apiInstance = new DatasetApi();
            var datasetUuid = new UUID(); // UUID | 
            var sampleId = sampleId_example;  // String | 

            try
            {
                // get a sample in the dataset
                Sample result = apiInstance.getDatasetSample(datasetUuid, sampleId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DatasetApi.getDatasetSample: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiDatasetApi();
$datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$sampleId = sampleId_example; // String | 

try {
    $result = $api_instance->getDatasetSample($datasetUuid, $sampleId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DatasetApi->getDatasetSample: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DatasetApi;

my $api_instance = WWW::SwaggerClient::DatasetApi->new();
my $datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $sampleId = sampleId_example; # String | 

eval { 
    my $result = $api_instance->getDatasetSample(datasetUuid => $datasetUuid, sampleId => $sampleId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DatasetApi->getDatasetSample: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DatasetApi()
datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | 
sampleId = sampleId_example # String | 

try: 
    # get a sample in the dataset
    api_response = api_instance.get_dataset_sample(datasetUuid, sampleId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DatasetApi->getDatasetSample: %s\n" % e)

Parameters

Path parameters
Name Description
dataset_uuid*
UUID (uuid)
Required
sample_id*
String
Required

Responses

Status: 200 - Sample description


getDatasetSchema

get a specific dataset's data schema


/api/dataset/{dataset_uuid}/schema

Usage and SDK Samples

curl -X GET "https://cloud.neuralconcept.com/api/dataset/{dataset_uuid}/schema"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DatasetApi;

import java.io.File;
import java.util.*;

public class DatasetApiExample {

    public static void main(String[] args) {
        
        DatasetApi apiInstance = new DatasetApi();
        UUID datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            DataSchema result = apiInstance.getDatasetSchema(datasetUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatasetApi#getDatasetSchema");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DatasetApi;

public class DatasetApiExample {

    public static void main(String[] args) {
        DatasetApi apiInstance = new DatasetApi();
        UUID datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            DataSchema result = apiInstance.getDatasetSchema(datasetUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatasetApi#getDatasetSchema");
            e.printStackTrace();
        }
    }
}
UUID *datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // 

DatasetApi *apiInstance = [[DatasetApi alloc] init];

// get a specific dataset's data schema
[apiInstance getDatasetSchemaWith:datasetUuid
              completionHandler: ^(DataSchema output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.DatasetApi()
var datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {{UUID}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getDatasetSchema(datasetUuid, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getDatasetSchemaExample
    {
        public void main()
        {

            var apiInstance = new DatasetApi();
            var datasetUuid = new UUID(); // UUID | 

            try
            {
                // get a specific dataset's data schema
                DataSchema result = apiInstance.getDatasetSchema(datasetUuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DatasetApi.getDatasetSchema: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiDatasetApi();
$datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->getDatasetSchema($datasetUuid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DatasetApi->getDatasetSchema: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DatasetApi;

my $api_instance = WWW::SwaggerClient::DatasetApi->new();
my $datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval { 
    my $result = $api_instance->getDatasetSchema(datasetUuid => $datasetUuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DatasetApi->getDatasetSchema: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DatasetApi()
datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | 

try: 
    # get a specific dataset's data schema
    api_response = api_instance.get_dataset_schema(datasetUuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DatasetApi->getDatasetSchema: %s\n" % e)

Parameters

Path parameters
Name Description
dataset_uuid*
UUID (uuid)
Required

Responses

Status: 200 - The schema


getDatasetSplit

Get the split of a dataset


/api/dataset/{dataset_uuid}/split

Usage and SDK Samples

curl -X GET "https://cloud.neuralconcept.com/api/dataset/{dataset_uuid}/split"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DatasetApi;

import java.io.File;
import java.util.*;

public class DatasetApiExample {

    public static void main(String[] args) {
        
        DatasetApi apiInstance = new DatasetApi();
        UUID datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            Split result = apiInstance.getDatasetSplit(datasetUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatasetApi#getDatasetSplit");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DatasetApi;

public class DatasetApiExample {

    public static void main(String[] args) {
        DatasetApi apiInstance = new DatasetApi();
        UUID datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            Split result = apiInstance.getDatasetSplit(datasetUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatasetApi#getDatasetSplit");
            e.printStackTrace();
        }
    }
}
UUID *datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // 

DatasetApi *apiInstance = [[DatasetApi alloc] init];

// Get the split of a dataset
[apiInstance getDatasetSplitWith:datasetUuid
              completionHandler: ^(Split output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.DatasetApi()
var datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {{UUID}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getDatasetSplit(datasetUuid, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getDatasetSplitExample
    {
        public void main()
        {

            var apiInstance = new DatasetApi();
            var datasetUuid = new UUID(); // UUID | 

            try
            {
                // Get the split of a dataset
                Split result = apiInstance.getDatasetSplit(datasetUuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DatasetApi.getDatasetSplit: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiDatasetApi();
$datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->getDatasetSplit($datasetUuid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DatasetApi->getDatasetSplit: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DatasetApi;

my $api_instance = WWW::SwaggerClient::DatasetApi->new();
my $datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval { 
    my $result = $api_instance->getDatasetSplit(datasetUuid => $datasetUuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DatasetApi->getDatasetSplit: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DatasetApi()
datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | 

try: 
    # Get the split of a dataset
    api_response = api_instance.get_dataset_split(datasetUuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DatasetApi->getDatasetSplit: %s\n" % e)

Parameters

Path parameters
Name Description
dataset_uuid*
UUID (uuid)
Required

Responses

Status: 200 - Split descriptionn


listDatasetSamples

get the list of samples in the dataset


/api/dataset/{dataset_uuid}/samples

Usage and SDK Samples

curl -X GET "https://cloud.neuralconcept.com/api/dataset/{dataset_uuid}/samples"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DatasetApi;

import java.io.File;
import java.util.*;

public class DatasetApiExample {

    public static void main(String[] args) {
        
        DatasetApi apiInstance = new DatasetApi();
        UUID datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            array[Sample] result = apiInstance.listDatasetSamples(datasetUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatasetApi#listDatasetSamples");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DatasetApi;

public class DatasetApiExample {

    public static void main(String[] args) {
        DatasetApi apiInstance = new DatasetApi();
        UUID datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            array[Sample] result = apiInstance.listDatasetSamples(datasetUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatasetApi#listDatasetSamples");
            e.printStackTrace();
        }
    }
}
UUID *datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // 

DatasetApi *apiInstance = [[DatasetApi alloc] init];

// get the list of samples in the dataset
[apiInstance listDatasetSamplesWith:datasetUuid
              completionHandler: ^(array[Sample] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.DatasetApi()
var datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {{UUID}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.listDatasetSamples(datasetUuid, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class listDatasetSamplesExample
    {
        public void main()
        {

            var apiInstance = new DatasetApi();
            var datasetUuid = new UUID(); // UUID | 

            try
            {
                // get the list of samples in the dataset
                array[Sample] result = apiInstance.listDatasetSamples(datasetUuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DatasetApi.listDatasetSamples: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiDatasetApi();
$datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->listDatasetSamples($datasetUuid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DatasetApi->listDatasetSamples: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DatasetApi;

my $api_instance = WWW::SwaggerClient::DatasetApi->new();
my $datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval { 
    my $result = $api_instance->listDatasetSamples(datasetUuid => $datasetUuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DatasetApi->listDatasetSamples: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DatasetApi()
datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | 

try: 
    # get the list of samples in the dataset
    api_response = api_instance.list_dataset_samples(datasetUuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DatasetApi->listDatasetSamples: %s\n" % e)

Parameters

Path parameters
Name Description
dataset_uuid*
UUID (uuid)
Required

Responses

Status: 200 - Sample list


listDatasets

List datasets


/api/dataset

Usage and SDK Samples

curl -X GET "https://cloud.neuralconcept.com/api/dataset"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DatasetApi;

import java.io.File;
import java.util.*;

public class DatasetApiExample {

    public static void main(String[] args) {
        
        DatasetApi apiInstance = new DatasetApi();
        try {
            array[Dataset] result = apiInstance.listDatasets();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatasetApi#listDatasets");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DatasetApi;

public class DatasetApiExample {

    public static void main(String[] args) {
        DatasetApi apiInstance = new DatasetApi();
        try {
            array[Dataset] result = apiInstance.listDatasets();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatasetApi#listDatasets");
            e.printStackTrace();
        }
    }
}

DatasetApi *apiInstance = [[DatasetApi alloc] init];

// List datasets
[apiInstance listDatasetsWithCompletionHandler: 
              ^(array[Dataset] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.DatasetApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.listDatasets(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class listDatasetsExample
    {
        public void main()
        {

            var apiInstance = new DatasetApi();

            try
            {
                // List datasets
                array[Dataset] result = apiInstance.listDatasets();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DatasetApi.listDatasets: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiDatasetApi();

try {
    $result = $api_instance->listDatasets();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DatasetApi->listDatasets: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DatasetApi;

my $api_instance = WWW::SwaggerClient::DatasetApi->new();

eval { 
    my $result = $api_instance->listDatasets();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DatasetApi->listDatasets: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DatasetApi()

try: 
    # List datasets
    api_response = api_instance.list_datasets()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DatasetApi->listDatasets: %s\n" % e)

Parameters

Responses

Status: 200 - List of datasets


restartDatasetConversion

Restart a conversion.


/api/dataset/{dataset_uuid}/convert/restart

Usage and SDK Samples

curl -X POST "https://cloud.neuralconcept.com/api/dataset/{dataset_uuid}/convert/restart"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DatasetApi;

import java.io.File;
import java.util.*;

public class DatasetApiExample {

    public static void main(String[] args) {
        
        DatasetApi apiInstance = new DatasetApi();
        UUID datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            Conversion result = apiInstance.restartDatasetConversion(datasetUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatasetApi#restartDatasetConversion");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DatasetApi;

public class DatasetApiExample {

    public static void main(String[] args) {
        DatasetApi apiInstance = new DatasetApi();
        UUID datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            Conversion result = apiInstance.restartDatasetConversion(datasetUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatasetApi#restartDatasetConversion");
            e.printStackTrace();
        }
    }
}
UUID *datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // 

DatasetApi *apiInstance = [[DatasetApi alloc] init];

// Restart a conversion.
[apiInstance restartDatasetConversionWith:datasetUuid
              completionHandler: ^(Conversion output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.DatasetApi()
var datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {{UUID}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.restartDatasetConversion(datasetUuid, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class restartDatasetConversionExample
    {
        public void main()
        {

            var apiInstance = new DatasetApi();
            var datasetUuid = new UUID(); // UUID | 

            try
            {
                // Restart a conversion.
                Conversion result = apiInstance.restartDatasetConversion(datasetUuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DatasetApi.restartDatasetConversion: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiDatasetApi();
$datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->restartDatasetConversion($datasetUuid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DatasetApi->restartDatasetConversion: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DatasetApi;

my $api_instance = WWW::SwaggerClient::DatasetApi->new();
my $datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval { 
    my $result = $api_instance->restartDatasetConversion(datasetUuid => $datasetUuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DatasetApi->restartDatasetConversion: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DatasetApi()
datasetUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | 

try: 
    # Restart a conversion.
    api_response = api_instance.restart_dataset_conversion(datasetUuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DatasetApi->restartDatasetConversion: %s\n" % e)

Parameters

Path parameters
Name Description
dataset_uuid*
UUID (uuid)
Required

Responses

Status: 200 - The conversion job

Status: 403 - The restart failed because conversion was not initially submitted or not failed.


Job

deleteJob

get a specific job


/api/jobs/{job_uuid}

Usage and SDK Samples

curl -X DELETE "https://cloud.neuralconcept.com/api/jobs/{job_uuid}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.JobApi;

import java.io.File;
import java.util.*;

public class JobApiExample {

    public static void main(String[] args) {
        
        JobApi apiInstance = new JobApi();
        String jobUuid = jobUuid_example; // String | uuid or job name
        try {
            inline_response_200 result = apiInstance.deleteJob(jobUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling JobApi#deleteJob");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.JobApi;

public class JobApiExample {

    public static void main(String[] args) {
        JobApi apiInstance = new JobApi();
        String jobUuid = jobUuid_example; // String | uuid or job name
        try {
            inline_response_200 result = apiInstance.deleteJob(jobUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling JobApi#deleteJob");
            e.printStackTrace();
        }
    }
}
String *jobUuid = jobUuid_example; // uuid or job name

JobApi *apiInstance = [[JobApi alloc] init];

// get a specific job
[apiInstance deleteJobWith:jobUuid
              completionHandler: ^(inline_response_200 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.JobApi()
var jobUuid = jobUuid_example; // {{String}} uuid or job name

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteJob(jobUuid, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class deleteJobExample
    {
        public void main()
        {

            var apiInstance = new JobApi();
            var jobUuid = jobUuid_example;  // String | uuid or job name

            try
            {
                // get a specific job
                inline_response_200 result = apiInstance.deleteJob(jobUuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling JobApi.deleteJob: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiJobApi();
$jobUuid = jobUuid_example; // String | uuid or job name

try {
    $result = $api_instance->deleteJob($jobUuid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling JobApi->deleteJob: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::JobApi;

my $api_instance = WWW::SwaggerClient::JobApi->new();
my $jobUuid = jobUuid_example; # String | uuid or job name

eval { 
    my $result = $api_instance->deleteJob(jobUuid => $jobUuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling JobApi->deleteJob: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.JobApi()
jobUuid = jobUuid_example # String | uuid or job name

try: 
    # get a specific job
    api_response = api_instance.delete_job(jobUuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling JobApi->deleteJob: %s\n" % e)

Parameters

Path parameters
Name Description
job_uuid*
String
uuid or job name
Required

Responses

Status: 200 - Delete message


getJob

get a specific job


/api/jobs/{job_uuid}

Usage and SDK Samples

curl -X GET "https://cloud.neuralconcept.com/api/jobs/{job_uuid}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.JobApi;

import java.io.File;
import java.util.*;

public class JobApiExample {

    public static void main(String[] args) {
        
        JobApi apiInstance = new JobApi();
        String jobUuid = jobUuid_example; // String | uuid or job name
        try {
            Job result = apiInstance.getJob(jobUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling JobApi#getJob");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.JobApi;

public class JobApiExample {

    public static void main(String[] args) {
        JobApi apiInstance = new JobApi();
        String jobUuid = jobUuid_example; // String | uuid or job name
        try {
            Job result = apiInstance.getJob(jobUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling JobApi#getJob");
            e.printStackTrace();
        }
    }
}
String *jobUuid = jobUuid_example; // uuid or job name

JobApi *apiInstance = [[JobApi alloc] init];

// get a specific job
[apiInstance getJobWith:jobUuid
              completionHandler: ^(Job output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.JobApi()
var jobUuid = jobUuid_example; // {{String}} uuid or job name

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getJob(jobUuid, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getJobExample
    {
        public void main()
        {

            var apiInstance = new JobApi();
            var jobUuid = jobUuid_example;  // String | uuid or job name

            try
            {
                // get a specific job
                Job result = apiInstance.getJob(jobUuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling JobApi.getJob: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiJobApi();
$jobUuid = jobUuid_example; // String | uuid or job name

try {
    $result = $api_instance->getJob($jobUuid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling JobApi->getJob: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::JobApi;

my $api_instance = WWW::SwaggerClient::JobApi->new();
my $jobUuid = jobUuid_example; # String | uuid or job name

eval { 
    my $result = $api_instance->getJob(jobUuid => $jobUuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling JobApi->getJob: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.JobApi()
jobUuid = jobUuid_example # String | uuid or job name

try: 
    # get a specific job
    api_response = api_instance.get_job(jobUuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling JobApi->getJob: %s\n" % e)

Parameters

Path parameters
Name Description
job_uuid*
String
uuid or job name
Required

Responses

Status: 200 - Job description


listJobs

List jobs


/api/jobs

Usage and SDK Samples

curl -X GET "https://cloud.neuralconcept.com/api/jobs"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.JobApi;

import java.io.File;
import java.util.*;

public class JobApiExample {

    public static void main(String[] args) {
        
        JobApi apiInstance = new JobApi();
        try {
            array[Job] result = apiInstance.listJobs();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling JobApi#listJobs");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.JobApi;

public class JobApiExample {

    public static void main(String[] args) {
        JobApi apiInstance = new JobApi();
        try {
            array[Job] result = apiInstance.listJobs();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling JobApi#listJobs");
            e.printStackTrace();
        }
    }
}

JobApi *apiInstance = [[JobApi alloc] init];

// List jobs
[apiInstance listJobsWithCompletionHandler: 
              ^(array[Job] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.JobApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.listJobs(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class listJobsExample
    {
        public void main()
        {

            var apiInstance = new JobApi();

            try
            {
                // List jobs
                array[Job] result = apiInstance.listJobs();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling JobApi.listJobs: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiJobApi();

try {
    $result = $api_instance->listJobs();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling JobApi->listJobs: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::JobApi;

my $api_instance = WWW::SwaggerClient::JobApi->new();

eval { 
    my $result = $api_instance->listJobs();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling JobApi->listJobs: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.JobApi()

try: 
    # List jobs
    api_response = api_instance.list_jobs()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling JobApi->listJobs: %s\n" % e)

Parameters

Responses

Status: 200 - Jobs list


restartJob

restart a specific job


/api/jobs/{job_uuid}/restart

Usage and SDK Samples

curl -X POST "https://cloud.neuralconcept.com/api/jobs/{job_uuid}/restart"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.JobApi;

import java.io.File;
import java.util.*;

public class JobApiExample {

    public static void main(String[] args) {
        
        JobApi apiInstance = new JobApi();
        String jobUuid = jobUuid_example; // String | uuid or job name
        try {
            Job result = apiInstance.restartJob(jobUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling JobApi#restartJob");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.JobApi;

public class JobApiExample {

    public static void main(String[] args) {
        JobApi apiInstance = new JobApi();
        String jobUuid = jobUuid_example; // String | uuid or job name
        try {
            Job result = apiInstance.restartJob(jobUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling JobApi#restartJob");
            e.printStackTrace();
        }
    }
}
String *jobUuid = jobUuid_example; // uuid or job name

JobApi *apiInstance = [[JobApi alloc] init];

// restart a specific job
[apiInstance restartJobWith:jobUuid
              completionHandler: ^(Job output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.JobApi()
var jobUuid = jobUuid_example; // {{String}} uuid or job name

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.restartJob(jobUuid, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class restartJobExample
    {
        public void main()
        {

            var apiInstance = new JobApi();
            var jobUuid = jobUuid_example;  // String | uuid or job name

            try
            {
                // restart a specific job
                Job result = apiInstance.restartJob(jobUuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling JobApi.restartJob: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiJobApi();
$jobUuid = jobUuid_example; // String | uuid or job name

try {
    $result = $api_instance->restartJob($jobUuid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling JobApi->restartJob: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::JobApi;

my $api_instance = WWW::SwaggerClient::JobApi->new();
my $jobUuid = jobUuid_example; # String | uuid or job name

eval { 
    my $result = $api_instance->restartJob(jobUuid => $jobUuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling JobApi->restartJob: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.JobApi()
jobUuid = jobUuid_example # String | uuid or job name

try: 
    # restart a specific job
    api_response = api_instance.restart_job(jobUuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling JobApi->restartJob: %s\n" % e)

Parameters

Path parameters
Name Description
job_uuid*
String
uuid or job name
Required

Responses

Status: 200 - Job with updated status


stopJob

stop a specific job


/api/jobs/{job_uuid}/stop

Usage and SDK Samples

curl -X POST "https://cloud.neuralconcept.com/api/jobs/{job_uuid}/stop"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.JobApi;

import java.io.File;
import java.util.*;

public class JobApiExample {

    public static void main(String[] args) {
        
        JobApi apiInstance = new JobApi();
        String jobUuid = jobUuid_example; // String | uuid or job name
        try {
            Job result = apiInstance.stopJob(jobUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling JobApi#stopJob");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.JobApi;

public class JobApiExample {

    public static void main(String[] args) {
        JobApi apiInstance = new JobApi();
        String jobUuid = jobUuid_example; // String | uuid or job name
        try {
            Job result = apiInstance.stopJob(jobUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling JobApi#stopJob");
            e.printStackTrace();
        }
    }
}
String *jobUuid = jobUuid_example; // uuid or job name

JobApi *apiInstance = [[JobApi alloc] init];

// stop a specific job
[apiInstance stopJobWith:jobUuid
              completionHandler: ^(Job output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.JobApi()
var jobUuid = jobUuid_example; // {{String}} uuid or job name

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.stopJob(jobUuid, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class stopJobExample
    {
        public void main()
        {

            var apiInstance = new JobApi();
            var jobUuid = jobUuid_example;  // String | uuid or job name

            try
            {
                // stop a specific job
                Job result = apiInstance.stopJob(jobUuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling JobApi.stopJob: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiJobApi();
$jobUuid = jobUuid_example; // String | uuid or job name

try {
    $result = $api_instance->stopJob($jobUuid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling JobApi->stopJob: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::JobApi;

my $api_instance = WWW::SwaggerClient::JobApi->new();
my $jobUuid = jobUuid_example; # String | uuid or job name

eval { 
    my $result = $api_instance->stopJob(jobUuid => $jobUuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling JobApi->stopJob: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.JobApi()
jobUuid = jobUuid_example # String | uuid or job name

try: 
    # stop a specific job
    api_response = api_instance.stop_job(jobUuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling JobApi->stopJob: %s\n" % e)

Parameters

Path parameters
Name Description
job_uuid*
String
uuid or job name
Required

Responses

Status: 200 - Job with updated status


Model

addModel

Add a model


/api/model

Usage and SDK Samples

curl -X POST "https://cloud.neuralconcept.com/api/model"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ModelApi;

import java.io.File;
import java.util.*;

public class ModelApiExample {

    public static void main(String[] args) {
        
        ModelApi apiInstance = new ModelApi();
        Model body = ; // Model | 
        try {
            Model result = apiInstance.addModel(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ModelApi#addModel");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ModelApi;

public class ModelApiExample {

    public static void main(String[] args) {
        ModelApi apiInstance = new ModelApi();
        Model body = ; // Model | 
        try {
            Model result = apiInstance.addModel(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ModelApi#addModel");
            e.printStackTrace();
        }
    }
}
Model *body = ; //  (optional)

ModelApi *apiInstance = [[ModelApi alloc] init];

// Add a model
[apiInstance addModelWith:body
              completionHandler: ^(Model output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.ModelApi()

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.addModel(, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class addModelExample
    {
        public void main()
        {

            var apiInstance = new ModelApi();
            var body = new Model(); // Model |  (optional) 

            try
            {
                // Add a model
                Model result = apiInstance.addModel(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ModelApi.addModel: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiModelApi();
$body = ; // Model | 

try {
    $result = $api_instance->addModel($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ModelApi->addModel: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ModelApi;

my $api_instance = WWW::SwaggerClient::ModelApi->new();
my $body = WWW::SwaggerClient::Object::Model->new(); # Model | 

eval { 
    my $result = $api_instance->addModel(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ModelApi->addModel: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.ModelApi()
body =  # Model |  (optional)

try: 
    # Add a model
    api_response = api_instance.add_model(body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ModelApi->addModel: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - The new model


deleteModel

Delete model


/api/model/{model_uuid}

Usage and SDK Samples

curl -X DELETE "https://cloud.neuralconcept.com/api/model/{model_uuid}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ModelApi;

import java.io.File;
import java.util.*;

public class ModelApiExample {

    public static void main(String[] args) {
        
        ModelApi apiInstance = new ModelApi();
        UUID modelUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | model name or uuid
        try {
            inline_response_200 result = apiInstance.deleteModel(modelUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ModelApi#deleteModel");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ModelApi;

public class ModelApiExample {

    public static void main(String[] args) {
        ModelApi apiInstance = new ModelApi();
        UUID modelUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | model name or uuid
        try {
            inline_response_200 result = apiInstance.deleteModel(modelUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ModelApi#deleteModel");
            e.printStackTrace();
        }
    }
}
UUID *modelUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // model name or uuid

ModelApi *apiInstance = [[ModelApi alloc] init];

// Delete model
[apiInstance deleteModelWith:modelUuid
              completionHandler: ^(inline_response_200 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.ModelApi()
var modelUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {{UUID}} model name or uuid

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteModel(modelUuid, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class deleteModelExample
    {
        public void main()
        {

            var apiInstance = new ModelApi();
            var modelUuid = new UUID(); // UUID | model name or uuid

            try
            {
                // Delete model
                inline_response_200 result = apiInstance.deleteModel(modelUuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ModelApi.deleteModel: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiModelApi();
$modelUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | model name or uuid

try {
    $result = $api_instance->deleteModel($modelUuid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ModelApi->deleteModel: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ModelApi;

my $api_instance = WWW::SwaggerClient::ModelApi->new();
my $modelUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | model name or uuid

eval { 
    my $result = $api_instance->deleteModel(modelUuid => $modelUuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ModelApi->deleteModel: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.ModelApi()
modelUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | model name or uuid

try: 
    # Delete model
    api_response = api_instance.delete_model(modelUuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ModelApi->deleteModel: %s\n" % e)

Parameters

Path parameters
Name Description
model_uuid*
UUID (uuid)
model name or uuid
Required

Responses

Status: 200 - Delete message


getModel

Get model description


/api/model/{model_uuid}

Usage and SDK Samples

curl -X GET "https://cloud.neuralconcept.com/api/model/{model_uuid}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ModelApi;

import java.io.File;
import java.util.*;

public class ModelApiExample {

    public static void main(String[] args) {
        
        ModelApi apiInstance = new ModelApi();
        UUID modelUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | model name or uuid
        try {
            Model result = apiInstance.getModel(modelUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ModelApi#getModel");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ModelApi;

public class ModelApiExample {

    public static void main(String[] args) {
        ModelApi apiInstance = new ModelApi();
        UUID modelUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | model name or uuid
        try {
            Model result = apiInstance.getModel(modelUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ModelApi#getModel");
            e.printStackTrace();
        }
    }
}
UUID *modelUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // model name or uuid

ModelApi *apiInstance = [[ModelApi alloc] init];

// Get model description
[apiInstance getModelWith:modelUuid
              completionHandler: ^(Model output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.ModelApi()
var modelUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {{UUID}} model name or uuid

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getModel(modelUuid, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getModelExample
    {
        public void main()
        {

            var apiInstance = new ModelApi();
            var modelUuid = new UUID(); // UUID | model name or uuid

            try
            {
                // Get model description
                Model result = apiInstance.getModel(modelUuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ModelApi.getModel: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiModelApi();
$modelUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | model name or uuid

try {
    $result = $api_instance->getModel($modelUuid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ModelApi->getModel: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ModelApi;

my $api_instance = WWW::SwaggerClient::ModelApi->new();
my $modelUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | model name or uuid

eval { 
    my $result = $api_instance->getModel(modelUuid => $modelUuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ModelApi->getModel: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.ModelApi()
modelUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | model name or uuid

try: 
    # Get model description
    api_response = api_instance.get_model(modelUuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ModelApi->getModel: %s\n" % e)

Parameters

Path parameters
Name Description
model_uuid*
UUID (uuid)
model name or uuid
Required

Responses

Status: 200 - The model description


listModels

List models


/api/model

Usage and SDK Samples

curl -X GET "https://cloud.neuralconcept.com/api/model"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ModelApi;

import java.io.File;
import java.util.*;

public class ModelApiExample {

    public static void main(String[] args) {
        
        ModelApi apiInstance = new ModelApi();
        try {
            array[Model] result = apiInstance.listModels();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ModelApi#listModels");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ModelApi;

public class ModelApiExample {

    public static void main(String[] args) {
        ModelApi apiInstance = new ModelApi();
        try {
            array[Model] result = apiInstance.listModels();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ModelApi#listModels");
            e.printStackTrace();
        }
    }
}

ModelApi *apiInstance = [[ModelApi alloc] init];

// List models
[apiInstance listModelsWithCompletionHandler: 
              ^(array[Model] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.ModelApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.listModels(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class listModelsExample
    {
        public void main()
        {

            var apiInstance = new ModelApi();

            try
            {
                // List models
                array[Model] result = apiInstance.listModels();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ModelApi.listModels: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiModelApi();

try {
    $result = $api_instance->listModels();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ModelApi->listModels: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ModelApi;

my $api_instance = WWW::SwaggerClient::ModelApi->new();

eval { 
    my $result = $api_instance->listModels();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ModelApi->listModels: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.ModelApi()

try: 
    # List models
    api_response = api_instance.list_models()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ModelApi->listModels: %s\n" % e)

Parameters

Responses

Status: 200 - Models list


Prediction

deletePredictionJob

delete a specific prediction job


/api/prediction/{job_uuid}/delete

Usage and SDK Samples

curl -X DELETE "https://cloud.neuralconcept.com/api/prediction/{job_uuid}/delete"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PredictionApi;

import java.io.File;
import java.util.*;

public class PredictionApiExample {

    public static void main(String[] args) {
        
        PredictionApi apiInstance = new PredictionApi();
        UUID jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            inline_response_200 result = apiInstance.deletePredictionJob(jobUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PredictionApi#deletePredictionJob");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.PredictionApi;

public class PredictionApiExample {

    public static void main(String[] args) {
        PredictionApi apiInstance = new PredictionApi();
        UUID jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            inline_response_200 result = apiInstance.deletePredictionJob(jobUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PredictionApi#deletePredictionJob");
            e.printStackTrace();
        }
    }
}
UUID *jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // 

PredictionApi *apiInstance = [[PredictionApi alloc] init];

// delete a specific prediction job
[apiInstance deletePredictionJobWith:jobUuid
              completionHandler: ^(inline_response_200 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.PredictionApi()
var jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {{UUID}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deletePredictionJob(jobUuid, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class deletePredictionJobExample
    {
        public void main()
        {

            var apiInstance = new PredictionApi();
            var jobUuid = new UUID(); // UUID | 

            try
            {
                // delete a specific prediction job
                inline_response_200 result = apiInstance.deletePredictionJob(jobUuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PredictionApi.deletePredictionJob: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiPredictionApi();
$jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->deletePredictionJob($jobUuid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling PredictionApi->deletePredictionJob: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PredictionApi;

my $api_instance = WWW::SwaggerClient::PredictionApi->new();
my $jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval { 
    my $result = $api_instance->deletePredictionJob(jobUuid => $jobUuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PredictionApi->deletePredictionJob: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.PredictionApi()
jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | 

try: 
    # delete a specific prediction job
    api_response = api_instance.delete_prediction_job(jobUuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PredictionApi->deletePredictionJob: %s\n" % e)

Parameters

Path parameters
Name Description
job_uuid*
UUID (uuid)
Required

Responses

Status: 200 - Delete message


getPredictionJob

Get details of prediction job


/api/prediction/{job_uuid}

Usage and SDK Samples

curl -X GET "https://cloud.neuralconcept.com/api/prediction/{job_uuid}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PredictionApi;

import java.io.File;
import java.util.*;

public class PredictionApiExample {

    public static void main(String[] args) {
        
        PredictionApi apiInstance = new PredictionApi();
        UUID jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            Prediction result = apiInstance.getPredictionJob(jobUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PredictionApi#getPredictionJob");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.PredictionApi;

public class PredictionApiExample {

    public static void main(String[] args) {
        PredictionApi apiInstance = new PredictionApi();
        UUID jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            Prediction result = apiInstance.getPredictionJob(jobUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PredictionApi#getPredictionJob");
            e.printStackTrace();
        }
    }
}
UUID *jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // 

PredictionApi *apiInstance = [[PredictionApi alloc] init];

// Get details of prediction job
[apiInstance getPredictionJobWith:jobUuid
              completionHandler: ^(Prediction output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.PredictionApi()
var jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {{UUID}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getPredictionJob(jobUuid, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getPredictionJobExample
    {
        public void main()
        {

            var apiInstance = new PredictionApi();
            var jobUuid = new UUID(); // UUID | 

            try
            {
                // Get details of prediction job
                Prediction result = apiInstance.getPredictionJob(jobUuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PredictionApi.getPredictionJob: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiPredictionApi();
$jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->getPredictionJob($jobUuid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling PredictionApi->getPredictionJob: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PredictionApi;

my $api_instance = WWW::SwaggerClient::PredictionApi->new();
my $jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval { 
    my $result = $api_instance->getPredictionJob(jobUuid => $jobUuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PredictionApi->getPredictionJob: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.PredictionApi()
jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | 

try: 
    # Get details of prediction job
    api_response = api_instance.get_prediction_job(jobUuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PredictionApi->getPredictionJob: %s\n" % e)

Parameters

Path parameters
Name Description
job_uuid*
UUID (uuid)
Required

Responses

Status: 200 - Job item


getPredictionResultForSample

get prediction result for a sample


/api/prediction/{job_uuid}/results/{sample_id}

Usage and SDK Samples

curl -X GET "https://cloud.neuralconcept.com/api/prediction/{job_uuid}/results/{sample_id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PredictionApi;

import java.io.File;
import java.util.*;

public class PredictionApiExample {

    public static void main(String[] args) {
        
        PredictionApi apiInstance = new PredictionApi();
        UUID jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        UUID sampleId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            inline_response_200_1 result = apiInstance.getPredictionResultForSample(jobUuid, sampleId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PredictionApi#getPredictionResultForSample");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.PredictionApi;

public class PredictionApiExample {

    public static void main(String[] args) {
        PredictionApi apiInstance = new PredictionApi();
        UUID jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        UUID sampleId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            inline_response_200_1 result = apiInstance.getPredictionResultForSample(jobUuid, sampleId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PredictionApi#getPredictionResultForSample");
            e.printStackTrace();
        }
    }
}
UUID *jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // 
UUID *sampleId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // 

PredictionApi *apiInstance = [[PredictionApi alloc] init];

// get prediction result for a sample
[apiInstance getPredictionResultForSampleWith:jobUuid
    sampleId:sampleId
              completionHandler: ^(inline_response_200_1 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.PredictionApi()
var jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {{UUID}} 
var sampleId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {{UUID}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getPredictionResultForSample(jobUuid, sampleId, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getPredictionResultForSampleExample
    {
        public void main()
        {

            var apiInstance = new PredictionApi();
            var jobUuid = new UUID(); // UUID | 
            var sampleId = new UUID(); // UUID | 

            try
            {
                // get prediction result for a sample
                inline_response_200_1 result = apiInstance.getPredictionResultForSample(jobUuid, sampleId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PredictionApi.getPredictionResultForSample: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiPredictionApi();
$jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$sampleId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->getPredictionResultForSample($jobUuid, $sampleId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling PredictionApi->getPredictionResultForSample: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PredictionApi;

my $api_instance = WWW::SwaggerClient::PredictionApi->new();
my $jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $sampleId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval { 
    my $result = $api_instance->getPredictionResultForSample(jobUuid => $jobUuid, sampleId => $sampleId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PredictionApi->getPredictionResultForSample: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.PredictionApi()
jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | 
sampleId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | 

try: 
    # get prediction result for a sample
    api_response = api_instance.get_prediction_result_for_sample(jobUuid, sampleId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PredictionApi->getPredictionResultForSample: %s\n" % e)

Parameters

Path parameters
Name Description
job_uuid*
UUID (uuid)
Required
sample_id*
UUID (uuid)
Required

Responses

Status: 200 - Sample and prediction result


listPredictionJobs


/api/prediction

Usage and SDK Samples

curl -X GET "https://cloud.neuralconcept.com/api/prediction"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PredictionApi;

import java.io.File;
import java.util.*;

public class PredictionApiExample {

    public static void main(String[] args) {
        
        PredictionApi apiInstance = new PredictionApi();
        try {
            array[Prediction] result = apiInstance.listPredictionJobs();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PredictionApi#listPredictionJobs");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.PredictionApi;

public class PredictionApiExample {

    public static void main(String[] args) {
        PredictionApi apiInstance = new PredictionApi();
        try {
            array[Prediction] result = apiInstance.listPredictionJobs();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PredictionApi#listPredictionJobs");
            e.printStackTrace();
        }
    }
}

PredictionApi *apiInstance = [[PredictionApi alloc] init];

[apiInstance listPredictionJobsWithCompletionHandler: 
              ^(array[Prediction] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.PredictionApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.listPredictionJobs(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class listPredictionJobsExample
    {
        public void main()
        {

            var apiInstance = new PredictionApi();

            try
            {
                array[Prediction] result = apiInstance.listPredictionJobs();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PredictionApi.listPredictionJobs: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiPredictionApi();

try {
    $result = $api_instance->listPredictionJobs();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling PredictionApi->listPredictionJobs: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PredictionApi;

my $api_instance = WWW::SwaggerClient::PredictionApi->new();

eval { 
    my $result = $api_instance->listPredictionJobs();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PredictionApi->listPredictionJobs: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.PredictionApi()

try: 
    api_response = api_instance.list_prediction_jobs()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PredictionApi->listPredictionJobs: %s\n" % e)

Parameters

Responses

Status: 200 - list prediction jobs


listPredictionResultIds

list sample Ids of prediction results


/api/prediction/{job_uuid}/results

Usage and SDK Samples

curl -X GET "https://cloud.neuralconcept.com/api/prediction/{job_uuid}/results"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PredictionApi;

import java.io.File;
import java.util.*;

public class PredictionApiExample {

    public static void main(String[] args) {
        
        PredictionApi apiInstance = new PredictionApi();
        UUID jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            Object result = apiInstance.listPredictionResultIds(jobUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PredictionApi#listPredictionResultIds");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.PredictionApi;

public class PredictionApiExample {

    public static void main(String[] args) {
        PredictionApi apiInstance = new PredictionApi();
        UUID jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            Object result = apiInstance.listPredictionResultIds(jobUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PredictionApi#listPredictionResultIds");
            e.printStackTrace();
        }
    }
}
UUID *jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // 

PredictionApi *apiInstance = [[PredictionApi alloc] init];

// list sample Ids of prediction results
[apiInstance listPredictionResultIdsWith:jobUuid
              completionHandler: ^(Object output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.PredictionApi()
var jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {{UUID}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.listPredictionResultIds(jobUuid, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class listPredictionResultIdsExample
    {
        public void main()
        {

            var apiInstance = new PredictionApi();
            var jobUuid = new UUID(); // UUID | 

            try
            {
                // list sample Ids of prediction results
                Object result = apiInstance.listPredictionResultIds(jobUuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PredictionApi.listPredictionResultIds: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiPredictionApi();
$jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->listPredictionResultIds($jobUuid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling PredictionApi->listPredictionResultIds: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PredictionApi;

my $api_instance = WWW::SwaggerClient::PredictionApi->new();
my $jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval { 
    my $result = $api_instance->listPredictionResultIds(jobUuid => $jobUuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PredictionApi->listPredictionResultIds: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.PredictionApi()
jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | 

try: 
    # list sample Ids of prediction results
    api_response = api_instance.list_prediction_result_ids(jobUuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PredictionApi->listPredictionResultIds: %s\n" % e)

Parameters

Path parameters
Name Description
job_uuid*
UUID (uuid)
Required

Responses

Status: 200 - List of result ids


restartPredictionJob

restart a specific prediction


/api/prediction/{job_uuid}/restart

Usage and SDK Samples

curl -X POST "https://cloud.neuralconcept.com/api/prediction/{job_uuid}/restart"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PredictionApi;

import java.io.File;
import java.util.*;

public class PredictionApiExample {

    public static void main(String[] args) {
        
        PredictionApi apiInstance = new PredictionApi();
        UUID jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            Prediction result = apiInstance.restartPredictionJob(jobUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PredictionApi#restartPredictionJob");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.PredictionApi;

public class PredictionApiExample {

    public static void main(String[] args) {
        PredictionApi apiInstance = new PredictionApi();
        UUID jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            Prediction result = apiInstance.restartPredictionJob(jobUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PredictionApi#restartPredictionJob");
            e.printStackTrace();
        }
    }
}
UUID *jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // 

PredictionApi *apiInstance = [[PredictionApi alloc] init];

// restart a specific prediction
[apiInstance restartPredictionJobWith:jobUuid
              completionHandler: ^(Prediction output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.PredictionApi()
var jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {{UUID}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.restartPredictionJob(jobUuid, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class restartPredictionJobExample
    {
        public void main()
        {

            var apiInstance = new PredictionApi();
            var jobUuid = new UUID(); // UUID | 

            try
            {
                // restart a specific prediction
                Prediction result = apiInstance.restartPredictionJob(jobUuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PredictionApi.restartPredictionJob: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiPredictionApi();
$jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->restartPredictionJob($jobUuid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling PredictionApi->restartPredictionJob: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PredictionApi;

my $api_instance = WWW::SwaggerClient::PredictionApi->new();
my $jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval { 
    my $result = $api_instance->restartPredictionJob(jobUuid => $jobUuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PredictionApi->restartPredictionJob: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.PredictionApi()
jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | 

try: 
    # restart a specific prediction
    api_response = api_instance.restart_prediction_job(jobUuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PredictionApi->restartPredictionJob: %s\n" % e)

Parameters

Path parameters
Name Description
job_uuid*
UUID (uuid)
Required

Responses

Status: 200 - Restarted job


stopPredictionJob

stop a specific prediction


/api/prediction/{job_uuid}/stop

Usage and SDK Samples

curl -X POST "https://cloud.neuralconcept.com/api/prediction/{job_uuid}/stop"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PredictionApi;

import java.io.File;
import java.util.*;

public class PredictionApiExample {

    public static void main(String[] args) {
        
        PredictionApi apiInstance = new PredictionApi();
        UUID jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            Prediction result = apiInstance.stopPredictionJob(jobUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PredictionApi#stopPredictionJob");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.PredictionApi;

public class PredictionApiExample {

    public static void main(String[] args) {
        PredictionApi apiInstance = new PredictionApi();
        UUID jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            Prediction result = apiInstance.stopPredictionJob(jobUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PredictionApi#stopPredictionJob");
            e.printStackTrace();
        }
    }
}
UUID *jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // 

PredictionApi *apiInstance = [[PredictionApi alloc] init];

// stop a specific prediction
[apiInstance stopPredictionJobWith:jobUuid
              completionHandler: ^(Prediction output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.PredictionApi()
var jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {{UUID}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.stopPredictionJob(jobUuid, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class stopPredictionJobExample
    {
        public void main()
        {

            var apiInstance = new PredictionApi();
            var jobUuid = new UUID(); // UUID | 

            try
            {
                // stop a specific prediction
                Prediction result = apiInstance.stopPredictionJob(jobUuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PredictionApi.stopPredictionJob: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiPredictionApi();
$jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->stopPredictionJob($jobUuid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling PredictionApi->stopPredictionJob: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PredictionApi;

my $api_instance = WWW::SwaggerClient::PredictionApi->new();
my $jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval { 
    my $result = $api_instance->stopPredictionJob(jobUuid => $jobUuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PredictionApi->stopPredictionJob: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.PredictionApi()
jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | 

try: 
    # stop a specific prediction
    api_response = api_instance.stop_prediction_job(jobUuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PredictionApi->stopPredictionJob: %s\n" % e)

Parameters

Path parameters
Name Description
job_uuid*
UUID (uuid)
Required

Responses

Status: 200 - Stopped job


submitPredictionJob

submit a batch prediction job


/api/prediction/submit

Usage and SDK Samples

curl -X POST "https://cloud.neuralconcept.com/api/prediction/submit"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PredictionApi;

import java.io.File;
import java.util.*;

public class PredictionApiExample {

    public static void main(String[] args) {
        
        PredictionApi apiInstance = new PredictionApi();
        Prediction body = ; // Prediction | 
        try {
            Prediction result = apiInstance.submitPredictionJob(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PredictionApi#submitPredictionJob");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.PredictionApi;

public class PredictionApiExample {

    public static void main(String[] args) {
        PredictionApi apiInstance = new PredictionApi();
        Prediction body = ; // Prediction | 
        try {
            Prediction result = apiInstance.submitPredictionJob(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PredictionApi#submitPredictionJob");
            e.printStackTrace();
        }
    }
}
Prediction *body = ; //  (optional)

PredictionApi *apiInstance = [[PredictionApi alloc] init];

// submit a batch prediction job
[apiInstance submitPredictionJobWith:body
              completionHandler: ^(Prediction output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.PredictionApi()

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.submitPredictionJob(, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class submitPredictionJobExample
    {
        public void main()
        {

            var apiInstance = new PredictionApi();
            var body = new Prediction(); // Prediction |  (optional) 

            try
            {
                // submit a batch prediction job
                Prediction result = apiInstance.submitPredictionJob(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PredictionApi.submitPredictionJob: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiPredictionApi();
$body = ; // Prediction | 

try {
    $result = $api_instance->submitPredictionJob($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling PredictionApi->submitPredictionJob: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PredictionApi;

my $api_instance = WWW::SwaggerClient::PredictionApi->new();
my $body = WWW::SwaggerClient::Object::Prediction->new(); # Prediction | 

eval { 
    my $result = $api_instance->submitPredictionJob(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PredictionApi->submitPredictionJob: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.PredictionApi()
body =  # Prediction |  (optional)

try: 
    # submit a batch prediction job
    api_response = api_instance.submit_prediction_job(body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PredictionApi->submitPredictionJob: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - The new model


Session

deleteSession

Delete a session


/api/session/{session_id}

Usage and SDK Samples

curl -X DELETE "https://cloud.neuralconcept.com/api/session/{session_id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SessionApi;

import java.io.File;
import java.util.*;

public class SessionApiExample {

    public static void main(String[] args) {
        
        SessionApi apiInstance = new SessionApi();
        String sessionId = sessionId_example; // String | 
        try {
            inline_response_200 result = apiInstance.deleteSession(sessionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SessionApi#deleteSession");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.SessionApi;

public class SessionApiExample {

    public static void main(String[] args) {
        SessionApi apiInstance = new SessionApi();
        String sessionId = sessionId_example; // String | 
        try {
            inline_response_200 result = apiInstance.deleteSession(sessionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SessionApi#deleteSession");
            e.printStackTrace();
        }
    }
}
String *sessionId = sessionId_example; // 

SessionApi *apiInstance = [[SessionApi alloc] init];

// Delete a session
[apiInstance deleteSessionWith:sessionId
              completionHandler: ^(inline_response_200 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.SessionApi()
var sessionId = sessionId_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteSession(sessionId, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class deleteSessionExample
    {
        public void main()
        {

            var apiInstance = new SessionApi();
            var sessionId = sessionId_example;  // String | 

            try
            {
                // Delete a session
                inline_response_200 result = apiInstance.deleteSession(sessionId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SessionApi.deleteSession: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiSessionApi();
$sessionId = sessionId_example; // String | 

try {
    $result = $api_instance->deleteSession($sessionId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling SessionApi->deleteSession: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SessionApi;

my $api_instance = WWW::SwaggerClient::SessionApi->new();
my $sessionId = sessionId_example; # String | 

eval { 
    my $result = $api_instance->deleteSession(sessionId => $sessionId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SessionApi->deleteSession: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.SessionApi()
sessionId = sessionId_example # String | 

try: 
    # Delete a session
    api_response = api_instance.delete_session(sessionId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SessionApi->deleteSession: %s\n" % e)

Parameters

Path parameters
Name Description
session_id*
String
Required

Responses

Status: 200 - Delete message


getSessionInfo

Get session information


/api/session/{session_id}

Usage and SDK Samples

curl -X GET "https://cloud.neuralconcept.com/api/session/{session_id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SessionApi;

import java.io.File;
import java.util.*;

public class SessionApiExample {

    public static void main(String[] args) {
        
        SessionApi apiInstance = new SessionApi();
        String sessionId = sessionId_example; // String | 
        try {
            SessionInfo result = apiInstance.getSessionInfo(sessionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SessionApi#getSessionInfo");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.SessionApi;

public class SessionApiExample {

    public static void main(String[] args) {
        SessionApi apiInstance = new SessionApi();
        String sessionId = sessionId_example; // String | 
        try {
            SessionInfo result = apiInstance.getSessionInfo(sessionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SessionApi#getSessionInfo");
            e.printStackTrace();
        }
    }
}
String *sessionId = sessionId_example; // 

SessionApi *apiInstance = [[SessionApi alloc] init];

// Get session information
[apiInstance getSessionInfoWith:sessionId
              completionHandler: ^(SessionInfo output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.SessionApi()
var sessionId = sessionId_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getSessionInfo(sessionId, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getSessionInfoExample
    {
        public void main()
        {

            var apiInstance = new SessionApi();
            var sessionId = sessionId_example;  // String | 

            try
            {
                // Get session information
                SessionInfo result = apiInstance.getSessionInfo(sessionId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SessionApi.getSessionInfo: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiSessionApi();
$sessionId = sessionId_example; // String | 

try {
    $result = $api_instance->getSessionInfo($sessionId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling SessionApi->getSessionInfo: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SessionApi;

my $api_instance = WWW::SwaggerClient::SessionApi->new();
my $sessionId = sessionId_example; # String | 

eval { 
    my $result = $api_instance->getSessionInfo(sessionId => $sessionId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SessionApi->getSessionInfo: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.SessionApi()
sessionId = sessionId_example # String | 

try: 
    # Get session information
    api_response = api_instance.get_session_info(sessionId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SessionApi->getSessionInfo: %s\n" % e)

Parameters

Path parameters
Name Description
session_id*
String
Required

Responses

Status: 200 - Session status


listSessions

List sessions


/api/session/list

Usage and SDK Samples

curl -X GET "https://cloud.neuralconcept.com/api/session/list"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SessionApi;

import java.io.File;
import java.util.*;

public class SessionApiExample {

    public static void main(String[] args) {
        
        SessionApi apiInstance = new SessionApi();
        try {
            array[SessionInfo] result = apiInstance.listSessions();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SessionApi#listSessions");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.SessionApi;

public class SessionApiExample {

    public static void main(String[] args) {
        SessionApi apiInstance = new SessionApi();
        try {
            array[SessionInfo] result = apiInstance.listSessions();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SessionApi#listSessions");
            e.printStackTrace();
        }
    }
}

SessionApi *apiInstance = [[SessionApi alloc] init];

// List sessions
[apiInstance listSessionsWithCompletionHandler: 
              ^(array[SessionInfo] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.SessionApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.listSessions(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class listSessionsExample
    {
        public void main()
        {

            var apiInstance = new SessionApi();

            try
            {
                // List sessions
                array[SessionInfo] result = apiInstance.listSessions();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SessionApi.listSessions: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiSessionApi();

try {
    $result = $api_instance->listSessions();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling SessionApi->listSessions: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SessionApi;

my $api_instance = WWW::SwaggerClient::SessionApi->new();

eval { 
    my $result = $api_instance->listSessions();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SessionApi->listSessions: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.SessionApi()

try: 
    # List sessions
    api_response = api_instance.list_sessions()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SessionApi->listSessions: %s\n" % e)

Parameters

Responses

Status: 200 - Session list


startSession

Start an interactive session


/api/session/start

Usage and SDK Samples

curl -X POST "https://cloud.neuralconcept.com/api/session/start"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SessionApi;

import java.io.File;
import java.util.*;

public class SessionApiExample {

    public static void main(String[] args) {
        
        SessionApi apiInstance = new SessionApi();
        SessionRequest body = ; // SessionRequest | 
        try {
            SessionInfo result = apiInstance.startSession(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SessionApi#startSession");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.SessionApi;

public class SessionApiExample {

    public static void main(String[] args) {
        SessionApi apiInstance = new SessionApi();
        SessionRequest body = ; // SessionRequest | 
        try {
            SessionInfo result = apiInstance.startSession(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SessionApi#startSession");
            e.printStackTrace();
        }
    }
}
SessionRequest *body = ; //  (optional)

SessionApi *apiInstance = [[SessionApi alloc] init];

// Start an interactive session
[apiInstance startSessionWith:body
              completionHandler: ^(SessionInfo output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.SessionApi()

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.startSession(, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class startSessionExample
    {
        public void main()
        {

            var apiInstance = new SessionApi();
            var body = new SessionRequest(); // SessionRequest |  (optional) 

            try
            {
                // Start an interactive session
                SessionInfo result = apiInstance.startSession(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SessionApi.startSession: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiSessionApi();
$body = ; // SessionRequest | 

try {
    $result = $api_instance->startSession($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling SessionApi->startSession: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SessionApi;

my $api_instance = WWW::SwaggerClient::SessionApi->new();
my $body = WWW::SwaggerClient::Object::SessionRequest->new(); # SessionRequest | 

eval { 
    my $result = $api_instance->startSession(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SessionApi->startSession: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.SessionApi()
body =  # SessionRequest |  (optional)

try: 
    # Start an interactive session
    api_response = api_instance.start_session(body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SessionApi->startSession: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Session id


stopSession

Stop an interactive session


/api/session/{session_id}/stop

Usage and SDK Samples

curl -X POST "https://cloud.neuralconcept.com/api/session/{session_id}/stop"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SessionApi;

import java.io.File;
import java.util.*;

public class SessionApiExample {

    public static void main(String[] args) {
        
        SessionApi apiInstance = new SessionApi();
        String sessionId = sessionId_example; // String | 
        try {
            SessionInfo result = apiInstance.stopSession(sessionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SessionApi#stopSession");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.SessionApi;

public class SessionApiExample {

    public static void main(String[] args) {
        SessionApi apiInstance = new SessionApi();
        String sessionId = sessionId_example; // String | 
        try {
            SessionInfo result = apiInstance.stopSession(sessionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SessionApi#stopSession");
            e.printStackTrace();
        }
    }
}
String *sessionId = sessionId_example; // 

SessionApi *apiInstance = [[SessionApi alloc] init];

// Stop an interactive session
[apiInstance stopSessionWith:sessionId
              completionHandler: ^(SessionInfo output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.SessionApi()
var sessionId = sessionId_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.stopSession(sessionId, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class stopSessionExample
    {
        public void main()
        {

            var apiInstance = new SessionApi();
            var sessionId = sessionId_example;  // String | 

            try
            {
                // Stop an interactive session
                SessionInfo result = apiInstance.stopSession(sessionId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SessionApi.stopSession: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiSessionApi();
$sessionId = sessionId_example; // String | 

try {
    $result = $api_instance->stopSession($sessionId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling SessionApi->stopSession: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SessionApi;

my $api_instance = WWW::SwaggerClient::SessionApi->new();
my $sessionId = sessionId_example; # String | 

eval { 
    my $result = $api_instance->stopSession(sessionId => $sessionId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SessionApi->stopSession: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.SessionApi()
sessionId = sessionId_example # String | 

try: 
    # Stop an interactive session
    api_response = api_instance.stop_session(sessionId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SessionApi->stopSession: %s\n" % e)

Parameters

Path parameters
Name Description
session_id*
String
Required

Responses

Status: 200 - Session id


TrainedModel

addTrainedModel

Add a trained model


/api/trained_model

Usage and SDK Samples

curl -X POST "https://cloud.neuralconcept.com/api/trained_model"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TrainedModelApi;

import java.io.File;
import java.util.*;

public class TrainedModelApiExample {

    public static void main(String[] args) {
        
        TrainedModelApi apiInstance = new TrainedModelApi();
        array[byte[]] filename = ; // array[byte[]] | 
        try {
            TrainedModel result = apiInstance.addTrainedModel(filename);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TrainedModelApi#addTrainedModel");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.TrainedModelApi;

public class TrainedModelApiExample {

    public static void main(String[] args) {
        TrainedModelApi apiInstance = new TrainedModelApi();
        array[byte[]] filename = ; // array[byte[]] | 
        try {
            TrainedModel result = apiInstance.addTrainedModel(filename);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TrainedModelApi#addTrainedModel");
            e.printStackTrace();
        }
    }
}
array[byte[]] *filename = ; //  (optional)

TrainedModelApi *apiInstance = [[TrainedModelApi alloc] init];

// Add a trained model
[apiInstance addTrainedModelWith:filename
              completionHandler: ^(TrainedModel output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.TrainedModelApi()

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.addTrainedModel(, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class addTrainedModelExample
    {
        public void main()
        {

            var apiInstance = new TrainedModelApi();
            var filename = new array[byte[]](); // array[byte[]] |  (optional) 

            try
            {
                // Add a trained model
                TrainedModel result = apiInstance.addTrainedModel(filename);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TrainedModelApi.addTrainedModel: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiTrainedModelApi();
$filename = ; // array[byte[]] | 

try {
    $result = $api_instance->addTrainedModel($filename);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling TrainedModelApi->addTrainedModel: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::TrainedModelApi;

my $api_instance = WWW::SwaggerClient::TrainedModelApi->new();
my $filename = []; # array[byte[]] | 

eval { 
    my $result = $api_instance->addTrainedModel(filename => $filename);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TrainedModelApi->addTrainedModel: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.TrainedModelApi()
filename =  # array[byte[]] |  (optional)

try: 
    # Add a trained model
    api_response = api_instance.add_trained_model(filename=filename)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TrainedModelApi->addTrainedModel: %s\n" % e)

Parameters

Form parameters
Name Description
filename
array[byte[]] (binary)

Responses

Status: 200 - The new trained model


deleteTrainedModel

Delete trained model


/api/trained_model/{model_uuid}

Usage and SDK Samples

curl -X DELETE "https://cloud.neuralconcept.com/api/trained_model/{model_uuid}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TrainedModelApi;

import java.io.File;
import java.util.*;

public class TrainedModelApiExample {

    public static void main(String[] args) {
        
        TrainedModelApi apiInstance = new TrainedModelApi();
        UUID modelUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | model name or uuid
        try {
            inline_response_200 result = apiInstance.deleteTrainedModel(modelUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TrainedModelApi#deleteTrainedModel");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.TrainedModelApi;

public class TrainedModelApiExample {

    public static void main(String[] args) {
        TrainedModelApi apiInstance = new TrainedModelApi();
        UUID modelUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | model name or uuid
        try {
            inline_response_200 result = apiInstance.deleteTrainedModel(modelUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TrainedModelApi#deleteTrainedModel");
            e.printStackTrace();
        }
    }
}
UUID *modelUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // model name or uuid

TrainedModelApi *apiInstance = [[TrainedModelApi alloc] init];

// Delete trained model
[apiInstance deleteTrainedModelWith:modelUuid
              completionHandler: ^(inline_response_200 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.TrainedModelApi()
var modelUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {{UUID}} model name or uuid

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteTrainedModel(modelUuid, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class deleteTrainedModelExample
    {
        public void main()
        {

            var apiInstance = new TrainedModelApi();
            var modelUuid = new UUID(); // UUID | model name or uuid

            try
            {
                // Delete trained model
                inline_response_200 result = apiInstance.deleteTrainedModel(modelUuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TrainedModelApi.deleteTrainedModel: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiTrainedModelApi();
$modelUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | model name or uuid

try {
    $result = $api_instance->deleteTrainedModel($modelUuid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling TrainedModelApi->deleteTrainedModel: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::TrainedModelApi;

my $api_instance = WWW::SwaggerClient::TrainedModelApi->new();
my $modelUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | model name or uuid

eval { 
    my $result = $api_instance->deleteTrainedModel(modelUuid => $modelUuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TrainedModelApi->deleteTrainedModel: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.TrainedModelApi()
modelUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | model name or uuid

try: 
    # Delete trained model
    api_response = api_instance.delete_trained_model(modelUuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TrainedModelApi->deleteTrainedModel: %s\n" % e)

Parameters

Path parameters
Name Description
model_uuid*
UUID (uuid)
model name or uuid
Required

Responses

Status: 200 - Delete message


downloadTrainedModel

Download trained model


/api/trained_model/{model_uuid}/download

Usage and SDK Samples

curl -X GET "https://cloud.neuralconcept.com/api/trained_model/{model_uuid}/download"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TrainedModelApi;

import java.io.File;
import java.util.*;

public class TrainedModelApiExample {

    public static void main(String[] args) {
        
        TrainedModelApi apiInstance = new TrainedModelApi();
        UUID modelUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | model name or uuid
        try {
            byte[] result = apiInstance.downloadTrainedModel(modelUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TrainedModelApi#downloadTrainedModel");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.TrainedModelApi;

public class TrainedModelApiExample {

    public static void main(String[] args) {
        TrainedModelApi apiInstance = new TrainedModelApi();
        UUID modelUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | model name or uuid
        try {
            byte[] result = apiInstance.downloadTrainedModel(modelUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TrainedModelApi#downloadTrainedModel");
            e.printStackTrace();
        }
    }
}
UUID *modelUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // model name or uuid

TrainedModelApi *apiInstance = [[TrainedModelApi alloc] init];

// Download trained model
[apiInstance downloadTrainedModelWith:modelUuid
              completionHandler: ^(byte[] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.TrainedModelApi()
var modelUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {{UUID}} model name or uuid

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.downloadTrainedModel(modelUuid, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class downloadTrainedModelExample
    {
        public void main()
        {

            var apiInstance = new TrainedModelApi();
            var modelUuid = new UUID(); // UUID | model name or uuid

            try
            {
                // Download trained model
                byte[] result = apiInstance.downloadTrainedModel(modelUuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TrainedModelApi.downloadTrainedModel: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiTrainedModelApi();
$modelUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | model name or uuid

try {
    $result = $api_instance->downloadTrainedModel($modelUuid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling TrainedModelApi->downloadTrainedModel: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::TrainedModelApi;

my $api_instance = WWW::SwaggerClient::TrainedModelApi->new();
my $modelUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | model name or uuid

eval { 
    my $result = $api_instance->downloadTrainedModel(modelUuid => $modelUuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TrainedModelApi->downloadTrainedModel: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.TrainedModelApi()
modelUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | model name or uuid

try: 
    # Download trained model
    api_response = api_instance.download_trained_model(modelUuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TrainedModelApi->downloadTrainedModel: %s\n" % e)

Parameters

Path parameters
Name Description
model_uuid*
UUID (uuid)
model name or uuid
Required

Responses

Status: 200 - The trained model


getTrainedModel

Get trained model description


/api/trained_model/{model_uuid}

Usage and SDK Samples

curl -X GET "https://cloud.neuralconcept.com/api/trained_model/{model_uuid}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TrainedModelApi;

import java.io.File;
import java.util.*;

public class TrainedModelApiExample {

    public static void main(String[] args) {
        
        TrainedModelApi apiInstance = new TrainedModelApi();
        UUID modelUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | model name or uuid
        try {
            TrainedModel result = apiInstance.getTrainedModel(modelUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TrainedModelApi#getTrainedModel");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.TrainedModelApi;

public class TrainedModelApiExample {

    public static void main(String[] args) {
        TrainedModelApi apiInstance = new TrainedModelApi();
        UUID modelUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | model name or uuid
        try {
            TrainedModel result = apiInstance.getTrainedModel(modelUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TrainedModelApi#getTrainedModel");
            e.printStackTrace();
        }
    }
}
UUID *modelUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // model name or uuid

TrainedModelApi *apiInstance = [[TrainedModelApi alloc] init];

// Get trained model description
[apiInstance getTrainedModelWith:modelUuid
              completionHandler: ^(TrainedModel output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.TrainedModelApi()
var modelUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {{UUID}} model name or uuid

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getTrainedModel(modelUuid, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getTrainedModelExample
    {
        public void main()
        {

            var apiInstance = new TrainedModelApi();
            var modelUuid = new UUID(); // UUID | model name or uuid

            try
            {
                // Get trained model description
                TrainedModel result = apiInstance.getTrainedModel(modelUuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TrainedModelApi.getTrainedModel: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiTrainedModelApi();
$modelUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | model name or uuid

try {
    $result = $api_instance->getTrainedModel($modelUuid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling TrainedModelApi->getTrainedModel: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::TrainedModelApi;

my $api_instance = WWW::SwaggerClient::TrainedModelApi->new();
my $modelUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | model name or uuid

eval { 
    my $result = $api_instance->getTrainedModel(modelUuid => $modelUuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TrainedModelApi->getTrainedModel: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.TrainedModelApi()
modelUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | model name or uuid

try: 
    # Get trained model description
    api_response = api_instance.get_trained_model(modelUuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TrainedModelApi->getTrainedModel: %s\n" % e)

Parameters

Path parameters
Name Description
model_uuid*
UUID (uuid)
model name or uuid
Required

Responses

Status: 200 - The trained model description


getTrainedModelConfig

Get the config for a trained model


/api/trained_model/{model_uuid}/config

Usage and SDK Samples

curl -X GET "https://cloud.neuralconcept.com/api/trained_model/{model_uuid}/config"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TrainedModelApi;

import java.io.File;
import java.util.*;

public class TrainedModelApiExample {

    public static void main(String[] args) {
        
        TrainedModelApi apiInstance = new TrainedModelApi();
        UUID modelUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | model name or uuid
        try {
            TrainedModelConfig result = apiInstance.getTrainedModelConfig(modelUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TrainedModelApi#getTrainedModelConfig");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.TrainedModelApi;

public class TrainedModelApiExample {

    public static void main(String[] args) {
        TrainedModelApi apiInstance = new TrainedModelApi();
        UUID modelUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | model name or uuid
        try {
            TrainedModelConfig result = apiInstance.getTrainedModelConfig(modelUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TrainedModelApi#getTrainedModelConfig");
            e.printStackTrace();
        }
    }
}
UUID *modelUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // model name or uuid

TrainedModelApi *apiInstance = [[TrainedModelApi alloc] init];

// Get the config for a trained model
[apiInstance getTrainedModelConfigWith:modelUuid
              completionHandler: ^(TrainedModelConfig output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.TrainedModelApi()
var modelUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {{UUID}} model name or uuid

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getTrainedModelConfig(modelUuid, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getTrainedModelConfigExample
    {
        public void main()
        {

            var apiInstance = new TrainedModelApi();
            var modelUuid = new UUID(); // UUID | model name or uuid

            try
            {
                // Get the config for a trained model
                TrainedModelConfig result = apiInstance.getTrainedModelConfig(modelUuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TrainedModelApi.getTrainedModelConfig: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiTrainedModelApi();
$modelUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | model name or uuid

try {
    $result = $api_instance->getTrainedModelConfig($modelUuid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling TrainedModelApi->getTrainedModelConfig: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::TrainedModelApi;

my $api_instance = WWW::SwaggerClient::TrainedModelApi->new();
my $modelUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | model name or uuid

eval { 
    my $result = $api_instance->getTrainedModelConfig(modelUuid => $modelUuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TrainedModelApi->getTrainedModelConfig: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.TrainedModelApi()
modelUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | model name or uuid

try: 
    # Get the config for a trained model
    api_response = api_instance.get_trained_model_config(modelUuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TrainedModelApi->getTrainedModelConfig: %s\n" % e)

Parameters

Path parameters
Name Description
model_uuid*
UUID (uuid)
model name or uuid
Required

Responses

Status: 200 - The trained model config


listTrainedModels

List models


/api/trained_model

Usage and SDK Samples

curl -X GET "https://cloud.neuralconcept.com/api/trained_model"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TrainedModelApi;

import java.io.File;
import java.util.*;

public class TrainedModelApiExample {

    public static void main(String[] args) {
        
        TrainedModelApi apiInstance = new TrainedModelApi();
        try {
            array[TrainedModel] result = apiInstance.listTrainedModels();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TrainedModelApi#listTrainedModels");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.TrainedModelApi;

public class TrainedModelApiExample {

    public static void main(String[] args) {
        TrainedModelApi apiInstance = new TrainedModelApi();
        try {
            array[TrainedModel] result = apiInstance.listTrainedModels();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TrainedModelApi#listTrainedModels");
            e.printStackTrace();
        }
    }
}

TrainedModelApi *apiInstance = [[TrainedModelApi alloc] init];

// List models
[apiInstance listTrainedModelsWithCompletionHandler: 
              ^(array[TrainedModel] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.TrainedModelApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.listTrainedModels(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class listTrainedModelsExample
    {
        public void main()
        {

            var apiInstance = new TrainedModelApi();

            try
            {
                // List models
                array[TrainedModel] result = apiInstance.listTrainedModels();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TrainedModelApi.listTrainedModels: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiTrainedModelApi();

try {
    $result = $api_instance->listTrainedModels();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling TrainedModelApi->listTrainedModels: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::TrainedModelApi;

my $api_instance = WWW::SwaggerClient::TrainedModelApi->new();

eval { 
    my $result = $api_instance->listTrainedModels();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TrainedModelApi->listTrainedModels: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.TrainedModelApi()

try: 
    # List models
    api_response = api_instance.list_trained_models()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TrainedModelApi->listTrainedModels: %s\n" % e)

Parameters

Responses

Status: 200 - Models list


Training

apiTrainingJobUuidDelete

Delete a training job


/api/training/{job_uuid}

Usage and SDK Samples

curl -X DELETE "https://cloud.neuralconcept.com/api/training/{job_uuid}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TrainingApi;

import java.io.File;
import java.util.*;

public class TrainingApiExample {

    public static void main(String[] args) {
        
        TrainingApi apiInstance = new TrainingApi();
        UUID jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            inline_response_200 result = apiInstance.apiTrainingJobUuidDelete(jobUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TrainingApi#apiTrainingJobUuidDelete");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.TrainingApi;

public class TrainingApiExample {

    public static void main(String[] args) {
        TrainingApi apiInstance = new TrainingApi();
        UUID jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            inline_response_200 result = apiInstance.apiTrainingJobUuidDelete(jobUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TrainingApi#apiTrainingJobUuidDelete");
            e.printStackTrace();
        }
    }
}
UUID *jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // 

TrainingApi *apiInstance = [[TrainingApi alloc] init];

// Delete a training job
[apiInstance apiTrainingJobUuidDeleteWith:jobUuid
              completionHandler: ^(inline_response_200 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.TrainingApi()
var jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {{UUID}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.apiTrainingJobUuidDelete(jobUuid, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiTrainingJobUuidDeleteExample
    {
        public void main()
        {

            var apiInstance = new TrainingApi();
            var jobUuid = new UUID(); // UUID | 

            try
            {
                // Delete a training job
                inline_response_200 result = apiInstance.apiTrainingJobUuidDelete(jobUuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TrainingApi.apiTrainingJobUuidDelete: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiTrainingApi();
$jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->apiTrainingJobUuidDelete($jobUuid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling TrainingApi->apiTrainingJobUuidDelete: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::TrainingApi;

my $api_instance = WWW::SwaggerClient::TrainingApi->new();
my $jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval { 
    my $result = $api_instance->apiTrainingJobUuidDelete(jobUuid => $jobUuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TrainingApi->apiTrainingJobUuidDelete: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.TrainingApi()
jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | 

try: 
    # Delete a training job
    api_response = api_instance.api_training_job_uuid_delete(jobUuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TrainingApi->apiTrainingJobUuidDelete: %s\n" % e)

Parameters

Path parameters
Name Description
job_uuid*
UUID (uuid)
Required

Responses

Status: 200 - Delete message


getTrainingCheckpoints

Get training checkpoints


/api/training/{job_uuid}>/checkpoints

Usage and SDK Samples

curl -X GET "https://cloud.neuralconcept.com/api/training/{job_uuid}>/checkpoints"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TrainingApi;

import java.io.File;
import java.util.*;

public class TrainingApiExample {

    public static void main(String[] args) {
        
        TrainingApi apiInstance = new TrainingApi();
        UUID jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            Checkpoints result = apiInstance.getTrainingCheckpoints(jobUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TrainingApi#getTrainingCheckpoints");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.TrainingApi;

public class TrainingApiExample {

    public static void main(String[] args) {
        TrainingApi apiInstance = new TrainingApi();
        UUID jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            Checkpoints result = apiInstance.getTrainingCheckpoints(jobUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TrainingApi#getTrainingCheckpoints");
            e.printStackTrace();
        }
    }
}
UUID *jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // 

TrainingApi *apiInstance = [[TrainingApi alloc] init];

// Get training checkpoints
[apiInstance getTrainingCheckpointsWith:jobUuid
              completionHandler: ^(Checkpoints output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.TrainingApi()
var jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {{UUID}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getTrainingCheckpoints(jobUuid, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getTrainingCheckpointsExample
    {
        public void main()
        {

            var apiInstance = new TrainingApi();
            var jobUuid = new UUID(); // UUID | 

            try
            {
                // Get training checkpoints
                Checkpoints result = apiInstance.getTrainingCheckpoints(jobUuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TrainingApi.getTrainingCheckpoints: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiTrainingApi();
$jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->getTrainingCheckpoints($jobUuid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling TrainingApi->getTrainingCheckpoints: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::TrainingApi;

my $api_instance = WWW::SwaggerClient::TrainingApi->new();
my $jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval { 
    my $result = $api_instance->getTrainingCheckpoints(jobUuid => $jobUuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TrainingApi->getTrainingCheckpoints: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.TrainingApi()
jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | 

try: 
    # Get training checkpoints
    api_response = api_instance.get_training_checkpoints(jobUuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TrainingApi->getTrainingCheckpoints: %s\n" % e)

Parameters

Path parameters
Name Description
job_uuid*
UUID (uuid)
Required

Responses

Status: 200 - Training checkpoints


getTrainingJob

Get training job info


/api/training/{job_uuid}

Usage and SDK Samples

curl -X GET "https://cloud.neuralconcept.com/api/training/{job_uuid}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TrainingApi;

import java.io.File;
import java.util.*;

public class TrainingApiExample {

    public static void main(String[] args) {
        
        TrainingApi apiInstance = new TrainingApi();
        UUID jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            Training result = apiInstance.getTrainingJob(jobUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TrainingApi#getTrainingJob");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.TrainingApi;

public class TrainingApiExample {

    public static void main(String[] args) {
        TrainingApi apiInstance = new TrainingApi();
        UUID jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            Training result = apiInstance.getTrainingJob(jobUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TrainingApi#getTrainingJob");
            e.printStackTrace();
        }
    }
}
UUID *jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // 

TrainingApi *apiInstance = [[TrainingApi alloc] init];

// Get training job info
[apiInstance getTrainingJobWith:jobUuid
              completionHandler: ^(Training output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.TrainingApi()
var jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {{UUID}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getTrainingJob(jobUuid, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getTrainingJobExample
    {
        public void main()
        {

            var apiInstance = new TrainingApi();
            var jobUuid = new UUID(); // UUID | 

            try
            {
                // Get training job info
                Training result = apiInstance.getTrainingJob(jobUuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TrainingApi.getTrainingJob: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiTrainingApi();
$jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->getTrainingJob($jobUuid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling TrainingApi->getTrainingJob: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::TrainingApi;

my $api_instance = WWW::SwaggerClient::TrainingApi->new();
my $jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval { 
    my $result = $api_instance->getTrainingJob(jobUuid => $jobUuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TrainingApi->getTrainingJob: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.TrainingApi()
jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | 

try: 
    # Get training job info
    api_response = api_instance.get_training_job(jobUuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TrainingApi->getTrainingJob: %s\n" % e)

Parameters

Path parameters
Name Description
job_uuid*
UUID (uuid)
Required

Responses

Status: 200 - Job item


getTrainingLog

Get training logs


/api/training/{job_uuid}>/logs

Usage and SDK Samples

curl -X GET "https://cloud.neuralconcept.com/api/training/{job_uuid}>/logs"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TrainingApi;

import java.io.File;
import java.util.*;

public class TrainingApiExample {

    public static void main(String[] args) {
        
        TrainingApi apiInstance = new TrainingApi();
        UUID jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            Logs result = apiInstance.getTrainingLog(jobUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TrainingApi#getTrainingLog");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.TrainingApi;

public class TrainingApiExample {

    public static void main(String[] args) {
        TrainingApi apiInstance = new TrainingApi();
        UUID jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            Logs result = apiInstance.getTrainingLog(jobUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TrainingApi#getTrainingLog");
            e.printStackTrace();
        }
    }
}
UUID *jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // 

TrainingApi *apiInstance = [[TrainingApi alloc] init];

// Get training logs
[apiInstance getTrainingLogWith:jobUuid
              completionHandler: ^(Logs output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.TrainingApi()
var jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {{UUID}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getTrainingLog(jobUuid, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getTrainingLogExample
    {
        public void main()
        {

            var apiInstance = new TrainingApi();
            var jobUuid = new UUID(); // UUID | 

            try
            {
                // Get training logs
                Logs result = apiInstance.getTrainingLog(jobUuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TrainingApi.getTrainingLog: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiTrainingApi();
$jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->getTrainingLog($jobUuid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling TrainingApi->getTrainingLog: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::TrainingApi;

my $api_instance = WWW::SwaggerClient::TrainingApi->new();
my $jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval { 
    my $result = $api_instance->getTrainingLog(jobUuid => $jobUuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TrainingApi->getTrainingLog: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.TrainingApi()
jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | 

try: 
    # Get training logs
    api_response = api_instance.get_training_log(jobUuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TrainingApi->getTrainingLog: %s\n" % e)

Parameters

Path parameters
Name Description
job_uuid*
UUID (uuid)
Required

Responses

Status: 200 - Training logs


listTrainingJobs

List training jobs


/api/training

Usage and SDK Samples

curl -X GET "https://cloud.neuralconcept.com/api/training"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TrainingApi;

import java.io.File;
import java.util.*;

public class TrainingApiExample {

    public static void main(String[] args) {
        
        TrainingApi apiInstance = new TrainingApi();
        try {
            array[Training] result = apiInstance.listTrainingJobs();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TrainingApi#listTrainingJobs");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.TrainingApi;

public class TrainingApiExample {

    public static void main(String[] args) {
        TrainingApi apiInstance = new TrainingApi();
        try {
            array[Training] result = apiInstance.listTrainingJobs();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TrainingApi#listTrainingJobs");
            e.printStackTrace();
        }
    }
}

TrainingApi *apiInstance = [[TrainingApi alloc] init];

// List training jobs
[apiInstance listTrainingJobsWithCompletionHandler: 
              ^(array[Training] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.TrainingApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.listTrainingJobs(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class listTrainingJobsExample
    {
        public void main()
        {

            var apiInstance = new TrainingApi();

            try
            {
                // List training jobs
                array[Training] result = apiInstance.listTrainingJobs();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TrainingApi.listTrainingJobs: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiTrainingApi();

try {
    $result = $api_instance->listTrainingJobs();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling TrainingApi->listTrainingJobs: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::TrainingApi;

my $api_instance = WWW::SwaggerClient::TrainingApi->new();

eval { 
    my $result = $api_instance->listTrainingJobs();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TrainingApi->listTrainingJobs: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.TrainingApi()

try: 
    # List training jobs
    api_response = api_instance.list_training_jobs()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TrainingApi->listTrainingJobs: %s\n" % e)

Parameters

Responses

Status: 200 - Training list


restartTrainingJob

restart a training job


/api/training/{job_uuid}/restart

Usage and SDK Samples

curl -X POST "https://cloud.neuralconcept.com/api/training/{job_uuid}/restart"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TrainingApi;

import java.io.File;
import java.util.*;

public class TrainingApiExample {

    public static void main(String[] args) {
        
        TrainingApi apiInstance = new TrainingApi();
        UUID jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            Training result = apiInstance.restartTrainingJob(jobUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TrainingApi#restartTrainingJob");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.TrainingApi;

public class TrainingApiExample {

    public static void main(String[] args) {
        TrainingApi apiInstance = new TrainingApi();
        UUID jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            Training result = apiInstance.restartTrainingJob(jobUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TrainingApi#restartTrainingJob");
            e.printStackTrace();
        }
    }
}
UUID *jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // 

TrainingApi *apiInstance = [[TrainingApi alloc] init];

// restart a training job
[apiInstance restartTrainingJobWith:jobUuid
              completionHandler: ^(Training output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.TrainingApi()
var jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {{UUID}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.restartTrainingJob(jobUuid, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class restartTrainingJobExample
    {
        public void main()
        {

            var apiInstance = new TrainingApi();
            var jobUuid = new UUID(); // UUID | 

            try
            {
                // restart a training job
                Training result = apiInstance.restartTrainingJob(jobUuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TrainingApi.restartTrainingJob: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiTrainingApi();
$jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->restartTrainingJob($jobUuid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling TrainingApi->restartTrainingJob: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::TrainingApi;

my $api_instance = WWW::SwaggerClient::TrainingApi->new();
my $jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval { 
    my $result = $api_instance->restartTrainingJob(jobUuid => $jobUuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TrainingApi->restartTrainingJob: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.TrainingApi()
jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | 

try: 
    # restart a training job
    api_response = api_instance.restart_training_job(jobUuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TrainingApi->restartTrainingJob: %s\n" % e)

Parameters

Path parameters
Name Description
job_uuid*
UUID (uuid)
Required

Responses

Status: 200 - Restarted job


saveTrainedModelFromTraining

Create a trained model from latest checkpoint.


/api/training/{job_uuid}>/save

Usage and SDK Samples

curl -X POST "https://cloud.neuralconcept.com/api/training/{job_uuid}>/save"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TrainingApi;

import java.io.File;
import java.util.*;

public class TrainingApiExample {

    public static void main(String[] args) {
        
        TrainingApi apiInstance = new TrainingApi();
        UUID jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            TrainedModel result = apiInstance.saveTrainedModelFromTraining(jobUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TrainingApi#saveTrainedModelFromTraining");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.TrainingApi;

public class TrainingApiExample {

    public static void main(String[] args) {
        TrainingApi apiInstance = new TrainingApi();
        UUID jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            TrainedModel result = apiInstance.saveTrainedModelFromTraining(jobUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TrainingApi#saveTrainedModelFromTraining");
            e.printStackTrace();
        }
    }
}
UUID *jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // 

TrainingApi *apiInstance = [[TrainingApi alloc] init];

// Create a trained model from latest checkpoint.
[apiInstance saveTrainedModelFromTrainingWith:jobUuid
              completionHandler: ^(TrainedModel output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.TrainingApi()
var jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {{UUID}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.saveTrainedModelFromTraining(jobUuid, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class saveTrainedModelFromTrainingExample
    {
        public void main()
        {

            var apiInstance = new TrainingApi();
            var jobUuid = new UUID(); // UUID | 

            try
            {
                // Create a trained model from latest checkpoint.
                TrainedModel result = apiInstance.saveTrainedModelFromTraining(jobUuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TrainingApi.saveTrainedModelFromTraining: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiTrainingApi();
$jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->saveTrainedModelFromTraining($jobUuid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling TrainingApi->saveTrainedModelFromTraining: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::TrainingApi;

my $api_instance = WWW::SwaggerClient::TrainingApi->new();
my $jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval { 
    my $result = $api_instance->saveTrainedModelFromTraining(jobUuid => $jobUuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TrainingApi->saveTrainedModelFromTraining: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.TrainingApi()
jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | 

try: 
    # Create a trained model from latest checkpoint.
    api_response = api_instance.save_trained_model_from_training(jobUuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TrainingApi->saveTrainedModelFromTraining: %s\n" % e)

Parameters

Path parameters
Name Description
job_uuid*
UUID (uuid)
Required

Responses

Status: 200 - Trained model


stopTrainingJob

stop a training job


/api/training/{job_uuid}/stop

Usage and SDK Samples

curl -X POST "https://cloud.neuralconcept.com/api/training/{job_uuid}/stop"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TrainingApi;

import java.io.File;
import java.util.*;

public class TrainingApiExample {

    public static void main(String[] args) {
        
        TrainingApi apiInstance = new TrainingApi();
        UUID jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            Training result = apiInstance.stopTrainingJob(jobUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TrainingApi#stopTrainingJob");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.TrainingApi;

public class TrainingApiExample {

    public static void main(String[] args) {
        TrainingApi apiInstance = new TrainingApi();
        UUID jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            Training result = apiInstance.stopTrainingJob(jobUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TrainingApi#stopTrainingJob");
            e.printStackTrace();
        }
    }
}
UUID *jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // 

TrainingApi *apiInstance = [[TrainingApi alloc] init];

// stop a training job
[apiInstance stopTrainingJobWith:jobUuid
              completionHandler: ^(Training output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.TrainingApi()
var jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {{UUID}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.stopTrainingJob(jobUuid, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class stopTrainingJobExample
    {
        public void main()
        {

            var apiInstance = new TrainingApi();
            var jobUuid = new UUID(); // UUID | 

            try
            {
                // stop a training job
                Training result = apiInstance.stopTrainingJob(jobUuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TrainingApi.stopTrainingJob: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiTrainingApi();
$jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->stopTrainingJob($jobUuid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling TrainingApi->stopTrainingJob: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::TrainingApi;

my $api_instance = WWW::SwaggerClient::TrainingApi->new();
my $jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval { 
    my $result = $api_instance->stopTrainingJob(jobUuid => $jobUuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TrainingApi->stopTrainingJob: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.TrainingApi()
jobUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | 

try: 
    # stop a training job
    api_response = api_instance.stop_training_job(jobUuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TrainingApi->stopTrainingJob: %s\n" % e)

Parameters

Path parameters
Name Description
job_uuid*
UUID (uuid)
Required

Responses

Status: 200 - stopped job


submitTrainingJob

Submit a training Job


/api/training/submit

Usage and SDK Samples

curl -X POST "https://cloud.neuralconcept.com/api/training/submit"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TrainingApi;

import java.io.File;
import java.util.*;

public class TrainingApiExample {

    public static void main(String[] args) {
        
        TrainingApi apiInstance = new TrainingApi();
        Training body = ; // Training | 
        try {
            Training result = apiInstance.submitTrainingJob(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TrainingApi#submitTrainingJob");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.TrainingApi;

public class TrainingApiExample {

    public static void main(String[] args) {
        TrainingApi apiInstance = new TrainingApi();
        Training body = ; // Training | 
        try {
            Training result = apiInstance.submitTrainingJob(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TrainingApi#submitTrainingJob");
            e.printStackTrace();
        }
    }
}
Training *body = ; // 

TrainingApi *apiInstance = [[TrainingApi alloc] init];

// Submit a training Job
[apiInstance submitTrainingJobWith:body
              completionHandler: ^(Training output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.TrainingApi()
var body = ; // {{Training}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.submitTrainingJob(body, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class submitTrainingJobExample
    {
        public void main()
        {

            var apiInstance = new TrainingApi();
            var body = new Training(); // Training | 

            try
            {
                // Submit a training Job
                Training result = apiInstance.submitTrainingJob(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TrainingApi.submitTrainingJob: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiTrainingApi();
$body = ; // Training | 

try {
    $result = $api_instance->submitTrainingJob($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling TrainingApi->submitTrainingJob: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::TrainingApi;

my $api_instance = WWW::SwaggerClient::TrainingApi->new();
my $body = WWW::SwaggerClient::Object::Training->new(); # Training | 

eval { 
    my $result = $api_instance->submitTrainingJob(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TrainingApi->submitTrainingJob: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.TrainingApi()
body =  # Training | 

try: 
    # Submit a training Job
    api_response = api_instance.submit_training_job(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TrainingApi->submitTrainingJob: %s\n" % e)

Parameters

Body parameters
Name Description
body *

Responses

Status: 200 - The new training job definition


User

deleteUser

delete a user


/api/user/{user_uuid}

Usage and SDK Samples

curl -X DELETE "https://cloud.neuralconcept.com/api/user/{user_uuid}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.UserApi;

import java.io.File;
import java.util.*;

public class UserApiExample {

    public static void main(String[] args) {
        
        UserApi apiInstance = new UserApi();
        UUID userUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            inline_response_200_4 result = apiInstance.deleteUser(userUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserApi#deleteUser");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.UserApi;

public class UserApiExample {

    public static void main(String[] args) {
        UserApi apiInstance = new UserApi();
        UUID userUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            inline_response_200_4 result = apiInstance.deleteUser(userUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserApi#deleteUser");
            e.printStackTrace();
        }
    }
}
UUID *userUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // 

UserApi *apiInstance = [[UserApi alloc] init];

// delete a user
[apiInstance deleteUserWith:userUuid
              completionHandler: ^(inline_response_200_4 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.UserApi()
var userUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {{UUID}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteUser(userUuid, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class deleteUserExample
    {
        public void main()
        {

            var apiInstance = new UserApi();
            var userUuid = new UUID(); // UUID | 

            try
            {
                // delete a user
                inline_response_200_4 result = apiInstance.deleteUser(userUuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling UserApi.deleteUser: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiUserApi();
$userUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->deleteUser($userUuid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UserApi->deleteUser: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::UserApi;

my $api_instance = WWW::SwaggerClient::UserApi->new();
my $userUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval { 
    my $result = $api_instance->deleteUser(userUuid => $userUuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserApi->deleteUser: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.UserApi()
userUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | 

try: 
    # delete a user
    api_response = api_instance.delete_user(userUuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserApi->deleteUser: %s\n" % e)

Parameters

Path parameters
Name Description
user_uuid*
UUID (uuid)
Required

Responses

Status: 200 - delete message


getUser

get info about a user


/api/user/{user_uuid}

Usage and SDK Samples

curl -X GET "https://cloud.neuralconcept.com/api/user/{user_uuid}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.UserApi;

import java.io.File;
import java.util.*;

public class UserApiExample {

    public static void main(String[] args) {
        
        UserApi apiInstance = new UserApi();
        UUID userUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            User result = apiInstance.getUser(userUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserApi#getUser");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.UserApi;

public class UserApiExample {

    public static void main(String[] args) {
        UserApi apiInstance = new UserApi();
        UUID userUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            User result = apiInstance.getUser(userUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserApi#getUser");
            e.printStackTrace();
        }
    }
}
UUID *userUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // 

UserApi *apiInstance = [[UserApi alloc] init];

// get info about a user
[apiInstance getUserWith:userUuid
              completionHandler: ^(User output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.UserApi()
var userUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {{UUID}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getUser(userUuid, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getUserExample
    {
        public void main()
        {

            var apiInstance = new UserApi();
            var userUuid = new UUID(); // UUID | 

            try
            {
                // get info about a user
                User result = apiInstance.getUser(userUuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling UserApi.getUser: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiUserApi();
$userUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->getUser($userUuid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UserApi->getUser: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::UserApi;

my $api_instance = WWW::SwaggerClient::UserApi->new();
my $userUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval { 
    my $result = $api_instance->getUser(userUuid => $userUuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserApi->getUser: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.UserApi()
userUuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | 

try: 
    # get info about a user
    api_response = api_instance.get_user(userUuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserApi->getUser: %s\n" % e)

Parameters

Path parameters
Name Description
user_uuid*
UUID (uuid)
Required

Responses

Status: 200 - User info


login

user login


/api/user/login

Usage and SDK Samples

curl -X POST "https://cloud.neuralconcept.com/api/user/login"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.UserApi;

import java.io.File;
import java.util.*;

public class UserApiExample {

    public static void main(String[] args) {
        
        UserApi apiInstance = new UserApi();
        User body = ; // User | 
        try {
            User result = apiInstance.login(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserApi#login");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.UserApi;

public class UserApiExample {

    public static void main(String[] args) {
        UserApi apiInstance = new UserApi();
        User body = ; // User | 
        try {
            User result = apiInstance.login(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserApi#login");
            e.printStackTrace();
        }
    }
}
User *body = ; // 

UserApi *apiInstance = [[UserApi alloc] init];

// user login
[apiInstance loginWith:body
              completionHandler: ^(User output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.UserApi()
var body = ; // {{User}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.login(body, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class loginExample
    {
        public void main()
        {

            var apiInstance = new UserApi();
            var body = new User(); // User | 

            try
            {
                // user login
                User result = apiInstance.login(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling UserApi.login: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiUserApi();
$body = ; // User | 

try {
    $result = $api_instance->login($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UserApi->login: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::UserApi;

my $api_instance = WWW::SwaggerClient::UserApi->new();
my $body = WWW::SwaggerClient::Object::User->new(); # User | 

eval { 
    my $result = $api_instance->login(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserApi->login: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.UserApi()
body =  # User | 

try: 
    # user login
    api_response = api_instance.login(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserApi->login: %s\n" % e)

Parameters

Body parameters
Name Description
body *

Responses

Status: 200 - Logged in user


logout

logout user


/api/user/logout

Usage and SDK Samples

curl -X GET "https://cloud.neuralconcept.com/api/user/logout"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.UserApi;

import java.io.File;
import java.util.*;

public class UserApiExample {

    public static void main(String[] args) {
        
        UserApi apiInstance = new UserApi();
        try {
            inline_response_200_2 result = apiInstance.logout();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserApi#logout");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.UserApi;

public class UserApiExample {

    public static void main(String[] args) {
        UserApi apiInstance = new UserApi();
        try {
            inline_response_200_2 result = apiInstance.logout();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserApi#logout");
            e.printStackTrace();
        }
    }
}

UserApi *apiInstance = [[UserApi alloc] init];

// logout user
[apiInstance logoutWithCompletionHandler: 
              ^(inline_response_200_2 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.UserApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.logout(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class logoutExample
    {
        public void main()
        {

            var apiInstance = new UserApi();

            try
            {
                // logout user
                inline_response_200_2 result = apiInstance.logout();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling UserApi.logout: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiUserApi();

try {
    $result = $api_instance->logout();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UserApi->logout: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::UserApi;

my $api_instance = WWW::SwaggerClient::UserApi->new();

eval { 
    my $result = $api_instance->logout();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserApi->logout: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.UserApi()

try: 
    # logout user
    api_response = api_instance.logout()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserApi->logout: %s\n" % e)

Parameters

Responses

Status: 200 - Logout message


passwordReset

send password reset email


/api/user/password_reset

Usage and SDK Samples

curl -X POST "https://cloud.neuralconcept.com/api/user/password_reset?token="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.UserApi;

import java.io.File;
import java.util.*;

public class UserApiExample {

    public static void main(String[] args) {
        
        UserApi apiInstance = new UserApi();
        Body_4 body = ; // Body_4 | 
        String token = token_example; // String | 
        try {
            inline_response_200_3 result = apiInstance.passwordReset(body, token);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserApi#passwordReset");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.UserApi;

public class UserApiExample {

    public static void main(String[] args) {
        UserApi apiInstance = new UserApi();
        Body_4 body = ; // Body_4 | 
        String token = token_example; // String | 
        try {
            inline_response_200_3 result = apiInstance.passwordReset(body, token);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserApi#passwordReset");
            e.printStackTrace();
        }
    }
}
Body_4 *body = ; // 
String *token = token_example; // 

UserApi *apiInstance = [[UserApi alloc] init];

// send password reset email
[apiInstance passwordResetWith:body
    token:token
              completionHandler: ^(inline_response_200_3 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var NeuralConceptApi = require('neural_concept_api');

var api = new NeuralConceptApi.UserApi()
var body = ; // {{Body_4}} 
var token = token_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.passwordReset(bodytoken, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class passwordResetExample
    {
        public void main()
        {

            var apiInstance = new UserApi();
            var body = new Body_4(); // Body_4 | 
            var token = token_example;  // String | 

            try
            {
                // send password reset email
                inline_response_200_3 result = apiInstance.passwordReset(body, token);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling UserApi.passwordReset: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiUserApi();
$body = ; // Body_4 | 
$token = token_example; // String | 

try {
    $result = $api_instance->passwordReset($body, $token);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UserApi->passwordReset: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::UserApi;

my $api_instance = WWW::SwaggerClient::UserApi->new();
my $body = WWW::SwaggerClient::Object::Body_4->new(); # Body_4 | 
my $token = token_example; # String | 

eval { 
    my $result = $api_instance->passwordReset(body => $body, token => $token);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserApi->passwordReset: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.UserApi()
body =  # Body_4 | 
token = token_example # String | 

try: 
    # send password reset email
    api_response = api_instance.password_reset(body, token)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserApi->passwordReset: %s\n" % e)

Parameters

Body parameters
Name Description
body *