Portfolio Optimizer

POST Absorption Ratio

{{baseUrl}}/assets/analysis/absorption-ratio

BODY json

{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsCovarianceMatrixEigenvectors": {
    "eigenvectorsRetained": 0
  }
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/assets/analysis/absorption-ratio");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsCovarianceMatrixEigenvectors\": {\n    \"eigenvectorsRetained\": 0\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/assets/analysis/absorption-ratio" {:content-type :json
                                                                             :form-params {:assets 0
                                                                                           :assetsCovarianceMatrix []
                                                                                           :assetsCovarianceMatrixEigenvectors {:eigenvectorsRetained 0}}})

require "http/client"

url = "{{baseUrl}}/assets/analysis/absorption-ratio"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsCovarianceMatrixEigenvectors\": {\n    \"eigenvectorsRetained\": 0\n  }\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/assets/analysis/absorption-ratio"),
    Content = new StringContent("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsCovarianceMatrixEigenvectors\": {\n    \"eigenvectorsRetained\": 0\n  }\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/assets/analysis/absorption-ratio");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsCovarianceMatrixEigenvectors\": {\n    \"eigenvectorsRetained\": 0\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/assets/analysis/absorption-ratio"

	payload := strings.NewReader("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsCovarianceMatrixEigenvectors\": {\n    \"eigenvectorsRetained\": 0\n  }\n}")

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

	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/assets/analysis/absorption-ratio HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 126

{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsCovarianceMatrixEigenvectors": {
    "eigenvectorsRetained": 0
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/assets/analysis/absorption-ratio")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsCovarianceMatrixEigenvectors\": {\n    \"eigenvectorsRetained\": 0\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/assets/analysis/absorption-ratio"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsCovarianceMatrixEigenvectors\": {\n    \"eigenvectorsRetained\": 0\n  }\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsCovarianceMatrixEigenvectors\": {\n    \"eigenvectorsRetained\": 0\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/assets/analysis/absorption-ratio")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/assets/analysis/absorption-ratio")
  .header("content-type", "application/json")
  .body("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsCovarianceMatrixEigenvectors\": {\n    \"eigenvectorsRetained\": 0\n  }\n}")
  .asString();

const data = JSON.stringify({
  assets: 0,
  assetsCovarianceMatrix: [],
  assetsCovarianceMatrixEigenvectors: {
    eigenvectorsRetained: 0
  }
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/assets/analysis/absorption-ratio');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/assets/analysis/absorption-ratio',
  headers: {'content-type': 'application/json'},
  data: {
    assets: 0,
    assetsCovarianceMatrix: [],
    assetsCovarianceMatrixEigenvectors: {eigenvectorsRetained: 0}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/assets/analysis/absorption-ratio';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":0,"assetsCovarianceMatrix":[],"assetsCovarianceMatrixEigenvectors":{"eigenvectorsRetained":0}}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/assets/analysis/absorption-ratio',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "assets": 0,\n  "assetsCovarianceMatrix": [],\n  "assetsCovarianceMatrixEigenvectors": {\n    "eigenvectorsRetained": 0\n  }\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsCovarianceMatrixEigenvectors\": {\n    \"eigenvectorsRetained\": 0\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/assets/analysis/absorption-ratio")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/assets/analysis/absorption-ratio',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  assets: 0,
  assetsCovarianceMatrix: [],
  assetsCovarianceMatrixEigenvectors: {eigenvectorsRetained: 0}
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/assets/analysis/absorption-ratio',
  headers: {'content-type': 'application/json'},
  body: {
    assets: 0,
    assetsCovarianceMatrix: [],
    assetsCovarianceMatrixEigenvectors: {eigenvectorsRetained: 0}
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/assets/analysis/absorption-ratio');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  assets: 0,
  assetsCovarianceMatrix: [],
  assetsCovarianceMatrixEigenvectors: {
    eigenvectorsRetained: 0
  }
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/assets/analysis/absorption-ratio',
  headers: {'content-type': 'application/json'},
  data: {
    assets: 0,
    assetsCovarianceMatrix: [],
    assetsCovarianceMatrixEigenvectors: {eigenvectorsRetained: 0}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/assets/analysis/absorption-ratio';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":0,"assetsCovarianceMatrix":[],"assetsCovarianceMatrixEigenvectors":{"eigenvectorsRetained":0}}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"assets": @0,
                              @"assetsCovarianceMatrix": @[  ],
                              @"assetsCovarianceMatrixEigenvectors": @{ @"eigenvectorsRetained": @0 } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/assets/analysis/absorption-ratio"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/assets/analysis/absorption-ratio" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsCovarianceMatrixEigenvectors\": {\n    \"eigenvectorsRetained\": 0\n  }\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/assets/analysis/absorption-ratio",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'assets' => 0,
    'assetsCovarianceMatrix' => [
        
    ],
    'assetsCovarianceMatrixEigenvectors' => [
        'eigenvectorsRetained' => 0
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/assets/analysis/absorption-ratio', [
  'body' => '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsCovarianceMatrixEigenvectors": {
    "eigenvectorsRetained": 0
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/assets/analysis/absorption-ratio');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'assets' => 0,
  'assetsCovarianceMatrix' => [
    
  ],
  'assetsCovarianceMatrixEigenvectors' => [
    'eigenvectorsRetained' => 0
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'assets' => 0,
  'assetsCovarianceMatrix' => [
    
  ],
  'assetsCovarianceMatrixEigenvectors' => [
    'eigenvectorsRetained' => 0
  ]
]));
$request->setRequestUrl('{{baseUrl}}/assets/analysis/absorption-ratio');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/assets/analysis/absorption-ratio' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsCovarianceMatrixEigenvectors": {
    "eigenvectorsRetained": 0
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/assets/analysis/absorption-ratio' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsCovarianceMatrixEigenvectors": {
    "eigenvectorsRetained": 0
  }
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsCovarianceMatrixEigenvectors\": {\n    \"eigenvectorsRetained\": 0\n  }\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/assets/analysis/absorption-ratio", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/assets/analysis/absorption-ratio"

payload = {
    "assets": 0,
    "assetsCovarianceMatrix": [],
    "assetsCovarianceMatrixEigenvectors": { "eigenvectorsRetained": 0 }
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/assets/analysis/absorption-ratio"

payload <- "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsCovarianceMatrixEigenvectors\": {\n    \"eigenvectorsRetained\": 0\n  }\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/assets/analysis/absorption-ratio")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsCovarianceMatrixEigenvectors\": {\n    \"eigenvectorsRetained\": 0\n  }\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/assets/analysis/absorption-ratio') do |req|
  req.body = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsCovarianceMatrixEigenvectors\": {\n    \"eigenvectorsRetained\": 0\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/assets/analysis/absorption-ratio";

    let payload = json!({
        "assets": 0,
        "assetsCovarianceMatrix": (),
        "assetsCovarianceMatrixEigenvectors": json!({"eigenvectorsRetained": 0})
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/assets/analysis/absorption-ratio \
  --header 'content-type: application/json' \
  --data '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsCovarianceMatrixEigenvectors": {
    "eigenvectorsRetained": 0
  }
}'

echo '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsCovarianceMatrixEigenvectors": {
    "eigenvectorsRetained": 0
  }
}' |  \
  http POST {{baseUrl}}/assets/analysis/absorption-ratio \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "assets": 0,\n  "assetsCovarianceMatrix": [],\n  "assetsCovarianceMatrixEigenvectors": {\n    "eigenvectorsRetained": 0\n  }\n}' \
  --output-document \
  - {{baseUrl}}/assets/analysis/absorption-ratio

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsCovarianceMatrixEigenvectors": ["eigenvectorsRetained": 0]
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/assets/analysis/absorption-ratio")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "assetsAbsorptionRatio": 0.9123105625617661
}

POST Turbulence Index

{{baseUrl}}/assets/analysis/turbulence-index

BODY json

{
  "assets": 0,
  "assetsAverageReturns": [],
  "assetsCovarianceMatrix": [],
  "assetsReturns": []
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/assets/analysis/turbulence-index");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"assets\": 0,\n  \"assetsAverageReturns\": [],\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": []\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/assets/analysis/turbulence-index" {:content-type :json
                                                                             :form-params {:assets 0
                                                                                           :assetsAverageReturns []
                                                                                           :assetsCovarianceMatrix []
                                                                                           :assetsReturns []}})

require "http/client"

url = "{{baseUrl}}/assets/analysis/turbulence-index"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"assets\": 0,\n  \"assetsAverageReturns\": [],\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": []\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/assets/analysis/turbulence-index"),
    Content = new StringContent("{\n  \"assets\": 0,\n  \"assetsAverageReturns\": [],\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": []\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/assets/analysis/turbulence-index");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"assets\": 0,\n  \"assetsAverageReturns\": [],\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/assets/analysis/turbulence-index"

	payload := strings.NewReader("{\n  \"assets\": 0,\n  \"assetsAverageReturns\": [],\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": []\n}")

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

	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/assets/analysis/turbulence-index HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 102

{
  "assets": 0,
  "assetsAverageReturns": [],
  "assetsCovarianceMatrix": [],
  "assetsReturns": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/assets/analysis/turbulence-index")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"assets\": 0,\n  \"assetsAverageReturns\": [],\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/assets/analysis/turbulence-index"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"assets\": 0,\n  \"assetsAverageReturns\": [],\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": []\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"assets\": 0,\n  \"assetsAverageReturns\": [],\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": []\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/assets/analysis/turbulence-index")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/assets/analysis/turbulence-index")
  .header("content-type", "application/json")
  .body("{\n  \"assets\": 0,\n  \"assetsAverageReturns\": [],\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": []\n}")
  .asString();

const data = JSON.stringify({
  assets: 0,
  assetsAverageReturns: [],
  assetsCovarianceMatrix: [],
  assetsReturns: []
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/assets/analysis/turbulence-index');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/assets/analysis/turbulence-index',
  headers: {'content-type': 'application/json'},
  data: {
    assets: 0,
    assetsAverageReturns: [],
    assetsCovarianceMatrix: [],
    assetsReturns: []
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/assets/analysis/turbulence-index';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":0,"assetsAverageReturns":[],"assetsCovarianceMatrix":[],"assetsReturns":[]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/assets/analysis/turbulence-index',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "assets": 0,\n  "assetsAverageReturns": [],\n  "assetsCovarianceMatrix": [],\n  "assetsReturns": []\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"assets\": 0,\n  \"assetsAverageReturns\": [],\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/assets/analysis/turbulence-index")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/assets/analysis/turbulence-index',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  assets: 0,
  assetsAverageReturns: [],
  assetsCovarianceMatrix: [],
  assetsReturns: []
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/assets/analysis/turbulence-index',
  headers: {'content-type': 'application/json'},
  body: {
    assets: 0,
    assetsAverageReturns: [],
    assetsCovarianceMatrix: [],
    assetsReturns: []
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/assets/analysis/turbulence-index');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  assets: 0,
  assetsAverageReturns: [],
  assetsCovarianceMatrix: [],
  assetsReturns: []
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/assets/analysis/turbulence-index',
  headers: {'content-type': 'application/json'},
  data: {
    assets: 0,
    assetsAverageReturns: [],
    assetsCovarianceMatrix: [],
    assetsReturns: []
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/assets/analysis/turbulence-index';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":0,"assetsAverageReturns":[],"assetsCovarianceMatrix":[],"assetsReturns":[]}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"assets": @0,
                              @"assetsAverageReturns": @[  ],
                              @"assetsCovarianceMatrix": @[  ],
                              @"assetsReturns": @[  ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/assets/analysis/turbulence-index"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/assets/analysis/turbulence-index" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"assets\": 0,\n  \"assetsAverageReturns\": [],\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": []\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/assets/analysis/turbulence-index",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'assets' => 0,
    'assetsAverageReturns' => [
        
    ],
    'assetsCovarianceMatrix' => [
        
    ],
    'assetsReturns' => [
        
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/assets/analysis/turbulence-index', [
  'body' => '{
  "assets": 0,
  "assetsAverageReturns": [],
  "assetsCovarianceMatrix": [],
  "assetsReturns": []
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/assets/analysis/turbulence-index');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'assets' => 0,
  'assetsAverageReturns' => [
    
  ],
  'assetsCovarianceMatrix' => [
    
  ],
  'assetsReturns' => [
    
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'assets' => 0,
  'assetsAverageReturns' => [
    
  ],
  'assetsCovarianceMatrix' => [
    
  ],
  'assetsReturns' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/assets/analysis/turbulence-index');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/assets/analysis/turbulence-index' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": 0,
  "assetsAverageReturns": [],
  "assetsCovarianceMatrix": [],
  "assetsReturns": []
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/assets/analysis/turbulence-index' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": 0,
  "assetsAverageReturns": [],
  "assetsCovarianceMatrix": [],
  "assetsReturns": []
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"assets\": 0,\n  \"assetsAverageReturns\": [],\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": []\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/assets/analysis/turbulence-index", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/assets/analysis/turbulence-index"

payload = {
    "assets": 0,
    "assetsAverageReturns": [],
    "assetsCovarianceMatrix": [],
    "assetsReturns": []
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/assets/analysis/turbulence-index"

payload <- "{\n  \"assets\": 0,\n  \"assetsAverageReturns\": [],\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": []\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/assets/analysis/turbulence-index")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"assets\": 0,\n  \"assetsAverageReturns\": [],\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": []\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/assets/analysis/turbulence-index') do |req|
  req.body = "{\n  \"assets\": 0,\n  \"assetsAverageReturns\": [],\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": []\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/assets/analysis/turbulence-index";

    let payload = json!({
        "assets": 0,
        "assetsAverageReturns": (),
        "assetsCovarianceMatrix": (),
        "assetsReturns": ()
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/assets/analysis/turbulence-index \
  --header 'content-type: application/json' \
  --data '{
  "assets": 0,
  "assetsAverageReturns": [],
  "assetsCovarianceMatrix": [],
  "assetsReturns": []
}'

echo '{
  "assets": 0,
  "assetsAverageReturns": [],
  "assetsCovarianceMatrix": [],
  "assetsReturns": []
}' |  \
  http POST {{baseUrl}}/assets/analysis/turbulence-index \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "assets": 0,\n  "assetsAverageReturns": [],\n  "assetsCovarianceMatrix": [],\n  "assetsReturns": []\n}' \
  --output-document \
  - {{baseUrl}}/assets/analysis/turbulence-index

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "assets": 0,
  "assetsAverageReturns": [],
  "assetsCovarianceMatrix": [],
  "assetsReturns": []
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/assets/analysis/turbulence-index")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "assetsTurbulenceIndex": 0.5624999999999999
}

POST Correlation Matrix Bounds

{{baseUrl}}/assets/correlation/matrix/bounds

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/assets/correlation/matrix/bounds");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/assets/correlation/matrix/bounds")

require "http/client"

url = "{{baseUrl}}/assets/correlation/matrix/bounds"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/assets/correlation/matrix/bounds"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/assets/correlation/matrix/bounds");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/assets/correlation/matrix/bounds"

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

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

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

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

}

POST /baseUrl/assets/correlation/matrix/bounds HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/assets/correlation/matrix/bounds")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/assets/correlation/matrix/bounds"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/assets/correlation/matrix/bounds")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/assets/correlation/matrix/bounds")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/assets/correlation/matrix/bounds');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/assets/correlation/matrix/bounds'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/assets/correlation/matrix/bounds';
const options = {method: 'POST'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/assets/correlation/matrix/bounds',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/assets/correlation/matrix/bounds")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/assets/correlation/matrix/bounds',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/assets/correlation/matrix/bounds'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/assets/correlation/matrix/bounds');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/assets/correlation/matrix/bounds'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/assets/correlation/matrix/bounds';
const options = {method: 'POST'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/assets/correlation/matrix/bounds"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/assets/correlation/matrix/bounds" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/assets/correlation/matrix/bounds",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/assets/correlation/matrix/bounds');

echo $response->getBody();

setUrl('{{baseUrl}}/assets/correlation/matrix/bounds');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/assets/correlation/matrix/bounds');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/assets/correlation/matrix/bounds' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/assets/correlation/matrix/bounds' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = ""

conn.request("POST", "/baseUrl/assets/correlation/matrix/bounds", payload)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/assets/correlation/matrix/bounds"

payload = ""

response = requests.post(url, data=payload)

print(response.json())

library(httr)

url <- "{{baseUrl}}/assets/correlation/matrix/bounds"

payload <- ""

response <- VERB("POST", url, body = payload, content_type(""))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/assets/correlation/matrix/bounds")

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

request = Net::HTTP::Post.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/assets/correlation/matrix/bounds') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/assets/correlation/matrix/bounds";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/assets/correlation/matrix/bounds

http POST {{baseUrl}}/assets/correlation/matrix/bounds

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/assets/correlation/matrix/bounds

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/assets/correlation/matrix/bounds")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "assetsCorrelationMatrixLowerBounds": [
    [
      1,
      0.5,
      0.5,
      0
    ],
    [
      0.5,
      1,
      0.5,
      0.3
    ],
    [
      0.5,
      0.5,
      1,
      -0.6659
    ],
    [
      0,
      0.3,
      -0.6659,
      1
    ]
  ],
  "assetsCorrelationMatrixUpperBounds": [
    [
      1,
      0.5,
      0.5,
      0
    ],
    [
      0.5,
      1,
      0.5,
      0.3
    ],
    [
      0.5,
      0.5,
      1,
      0.8659
    ],
    [
      0,
      0.3,
      0.8659,
      1
    ]
  ]
}

POST Correlation Matrix Distance

{{baseUrl}}/assets/correlation/matrix/distance

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/assets/correlation/matrix/distance");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/assets/correlation/matrix/distance")

require "http/client"

url = "{{baseUrl}}/assets/correlation/matrix/distance"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/assets/correlation/matrix/distance"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/assets/correlation/matrix/distance");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/assets/correlation/matrix/distance"

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

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

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

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

}

POST /baseUrl/assets/correlation/matrix/distance HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/assets/correlation/matrix/distance")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/assets/correlation/matrix/distance"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/assets/correlation/matrix/distance")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/assets/correlation/matrix/distance")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/assets/correlation/matrix/distance');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/assets/correlation/matrix/distance'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/assets/correlation/matrix/distance';
const options = {method: 'POST'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/assets/correlation/matrix/distance',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/assets/correlation/matrix/distance")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/assets/correlation/matrix/distance',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/assets/correlation/matrix/distance'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/assets/correlation/matrix/distance');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/assets/correlation/matrix/distance'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/assets/correlation/matrix/distance';
const options = {method: 'POST'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/assets/correlation/matrix/distance"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/assets/correlation/matrix/distance" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/assets/correlation/matrix/distance",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/assets/correlation/matrix/distance');

echo $response->getBody();

setUrl('{{baseUrl}}/assets/correlation/matrix/distance');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/assets/correlation/matrix/distance');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/assets/correlation/matrix/distance' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/assets/correlation/matrix/distance' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = ""

conn.request("POST", "/baseUrl/assets/correlation/matrix/distance", payload)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/assets/correlation/matrix/distance"

payload = ""

response = requests.post(url, data=payload)

print(response.json())

library(httr)

url <- "{{baseUrl}}/assets/correlation/matrix/distance"

payload <- ""

response <- VERB("POST", url, body = payload, content_type(""))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/assets/correlation/matrix/distance")

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

request = Net::HTTP::Post.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/assets/correlation/matrix/distance') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/assets/correlation/matrix/distance";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/assets/correlation/matrix/distance

http POST {{baseUrl}}/assets/correlation/matrix/distance

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/assets/correlation/matrix/distance

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/assets/correlation/matrix/distance")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "assetsCorrelationMatrixDistance": 0.8366600265340757
}

POST Correlation Matrix Effective Rank

{{baseUrl}}/assets/correlation/matrix/effective-rank

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/assets/correlation/matrix/effective-rank");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/assets/correlation/matrix/effective-rank")

require "http/client"

url = "{{baseUrl}}/assets/correlation/matrix/effective-rank"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/assets/correlation/matrix/effective-rank"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/assets/correlation/matrix/effective-rank");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/assets/correlation/matrix/effective-rank"

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

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

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

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

}

POST /baseUrl/assets/correlation/matrix/effective-rank HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/assets/correlation/matrix/effective-rank")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/assets/correlation/matrix/effective-rank"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/assets/correlation/matrix/effective-rank")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/assets/correlation/matrix/effective-rank")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/assets/correlation/matrix/effective-rank');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/assets/correlation/matrix/effective-rank'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/assets/correlation/matrix/effective-rank';
const options = {method: 'POST'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/assets/correlation/matrix/effective-rank',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/assets/correlation/matrix/effective-rank")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/assets/correlation/matrix/effective-rank',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/assets/correlation/matrix/effective-rank'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/assets/correlation/matrix/effective-rank');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/assets/correlation/matrix/effective-rank'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/assets/correlation/matrix/effective-rank';
const options = {method: 'POST'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/assets/correlation/matrix/effective-rank"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/assets/correlation/matrix/effective-rank" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/assets/correlation/matrix/effective-rank",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/assets/correlation/matrix/effective-rank');

echo $response->getBody();

setUrl('{{baseUrl}}/assets/correlation/matrix/effective-rank');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/assets/correlation/matrix/effective-rank');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/assets/correlation/matrix/effective-rank' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/assets/correlation/matrix/effective-rank' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = ""

conn.request("POST", "/baseUrl/assets/correlation/matrix/effective-rank", payload)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/assets/correlation/matrix/effective-rank"

payload = ""

response = requests.post(url, data=payload)

print(response.json())

library(httr)

url <- "{{baseUrl}}/assets/correlation/matrix/effective-rank"

payload <- ""

response <- VERB("POST", url, body = payload, content_type(""))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/assets/correlation/matrix/effective-rank")

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

request = Net::HTTP::Post.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/assets/correlation/matrix/effective-rank') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/assets/correlation/matrix/effective-rank";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/assets/correlation/matrix/effective-rank

http POST {{baseUrl}}/assets/correlation/matrix/effective-rank

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/assets/correlation/matrix/effective-rank

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/assets/correlation/matrix/effective-rank")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "assetsCorrelationMatrixEffectiveRank": 2
}

POST Correlation Matrix Informativeness

{{baseUrl}}/assets/correlation/matrix/informativeness

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/assets/correlation/matrix/informativeness");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/assets/correlation/matrix/informativeness")

require "http/client"

url = "{{baseUrl}}/assets/correlation/matrix/informativeness"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/assets/correlation/matrix/informativeness"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/assets/correlation/matrix/informativeness");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/assets/correlation/matrix/informativeness"

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

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

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

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

}

POST /baseUrl/assets/correlation/matrix/informativeness HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/assets/correlation/matrix/informativeness")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/assets/correlation/matrix/informativeness"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/assets/correlation/matrix/informativeness")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/assets/correlation/matrix/informativeness")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/assets/correlation/matrix/informativeness');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/assets/correlation/matrix/informativeness'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/assets/correlation/matrix/informativeness';
const options = {method: 'POST'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/assets/correlation/matrix/informativeness',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/assets/correlation/matrix/informativeness")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/assets/correlation/matrix/informativeness',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/assets/correlation/matrix/informativeness'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/assets/correlation/matrix/informativeness');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/assets/correlation/matrix/informativeness'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/assets/correlation/matrix/informativeness';
const options = {method: 'POST'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/assets/correlation/matrix/informativeness"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/assets/correlation/matrix/informativeness" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/assets/correlation/matrix/informativeness",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/assets/correlation/matrix/informativeness');

echo $response->getBody();

setUrl('{{baseUrl}}/assets/correlation/matrix/informativeness');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/assets/correlation/matrix/informativeness');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/assets/correlation/matrix/informativeness' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/assets/correlation/matrix/informativeness' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = ""

conn.request("POST", "/baseUrl/assets/correlation/matrix/informativeness", payload)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/assets/correlation/matrix/informativeness"

payload = ""

response = requests.post(url, data=payload)

print(response.json())

library(httr)

url <- "{{baseUrl}}/assets/correlation/matrix/informativeness"

payload <- ""

response <- VERB("POST", url, body = payload, content_type(""))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/assets/correlation/matrix/informativeness")

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

request = Net::HTTP::Post.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/assets/correlation/matrix/informativeness') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/assets/correlation/matrix/informativeness";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/assets/correlation/matrix/informativeness

http POST {{baseUrl}}/assets/correlation/matrix/informativeness

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/assets/correlation/matrix/informativeness

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/assets/correlation/matrix/informativeness")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "assetsCorrelationMatrixInformativeness": 0.020539611658192996
}

POST Correlation Matrix Shrinkage

{{baseUrl}}/assets/correlation/matrix/shrinkage

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/assets/correlation/matrix/shrinkage");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/assets/correlation/matrix/shrinkage")

require "http/client"

url = "{{baseUrl}}/assets/correlation/matrix/shrinkage"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/assets/correlation/matrix/shrinkage"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/assets/correlation/matrix/shrinkage");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/assets/correlation/matrix/shrinkage"

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

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

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

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

}

POST /baseUrl/assets/correlation/matrix/shrinkage HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/assets/correlation/matrix/shrinkage")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/assets/correlation/matrix/shrinkage"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/assets/correlation/matrix/shrinkage")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/assets/correlation/matrix/shrinkage")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/assets/correlation/matrix/shrinkage');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/assets/correlation/matrix/shrinkage'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/assets/correlation/matrix/shrinkage';
const options = {method: 'POST'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/assets/correlation/matrix/shrinkage',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/assets/correlation/matrix/shrinkage")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/assets/correlation/matrix/shrinkage',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/assets/correlation/matrix/shrinkage'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/assets/correlation/matrix/shrinkage');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/assets/correlation/matrix/shrinkage'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/assets/correlation/matrix/shrinkage';
const options = {method: 'POST'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/assets/correlation/matrix/shrinkage"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/assets/correlation/matrix/shrinkage" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/assets/correlation/matrix/shrinkage",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/assets/correlation/matrix/shrinkage');

echo $response->getBody();

setUrl('{{baseUrl}}/assets/correlation/matrix/shrinkage');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/assets/correlation/matrix/shrinkage');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/assets/correlation/matrix/shrinkage' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/assets/correlation/matrix/shrinkage' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = ""

conn.request("POST", "/baseUrl/assets/correlation/matrix/shrinkage", payload)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/assets/correlation/matrix/shrinkage"

payload = ""

response = requests.post(url, data=payload)

print(response.json())

library(httr)

url <- "{{baseUrl}}/assets/correlation/matrix/shrinkage"

payload <- ""

response <- VERB("POST", url, body = payload, content_type(""))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/assets/correlation/matrix/shrinkage")

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

request = Net::HTTP::Post.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/assets/correlation/matrix/shrinkage') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/assets/correlation/matrix/shrinkage";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/assets/correlation/matrix/shrinkage

http POST {{baseUrl}}/assets/correlation/matrix/shrinkage

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/assets/correlation/matrix/shrinkage

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/assets/correlation/matrix/shrinkage")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "assetsCorrelationMatrix": [
    [
      1,
      0.75,
      0.95
    ],
    [
      0.75,
      1,
      0.85
    ],
    [
      0.95,
      0.85,
      1
    ]
  ]
}

POST Correlation Matrix Validation

{{baseUrl}}/assets/correlation/matrix/validation

BODY json

{
  "assets": 0,
  "assetsCorrelationMatrix": []
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/assets/correlation/matrix/validation");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"assets\": 0,\n  \"assetsCorrelationMatrix\": []\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/assets/correlation/matrix/validation" {:content-type :json
                                                                                 :form-params {:assets 0
                                                                                               :assetsCorrelationMatrix []}})

require "http/client"

url = "{{baseUrl}}/assets/correlation/matrix/validation"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"assets\": 0,\n  \"assetsCorrelationMatrix\": []\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/assets/correlation/matrix/validation"),
    Content = new StringContent("{\n  \"assets\": 0,\n  \"assetsCorrelationMatrix\": []\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/assets/correlation/matrix/validation");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"assets\": 0,\n  \"assetsCorrelationMatrix\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/assets/correlation/matrix/validation"

	payload := strings.NewReader("{\n  \"assets\": 0,\n  \"assetsCorrelationMatrix\": []\n}")

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

	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/assets/correlation/matrix/validation HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 50

{
  "assets": 0,
  "assetsCorrelationMatrix": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/assets/correlation/matrix/validation")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"assets\": 0,\n  \"assetsCorrelationMatrix\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/assets/correlation/matrix/validation"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"assets\": 0,\n  \"assetsCorrelationMatrix\": []\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"assets\": 0,\n  \"assetsCorrelationMatrix\": []\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/assets/correlation/matrix/validation")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/assets/correlation/matrix/validation")
  .header("content-type", "application/json")
  .body("{\n  \"assets\": 0,\n  \"assetsCorrelationMatrix\": []\n}")
  .asString();

const data = JSON.stringify({
  assets: 0,
  assetsCorrelationMatrix: []
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/assets/correlation/matrix/validation');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/assets/correlation/matrix/validation',
  headers: {'content-type': 'application/json'},
  data: {assets: 0, assetsCorrelationMatrix: []}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/assets/correlation/matrix/validation';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":0,"assetsCorrelationMatrix":[]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/assets/correlation/matrix/validation',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "assets": 0,\n  "assetsCorrelationMatrix": []\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"assets\": 0,\n  \"assetsCorrelationMatrix\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/assets/correlation/matrix/validation")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/assets/correlation/matrix/validation',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({assets: 0, assetsCorrelationMatrix: []}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/assets/correlation/matrix/validation',
  headers: {'content-type': 'application/json'},
  body: {assets: 0, assetsCorrelationMatrix: []},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/assets/correlation/matrix/validation');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  assets: 0,
  assetsCorrelationMatrix: []
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/assets/correlation/matrix/validation',
  headers: {'content-type': 'application/json'},
  data: {assets: 0, assetsCorrelationMatrix: []}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/assets/correlation/matrix/validation';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":0,"assetsCorrelationMatrix":[]}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"assets": @0,
                              @"assetsCorrelationMatrix": @[  ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/assets/correlation/matrix/validation"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/assets/correlation/matrix/validation" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"assets\": 0,\n  \"assetsCorrelationMatrix\": []\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/assets/correlation/matrix/validation",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'assets' => 0,
    'assetsCorrelationMatrix' => [
        
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/assets/correlation/matrix/validation', [
  'body' => '{
  "assets": 0,
  "assetsCorrelationMatrix": []
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/assets/correlation/matrix/validation');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'assets' => 0,
  'assetsCorrelationMatrix' => [
    
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'assets' => 0,
  'assetsCorrelationMatrix' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/assets/correlation/matrix/validation');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/assets/correlation/matrix/validation' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": 0,
  "assetsCorrelationMatrix": []
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/assets/correlation/matrix/validation' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": 0,
  "assetsCorrelationMatrix": []
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"assets\": 0,\n  \"assetsCorrelationMatrix\": []\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/assets/correlation/matrix/validation", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/assets/correlation/matrix/validation"

payload = {
    "assets": 0,
    "assetsCorrelationMatrix": []
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/assets/correlation/matrix/validation"

payload <- "{\n  \"assets\": 0,\n  \"assetsCorrelationMatrix\": []\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/assets/correlation/matrix/validation")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"assets\": 0,\n  \"assetsCorrelationMatrix\": []\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/assets/correlation/matrix/validation') do |req|
  req.body = "{\n  \"assets\": 0,\n  \"assetsCorrelationMatrix\": []\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/assets/correlation/matrix/validation";

    let payload = json!({
        "assets": 0,
        "assetsCorrelationMatrix": ()
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/assets/correlation/matrix/validation \
  --header 'content-type: application/json' \
  --data '{
  "assets": 0,
  "assetsCorrelationMatrix": []
}'

echo '{
  "assets": 0,
  "assetsCorrelationMatrix": []
}' |  \
  http POST {{baseUrl}}/assets/correlation/matrix/validation \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "assets": 0,\n  "assetsCorrelationMatrix": []\n}' \
  --output-document \
  - {{baseUrl}}/assets/correlation/matrix/validation

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "assets": 0,
  "assetsCorrelationMatrix": []
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/assets/correlation/matrix/validation")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "message": "valid correlation matrix"
}

POST Correlation Matrix

{{baseUrl}}/assets/correlation/matrix

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/assets/correlation/matrix");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/assets/correlation/matrix")

require "http/client"

url = "{{baseUrl}}/assets/correlation/matrix"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/assets/correlation/matrix"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/assets/correlation/matrix");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/assets/correlation/matrix"

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

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

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

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

}

POST /baseUrl/assets/correlation/matrix HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/assets/correlation/matrix")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/assets/correlation/matrix"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/assets/correlation/matrix")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/assets/correlation/matrix")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/assets/correlation/matrix');

xhr.send(data);

import axios from 'axios';

const options = {method: 'POST', url: '{{baseUrl}}/assets/correlation/matrix'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/assets/correlation/matrix';
const options = {method: 'POST'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/assets/correlation/matrix',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/assets/correlation/matrix")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/assets/correlation/matrix',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'POST', url: '{{baseUrl}}/assets/correlation/matrix'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/assets/correlation/matrix');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'POST', url: '{{baseUrl}}/assets/correlation/matrix'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/assets/correlation/matrix';
const options = {method: 'POST'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/assets/correlation/matrix"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/assets/correlation/matrix" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/assets/correlation/matrix",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/assets/correlation/matrix');

echo $response->getBody();

setUrl('{{baseUrl}}/assets/correlation/matrix');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/assets/correlation/matrix');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/assets/correlation/matrix' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/assets/correlation/matrix' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = ""

conn.request("POST", "/baseUrl/assets/correlation/matrix", payload)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/assets/correlation/matrix"

payload = ""

response = requests.post(url, data=payload)

print(response.json())

library(httr)

url <- "{{baseUrl}}/assets/correlation/matrix"

payload <- ""

response <- VERB("POST", url, body = payload, content_type(""))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/assets/correlation/matrix")

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

request = Net::HTTP::Post.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/assets/correlation/matrix') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/assets/correlation/matrix";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/assets/correlation/matrix

http POST {{baseUrl}}/assets/correlation/matrix

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/assets/correlation/matrix

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/assets/correlation/matrix")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "assetsCorrelationMatrix": [
    [
      1,
      0.5
    ],
    [
      0.5,
      1
    ]
  ]
}

POST Denoised Correlation Matrix

{{baseUrl}}/assets/correlation/matrix/denoised

BODY json

{
  "assets": 0,
  "assetsCorrelationMatrix": [],
  "assetsCorrelationMatrixAspectRatio": "",
  "denoisingMethod": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/assets/correlation/matrix/denoised");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"assets\": 0,\n  \"assetsCorrelationMatrix\": [],\n  \"assetsCorrelationMatrixAspectRatio\": \"\",\n  \"denoisingMethod\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/assets/correlation/matrix/denoised" {:content-type :json
                                                                               :form-params {:assets 0
                                                                                             :assetsCorrelationMatrix []
                                                                                             :assetsCorrelationMatrixAspectRatio ""
                                                                                             :denoisingMethod ""}})

require "http/client"

url = "{{baseUrl}}/assets/correlation/matrix/denoised"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"assets\": 0,\n  \"assetsCorrelationMatrix\": [],\n  \"assetsCorrelationMatrixAspectRatio\": \"\",\n  \"denoisingMethod\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/assets/correlation/matrix/denoised"),
    Content = new StringContent("{\n  \"assets\": 0,\n  \"assetsCorrelationMatrix\": [],\n  \"assetsCorrelationMatrixAspectRatio\": \"\",\n  \"denoisingMethod\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/assets/correlation/matrix/denoised");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"assets\": 0,\n  \"assetsCorrelationMatrix\": [],\n  \"assetsCorrelationMatrixAspectRatio\": \"\",\n  \"denoisingMethod\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/assets/correlation/matrix/denoised"

	payload := strings.NewReader("{\n  \"assets\": 0,\n  \"assetsCorrelationMatrix\": [],\n  \"assetsCorrelationMatrixAspectRatio\": \"\",\n  \"denoisingMethod\": \"\"\n}")

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

	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/assets/correlation/matrix/denoised HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 119

{
  "assets": 0,
  "assetsCorrelationMatrix": [],
  "assetsCorrelationMatrixAspectRatio": "",
  "denoisingMethod": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/assets/correlation/matrix/denoised")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"assets\": 0,\n  \"assetsCorrelationMatrix\": [],\n  \"assetsCorrelationMatrixAspectRatio\": \"\",\n  \"denoisingMethod\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/assets/correlation/matrix/denoised"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"assets\": 0,\n  \"assetsCorrelationMatrix\": [],\n  \"assetsCorrelationMatrixAspectRatio\": \"\",\n  \"denoisingMethod\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"assets\": 0,\n  \"assetsCorrelationMatrix\": [],\n  \"assetsCorrelationMatrixAspectRatio\": \"\",\n  \"denoisingMethod\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/assets/correlation/matrix/denoised")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/assets/correlation/matrix/denoised")
  .header("content-type", "application/json")
  .body("{\n  \"assets\": 0,\n  \"assetsCorrelationMatrix\": [],\n  \"assetsCorrelationMatrixAspectRatio\": \"\",\n  \"denoisingMethod\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  assets: 0,
  assetsCorrelationMatrix: [],
  assetsCorrelationMatrixAspectRatio: '',
  denoisingMethod: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/assets/correlation/matrix/denoised');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/assets/correlation/matrix/denoised',
  headers: {'content-type': 'application/json'},
  data: {
    assets: 0,
    assetsCorrelationMatrix: [],
    assetsCorrelationMatrixAspectRatio: '',
    denoisingMethod: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/assets/correlation/matrix/denoised';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":0,"assetsCorrelationMatrix":[],"assetsCorrelationMatrixAspectRatio":"","denoisingMethod":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/assets/correlation/matrix/denoised',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "assets": 0,\n  "assetsCorrelationMatrix": [],\n  "assetsCorrelationMatrixAspectRatio": "",\n  "denoisingMethod": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"assets\": 0,\n  \"assetsCorrelationMatrix\": [],\n  \"assetsCorrelationMatrixAspectRatio\": \"\",\n  \"denoisingMethod\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/assets/correlation/matrix/denoised")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/assets/correlation/matrix/denoised',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  assets: 0,
  assetsCorrelationMatrix: [],
  assetsCorrelationMatrixAspectRatio: '',
  denoisingMethod: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/assets/correlation/matrix/denoised',
  headers: {'content-type': 'application/json'},
  body: {
    assets: 0,
    assetsCorrelationMatrix: [],
    assetsCorrelationMatrixAspectRatio: '',
    denoisingMethod: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/assets/correlation/matrix/denoised');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  assets: 0,
  assetsCorrelationMatrix: [],
  assetsCorrelationMatrixAspectRatio: '',
  denoisingMethod: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/assets/correlation/matrix/denoised',
  headers: {'content-type': 'application/json'},
  data: {
    assets: 0,
    assetsCorrelationMatrix: [],
    assetsCorrelationMatrixAspectRatio: '',
    denoisingMethod: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/assets/correlation/matrix/denoised';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":0,"assetsCorrelationMatrix":[],"assetsCorrelationMatrixAspectRatio":"","denoisingMethod":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"assets": @0,
                              @"assetsCorrelationMatrix": @[  ],
                              @"assetsCorrelationMatrixAspectRatio": @"",
                              @"denoisingMethod": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/assets/correlation/matrix/denoised"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/assets/correlation/matrix/denoised" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"assets\": 0,\n  \"assetsCorrelationMatrix\": [],\n  \"assetsCorrelationMatrixAspectRatio\": \"\",\n  \"denoisingMethod\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/assets/correlation/matrix/denoised",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'assets' => 0,
    'assetsCorrelationMatrix' => [
        
    ],
    'assetsCorrelationMatrixAspectRatio' => '',
    'denoisingMethod' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/assets/correlation/matrix/denoised', [
  'body' => '{
  "assets": 0,
  "assetsCorrelationMatrix": [],
  "assetsCorrelationMatrixAspectRatio": "",
  "denoisingMethod": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/assets/correlation/matrix/denoised');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'assets' => 0,
  'assetsCorrelationMatrix' => [
    
  ],
  'assetsCorrelationMatrixAspectRatio' => '',
  'denoisingMethod' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'assets' => 0,
  'assetsCorrelationMatrix' => [
    
  ],
  'assetsCorrelationMatrixAspectRatio' => '',
  'denoisingMethod' => ''
]));
$request->setRequestUrl('{{baseUrl}}/assets/correlation/matrix/denoised');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/assets/correlation/matrix/denoised' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": 0,
  "assetsCorrelationMatrix": [],
  "assetsCorrelationMatrixAspectRatio": "",
  "denoisingMethod": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/assets/correlation/matrix/denoised' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": 0,
  "assetsCorrelationMatrix": [],
  "assetsCorrelationMatrixAspectRatio": "",
  "denoisingMethod": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"assets\": 0,\n  \"assetsCorrelationMatrix\": [],\n  \"assetsCorrelationMatrixAspectRatio\": \"\",\n  \"denoisingMethod\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/assets/correlation/matrix/denoised", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/assets/correlation/matrix/denoised"

payload = {
    "assets": 0,
    "assetsCorrelationMatrix": [],
    "assetsCorrelationMatrixAspectRatio": "",
    "denoisingMethod": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/assets/correlation/matrix/denoised"

payload <- "{\n  \"assets\": 0,\n  \"assetsCorrelationMatrix\": [],\n  \"assetsCorrelationMatrixAspectRatio\": \"\",\n  \"denoisingMethod\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/assets/correlation/matrix/denoised")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"assets\": 0,\n  \"assetsCorrelationMatrix\": [],\n  \"assetsCorrelationMatrixAspectRatio\": \"\",\n  \"denoisingMethod\": \"\"\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/assets/correlation/matrix/denoised') do |req|
  req.body = "{\n  \"assets\": 0,\n  \"assetsCorrelationMatrix\": [],\n  \"assetsCorrelationMatrixAspectRatio\": \"\",\n  \"denoisingMethod\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/assets/correlation/matrix/denoised";

    let payload = json!({
        "assets": 0,
        "assetsCorrelationMatrix": (),
        "assetsCorrelationMatrixAspectRatio": "",
        "denoisingMethod": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/assets/correlation/matrix/denoised \
  --header 'content-type: application/json' \
  --data '{
  "assets": 0,
  "assetsCorrelationMatrix": [],
  "assetsCorrelationMatrixAspectRatio": "",
  "denoisingMethod": ""
}'

echo '{
  "assets": 0,
  "assetsCorrelationMatrix": [],
  "assetsCorrelationMatrixAspectRatio": "",
  "denoisingMethod": ""
}' |  \
  http POST {{baseUrl}}/assets/correlation/matrix/denoised \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "assets": 0,\n  "assetsCorrelationMatrix": [],\n  "assetsCorrelationMatrixAspectRatio": "",\n  "denoisingMethod": ""\n}' \
  --output-document \
  - {{baseUrl}}/assets/correlation/matrix/denoised

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "assets": 0,
  "assetsCorrelationMatrix": [],
  "assetsCorrelationMatrixAspectRatio": "",
  "denoisingMethod": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/assets/correlation/matrix/denoised")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "assetsCorrelationMatrix": [
    [
      1,
      0.6838346015086407,
      0.7246659534718176
    ],
    [
      0.6838346015086407,
      1,
      0.6978824315038066
    ],
    [
      0.7246659534718176,
      0.6978824315038066,
      1
    ]
  ]
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "assetsCorrelationMatrix": null
}

POST Nearest Correlation Matrix

{{baseUrl}}/assets/correlation/matrix/nearest

BODY json

{
  "assets": 0,
  "assetsApproximateCorrelationMatrix": [],
  "assetsFixedCorrelations": []
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/assets/correlation/matrix/nearest");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"assets\": 0,\n  \"assetsApproximateCorrelationMatrix\": [],\n  \"assetsFixedCorrelations\": []\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/assets/correlation/matrix/nearest" {:content-type :json
                                                                              :form-params {:assets 0
                                                                                            :assetsApproximateCorrelationMatrix []
                                                                                            :assetsFixedCorrelations []}})

require "http/client"

url = "{{baseUrl}}/assets/correlation/matrix/nearest"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"assets\": 0,\n  \"assetsApproximateCorrelationMatrix\": [],\n  \"assetsFixedCorrelations\": []\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/assets/correlation/matrix/nearest"),
    Content = new StringContent("{\n  \"assets\": 0,\n  \"assetsApproximateCorrelationMatrix\": [],\n  \"assetsFixedCorrelations\": []\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/assets/correlation/matrix/nearest");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"assets\": 0,\n  \"assetsApproximateCorrelationMatrix\": [],\n  \"assetsFixedCorrelations\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/assets/correlation/matrix/nearest"

	payload := strings.NewReader("{\n  \"assets\": 0,\n  \"assetsApproximateCorrelationMatrix\": [],\n  \"assetsFixedCorrelations\": []\n}")

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

	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/assets/correlation/matrix/nearest HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 94

{
  "assets": 0,
  "assetsApproximateCorrelationMatrix": [],
  "assetsFixedCorrelations": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/assets/correlation/matrix/nearest")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"assets\": 0,\n  \"assetsApproximateCorrelationMatrix\": [],\n  \"assetsFixedCorrelations\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/assets/correlation/matrix/nearest"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"assets\": 0,\n  \"assetsApproximateCorrelationMatrix\": [],\n  \"assetsFixedCorrelations\": []\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"assets\": 0,\n  \"assetsApproximateCorrelationMatrix\": [],\n  \"assetsFixedCorrelations\": []\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/assets/correlation/matrix/nearest")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/assets/correlation/matrix/nearest")
  .header("content-type", "application/json")
  .body("{\n  \"assets\": 0,\n  \"assetsApproximateCorrelationMatrix\": [],\n  \"assetsFixedCorrelations\": []\n}")
  .asString();

const data = JSON.stringify({
  assets: 0,
  assetsApproximateCorrelationMatrix: [],
  assetsFixedCorrelations: []
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/assets/correlation/matrix/nearest');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/assets/correlation/matrix/nearest',
  headers: {'content-type': 'application/json'},
  data: {assets: 0, assetsApproximateCorrelationMatrix: [], assetsFixedCorrelations: []}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/assets/correlation/matrix/nearest';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":0,"assetsApproximateCorrelationMatrix":[],"assetsFixedCorrelations":[]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/assets/correlation/matrix/nearest',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "assets": 0,\n  "assetsApproximateCorrelationMatrix": [],\n  "assetsFixedCorrelations": []\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"assets\": 0,\n  \"assetsApproximateCorrelationMatrix\": [],\n  \"assetsFixedCorrelations\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/assets/correlation/matrix/nearest")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/assets/correlation/matrix/nearest',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({assets: 0, assetsApproximateCorrelationMatrix: [], assetsFixedCorrelations: []}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/assets/correlation/matrix/nearest',
  headers: {'content-type': 'application/json'},
  body: {assets: 0, assetsApproximateCorrelationMatrix: [], assetsFixedCorrelations: []},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/assets/correlation/matrix/nearest');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  assets: 0,
  assetsApproximateCorrelationMatrix: [],
  assetsFixedCorrelations: []
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/assets/correlation/matrix/nearest',
  headers: {'content-type': 'application/json'},
  data: {assets: 0, assetsApproximateCorrelationMatrix: [], assetsFixedCorrelations: []}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/assets/correlation/matrix/nearest';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":0,"assetsApproximateCorrelationMatrix":[],"assetsFixedCorrelations":[]}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"assets": @0,
                              @"assetsApproximateCorrelationMatrix": @[  ],
                              @"assetsFixedCorrelations": @[  ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/assets/correlation/matrix/nearest"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/assets/correlation/matrix/nearest" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"assets\": 0,\n  \"assetsApproximateCorrelationMatrix\": [],\n  \"assetsFixedCorrelations\": []\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/assets/correlation/matrix/nearest",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'assets' => 0,
    'assetsApproximateCorrelationMatrix' => [
        
    ],
    'assetsFixedCorrelations' => [
        
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/assets/correlation/matrix/nearest', [
  'body' => '{
  "assets": 0,
  "assetsApproximateCorrelationMatrix": [],
  "assetsFixedCorrelations": []
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/assets/correlation/matrix/nearest');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'assets' => 0,
  'assetsApproximateCorrelationMatrix' => [
    
  ],
  'assetsFixedCorrelations' => [
    
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'assets' => 0,
  'assetsApproximateCorrelationMatrix' => [
    
  ],
  'assetsFixedCorrelations' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/assets/correlation/matrix/nearest');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/assets/correlation/matrix/nearest' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": 0,
  "assetsApproximateCorrelationMatrix": [],
  "assetsFixedCorrelations": []
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/assets/correlation/matrix/nearest' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": 0,
  "assetsApproximateCorrelationMatrix": [],
  "assetsFixedCorrelations": []
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"assets\": 0,\n  \"assetsApproximateCorrelationMatrix\": [],\n  \"assetsFixedCorrelations\": []\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/assets/correlation/matrix/nearest", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/assets/correlation/matrix/nearest"

payload = {
    "assets": 0,
    "assetsApproximateCorrelationMatrix": [],
    "assetsFixedCorrelations": []
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/assets/correlation/matrix/nearest"

payload <- "{\n  \"assets\": 0,\n  \"assetsApproximateCorrelationMatrix\": [],\n  \"assetsFixedCorrelations\": []\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/assets/correlation/matrix/nearest")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"assets\": 0,\n  \"assetsApproximateCorrelationMatrix\": [],\n  \"assetsFixedCorrelations\": []\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/assets/correlation/matrix/nearest') do |req|
  req.body = "{\n  \"assets\": 0,\n  \"assetsApproximateCorrelationMatrix\": [],\n  \"assetsFixedCorrelations\": []\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/assets/correlation/matrix/nearest";

    let payload = json!({
        "assets": 0,
        "assetsApproximateCorrelationMatrix": (),
        "assetsFixedCorrelations": ()
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/assets/correlation/matrix/nearest \
  --header 'content-type: application/json' \
  --data '{
  "assets": 0,
  "assetsApproximateCorrelationMatrix": [],
  "assetsFixedCorrelations": []
}'

echo '{
  "assets": 0,
  "assetsApproximateCorrelationMatrix": [],
  "assetsFixedCorrelations": []
}' |  \
  http POST {{baseUrl}}/assets/correlation/matrix/nearest \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "assets": 0,\n  "assetsApproximateCorrelationMatrix": [],\n  "assetsFixedCorrelations": []\n}' \
  --output-document \
  - {{baseUrl}}/assets/correlation/matrix/nearest

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "assets": 0,
  "assetsApproximateCorrelationMatrix": [],
  "assetsFixedCorrelations": []
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/assets/correlation/matrix/nearest")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "assetsCorrelationMatrix": [
    [
      1,
      0.7606306078350177,
      0.15733356650676536
    ],
    [
      0.7606306078350177,
      1,
      0.7606306078350177
    ],
    [
      0.15733356650676536,
      0.7606306078350177,
      1
    ]
  ]
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "assetsCorrelationMatrix": [
    [
      1,
      0.4314569968899409,
      0.7974943959465133
    ],
    [
      0.4314569968899409,
      1,
      -0.2
    ],
    [
      0.7974943959465133,
      -0.2,
      1
    ]
  ]
}

POST Random Correlation Matrix

{{baseUrl}}/assets/correlation/matrix/random

BODY json

{
  "assets": 0
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/assets/correlation/matrix/random");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"assets\": 0\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/assets/correlation/matrix/random" {:content-type :json
                                                                             :form-params {:assets 0}})

require "http/client"

url = "{{baseUrl}}/assets/correlation/matrix/random"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"assets\": 0\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/assets/correlation/matrix/random"),
    Content = new StringContent("{\n  \"assets\": 0\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/assets/correlation/matrix/random");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"assets\": 0\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/assets/correlation/matrix/random"

	payload := strings.NewReader("{\n  \"assets\": 0\n}")

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

	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/assets/correlation/matrix/random HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 17

{
  "assets": 0
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/assets/correlation/matrix/random")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"assets\": 0\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/assets/correlation/matrix/random"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"assets\": 0\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"assets\": 0\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/assets/correlation/matrix/random")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/assets/correlation/matrix/random")
  .header("content-type", "application/json")
  .body("{\n  \"assets\": 0\n}")
  .asString();

const data = JSON.stringify({
  assets: 0
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/assets/correlation/matrix/random');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/assets/correlation/matrix/random',
  headers: {'content-type': 'application/json'},
  data: {assets: 0}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/assets/correlation/matrix/random';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":0}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/assets/correlation/matrix/random',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "assets": 0\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"assets\": 0\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/assets/correlation/matrix/random")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/assets/correlation/matrix/random',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({assets: 0}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/assets/correlation/matrix/random',
  headers: {'content-type': 'application/json'},
  body: {assets: 0},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/assets/correlation/matrix/random');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  assets: 0
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/assets/correlation/matrix/random',
  headers: {'content-type': 'application/json'},
  data: {assets: 0}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/assets/correlation/matrix/random';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":0}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"assets": @0 };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/assets/correlation/matrix/random"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/assets/correlation/matrix/random" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"assets\": 0\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/assets/correlation/matrix/random",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'assets' => 0
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/assets/correlation/matrix/random', [
  'body' => '{
  "assets": 0
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/assets/correlation/matrix/random');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'assets' => 0
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'assets' => 0
]));
$request->setRequestUrl('{{baseUrl}}/assets/correlation/matrix/random');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/assets/correlation/matrix/random' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": 0
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/assets/correlation/matrix/random' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": 0
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"assets\": 0\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/assets/correlation/matrix/random", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/assets/correlation/matrix/random"

payload = { "assets": 0 }
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/assets/correlation/matrix/random"

payload <- "{\n  \"assets\": 0\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/assets/correlation/matrix/random")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"assets\": 0\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/assets/correlation/matrix/random') do |req|
  req.body = "{\n  \"assets\": 0\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/assets/correlation/matrix/random";

    let payload = json!({"assets": 0});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/assets/correlation/matrix/random \
  --header 'content-type: application/json' \
  --data '{
  "assets": 0
}'

echo '{
  "assets": 0
}' |  \
  http POST {{baseUrl}}/assets/correlation/matrix/random \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "assets": 0\n}' \
  --output-document \
  - {{baseUrl}}/assets/correlation/matrix/random

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["assets": 0] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/assets/correlation/matrix/random")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "assetsCorrelationMatrix": [
    [
      1,
      0.7606306078350177,
      0.15733356650676536
    ],
    [
      0.7606306078350177,
      1,
      0.7606306078350177
    ],
    [
      0.15733356650676536,
      0.7606306078350177,
      1
    ]
  ]
}

POST Theory-Implied Correlation Matrix

{{baseUrl}}/assets/correlation/matrix/theory-implied

BODY json

{
  "assets": [
    {
      "assetHierarchicalClassification": []
    }
  ],
  "assetsCorrelationMatrix": [],
  "clusteringMethod": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/assets/correlation/matrix/theory-implied");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"assets\": [\n    {\n      \"assetHierarchicalClassification\": []\n    }\n  ],\n  \"assetsCorrelationMatrix\": [],\n  \"clusteringMethod\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/assets/correlation/matrix/theory-implied" {:content-type :json
                                                                                     :form-params {:assets [{:assetHierarchicalClassification []}]
                                                                                                   :assetsCorrelationMatrix []
                                                                                                   :clusteringMethod ""}})

require "http/client"

url = "{{baseUrl}}/assets/correlation/matrix/theory-implied"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"assets\": [\n    {\n      \"assetHierarchicalClassification\": []\n    }\n  ],\n  \"assetsCorrelationMatrix\": [],\n  \"clusteringMethod\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/assets/correlation/matrix/theory-implied"),
    Content = new StringContent("{\n  \"assets\": [\n    {\n      \"assetHierarchicalClassification\": []\n    }\n  ],\n  \"assetsCorrelationMatrix\": [],\n  \"clusteringMethod\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/assets/correlation/matrix/theory-implied");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"assets\": [\n    {\n      \"assetHierarchicalClassification\": []\n    }\n  ],\n  \"assetsCorrelationMatrix\": [],\n  \"clusteringMethod\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/assets/correlation/matrix/theory-implied"

	payload := strings.NewReader("{\n  \"assets\": [\n    {\n      \"assetHierarchicalClassification\": []\n    }\n  ],\n  \"assetsCorrelationMatrix\": [],\n  \"clusteringMethod\": \"\"\n}")

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

	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/assets/correlation/matrix/theory-implied HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 136

{
  "assets": [
    {
      "assetHierarchicalClassification": []
    }
  ],
  "assetsCorrelationMatrix": [],
  "clusteringMethod": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/assets/correlation/matrix/theory-implied")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"assets\": [\n    {\n      \"assetHierarchicalClassification\": []\n    }\n  ],\n  \"assetsCorrelationMatrix\": [],\n  \"clusteringMethod\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/assets/correlation/matrix/theory-implied"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"assets\": [\n    {\n      \"assetHierarchicalClassification\": []\n    }\n  ],\n  \"assetsCorrelationMatrix\": [],\n  \"clusteringMethod\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"assets\": [\n    {\n      \"assetHierarchicalClassification\": []\n    }\n  ],\n  \"assetsCorrelationMatrix\": [],\n  \"clusteringMethod\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/assets/correlation/matrix/theory-implied")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/assets/correlation/matrix/theory-implied")
  .header("content-type", "application/json")
  .body("{\n  \"assets\": [\n    {\n      \"assetHierarchicalClassification\": []\n    }\n  ],\n  \"assetsCorrelationMatrix\": [],\n  \"clusteringMethod\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  assets: [
    {
      assetHierarchicalClassification: []
    }
  ],
  assetsCorrelationMatrix: [],
  clusteringMethod: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/assets/correlation/matrix/theory-implied');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/assets/correlation/matrix/theory-implied',
  headers: {'content-type': 'application/json'},
  data: {
    assets: [{assetHierarchicalClassification: []}],
    assetsCorrelationMatrix: [],
    clusteringMethod: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/assets/correlation/matrix/theory-implied';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":[{"assetHierarchicalClassification":[]}],"assetsCorrelationMatrix":[],"clusteringMethod":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/assets/correlation/matrix/theory-implied',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "assets": [\n    {\n      "assetHierarchicalClassification": []\n    }\n  ],\n  "assetsCorrelationMatrix": [],\n  "clusteringMethod": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"assets\": [\n    {\n      \"assetHierarchicalClassification\": []\n    }\n  ],\n  \"assetsCorrelationMatrix\": [],\n  \"clusteringMethod\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/assets/correlation/matrix/theory-implied")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/assets/correlation/matrix/theory-implied',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  assets: [{assetHierarchicalClassification: []}],
  assetsCorrelationMatrix: [],
  clusteringMethod: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/assets/correlation/matrix/theory-implied',
  headers: {'content-type': 'application/json'},
  body: {
    assets: [{assetHierarchicalClassification: []}],
    assetsCorrelationMatrix: [],
    clusteringMethod: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/assets/correlation/matrix/theory-implied');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  assets: [
    {
      assetHierarchicalClassification: []
    }
  ],
  assetsCorrelationMatrix: [],
  clusteringMethod: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/assets/correlation/matrix/theory-implied',
  headers: {'content-type': 'application/json'},
  data: {
    assets: [{assetHierarchicalClassification: []}],
    assetsCorrelationMatrix: [],
    clusteringMethod: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/assets/correlation/matrix/theory-implied';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":[{"assetHierarchicalClassification":[]}],"assetsCorrelationMatrix":[],"clusteringMethod":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"assets": @[ @{ @"assetHierarchicalClassification": @[  ] } ],
                              @"assetsCorrelationMatrix": @[  ],
                              @"clusteringMethod": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/assets/correlation/matrix/theory-implied"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/assets/correlation/matrix/theory-implied" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"assets\": [\n    {\n      \"assetHierarchicalClassification\": []\n    }\n  ],\n  \"assetsCorrelationMatrix\": [],\n  \"clusteringMethod\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/assets/correlation/matrix/theory-implied",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'assets' => [
        [
                'assetHierarchicalClassification' => [
                                
                ]
        ]
    ],
    'assetsCorrelationMatrix' => [
        
    ],
    'clusteringMethod' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/assets/correlation/matrix/theory-implied', [
  'body' => '{
  "assets": [
    {
      "assetHierarchicalClassification": []
    }
  ],
  "assetsCorrelationMatrix": [],
  "clusteringMethod": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/assets/correlation/matrix/theory-implied');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'assets' => [
    [
        'assetHierarchicalClassification' => [
                
        ]
    ]
  ],
  'assetsCorrelationMatrix' => [
    
  ],
  'clusteringMethod' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'assets' => [
    [
        'assetHierarchicalClassification' => [
                
        ]
    ]
  ],
  'assetsCorrelationMatrix' => [
    
  ],
  'clusteringMethod' => ''
]));
$request->setRequestUrl('{{baseUrl}}/assets/correlation/matrix/theory-implied');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/assets/correlation/matrix/theory-implied' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": [
    {
      "assetHierarchicalClassification": []
    }
  ],
  "assetsCorrelationMatrix": [],
  "clusteringMethod": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/assets/correlation/matrix/theory-implied' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": [
    {
      "assetHierarchicalClassification": []
    }
  ],
  "assetsCorrelationMatrix": [],
  "clusteringMethod": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"assets\": [\n    {\n      \"assetHierarchicalClassification\": []\n    }\n  ],\n  \"assetsCorrelationMatrix\": [],\n  \"clusteringMethod\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/assets/correlation/matrix/theory-implied", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/assets/correlation/matrix/theory-implied"

payload = {
    "assets": [{ "assetHierarchicalClassification": [] }],
    "assetsCorrelationMatrix": [],
    "clusteringMethod": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/assets/correlation/matrix/theory-implied"

payload <- "{\n  \"assets\": [\n    {\n      \"assetHierarchicalClassification\": []\n    }\n  ],\n  \"assetsCorrelationMatrix\": [],\n  \"clusteringMethod\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/assets/correlation/matrix/theory-implied")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"assets\": [\n    {\n      \"assetHierarchicalClassification\": []\n    }\n  ],\n  \"assetsCorrelationMatrix\": [],\n  \"clusteringMethod\": \"\"\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/assets/correlation/matrix/theory-implied') do |req|
  req.body = "{\n  \"assets\": [\n    {\n      \"assetHierarchicalClassification\": []\n    }\n  ],\n  \"assetsCorrelationMatrix\": [],\n  \"clusteringMethod\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/assets/correlation/matrix/theory-implied";

    let payload = json!({
        "assets": (json!({"assetHierarchicalClassification": ()})),
        "assetsCorrelationMatrix": (),
        "clusteringMethod": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/assets/correlation/matrix/theory-implied \
  --header 'content-type: application/json' \
  --data '{
  "assets": [
    {
      "assetHierarchicalClassification": []
    }
  ],
  "assetsCorrelationMatrix": [],
  "clusteringMethod": ""
}'

echo '{
  "assets": [
    {
      "assetHierarchicalClassification": []
    }
  ],
  "assetsCorrelationMatrix": [],
  "clusteringMethod": ""
}' |  \
  http POST {{baseUrl}}/assets/correlation/matrix/theory-implied \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "assets": [\n    {\n      "assetHierarchicalClassification": []\n    }\n  ],\n  "assetsCorrelationMatrix": [],\n  "clusteringMethod": ""\n}' \
  --output-document \
  - {{baseUrl}}/assets/correlation/matrix/theory-implied

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "assets": [["assetHierarchicalClassification": []]],
  "assetsCorrelationMatrix": [],
  "clusteringMethod": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/assets/correlation/matrix/theory-implied")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "assetsCorrelationMatrix": [
    [
      1,
      -0.00034999999999985043
    ],
    [
      -0.00034999999999985043,
      1
    ]
  ]
}

POST Covariance Matrix Effective Rank

{{baseUrl}}/assets/covariance/matrix/effective-rank

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/assets/covariance/matrix/effective-rank");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/assets/covariance/matrix/effective-rank")

require "http/client"

url = "{{baseUrl}}/assets/covariance/matrix/effective-rank"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/assets/covariance/matrix/effective-rank"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/assets/covariance/matrix/effective-rank");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/assets/covariance/matrix/effective-rank"

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

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

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

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

}

POST /baseUrl/assets/covariance/matrix/effective-rank HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/assets/covariance/matrix/effective-rank")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/assets/covariance/matrix/effective-rank"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/assets/covariance/matrix/effective-rank")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/assets/covariance/matrix/effective-rank")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/assets/covariance/matrix/effective-rank');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/assets/covariance/matrix/effective-rank'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/assets/covariance/matrix/effective-rank';
const options = {method: 'POST'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/assets/covariance/matrix/effective-rank',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/assets/covariance/matrix/effective-rank")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/assets/covariance/matrix/effective-rank',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/assets/covariance/matrix/effective-rank'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/assets/covariance/matrix/effective-rank');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/assets/covariance/matrix/effective-rank'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/assets/covariance/matrix/effective-rank';
const options = {method: 'POST'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/assets/covariance/matrix/effective-rank"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/assets/covariance/matrix/effective-rank" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/assets/covariance/matrix/effective-rank",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/assets/covariance/matrix/effective-rank');

echo $response->getBody();

setUrl('{{baseUrl}}/assets/covariance/matrix/effective-rank');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/assets/covariance/matrix/effective-rank');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/assets/covariance/matrix/effective-rank' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/assets/covariance/matrix/effective-rank' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = ""

conn.request("POST", "/baseUrl/assets/covariance/matrix/effective-rank", payload)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/assets/covariance/matrix/effective-rank"

payload = ""

response = requests.post(url, data=payload)

print(response.json())

library(httr)

url <- "{{baseUrl}}/assets/covariance/matrix/effective-rank"

payload <- ""

response <- VERB("POST", url, body = payload, content_type(""))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/assets/covariance/matrix/effective-rank")

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

request = Net::HTTP::Post.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/assets/covariance/matrix/effective-rank') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/assets/covariance/matrix/effective-rank";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/assets/covariance/matrix/effective-rank

http POST {{baseUrl}}/assets/covariance/matrix/effective-rank

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/assets/covariance/matrix/effective-rank

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/assets/covariance/matrix/effective-rank")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "assetsCovarianceMatrixEffectiveRank": 1
}

POST Covariance Matrix Validation

{{baseUrl}}/assets/covariance/matrix/validation

BODY json

{
  "assets": 0,
  "assetsCovarianceMatrix": []
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/assets/covariance/matrix/validation");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": []\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/assets/covariance/matrix/validation" {:content-type :json
                                                                                :form-params {:assets 0
                                                                                              :assetsCovarianceMatrix []}})

require "http/client"

url = "{{baseUrl}}/assets/covariance/matrix/validation"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": []\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/assets/covariance/matrix/validation"),
    Content = new StringContent("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": []\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/assets/covariance/matrix/validation");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/assets/covariance/matrix/validation"

	payload := strings.NewReader("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": []\n}")

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

	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/assets/covariance/matrix/validation HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 49

{
  "assets": 0,
  "assetsCovarianceMatrix": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/assets/covariance/matrix/validation")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/assets/covariance/matrix/validation"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": []\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": []\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/assets/covariance/matrix/validation")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/assets/covariance/matrix/validation")
  .header("content-type", "application/json")
  .body("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": []\n}")
  .asString();

const data = JSON.stringify({
  assets: 0,
  assetsCovarianceMatrix: []
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/assets/covariance/matrix/validation');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/assets/covariance/matrix/validation',
  headers: {'content-type': 'application/json'},
  data: {assets: 0, assetsCovarianceMatrix: []}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/assets/covariance/matrix/validation';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":0,"assetsCovarianceMatrix":[]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/assets/covariance/matrix/validation',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "assets": 0,\n  "assetsCovarianceMatrix": []\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/assets/covariance/matrix/validation")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/assets/covariance/matrix/validation',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({assets: 0, assetsCovarianceMatrix: []}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/assets/covariance/matrix/validation',
  headers: {'content-type': 'application/json'},
  body: {assets: 0, assetsCovarianceMatrix: []},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/assets/covariance/matrix/validation');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  assets: 0,
  assetsCovarianceMatrix: []
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/assets/covariance/matrix/validation',
  headers: {'content-type': 'application/json'},
  data: {assets: 0, assetsCovarianceMatrix: []}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/assets/covariance/matrix/validation';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":0,"assetsCovarianceMatrix":[]}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"assets": @0,
                              @"assetsCovarianceMatrix": @[  ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/assets/covariance/matrix/validation"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/assets/covariance/matrix/validation" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": []\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/assets/covariance/matrix/validation",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'assets' => 0,
    'assetsCovarianceMatrix' => [
        
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/assets/covariance/matrix/validation', [
  'body' => '{
  "assets": 0,
  "assetsCovarianceMatrix": []
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/assets/covariance/matrix/validation');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'assets' => 0,
  'assetsCovarianceMatrix' => [
    
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'assets' => 0,
  'assetsCovarianceMatrix' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/assets/covariance/matrix/validation');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/assets/covariance/matrix/validation' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": 0,
  "assetsCovarianceMatrix": []
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/assets/covariance/matrix/validation' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": 0,
  "assetsCovarianceMatrix": []
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": []\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/assets/covariance/matrix/validation", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/assets/covariance/matrix/validation"

payload = {
    "assets": 0,
    "assetsCovarianceMatrix": []
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/assets/covariance/matrix/validation"

payload <- "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": []\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/assets/covariance/matrix/validation")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": []\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/assets/covariance/matrix/validation') do |req|
  req.body = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": []\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/assets/covariance/matrix/validation";

    let payload = json!({
        "assets": 0,
        "assetsCovarianceMatrix": ()
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/assets/covariance/matrix/validation \
  --header 'content-type: application/json' \
  --data '{
  "assets": 0,
  "assetsCovarianceMatrix": []
}'

echo '{
  "assets": 0,
  "assetsCovarianceMatrix": []
}' |  \
  http POST {{baseUrl}}/assets/covariance/matrix/validation \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "assets": 0,\n  "assetsCovarianceMatrix": []\n}' \
  --output-document \
  - {{baseUrl}}/assets/covariance/matrix/validation

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "assets": 0,
  "assetsCovarianceMatrix": []
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/assets/covariance/matrix/validation")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "message": "valid covariance matrix"
}

POST Covariance Matrix

{{baseUrl}}/assets/covariance/matrix

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/assets/covariance/matrix");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/assets/covariance/matrix")

require "http/client"

url = "{{baseUrl}}/assets/covariance/matrix"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/assets/covariance/matrix"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/assets/covariance/matrix");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/assets/covariance/matrix"

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

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

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

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

}

POST /baseUrl/assets/covariance/matrix HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/assets/covariance/matrix")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/assets/covariance/matrix"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/assets/covariance/matrix")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/assets/covariance/matrix")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/assets/covariance/matrix');

xhr.send(data);

import axios from 'axios';

const options = {method: 'POST', url: '{{baseUrl}}/assets/covariance/matrix'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/assets/covariance/matrix';
const options = {method: 'POST'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/assets/covariance/matrix',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/assets/covariance/matrix")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/assets/covariance/matrix',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'POST', url: '{{baseUrl}}/assets/covariance/matrix'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/assets/covariance/matrix');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'POST', url: '{{baseUrl}}/assets/covariance/matrix'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/assets/covariance/matrix';
const options = {method: 'POST'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/assets/covariance/matrix"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/assets/covariance/matrix" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/assets/covariance/matrix",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/assets/covariance/matrix');

echo $response->getBody();

setUrl('{{baseUrl}}/assets/covariance/matrix');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/assets/covariance/matrix');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/assets/covariance/matrix' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/assets/covariance/matrix' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = ""

conn.request("POST", "/baseUrl/assets/covariance/matrix", payload)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/assets/covariance/matrix"

payload = ""

response = requests.post(url, data=payload)

print(response.json())

library(httr)

url <- "{{baseUrl}}/assets/covariance/matrix"

payload <- ""

response <- VERB("POST", url, body = payload, content_type(""))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/assets/covariance/matrix")

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

request = Net::HTTP::Post.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/assets/covariance/matrix') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/assets/covariance/matrix";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/assets/covariance/matrix

http POST {{baseUrl}}/assets/covariance/matrix

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/assets/covariance/matrix

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/assets/covariance/matrix")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "assetsCovarianceMatrix": [
    [
      0.010000000000000002,
      -0.0025000000000000005
    ],
    [
      -0.0025000000000000005,
      0.0025000000000000005
    ]
  ]
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "assetsCovarianceMatrix": [
    [
      0.010000000000000002,
      -0.0025000000000000005
    ],
    [
      -0.0025000000000000005,
      0.0025000000000000005
    ]
  ]
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "assetsCovarianceMatrix": [
    [
      0.00035,
      0.00035
    ],
    [
      0.00035,
      0.00035
    ]
  ]
}

POST Exponentially Weighted Covariance Matrix

{{baseUrl}}/assets/covariance/matrix/exponentially-weighted

BODY json

{
  "assets": [
    {
      "assetReturns": []
    }
  ],
  "decayFactor": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/assets/covariance/matrix/exponentially-weighted");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ],\n  \"decayFactor\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/assets/covariance/matrix/exponentially-weighted" {:content-type :json
                                                                                            :form-params {:assets [{:assetReturns []}]
                                                                                                          :decayFactor ""}})

require "http/client"

url = "{{baseUrl}}/assets/covariance/matrix/exponentially-weighted"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ],\n  \"decayFactor\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/assets/covariance/matrix/exponentially-weighted"),
    Content = new StringContent("{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ],\n  \"decayFactor\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/assets/covariance/matrix/exponentially-weighted");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ],\n  \"decayFactor\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/assets/covariance/matrix/exponentially-weighted"

	payload := strings.NewReader("{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ],\n  \"decayFactor\": \"\"\n}")

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

	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/assets/covariance/matrix/exponentially-weighted HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 79

{
  "assets": [
    {
      "assetReturns": []
    }
  ],
  "decayFactor": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/assets/covariance/matrix/exponentially-weighted")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ],\n  \"decayFactor\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/assets/covariance/matrix/exponentially-weighted"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ],\n  \"decayFactor\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ],\n  \"decayFactor\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/assets/covariance/matrix/exponentially-weighted")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/assets/covariance/matrix/exponentially-weighted")
  .header("content-type", "application/json")
  .body("{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ],\n  \"decayFactor\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  assets: [
    {
      assetReturns: []
    }
  ],
  decayFactor: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/assets/covariance/matrix/exponentially-weighted');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/assets/covariance/matrix/exponentially-weighted',
  headers: {'content-type': 'application/json'},
  data: {assets: [{assetReturns: []}], decayFactor: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/assets/covariance/matrix/exponentially-weighted';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":[{"assetReturns":[]}],"decayFactor":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/assets/covariance/matrix/exponentially-weighted',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "assets": [\n    {\n      "assetReturns": []\n    }\n  ],\n  "decayFactor": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ],\n  \"decayFactor\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/assets/covariance/matrix/exponentially-weighted")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/assets/covariance/matrix/exponentially-weighted',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({assets: [{assetReturns: []}], decayFactor: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/assets/covariance/matrix/exponentially-weighted',
  headers: {'content-type': 'application/json'},
  body: {assets: [{assetReturns: []}], decayFactor: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/assets/covariance/matrix/exponentially-weighted');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  assets: [
    {
      assetReturns: []
    }
  ],
  decayFactor: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/assets/covariance/matrix/exponentially-weighted',
  headers: {'content-type': 'application/json'},
  data: {assets: [{assetReturns: []}], decayFactor: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/assets/covariance/matrix/exponentially-weighted';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":[{"assetReturns":[]}],"decayFactor":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"assets": @[ @{ @"assetReturns": @[  ] } ],
                              @"decayFactor": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/assets/covariance/matrix/exponentially-weighted"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/assets/covariance/matrix/exponentially-weighted" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ],\n  \"decayFactor\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/assets/covariance/matrix/exponentially-weighted",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'assets' => [
        [
                'assetReturns' => [
                                
                ]
        ]
    ],
    'decayFactor' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/assets/covariance/matrix/exponentially-weighted', [
  'body' => '{
  "assets": [
    {
      "assetReturns": []
    }
  ],
  "decayFactor": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/assets/covariance/matrix/exponentially-weighted');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'assets' => [
    [
        'assetReturns' => [
                
        ]
    ]
  ],
  'decayFactor' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'assets' => [
    [
        'assetReturns' => [
                
        ]
    ]
  ],
  'decayFactor' => ''
]));
$request->setRequestUrl('{{baseUrl}}/assets/covariance/matrix/exponentially-weighted');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/assets/covariance/matrix/exponentially-weighted' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": [
    {
      "assetReturns": []
    }
  ],
  "decayFactor": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/assets/covariance/matrix/exponentially-weighted' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": [
    {
      "assetReturns": []
    }
  ],
  "decayFactor": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ],\n  \"decayFactor\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/assets/covariance/matrix/exponentially-weighted", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/assets/covariance/matrix/exponentially-weighted"

payload = {
    "assets": [{ "assetReturns": [] }],
    "decayFactor": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/assets/covariance/matrix/exponentially-weighted"

payload <- "{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ],\n  \"decayFactor\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/assets/covariance/matrix/exponentially-weighted")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ],\n  \"decayFactor\": \"\"\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/assets/covariance/matrix/exponentially-weighted') do |req|
  req.body = "{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ],\n  \"decayFactor\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/assets/covariance/matrix/exponentially-weighted";

    let payload = json!({
        "assets": (json!({"assetReturns": ()})),
        "decayFactor": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/assets/covariance/matrix/exponentially-weighted \
  --header 'content-type: application/json' \
  --data '{
  "assets": [
    {
      "assetReturns": []
    }
  ],
  "decayFactor": ""
}'

echo '{
  "assets": [
    {
      "assetReturns": []
    }
  ],
  "decayFactor": ""
}' |  \
  http POST {{baseUrl}}/assets/covariance/matrix/exponentially-weighted \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "assets": [\n    {\n      "assetReturns": []\n    }\n  ],\n  "decayFactor": ""\n}' \
  --output-document \
  - {{baseUrl}}/assets/covariance/matrix/exponentially-weighted

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "assets": [["assetReturns": []]],
  "decayFactor": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/assets/covariance/matrix/exponentially-weighted")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "assetsCovarianceMatrix": [
    [
      0.000019583333333333333,
      -0.000039166666666666665
    ],
    [
      -0.000039166666666666665,
      0.00007833333333333333
    ]
  ]
}

POST Kurtosis

{{baseUrl}}/assets/kurtosis

BODY json

{
  "assets": [
    {
      "assetReturns": []
    }
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/assets/kurtosis");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/assets/kurtosis" {:content-type :json
                                                            :form-params {:assets [{:assetReturns []}]}})

require "http/client"

url = "{{baseUrl}}/assets/kurtosis"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ]\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/assets/kurtosis"),
    Content = new StringContent("{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/assets/kurtosis");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/assets/kurtosis"

	payload := strings.NewReader("{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ]\n}")

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

	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/assets/kurtosis HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 58

{
  "assets": [
    {
      "assetReturns": []
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/assets/kurtosis")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/assets/kurtosis"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/assets/kurtosis")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/assets/kurtosis")
  .header("content-type", "application/json")
  .body("{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  assets: [
    {
      assetReturns: []
    }
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/assets/kurtosis');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/assets/kurtosis',
  headers: {'content-type': 'application/json'},
  data: {assets: [{assetReturns: []}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/assets/kurtosis';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":[{"assetReturns":[]}]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/assets/kurtosis',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "assets": [\n    {\n      "assetReturns": []\n    }\n  ]\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/assets/kurtosis")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/assets/kurtosis',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({assets: [{assetReturns: []}]}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/assets/kurtosis',
  headers: {'content-type': 'application/json'},
  body: {assets: [{assetReturns: []}]},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/assets/kurtosis');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  assets: [
    {
      assetReturns: []
    }
  ]
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/assets/kurtosis',
  headers: {'content-type': 'application/json'},
  data: {assets: [{assetReturns: []}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/assets/kurtosis';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":[{"assetReturns":[]}]}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"assets": @[ @{ @"assetReturns": @[  ] } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/assets/kurtosis"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/assets/kurtosis" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ]\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/assets/kurtosis",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'assets' => [
        [
                'assetReturns' => [
                                
                ]
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/assets/kurtosis', [
  'body' => '{
  "assets": [
    {
      "assetReturns": []
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/assets/kurtosis');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'assets' => [
    [
        'assetReturns' => [
                
        ]
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'assets' => [
    [
        'assetReturns' => [
                
        ]
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/assets/kurtosis');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/assets/kurtosis' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": [
    {
      "assetReturns": []
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/assets/kurtosis' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": [
    {
      "assetReturns": []
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/assets/kurtosis", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/assets/kurtosis"

payload = { "assets": [{ "assetReturns": [] }] }
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/assets/kurtosis"

payload <- "{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ]\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/assets/kurtosis")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ]\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/assets/kurtosis') do |req|
  req.body = "{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/assets/kurtosis";

    let payload = json!({"assets": (json!({"assetReturns": ()}))});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/assets/kurtosis \
  --header 'content-type: application/json' \
  --data '{
  "assets": [
    {
      "assetReturns": []
    }
  ]
}'

echo '{
  "assets": [
    {
      "assetReturns": []
    }
  ]
}' |  \
  http POST {{baseUrl}}/assets/kurtosis \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "assets": [\n    {\n      "assetReturns": []\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/assets/kurtosis

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["assets": [["assetReturns": []]]] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/assets/kurtosis")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "assets": [
    {
      "assetKurtosis": 2
    }
  ]
}

POST Adjusted Prices

{{baseUrl}}/assets/prices/adjusted

BODY json

{
  "assets": [
    {
      "assetDividends": [
        {
          "amount": "",
          "date": ""
        }
      ],
      "assetPrices": [
        {
          "close": "",
          "date": ""
        }
      ],
      "assetSplits": [
        {
          "date": "",
          "factor": ""
        }
      ]
    }
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/assets/prices/adjusted");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"assets\": [\n    {\n      \"assetDividends\": [\n        {\n          \"amount\": \"\",\n          \"date\": \"\"\n        }\n      ],\n      \"assetPrices\": [\n        {\n          \"close\": \"\",\n          \"date\": \"\"\n        }\n      ],\n      \"assetSplits\": [\n        {\n          \"date\": \"\",\n          \"factor\": \"\"\n        }\n      ]\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/assets/prices/adjusted" {:content-type :json
                                                                   :form-params {:assets [{:assetDividends [{:amount ""
                                                                                                             :date ""}]
                                                                                           :assetPrices [{:close ""
                                                                                                          :date ""}]
                                                                                           :assetSplits [{:date ""
                                                                                                          :factor ""}]}]}})

require "http/client"

url = "{{baseUrl}}/assets/prices/adjusted"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"assets\": [\n    {\n      \"assetDividends\": [\n        {\n          \"amount\": \"\",\n          \"date\": \"\"\n        }\n      ],\n      \"assetPrices\": [\n        {\n          \"close\": \"\",\n          \"date\": \"\"\n        }\n      ],\n      \"assetSplits\": [\n        {\n          \"date\": \"\",\n          \"factor\": \"\"\n        }\n      ]\n    }\n  ]\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/assets/prices/adjusted"),
    Content = new StringContent("{\n  \"assets\": [\n    {\n      \"assetDividends\": [\n        {\n          \"amount\": \"\",\n          \"date\": \"\"\n        }\n      ],\n      \"assetPrices\": [\n        {\n          \"close\": \"\",\n          \"date\": \"\"\n        }\n      ],\n      \"assetSplits\": [\n        {\n          \"date\": \"\",\n          \"factor\": \"\"\n        }\n      ]\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/assets/prices/adjusted");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"assets\": [\n    {\n      \"assetDividends\": [\n        {\n          \"amount\": \"\",\n          \"date\": \"\"\n        }\n      ],\n      \"assetPrices\": [\n        {\n          \"close\": \"\",\n          \"date\": \"\"\n        }\n      ],\n      \"assetSplits\": [\n        {\n          \"date\": \"\",\n          \"factor\": \"\"\n        }\n      ]\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/assets/prices/adjusted"

	payload := strings.NewReader("{\n  \"assets\": [\n    {\n      \"assetDividends\": [\n        {\n          \"amount\": \"\",\n          \"date\": \"\"\n        }\n      ],\n      \"assetPrices\": [\n        {\n          \"close\": \"\",\n          \"date\": \"\"\n        }\n      ],\n      \"assetSplits\": [\n        {\n          \"date\": \"\",\n          \"factor\": \"\"\n        }\n      ]\n    }\n  ]\n}")

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

	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/assets/prices/adjusted HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 325

{
  "assets": [
    {
      "assetDividends": [
        {
          "amount": "",
          "date": ""
        }
      ],
      "assetPrices": [
        {
          "close": "",
          "date": ""
        }
      ],
      "assetSplits": [
        {
          "date": "",
          "factor": ""
        }
      ]
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/assets/prices/adjusted")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"assets\": [\n    {\n      \"assetDividends\": [\n        {\n          \"amount\": \"\",\n          \"date\": \"\"\n        }\n      ],\n      \"assetPrices\": [\n        {\n          \"close\": \"\",\n          \"date\": \"\"\n        }\n      ],\n      \"assetSplits\": [\n        {\n          \"date\": \"\",\n          \"factor\": \"\"\n        }\n      ]\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/assets/prices/adjusted"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"assets\": [\n    {\n      \"assetDividends\": [\n        {\n          \"amount\": \"\",\n          \"date\": \"\"\n        }\n      ],\n      \"assetPrices\": [\n        {\n          \"close\": \"\",\n          \"date\": \"\"\n        }\n      ],\n      \"assetSplits\": [\n        {\n          \"date\": \"\",\n          \"factor\": \"\"\n        }\n      ]\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"assets\": [\n    {\n      \"assetDividends\": [\n        {\n          \"amount\": \"\",\n          \"date\": \"\"\n        }\n      ],\n      \"assetPrices\": [\n        {\n          \"close\": \"\",\n          \"date\": \"\"\n        }\n      ],\n      \"assetSplits\": [\n        {\n          \"date\": \"\",\n          \"factor\": \"\"\n        }\n      ]\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/assets/prices/adjusted")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/assets/prices/adjusted")
  .header("content-type", "application/json")
  .body("{\n  \"assets\": [\n    {\n      \"assetDividends\": [\n        {\n          \"amount\": \"\",\n          \"date\": \"\"\n        }\n      ],\n      \"assetPrices\": [\n        {\n          \"close\": \"\",\n          \"date\": \"\"\n        }\n      ],\n      \"assetSplits\": [\n        {\n          \"date\": \"\",\n          \"factor\": \"\"\n        }\n      ]\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  assets: [
    {
      assetDividends: [
        {
          amount: '',
          date: ''
        }
      ],
      assetPrices: [
        {
          close: '',
          date: ''
        }
      ],
      assetSplits: [
        {
          date: '',
          factor: ''
        }
      ]
    }
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/assets/prices/adjusted');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/assets/prices/adjusted',
  headers: {'content-type': 'application/json'},
  data: {
    assets: [
      {
        assetDividends: [{amount: '', date: ''}],
        assetPrices: [{close: '', date: ''}],
        assetSplits: [{date: '', factor: ''}]
      }
    ]
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/assets/prices/adjusted';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":[{"assetDividends":[{"amount":"","date":""}],"assetPrices":[{"close":"","date":""}],"assetSplits":[{"date":"","factor":""}]}]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/assets/prices/adjusted',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "assets": [\n    {\n      "assetDividends": [\n        {\n          "amount": "",\n          "date": ""\n        }\n      ],\n      "assetPrices": [\n        {\n          "close": "",\n          "date": ""\n        }\n      ],\n      "assetSplits": [\n        {\n          "date": "",\n          "factor": ""\n        }\n      ]\n    }\n  ]\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"assets\": [\n    {\n      \"assetDividends\": [\n        {\n          \"amount\": \"\",\n          \"date\": \"\"\n        }\n      ],\n      \"assetPrices\": [\n        {\n          \"close\": \"\",\n          \"date\": \"\"\n        }\n      ],\n      \"assetSplits\": [\n        {\n          \"date\": \"\",\n          \"factor\": \"\"\n        }\n      ]\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/assets/prices/adjusted")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/assets/prices/adjusted',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  assets: [
    {
      assetDividends: [{amount: '', date: ''}],
      assetPrices: [{close: '', date: ''}],
      assetSplits: [{date: '', factor: ''}]
    }
  ]
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/assets/prices/adjusted',
  headers: {'content-type': 'application/json'},
  body: {
    assets: [
      {
        assetDividends: [{amount: '', date: ''}],
        assetPrices: [{close: '', date: ''}],
        assetSplits: [{date: '', factor: ''}]
      }
    ]
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/assets/prices/adjusted');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  assets: [
    {
      assetDividends: [
        {
          amount: '',
          date: ''
        }
      ],
      assetPrices: [
        {
          close: '',
          date: ''
        }
      ],
      assetSplits: [
        {
          date: '',
          factor: ''
        }
      ]
    }
  ]
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/assets/prices/adjusted',
  headers: {'content-type': 'application/json'},
  data: {
    assets: [
      {
        assetDividends: [{amount: '', date: ''}],
        assetPrices: [{close: '', date: ''}],
        assetSplits: [{date: '', factor: ''}]
      }
    ]
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/assets/prices/adjusted';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":[{"assetDividends":[{"amount":"","date":""}],"assetPrices":[{"close":"","date":""}],"assetSplits":[{"date":"","factor":""}]}]}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"assets": @[ @{ @"assetDividends": @[ @{ @"amount": @"", @"date": @"" } ], @"assetPrices": @[ @{ @"close": @"", @"date": @"" } ], @"assetSplits": @[ @{ @"date": @"", @"factor": @"" } ] } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/assets/prices/adjusted"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/assets/prices/adjusted" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"assets\": [\n    {\n      \"assetDividends\": [\n        {\n          \"amount\": \"\",\n          \"date\": \"\"\n        }\n      ],\n      \"assetPrices\": [\n        {\n          \"close\": \"\",\n          \"date\": \"\"\n        }\n      ],\n      \"assetSplits\": [\n        {\n          \"date\": \"\",\n          \"factor\": \"\"\n        }\n      ]\n    }\n  ]\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/assets/prices/adjusted",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'assets' => [
        [
                'assetDividends' => [
                                [
                                                                'amount' => '',
                                                                'date' => ''
                                ]
                ],
                'assetPrices' => [
                                [
                                                                'close' => '',
                                                                'date' => ''
                                ]
                ],
                'assetSplits' => [
                                [
                                                                'date' => '',
                                                                'factor' => ''
                                ]
                ]
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/assets/prices/adjusted', [
  'body' => '{
  "assets": [
    {
      "assetDividends": [
        {
          "amount": "",
          "date": ""
        }
      ],
      "assetPrices": [
        {
          "close": "",
          "date": ""
        }
      ],
      "assetSplits": [
        {
          "date": "",
          "factor": ""
        }
      ]
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/assets/prices/adjusted');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'assets' => [
    [
        'assetDividends' => [
                [
                                'amount' => '',
                                'date' => ''
                ]
        ],
        'assetPrices' => [
                [
                                'close' => '',
                                'date' => ''
                ]
        ],
        'assetSplits' => [
                [
                                'date' => '',
                                'factor' => ''
                ]
        ]
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'assets' => [
    [
        'assetDividends' => [
                [
                                'amount' => '',
                                'date' => ''
                ]
        ],
        'assetPrices' => [
                [
                                'close' => '',
                                'date' => ''
                ]
        ],
        'assetSplits' => [
                [
                                'date' => '',
                                'factor' => ''
                ]
        ]
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/assets/prices/adjusted');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/assets/prices/adjusted' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": [
    {
      "assetDividends": [
        {
          "amount": "",
          "date": ""
        }
      ],
      "assetPrices": [
        {
          "close": "",
          "date": ""
        }
      ],
      "assetSplits": [
        {
          "date": "",
          "factor": ""
        }
      ]
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/assets/prices/adjusted' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": [
    {
      "assetDividends": [
        {
          "amount": "",
          "date": ""
        }
      ],
      "assetPrices": [
        {
          "close": "",
          "date": ""
        }
      ],
      "assetSplits": [
        {
          "date": "",
          "factor": ""
        }
      ]
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"assets\": [\n    {\n      \"assetDividends\": [\n        {\n          \"amount\": \"\",\n          \"date\": \"\"\n        }\n      ],\n      \"assetPrices\": [\n        {\n          \"close\": \"\",\n          \"date\": \"\"\n        }\n      ],\n      \"assetSplits\": [\n        {\n          \"date\": \"\",\n          \"factor\": \"\"\n        }\n      ]\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/assets/prices/adjusted", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/assets/prices/adjusted"

payload = { "assets": [
        {
            "assetDividends": [
                {
                    "amount": "",
                    "date": ""
                }
            ],
            "assetPrices": [
                {
                    "close": "",
                    "date": ""
                }
            ],
            "assetSplits": [
                {
                    "date": "",
                    "factor": ""
                }
            ]
        }
    ] }
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/assets/prices/adjusted"

payload <- "{\n  \"assets\": [\n    {\n      \"assetDividends\": [\n        {\n          \"amount\": \"\",\n          \"date\": \"\"\n        }\n      ],\n      \"assetPrices\": [\n        {\n          \"close\": \"\",\n          \"date\": \"\"\n        }\n      ],\n      \"assetSplits\": [\n        {\n          \"date\": \"\",\n          \"factor\": \"\"\n        }\n      ]\n    }\n  ]\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/assets/prices/adjusted")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"assets\": [\n    {\n      \"assetDividends\": [\n        {\n          \"amount\": \"\",\n          \"date\": \"\"\n        }\n      ],\n      \"assetPrices\": [\n        {\n          \"close\": \"\",\n          \"date\": \"\"\n        }\n      ],\n      \"assetSplits\": [\n        {\n          \"date\": \"\",\n          \"factor\": \"\"\n        }\n      ]\n    }\n  ]\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/assets/prices/adjusted') do |req|
  req.body = "{\n  \"assets\": [\n    {\n      \"assetDividends\": [\n        {\n          \"amount\": \"\",\n          \"date\": \"\"\n        }\n      ],\n      \"assetPrices\": [\n        {\n          \"close\": \"\",\n          \"date\": \"\"\n        }\n      ],\n      \"assetSplits\": [\n        {\n          \"date\": \"\",\n          \"factor\": \"\"\n        }\n      ]\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/assets/prices/adjusted";

    let payload = json!({"assets": (
            json!({
                "assetDividends": (
                    json!({
                        "amount": "",
                        "date": ""
                    })
                ),
                "assetPrices": (
                    json!({
                        "close": "",
                        "date": ""
                    })
                ),
                "assetSplits": (
                    json!({
                        "date": "",
                        "factor": ""
                    })
                )
            })
        )});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/assets/prices/adjusted \
  --header 'content-type: application/json' \
  --data '{
  "assets": [
    {
      "assetDividends": [
        {
          "amount": "",
          "date": ""
        }
      ],
      "assetPrices": [
        {
          "close": "",
          "date": ""
        }
      ],
      "assetSplits": [
        {
          "date": "",
          "factor": ""
        }
      ]
    }
  ]
}'

echo '{
  "assets": [
    {
      "assetDividends": [
        {
          "amount": "",
          "date": ""
        }
      ],
      "assetPrices": [
        {
          "close": "",
          "date": ""
        }
      ],
      "assetSplits": [
        {
          "date": "",
          "factor": ""
        }
      ]
    }
  ]
}' |  \
  http POST {{baseUrl}}/assets/prices/adjusted \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "assets": [\n    {\n      "assetDividends": [\n        {\n          "amount": "",\n          "date": ""\n        }\n      ],\n      "assetPrices": [\n        {\n          "close": "",\n          "date": ""\n        }\n      ],\n      "assetSplits": [\n        {\n          "date": "",\n          "factor": ""\n        }\n      ]\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/assets/prices/adjusted

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["assets": [
    [
      "assetDividends": [
        [
          "amount": "",
          "date": ""
        ]
      ],
      "assetPrices": [
        [
          "close": "",
          "date": ""
        ]
      ],
      "assetSplits": [
        [
          "date": "",
          "factor": ""
        ]
      ]
    ]
  ]] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/assets/prices/adjusted")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "assets": [
    {
      "assetAdjustedPrices": [
        {
          "date": "2020-09-01",
          "fullyAdjustedClose": 475.05,
          "splitAdjustedClose": 475.05
        },
        {
          "date": "2020-08-31",
          "fullyAdjustedClose": 498.32,
          "splitAdjustedClose": 498.32
        },
        {
          "date": "2020-08-28",
          "fullyAdjustedClose": 442.68,
          "splitAdjustedClose": 442.68
        }
      ]
    }
  ]
}

POST Forward-Adjusted Prices

{{baseUrl}}/assets/prices/adjusted/forward

BODY json

{
  "assets": [
    {
      "assetDividends": [
        {
          "amount": "",
          "date": ""
        }
      ],
      "assetPrices": [
        {
          "close": "",
          "date": ""
        }
      ],
      "assetSplits": [
        {
          "date": "",
          "factor": ""
        }
      ]
    }
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/assets/prices/adjusted/forward");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"assets\": [\n    {\n      \"assetDividends\": [\n        {\n          \"amount\": \"\",\n          \"date\": \"\"\n        }\n      ],\n      \"assetPrices\": [\n        {\n          \"close\": \"\",\n          \"date\": \"\"\n        }\n      ],\n      \"assetSplits\": [\n        {\n          \"date\": \"\",\n          \"factor\": \"\"\n        }\n      ]\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/assets/prices/adjusted/forward" {:content-type :json
                                                                           :form-params {:assets [{:assetDividends [{:amount ""
                                                                                                                     :date ""}]
                                                                                                   :assetPrices [{:close ""
                                                                                                                  :date ""}]
                                                                                                   :assetSplits [{:date ""
                                                                                                                  :factor ""}]}]}})

require "http/client"

url = "{{baseUrl}}/assets/prices/adjusted/forward"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"assets\": [\n    {\n      \"assetDividends\": [\n        {\n          \"amount\": \"\",\n          \"date\": \"\"\n        }\n      ],\n      \"assetPrices\": [\n        {\n          \"close\": \"\",\n          \"date\": \"\"\n        }\n      ],\n      \"assetSplits\": [\n        {\n          \"date\": \"\",\n          \"factor\": \"\"\n        }\n      ]\n    }\n  ]\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/assets/prices/adjusted/forward"),
    Content = new StringContent("{\n  \"assets\": [\n    {\n      \"assetDividends\": [\n        {\n          \"amount\": \"\",\n          \"date\": \"\"\n        }\n      ],\n      \"assetPrices\": [\n        {\n          \"close\": \"\",\n          \"date\": \"\"\n        }\n      ],\n      \"assetSplits\": [\n        {\n          \"date\": \"\",\n          \"factor\": \"\"\n        }\n      ]\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/assets/prices/adjusted/forward");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"assets\": [\n    {\n      \"assetDividends\": [\n        {\n          \"amount\": \"\",\n          \"date\": \"\"\n        }\n      ],\n      \"assetPrices\": [\n        {\n          \"close\": \"\",\n          \"date\": \"\"\n        }\n      ],\n      \"assetSplits\": [\n        {\n          \"date\": \"\",\n          \"factor\": \"\"\n        }\n      ]\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/assets/prices/adjusted/forward"

	payload := strings.NewReader("{\n  \"assets\": [\n    {\n      \"assetDividends\": [\n        {\n          \"amount\": \"\",\n          \"date\": \"\"\n        }\n      ],\n      \"assetPrices\": [\n        {\n          \"close\": \"\",\n          \"date\": \"\"\n        }\n      ],\n      \"assetSplits\": [\n        {\n          \"date\": \"\",\n          \"factor\": \"\"\n        }\n      ]\n    }\n  ]\n}")

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

	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/assets/prices/adjusted/forward HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 325

{
  "assets": [
    {
      "assetDividends": [
        {
          "amount": "",
          "date": ""
        }
      ],
      "assetPrices": [
        {
          "close": "",
          "date": ""
        }
      ],
      "assetSplits": [
        {
          "date": "",
          "factor": ""
        }
      ]
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/assets/prices/adjusted/forward")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"assets\": [\n    {\n      \"assetDividends\": [\n        {\n          \"amount\": \"\",\n          \"date\": \"\"\n        }\n      ],\n      \"assetPrices\": [\n        {\n          \"close\": \"\",\n          \"date\": \"\"\n        }\n      ],\n      \"assetSplits\": [\n        {\n          \"date\": \"\",\n          \"factor\": \"\"\n        }\n      ]\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/assets/prices/adjusted/forward"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"assets\": [\n    {\n      \"assetDividends\": [\n        {\n          \"amount\": \"\",\n          \"date\": \"\"\n        }\n      ],\n      \"assetPrices\": [\n        {\n          \"close\": \"\",\n          \"date\": \"\"\n        }\n      ],\n      \"assetSplits\": [\n        {\n          \"date\": \"\",\n          \"factor\": \"\"\n        }\n      ]\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"assets\": [\n    {\n      \"assetDividends\": [\n        {\n          \"amount\": \"\",\n          \"date\": \"\"\n        }\n      ],\n      \"assetPrices\": [\n        {\n          \"close\": \"\",\n          \"date\": \"\"\n        }\n      ],\n      \"assetSplits\": [\n        {\n          \"date\": \"\",\n          \"factor\": \"\"\n        }\n      ]\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/assets/prices/adjusted/forward")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/assets/prices/adjusted/forward")
  .header("content-type", "application/json")
  .body("{\n  \"assets\": [\n    {\n      \"assetDividends\": [\n        {\n          \"amount\": \"\",\n          \"date\": \"\"\n        }\n      ],\n      \"assetPrices\": [\n        {\n          \"close\": \"\",\n          \"date\": \"\"\n        }\n      ],\n      \"assetSplits\": [\n        {\n          \"date\": \"\",\n          \"factor\": \"\"\n        }\n      ]\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  assets: [
    {
      assetDividends: [
        {
          amount: '',
          date: ''
        }
      ],
      assetPrices: [
        {
          close: '',
          date: ''
        }
      ],
      assetSplits: [
        {
          date: '',
          factor: ''
        }
      ]
    }
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/assets/prices/adjusted/forward');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/assets/prices/adjusted/forward',
  headers: {'content-type': 'application/json'},
  data: {
    assets: [
      {
        assetDividends: [{amount: '', date: ''}],
        assetPrices: [{close: '', date: ''}],
        assetSplits: [{date: '', factor: ''}]
      }
    ]
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/assets/prices/adjusted/forward';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":[{"assetDividends":[{"amount":"","date":""}],"assetPrices":[{"close":"","date":""}],"assetSplits":[{"date":"","factor":""}]}]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/assets/prices/adjusted/forward',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "assets": [\n    {\n      "assetDividends": [\n        {\n          "amount": "",\n          "date": ""\n        }\n      ],\n      "assetPrices": [\n        {\n          "close": "",\n          "date": ""\n        }\n      ],\n      "assetSplits": [\n        {\n          "date": "",\n          "factor": ""\n        }\n      ]\n    }\n  ]\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"assets\": [\n    {\n      \"assetDividends\": [\n        {\n          \"amount\": \"\",\n          \"date\": \"\"\n        }\n      ],\n      \"assetPrices\": [\n        {\n          \"close\": \"\",\n          \"date\": \"\"\n        }\n      ],\n      \"assetSplits\": [\n        {\n          \"date\": \"\",\n          \"factor\": \"\"\n        }\n      ]\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/assets/prices/adjusted/forward")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/assets/prices/adjusted/forward',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  assets: [
    {
      assetDividends: [{amount: '', date: ''}],
      assetPrices: [{close: '', date: ''}],
      assetSplits: [{date: '', factor: ''}]
    }
  ]
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/assets/prices/adjusted/forward',
  headers: {'content-type': 'application/json'},
  body: {
    assets: [
      {
        assetDividends: [{amount: '', date: ''}],
        assetPrices: [{close: '', date: ''}],
        assetSplits: [{date: '', factor: ''}]
      }
    ]
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/assets/prices/adjusted/forward');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  assets: [
    {
      assetDividends: [
        {
          amount: '',
          date: ''
        }
      ],
      assetPrices: [
        {
          close: '',
          date: ''
        }
      ],
      assetSplits: [
        {
          date: '',
          factor: ''
        }
      ]
    }
  ]
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/assets/prices/adjusted/forward',
  headers: {'content-type': 'application/json'},
  data: {
    assets: [
      {
        assetDividends: [{amount: '', date: ''}],
        assetPrices: [{close: '', date: ''}],
        assetSplits: [{date: '', factor: ''}]
      }
    ]
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/assets/prices/adjusted/forward';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":[{"assetDividends":[{"amount":"","date":""}],"assetPrices":[{"close":"","date":""}],"assetSplits":[{"date":"","factor":""}]}]}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"assets": @[ @{ @"assetDividends": @[ @{ @"amount": @"", @"date": @"" } ], @"assetPrices": @[ @{ @"close": @"", @"date": @"" } ], @"assetSplits": @[ @{ @"date": @"", @"factor": @"" } ] } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/assets/prices/adjusted/forward"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/assets/prices/adjusted/forward" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"assets\": [\n    {\n      \"assetDividends\": [\n        {\n          \"amount\": \"\",\n          \"date\": \"\"\n        }\n      ],\n      \"assetPrices\": [\n        {\n          \"close\": \"\",\n          \"date\": \"\"\n        }\n      ],\n      \"assetSplits\": [\n        {\n          \"date\": \"\",\n          \"factor\": \"\"\n        }\n      ]\n    }\n  ]\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/assets/prices/adjusted/forward",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'assets' => [
        [
                'assetDividends' => [
                                [
                                                                'amount' => '',
                                                                'date' => ''
                                ]
                ],
                'assetPrices' => [
                                [
                                                                'close' => '',
                                                                'date' => ''
                                ]
                ],
                'assetSplits' => [
                                [
                                                                'date' => '',
                                                                'factor' => ''
                                ]
                ]
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/assets/prices/adjusted/forward', [
  'body' => '{
  "assets": [
    {
      "assetDividends": [
        {
          "amount": "",
          "date": ""
        }
      ],
      "assetPrices": [
        {
          "close": "",
          "date": ""
        }
      ],
      "assetSplits": [
        {
          "date": "",
          "factor": ""
        }
      ]
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/assets/prices/adjusted/forward');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'assets' => [
    [
        'assetDividends' => [
                [
                                'amount' => '',
                                'date' => ''
                ]
        ],
        'assetPrices' => [
                [
                                'close' => '',
                                'date' => ''
                ]
        ],
        'assetSplits' => [
                [
                                'date' => '',
                                'factor' => ''
                ]
        ]
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'assets' => [
    [
        'assetDividends' => [
                [
                                'amount' => '',
                                'date' => ''
                ]
        ],
        'assetPrices' => [
                [
                                'close' => '',
                                'date' => ''
                ]
        ],
        'assetSplits' => [
                [
                                'date' => '',
                                'factor' => ''
                ]
        ]
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/assets/prices/adjusted/forward');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/assets/prices/adjusted/forward' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": [
    {
      "assetDividends": [
        {
          "amount": "",
          "date": ""
        }
      ],
      "assetPrices": [
        {
          "close": "",
          "date": ""
        }
      ],
      "assetSplits": [
        {
          "date": "",
          "factor": ""
        }
      ]
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/assets/prices/adjusted/forward' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": [
    {
      "assetDividends": [
        {
          "amount": "",
          "date": ""
        }
      ],
      "assetPrices": [
        {
          "close": "",
          "date": ""
        }
      ],
      "assetSplits": [
        {
          "date": "",
          "factor": ""
        }
      ]
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"assets\": [\n    {\n      \"assetDividends\": [\n        {\n          \"amount\": \"\",\n          \"date\": \"\"\n        }\n      ],\n      \"assetPrices\": [\n        {\n          \"close\": \"\",\n          \"date\": \"\"\n        }\n      ],\n      \"assetSplits\": [\n        {\n          \"date\": \"\",\n          \"factor\": \"\"\n        }\n      ]\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/assets/prices/adjusted/forward", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/assets/prices/adjusted/forward"

payload = { "assets": [
        {
            "assetDividends": [
                {
                    "amount": "",
                    "date": ""
                }
            ],
            "assetPrices": [
                {
                    "close": "",
                    "date": ""
                }
            ],
            "assetSplits": [
                {
                    "date": "",
                    "factor": ""
                }
            ]
        }
    ] }
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/assets/prices/adjusted/forward"

payload <- "{\n  \"assets\": [\n    {\n      \"assetDividends\": [\n        {\n          \"amount\": \"\",\n          \"date\": \"\"\n        }\n      ],\n      \"assetPrices\": [\n        {\n          \"close\": \"\",\n          \"date\": \"\"\n        }\n      ],\n      \"assetSplits\": [\n        {\n          \"date\": \"\",\n          \"factor\": \"\"\n        }\n      ]\n    }\n  ]\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/assets/prices/adjusted/forward")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"assets\": [\n    {\n      \"assetDividends\": [\n        {\n          \"amount\": \"\",\n          \"date\": \"\"\n        }\n      ],\n      \"assetPrices\": [\n        {\n          \"close\": \"\",\n          \"date\": \"\"\n        }\n      ],\n      \"assetSplits\": [\n        {\n          \"date\": \"\",\n          \"factor\": \"\"\n        }\n      ]\n    }\n  ]\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/assets/prices/adjusted/forward') do |req|
  req.body = "{\n  \"assets\": [\n    {\n      \"assetDividends\": [\n        {\n          \"amount\": \"\",\n          \"date\": \"\"\n        }\n      ],\n      \"assetPrices\": [\n        {\n          \"close\": \"\",\n          \"date\": \"\"\n        }\n      ],\n      \"assetSplits\": [\n        {\n          \"date\": \"\",\n          \"factor\": \"\"\n        }\n      ]\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/assets/prices/adjusted/forward";

    let payload = json!({"assets": (
            json!({
                "assetDividends": (
                    json!({
                        "amount": "",
                        "date": ""
                    })
                ),
                "assetPrices": (
                    json!({
                        "close": "",
                        "date": ""
                    })
                ),
                "assetSplits": (
                    json!({
                        "date": "",
                        "factor": ""
                    })
                )
            })
        )});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/assets/prices/adjusted/forward \
  --header 'content-type: application/json' \
  --data '{
  "assets": [
    {
      "assetDividends": [
        {
          "amount": "",
          "date": ""
        }
      ],
      "assetPrices": [
        {
          "close": "",
          "date": ""
        }
      ],
      "assetSplits": [
        {
          "date": "",
          "factor": ""
        }
      ]
    }
  ]
}'

echo '{
  "assets": [
    {
      "assetDividends": [
        {
          "amount": "",
          "date": ""
        }
      ],
      "assetPrices": [
        {
          "close": "",
          "date": ""
        }
      ],
      "assetSplits": [
        {
          "date": "",
          "factor": ""
        }
      ]
    }
  ]
}' |  \
  http POST {{baseUrl}}/assets/prices/adjusted/forward \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "assets": [\n    {\n      "assetDividends": [\n        {\n          "amount": "",\n          "date": ""\n        }\n      ],\n      "assetPrices": [\n        {\n          "close": "",\n          "date": ""\n        }\n      ],\n      "assetSplits": [\n        {\n          "date": "",\n          "factor": ""\n        }\n      ]\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/assets/prices/adjusted/forward

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["assets": [
    [
      "assetDividends": [
        [
          "amount": "",
          "date": ""
        ]
      ],
      "assetPrices": [
        [
          "close": "",
          "date": ""
        ]
      ],
      "assetSplits": [
        [
          "date": "",
          "factor": ""
        ]
      ]
    ]
  ]] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/assets/prices/adjusted/forward")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "assets": [
    {
      "assetAdjustedPrices": [
        {
          "date": "2020-08-28",
          "fullyAdjustedClose": 2213.4,
          "splitAdjustedClose": 2213.4
        },
        {
          "date": "2020-08-31",
          "fullyAdjustedClose": 2491.6,
          "splitAdjustedClose": 2491.6
        },
        {
          "date": "2020-09-01",
          "fullyAdjustedClose": 2375.25,
          "splitAdjustedClose": 2375.25
        }
      ]
    }
  ]
}

POST Arithmetic Average Return

{{baseUrl}}/assets/returns/average

BODY json

{
  "assets": [
    {
      "assetReturns": []
    }
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/assets/returns/average");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/assets/returns/average" {:content-type :json
                                                                   :form-params {:assets [{:assetReturns []}]}})

require "http/client"

url = "{{baseUrl}}/assets/returns/average"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ]\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/assets/returns/average"),
    Content = new StringContent("{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/assets/returns/average");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/assets/returns/average"

	payload := strings.NewReader("{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ]\n}")

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

	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/assets/returns/average HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 58

{
  "assets": [
    {
      "assetReturns": []
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/assets/returns/average")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/assets/returns/average"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/assets/returns/average")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/assets/returns/average")
  .header("content-type", "application/json")
  .body("{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  assets: [
    {
      assetReturns: []
    }
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/assets/returns/average');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/assets/returns/average',
  headers: {'content-type': 'application/json'},
  data: {assets: [{assetReturns: []}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/assets/returns/average';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":[{"assetReturns":[]}]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/assets/returns/average',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "assets": [\n    {\n      "assetReturns": []\n    }\n  ]\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/assets/returns/average")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/assets/returns/average',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({assets: [{assetReturns: []}]}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/assets/returns/average',
  headers: {'content-type': 'application/json'},
  body: {assets: [{assetReturns: []}]},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/assets/returns/average');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  assets: [
    {
      assetReturns: []
    }
  ]
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/assets/returns/average',
  headers: {'content-type': 'application/json'},
  data: {assets: [{assetReturns: []}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/assets/returns/average';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":[{"assetReturns":[]}]}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"assets": @[ @{ @"assetReturns": @[  ] } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/assets/returns/average"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/assets/returns/average" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ]\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/assets/returns/average",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'assets' => [
        [
                'assetReturns' => [
                                
                ]
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/assets/returns/average', [
  'body' => '{
  "assets": [
    {
      "assetReturns": []
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/assets/returns/average');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'assets' => [
    [
        'assetReturns' => [
                
        ]
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'assets' => [
    [
        'assetReturns' => [
                
        ]
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/assets/returns/average');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/assets/returns/average' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": [
    {
      "assetReturns": []
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/assets/returns/average' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": [
    {
      "assetReturns": []
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/assets/returns/average", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/assets/returns/average"

payload = { "assets": [{ "assetReturns": [] }] }
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/assets/returns/average"

payload <- "{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ]\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/assets/returns/average")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ]\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/assets/returns/average') do |req|
  req.body = "{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/assets/returns/average";

    let payload = json!({"assets": (json!({"assetReturns": ()}))});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/assets/returns/average \
  --header 'content-type: application/json' \
  --data '{
  "assets": [
    {
      "assetReturns": []
    }
  ]
}'

echo '{
  "assets": [
    {
      "assetReturns": []
    }
  ]
}' |  \
  http POST {{baseUrl}}/assets/returns/average \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "assets": [\n    {\n      "assetReturns": []\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/assets/returns/average

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["assets": [["assetReturns": []]]] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/assets/returns/average")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "assets": [
    {
      "assetAverageReturn": 0.025
    },
    {
      "assetAverageReturn": 0
    }
  ]
}

POST Arithmetic Returns

{{baseUrl}}/assets/returns

BODY json

{
  "assets": [
    {
      "assetPrices": []
    }
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/assets/returns");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/assets/returns" {:content-type :json
                                                           :form-params {:assets [{:assetPrices []}]}})

require "http/client"

url = "{{baseUrl}}/assets/returns"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ]\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/assets/returns"),
    Content = new StringContent("{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/assets/returns");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/assets/returns"

	payload := strings.NewReader("{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ]\n}")

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

	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/assets/returns HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 57

{
  "assets": [
    {
      "assetPrices": []
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/assets/returns")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/assets/returns"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/assets/returns")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/assets/returns")
  .header("content-type", "application/json")
  .body("{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  assets: [
    {
      assetPrices: []
    }
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/assets/returns');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/assets/returns',
  headers: {'content-type': 'application/json'},
  data: {assets: [{assetPrices: []}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/assets/returns';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":[{"assetPrices":[]}]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/assets/returns',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "assets": [\n    {\n      "assetPrices": []\n    }\n  ]\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/assets/returns")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/assets/returns',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({assets: [{assetPrices: []}]}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/assets/returns',
  headers: {'content-type': 'application/json'},
  body: {assets: [{assetPrices: []}]},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/assets/returns');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  assets: [
    {
      assetPrices: []
    }
  ]
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/assets/returns',
  headers: {'content-type': 'application/json'},
  data: {assets: [{assetPrices: []}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/assets/returns';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":[{"assetPrices":[]}]}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"assets": @[ @{ @"assetPrices": @[  ] } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/assets/returns"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/assets/returns" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ]\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/assets/returns",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'assets' => [
        [
                'assetPrices' => [
                                
                ]
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/assets/returns', [
  'body' => '{
  "assets": [
    {
      "assetPrices": []
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/assets/returns');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'assets' => [
    [
        'assetPrices' => [
                
        ]
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'assets' => [
    [
        'assetPrices' => [
                
        ]
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/assets/returns');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/assets/returns' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": [
    {
      "assetPrices": []
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/assets/returns' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": [
    {
      "assetPrices": []
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/assets/returns", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/assets/returns"

payload = { "assets": [{ "assetPrices": [] }] }
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/assets/returns"

payload <- "{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ]\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/assets/returns")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ]\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/assets/returns') do |req|
  req.body = "{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/assets/returns";

    let payload = json!({"assets": (json!({"assetPrices": ()}))});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/assets/returns \
  --header 'content-type: application/json' \
  --data '{
  "assets": [
    {
      "assetPrices": []
    }
  ]
}'

echo '{
  "assets": [
    {
      "assetPrices": []
    }
  ]
}' |  \
  http POST {{baseUrl}}/assets/returns \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "assets": [\n    {\n      "assetPrices": []\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/assets/returns

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["assets": [["assetPrices": []]]] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/assets/returns")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "assets": [
    {
      "assetReturns": [
        1
      ]
    },
    {
      "assetReturns": [
        0.5,
        1
      ]
    }
  ]
}

POST Bootstrap

{{baseUrl}}/assets/returns/simulation/bootstrap

BODY json

{
  "assets": [
    {
      "assetReturns": []
    }
  ],
  "bootstrapAverageBlockLength": "",
  "bootstrapBlockLength": 0,
  "bootstrapMethod": "",
  "simulations": 0,
  "simulationsLength": 0
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/assets/returns/simulation/bootstrap");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ],\n  \"bootstrapAverageBlockLength\": \"\",\n  \"bootstrapBlockLength\": 0,\n  \"bootstrapMethod\": \"\",\n  \"simulations\": 0,\n  \"simulationsLength\": 0\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/assets/returns/simulation/bootstrap" {:content-type :json
                                                                                :form-params {:assets [{:assetReturns []}]
                                                                                              :bootstrapAverageBlockLength ""
                                                                                              :bootstrapBlockLength 0
                                                                                              :bootstrapMethod ""
                                                                                              :simulations 0
                                                                                              :simulationsLength 0}})

require "http/client"

url = "{{baseUrl}}/assets/returns/simulation/bootstrap"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ],\n  \"bootstrapAverageBlockLength\": \"\",\n  \"bootstrapBlockLength\": 0,\n  \"bootstrapMethod\": \"\",\n  \"simulations\": 0,\n  \"simulationsLength\": 0\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/assets/returns/simulation/bootstrap"),
    Content = new StringContent("{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ],\n  \"bootstrapAverageBlockLength\": \"\",\n  \"bootstrapBlockLength\": 0,\n  \"bootstrapMethod\": \"\",\n  \"simulations\": 0,\n  \"simulationsLength\": 0\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/assets/returns/simulation/bootstrap");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ],\n  \"bootstrapAverageBlockLength\": \"\",\n  \"bootstrapBlockLength\": 0,\n  \"bootstrapMethod\": \"\",\n  \"simulations\": 0,\n  \"simulationsLength\": 0\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/assets/returns/simulation/bootstrap"

	payload := strings.NewReader("{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ],\n  \"bootstrapAverageBlockLength\": \"\",\n  \"bootstrapBlockLength\": 0,\n  \"bootstrapMethod\": \"\",\n  \"simulations\": 0,\n  \"simulationsLength\": 0\n}")

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

	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/assets/returns/simulation/bootstrap HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 195

{
  "assets": [
    {
      "assetReturns": []
    }
  ],
  "bootstrapAverageBlockLength": "",
  "bootstrapBlockLength": 0,
  "bootstrapMethod": "",
  "simulations": 0,
  "simulationsLength": 0
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/assets/returns/simulation/bootstrap")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ],\n  \"bootstrapAverageBlockLength\": \"\",\n  \"bootstrapBlockLength\": 0,\n  \"bootstrapMethod\": \"\",\n  \"simulations\": 0,\n  \"simulationsLength\": 0\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/assets/returns/simulation/bootstrap"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ],\n  \"bootstrapAverageBlockLength\": \"\",\n  \"bootstrapBlockLength\": 0,\n  \"bootstrapMethod\": \"\",\n  \"simulations\": 0,\n  \"simulationsLength\": 0\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ],\n  \"bootstrapAverageBlockLength\": \"\",\n  \"bootstrapBlockLength\": 0,\n  \"bootstrapMethod\": \"\",\n  \"simulations\": 0,\n  \"simulationsLength\": 0\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/assets/returns/simulation/bootstrap")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/assets/returns/simulation/bootstrap")
  .header("content-type", "application/json")
  .body("{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ],\n  \"bootstrapAverageBlockLength\": \"\",\n  \"bootstrapBlockLength\": 0,\n  \"bootstrapMethod\": \"\",\n  \"simulations\": 0,\n  \"simulationsLength\": 0\n}")
  .asString();

const data = JSON.stringify({
  assets: [
    {
      assetReturns: []
    }
  ],
  bootstrapAverageBlockLength: '',
  bootstrapBlockLength: 0,
  bootstrapMethod: '',
  simulations: 0,
  simulationsLength: 0
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/assets/returns/simulation/bootstrap');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/assets/returns/simulation/bootstrap',
  headers: {'content-type': 'application/json'},
  data: {
    assets: [{assetReturns: []}],
    bootstrapAverageBlockLength: '',
    bootstrapBlockLength: 0,
    bootstrapMethod: '',
    simulations: 0,
    simulationsLength: 0
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/assets/returns/simulation/bootstrap';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":[{"assetReturns":[]}],"bootstrapAverageBlockLength":"","bootstrapBlockLength":0,"bootstrapMethod":"","simulations":0,"simulationsLength":0}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/assets/returns/simulation/bootstrap',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "assets": [\n    {\n      "assetReturns": []\n    }\n  ],\n  "bootstrapAverageBlockLength": "",\n  "bootstrapBlockLength": 0,\n  "bootstrapMethod": "",\n  "simulations": 0,\n  "simulationsLength": 0\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ],\n  \"bootstrapAverageBlockLength\": \"\",\n  \"bootstrapBlockLength\": 0,\n  \"bootstrapMethod\": \"\",\n  \"simulations\": 0,\n  \"simulationsLength\": 0\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/assets/returns/simulation/bootstrap")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/assets/returns/simulation/bootstrap',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  assets: [{assetReturns: []}],
  bootstrapAverageBlockLength: '',
  bootstrapBlockLength: 0,
  bootstrapMethod: '',
  simulations: 0,
  simulationsLength: 0
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/assets/returns/simulation/bootstrap',
  headers: {'content-type': 'application/json'},
  body: {
    assets: [{assetReturns: []}],
    bootstrapAverageBlockLength: '',
    bootstrapBlockLength: 0,
    bootstrapMethod: '',
    simulations: 0,
    simulationsLength: 0
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/assets/returns/simulation/bootstrap');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  assets: [
    {
      assetReturns: []
    }
  ],
  bootstrapAverageBlockLength: '',
  bootstrapBlockLength: 0,
  bootstrapMethod: '',
  simulations: 0,
  simulationsLength: 0
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/assets/returns/simulation/bootstrap',
  headers: {'content-type': 'application/json'},
  data: {
    assets: [{assetReturns: []}],
    bootstrapAverageBlockLength: '',
    bootstrapBlockLength: 0,
    bootstrapMethod: '',
    simulations: 0,
    simulationsLength: 0
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/assets/returns/simulation/bootstrap';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":[{"assetReturns":[]}],"bootstrapAverageBlockLength":"","bootstrapBlockLength":0,"bootstrapMethod":"","simulations":0,"simulationsLength":0}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"assets": @[ @{ @"assetReturns": @[  ] } ],
                              @"bootstrapAverageBlockLength": @"",
                              @"bootstrapBlockLength": @0,
                              @"bootstrapMethod": @"",
                              @"simulations": @0,
                              @"simulationsLength": @0 };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/assets/returns/simulation/bootstrap"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/assets/returns/simulation/bootstrap" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ],\n  \"bootstrapAverageBlockLength\": \"\",\n  \"bootstrapBlockLength\": 0,\n  \"bootstrapMethod\": \"\",\n  \"simulations\": 0,\n  \"simulationsLength\": 0\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/assets/returns/simulation/bootstrap",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'assets' => [
        [
                'assetReturns' => [
                                
                ]
        ]
    ],
    'bootstrapAverageBlockLength' => '',
    'bootstrapBlockLength' => 0,
    'bootstrapMethod' => '',
    'simulations' => 0,
    'simulationsLength' => 0
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/assets/returns/simulation/bootstrap', [
  'body' => '{
  "assets": [
    {
      "assetReturns": []
    }
  ],
  "bootstrapAverageBlockLength": "",
  "bootstrapBlockLength": 0,
  "bootstrapMethod": "",
  "simulations": 0,
  "simulationsLength": 0
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/assets/returns/simulation/bootstrap');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'assets' => [
    [
        'assetReturns' => [
                
        ]
    ]
  ],
  'bootstrapAverageBlockLength' => '',
  'bootstrapBlockLength' => 0,
  'bootstrapMethod' => '',
  'simulations' => 0,
  'simulationsLength' => 0
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'assets' => [
    [
        'assetReturns' => [
                
        ]
    ]
  ],
  'bootstrapAverageBlockLength' => '',
  'bootstrapBlockLength' => 0,
  'bootstrapMethod' => '',
  'simulations' => 0,
  'simulationsLength' => 0
]));
$request->setRequestUrl('{{baseUrl}}/assets/returns/simulation/bootstrap');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/assets/returns/simulation/bootstrap' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": [
    {
      "assetReturns": []
    }
  ],
  "bootstrapAverageBlockLength": "",
  "bootstrapBlockLength": 0,
  "bootstrapMethod": "",
  "simulations": 0,
  "simulationsLength": 0
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/assets/returns/simulation/bootstrap' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": [
    {
      "assetReturns": []
    }
  ],
  "bootstrapAverageBlockLength": "",
  "bootstrapBlockLength": 0,
  "bootstrapMethod": "",
  "simulations": 0,
  "simulationsLength": 0
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ],\n  \"bootstrapAverageBlockLength\": \"\",\n  \"bootstrapBlockLength\": 0,\n  \"bootstrapMethod\": \"\",\n  \"simulations\": 0,\n  \"simulationsLength\": 0\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/assets/returns/simulation/bootstrap", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/assets/returns/simulation/bootstrap"

payload = {
    "assets": [{ "assetReturns": [] }],
    "bootstrapAverageBlockLength": "",
    "bootstrapBlockLength": 0,
    "bootstrapMethod": "",
    "simulations": 0,
    "simulationsLength": 0
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/assets/returns/simulation/bootstrap"

payload <- "{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ],\n  \"bootstrapAverageBlockLength\": \"\",\n  \"bootstrapBlockLength\": 0,\n  \"bootstrapMethod\": \"\",\n  \"simulations\": 0,\n  \"simulationsLength\": 0\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/assets/returns/simulation/bootstrap")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ],\n  \"bootstrapAverageBlockLength\": \"\",\n  \"bootstrapBlockLength\": 0,\n  \"bootstrapMethod\": \"\",\n  \"simulations\": 0,\n  \"simulationsLength\": 0\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/assets/returns/simulation/bootstrap') do |req|
  req.body = "{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ],\n  \"bootstrapAverageBlockLength\": \"\",\n  \"bootstrapBlockLength\": 0,\n  \"bootstrapMethod\": \"\",\n  \"simulations\": 0,\n  \"simulationsLength\": 0\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/assets/returns/simulation/bootstrap";

    let payload = json!({
        "assets": (json!({"assetReturns": ()})),
        "bootstrapAverageBlockLength": "",
        "bootstrapBlockLength": 0,
        "bootstrapMethod": "",
        "simulations": 0,
        "simulationsLength": 0
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/assets/returns/simulation/bootstrap \
  --header 'content-type: application/json' \
  --data '{
  "assets": [
    {
      "assetReturns": []
    }
  ],
  "bootstrapAverageBlockLength": "",
  "bootstrapBlockLength": 0,
  "bootstrapMethod": "",
  "simulations": 0,
  "simulationsLength": 0
}'

echo '{
  "assets": [
    {
      "assetReturns": []
    }
  ],
  "bootstrapAverageBlockLength": "",
  "bootstrapBlockLength": 0,
  "bootstrapMethod": "",
  "simulations": 0,
  "simulationsLength": 0
}' |  \
  http POST {{baseUrl}}/assets/returns/simulation/bootstrap \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "assets": [\n    {\n      "assetReturns": []\n    }\n  ],\n  "bootstrapAverageBlockLength": "",\n  "bootstrapBlockLength": 0,\n  "bootstrapMethod": "",\n  "simulations": 0,\n  "simulationsLength": 0\n}' \
  --output-document \
  - {{baseUrl}}/assets/returns/simulation/bootstrap

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "assets": [["assetReturns": []]],
  "bootstrapAverageBlockLength": "",
  "bootstrapBlockLength": 0,
  "bootstrapMethod": "",
  "simulations": 0,
  "simulationsLength": 0
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/assets/returns/simulation/bootstrap")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "simulations": [
    {
      "assets": [
        {
          "assetReturns": [
            0.01,
            0.02
          ]
        },
        {
          "assetReturns": [
            0.01,
            -0.02
          ]
        }
      ]
    }
  ]
}

POST Skewness

{{baseUrl}}/assets/skewness

BODY json

{
  "assets": [
    {
      "assetReturns": []
    }
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/assets/skewness");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/assets/skewness" {:content-type :json
                                                            :form-params {:assets [{:assetReturns []}]}})

require "http/client"

url = "{{baseUrl}}/assets/skewness"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ]\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/assets/skewness"),
    Content = new StringContent("{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/assets/skewness");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/assets/skewness"

	payload := strings.NewReader("{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ]\n}")

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

	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/assets/skewness HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 58

{
  "assets": [
    {
      "assetReturns": []
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/assets/skewness")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/assets/skewness"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/assets/skewness")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/assets/skewness")
  .header("content-type", "application/json")
  .body("{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  assets: [
    {
      assetReturns: []
    }
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/assets/skewness');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/assets/skewness',
  headers: {'content-type': 'application/json'},
  data: {assets: [{assetReturns: []}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/assets/skewness';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":[{"assetReturns":[]}]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/assets/skewness',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "assets": [\n    {\n      "assetReturns": []\n    }\n  ]\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/assets/skewness")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/assets/skewness',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({assets: [{assetReturns: []}]}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/assets/skewness',
  headers: {'content-type': 'application/json'},
  body: {assets: [{assetReturns: []}]},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/assets/skewness');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  assets: [
    {
      assetReturns: []
    }
  ]
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/assets/skewness',
  headers: {'content-type': 'application/json'},
  data: {assets: [{assetReturns: []}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/assets/skewness';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":[{"assetReturns":[]}]}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"assets": @[ @{ @"assetReturns": @[  ] } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/assets/skewness"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/assets/skewness" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ]\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/assets/skewness",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'assets' => [
        [
                'assetReturns' => [
                                
                ]
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/assets/skewness', [
  'body' => '{
  "assets": [
    {
      "assetReturns": []
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/assets/skewness');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'assets' => [
    [
        'assetReturns' => [
                
        ]
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'assets' => [
    [
        'assetReturns' => [
                
        ]
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/assets/skewness');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/assets/skewness' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": [
    {
      "assetReturns": []
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/assets/skewness' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": [
    {
      "assetReturns": []
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/assets/skewness", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/assets/skewness"

payload = { "assets": [{ "assetReturns": [] }] }
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/assets/skewness"

payload <- "{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ]\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/assets/skewness")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ]\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/assets/skewness') do |req|
  req.body = "{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/assets/skewness";

    let payload = json!({"assets": (json!({"assetReturns": ()}))});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/assets/skewness \
  --header 'content-type: application/json' \
  --data '{
  "assets": [
    {
      "assetReturns": []
    }
  ]
}'

echo '{
  "assets": [
    {
      "assetReturns": []
    }
  ]
}' |  \
  http POST {{baseUrl}}/assets/skewness \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "assets": [\n    {\n      "assetReturns": []\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/assets/skewness

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["assets": [["assetReturns": []]]] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/assets/skewness")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "assets": [
    {
      "assetSkewness": -0.6872431934890911
    }
  ]
}

POST Variance

{{baseUrl}}/assets/variance

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/assets/variance");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/assets/variance")

require "http/client"

url = "{{baseUrl}}/assets/variance"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/assets/variance"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/assets/variance");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/assets/variance"

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

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

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

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

}

POST /baseUrl/assets/variance HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/assets/variance")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/assets/variance"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/assets/variance")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/assets/variance")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/assets/variance');

xhr.send(data);

import axios from 'axios';

const options = {method: 'POST', url: '{{baseUrl}}/assets/variance'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/assets/variance';
const options = {method: 'POST'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/assets/variance',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/assets/variance")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/assets/variance',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'POST', url: '{{baseUrl}}/assets/variance'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/assets/variance');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'POST', url: '{{baseUrl}}/assets/variance'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/assets/variance';
const options = {method: 'POST'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/assets/variance"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/assets/variance" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/assets/variance",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/assets/variance');

echo $response->getBody();

setUrl('{{baseUrl}}/assets/variance');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/assets/variance');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/assets/variance' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/assets/variance' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = ""

conn.request("POST", "/baseUrl/assets/variance", payload)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/assets/variance"

payload = ""

response = requests.post(url, data=payload)

print(response.json())

library(httr)

url <- "{{baseUrl}}/assets/variance"

payload <- ""

response <- VERB("POST", url, body = payload, content_type(""))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/assets/variance")

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

request = Net::HTTP::Post.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/assets/variance') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/assets/variance";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/assets/variance

http POST {{baseUrl}}/assets/variance

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/assets/variance

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/assets/variance")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "assets": [
    {
      "assetVariance": 0.01
    },
    {
      "assetVariance": 0.0025
    }
  ]
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "assets": [
    {
      "assetVariance": 0.00035
    },
    {
      "assetVariance": 0.00035
    }
  ]
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "assets": [
    {
      "assetVariance": 0.010000000000000002
    },
    {
      "assetVariance": 0.0025000000000000005
    }
  ]
}

POST Volatility

{{baseUrl}}/assets/volatility

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/assets/volatility");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/assets/volatility")

require "http/client"

url = "{{baseUrl}}/assets/volatility"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/assets/volatility"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/assets/volatility");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/assets/volatility"

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

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

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

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

}

POST /baseUrl/assets/volatility HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/assets/volatility")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/assets/volatility"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/assets/volatility")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/assets/volatility")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/assets/volatility');

xhr.send(data);

import axios from 'axios';

const options = {method: 'POST', url: '{{baseUrl}}/assets/volatility'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/assets/volatility';
const options = {method: 'POST'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/assets/volatility',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/assets/volatility")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/assets/volatility',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'POST', url: '{{baseUrl}}/assets/volatility'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/assets/volatility');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'POST', url: '{{baseUrl}}/assets/volatility'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/assets/volatility';
const options = {method: 'POST'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/assets/volatility"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/assets/volatility" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/assets/volatility",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/assets/volatility');

echo $response->getBody();

setUrl('{{baseUrl}}/assets/volatility');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/assets/volatility');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/assets/volatility' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/assets/volatility' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = ""

conn.request("POST", "/baseUrl/assets/volatility", payload)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/assets/volatility"

payload = ""

response = requests.post(url, data=payload)

print(response.json())

library(httr)

url <- "{{baseUrl}}/assets/volatility"

payload <- ""

response <- VERB("POST", url, body = payload, content_type(""))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/assets/volatility")

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

request = Net::HTTP::Post.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/assets/volatility') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/assets/volatility";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/assets/volatility

http POST {{baseUrl}}/assets/volatility

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/assets/volatility

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/assets/volatility")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "assets": [
    {
      "assetVolatility": 0.1
    },
    {
      "assetVolatility": 0.05
    }
  ]
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "assets": [
    {
      "assetVolatility": 0.01870828693386971
    },
    {
      "assetVolatility": 0.01870828693386971
    }
  ]
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "assets": [
    {
      "assetVolatility": 0.1
    },
    {
      "assetVolatility": 0.05
    }
  ]
}

POST Residualization

{{baseUrl}}/factors/residualization

BODY json

{
  "factors": [
    {
      "factorReturns": []
    }
  ],
  "residualizedFactor": 0
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/factors/residualization");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"factors\": [\n    {\n      \"factorReturns\": []\n    }\n  ],\n  \"residualizedFactor\": 0\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/factors/residualization" {:content-type :json
                                                                    :form-params {:factors [{:factorReturns []}]
                                                                                  :residualizedFactor 0}})

require "http/client"

url = "{{baseUrl}}/factors/residualization"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"factors\": [\n    {\n      \"factorReturns\": []\n    }\n  ],\n  \"residualizedFactor\": 0\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/factors/residualization"),
    Content = new StringContent("{\n  \"factors\": [\n    {\n      \"factorReturns\": []\n    }\n  ],\n  \"residualizedFactor\": 0\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/factors/residualization");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"factors\": [\n    {\n      \"factorReturns\": []\n    }\n  ],\n  \"residualizedFactor\": 0\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/factors/residualization"

	payload := strings.NewReader("{\n  \"factors\": [\n    {\n      \"factorReturns\": []\n    }\n  ],\n  \"residualizedFactor\": 0\n}")

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

	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/factors/residualization HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 87

{
  "factors": [
    {
      "factorReturns": []
    }
  ],
  "residualizedFactor": 0
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/factors/residualization")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"factors\": [\n    {\n      \"factorReturns\": []\n    }\n  ],\n  \"residualizedFactor\": 0\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/factors/residualization"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"factors\": [\n    {\n      \"factorReturns\": []\n    }\n  ],\n  \"residualizedFactor\": 0\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"factors\": [\n    {\n      \"factorReturns\": []\n    }\n  ],\n  \"residualizedFactor\": 0\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/factors/residualization")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/factors/residualization")
  .header("content-type", "application/json")
  .body("{\n  \"factors\": [\n    {\n      \"factorReturns\": []\n    }\n  ],\n  \"residualizedFactor\": 0\n}")
  .asString();

const data = JSON.stringify({
  factors: [
    {
      factorReturns: []
    }
  ],
  residualizedFactor: 0
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/factors/residualization');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/factors/residualization',
  headers: {'content-type': 'application/json'},
  data: {factors: [{factorReturns: []}], residualizedFactor: 0}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/factors/residualization';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"factors":[{"factorReturns":[]}],"residualizedFactor":0}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/factors/residualization',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "factors": [\n    {\n      "factorReturns": []\n    }\n  ],\n  "residualizedFactor": 0\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"factors\": [\n    {\n      \"factorReturns\": []\n    }\n  ],\n  \"residualizedFactor\": 0\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/factors/residualization")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/factors/residualization',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({factors: [{factorReturns: []}], residualizedFactor: 0}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/factors/residualization',
  headers: {'content-type': 'application/json'},
  body: {factors: [{factorReturns: []}], residualizedFactor: 0},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/factors/residualization');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  factors: [
    {
      factorReturns: []
    }
  ],
  residualizedFactor: 0
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/factors/residualization',
  headers: {'content-type': 'application/json'},
  data: {factors: [{factorReturns: []}], residualizedFactor: 0}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/factors/residualization';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"factors":[{"factorReturns":[]}],"residualizedFactor":0}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"factors": @[ @{ @"factorReturns": @[  ] } ],
                              @"residualizedFactor": @0 };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/factors/residualization"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/factors/residualization" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"factors\": [\n    {\n      \"factorReturns\": []\n    }\n  ],\n  \"residualizedFactor\": 0\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/factors/residualization",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'factors' => [
        [
                'factorReturns' => [
                                
                ]
        ]
    ],
    'residualizedFactor' => 0
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/factors/residualization', [
  'body' => '{
  "factors": [
    {
      "factorReturns": []
    }
  ],
  "residualizedFactor": 0
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/factors/residualization');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'factors' => [
    [
        'factorReturns' => [
                
        ]
    ]
  ],
  'residualizedFactor' => 0
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'factors' => [
    [
        'factorReturns' => [
                
        ]
    ]
  ],
  'residualizedFactor' => 0
]));
$request->setRequestUrl('{{baseUrl}}/factors/residualization');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/factors/residualization' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "factors": [
    {
      "factorReturns": []
    }
  ],
  "residualizedFactor": 0
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/factors/residualization' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "factors": [
    {
      "factorReturns": []
    }
  ],
  "residualizedFactor": 0
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"factors\": [\n    {\n      \"factorReturns\": []\n    }\n  ],\n  \"residualizedFactor\": 0\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/factors/residualization", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/factors/residualization"

payload = {
    "factors": [{ "factorReturns": [] }],
    "residualizedFactor": 0
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/factors/residualization"

payload <- "{\n  \"factors\": [\n    {\n      \"factorReturns\": []\n    }\n  ],\n  \"residualizedFactor\": 0\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/factors/residualization")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"factors\": [\n    {\n      \"factorReturns\": []\n    }\n  ],\n  \"residualizedFactor\": 0\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/factors/residualization') do |req|
  req.body = "{\n  \"factors\": [\n    {\n      \"factorReturns\": []\n    }\n  ],\n  \"residualizedFactor\": 0\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/factors/residualization";

    let payload = json!({
        "factors": (json!({"factorReturns": ()})),
        "residualizedFactor": 0
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/factors/residualization \
  --header 'content-type: application/json' \
  --data '{
  "factors": [
    {
      "factorReturns": []
    }
  ],
  "residualizedFactor": 0
}'

echo '{
  "factors": [
    {
      "factorReturns": []
    }
  ],
  "residualizedFactor": 0
}' |  \
  http POST {{baseUrl}}/factors/residualization \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "factors": [\n    {\n      "factorReturns": []\n    }\n  ],\n  "residualizedFactor": 0\n}' \
  --output-document \
  - {{baseUrl}}/factors/residualization

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "factors": [["factorReturns": []]],
  "residualizedFactor": 0
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/factors/residualization")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "residualizedFactorReturns": [
    -0.001885245901639342,
    0.017622950819672134,
    -0.0004918032786885261
  ]
}

POST Alpha

{{baseUrl}}/portfolio/analysis/alpha

BODY json

{}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/portfolio/analysis/alpha");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/portfolio/analysis/alpha" {:content-type :json})

require "http/client"

url = "{{baseUrl}}/portfolio/analysis/alpha"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/portfolio/analysis/alpha"),
    Content = new StringContent("{}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/portfolio/analysis/alpha");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/portfolio/analysis/alpha"

	payload := strings.NewReader("{}")

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

	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/portfolio/analysis/alpha HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 2

{}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/portfolio/analysis/alpha")
  .setHeader("content-type", "application/json")
  .setBody("{}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/portfolio/analysis/alpha"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/portfolio/analysis/alpha")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/portfolio/analysis/alpha")
  .header("content-type", "application/json")
  .body("{}")
  .asString();

const data = JSON.stringify({});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/portfolio/analysis/alpha');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/analysis/alpha',
  headers: {'content-type': 'application/json'},
  data: {}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/portfolio/analysis/alpha';
const options = {method: 'POST', headers: {'content-type': 'application/json'}, body: '{}'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/portfolio/analysis/alpha',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{}")
val request = Request.Builder()
  .url("{{baseUrl}}/portfolio/analysis/alpha")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/portfolio/analysis/alpha',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/analysis/alpha',
  headers: {'content-type': 'application/json'},
  body: {},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/portfolio/analysis/alpha');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/analysis/alpha',
  headers: {'content-type': 'application/json'},
  data: {}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/portfolio/analysis/alpha';
const options = {method: 'POST', headers: {'content-type': 'application/json'}, body: '{}'};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{  };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/portfolio/analysis/alpha"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/portfolio/analysis/alpha" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/portfolio/analysis/alpha",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/portfolio/analysis/alpha', [
  'body' => '{}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/portfolio/analysis/alpha');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  
]));
$request->setRequestUrl('{{baseUrl}}/portfolio/analysis/alpha');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/portfolio/analysis/alpha' -Method POST -Headers $headers -ContentType 'application/json' -Body '{}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/portfolio/analysis/alpha' -Method POST -Headers $headers -ContentType 'application/json' -Body '{}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/portfolio/analysis/alpha", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/portfolio/analysis/alpha"

payload = {}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/portfolio/analysis/alpha"

payload <- "{}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/portfolio/analysis/alpha")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/portfolio/analysis/alpha') do |req|
  req.body = "{}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/portfolio/analysis/alpha";

    let payload = json!({});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/portfolio/analysis/alpha \
  --header 'content-type: application/json' \
  --data '{}'

echo '{}' |  \
  http POST {{baseUrl}}/portfolio/analysis/alpha \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{}' \
  --output-document \
  - {{baseUrl}}/portfolio/analysis/alpha

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/portfolio/analysis/alpha")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "portfolios": [
    {
      "portfolioAlpha": -0.0006332179930795853
    }
  ]
}

POST Arithmetic Average Return (POST)

{{baseUrl}}/portfolio/analysis/returns/average

BODY json

{
  "portfolios": [
    {
      "portfolioValues": []
    }
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/portfolio/analysis/returns/average");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/portfolio/analysis/returns/average" {:content-type :json
                                                                               :form-params {:portfolios [{:portfolioValues []}]}})

require "http/client"

url = "{{baseUrl}}/portfolio/analysis/returns/average"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ]\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/portfolio/analysis/returns/average"),
    Content = new StringContent("{\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/portfolio/analysis/returns/average");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/portfolio/analysis/returns/average"

	payload := strings.NewReader("{\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ]\n}")

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

	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/portfolio/analysis/returns/average HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 65

{
  "portfolios": [
    {
      "portfolioValues": []
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/portfolio/analysis/returns/average")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/portfolio/analysis/returns/average"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/portfolio/analysis/returns/average")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/portfolio/analysis/returns/average")
  .header("content-type", "application/json")
  .body("{\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  portfolios: [
    {
      portfolioValues: []
    }
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/portfolio/analysis/returns/average');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/analysis/returns/average',
  headers: {'content-type': 'application/json'},
  data: {portfolios: [{portfolioValues: []}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/portfolio/analysis/returns/average';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"portfolios":[{"portfolioValues":[]}]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/portfolio/analysis/returns/average',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "portfolios": [\n    {\n      "portfolioValues": []\n    }\n  ]\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/portfolio/analysis/returns/average")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/portfolio/analysis/returns/average',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({portfolios: [{portfolioValues: []}]}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/analysis/returns/average',
  headers: {'content-type': 'application/json'},
  body: {portfolios: [{portfolioValues: []}]},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/portfolio/analysis/returns/average');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  portfolios: [
    {
      portfolioValues: []
    }
  ]
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/analysis/returns/average',
  headers: {'content-type': 'application/json'},
  data: {portfolios: [{portfolioValues: []}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/portfolio/analysis/returns/average';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"portfolios":[{"portfolioValues":[]}]}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"portfolios": @[ @{ @"portfolioValues": @[  ] } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/portfolio/analysis/returns/average"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/portfolio/analysis/returns/average" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ]\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/portfolio/analysis/returns/average",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'portfolios' => [
        [
                'portfolioValues' => [
                                
                ]
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/portfolio/analysis/returns/average', [
  'body' => '{
  "portfolios": [
    {
      "portfolioValues": []
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/portfolio/analysis/returns/average');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'portfolios' => [
    [
        'portfolioValues' => [
                
        ]
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'portfolios' => [
    [
        'portfolioValues' => [
                
        ]
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/portfolio/analysis/returns/average');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/portfolio/analysis/returns/average' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "portfolios": [
    {
      "portfolioValues": []
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/portfolio/analysis/returns/average' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "portfolios": [
    {
      "portfolioValues": []
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/portfolio/analysis/returns/average", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/portfolio/analysis/returns/average"

payload = { "portfolios": [{ "portfolioValues": [] }] }
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/portfolio/analysis/returns/average"

payload <- "{\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ]\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/portfolio/analysis/returns/average")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ]\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/portfolio/analysis/returns/average') do |req|
  req.body = "{\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/portfolio/analysis/returns/average";

    let payload = json!({"portfolios": (json!({"portfolioValues": ()}))});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/portfolio/analysis/returns/average \
  --header 'content-type: application/json' \
  --data '{
  "portfolios": [
    {
      "portfolioValues": []
    }
  ]
}'

echo '{
  "portfolios": [
    {
      "portfolioValues": []
    }
  ]
}' |  \
  http POST {{baseUrl}}/portfolio/analysis/returns/average \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "portfolios": [\n    {\n      "portfolioValues": []\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/portfolio/analysis/returns/average

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["portfolios": [["portfolioValues": []]]] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/portfolio/analysis/returns/average")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "portfolios": [
    {
      "portfolioAverageReturn": 0.01
    }
  ]
}

POST Arithmetic Return

{{baseUrl}}/portfolio/analysis/return

BODY json

{}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/portfolio/analysis/return");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/portfolio/analysis/return" {:content-type :json})

require "http/client"

url = "{{baseUrl}}/portfolio/analysis/return"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/portfolio/analysis/return"),
    Content = new StringContent("{}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/portfolio/analysis/return");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/portfolio/analysis/return"

	payload := strings.NewReader("{}")

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

	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/portfolio/analysis/return HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 2

{}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/portfolio/analysis/return")
  .setHeader("content-type", "application/json")
  .setBody("{}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/portfolio/analysis/return"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/portfolio/analysis/return")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/portfolio/analysis/return")
  .header("content-type", "application/json")
  .body("{}")
  .asString();

const data = JSON.stringify({});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/portfolio/analysis/return');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/analysis/return',
  headers: {'content-type': 'application/json'},
  data: {}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/portfolio/analysis/return';
const options = {method: 'POST', headers: {'content-type': 'application/json'}, body: '{}'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/portfolio/analysis/return',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{}")
val request = Request.Builder()
  .url("{{baseUrl}}/portfolio/analysis/return")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/portfolio/analysis/return',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/analysis/return',
  headers: {'content-type': 'application/json'},
  body: {},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/portfolio/analysis/return');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/analysis/return',
  headers: {'content-type': 'application/json'},
  data: {}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/portfolio/analysis/return';
const options = {method: 'POST', headers: {'content-type': 'application/json'}, body: '{}'};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{  };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/portfolio/analysis/return"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/portfolio/analysis/return" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/portfolio/analysis/return",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/portfolio/analysis/return', [
  'body' => '{}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/portfolio/analysis/return');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  
]));
$request->setRequestUrl('{{baseUrl}}/portfolio/analysis/return');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/portfolio/analysis/return' -Method POST -Headers $headers -ContentType 'application/json' -Body '{}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/portfolio/analysis/return' -Method POST -Headers $headers -ContentType 'application/json' -Body '{}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/portfolio/analysis/return", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/portfolio/analysis/return"

payload = {}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/portfolio/analysis/return"

payload <- "{}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/portfolio/analysis/return")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/portfolio/analysis/return') do |req|
  req.body = "{}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/portfolio/analysis/return";

    let payload = json!({});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/portfolio/analysis/return \
  --header 'content-type: application/json' \
  --data '{}'

echo '{}' |  \
  http POST {{baseUrl}}/portfolio/analysis/return \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{}' \
  --output-document \
  - {{baseUrl}}/portfolio/analysis/return

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/portfolio/analysis/return")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "portfolios": [
    {
      "portfolioReturn": 0.01
    },
    {
      "portfolioReturn": 0.05
    }
  ]
}

POST Beta

{{baseUrl}}/portfolio/analysis/beta

BODY json

{}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/portfolio/analysis/beta");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/portfolio/analysis/beta" {:content-type :json})

require "http/client"

url = "{{baseUrl}}/portfolio/analysis/beta"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/portfolio/analysis/beta"),
    Content = new StringContent("{}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/portfolio/analysis/beta");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/portfolio/analysis/beta"

	payload := strings.NewReader("{}")

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

	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/portfolio/analysis/beta HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 2

{}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/portfolio/analysis/beta")
  .setHeader("content-type", "application/json")
  .setBody("{}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/portfolio/analysis/beta"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/portfolio/analysis/beta")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/portfolio/analysis/beta")
  .header("content-type", "application/json")
  .body("{}")
  .asString();

const data = JSON.stringify({});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/portfolio/analysis/beta');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/analysis/beta',
  headers: {'content-type': 'application/json'},
  data: {}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/portfolio/analysis/beta';
const options = {method: 'POST', headers: {'content-type': 'application/json'}, body: '{}'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/portfolio/analysis/beta',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{}")
val request = Request.Builder()
  .url("{{baseUrl}}/portfolio/analysis/beta")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/portfolio/analysis/beta',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/analysis/beta',
  headers: {'content-type': 'application/json'},
  body: {},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/portfolio/analysis/beta');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/analysis/beta',
  headers: {'content-type': 'application/json'},
  data: {}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/portfolio/analysis/beta';
const options = {method: 'POST', headers: {'content-type': 'application/json'}, body: '{}'};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{  };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/portfolio/analysis/beta"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/portfolio/analysis/beta" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/portfolio/analysis/beta",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/portfolio/analysis/beta', [
  'body' => '{}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/portfolio/analysis/beta');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  
]));
$request->setRequestUrl('{{baseUrl}}/portfolio/analysis/beta');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/portfolio/analysis/beta' -Method POST -Headers $headers -ContentType 'application/json' -Body '{}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/portfolio/analysis/beta' -Method POST -Headers $headers -ContentType 'application/json' -Body '{}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/portfolio/analysis/beta", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/portfolio/analysis/beta"

payload = {}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/portfolio/analysis/beta"

payload <- "{}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/portfolio/analysis/beta")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/portfolio/analysis/beta') do |req|
  req.body = "{}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/portfolio/analysis/beta";

    let payload = json!({});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/portfolio/analysis/beta \
  --header 'content-type: application/json' \
  --data '{}'

echo '{}' |  \
  http POST {{baseUrl}}/portfolio/analysis/beta \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{}' \
  --output-document \
  - {{baseUrl}}/portfolio/analysis/beta

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/portfolio/analysis/beta")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "portfolios": [
    {
      "portfolioBeta": 0.9169550173010382
    }
  ]
}

POST Conditional Value At Risk

{{baseUrl}}/portfolio/analysis/conditional-value-at-risk

BODY json

{
  "alpha": "",
  "portfolios": [
    {
      "portfolioValues": []
    }
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/portfolio/analysis/conditional-value-at-risk");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"alpha\": \"\",\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/portfolio/analysis/conditional-value-at-risk" {:content-type :json
                                                                                         :form-params {:alpha ""
                                                                                                       :portfolios [{:portfolioValues []}]}})

require "http/client"

url = "{{baseUrl}}/portfolio/analysis/conditional-value-at-risk"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"alpha\": \"\",\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ]\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/portfolio/analysis/conditional-value-at-risk"),
    Content = new StringContent("{\n  \"alpha\": \"\",\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/portfolio/analysis/conditional-value-at-risk");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"alpha\": \"\",\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/portfolio/analysis/conditional-value-at-risk"

	payload := strings.NewReader("{\n  \"alpha\": \"\",\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ]\n}")

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

	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/portfolio/analysis/conditional-value-at-risk HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 80

{
  "alpha": "",
  "portfolios": [
    {
      "portfolioValues": []
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/portfolio/analysis/conditional-value-at-risk")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"alpha\": \"\",\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/portfolio/analysis/conditional-value-at-risk"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"alpha\": \"\",\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"alpha\": \"\",\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/portfolio/analysis/conditional-value-at-risk")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/portfolio/analysis/conditional-value-at-risk")
  .header("content-type", "application/json")
  .body("{\n  \"alpha\": \"\",\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  alpha: '',
  portfolios: [
    {
      portfolioValues: []
    }
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/portfolio/analysis/conditional-value-at-risk');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/analysis/conditional-value-at-risk',
  headers: {'content-type': 'application/json'},
  data: {alpha: '', portfolios: [{portfolioValues: []}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/portfolio/analysis/conditional-value-at-risk';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"alpha":"","portfolios":[{"portfolioValues":[]}]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/portfolio/analysis/conditional-value-at-risk',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "alpha": "",\n  "portfolios": [\n    {\n      "portfolioValues": []\n    }\n  ]\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"alpha\": \"\",\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/portfolio/analysis/conditional-value-at-risk")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/portfolio/analysis/conditional-value-at-risk',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({alpha: '', portfolios: [{portfolioValues: []}]}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/analysis/conditional-value-at-risk',
  headers: {'content-type': 'application/json'},
  body: {alpha: '', portfolios: [{portfolioValues: []}]},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/portfolio/analysis/conditional-value-at-risk');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  alpha: '',
  portfolios: [
    {
      portfolioValues: []
    }
  ]
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/analysis/conditional-value-at-risk',
  headers: {'content-type': 'application/json'},
  data: {alpha: '', portfolios: [{portfolioValues: []}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/portfolio/analysis/conditional-value-at-risk';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"alpha":"","portfolios":[{"portfolioValues":[]}]}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"alpha": @"",
                              @"portfolios": @[ @{ @"portfolioValues": @[  ] } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/portfolio/analysis/conditional-value-at-risk"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/portfolio/analysis/conditional-value-at-risk" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"alpha\": \"\",\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ]\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/portfolio/analysis/conditional-value-at-risk",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'alpha' => '',
    'portfolios' => [
        [
                'portfolioValues' => [
                                
                ]
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/portfolio/analysis/conditional-value-at-risk', [
  'body' => '{
  "alpha": "",
  "portfolios": [
    {
      "portfolioValues": []
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/portfolio/analysis/conditional-value-at-risk');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'alpha' => '',
  'portfolios' => [
    [
        'portfolioValues' => [
                
        ]
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'alpha' => '',
  'portfolios' => [
    [
        'portfolioValues' => [
                
        ]
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/portfolio/analysis/conditional-value-at-risk');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/portfolio/analysis/conditional-value-at-risk' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "alpha": "",
  "portfolios": [
    {
      "portfolioValues": []
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/portfolio/analysis/conditional-value-at-risk' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "alpha": "",
  "portfolios": [
    {
      "portfolioValues": []
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"alpha\": \"\",\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/portfolio/analysis/conditional-value-at-risk", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/portfolio/analysis/conditional-value-at-risk"

payload = {
    "alpha": "",
    "portfolios": [{ "portfolioValues": [] }]
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/portfolio/analysis/conditional-value-at-risk"

payload <- "{\n  \"alpha\": \"\",\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ]\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/portfolio/analysis/conditional-value-at-risk")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"alpha\": \"\",\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ]\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/portfolio/analysis/conditional-value-at-risk') do |req|
  req.body = "{\n  \"alpha\": \"\",\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/portfolio/analysis/conditional-value-at-risk";

    let payload = json!({
        "alpha": "",
        "portfolios": (json!({"portfolioValues": ()}))
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/portfolio/analysis/conditional-value-at-risk \
  --header 'content-type: application/json' \
  --data '{
  "alpha": "",
  "portfolios": [
    {
      "portfolioValues": []
    }
  ]
}'

echo '{
  "alpha": "",
  "portfolios": [
    {
      "portfolioValues": []
    }
  ]
}' |  \
  http POST {{baseUrl}}/portfolio/analysis/conditional-value-at-risk \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "alpha": "",\n  "portfolios": [\n    {\n      "portfolioValues": []\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/portfolio/analysis/conditional-value-at-risk

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "alpha": "",
  "portfolios": [["portfolioValues": []]]
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/portfolio/analysis/conditional-value-at-risk")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "portfolios": [
    {
      "portfolioConditionalValueAtRisk": 0.17647058823529413
    }
  ]
}

POST Correlation Spectrum

{{baseUrl}}/portfolio/analysis/correlation-spectrum

BODY json

{}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/portfolio/analysis/correlation-spectrum");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/portfolio/analysis/correlation-spectrum" {:content-type :json})

require "http/client"

url = "{{baseUrl}}/portfolio/analysis/correlation-spectrum"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/portfolio/analysis/correlation-spectrum"),
    Content = new StringContent("{}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/portfolio/analysis/correlation-spectrum");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/portfolio/analysis/correlation-spectrum"

	payload := strings.NewReader("{}")

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

	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/portfolio/analysis/correlation-spectrum HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 2

{}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/portfolio/analysis/correlation-spectrum")
  .setHeader("content-type", "application/json")
  .setBody("{}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/portfolio/analysis/correlation-spectrum"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/portfolio/analysis/correlation-spectrum")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/portfolio/analysis/correlation-spectrum")
  .header("content-type", "application/json")
  .body("{}")
  .asString();

const data = JSON.stringify({});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/portfolio/analysis/correlation-spectrum');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/analysis/correlation-spectrum',
  headers: {'content-type': 'application/json'},
  data: {}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/portfolio/analysis/correlation-spectrum';
const options = {method: 'POST', headers: {'content-type': 'application/json'}, body: '{}'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/portfolio/analysis/correlation-spectrum',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{}")
val request = Request.Builder()
  .url("{{baseUrl}}/portfolio/analysis/correlation-spectrum")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/portfolio/analysis/correlation-spectrum',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/analysis/correlation-spectrum',
  headers: {'content-type': 'application/json'},
  body: {},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/portfolio/analysis/correlation-spectrum');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/analysis/correlation-spectrum',
  headers: {'content-type': 'application/json'},
  data: {}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/portfolio/analysis/correlation-spectrum';
const options = {method: 'POST', headers: {'content-type': 'application/json'}, body: '{}'};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{  };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/portfolio/analysis/correlation-spectrum"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/portfolio/analysis/correlation-spectrum" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/portfolio/analysis/correlation-spectrum",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/portfolio/analysis/correlation-spectrum', [
  'body' => '{}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/portfolio/analysis/correlation-spectrum');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  
]));
$request->setRequestUrl('{{baseUrl}}/portfolio/analysis/correlation-spectrum');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/portfolio/analysis/correlation-spectrum' -Method POST -Headers $headers -ContentType 'application/json' -Body '{}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/portfolio/analysis/correlation-spectrum' -Method POST -Headers $headers -ContentType 'application/json' -Body '{}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/portfolio/analysis/correlation-spectrum", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/portfolio/analysis/correlation-spectrum"

payload = {}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/portfolio/analysis/correlation-spectrum"

payload <- "{}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/portfolio/analysis/correlation-spectrum")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/portfolio/analysis/correlation-spectrum') do |req|
  req.body = "{}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/portfolio/analysis/correlation-spectrum";

    let payload = json!({});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/portfolio/analysis/correlation-spectrum \
  --header 'content-type: application/json' \
  --data '{}'

echo '{}' |  \
  http POST {{baseUrl}}/portfolio/analysis/correlation-spectrum \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{}' \
  --output-document \
  - {{baseUrl}}/portfolio/analysis/correlation-spectrum

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/portfolio/analysis/correlation-spectrum")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "portfolios": [
    {
      "portfolioCorrelationSpectrum": [
        0.9543679526112243,
        0.5767242991086425,
        0.9573818866065777
      ]
    }
  ]
}

POST Diversification Ratio

{{baseUrl}}/portfolio/analysis/diversification-ratio

BODY json

{}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/portfolio/analysis/diversification-ratio");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/portfolio/analysis/diversification-ratio" {:content-type :json})

require "http/client"

url = "{{baseUrl}}/portfolio/analysis/diversification-ratio"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/portfolio/analysis/diversification-ratio"),
    Content = new StringContent("{}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/portfolio/analysis/diversification-ratio");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/portfolio/analysis/diversification-ratio"

	payload := strings.NewReader("{}")

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

	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/portfolio/analysis/diversification-ratio HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 2

{}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/portfolio/analysis/diversification-ratio")
  .setHeader("content-type", "application/json")
  .setBody("{}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/portfolio/analysis/diversification-ratio"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/portfolio/analysis/diversification-ratio")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/portfolio/analysis/diversification-ratio")
  .header("content-type", "application/json")
  .body("{}")
  .asString();

const data = JSON.stringify({});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/portfolio/analysis/diversification-ratio');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/analysis/diversification-ratio',
  headers: {'content-type': 'application/json'},
  data: {}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/portfolio/analysis/diversification-ratio';
const options = {method: 'POST', headers: {'content-type': 'application/json'}, body: '{}'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/portfolio/analysis/diversification-ratio',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{}")
val request = Request.Builder()
  .url("{{baseUrl}}/portfolio/analysis/diversification-ratio")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/portfolio/analysis/diversification-ratio',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/analysis/diversification-ratio',
  headers: {'content-type': 'application/json'},
  body: {},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/portfolio/analysis/diversification-ratio');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/analysis/diversification-ratio',
  headers: {'content-type': 'application/json'},
  data: {}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/portfolio/analysis/diversification-ratio';
const options = {method: 'POST', headers: {'content-type': 'application/json'}, body: '{}'};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{  };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/portfolio/analysis/diversification-ratio"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/portfolio/analysis/diversification-ratio" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/portfolio/analysis/diversification-ratio",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/portfolio/analysis/diversification-ratio', [
  'body' => '{}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/portfolio/analysis/diversification-ratio');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  
]));
$request->setRequestUrl('{{baseUrl}}/portfolio/analysis/diversification-ratio');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/portfolio/analysis/diversification-ratio' -Method POST -Headers $headers -ContentType 'application/json' -Body '{}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/portfolio/analysis/diversification-ratio' -Method POST -Headers $headers -ContentType 'application/json' -Body '{}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/portfolio/analysis/diversification-ratio", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/portfolio/analysis/diversification-ratio"

payload = {}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/portfolio/analysis/diversification-ratio"

payload <- "{}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/portfolio/analysis/diversification-ratio")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/portfolio/analysis/diversification-ratio') do |req|
  req.body = "{}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/portfolio/analysis/diversification-ratio";

    let payload = json!({});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/portfolio/analysis/diversification-ratio \
  --header 'content-type: application/json' \
  --data '{}'

echo '{}' |  \
  http POST {{baseUrl}}/portfolio/analysis/diversification-ratio \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{}' \
  --output-document \
  - {{baseUrl}}/portfolio/analysis/diversification-ratio

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/portfolio/analysis/diversification-ratio")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "portfolios": [
    {
      "portfolioDiversificationRatio": 1.2909944487358058
    }
  ]
}

POST Drawdowns

{{baseUrl}}/portfolio/analysis/drawdowns

BODY json

{
  "portfolios": [
    {
      "portfolioValues": []
    }
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/portfolio/analysis/drawdowns");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/portfolio/analysis/drawdowns" {:content-type :json
                                                                         :form-params {:portfolios [{:portfolioValues []}]}})

require "http/client"

url = "{{baseUrl}}/portfolio/analysis/drawdowns"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ]\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/portfolio/analysis/drawdowns"),
    Content = new StringContent("{\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/portfolio/analysis/drawdowns");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/portfolio/analysis/drawdowns"

	payload := strings.NewReader("{\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ]\n}")

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

	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/portfolio/analysis/drawdowns HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 65

{
  "portfolios": [
    {
      "portfolioValues": []
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/portfolio/analysis/drawdowns")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/portfolio/analysis/drawdowns"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/portfolio/analysis/drawdowns")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/portfolio/analysis/drawdowns")
  .header("content-type", "application/json")
  .body("{\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  portfolios: [
    {
      portfolioValues: []
    }
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/portfolio/analysis/drawdowns');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/analysis/drawdowns',
  headers: {'content-type': 'application/json'},
  data: {portfolios: [{portfolioValues: []}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/portfolio/analysis/drawdowns';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"portfolios":[{"portfolioValues":[]}]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/portfolio/analysis/drawdowns',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "portfolios": [\n    {\n      "portfolioValues": []\n    }\n  ]\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/portfolio/analysis/drawdowns")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/portfolio/analysis/drawdowns',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({portfolios: [{portfolioValues: []}]}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/analysis/drawdowns',
  headers: {'content-type': 'application/json'},
  body: {portfolios: [{portfolioValues: []}]},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/portfolio/analysis/drawdowns');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  portfolios: [
    {
      portfolioValues: []
    }
  ]
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/analysis/drawdowns',
  headers: {'content-type': 'application/json'},
  data: {portfolios: [{portfolioValues: []}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/portfolio/analysis/drawdowns';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"portfolios":[{"portfolioValues":[]}]}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"portfolios": @[ @{ @"portfolioValues": @[  ] } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/portfolio/analysis/drawdowns"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/portfolio/analysis/drawdowns" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ]\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/portfolio/analysis/drawdowns",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'portfolios' => [
        [
                'portfolioValues' => [
                                
                ]
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/portfolio/analysis/drawdowns', [
  'body' => '{
  "portfolios": [
    {
      "portfolioValues": []
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/portfolio/analysis/drawdowns');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'portfolios' => [
    [
        'portfolioValues' => [
                
        ]
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'portfolios' => [
    [
        'portfolioValues' => [
                
        ]
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/portfolio/analysis/drawdowns');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/portfolio/analysis/drawdowns' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "portfolios": [
    {
      "portfolioValues": []
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/portfolio/analysis/drawdowns' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "portfolios": [
    {
      "portfolioValues": []
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/portfolio/analysis/drawdowns", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/portfolio/analysis/drawdowns"

payload = { "portfolios": [{ "portfolioValues": [] }] }
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/portfolio/analysis/drawdowns"

payload <- "{\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ]\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/portfolio/analysis/drawdowns")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ]\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/portfolio/analysis/drawdowns') do |req|
  req.body = "{\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/portfolio/analysis/drawdowns";

    let payload = json!({"portfolios": (json!({"portfolioValues": ()}))});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/portfolio/analysis/drawdowns \
  --header 'content-type: application/json' \
  --data '{
  "portfolios": [
    {
      "portfolioValues": []
    }
  ]
}'

echo '{
  "portfolios": [
    {
      "portfolioValues": []
    }
  ]
}' |  \
  http POST {{baseUrl}}/portfolio/analysis/drawdowns \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "portfolios": [\n    {\n      "portfolioValues": []\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/portfolio/analysis/drawdowns

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["portfolios": [["portfolioValues": []]]] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/portfolio/analysis/drawdowns")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "portfolios": [
    {
      "portfolioDrawdowns": [
        0,
        0.05,
        0,
        0.1,
        0.15,
        0.3
      ],
      "portfolioWorstDrawdowns": [
        {
          "drawdownBottom": 6,
          "drawdownDepth": 0.3,
          "drawdownEnd": 0,
          "drawdownStart": 3
        },
        {
          "drawdownBottom": 2,
          "drawdownDepth": 0.05,
          "drawdownEnd": 3,
          "drawdownStart": 1
        }
      ]
    }
  ]
}

POST Effective Number of Bets

{{baseUrl}}/portfolio/analysis/effective-number-of-bets

BODY json

{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "factorsExtractionMethod": "",
  "portfolios": [
    {
      "assetsWeights": []
    }
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/portfolio/analysis/effective-number-of-bets");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"factorsExtractionMethod\": \"\",\n  \"portfolios\": [\n    {\n      \"assetsWeights\": []\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/portfolio/analysis/effective-number-of-bets" {:content-type :json
                                                                                        :form-params {:assets 0
                                                                                                      :assetsCovarianceMatrix []
                                                                                                      :factorsExtractionMethod ""
                                                                                                      :portfolios [{:assetsWeights []}]}})

require "http/client"

url = "{{baseUrl}}/portfolio/analysis/effective-number-of-bets"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"factorsExtractionMethod\": \"\",\n  \"portfolios\": [\n    {\n      \"assetsWeights\": []\n    }\n  ]\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/portfolio/analysis/effective-number-of-bets"),
    Content = new StringContent("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"factorsExtractionMethod\": \"\",\n  \"portfolios\": [\n    {\n      \"assetsWeights\": []\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/portfolio/analysis/effective-number-of-bets");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"factorsExtractionMethod\": \"\",\n  \"portfolios\": [\n    {\n      \"assetsWeights\": []\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/portfolio/analysis/effective-number-of-bets"

	payload := strings.NewReader("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"factorsExtractionMethod\": \"\",\n  \"portfolios\": [\n    {\n      \"assetsWeights\": []\n    }\n  ]\n}")

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

	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/portfolio/analysis/effective-number-of-bets HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 143

{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "factorsExtractionMethod": "",
  "portfolios": [
    {
      "assetsWeights": []
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/portfolio/analysis/effective-number-of-bets")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"factorsExtractionMethod\": \"\",\n  \"portfolios\": [\n    {\n      \"assetsWeights\": []\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/portfolio/analysis/effective-number-of-bets"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"factorsExtractionMethod\": \"\",\n  \"portfolios\": [\n    {\n      \"assetsWeights\": []\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"factorsExtractionMethod\": \"\",\n  \"portfolios\": [\n    {\n      \"assetsWeights\": []\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/portfolio/analysis/effective-number-of-bets")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/portfolio/analysis/effective-number-of-bets")
  .header("content-type", "application/json")
  .body("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"factorsExtractionMethod\": \"\",\n  \"portfolios\": [\n    {\n      \"assetsWeights\": []\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  assets: 0,
  assetsCovarianceMatrix: [],
  factorsExtractionMethod: '',
  portfolios: [
    {
      assetsWeights: []
    }
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/portfolio/analysis/effective-number-of-bets');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/analysis/effective-number-of-bets',
  headers: {'content-type': 'application/json'},
  data: {
    assets: 0,
    assetsCovarianceMatrix: [],
    factorsExtractionMethod: '',
    portfolios: [{assetsWeights: []}]
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/portfolio/analysis/effective-number-of-bets';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":0,"assetsCovarianceMatrix":[],"factorsExtractionMethod":"","portfolios":[{"assetsWeights":[]}]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/portfolio/analysis/effective-number-of-bets',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "assets": 0,\n  "assetsCovarianceMatrix": [],\n  "factorsExtractionMethod": "",\n  "portfolios": [\n    {\n      "assetsWeights": []\n    }\n  ]\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"factorsExtractionMethod\": \"\",\n  \"portfolios\": [\n    {\n      \"assetsWeights\": []\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/portfolio/analysis/effective-number-of-bets")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/portfolio/analysis/effective-number-of-bets',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  assets: 0,
  assetsCovarianceMatrix: [],
  factorsExtractionMethod: '',
  portfolios: [{assetsWeights: []}]
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/analysis/effective-number-of-bets',
  headers: {'content-type': 'application/json'},
  body: {
    assets: 0,
    assetsCovarianceMatrix: [],
    factorsExtractionMethod: '',
    portfolios: [{assetsWeights: []}]
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/portfolio/analysis/effective-number-of-bets');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  assets: 0,
  assetsCovarianceMatrix: [],
  factorsExtractionMethod: '',
  portfolios: [
    {
      assetsWeights: []
    }
  ]
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/analysis/effective-number-of-bets',
  headers: {'content-type': 'application/json'},
  data: {
    assets: 0,
    assetsCovarianceMatrix: [],
    factorsExtractionMethod: '',
    portfolios: [{assetsWeights: []}]
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/portfolio/analysis/effective-number-of-bets';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":0,"assetsCovarianceMatrix":[],"factorsExtractionMethod":"","portfolios":[{"assetsWeights":[]}]}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"assets": @0,
                              @"assetsCovarianceMatrix": @[  ],
                              @"factorsExtractionMethod": @"",
                              @"portfolios": @[ @{ @"assetsWeights": @[  ] } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/portfolio/analysis/effective-number-of-bets"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/portfolio/analysis/effective-number-of-bets" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"factorsExtractionMethod\": \"\",\n  \"portfolios\": [\n    {\n      \"assetsWeights\": []\n    }\n  ]\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/portfolio/analysis/effective-number-of-bets",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'assets' => 0,
    'assetsCovarianceMatrix' => [
        
    ],
    'factorsExtractionMethod' => '',
    'portfolios' => [
        [
                'assetsWeights' => [
                                
                ]
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/portfolio/analysis/effective-number-of-bets', [
  'body' => '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "factorsExtractionMethod": "",
  "portfolios": [
    {
      "assetsWeights": []
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/portfolio/analysis/effective-number-of-bets');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'assets' => 0,
  'assetsCovarianceMatrix' => [
    
  ],
  'factorsExtractionMethod' => '',
  'portfolios' => [
    [
        'assetsWeights' => [
                
        ]
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'assets' => 0,
  'assetsCovarianceMatrix' => [
    
  ],
  'factorsExtractionMethod' => '',
  'portfolios' => [
    [
        'assetsWeights' => [
                
        ]
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/portfolio/analysis/effective-number-of-bets');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/portfolio/analysis/effective-number-of-bets' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "factorsExtractionMethod": "",
  "portfolios": [
    {
      "assetsWeights": []
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/portfolio/analysis/effective-number-of-bets' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "factorsExtractionMethod": "",
  "portfolios": [
    {
      "assetsWeights": []
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"factorsExtractionMethod\": \"\",\n  \"portfolios\": [\n    {\n      \"assetsWeights\": []\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/portfolio/analysis/effective-number-of-bets", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/portfolio/analysis/effective-number-of-bets"

payload = {
    "assets": 0,
    "assetsCovarianceMatrix": [],
    "factorsExtractionMethod": "",
    "portfolios": [{ "assetsWeights": [] }]
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/portfolio/analysis/effective-number-of-bets"

payload <- "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"factorsExtractionMethod\": \"\",\n  \"portfolios\": [\n    {\n      \"assetsWeights\": []\n    }\n  ]\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/portfolio/analysis/effective-number-of-bets")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"factorsExtractionMethod\": \"\",\n  \"portfolios\": [\n    {\n      \"assetsWeights\": []\n    }\n  ]\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/portfolio/analysis/effective-number-of-bets') do |req|
  req.body = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"factorsExtractionMethod\": \"\",\n  \"portfolios\": [\n    {\n      \"assetsWeights\": []\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/portfolio/analysis/effective-number-of-bets";

    let payload = json!({
        "assets": 0,
        "assetsCovarianceMatrix": (),
        "factorsExtractionMethod": "",
        "portfolios": (json!({"assetsWeights": ()}))
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/portfolio/analysis/effective-number-of-bets \
  --header 'content-type: application/json' \
  --data '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "factorsExtractionMethod": "",
  "portfolios": [
    {
      "assetsWeights": []
    }
  ]
}'

echo '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "factorsExtractionMethod": "",
  "portfolios": [
    {
      "assetsWeights": []
    }
  ]
}' |  \
  http POST {{baseUrl}}/portfolio/analysis/effective-number-of-bets \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "assets": 0,\n  "assetsCovarianceMatrix": [],\n  "factorsExtractionMethod": "",\n  "portfolios": [\n    {\n      "assetsWeights": []\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/portfolio/analysis/effective-number-of-bets

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "factorsExtractionMethod": "",
  "portfolios": [["assetsWeights": []]]
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/portfolio/analysis/effective-number-of-bets")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "portfolios": [
    {
      "portfolioEffectiveNumberOfBets": 2.3564325389900276
    }
  ]
}

POST Factor Exposures

{{baseUrl}}/portfolio/analysis/factors/exposures

BODY json

{
  "factors": [
    {
      "factorReturns": []
    }
  ],
  "portfolios": [
    {
      "portfolioReturns": []
    }
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/portfolio/analysis/factors/exposures");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"factors\": [\n    {\n      \"factorReturns\": []\n    }\n  ],\n  \"portfolios\": [\n    {\n      \"portfolioReturns\": []\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/portfolio/analysis/factors/exposures" {:content-type :json
                                                                                 :form-params {:factors [{:factorReturns []}]
                                                                                               :portfolios [{:portfolioReturns []}]}})

require "http/client"

url = "{{baseUrl}}/portfolio/analysis/factors/exposures"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"factors\": [\n    {\n      \"factorReturns\": []\n    }\n  ],\n  \"portfolios\": [\n    {\n      \"portfolioReturns\": []\n    }\n  ]\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/portfolio/analysis/factors/exposures"),
    Content = new StringContent("{\n  \"factors\": [\n    {\n      \"factorReturns\": []\n    }\n  ],\n  \"portfolios\": [\n    {\n      \"portfolioReturns\": []\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/portfolio/analysis/factors/exposures");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"factors\": [\n    {\n      \"factorReturns\": []\n    }\n  ],\n  \"portfolios\": [\n    {\n      \"portfolioReturns\": []\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/portfolio/analysis/factors/exposures"

	payload := strings.NewReader("{\n  \"factors\": [\n    {\n      \"factorReturns\": []\n    }\n  ],\n  \"portfolios\": [\n    {\n      \"portfolioReturns\": []\n    }\n  ]\n}")

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

	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/portfolio/analysis/factors/exposures HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 124

{
  "factors": [
    {
      "factorReturns": []
    }
  ],
  "portfolios": [
    {
      "portfolioReturns": []
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/portfolio/analysis/factors/exposures")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"factors\": [\n    {\n      \"factorReturns\": []\n    }\n  ],\n  \"portfolios\": [\n    {\n      \"portfolioReturns\": []\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/portfolio/analysis/factors/exposures"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"factors\": [\n    {\n      \"factorReturns\": []\n    }\n  ],\n  \"portfolios\": [\n    {\n      \"portfolioReturns\": []\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"factors\": [\n    {\n      \"factorReturns\": []\n    }\n  ],\n  \"portfolios\": [\n    {\n      \"portfolioReturns\": []\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/portfolio/analysis/factors/exposures")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/portfolio/analysis/factors/exposures")
  .header("content-type", "application/json")
  .body("{\n  \"factors\": [\n    {\n      \"factorReturns\": []\n    }\n  ],\n  \"portfolios\": [\n    {\n      \"portfolioReturns\": []\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  factors: [
    {
      factorReturns: []
    }
  ],
  portfolios: [
    {
      portfolioReturns: []
    }
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/portfolio/analysis/factors/exposures');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/analysis/factors/exposures',
  headers: {'content-type': 'application/json'},
  data: {factors: [{factorReturns: []}], portfolios: [{portfolioReturns: []}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/portfolio/analysis/factors/exposures';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"factors":[{"factorReturns":[]}],"portfolios":[{"portfolioReturns":[]}]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/portfolio/analysis/factors/exposures',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "factors": [\n    {\n      "factorReturns": []\n    }\n  ],\n  "portfolios": [\n    {\n      "portfolioReturns": []\n    }\n  ]\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"factors\": [\n    {\n      \"factorReturns\": []\n    }\n  ],\n  \"portfolios\": [\n    {\n      \"portfolioReturns\": []\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/portfolio/analysis/factors/exposures")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/portfolio/analysis/factors/exposures',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({factors: [{factorReturns: []}], portfolios: [{portfolioReturns: []}]}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/analysis/factors/exposures',
  headers: {'content-type': 'application/json'},
  body: {factors: [{factorReturns: []}], portfolios: [{portfolioReturns: []}]},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/portfolio/analysis/factors/exposures');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  factors: [
    {
      factorReturns: []
    }
  ],
  portfolios: [
    {
      portfolioReturns: []
    }
  ]
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/analysis/factors/exposures',
  headers: {'content-type': 'application/json'},
  data: {factors: [{factorReturns: []}], portfolios: [{portfolioReturns: []}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/portfolio/analysis/factors/exposures';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"factors":[{"factorReturns":[]}],"portfolios":[{"portfolioReturns":[]}]}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"factors": @[ @{ @"factorReturns": @[  ] } ],
                              @"portfolios": @[ @{ @"portfolioReturns": @[  ] } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/portfolio/analysis/factors/exposures"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/portfolio/analysis/factors/exposures" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"factors\": [\n    {\n      \"factorReturns\": []\n    }\n  ],\n  \"portfolios\": [\n    {\n      \"portfolioReturns\": []\n    }\n  ]\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/portfolio/analysis/factors/exposures",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'factors' => [
        [
                'factorReturns' => [
                                
                ]
        ]
    ],
    'portfolios' => [
        [
                'portfolioReturns' => [
                                
                ]
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/portfolio/analysis/factors/exposures', [
  'body' => '{
  "factors": [
    {
      "factorReturns": []
    }
  ],
  "portfolios": [
    {
      "portfolioReturns": []
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/portfolio/analysis/factors/exposures');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'factors' => [
    [
        'factorReturns' => [
                
        ]
    ]
  ],
  'portfolios' => [
    [
        'portfolioReturns' => [
                
        ]
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'factors' => [
    [
        'factorReturns' => [
                
        ]
    ]
  ],
  'portfolios' => [
    [
        'portfolioReturns' => [
                
        ]
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/portfolio/analysis/factors/exposures');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/portfolio/analysis/factors/exposures' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "factors": [
    {
      "factorReturns": []
    }
  ],
  "portfolios": [
    {
      "portfolioReturns": []
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/portfolio/analysis/factors/exposures' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "factors": [
    {
      "factorReturns": []
    }
  ],
  "portfolios": [
    {
      "portfolioReturns": []
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"factors\": [\n    {\n      \"factorReturns\": []\n    }\n  ],\n  \"portfolios\": [\n    {\n      \"portfolioReturns\": []\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/portfolio/analysis/factors/exposures", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/portfolio/analysis/factors/exposures"

payload = {
    "factors": [{ "factorReturns": [] }],
    "portfolios": [{ "portfolioReturns": [] }]
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/portfolio/analysis/factors/exposures"

payload <- "{\n  \"factors\": [\n    {\n      \"factorReturns\": []\n    }\n  ],\n  \"portfolios\": [\n    {\n      \"portfolioReturns\": []\n    }\n  ]\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/portfolio/analysis/factors/exposures")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"factors\": [\n    {\n      \"factorReturns\": []\n    }\n  ],\n  \"portfolios\": [\n    {\n      \"portfolioReturns\": []\n    }\n  ]\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/portfolio/analysis/factors/exposures') do |req|
  req.body = "{\n  \"factors\": [\n    {\n      \"factorReturns\": []\n    }\n  ],\n  \"portfolios\": [\n    {\n      \"portfolioReturns\": []\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/portfolio/analysis/factors/exposures";

    let payload = json!({
        "factors": (json!({"factorReturns": ()})),
        "portfolios": (json!({"portfolioReturns": ()}))
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/portfolio/analysis/factors/exposures \
  --header 'content-type: application/json' \
  --data '{
  "factors": [
    {
      "factorReturns": []
    }
  ],
  "portfolios": [
    {
      "portfolioReturns": []
    }
  ]
}'

echo '{
  "factors": [
    {
      "factorReturns": []
    }
  ],
  "portfolios": [
    {
      "portfolioReturns": []
    }
  ]
}' |  \
  http POST {{baseUrl}}/portfolio/analysis/factors/exposures \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "factors": [\n    {\n      "factorReturns": []\n    }\n  ],\n  "portfolios": [\n    {\n      "portfolioReturns": []\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/portfolio/analysis/factors/exposures

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "factors": [["factorReturns": []]],
  "portfolios": [["portfolioReturns": []]]
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/portfolio/analysis/factors/exposures")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "portfolios": [
    {
      "portfolioAlpha": -0.000017563172006410804,
      "portfolioBetas": [
        3.083191766752847,
        2.17931822921701
      ],
      "portfolioRSquared": 1
    }
  ]
}

POST Mean-Variance Efficient Frontier

{{baseUrl}}/portfolio/analysis/mean-variance/efficient-frontier

BODY json

{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  },
  "portfolios": 0
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/portfolio/analysis/mean-variance/efficient-frontier");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"portfolios\": 0\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/portfolio/analysis/mean-variance/efficient-frontier" {:content-type :json
                                                                                                :form-params {:assets 0
                                                                                                              :assetsCovarianceMatrix []
                                                                                                              :assetsReturns []
                                                                                                              :constraints {:assetsGroups []
                                                                                                                            :assetsGroupsMatrix []
                                                                                                                            :maximumAssetsGroupsWeights []
                                                                                                                            :maximumAssetsWeights []
                                                                                                                            :maximumPortfolioExposure ""
                                                                                                                            :minimumAssetsWeights []
                                                                                                                            :minimumPortfolioExposure ""}
                                                                                                              :portfolios 0}})

require "http/client"

url = "{{baseUrl}}/portfolio/analysis/mean-variance/efficient-frontier"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"portfolios\": 0\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/portfolio/analysis/mean-variance/efficient-frontier"),
    Content = new StringContent("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"portfolios\": 0\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/portfolio/analysis/mean-variance/efficient-frontier");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"portfolios\": 0\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/portfolio/analysis/mean-variance/efficient-frontier"

	payload := strings.NewReader("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"portfolios\": 0\n}")

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

	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/portfolio/analysis/mean-variance/efficient-frontier HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 342

{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  },
  "portfolios": 0
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/portfolio/analysis/mean-variance/efficient-frontier")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"portfolios\": 0\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/portfolio/analysis/mean-variance/efficient-frontier"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"portfolios\": 0\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"portfolios\": 0\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/portfolio/analysis/mean-variance/efficient-frontier")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/portfolio/analysis/mean-variance/efficient-frontier")
  .header("content-type", "application/json")
  .body("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"portfolios\": 0\n}")
  .asString();

const data = JSON.stringify({
  assets: 0,
  assetsCovarianceMatrix: [],
  assetsReturns: [],
  constraints: {
    assetsGroups: [],
    assetsGroupsMatrix: [],
    maximumAssetsGroupsWeights: [],
    maximumAssetsWeights: [],
    maximumPortfolioExposure: '',
    minimumAssetsWeights: [],
    minimumPortfolioExposure: ''
  },
  portfolios: 0
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/portfolio/analysis/mean-variance/efficient-frontier');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/analysis/mean-variance/efficient-frontier',
  headers: {'content-type': 'application/json'},
  data: {
    assets: 0,
    assetsCovarianceMatrix: [],
    assetsReturns: [],
    constraints: {
      assetsGroups: [],
      assetsGroupsMatrix: [],
      maximumAssetsGroupsWeights: [],
      maximumAssetsWeights: [],
      maximumPortfolioExposure: '',
      minimumAssetsWeights: [],
      minimumPortfolioExposure: ''
    },
    portfolios: 0
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/portfolio/analysis/mean-variance/efficient-frontier';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":0,"assetsCovarianceMatrix":[],"assetsReturns":[],"constraints":{"assetsGroups":[],"assetsGroupsMatrix":[],"maximumAssetsGroupsWeights":[],"maximumAssetsWeights":[],"maximumPortfolioExposure":"","minimumAssetsWeights":[],"minimumPortfolioExposure":""},"portfolios":0}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/portfolio/analysis/mean-variance/efficient-frontier',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "assets": 0,\n  "assetsCovarianceMatrix": [],\n  "assetsReturns": [],\n  "constraints": {\n    "assetsGroups": [],\n    "assetsGroupsMatrix": [],\n    "maximumAssetsGroupsWeights": [],\n    "maximumAssetsWeights": [],\n    "maximumPortfolioExposure": "",\n    "minimumAssetsWeights": [],\n    "minimumPortfolioExposure": ""\n  },\n  "portfolios": 0\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"portfolios\": 0\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/portfolio/analysis/mean-variance/efficient-frontier")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/portfolio/analysis/mean-variance/efficient-frontier',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  assets: 0,
  assetsCovarianceMatrix: [],
  assetsReturns: [],
  constraints: {
    assetsGroups: [],
    assetsGroupsMatrix: [],
    maximumAssetsGroupsWeights: [],
    maximumAssetsWeights: [],
    maximumPortfolioExposure: '',
    minimumAssetsWeights: [],
    minimumPortfolioExposure: ''
  },
  portfolios: 0
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/analysis/mean-variance/efficient-frontier',
  headers: {'content-type': 'application/json'},
  body: {
    assets: 0,
    assetsCovarianceMatrix: [],
    assetsReturns: [],
    constraints: {
      assetsGroups: [],
      assetsGroupsMatrix: [],
      maximumAssetsGroupsWeights: [],
      maximumAssetsWeights: [],
      maximumPortfolioExposure: '',
      minimumAssetsWeights: [],
      minimumPortfolioExposure: ''
    },
    portfolios: 0
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/portfolio/analysis/mean-variance/efficient-frontier');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  assets: 0,
  assetsCovarianceMatrix: [],
  assetsReturns: [],
  constraints: {
    assetsGroups: [],
    assetsGroupsMatrix: [],
    maximumAssetsGroupsWeights: [],
    maximumAssetsWeights: [],
    maximumPortfolioExposure: '',
    minimumAssetsWeights: [],
    minimumPortfolioExposure: ''
  },
  portfolios: 0
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/analysis/mean-variance/efficient-frontier',
  headers: {'content-type': 'application/json'},
  data: {
    assets: 0,
    assetsCovarianceMatrix: [],
    assetsReturns: [],
    constraints: {
      assetsGroups: [],
      assetsGroupsMatrix: [],
      maximumAssetsGroupsWeights: [],
      maximumAssetsWeights: [],
      maximumPortfolioExposure: '',
      minimumAssetsWeights: [],
      minimumPortfolioExposure: ''
    },
    portfolios: 0
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/portfolio/analysis/mean-variance/efficient-frontier';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":0,"assetsCovarianceMatrix":[],"assetsReturns":[],"constraints":{"assetsGroups":[],"assetsGroupsMatrix":[],"maximumAssetsGroupsWeights":[],"maximumAssetsWeights":[],"maximumPortfolioExposure":"","minimumAssetsWeights":[],"minimumPortfolioExposure":""},"portfolios":0}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"assets": @0,
                              @"assetsCovarianceMatrix": @[  ],
                              @"assetsReturns": @[  ],
                              @"constraints": @{ @"assetsGroups": @[  ], @"assetsGroupsMatrix": @[  ], @"maximumAssetsGroupsWeights": @[  ], @"maximumAssetsWeights": @[  ], @"maximumPortfolioExposure": @"", @"minimumAssetsWeights": @[  ], @"minimumPortfolioExposure": @"" },
                              @"portfolios": @0 };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/portfolio/analysis/mean-variance/efficient-frontier"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/portfolio/analysis/mean-variance/efficient-frontier" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"portfolios\": 0\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/portfolio/analysis/mean-variance/efficient-frontier",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'assets' => 0,
    'assetsCovarianceMatrix' => [
        
    ],
    'assetsReturns' => [
        
    ],
    'constraints' => [
        'assetsGroups' => [
                
        ],
        'assetsGroupsMatrix' => [
                
        ],
        'maximumAssetsGroupsWeights' => [
                
        ],
        'maximumAssetsWeights' => [
                
        ],
        'maximumPortfolioExposure' => '',
        'minimumAssetsWeights' => [
                
        ],
        'minimumPortfolioExposure' => ''
    ],
    'portfolios' => 0
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/portfolio/analysis/mean-variance/efficient-frontier', [
  'body' => '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  },
  "portfolios": 0
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/portfolio/analysis/mean-variance/efficient-frontier');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'assets' => 0,
  'assetsCovarianceMatrix' => [
    
  ],
  'assetsReturns' => [
    
  ],
  'constraints' => [
    'assetsGroups' => [
        
    ],
    'assetsGroupsMatrix' => [
        
    ],
    'maximumAssetsGroupsWeights' => [
        
    ],
    'maximumAssetsWeights' => [
        
    ],
    'maximumPortfolioExposure' => '',
    'minimumAssetsWeights' => [
        
    ],
    'minimumPortfolioExposure' => ''
  ],
  'portfolios' => 0
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'assets' => 0,
  'assetsCovarianceMatrix' => [
    
  ],
  'assetsReturns' => [
    
  ],
  'constraints' => [
    'assetsGroups' => [
        
    ],
    'assetsGroupsMatrix' => [
        
    ],
    'maximumAssetsGroupsWeights' => [
        
    ],
    'maximumAssetsWeights' => [
        
    ],
    'maximumPortfolioExposure' => '',
    'minimumAssetsWeights' => [
        
    ],
    'minimumPortfolioExposure' => ''
  ],
  'portfolios' => 0
]));
$request->setRequestUrl('{{baseUrl}}/portfolio/analysis/mean-variance/efficient-frontier');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/portfolio/analysis/mean-variance/efficient-frontier' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  },
  "portfolios": 0
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/portfolio/analysis/mean-variance/efficient-frontier' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  },
  "portfolios": 0
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"portfolios\": 0\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/portfolio/analysis/mean-variance/efficient-frontier", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/portfolio/analysis/mean-variance/efficient-frontier"

payload = {
    "assets": 0,
    "assetsCovarianceMatrix": [],
    "assetsReturns": [],
    "constraints": {
        "assetsGroups": [],
        "assetsGroupsMatrix": [],
        "maximumAssetsGroupsWeights": [],
        "maximumAssetsWeights": [],
        "maximumPortfolioExposure": "",
        "minimumAssetsWeights": [],
        "minimumPortfolioExposure": ""
    },
    "portfolios": 0
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/portfolio/analysis/mean-variance/efficient-frontier"

payload <- "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"portfolios\": 0\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/portfolio/analysis/mean-variance/efficient-frontier")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"portfolios\": 0\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/portfolio/analysis/mean-variance/efficient-frontier') do |req|
  req.body = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"portfolios\": 0\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/portfolio/analysis/mean-variance/efficient-frontier";

    let payload = json!({
        "assets": 0,
        "assetsCovarianceMatrix": (),
        "assetsReturns": (),
        "constraints": json!({
            "assetsGroups": (),
            "assetsGroupsMatrix": (),
            "maximumAssetsGroupsWeights": (),
            "maximumAssetsWeights": (),
            "maximumPortfolioExposure": "",
            "minimumAssetsWeights": (),
            "minimumPortfolioExposure": ""
        }),
        "portfolios": 0
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/portfolio/analysis/mean-variance/efficient-frontier \
  --header 'content-type: application/json' \
  --data '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  },
  "portfolios": 0
}'

echo '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  },
  "portfolios": 0
}' |  \
  http POST {{baseUrl}}/portfolio/analysis/mean-variance/efficient-frontier \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "assets": 0,\n  "assetsCovarianceMatrix": [],\n  "assetsReturns": [],\n  "constraints": {\n    "assetsGroups": [],\n    "assetsGroupsMatrix": [],\n    "maximumAssetsGroupsWeights": [],\n    "maximumAssetsWeights": [],\n    "maximumPortfolioExposure": "",\n    "minimumAssetsWeights": [],\n    "minimumPortfolioExposure": ""\n  },\n  "portfolios": 0\n}' \
  --output-document \
  - {{baseUrl}}/portfolio/analysis/mean-variance/efficient-frontier

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": [
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  ],
  "portfolios": 0
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/portfolio/analysis/mean-variance/efficient-frontier")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "portfolios": [
    {
      "assetsWeights": [
        0.8260869565217391,
        0.17391304347826086
      ],
      "portfolioReturn": 0.016956521739130433,
      "portfolioVolatility": 0.0463915284620315
    },
    {
      "assetsWeights": [
        0.5130434782608696,
        0.48695652173913045
      ],
      "portfolioReturn": 0.02947826086956522,
      "portfolioVolatility": 0.05726369211623199
    },
    {
      "assetsWeights": [
        0.2,
        0.8
      ],
      "portfolioReturn": 0.04200000000000001,
      "portfolioVolatility": 0.08160882305241265
    }
  ]
}

POST Mean-Variance Minimum Variance Frontier

{{baseUrl}}/portfolio/analysis/mean-variance/minimum-variance-frontier

BODY json

{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  },
  "portfolios": 0
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/portfolio/analysis/mean-variance/minimum-variance-frontier");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"portfolios\": 0\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/portfolio/analysis/mean-variance/minimum-variance-frontier" {:content-type :json
                                                                                                       :form-params {:assets 0
                                                                                                                     :assetsCovarianceMatrix []
                                                                                                                     :assetsReturns []
                                                                                                                     :constraints {:assetsGroups []
                                                                                                                                   :assetsGroupsMatrix []
                                                                                                                                   :maximumAssetsGroupsWeights []
                                                                                                                                   :maximumAssetsWeights []
                                                                                                                                   :maximumPortfolioExposure ""
                                                                                                                                   :minimumAssetsWeights []
                                                                                                                                   :minimumPortfolioExposure ""}
                                                                                                                     :portfolios 0}})

require "http/client"

url = "{{baseUrl}}/portfolio/analysis/mean-variance/minimum-variance-frontier"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"portfolios\": 0\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/portfolio/analysis/mean-variance/minimum-variance-frontier"),
    Content = new StringContent("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"portfolios\": 0\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/portfolio/analysis/mean-variance/minimum-variance-frontier");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"portfolios\": 0\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/portfolio/analysis/mean-variance/minimum-variance-frontier"

	payload := strings.NewReader("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"portfolios\": 0\n}")

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

	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/portfolio/analysis/mean-variance/minimum-variance-frontier HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 342

{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  },
  "portfolios": 0
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/portfolio/analysis/mean-variance/minimum-variance-frontier")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"portfolios\": 0\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/portfolio/analysis/mean-variance/minimum-variance-frontier"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"portfolios\": 0\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"portfolios\": 0\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/portfolio/analysis/mean-variance/minimum-variance-frontier")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/portfolio/analysis/mean-variance/minimum-variance-frontier")
  .header("content-type", "application/json")
  .body("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"portfolios\": 0\n}")
  .asString();

const data = JSON.stringify({
  assets: 0,
  assetsCovarianceMatrix: [],
  assetsReturns: [],
  constraints: {
    assetsGroups: [],
    assetsGroupsMatrix: [],
    maximumAssetsGroupsWeights: [],
    maximumAssetsWeights: [],
    maximumPortfolioExposure: '',
    minimumAssetsWeights: [],
    minimumPortfolioExposure: ''
  },
  portfolios: 0
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/portfolio/analysis/mean-variance/minimum-variance-frontier');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/analysis/mean-variance/minimum-variance-frontier',
  headers: {'content-type': 'application/json'},
  data: {
    assets: 0,
    assetsCovarianceMatrix: [],
    assetsReturns: [],
    constraints: {
      assetsGroups: [],
      assetsGroupsMatrix: [],
      maximumAssetsGroupsWeights: [],
      maximumAssetsWeights: [],
      maximumPortfolioExposure: '',
      minimumAssetsWeights: [],
      minimumPortfolioExposure: ''
    },
    portfolios: 0
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/portfolio/analysis/mean-variance/minimum-variance-frontier';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":0,"assetsCovarianceMatrix":[],"assetsReturns":[],"constraints":{"assetsGroups":[],"assetsGroupsMatrix":[],"maximumAssetsGroupsWeights":[],"maximumAssetsWeights":[],"maximumPortfolioExposure":"","minimumAssetsWeights":[],"minimumPortfolioExposure":""},"portfolios":0}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/portfolio/analysis/mean-variance/minimum-variance-frontier',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "assets": 0,\n  "assetsCovarianceMatrix": [],\n  "assetsReturns": [],\n  "constraints": {\n    "assetsGroups": [],\n    "assetsGroupsMatrix": [],\n    "maximumAssetsGroupsWeights": [],\n    "maximumAssetsWeights": [],\n    "maximumPortfolioExposure": "",\n    "minimumAssetsWeights": [],\n    "minimumPortfolioExposure": ""\n  },\n  "portfolios": 0\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"portfolios\": 0\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/portfolio/analysis/mean-variance/minimum-variance-frontier")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/portfolio/analysis/mean-variance/minimum-variance-frontier',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  assets: 0,
  assetsCovarianceMatrix: [],
  assetsReturns: [],
  constraints: {
    assetsGroups: [],
    assetsGroupsMatrix: [],
    maximumAssetsGroupsWeights: [],
    maximumAssetsWeights: [],
    maximumPortfolioExposure: '',
    minimumAssetsWeights: [],
    minimumPortfolioExposure: ''
  },
  portfolios: 0
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/analysis/mean-variance/minimum-variance-frontier',
  headers: {'content-type': 'application/json'},
  body: {
    assets: 0,
    assetsCovarianceMatrix: [],
    assetsReturns: [],
    constraints: {
      assetsGroups: [],
      assetsGroupsMatrix: [],
      maximumAssetsGroupsWeights: [],
      maximumAssetsWeights: [],
      maximumPortfolioExposure: '',
      minimumAssetsWeights: [],
      minimumPortfolioExposure: ''
    },
    portfolios: 0
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/portfolio/analysis/mean-variance/minimum-variance-frontier');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  assets: 0,
  assetsCovarianceMatrix: [],
  assetsReturns: [],
  constraints: {
    assetsGroups: [],
    assetsGroupsMatrix: [],
    maximumAssetsGroupsWeights: [],
    maximumAssetsWeights: [],
    maximumPortfolioExposure: '',
    minimumAssetsWeights: [],
    minimumPortfolioExposure: ''
  },
  portfolios: 0
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/analysis/mean-variance/minimum-variance-frontier',
  headers: {'content-type': 'application/json'},
  data: {
    assets: 0,
    assetsCovarianceMatrix: [],
    assetsReturns: [],
    constraints: {
      assetsGroups: [],
      assetsGroupsMatrix: [],
      maximumAssetsGroupsWeights: [],
      maximumAssetsWeights: [],
      maximumPortfolioExposure: '',
      minimumAssetsWeights: [],
      minimumPortfolioExposure: ''
    },
    portfolios: 0
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/portfolio/analysis/mean-variance/minimum-variance-frontier';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":0,"assetsCovarianceMatrix":[],"assetsReturns":[],"constraints":{"assetsGroups":[],"assetsGroupsMatrix":[],"maximumAssetsGroupsWeights":[],"maximumAssetsWeights":[],"maximumPortfolioExposure":"","minimumAssetsWeights":[],"minimumPortfolioExposure":""},"portfolios":0}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"assets": @0,
                              @"assetsCovarianceMatrix": @[  ],
                              @"assetsReturns": @[  ],
                              @"constraints": @{ @"assetsGroups": @[  ], @"assetsGroupsMatrix": @[  ], @"maximumAssetsGroupsWeights": @[  ], @"maximumAssetsWeights": @[  ], @"maximumPortfolioExposure": @"", @"minimumAssetsWeights": @[  ], @"minimumPortfolioExposure": @"" },
                              @"portfolios": @0 };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/portfolio/analysis/mean-variance/minimum-variance-frontier"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/portfolio/analysis/mean-variance/minimum-variance-frontier" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"portfolios\": 0\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/portfolio/analysis/mean-variance/minimum-variance-frontier",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'assets' => 0,
    'assetsCovarianceMatrix' => [
        
    ],
    'assetsReturns' => [
        
    ],
    'constraints' => [
        'assetsGroups' => [
                
        ],
        'assetsGroupsMatrix' => [
                
        ],
        'maximumAssetsGroupsWeights' => [
                
        ],
        'maximumAssetsWeights' => [
                
        ],
        'maximumPortfolioExposure' => '',
        'minimumAssetsWeights' => [
                
        ],
        'minimumPortfolioExposure' => ''
    ],
    'portfolios' => 0
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/portfolio/analysis/mean-variance/minimum-variance-frontier', [
  'body' => '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  },
  "portfolios": 0
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/portfolio/analysis/mean-variance/minimum-variance-frontier');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'assets' => 0,
  'assetsCovarianceMatrix' => [
    
  ],
  'assetsReturns' => [
    
  ],
  'constraints' => [
    'assetsGroups' => [
        
    ],
    'assetsGroupsMatrix' => [
        
    ],
    'maximumAssetsGroupsWeights' => [
        
    ],
    'maximumAssetsWeights' => [
        
    ],
    'maximumPortfolioExposure' => '',
    'minimumAssetsWeights' => [
        
    ],
    'minimumPortfolioExposure' => ''
  ],
  'portfolios' => 0
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'assets' => 0,
  'assetsCovarianceMatrix' => [
    
  ],
  'assetsReturns' => [
    
  ],
  'constraints' => [
    'assetsGroups' => [
        
    ],
    'assetsGroupsMatrix' => [
        
    ],
    'maximumAssetsGroupsWeights' => [
        
    ],
    'maximumAssetsWeights' => [
        
    ],
    'maximumPortfolioExposure' => '',
    'minimumAssetsWeights' => [
        
    ],
    'minimumPortfolioExposure' => ''
  ],
  'portfolios' => 0
]));
$request->setRequestUrl('{{baseUrl}}/portfolio/analysis/mean-variance/minimum-variance-frontier');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/portfolio/analysis/mean-variance/minimum-variance-frontier' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  },
  "portfolios": 0
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/portfolio/analysis/mean-variance/minimum-variance-frontier' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  },
  "portfolios": 0
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"portfolios\": 0\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/portfolio/analysis/mean-variance/minimum-variance-frontier", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/portfolio/analysis/mean-variance/minimum-variance-frontier"

payload = {
    "assets": 0,
    "assetsCovarianceMatrix": [],
    "assetsReturns": [],
    "constraints": {
        "assetsGroups": [],
        "assetsGroupsMatrix": [],
        "maximumAssetsGroupsWeights": [],
        "maximumAssetsWeights": [],
        "maximumPortfolioExposure": "",
        "minimumAssetsWeights": [],
        "minimumPortfolioExposure": ""
    },
    "portfolios": 0
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/portfolio/analysis/mean-variance/minimum-variance-frontier"

payload <- "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"portfolios\": 0\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/portfolio/analysis/mean-variance/minimum-variance-frontier")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"portfolios\": 0\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/portfolio/analysis/mean-variance/minimum-variance-frontier') do |req|
  req.body = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"portfolios\": 0\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/portfolio/analysis/mean-variance/minimum-variance-frontier";

    let payload = json!({
        "assets": 0,
        "assetsCovarianceMatrix": (),
        "assetsReturns": (),
        "constraints": json!({
            "assetsGroups": (),
            "assetsGroupsMatrix": (),
            "maximumAssetsGroupsWeights": (),
            "maximumAssetsWeights": (),
            "maximumPortfolioExposure": "",
            "minimumAssetsWeights": (),
            "minimumPortfolioExposure": ""
        }),
        "portfolios": 0
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/portfolio/analysis/mean-variance/minimum-variance-frontier \
  --header 'content-type: application/json' \
  --data '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  },
  "portfolios": 0
}'

echo '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  },
  "portfolios": 0
}' |  \
  http POST {{baseUrl}}/portfolio/analysis/mean-variance/minimum-variance-frontier \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "assets": 0,\n  "assetsCovarianceMatrix": [],\n  "assetsReturns": [],\n  "constraints": {\n    "assetsGroups": [],\n    "assetsGroupsMatrix": [],\n    "maximumAssetsGroupsWeights": [],\n    "maximumAssetsWeights": [],\n    "maximumPortfolioExposure": "",\n    "minimumAssetsWeights": [],\n    "minimumPortfolioExposure": ""\n  },\n  "portfolios": 0\n}' \
  --output-document \
  - {{baseUrl}}/portfolio/analysis/mean-variance/minimum-variance-frontier

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": [
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  ],
  "portfolios": 0
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/portfolio/analysis/mean-variance/minimum-variance-frontier")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "portfolios": [
    {
      "assetsWeights": [
        1,
        0
      ],
      "portfolioReturn": 0.01,
      "portfolioVolatility": 0.05
    },
    {
      "assetsWeights": [
        0.7333333333333333,
        0.2666666666666667
      ],
      "portfolioReturn": 0.02066666666666667,
      "portfolioVolatility": 0.04744587559642156
    },
    {
      "assetsWeights": [
        0.4666666666666667,
        0.5333333333333333
      ],
      "portfolioReturn": 0.03133333333333334,
      "portfolioVolatility": 0.06031399321697891
    },
    {
      "assetsWeights": [
        0.2,
        0.8
      ],
      "portfolioReturn": 0.04200000000000001,
      "portfolioVolatility": 0.08160882305241265
    }
  ]
}

POST Return Contributions

{{baseUrl}}/portfolio/analysis/contributions/return

BODY json

{
  "assets": 0,
  "assetsGroups": [],
  "assetsReturns": [],
  "portfolios": [
    {
      "assetsWeights": []
    }
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/portfolio/analysis/contributions/return");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"assets\": 0,\n  \"assetsGroups\": [],\n  \"assetsReturns\": [],\n  \"portfolios\": [\n    {\n      \"assetsWeights\": []\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/portfolio/analysis/contributions/return" {:content-type :json
                                                                                    :form-params {:assets 0
                                                                                                  :assetsGroups []
                                                                                                  :assetsReturns []
                                                                                                  :portfolios [{:assetsWeights []}]}})

require "http/client"

url = "{{baseUrl}}/portfolio/analysis/contributions/return"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"assets\": 0,\n  \"assetsGroups\": [],\n  \"assetsReturns\": [],\n  \"portfolios\": [\n    {\n      \"assetsWeights\": []\n    }\n  ]\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/portfolio/analysis/contributions/return"),
    Content = new StringContent("{\n  \"assets\": 0,\n  \"assetsGroups\": [],\n  \"assetsReturns\": [],\n  \"portfolios\": [\n    {\n      \"assetsWeights\": []\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/portfolio/analysis/contributions/return");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"assets\": 0,\n  \"assetsGroups\": [],\n  \"assetsReturns\": [],\n  \"portfolios\": [\n    {\n      \"assetsWeights\": []\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/portfolio/analysis/contributions/return"

	payload := strings.NewReader("{\n  \"assets\": 0,\n  \"assetsGroups\": [],\n  \"assetsReturns\": [],\n  \"portfolios\": [\n    {\n      \"assetsWeights\": []\n    }\n  ]\n}")

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

	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/portfolio/analysis/contributions/return HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 123

{
  "assets": 0,
  "assetsGroups": [],
  "assetsReturns": [],
  "portfolios": [
    {
      "assetsWeights": []
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/portfolio/analysis/contributions/return")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"assets\": 0,\n  \"assetsGroups\": [],\n  \"assetsReturns\": [],\n  \"portfolios\": [\n    {\n      \"assetsWeights\": []\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/portfolio/analysis/contributions/return"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"assets\": 0,\n  \"assetsGroups\": [],\n  \"assetsReturns\": [],\n  \"portfolios\": [\n    {\n      \"assetsWeights\": []\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"assets\": 0,\n  \"assetsGroups\": [],\n  \"assetsReturns\": [],\n  \"portfolios\": [\n    {\n      \"assetsWeights\": []\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/portfolio/analysis/contributions/return")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/portfolio/analysis/contributions/return")
  .header("content-type", "application/json")
  .body("{\n  \"assets\": 0,\n  \"assetsGroups\": [],\n  \"assetsReturns\": [],\n  \"portfolios\": [\n    {\n      \"assetsWeights\": []\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  assets: 0,
  assetsGroups: [],
  assetsReturns: [],
  portfolios: [
    {
      assetsWeights: []
    }
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/portfolio/analysis/contributions/return');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/analysis/contributions/return',
  headers: {'content-type': 'application/json'},
  data: {
    assets: 0,
    assetsGroups: [],
    assetsReturns: [],
    portfolios: [{assetsWeights: []}]
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/portfolio/analysis/contributions/return';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":0,"assetsGroups":[],"assetsReturns":[],"portfolios":[{"assetsWeights":[]}]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/portfolio/analysis/contributions/return',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "assets": 0,\n  "assetsGroups": [],\n  "assetsReturns": [],\n  "portfolios": [\n    {\n      "assetsWeights": []\n    }\n  ]\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"assets\": 0,\n  \"assetsGroups\": [],\n  \"assetsReturns\": [],\n  \"portfolios\": [\n    {\n      \"assetsWeights\": []\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/portfolio/analysis/contributions/return")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/portfolio/analysis/contributions/return',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  assets: 0,
  assetsGroups: [],
  assetsReturns: [],
  portfolios: [{assetsWeights: []}]
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/analysis/contributions/return',
  headers: {'content-type': 'application/json'},
  body: {
    assets: 0,
    assetsGroups: [],
    assetsReturns: [],
    portfolios: [{assetsWeights: []}]
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/portfolio/analysis/contributions/return');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  assets: 0,
  assetsGroups: [],
  assetsReturns: [],
  portfolios: [
    {
      assetsWeights: []
    }
  ]
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/analysis/contributions/return',
  headers: {'content-type': 'application/json'},
  data: {
    assets: 0,
    assetsGroups: [],
    assetsReturns: [],
    portfolios: [{assetsWeights: []}]
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/portfolio/analysis/contributions/return';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":0,"assetsGroups":[],"assetsReturns":[],"portfolios":[{"assetsWeights":[]}]}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"assets": @0,
                              @"assetsGroups": @[  ],
                              @"assetsReturns": @[  ],
                              @"portfolios": @[ @{ @"assetsWeights": @[  ] } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/portfolio/analysis/contributions/return"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/portfolio/analysis/contributions/return" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"assets\": 0,\n  \"assetsGroups\": [],\n  \"assetsReturns\": [],\n  \"portfolios\": [\n    {\n      \"assetsWeights\": []\n    }\n  ]\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/portfolio/analysis/contributions/return",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'assets' => 0,
    'assetsGroups' => [
        
    ],
    'assetsReturns' => [
        
    ],
    'portfolios' => [
        [
                'assetsWeights' => [
                                
                ]
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/portfolio/analysis/contributions/return', [
  'body' => '{
  "assets": 0,
  "assetsGroups": [],
  "assetsReturns": [],
  "portfolios": [
    {
      "assetsWeights": []
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/portfolio/analysis/contributions/return');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'assets' => 0,
  'assetsGroups' => [
    
  ],
  'assetsReturns' => [
    
  ],
  'portfolios' => [
    [
        'assetsWeights' => [
                
        ]
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'assets' => 0,
  'assetsGroups' => [
    
  ],
  'assetsReturns' => [
    
  ],
  'portfolios' => [
    [
        'assetsWeights' => [
                
        ]
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/portfolio/analysis/contributions/return');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/portfolio/analysis/contributions/return' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": 0,
  "assetsGroups": [],
  "assetsReturns": [],
  "portfolios": [
    {
      "assetsWeights": []
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/portfolio/analysis/contributions/return' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": 0,
  "assetsGroups": [],
  "assetsReturns": [],
  "portfolios": [
    {
      "assetsWeights": []
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"assets\": 0,\n  \"assetsGroups\": [],\n  \"assetsReturns\": [],\n  \"portfolios\": [\n    {\n      \"assetsWeights\": []\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/portfolio/analysis/contributions/return", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/portfolio/analysis/contributions/return"

payload = {
    "assets": 0,
    "assetsGroups": [],
    "assetsReturns": [],
    "portfolios": [{ "assetsWeights": [] }]
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/portfolio/analysis/contributions/return"

payload <- "{\n  \"assets\": 0,\n  \"assetsGroups\": [],\n  \"assetsReturns\": [],\n  \"portfolios\": [\n    {\n      \"assetsWeights\": []\n    }\n  ]\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/portfolio/analysis/contributions/return")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"assets\": 0,\n  \"assetsGroups\": [],\n  \"assetsReturns\": [],\n  \"portfolios\": [\n    {\n      \"assetsWeights\": []\n    }\n  ]\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/portfolio/analysis/contributions/return') do |req|
  req.body = "{\n  \"assets\": 0,\n  \"assetsGroups\": [],\n  \"assetsReturns\": [],\n  \"portfolios\": [\n    {\n      \"assetsWeights\": []\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/portfolio/analysis/contributions/return";

    let payload = json!({
        "assets": 0,
        "assetsGroups": (),
        "assetsReturns": (),
        "portfolios": (json!({"assetsWeights": ()}))
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/portfolio/analysis/contributions/return \
  --header 'content-type: application/json' \
  --data '{
  "assets": 0,
  "assetsGroups": [],
  "assetsReturns": [],
  "portfolios": [
    {
      "assetsWeights": []
    }
  ]
}'

echo '{
  "assets": 0,
  "assetsGroups": [],
  "assetsReturns": [],
  "portfolios": [
    {
      "assetsWeights": []
    }
  ]
}' |  \
  http POST {{baseUrl}}/portfolio/analysis/contributions/return \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "assets": 0,\n  "assetsGroups": [],\n  "assetsReturns": [],\n  "portfolios": [\n    {\n      "assetsWeights": []\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/portfolio/analysis/contributions/return

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "assets": 0,
  "assetsGroups": [],
  "assetsReturns": [],
  "portfolios": [["assetsWeights": []]]
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/portfolio/analysis/contributions/return")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "portfolios": [
    {
      "assetsGroupsReturnContributions": [
        0.0025,
        0.00625
      ],
      "assetsReturnContributions": [
        0.005,
        -0.0025,
        0.00625
      ]
    }
  ]
}

POST Risk Contributions

{{baseUrl}}/portfolio/analysis/contributions/risk

BODY json

{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsGroups": [],
  "portfolios": [
    {
      "assetsWeights": []
    }
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/portfolio/analysis/contributions/risk");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsGroups\": [],\n  \"portfolios\": [\n    {\n      \"assetsWeights\": []\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/portfolio/analysis/contributions/risk" {:content-type :json
                                                                                  :form-params {:assets 0
                                                                                                :assetsCovarianceMatrix []
                                                                                                :assetsGroups []
                                                                                                :portfolios [{:assetsWeights []}]}})

require "http/client"

url = "{{baseUrl}}/portfolio/analysis/contributions/risk"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsGroups\": [],\n  \"portfolios\": [\n    {\n      \"assetsWeights\": []\n    }\n  ]\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/portfolio/analysis/contributions/risk"),
    Content = new StringContent("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsGroups\": [],\n  \"portfolios\": [\n    {\n      \"assetsWeights\": []\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/portfolio/analysis/contributions/risk");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsGroups\": [],\n  \"portfolios\": [\n    {\n      \"assetsWeights\": []\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/portfolio/analysis/contributions/risk"

	payload := strings.NewReader("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsGroups\": [],\n  \"portfolios\": [\n    {\n      \"assetsWeights\": []\n    }\n  ]\n}")

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

	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/portfolio/analysis/contributions/risk HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 132

{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsGroups": [],
  "portfolios": [
    {
      "assetsWeights": []
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/portfolio/analysis/contributions/risk")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsGroups\": [],\n  \"portfolios\": [\n    {\n      \"assetsWeights\": []\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/portfolio/analysis/contributions/risk"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsGroups\": [],\n  \"portfolios\": [\n    {\n      \"assetsWeights\": []\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsGroups\": [],\n  \"portfolios\": [\n    {\n      \"assetsWeights\": []\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/portfolio/analysis/contributions/risk")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/portfolio/analysis/contributions/risk")
  .header("content-type", "application/json")
  .body("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsGroups\": [],\n  \"portfolios\": [\n    {\n      \"assetsWeights\": []\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  assets: 0,
  assetsCovarianceMatrix: [],
  assetsGroups: [],
  portfolios: [
    {
      assetsWeights: []
    }
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/portfolio/analysis/contributions/risk');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/analysis/contributions/risk',
  headers: {'content-type': 'application/json'},
  data: {
    assets: 0,
    assetsCovarianceMatrix: [],
    assetsGroups: [],
    portfolios: [{assetsWeights: []}]
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/portfolio/analysis/contributions/risk';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":0,"assetsCovarianceMatrix":[],"assetsGroups":[],"portfolios":[{"assetsWeights":[]}]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/portfolio/analysis/contributions/risk',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "assets": 0,\n  "assetsCovarianceMatrix": [],\n  "assetsGroups": [],\n  "portfolios": [\n    {\n      "assetsWeights": []\n    }\n  ]\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsGroups\": [],\n  \"portfolios\": [\n    {\n      \"assetsWeights\": []\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/portfolio/analysis/contributions/risk")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/portfolio/analysis/contributions/risk',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  assets: 0,
  assetsCovarianceMatrix: [],
  assetsGroups: [],
  portfolios: [{assetsWeights: []}]
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/analysis/contributions/risk',
  headers: {'content-type': 'application/json'},
  body: {
    assets: 0,
    assetsCovarianceMatrix: [],
    assetsGroups: [],
    portfolios: [{assetsWeights: []}]
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/portfolio/analysis/contributions/risk');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  assets: 0,
  assetsCovarianceMatrix: [],
  assetsGroups: [],
  portfolios: [
    {
      assetsWeights: []
    }
  ]
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/analysis/contributions/risk',
  headers: {'content-type': 'application/json'},
  data: {
    assets: 0,
    assetsCovarianceMatrix: [],
    assetsGroups: [],
    portfolios: [{assetsWeights: []}]
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/portfolio/analysis/contributions/risk';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":0,"assetsCovarianceMatrix":[],"assetsGroups":[],"portfolios":[{"assetsWeights":[]}]}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"assets": @0,
                              @"assetsCovarianceMatrix": @[  ],
                              @"assetsGroups": @[  ],
                              @"portfolios": @[ @{ @"assetsWeights": @[  ] } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/portfolio/analysis/contributions/risk"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/portfolio/analysis/contributions/risk" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsGroups\": [],\n  \"portfolios\": [\n    {\n      \"assetsWeights\": []\n    }\n  ]\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/portfolio/analysis/contributions/risk",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'assets' => 0,
    'assetsCovarianceMatrix' => [
        
    ],
    'assetsGroups' => [
        
    ],
    'portfolios' => [
        [
                'assetsWeights' => [
                                
                ]
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/portfolio/analysis/contributions/risk', [
  'body' => '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsGroups": [],
  "portfolios": [
    {
      "assetsWeights": []
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/portfolio/analysis/contributions/risk');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'assets' => 0,
  'assetsCovarianceMatrix' => [
    
  ],
  'assetsGroups' => [
    
  ],
  'portfolios' => [
    [
        'assetsWeights' => [
                
        ]
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'assets' => 0,
  'assetsCovarianceMatrix' => [
    
  ],
  'assetsGroups' => [
    
  ],
  'portfolios' => [
    [
        'assetsWeights' => [
                
        ]
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/portfolio/analysis/contributions/risk');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/portfolio/analysis/contributions/risk' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsGroups": [],
  "portfolios": [
    {
      "assetsWeights": []
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/portfolio/analysis/contributions/risk' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsGroups": [],
  "portfolios": [
    {
      "assetsWeights": []
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsGroups\": [],\n  \"portfolios\": [\n    {\n      \"assetsWeights\": []\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/portfolio/analysis/contributions/risk", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/portfolio/analysis/contributions/risk"

payload = {
    "assets": 0,
    "assetsCovarianceMatrix": [],
    "assetsGroups": [],
    "portfolios": [{ "assetsWeights": [] }]
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/portfolio/analysis/contributions/risk"

payload <- "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsGroups\": [],\n  \"portfolios\": [\n    {\n      \"assetsWeights\": []\n    }\n  ]\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/portfolio/analysis/contributions/risk")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsGroups\": [],\n  \"portfolios\": [\n    {\n      \"assetsWeights\": []\n    }\n  ]\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/portfolio/analysis/contributions/risk') do |req|
  req.body = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsGroups\": [],\n  \"portfolios\": [\n    {\n      \"assetsWeights\": []\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/portfolio/analysis/contributions/risk";

    let payload = json!({
        "assets": 0,
        "assetsCovarianceMatrix": (),
        "assetsGroups": (),
        "portfolios": (json!({"assetsWeights": ()}))
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/portfolio/analysis/contributions/risk \
  --header 'content-type: application/json' \
  --data '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsGroups": [],
  "portfolios": [
    {
      "assetsWeights": []
    }
  ]
}'

echo '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsGroups": [],
  "portfolios": [
    {
      "assetsWeights": []
    }
  ]
}' |  \
  http POST {{baseUrl}}/portfolio/analysis/contributions/risk \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "assets": 0,\n  "assetsCovarianceMatrix": [],\n  "assetsGroups": [],\n  "portfolios": [\n    {\n      "assetsWeights": []\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/portfolio/analysis/contributions/risk

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsGroups": [],
  "portfolios": [["assetsWeights": []]]
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/portfolio/analysis/contributions/risk")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "portfolios": [
    {
      "assetsRiskContributions": [
        0.0004969039949999533,
        0.00012422599874998834,
        0.049690399499995326
      ]
    }
  ]
}

POST Tracking Error

{{baseUrl}}/portfolio/analysis/tracking-error

BODY json

{
  "benchmarkReturns": [],
  "portfolios": [
    {
      "portfolioReturns": []
    }
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/portfolio/analysis/tracking-error");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"benchmarkReturns\": [],\n  \"portfolios\": [\n    {\n      \"portfolioReturns\": []\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/portfolio/analysis/tracking-error" {:content-type :json
                                                                              :form-params {:benchmarkReturns []
                                                                                            :portfolios [{:portfolioReturns []}]}})

require "http/client"

url = "{{baseUrl}}/portfolio/analysis/tracking-error"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"benchmarkReturns\": [],\n  \"portfolios\": [\n    {\n      \"portfolioReturns\": []\n    }\n  ]\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/portfolio/analysis/tracking-error"),
    Content = new StringContent("{\n  \"benchmarkReturns\": [],\n  \"portfolios\": [\n    {\n      \"portfolioReturns\": []\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/portfolio/analysis/tracking-error");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"benchmarkReturns\": [],\n  \"portfolios\": [\n    {\n      \"portfolioReturns\": []\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/portfolio/analysis/tracking-error"

	payload := strings.NewReader("{\n  \"benchmarkReturns\": [],\n  \"portfolios\": [\n    {\n      \"portfolioReturns\": []\n    }\n  ]\n}")

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

	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/portfolio/analysis/tracking-error HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 92

{
  "benchmarkReturns": [],
  "portfolios": [
    {
      "portfolioReturns": []
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/portfolio/analysis/tracking-error")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"benchmarkReturns\": [],\n  \"portfolios\": [\n    {\n      \"portfolioReturns\": []\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/portfolio/analysis/tracking-error"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"benchmarkReturns\": [],\n  \"portfolios\": [\n    {\n      \"portfolioReturns\": []\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"benchmarkReturns\": [],\n  \"portfolios\": [\n    {\n      \"portfolioReturns\": []\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/portfolio/analysis/tracking-error")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/portfolio/analysis/tracking-error")
  .header("content-type", "application/json")
  .body("{\n  \"benchmarkReturns\": [],\n  \"portfolios\": [\n    {\n      \"portfolioReturns\": []\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  benchmarkReturns: [],
  portfolios: [
    {
      portfolioReturns: []
    }
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/portfolio/analysis/tracking-error');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/analysis/tracking-error',
  headers: {'content-type': 'application/json'},
  data: {benchmarkReturns: [], portfolios: [{portfolioReturns: []}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/portfolio/analysis/tracking-error';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"benchmarkReturns":[],"portfolios":[{"portfolioReturns":[]}]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/portfolio/analysis/tracking-error',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "benchmarkReturns": [],\n  "portfolios": [\n    {\n      "portfolioReturns": []\n    }\n  ]\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"benchmarkReturns\": [],\n  \"portfolios\": [\n    {\n      \"portfolioReturns\": []\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/portfolio/analysis/tracking-error")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/portfolio/analysis/tracking-error',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({benchmarkReturns: [], portfolios: [{portfolioReturns: []}]}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/analysis/tracking-error',
  headers: {'content-type': 'application/json'},
  body: {benchmarkReturns: [], portfolios: [{portfolioReturns: []}]},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/portfolio/analysis/tracking-error');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  benchmarkReturns: [],
  portfolios: [
    {
      portfolioReturns: []
    }
  ]
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/analysis/tracking-error',
  headers: {'content-type': 'application/json'},
  data: {benchmarkReturns: [], portfolios: [{portfolioReturns: []}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/portfolio/analysis/tracking-error';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"benchmarkReturns":[],"portfolios":[{"portfolioReturns":[]}]}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"benchmarkReturns": @[  ],
                              @"portfolios": @[ @{ @"portfolioReturns": @[  ] } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/portfolio/analysis/tracking-error"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/portfolio/analysis/tracking-error" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"benchmarkReturns\": [],\n  \"portfolios\": [\n    {\n      \"portfolioReturns\": []\n    }\n  ]\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/portfolio/analysis/tracking-error",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'benchmarkReturns' => [
        
    ],
    'portfolios' => [
        [
                'portfolioReturns' => [
                                
                ]
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/portfolio/analysis/tracking-error', [
  'body' => '{
  "benchmarkReturns": [],
  "portfolios": [
    {
      "portfolioReturns": []
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/portfolio/analysis/tracking-error');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'benchmarkReturns' => [
    
  ],
  'portfolios' => [
    [
        'portfolioReturns' => [
                
        ]
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'benchmarkReturns' => [
    
  ],
  'portfolios' => [
    [
        'portfolioReturns' => [
                
        ]
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/portfolio/analysis/tracking-error');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/portfolio/analysis/tracking-error' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "benchmarkReturns": [],
  "portfolios": [
    {
      "portfolioReturns": []
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/portfolio/analysis/tracking-error' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "benchmarkReturns": [],
  "portfolios": [
    {
      "portfolioReturns": []
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"benchmarkReturns\": [],\n  \"portfolios\": [\n    {\n      \"portfolioReturns\": []\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/portfolio/analysis/tracking-error", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/portfolio/analysis/tracking-error"

payload = {
    "benchmarkReturns": [],
    "portfolios": [{ "portfolioReturns": [] }]
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/portfolio/analysis/tracking-error"

payload <- "{\n  \"benchmarkReturns\": [],\n  \"portfolios\": [\n    {\n      \"portfolioReturns\": []\n    }\n  ]\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/portfolio/analysis/tracking-error")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"benchmarkReturns\": [],\n  \"portfolios\": [\n    {\n      \"portfolioReturns\": []\n    }\n  ]\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/portfolio/analysis/tracking-error') do |req|
  req.body = "{\n  \"benchmarkReturns\": [],\n  \"portfolios\": [\n    {\n      \"portfolioReturns\": []\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/portfolio/analysis/tracking-error";

    let payload = json!({
        "benchmarkReturns": (),
        "portfolios": (json!({"portfolioReturns": ()}))
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/portfolio/analysis/tracking-error \
  --header 'content-type: application/json' \
  --data '{
  "benchmarkReturns": [],
  "portfolios": [
    {
      "portfolioReturns": []
    }
  ]
}'

echo '{
  "benchmarkReturns": [],
  "portfolios": [
    {
      "portfolioReturns": []
    }
  ]
}' |  \
  http POST {{baseUrl}}/portfolio/analysis/tracking-error \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "benchmarkReturns": [],\n  "portfolios": [\n    {\n      "portfolioReturns": []\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/portfolio/analysis/tracking-error

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "benchmarkReturns": [],
  "portfolios": [["portfolioReturns": []]]
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/portfolio/analysis/tracking-error")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "portfolios": [
    {
      "portfolioTrackingError": 0.00950648535942116
    }
  ]
}

POST Ulcer Index

{{baseUrl}}/portfolio/analysis/ulcer-index

BODY json

{
  "portfolios": [
    {
      "portfolioValues": []
    }
  ],
  "riskFreeRate": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/portfolio/analysis/ulcer-index");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ],\n  \"riskFreeRate\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/portfolio/analysis/ulcer-index" {:content-type :json
                                                                           :form-params {:portfolios [{:portfolioValues []}]
                                                                                         :riskFreeRate ""}})

require "http/client"

url = "{{baseUrl}}/portfolio/analysis/ulcer-index"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ],\n  \"riskFreeRate\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/portfolio/analysis/ulcer-index"),
    Content = new StringContent("{\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ],\n  \"riskFreeRate\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/portfolio/analysis/ulcer-index");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ],\n  \"riskFreeRate\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/portfolio/analysis/ulcer-index"

	payload := strings.NewReader("{\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ],\n  \"riskFreeRate\": \"\"\n}")

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

	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/portfolio/analysis/ulcer-index HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 87

{
  "portfolios": [
    {
      "portfolioValues": []
    }
  ],
  "riskFreeRate": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/portfolio/analysis/ulcer-index")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ],\n  \"riskFreeRate\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/portfolio/analysis/ulcer-index"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ],\n  \"riskFreeRate\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ],\n  \"riskFreeRate\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/portfolio/analysis/ulcer-index")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/portfolio/analysis/ulcer-index")
  .header("content-type", "application/json")
  .body("{\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ],\n  \"riskFreeRate\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  portfolios: [
    {
      portfolioValues: []
    }
  ],
  riskFreeRate: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/portfolio/analysis/ulcer-index');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/analysis/ulcer-index',
  headers: {'content-type': 'application/json'},
  data: {portfolios: [{portfolioValues: []}], riskFreeRate: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/portfolio/analysis/ulcer-index';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"portfolios":[{"portfolioValues":[]}],"riskFreeRate":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/portfolio/analysis/ulcer-index',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "portfolios": [\n    {\n      "portfolioValues": []\n    }\n  ],\n  "riskFreeRate": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ],\n  \"riskFreeRate\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/portfolio/analysis/ulcer-index")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/portfolio/analysis/ulcer-index',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({portfolios: [{portfolioValues: []}], riskFreeRate: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/analysis/ulcer-index',
  headers: {'content-type': 'application/json'},
  body: {portfolios: [{portfolioValues: []}], riskFreeRate: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/portfolio/analysis/ulcer-index');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  portfolios: [
    {
      portfolioValues: []
    }
  ],
  riskFreeRate: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/analysis/ulcer-index',
  headers: {'content-type': 'application/json'},
  data: {portfolios: [{portfolioValues: []}], riskFreeRate: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/portfolio/analysis/ulcer-index';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"portfolios":[{"portfolioValues":[]}],"riskFreeRate":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"portfolios": @[ @{ @"portfolioValues": @[  ] } ],
                              @"riskFreeRate": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/portfolio/analysis/ulcer-index"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/portfolio/analysis/ulcer-index" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ],\n  \"riskFreeRate\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/portfolio/analysis/ulcer-index",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'portfolios' => [
        [
                'portfolioValues' => [
                                
                ]
        ]
    ],
    'riskFreeRate' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/portfolio/analysis/ulcer-index', [
  'body' => '{
  "portfolios": [
    {
      "portfolioValues": []
    }
  ],
  "riskFreeRate": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/portfolio/analysis/ulcer-index');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'portfolios' => [
    [
        'portfolioValues' => [
                
        ]
    ]
  ],
  'riskFreeRate' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'portfolios' => [
    [
        'portfolioValues' => [
                
        ]
    ]
  ],
  'riskFreeRate' => ''
]));
$request->setRequestUrl('{{baseUrl}}/portfolio/analysis/ulcer-index');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/portfolio/analysis/ulcer-index' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "portfolios": [
    {
      "portfolioValues": []
    }
  ],
  "riskFreeRate": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/portfolio/analysis/ulcer-index' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "portfolios": [
    {
      "portfolioValues": []
    }
  ],
  "riskFreeRate": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ],\n  \"riskFreeRate\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/portfolio/analysis/ulcer-index", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/portfolio/analysis/ulcer-index"

payload = {
    "portfolios": [{ "portfolioValues": [] }],
    "riskFreeRate": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/portfolio/analysis/ulcer-index"

payload <- "{\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ],\n  \"riskFreeRate\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/portfolio/analysis/ulcer-index")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ],\n  \"riskFreeRate\": \"\"\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/portfolio/analysis/ulcer-index') do |req|
  req.body = "{\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ],\n  \"riskFreeRate\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/portfolio/analysis/ulcer-index";

    let payload = json!({
        "portfolios": (json!({"portfolioValues": ()})),
        "riskFreeRate": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/portfolio/analysis/ulcer-index \
  --header 'content-type: application/json' \
  --data '{
  "portfolios": [
    {
      "portfolioValues": []
    }
  ],
  "riskFreeRate": ""
}'

echo '{
  "portfolios": [
    {
      "portfolioValues": []
    }
  ],
  "riskFreeRate": ""
}' |  \
  http POST {{baseUrl}}/portfolio/analysis/ulcer-index \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "portfolios": [\n    {\n      "portfolioValues": []\n    }\n  ],\n  "riskFreeRate": ""\n}' \
  --output-document \
  - {{baseUrl}}/portfolio/analysis/ulcer-index

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "portfolios": [["portfolioValues": []]],
  "riskFreeRate": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/portfolio/analysis/ulcer-index")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "portfolios": [
    {
      "portfolioUlcerIndex": 0.14433756729740643
    }
  ]
}

POST Ulcer Performance Index

{{baseUrl}}/portfolio/analysis/ulcer-performance-index

BODY json

{
  "portfolios": [
    {
      "portfolioValues": []
    }
  ],
  "riskFreeRate": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/portfolio/analysis/ulcer-performance-index");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ],\n  \"riskFreeRate\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/portfolio/analysis/ulcer-performance-index" {:content-type :json
                                                                                       :form-params {:portfolios [{:portfolioValues []}]
                                                                                                     :riskFreeRate ""}})

require "http/client"

url = "{{baseUrl}}/portfolio/analysis/ulcer-performance-index"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ],\n  \"riskFreeRate\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/portfolio/analysis/ulcer-performance-index"),
    Content = new StringContent("{\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ],\n  \"riskFreeRate\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/portfolio/analysis/ulcer-performance-index");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ],\n  \"riskFreeRate\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/portfolio/analysis/ulcer-performance-index"

	payload := strings.NewReader("{\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ],\n  \"riskFreeRate\": \"\"\n}")

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

	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/portfolio/analysis/ulcer-performance-index HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 87

{
  "portfolios": [
    {
      "portfolioValues": []
    }
  ],
  "riskFreeRate": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/portfolio/analysis/ulcer-performance-index")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ],\n  \"riskFreeRate\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/portfolio/analysis/ulcer-performance-index"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ],\n  \"riskFreeRate\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ],\n  \"riskFreeRate\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/portfolio/analysis/ulcer-performance-index")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/portfolio/analysis/ulcer-performance-index")
  .header("content-type", "application/json")
  .body("{\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ],\n  \"riskFreeRate\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  portfolios: [
    {
      portfolioValues: []
    }
  ],
  riskFreeRate: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/portfolio/analysis/ulcer-performance-index');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/analysis/ulcer-performance-index',
  headers: {'content-type': 'application/json'},
  data: {portfolios: [{portfolioValues: []}], riskFreeRate: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/portfolio/analysis/ulcer-performance-index';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"portfolios":[{"portfolioValues":[]}],"riskFreeRate":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/portfolio/analysis/ulcer-performance-index',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "portfolios": [\n    {\n      "portfolioValues": []\n    }\n  ],\n  "riskFreeRate": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ],\n  \"riskFreeRate\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/portfolio/analysis/ulcer-performance-index")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/portfolio/analysis/ulcer-performance-index',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({portfolios: [{portfolioValues: []}], riskFreeRate: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/analysis/ulcer-performance-index',
  headers: {'content-type': 'application/json'},
  body: {portfolios: [{portfolioValues: []}], riskFreeRate: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/portfolio/analysis/ulcer-performance-index');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  portfolios: [
    {
      portfolioValues: []
    }
  ],
  riskFreeRate: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/analysis/ulcer-performance-index',
  headers: {'content-type': 'application/json'},
  data: {portfolios: [{portfolioValues: []}], riskFreeRate: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/portfolio/analysis/ulcer-performance-index';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"portfolios":[{"portfolioValues":[]}],"riskFreeRate":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"portfolios": @[ @{ @"portfolioValues": @[  ] } ],
                              @"riskFreeRate": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/portfolio/analysis/ulcer-performance-index"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/portfolio/analysis/ulcer-performance-index" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ],\n  \"riskFreeRate\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/portfolio/analysis/ulcer-performance-index",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'portfolios' => [
        [
                'portfolioValues' => [
                                
                ]
        ]
    ],
    'riskFreeRate' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/portfolio/analysis/ulcer-performance-index', [
  'body' => '{
  "portfolios": [
    {
      "portfolioValues": []
    }
  ],
  "riskFreeRate": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/portfolio/analysis/ulcer-performance-index');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'portfolios' => [
    [
        'portfolioValues' => [
                
        ]
    ]
  ],
  'riskFreeRate' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'portfolios' => [
    [
        'portfolioValues' => [
                
        ]
    ]
  ],
  'riskFreeRate' => ''
]));
$request->setRequestUrl('{{baseUrl}}/portfolio/analysis/ulcer-performance-index');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/portfolio/analysis/ulcer-performance-index' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "portfolios": [
    {
      "portfolioValues": []
    }
  ],
  "riskFreeRate": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/portfolio/analysis/ulcer-performance-index' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "portfolios": [
    {
      "portfolioValues": []
    }
  ],
  "riskFreeRate": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ],\n  \"riskFreeRate\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/portfolio/analysis/ulcer-performance-index", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/portfolio/analysis/ulcer-performance-index"

payload = {
    "portfolios": [{ "portfolioValues": [] }],
    "riskFreeRate": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/portfolio/analysis/ulcer-performance-index"

payload <- "{\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ],\n  \"riskFreeRate\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/portfolio/analysis/ulcer-performance-index")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ],\n  \"riskFreeRate\": \"\"\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/portfolio/analysis/ulcer-performance-index') do |req|
  req.body = "{\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ],\n  \"riskFreeRate\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/portfolio/analysis/ulcer-performance-index";

    let payload = json!({
        "portfolios": (json!({"portfolioValues": ()})),
        "riskFreeRate": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/portfolio/analysis/ulcer-performance-index \
  --header 'content-type: application/json' \
  --data '{
  "portfolios": [
    {
      "portfolioValues": []
    }
  ],
  "riskFreeRate": ""
}'

echo '{
  "portfolios": [
    {
      "portfolioValues": []
    }
  ],
  "riskFreeRate": ""
}' |  \
  http POST {{baseUrl}}/portfolio/analysis/ulcer-performance-index \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "portfolios": [\n    {\n      "portfolioValues": []\n    }\n  ],\n  "riskFreeRate": ""\n}' \
  --output-document \
  - {{baseUrl}}/portfolio/analysis/ulcer-performance-index

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "portfolios": [["portfolioValues": []]],
  "riskFreeRate": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/portfolio/analysis/ulcer-performance-index")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "portfolios": [
    {
      "portfolioUlcerPerformanceIndex": -0.45642249763676057
    }
  ]
}

POST Value At Risk

{{baseUrl}}/portfolio/analysis/value-at-risk

BODY json

{
  "alpha": "",
  "portfolios": [
    {
      "portfolioValues": []
    }
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/portfolio/analysis/value-at-risk");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"alpha\": \"\",\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/portfolio/analysis/value-at-risk" {:content-type :json
                                                                             :form-params {:alpha ""
                                                                                           :portfolios [{:portfolioValues []}]}})

require "http/client"

url = "{{baseUrl}}/portfolio/analysis/value-at-risk"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"alpha\": \"\",\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ]\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/portfolio/analysis/value-at-risk"),
    Content = new StringContent("{\n  \"alpha\": \"\",\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/portfolio/analysis/value-at-risk");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"alpha\": \"\",\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/portfolio/analysis/value-at-risk"

	payload := strings.NewReader("{\n  \"alpha\": \"\",\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ]\n}")

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

	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/portfolio/analysis/value-at-risk HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 80

{
  "alpha": "",
  "portfolios": [
    {
      "portfolioValues": []
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/portfolio/analysis/value-at-risk")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"alpha\": \"\",\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/portfolio/analysis/value-at-risk"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"alpha\": \"\",\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"alpha\": \"\",\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/portfolio/analysis/value-at-risk")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/portfolio/analysis/value-at-risk")
  .header("content-type", "application/json")
  .body("{\n  \"alpha\": \"\",\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  alpha: '',
  portfolios: [
    {
      portfolioValues: []
    }
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/portfolio/analysis/value-at-risk');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/analysis/value-at-risk',
  headers: {'content-type': 'application/json'},
  data: {alpha: '', portfolios: [{portfolioValues: []}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/portfolio/analysis/value-at-risk';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"alpha":"","portfolios":[{"portfolioValues":[]}]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/portfolio/analysis/value-at-risk',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "alpha": "",\n  "portfolios": [\n    {\n      "portfolioValues": []\n    }\n  ]\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"alpha\": \"\",\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/portfolio/analysis/value-at-risk")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/portfolio/analysis/value-at-risk',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({alpha: '', portfolios: [{portfolioValues: []}]}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/analysis/value-at-risk',
  headers: {'content-type': 'application/json'},
  body: {alpha: '', portfolios: [{portfolioValues: []}]},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/portfolio/analysis/value-at-risk');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  alpha: '',
  portfolios: [
    {
      portfolioValues: []
    }
  ]
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/analysis/value-at-risk',
  headers: {'content-type': 'application/json'},
  data: {alpha: '', portfolios: [{portfolioValues: []}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/portfolio/analysis/value-at-risk';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"alpha":"","portfolios":[{"portfolioValues":[]}]}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"alpha": @"",
                              @"portfolios": @[ @{ @"portfolioValues": @[  ] } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/portfolio/analysis/value-at-risk"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/portfolio/analysis/value-at-risk" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"alpha\": \"\",\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ]\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/portfolio/analysis/value-at-risk",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'alpha' => '',
    'portfolios' => [
        [
                'portfolioValues' => [
                                
                ]
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/portfolio/analysis/value-at-risk', [
  'body' => '{
  "alpha": "",
  "portfolios": [
    {
      "portfolioValues": []
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/portfolio/analysis/value-at-risk');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'alpha' => '',
  'portfolios' => [
    [
        'portfolioValues' => [
                
        ]
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'alpha' => '',
  'portfolios' => [
    [
        'portfolioValues' => [
                
        ]
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/portfolio/analysis/value-at-risk');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/portfolio/analysis/value-at-risk' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "alpha": "",
  "portfolios": [
    {
      "portfolioValues": []
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/portfolio/analysis/value-at-risk' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "alpha": "",
  "portfolios": [
    {
      "portfolioValues": []
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"alpha\": \"\",\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/portfolio/analysis/value-at-risk", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/portfolio/analysis/value-at-risk"

payload = {
    "alpha": "",
    "portfolios": [{ "portfolioValues": [] }]
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/portfolio/analysis/value-at-risk"

payload <- "{\n  \"alpha\": \"\",\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ]\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/portfolio/analysis/value-at-risk")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"alpha\": \"\",\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ]\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/portfolio/analysis/value-at-risk') do |req|
  req.body = "{\n  \"alpha\": \"\",\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/portfolio/analysis/value-at-risk";

    let payload = json!({
        "alpha": "",
        "portfolios": (json!({"portfolioValues": ()}))
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/portfolio/analysis/value-at-risk \
  --header 'content-type: application/json' \
  --data '{
  "alpha": "",
  "portfolios": [
    {
      "portfolioValues": []
    }
  ]
}'

echo '{
  "alpha": "",
  "portfolios": [
    {
      "portfolioValues": []
    }
  ]
}' |  \
  http POST {{baseUrl}}/portfolio/analysis/value-at-risk \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "alpha": "",\n  "portfolios": [\n    {\n      "portfolioValues": []\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/portfolio/analysis/value-at-risk

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "alpha": "",
  "portfolios": [["portfolioValues": []]]
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/portfolio/analysis/value-at-risk")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "portfolios": [
    {
      "portfolioValueAtRisk": 0.17647058823529413
    }
  ]
}

POST Volatility (POST)

{{baseUrl}}/portfolio/analysis/volatility

BODY json

{}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/portfolio/analysis/volatility");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/portfolio/analysis/volatility" {:content-type :json})

require "http/client"

url = "{{baseUrl}}/portfolio/analysis/volatility"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/portfolio/analysis/volatility"),
    Content = new StringContent("{}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/portfolio/analysis/volatility");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/portfolio/analysis/volatility"

	payload := strings.NewReader("{}")

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

	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/portfolio/analysis/volatility HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 2

{}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/portfolio/analysis/volatility")
  .setHeader("content-type", "application/json")
  .setBody("{}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/portfolio/analysis/volatility"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/portfolio/analysis/volatility")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/portfolio/analysis/volatility")
  .header("content-type", "application/json")
  .body("{}")
  .asString();

const data = JSON.stringify({});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/portfolio/analysis/volatility');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/analysis/volatility',
  headers: {'content-type': 'application/json'},
  data: {}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/portfolio/analysis/volatility';
const options = {method: 'POST', headers: {'content-type': 'application/json'}, body: '{}'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/portfolio/analysis/volatility',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{}")
val request = Request.Builder()
  .url("{{baseUrl}}/portfolio/analysis/volatility")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/portfolio/analysis/volatility',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/analysis/volatility',
  headers: {'content-type': 'application/json'},
  body: {},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/portfolio/analysis/volatility');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/analysis/volatility',
  headers: {'content-type': 'application/json'},
  data: {}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/portfolio/analysis/volatility';
const options = {method: 'POST', headers: {'content-type': 'application/json'}, body: '{}'};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{  };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/portfolio/analysis/volatility"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/portfolio/analysis/volatility" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/portfolio/analysis/volatility",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/portfolio/analysis/volatility', [
  'body' => '{}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/portfolio/analysis/volatility');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  
]));
$request->setRequestUrl('{{baseUrl}}/portfolio/analysis/volatility');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/portfolio/analysis/volatility' -Method POST -Headers $headers -ContentType 'application/json' -Body '{}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/portfolio/analysis/volatility' -Method POST -Headers $headers -ContentType 'application/json' -Body '{}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/portfolio/analysis/volatility", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/portfolio/analysis/volatility"

payload = {}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/portfolio/analysis/volatility"

payload <- "{}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/portfolio/analysis/volatility")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/portfolio/analysis/volatility') do |req|
  req.body = "{}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/portfolio/analysis/volatility";

    let payload = json!({});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/portfolio/analysis/volatility \
  --header 'content-type: application/json' \
  --data '{}'

echo '{}' |  \
  http POST {{baseUrl}}/portfolio/analysis/volatility \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{}' \
  --output-document \
  - {{baseUrl}}/portfolio/analysis/volatility

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/portfolio/analysis/volatility")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "portfolios": [
    {
      "portfolioVolatility": 0.05
    },
    {
      "portfolioVolatility": 0.1
    }
  ]
}

POST Bias-Adjusted Sharpe Ratio

{{baseUrl}}/portfolio/analysis/sharpe-ratio/bias-adjusted

BODY json

{
  "portfolios": [
    {
      "portfolioValues": []
    }
  ],
  "riskFreeRate": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/portfolio/analysis/sharpe-ratio/bias-adjusted");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ],\n  \"riskFreeRate\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/portfolio/analysis/sharpe-ratio/bias-adjusted" {:content-type :json
                                                                                          :form-params {:portfolios [{:portfolioValues []}]
                                                                                                        :riskFreeRate ""}})

require "http/client"

url = "{{baseUrl}}/portfolio/analysis/sharpe-ratio/bias-adjusted"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ],\n  \"riskFreeRate\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/portfolio/analysis/sharpe-ratio/bias-adjusted"),
    Content = new StringContent("{\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ],\n  \"riskFreeRate\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/portfolio/analysis/sharpe-ratio/bias-adjusted");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ],\n  \"riskFreeRate\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/portfolio/analysis/sharpe-ratio/bias-adjusted"

	payload := strings.NewReader("{\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ],\n  \"riskFreeRate\": \"\"\n}")

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

	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/portfolio/analysis/sharpe-ratio/bias-adjusted HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 87

{
  "portfolios": [
    {
      "portfolioValues": []
    }
  ],
  "riskFreeRate": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/portfolio/analysis/sharpe-ratio/bias-adjusted")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ],\n  \"riskFreeRate\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/portfolio/analysis/sharpe-ratio/bias-adjusted"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ],\n  \"riskFreeRate\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ],\n  \"riskFreeRate\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/portfolio/analysis/sharpe-ratio/bias-adjusted")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/portfolio/analysis/sharpe-ratio/bias-adjusted")
  .header("content-type", "application/json")
  .body("{\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ],\n  \"riskFreeRate\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  portfolios: [
    {
      portfolioValues: []
    }
  ],
  riskFreeRate: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/portfolio/analysis/sharpe-ratio/bias-adjusted');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/analysis/sharpe-ratio/bias-adjusted',
  headers: {'content-type': 'application/json'},
  data: {portfolios: [{portfolioValues: []}], riskFreeRate: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/portfolio/analysis/sharpe-ratio/bias-adjusted';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"portfolios":[{"portfolioValues":[]}],"riskFreeRate":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/portfolio/analysis/sharpe-ratio/bias-adjusted',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "portfolios": [\n    {\n      "portfolioValues": []\n    }\n  ],\n  "riskFreeRate": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ],\n  \"riskFreeRate\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/portfolio/analysis/sharpe-ratio/bias-adjusted")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/portfolio/analysis/sharpe-ratio/bias-adjusted',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({portfolios: [{portfolioValues: []}], riskFreeRate: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/analysis/sharpe-ratio/bias-adjusted',
  headers: {'content-type': 'application/json'},
  body: {portfolios: [{portfolioValues: []}], riskFreeRate: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/portfolio/analysis/sharpe-ratio/bias-adjusted');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  portfolios: [
    {
      portfolioValues: []
    }
  ],
  riskFreeRate: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/analysis/sharpe-ratio/bias-adjusted',
  headers: {'content-type': 'application/json'},
  data: {portfolios: [{portfolioValues: []}], riskFreeRate: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/portfolio/analysis/sharpe-ratio/bias-adjusted';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"portfolios":[{"portfolioValues":[]}],"riskFreeRate":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"portfolios": @[ @{ @"portfolioValues": @[  ] } ],
                              @"riskFreeRate": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/portfolio/analysis/sharpe-ratio/bias-adjusted"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/portfolio/analysis/sharpe-ratio/bias-adjusted" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ],\n  \"riskFreeRate\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/portfolio/analysis/sharpe-ratio/bias-adjusted",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'portfolios' => [
        [
                'portfolioValues' => [
                                
                ]
        ]
    ],
    'riskFreeRate' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/portfolio/analysis/sharpe-ratio/bias-adjusted', [
  'body' => '{
  "portfolios": [
    {
      "portfolioValues": []
    }
  ],
  "riskFreeRate": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/portfolio/analysis/sharpe-ratio/bias-adjusted');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'portfolios' => [
    [
        'portfolioValues' => [
                
        ]
    ]
  ],
  'riskFreeRate' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'portfolios' => [
    [
        'portfolioValues' => [
                
        ]
    ]
  ],
  'riskFreeRate' => ''
]));
$request->setRequestUrl('{{baseUrl}}/portfolio/analysis/sharpe-ratio/bias-adjusted');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/portfolio/analysis/sharpe-ratio/bias-adjusted' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "portfolios": [
    {
      "portfolioValues": []
    }
  ],
  "riskFreeRate": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/portfolio/analysis/sharpe-ratio/bias-adjusted' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "portfolios": [
    {
      "portfolioValues": []
    }
  ],
  "riskFreeRate": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ],\n  \"riskFreeRate\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/portfolio/analysis/sharpe-ratio/bias-adjusted", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/portfolio/analysis/sharpe-ratio/bias-adjusted"

payload = {
    "portfolios": [{ "portfolioValues": [] }],
    "riskFreeRate": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/portfolio/analysis/sharpe-ratio/bias-adjusted"

payload <- "{\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ],\n  \"riskFreeRate\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/portfolio/analysis/sharpe-ratio/bias-adjusted")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ],\n  \"riskFreeRate\": \"\"\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/portfolio/analysis/sharpe-ratio/bias-adjusted') do |req|
  req.body = "{\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ],\n  \"riskFreeRate\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/portfolio/analysis/sharpe-ratio/bias-adjusted";

    let payload = json!({
        "portfolios": (json!({"portfolioValues": ()})),
        "riskFreeRate": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/portfolio/analysis/sharpe-ratio/bias-adjusted \
  --header 'content-type: application/json' \
  --data '{
  "portfolios": [
    {
      "portfolioValues": []
    }
  ],
  "riskFreeRate": ""
}'

echo '{
  "portfolios": [
    {
      "portfolioValues": []
    }
  ],
  "riskFreeRate": ""
}' |  \
  http POST {{baseUrl}}/portfolio/analysis/sharpe-ratio/bias-adjusted \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "portfolios": [\n    {\n      "portfolioValues": []\n    }\n  ],\n  "riskFreeRate": ""\n}' \
  --output-document \
  - {{baseUrl}}/portfolio/analysis/sharpe-ratio/bias-adjusted

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "portfolios": [["portfolioValues": []]],
  "riskFreeRate": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/portfolio/analysis/sharpe-ratio/bias-adjusted")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "portfolios": [
    {
      "portfolioBiasAdjustedSharpeRatio": -0.8314248234836994
    }
  ]
}

POST Minimum Track Record Length

{{baseUrl}}/portfolio/analysis/sharpe-ratio/probabilistic/minimum-track-record-length

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/portfolio/analysis/sharpe-ratio/probabilistic/minimum-track-record-length");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/portfolio/analysis/sharpe-ratio/probabilistic/minimum-track-record-length")

require "http/client"

url = "{{baseUrl}}/portfolio/analysis/sharpe-ratio/probabilistic/minimum-track-record-length"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/portfolio/analysis/sharpe-ratio/probabilistic/minimum-track-record-length"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/portfolio/analysis/sharpe-ratio/probabilistic/minimum-track-record-length");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/portfolio/analysis/sharpe-ratio/probabilistic/minimum-track-record-length"

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

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

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

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

}

POST /baseUrl/portfolio/analysis/sharpe-ratio/probabilistic/minimum-track-record-length HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/portfolio/analysis/sharpe-ratio/probabilistic/minimum-track-record-length")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/portfolio/analysis/sharpe-ratio/probabilistic/minimum-track-record-length"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/portfolio/analysis/sharpe-ratio/probabilistic/minimum-track-record-length")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/portfolio/analysis/sharpe-ratio/probabilistic/minimum-track-record-length")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/portfolio/analysis/sharpe-ratio/probabilistic/minimum-track-record-length');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/analysis/sharpe-ratio/probabilistic/minimum-track-record-length'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/portfolio/analysis/sharpe-ratio/probabilistic/minimum-track-record-length';
const options = {method: 'POST'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/portfolio/analysis/sharpe-ratio/probabilistic/minimum-track-record-length',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/portfolio/analysis/sharpe-ratio/probabilistic/minimum-track-record-length")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/portfolio/analysis/sharpe-ratio/probabilistic/minimum-track-record-length',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/analysis/sharpe-ratio/probabilistic/minimum-track-record-length'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/portfolio/analysis/sharpe-ratio/probabilistic/minimum-track-record-length');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/analysis/sharpe-ratio/probabilistic/minimum-track-record-length'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/portfolio/analysis/sharpe-ratio/probabilistic/minimum-track-record-length';
const options = {method: 'POST'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/portfolio/analysis/sharpe-ratio/probabilistic/minimum-track-record-length"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/portfolio/analysis/sharpe-ratio/probabilistic/minimum-track-record-length" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/portfolio/analysis/sharpe-ratio/probabilistic/minimum-track-record-length",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/portfolio/analysis/sharpe-ratio/probabilistic/minimum-track-record-length');

echo $response->getBody();

setUrl('{{baseUrl}}/portfolio/analysis/sharpe-ratio/probabilistic/minimum-track-record-length');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/portfolio/analysis/sharpe-ratio/probabilistic/minimum-track-record-length');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/portfolio/analysis/sharpe-ratio/probabilistic/minimum-track-record-length' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/portfolio/analysis/sharpe-ratio/probabilistic/minimum-track-record-length' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = ""

conn.request("POST", "/baseUrl/portfolio/analysis/sharpe-ratio/probabilistic/minimum-track-record-length", payload)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/portfolio/analysis/sharpe-ratio/probabilistic/minimum-track-record-length"

payload = ""

response = requests.post(url, data=payload)

print(response.json())

library(httr)

url <- "{{baseUrl}}/portfolio/analysis/sharpe-ratio/probabilistic/minimum-track-record-length"

payload <- ""

response <- VERB("POST", url, body = payload, content_type(""))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/portfolio/analysis/sharpe-ratio/probabilistic/minimum-track-record-length")

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

request = Net::HTTP::Post.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/portfolio/analysis/sharpe-ratio/probabilistic/minimum-track-record-length') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/portfolio/analysis/sharpe-ratio/probabilistic/minimum-track-record-length";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/portfolio/analysis/sharpe-ratio/probabilistic/minimum-track-record-length

http POST {{baseUrl}}/portfolio/analysis/sharpe-ratio/probabilistic/minimum-track-record-length

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/portfolio/analysis/sharpe-ratio/probabilistic/minimum-track-record-length

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/portfolio/analysis/sharpe-ratio/probabilistic/minimum-track-record-length")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "portfolios": [
    {
      "portfolioSharpeRatioMinimumTrackRecordLength": null
    }
  ]
}

POST Probabilistic Sharpe Ratio

{{baseUrl}}/portfolio/analysis/sharpe-ratio/probabilistic

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/portfolio/analysis/sharpe-ratio/probabilistic");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/portfolio/analysis/sharpe-ratio/probabilistic")

require "http/client"

url = "{{baseUrl}}/portfolio/analysis/sharpe-ratio/probabilistic"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/portfolio/analysis/sharpe-ratio/probabilistic"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/portfolio/analysis/sharpe-ratio/probabilistic");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/portfolio/analysis/sharpe-ratio/probabilistic"

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

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

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

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

}

POST /baseUrl/portfolio/analysis/sharpe-ratio/probabilistic HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/portfolio/analysis/sharpe-ratio/probabilistic")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/portfolio/analysis/sharpe-ratio/probabilistic"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/portfolio/analysis/sharpe-ratio/probabilistic")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/portfolio/analysis/sharpe-ratio/probabilistic")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/portfolio/analysis/sharpe-ratio/probabilistic');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/analysis/sharpe-ratio/probabilistic'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/portfolio/analysis/sharpe-ratio/probabilistic';
const options = {method: 'POST'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/portfolio/analysis/sharpe-ratio/probabilistic',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/portfolio/analysis/sharpe-ratio/probabilistic")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/portfolio/analysis/sharpe-ratio/probabilistic',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/analysis/sharpe-ratio/probabilistic'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/portfolio/analysis/sharpe-ratio/probabilistic');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/analysis/sharpe-ratio/probabilistic'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/portfolio/analysis/sharpe-ratio/probabilistic';
const options = {method: 'POST'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/portfolio/analysis/sharpe-ratio/probabilistic"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/portfolio/analysis/sharpe-ratio/probabilistic" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/portfolio/analysis/sharpe-ratio/probabilistic",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/portfolio/analysis/sharpe-ratio/probabilistic');

echo $response->getBody();

setUrl('{{baseUrl}}/portfolio/analysis/sharpe-ratio/probabilistic');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/portfolio/analysis/sharpe-ratio/probabilistic');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/portfolio/analysis/sharpe-ratio/probabilistic' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/portfolio/analysis/sharpe-ratio/probabilistic' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = ""

conn.request("POST", "/baseUrl/portfolio/analysis/sharpe-ratio/probabilistic", payload)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/portfolio/analysis/sharpe-ratio/probabilistic"

payload = ""

response = requests.post(url, data=payload)

print(response.json())

library(httr)

url <- "{{baseUrl}}/portfolio/analysis/sharpe-ratio/probabilistic"

payload <- ""

response <- VERB("POST", url, body = payload, content_type(""))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/portfolio/analysis/sharpe-ratio/probabilistic")

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

request = Net::HTTP::Post.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/portfolio/analysis/sharpe-ratio/probabilistic') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/portfolio/analysis/sharpe-ratio/probabilistic";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/portfolio/analysis/sharpe-ratio/probabilistic

http POST {{baseUrl}}/portfolio/analysis/sharpe-ratio/probabilistic

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/portfolio/analysis/sharpe-ratio/probabilistic

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/portfolio/analysis/sharpe-ratio/probabilistic")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "portfolios": [
    {
      "portfolioProbabilisticSharpeRatio": 0.0452890775705429
    }
  ]
}

POST Sharpe Ratio Confidence Interval

{{baseUrl}}/portfolio/analysis/sharpe-ratio/confidence-interval

BODY json

{
  "confidenceIntervalType": "",
  "confidenceLevel": "",
  "portfolios": [
    {
      "portfolioValues": []
    }
  ],
  "riskFreeRate": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/portfolio/analysis/sharpe-ratio/confidence-interval");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"confidenceIntervalType\": \"\",\n  \"confidenceLevel\": \"\",\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ],\n  \"riskFreeRate\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/portfolio/analysis/sharpe-ratio/confidence-interval" {:content-type :json
                                                                                                :form-params {:confidenceIntervalType ""
                                                                                                              :confidenceLevel ""
                                                                                                              :portfolios [{:portfolioValues []}]
                                                                                                              :riskFreeRate ""}})

require "http/client"

url = "{{baseUrl}}/portfolio/analysis/sharpe-ratio/confidence-interval"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"confidenceIntervalType\": \"\",\n  \"confidenceLevel\": \"\",\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ],\n  \"riskFreeRate\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/portfolio/analysis/sharpe-ratio/confidence-interval"),
    Content = new StringContent("{\n  \"confidenceIntervalType\": \"\",\n  \"confidenceLevel\": \"\",\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ],\n  \"riskFreeRate\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/portfolio/analysis/sharpe-ratio/confidence-interval");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"confidenceIntervalType\": \"\",\n  \"confidenceLevel\": \"\",\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ],\n  \"riskFreeRate\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/portfolio/analysis/sharpe-ratio/confidence-interval"

	payload := strings.NewReader("{\n  \"confidenceIntervalType\": \"\",\n  \"confidenceLevel\": \"\",\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ],\n  \"riskFreeRate\": \"\"\n}")

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

	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/portfolio/analysis/sharpe-ratio/confidence-interval HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 144

{
  "confidenceIntervalType": "",
  "confidenceLevel": "",
  "portfolios": [
    {
      "portfolioValues": []
    }
  ],
  "riskFreeRate": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/portfolio/analysis/sharpe-ratio/confidence-interval")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"confidenceIntervalType\": \"\",\n  \"confidenceLevel\": \"\",\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ],\n  \"riskFreeRate\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/portfolio/analysis/sharpe-ratio/confidence-interval"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"confidenceIntervalType\": \"\",\n  \"confidenceLevel\": \"\",\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ],\n  \"riskFreeRate\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"confidenceIntervalType\": \"\",\n  \"confidenceLevel\": \"\",\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ],\n  \"riskFreeRate\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/portfolio/analysis/sharpe-ratio/confidence-interval")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/portfolio/analysis/sharpe-ratio/confidence-interval")
  .header("content-type", "application/json")
  .body("{\n  \"confidenceIntervalType\": \"\",\n  \"confidenceLevel\": \"\",\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ],\n  \"riskFreeRate\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  confidenceIntervalType: '',
  confidenceLevel: '',
  portfolios: [
    {
      portfolioValues: []
    }
  ],
  riskFreeRate: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/portfolio/analysis/sharpe-ratio/confidence-interval');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/analysis/sharpe-ratio/confidence-interval',
  headers: {'content-type': 'application/json'},
  data: {
    confidenceIntervalType: '',
    confidenceLevel: '',
    portfolios: [{portfolioValues: []}],
    riskFreeRate: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/portfolio/analysis/sharpe-ratio/confidence-interval';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"confidenceIntervalType":"","confidenceLevel":"","portfolios":[{"portfolioValues":[]}],"riskFreeRate":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/portfolio/analysis/sharpe-ratio/confidence-interval',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "confidenceIntervalType": "",\n  "confidenceLevel": "",\n  "portfolios": [\n    {\n      "portfolioValues": []\n    }\n  ],\n  "riskFreeRate": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"confidenceIntervalType\": \"\",\n  \"confidenceLevel\": \"\",\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ],\n  \"riskFreeRate\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/portfolio/analysis/sharpe-ratio/confidence-interval")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/portfolio/analysis/sharpe-ratio/confidence-interval',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  confidenceIntervalType: '',
  confidenceLevel: '',
  portfolios: [{portfolioValues: []}],
  riskFreeRate: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/analysis/sharpe-ratio/confidence-interval',
  headers: {'content-type': 'application/json'},
  body: {
    confidenceIntervalType: '',
    confidenceLevel: '',
    portfolios: [{portfolioValues: []}],
    riskFreeRate: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/portfolio/analysis/sharpe-ratio/confidence-interval');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  confidenceIntervalType: '',
  confidenceLevel: '',
  portfolios: [
    {
      portfolioValues: []
    }
  ],
  riskFreeRate: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/analysis/sharpe-ratio/confidence-interval',
  headers: {'content-type': 'application/json'},
  data: {
    confidenceIntervalType: '',
    confidenceLevel: '',
    portfolios: [{portfolioValues: []}],
    riskFreeRate: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/portfolio/analysis/sharpe-ratio/confidence-interval';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"confidenceIntervalType":"","confidenceLevel":"","portfolios":[{"portfolioValues":[]}],"riskFreeRate":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"confidenceIntervalType": @"",
                              @"confidenceLevel": @"",
                              @"portfolios": @[ @{ @"portfolioValues": @[  ] } ],
                              @"riskFreeRate": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/portfolio/analysis/sharpe-ratio/confidence-interval"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/portfolio/analysis/sharpe-ratio/confidence-interval" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"confidenceIntervalType\": \"\",\n  \"confidenceLevel\": \"\",\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ],\n  \"riskFreeRate\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/portfolio/analysis/sharpe-ratio/confidence-interval",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'confidenceIntervalType' => '',
    'confidenceLevel' => '',
    'portfolios' => [
        [
                'portfolioValues' => [
                                
                ]
        ]
    ],
    'riskFreeRate' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/portfolio/analysis/sharpe-ratio/confidence-interval', [
  'body' => '{
  "confidenceIntervalType": "",
  "confidenceLevel": "",
  "portfolios": [
    {
      "portfolioValues": []
    }
  ],
  "riskFreeRate": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/portfolio/analysis/sharpe-ratio/confidence-interval');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'confidenceIntervalType' => '',
  'confidenceLevel' => '',
  'portfolios' => [
    [
        'portfolioValues' => [
                
        ]
    ]
  ],
  'riskFreeRate' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'confidenceIntervalType' => '',
  'confidenceLevel' => '',
  'portfolios' => [
    [
        'portfolioValues' => [
                
        ]
    ]
  ],
  'riskFreeRate' => ''
]));
$request->setRequestUrl('{{baseUrl}}/portfolio/analysis/sharpe-ratio/confidence-interval');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/portfolio/analysis/sharpe-ratio/confidence-interval' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "confidenceIntervalType": "",
  "confidenceLevel": "",
  "portfolios": [
    {
      "portfolioValues": []
    }
  ],
  "riskFreeRate": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/portfolio/analysis/sharpe-ratio/confidence-interval' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "confidenceIntervalType": "",
  "confidenceLevel": "",
  "portfolios": [
    {
      "portfolioValues": []
    }
  ],
  "riskFreeRate": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"confidenceIntervalType\": \"\",\n  \"confidenceLevel\": \"\",\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ],\n  \"riskFreeRate\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/portfolio/analysis/sharpe-ratio/confidence-interval", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/portfolio/analysis/sharpe-ratio/confidence-interval"

payload = {
    "confidenceIntervalType": "",
    "confidenceLevel": "",
    "portfolios": [{ "portfolioValues": [] }],
    "riskFreeRate": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/portfolio/analysis/sharpe-ratio/confidence-interval"

payload <- "{\n  \"confidenceIntervalType\": \"\",\n  \"confidenceLevel\": \"\",\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ],\n  \"riskFreeRate\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/portfolio/analysis/sharpe-ratio/confidence-interval")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"confidenceIntervalType\": \"\",\n  \"confidenceLevel\": \"\",\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ],\n  \"riskFreeRate\": \"\"\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/portfolio/analysis/sharpe-ratio/confidence-interval') do |req|
  req.body = "{\n  \"confidenceIntervalType\": \"\",\n  \"confidenceLevel\": \"\",\n  \"portfolios\": [\n    {\n      \"portfolioValues\": []\n    }\n  ],\n  \"riskFreeRate\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/portfolio/analysis/sharpe-ratio/confidence-interval";

    let payload = json!({
        "confidenceIntervalType": "",
        "confidenceLevel": "",
        "portfolios": (json!({"portfolioValues": ()})),
        "riskFreeRate": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/portfolio/analysis/sharpe-ratio/confidence-interval \
  --header 'content-type: application/json' \
  --data '{
  "confidenceIntervalType": "",
  "confidenceLevel": "",
  "portfolios": [
    {
      "portfolioValues": []
    }
  ],
  "riskFreeRate": ""
}'

echo '{
  "confidenceIntervalType": "",
  "confidenceLevel": "",
  "portfolios": [
    {
      "portfolioValues": []
    }
  ],
  "riskFreeRate": ""
}' |  \
  http POST {{baseUrl}}/portfolio/analysis/sharpe-ratio/confidence-interval \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "confidenceIntervalType": "",\n  "confidenceLevel": "",\n  "portfolios": [\n    {\n      "portfolioValues": []\n    }\n  ],\n  "riskFreeRate": ""\n}' \
  --output-document \
  - {{baseUrl}}/portfolio/analysis/sharpe-ratio/confidence-interval

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "confidenceIntervalType": "",
  "confidenceLevel": "",
  "portfolios": [["portfolioValues": []]],
  "riskFreeRate": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/portfolio/analysis/sharpe-ratio/confidence-interval")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "portfolios": [
    {
      "portfolioSharpeRatioConfidenceInterval": [
        null,
        0.3309901925834179
      ]
    }
  ]
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "portfolios": [
    {
      "portfolioSharpeRatioConfidenceInterval": [
        -2.2283045143292535,
        0.46123772931706875
      ]
    }
  ]
}

POST Sharpe Ratio

{{baseUrl}}/portfolio/analysis/sharpe-ratio

BODY json

{}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/portfolio/analysis/sharpe-ratio");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/portfolio/analysis/sharpe-ratio" {:content-type :json})

require "http/client"

url = "{{baseUrl}}/portfolio/analysis/sharpe-ratio"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/portfolio/analysis/sharpe-ratio"),
    Content = new StringContent("{}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/portfolio/analysis/sharpe-ratio");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/portfolio/analysis/sharpe-ratio"

	payload := strings.NewReader("{}")

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

	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/portfolio/analysis/sharpe-ratio HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 2

{}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/portfolio/analysis/sharpe-ratio")
  .setHeader("content-type", "application/json")
  .setBody("{}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/portfolio/analysis/sharpe-ratio"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/portfolio/analysis/sharpe-ratio")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/portfolio/analysis/sharpe-ratio")
  .header("content-type", "application/json")
  .body("{}")
  .asString();

const data = JSON.stringify({});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/portfolio/analysis/sharpe-ratio');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/analysis/sharpe-ratio',
  headers: {'content-type': 'application/json'},
  data: {}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/portfolio/analysis/sharpe-ratio';
const options = {method: 'POST', headers: {'content-type': 'application/json'}, body: '{}'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/portfolio/analysis/sharpe-ratio',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{}")
val request = Request.Builder()
  .url("{{baseUrl}}/portfolio/analysis/sharpe-ratio")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/portfolio/analysis/sharpe-ratio',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/analysis/sharpe-ratio',
  headers: {'content-type': 'application/json'},
  body: {},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/portfolio/analysis/sharpe-ratio');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/analysis/sharpe-ratio',
  headers: {'content-type': 'application/json'},
  data: {}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/portfolio/analysis/sharpe-ratio';
const options = {method: 'POST', headers: {'content-type': 'application/json'}, body: '{}'};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{  };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/portfolio/analysis/sharpe-ratio"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/portfolio/analysis/sharpe-ratio" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/portfolio/analysis/sharpe-ratio",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/portfolio/analysis/sharpe-ratio', [
  'body' => '{}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/portfolio/analysis/sharpe-ratio');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  
]));
$request->setRequestUrl('{{baseUrl}}/portfolio/analysis/sharpe-ratio');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/portfolio/analysis/sharpe-ratio' -Method POST -Headers $headers -ContentType 'application/json' -Body '{}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/portfolio/analysis/sharpe-ratio' -Method POST -Headers $headers -ContentType 'application/json' -Body '{}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/portfolio/analysis/sharpe-ratio", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/portfolio/analysis/sharpe-ratio"

payload = {}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/portfolio/analysis/sharpe-ratio"

payload <- "{}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/portfolio/analysis/sharpe-ratio")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/portfolio/analysis/sharpe-ratio') do |req|
  req.body = "{}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/portfolio/analysis/sharpe-ratio";

    let payload = json!({});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/portfolio/analysis/sharpe-ratio \
  --header 'content-type: application/json' \
  --data '{}'

echo '{}' |  \
  http POST {{baseUrl}}/portfolio/analysis/sharpe-ratio \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{}' \
  --output-document \
  - {{baseUrl}}/portfolio/analysis/sharpe-ratio

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/portfolio/analysis/sharpe-ratio")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "portfolios": [
    {
      "portfolioSharpeRatio": -0.8835333925060923
    }
  ]
}

POST Investable Portfolio

{{baseUrl}}/portfolio/construction/investable

BODY json

{
  "assets": 0,
  "assetsGroups": [],
  "assetsGroupsWeights": [],
  "assetsMinimumNotionalValues": [],
  "assetsMinimumPositions": [],
  "assetsPrices": [],
  "assetsSizeLots": [],
  "assetsWeights": [],
  "maximumAssetsGroupsWeights": [],
  "portfolioValue": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/portfolio/construction/investable");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"assets\": 0,\n  \"assetsGroups\": [],\n  \"assetsGroupsWeights\": [],\n  \"assetsMinimumNotionalValues\": [],\n  \"assetsMinimumPositions\": [],\n  \"assetsPrices\": [],\n  \"assetsSizeLots\": [],\n  \"assetsWeights\": [],\n  \"maximumAssetsGroupsWeights\": [],\n  \"portfolioValue\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/portfolio/construction/investable" {:content-type :json
                                                                              :form-params {:assets 0
                                                                                            :assetsGroups []
                                                                                            :assetsGroupsWeights []
                                                                                            :assetsMinimumNotionalValues []
                                                                                            :assetsMinimumPositions []
                                                                                            :assetsPrices []
                                                                                            :assetsSizeLots []
                                                                                            :assetsWeights []
                                                                                            :maximumAssetsGroupsWeights []
                                                                                            :portfolioValue ""}})

require "http/client"

url = "{{baseUrl}}/portfolio/construction/investable"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"assets\": 0,\n  \"assetsGroups\": [],\n  \"assetsGroupsWeights\": [],\n  \"assetsMinimumNotionalValues\": [],\n  \"assetsMinimumPositions\": [],\n  \"assetsPrices\": [],\n  \"assetsSizeLots\": [],\n  \"assetsWeights\": [],\n  \"maximumAssetsGroupsWeights\": [],\n  \"portfolioValue\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/portfolio/construction/investable"),
    Content = new StringContent("{\n  \"assets\": 0,\n  \"assetsGroups\": [],\n  \"assetsGroupsWeights\": [],\n  \"assetsMinimumNotionalValues\": [],\n  \"assetsMinimumPositions\": [],\n  \"assetsPrices\": [],\n  \"assetsSizeLots\": [],\n  \"assetsWeights\": [],\n  \"maximumAssetsGroupsWeights\": [],\n  \"portfolioValue\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/portfolio/construction/investable");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"assets\": 0,\n  \"assetsGroups\": [],\n  \"assetsGroupsWeights\": [],\n  \"assetsMinimumNotionalValues\": [],\n  \"assetsMinimumPositions\": [],\n  \"assetsPrices\": [],\n  \"assetsSizeLots\": [],\n  \"assetsWeights\": [],\n  \"maximumAssetsGroupsWeights\": [],\n  \"portfolioValue\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/portfolio/construction/investable"

	payload := strings.NewReader("{\n  \"assets\": 0,\n  \"assetsGroups\": [],\n  \"assetsGroupsWeights\": [],\n  \"assetsMinimumNotionalValues\": [],\n  \"assetsMinimumPositions\": [],\n  \"assetsPrices\": [],\n  \"assetsSizeLots\": [],\n  \"assetsWeights\": [],\n  \"maximumAssetsGroupsWeights\": [],\n  \"portfolioValue\": \"\"\n}")

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

	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/portfolio/construction/investable HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 266

{
  "assets": 0,
  "assetsGroups": [],
  "assetsGroupsWeights": [],
  "assetsMinimumNotionalValues": [],
  "assetsMinimumPositions": [],
  "assetsPrices": [],
  "assetsSizeLots": [],
  "assetsWeights": [],
  "maximumAssetsGroupsWeights": [],
  "portfolioValue": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/portfolio/construction/investable")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"assets\": 0,\n  \"assetsGroups\": [],\n  \"assetsGroupsWeights\": [],\n  \"assetsMinimumNotionalValues\": [],\n  \"assetsMinimumPositions\": [],\n  \"assetsPrices\": [],\n  \"assetsSizeLots\": [],\n  \"assetsWeights\": [],\n  \"maximumAssetsGroupsWeights\": [],\n  \"portfolioValue\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/portfolio/construction/investable"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"assets\": 0,\n  \"assetsGroups\": [],\n  \"assetsGroupsWeights\": [],\n  \"assetsMinimumNotionalValues\": [],\n  \"assetsMinimumPositions\": [],\n  \"assetsPrices\": [],\n  \"assetsSizeLots\": [],\n  \"assetsWeights\": [],\n  \"maximumAssetsGroupsWeights\": [],\n  \"portfolioValue\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"assets\": 0,\n  \"assetsGroups\": [],\n  \"assetsGroupsWeights\": [],\n  \"assetsMinimumNotionalValues\": [],\n  \"assetsMinimumPositions\": [],\n  \"assetsPrices\": [],\n  \"assetsSizeLots\": [],\n  \"assetsWeights\": [],\n  \"maximumAssetsGroupsWeights\": [],\n  \"portfolioValue\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/portfolio/construction/investable")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/portfolio/construction/investable")
  .header("content-type", "application/json")
  .body("{\n  \"assets\": 0,\n  \"assetsGroups\": [],\n  \"assetsGroupsWeights\": [],\n  \"assetsMinimumNotionalValues\": [],\n  \"assetsMinimumPositions\": [],\n  \"assetsPrices\": [],\n  \"assetsSizeLots\": [],\n  \"assetsWeights\": [],\n  \"maximumAssetsGroupsWeights\": [],\n  \"portfolioValue\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  assets: 0,
  assetsGroups: [],
  assetsGroupsWeights: [],
  assetsMinimumNotionalValues: [],
  assetsMinimumPositions: [],
  assetsPrices: [],
  assetsSizeLots: [],
  assetsWeights: [],
  maximumAssetsGroupsWeights: [],
  portfolioValue: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/portfolio/construction/investable');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/construction/investable',
  headers: {'content-type': 'application/json'},
  data: {
    assets: 0,
    assetsGroups: [],
    assetsGroupsWeights: [],
    assetsMinimumNotionalValues: [],
    assetsMinimumPositions: [],
    assetsPrices: [],
    assetsSizeLots: [],
    assetsWeights: [],
    maximumAssetsGroupsWeights: [],
    portfolioValue: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/portfolio/construction/investable';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":0,"assetsGroups":[],"assetsGroupsWeights":[],"assetsMinimumNotionalValues":[],"assetsMinimumPositions":[],"assetsPrices":[],"assetsSizeLots":[],"assetsWeights":[],"maximumAssetsGroupsWeights":[],"portfolioValue":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/portfolio/construction/investable',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "assets": 0,\n  "assetsGroups": [],\n  "assetsGroupsWeights": [],\n  "assetsMinimumNotionalValues": [],\n  "assetsMinimumPositions": [],\n  "assetsPrices": [],\n  "assetsSizeLots": [],\n  "assetsWeights": [],\n  "maximumAssetsGroupsWeights": [],\n  "portfolioValue": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"assets\": 0,\n  \"assetsGroups\": [],\n  \"assetsGroupsWeights\": [],\n  \"assetsMinimumNotionalValues\": [],\n  \"assetsMinimumPositions\": [],\n  \"assetsPrices\": [],\n  \"assetsSizeLots\": [],\n  \"assetsWeights\": [],\n  \"maximumAssetsGroupsWeights\": [],\n  \"portfolioValue\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/portfolio/construction/investable")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/portfolio/construction/investable',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  assets: 0,
  assetsGroups: [],
  assetsGroupsWeights: [],
  assetsMinimumNotionalValues: [],
  assetsMinimumPositions: [],
  assetsPrices: [],
  assetsSizeLots: [],
  assetsWeights: [],
  maximumAssetsGroupsWeights: [],
  portfolioValue: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/construction/investable',
  headers: {'content-type': 'application/json'},
  body: {
    assets: 0,
    assetsGroups: [],
    assetsGroupsWeights: [],
    assetsMinimumNotionalValues: [],
    assetsMinimumPositions: [],
    assetsPrices: [],
    assetsSizeLots: [],
    assetsWeights: [],
    maximumAssetsGroupsWeights: [],
    portfolioValue: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/portfolio/construction/investable');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  assets: 0,
  assetsGroups: [],
  assetsGroupsWeights: [],
  assetsMinimumNotionalValues: [],
  assetsMinimumPositions: [],
  assetsPrices: [],
  assetsSizeLots: [],
  assetsWeights: [],
  maximumAssetsGroupsWeights: [],
  portfolioValue: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/construction/investable',
  headers: {'content-type': 'application/json'},
  data: {
    assets: 0,
    assetsGroups: [],
    assetsGroupsWeights: [],
    assetsMinimumNotionalValues: [],
    assetsMinimumPositions: [],
    assetsPrices: [],
    assetsSizeLots: [],
    assetsWeights: [],
    maximumAssetsGroupsWeights: [],
    portfolioValue: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/portfolio/construction/investable';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":0,"assetsGroups":[],"assetsGroupsWeights":[],"assetsMinimumNotionalValues":[],"assetsMinimumPositions":[],"assetsPrices":[],"assetsSizeLots":[],"assetsWeights":[],"maximumAssetsGroupsWeights":[],"portfolioValue":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"assets": @0,
                              @"assetsGroups": @[  ],
                              @"assetsGroupsWeights": @[  ],
                              @"assetsMinimumNotionalValues": @[  ],
                              @"assetsMinimumPositions": @[  ],
                              @"assetsPrices": @[  ],
                              @"assetsSizeLots": @[  ],
                              @"assetsWeights": @[  ],
                              @"maximumAssetsGroupsWeights": @[  ],
                              @"portfolioValue": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/portfolio/construction/investable"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/portfolio/construction/investable" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"assets\": 0,\n  \"assetsGroups\": [],\n  \"assetsGroupsWeights\": [],\n  \"assetsMinimumNotionalValues\": [],\n  \"assetsMinimumPositions\": [],\n  \"assetsPrices\": [],\n  \"assetsSizeLots\": [],\n  \"assetsWeights\": [],\n  \"maximumAssetsGroupsWeights\": [],\n  \"portfolioValue\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/portfolio/construction/investable",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'assets' => 0,
    'assetsGroups' => [
        
    ],
    'assetsGroupsWeights' => [
        
    ],
    'assetsMinimumNotionalValues' => [
        
    ],
    'assetsMinimumPositions' => [
        
    ],
    'assetsPrices' => [
        
    ],
    'assetsSizeLots' => [
        
    ],
    'assetsWeights' => [
        
    ],
    'maximumAssetsGroupsWeights' => [
        
    ],
    'portfolioValue' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/portfolio/construction/investable', [
  'body' => '{
  "assets": 0,
  "assetsGroups": [],
  "assetsGroupsWeights": [],
  "assetsMinimumNotionalValues": [],
  "assetsMinimumPositions": [],
  "assetsPrices": [],
  "assetsSizeLots": [],
  "assetsWeights": [],
  "maximumAssetsGroupsWeights": [],
  "portfolioValue": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/portfolio/construction/investable');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'assets' => 0,
  'assetsGroups' => [
    
  ],
  'assetsGroupsWeights' => [
    
  ],
  'assetsMinimumNotionalValues' => [
    
  ],
  'assetsMinimumPositions' => [
    
  ],
  'assetsPrices' => [
    
  ],
  'assetsSizeLots' => [
    
  ],
  'assetsWeights' => [
    
  ],
  'maximumAssetsGroupsWeights' => [
    
  ],
  'portfolioValue' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'assets' => 0,
  'assetsGroups' => [
    
  ],
  'assetsGroupsWeights' => [
    
  ],
  'assetsMinimumNotionalValues' => [
    
  ],
  'assetsMinimumPositions' => [
    
  ],
  'assetsPrices' => [
    
  ],
  'assetsSizeLots' => [
    
  ],
  'assetsWeights' => [
    
  ],
  'maximumAssetsGroupsWeights' => [
    
  ],
  'portfolioValue' => ''
]));
$request->setRequestUrl('{{baseUrl}}/portfolio/construction/investable');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/portfolio/construction/investable' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": 0,
  "assetsGroups": [],
  "assetsGroupsWeights": [],
  "assetsMinimumNotionalValues": [],
  "assetsMinimumPositions": [],
  "assetsPrices": [],
  "assetsSizeLots": [],
  "assetsWeights": [],
  "maximumAssetsGroupsWeights": [],
  "portfolioValue": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/portfolio/construction/investable' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": 0,
  "assetsGroups": [],
  "assetsGroupsWeights": [],
  "assetsMinimumNotionalValues": [],
  "assetsMinimumPositions": [],
  "assetsPrices": [],
  "assetsSizeLots": [],
  "assetsWeights": [],
  "maximumAssetsGroupsWeights": [],
  "portfolioValue": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"assets\": 0,\n  \"assetsGroups\": [],\n  \"assetsGroupsWeights\": [],\n  \"assetsMinimumNotionalValues\": [],\n  \"assetsMinimumPositions\": [],\n  \"assetsPrices\": [],\n  \"assetsSizeLots\": [],\n  \"assetsWeights\": [],\n  \"maximumAssetsGroupsWeights\": [],\n  \"portfolioValue\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/portfolio/construction/investable", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/portfolio/construction/investable"

payload = {
    "assets": 0,
    "assetsGroups": [],
    "assetsGroupsWeights": [],
    "assetsMinimumNotionalValues": [],
    "assetsMinimumPositions": [],
    "assetsPrices": [],
    "assetsSizeLots": [],
    "assetsWeights": [],
    "maximumAssetsGroupsWeights": [],
    "portfolioValue": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/portfolio/construction/investable"

payload <- "{\n  \"assets\": 0,\n  \"assetsGroups\": [],\n  \"assetsGroupsWeights\": [],\n  \"assetsMinimumNotionalValues\": [],\n  \"assetsMinimumPositions\": [],\n  \"assetsPrices\": [],\n  \"assetsSizeLots\": [],\n  \"assetsWeights\": [],\n  \"maximumAssetsGroupsWeights\": [],\n  \"portfolioValue\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/portfolio/construction/investable")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"assets\": 0,\n  \"assetsGroups\": [],\n  \"assetsGroupsWeights\": [],\n  \"assetsMinimumNotionalValues\": [],\n  \"assetsMinimumPositions\": [],\n  \"assetsPrices\": [],\n  \"assetsSizeLots\": [],\n  \"assetsWeights\": [],\n  \"maximumAssetsGroupsWeights\": [],\n  \"portfolioValue\": \"\"\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/portfolio/construction/investable') do |req|
  req.body = "{\n  \"assets\": 0,\n  \"assetsGroups\": [],\n  \"assetsGroupsWeights\": [],\n  \"assetsMinimumNotionalValues\": [],\n  \"assetsMinimumPositions\": [],\n  \"assetsPrices\": [],\n  \"assetsSizeLots\": [],\n  \"assetsWeights\": [],\n  \"maximumAssetsGroupsWeights\": [],\n  \"portfolioValue\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/portfolio/construction/investable";

    let payload = json!({
        "assets": 0,
        "assetsGroups": (),
        "assetsGroupsWeights": (),
        "assetsMinimumNotionalValues": (),
        "assetsMinimumPositions": (),
        "assetsPrices": (),
        "assetsSizeLots": (),
        "assetsWeights": (),
        "maximumAssetsGroupsWeights": (),
        "portfolioValue": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/portfolio/construction/investable \
  --header 'content-type: application/json' \
  --data '{
  "assets": 0,
  "assetsGroups": [],
  "assetsGroupsWeights": [],
  "assetsMinimumNotionalValues": [],
  "assetsMinimumPositions": [],
  "assetsPrices": [],
  "assetsSizeLots": [],
  "assetsWeights": [],
  "maximumAssetsGroupsWeights": [],
  "portfolioValue": ""
}'

echo '{
  "assets": 0,
  "assetsGroups": [],
  "assetsGroupsWeights": [],
  "assetsMinimumNotionalValues": [],
  "assetsMinimumPositions": [],
  "assetsPrices": [],
  "assetsSizeLots": [],
  "assetsWeights": [],
  "maximumAssetsGroupsWeights": [],
  "portfolioValue": ""
}' |  \
  http POST {{baseUrl}}/portfolio/construction/investable \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "assets": 0,\n  "assetsGroups": [],\n  "assetsGroupsWeights": [],\n  "assetsMinimumNotionalValues": [],\n  "assetsMinimumPositions": [],\n  "assetsPrices": [],\n  "assetsSizeLots": [],\n  "assetsWeights": [],\n  "maximumAssetsGroupsWeights": [],\n  "portfolioValue": ""\n}' \
  --output-document \
  - {{baseUrl}}/portfolio/construction/investable

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "assets": 0,
  "assetsGroups": [],
  "assetsGroupsWeights": [],
  "assetsMinimumNotionalValues": [],
  "assetsMinimumPositions": [],
  "assetsPrices": [],
  "assetsSizeLots": [],
  "assetsWeights": [],
  "maximumAssetsGroupsWeights": [],
  "portfolioValue": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/portfolio/construction/investable")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "assetsPositions": [
    200,
    80,
    20,
    4
  ],
  "assetsWeights": [
    0.2,
    0.2,
    0.2,
    0.2
  ]
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "assetsPositions": [
    50,
    240,
    7
  ],
  "assetsWeights": [
    0.05,
    0.6,
    0.35
  ]
}

POST Mimicking Portfolio

{{baseUrl}}/portfolio/construction/mimicking

BODY json

{
  "assets": [
    {
      "assetReturns": []
    }
  ],
  "benchmarkReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  }
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/portfolio/construction/mimicking");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ],\n  \"benchmarkReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/portfolio/construction/mimicking" {:content-type :json
                                                                             :form-params {:assets [{:assetReturns []}]
                                                                                           :benchmarkReturns []
                                                                                           :constraints {:assetsGroups []
                                                                                                         :assetsGroupsMatrix []
                                                                                                         :maximumAssetsGroupsWeights []
                                                                                                         :maximumAssetsWeights []
                                                                                                         :maximumPortfolioExposure ""
                                                                                                         :minimumAssetsWeights []
                                                                                                         :minimumPortfolioExposure ""}}})

require "http/client"

url = "{{baseUrl}}/portfolio/construction/mimicking"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ],\n  \"benchmarkReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/portfolio/construction/mimicking"),
    Content = new StringContent("{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ],\n  \"benchmarkReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/portfolio/construction/mimicking");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ],\n  \"benchmarkReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/portfolio/construction/mimicking"

	payload := strings.NewReader("{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ],\n  \"benchmarkReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}")

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

	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/portfolio/construction/mimicking HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 335

{
  "assets": [
    {
      "assetReturns": []
    }
  ],
  "benchmarkReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/portfolio/construction/mimicking")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ],\n  \"benchmarkReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/portfolio/construction/mimicking"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ],\n  \"benchmarkReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ],\n  \"benchmarkReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/portfolio/construction/mimicking")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/portfolio/construction/mimicking")
  .header("content-type", "application/json")
  .body("{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ],\n  \"benchmarkReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  assets: [
    {
      assetReturns: []
    }
  ],
  benchmarkReturns: [],
  constraints: {
    assetsGroups: [],
    assetsGroupsMatrix: [],
    maximumAssetsGroupsWeights: [],
    maximumAssetsWeights: [],
    maximumPortfolioExposure: '',
    minimumAssetsWeights: [],
    minimumPortfolioExposure: ''
  }
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/portfolio/construction/mimicking');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/construction/mimicking',
  headers: {'content-type': 'application/json'},
  data: {
    assets: [{assetReturns: []}],
    benchmarkReturns: [],
    constraints: {
      assetsGroups: [],
      assetsGroupsMatrix: [],
      maximumAssetsGroupsWeights: [],
      maximumAssetsWeights: [],
      maximumPortfolioExposure: '',
      minimumAssetsWeights: [],
      minimumPortfolioExposure: ''
    }
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/portfolio/construction/mimicking';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":[{"assetReturns":[]}],"benchmarkReturns":[],"constraints":{"assetsGroups":[],"assetsGroupsMatrix":[],"maximumAssetsGroupsWeights":[],"maximumAssetsWeights":[],"maximumPortfolioExposure":"","minimumAssetsWeights":[],"minimumPortfolioExposure":""}}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/portfolio/construction/mimicking',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "assets": [\n    {\n      "assetReturns": []\n    }\n  ],\n  "benchmarkReturns": [],\n  "constraints": {\n    "assetsGroups": [],\n    "assetsGroupsMatrix": [],\n    "maximumAssetsGroupsWeights": [],\n    "maximumAssetsWeights": [],\n    "maximumPortfolioExposure": "",\n    "minimumAssetsWeights": [],\n    "minimumPortfolioExposure": ""\n  }\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ],\n  \"benchmarkReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/portfolio/construction/mimicking")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/portfolio/construction/mimicking',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  assets: [{assetReturns: []}],
  benchmarkReturns: [],
  constraints: {
    assetsGroups: [],
    assetsGroupsMatrix: [],
    maximumAssetsGroupsWeights: [],
    maximumAssetsWeights: [],
    maximumPortfolioExposure: '',
    minimumAssetsWeights: [],
    minimumPortfolioExposure: ''
  }
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/construction/mimicking',
  headers: {'content-type': 'application/json'},
  body: {
    assets: [{assetReturns: []}],
    benchmarkReturns: [],
    constraints: {
      assetsGroups: [],
      assetsGroupsMatrix: [],
      maximumAssetsGroupsWeights: [],
      maximumAssetsWeights: [],
      maximumPortfolioExposure: '',
      minimumAssetsWeights: [],
      minimumPortfolioExposure: ''
    }
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/portfolio/construction/mimicking');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  assets: [
    {
      assetReturns: []
    }
  ],
  benchmarkReturns: [],
  constraints: {
    assetsGroups: [],
    assetsGroupsMatrix: [],
    maximumAssetsGroupsWeights: [],
    maximumAssetsWeights: [],
    maximumPortfolioExposure: '',
    minimumAssetsWeights: [],
    minimumPortfolioExposure: ''
  }
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/construction/mimicking',
  headers: {'content-type': 'application/json'},
  data: {
    assets: [{assetReturns: []}],
    benchmarkReturns: [],
    constraints: {
      assetsGroups: [],
      assetsGroupsMatrix: [],
      maximumAssetsGroupsWeights: [],
      maximumAssetsWeights: [],
      maximumPortfolioExposure: '',
      minimumAssetsWeights: [],
      minimumPortfolioExposure: ''
    }
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/portfolio/construction/mimicking';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":[{"assetReturns":[]}],"benchmarkReturns":[],"constraints":{"assetsGroups":[],"assetsGroupsMatrix":[],"maximumAssetsGroupsWeights":[],"maximumAssetsWeights":[],"maximumPortfolioExposure":"","minimumAssetsWeights":[],"minimumPortfolioExposure":""}}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"assets": @[ @{ @"assetReturns": @[  ] } ],
                              @"benchmarkReturns": @[  ],
                              @"constraints": @{ @"assetsGroups": @[  ], @"assetsGroupsMatrix": @[  ], @"maximumAssetsGroupsWeights": @[  ], @"maximumAssetsWeights": @[  ], @"maximumPortfolioExposure": @"", @"minimumAssetsWeights": @[  ], @"minimumPortfolioExposure": @"" } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/portfolio/construction/mimicking"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/portfolio/construction/mimicking" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ],\n  \"benchmarkReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/portfolio/construction/mimicking",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'assets' => [
        [
                'assetReturns' => [
                                
                ]
        ]
    ],
    'benchmarkReturns' => [
        
    ],
    'constraints' => [
        'assetsGroups' => [
                
        ],
        'assetsGroupsMatrix' => [
                
        ],
        'maximumAssetsGroupsWeights' => [
                
        ],
        'maximumAssetsWeights' => [
                
        ],
        'maximumPortfolioExposure' => '',
        'minimumAssetsWeights' => [
                
        ],
        'minimumPortfolioExposure' => ''
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/portfolio/construction/mimicking', [
  'body' => '{
  "assets": [
    {
      "assetReturns": []
    }
  ],
  "benchmarkReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/portfolio/construction/mimicking');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'assets' => [
    [
        'assetReturns' => [
                
        ]
    ]
  ],
  'benchmarkReturns' => [
    
  ],
  'constraints' => [
    'assetsGroups' => [
        
    ],
    'assetsGroupsMatrix' => [
        
    ],
    'maximumAssetsGroupsWeights' => [
        
    ],
    'maximumAssetsWeights' => [
        
    ],
    'maximumPortfolioExposure' => '',
    'minimumAssetsWeights' => [
        
    ],
    'minimumPortfolioExposure' => ''
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'assets' => [
    [
        'assetReturns' => [
                
        ]
    ]
  ],
  'benchmarkReturns' => [
    
  ],
  'constraints' => [
    'assetsGroups' => [
        
    ],
    'assetsGroupsMatrix' => [
        
    ],
    'maximumAssetsGroupsWeights' => [
        
    ],
    'maximumAssetsWeights' => [
        
    ],
    'maximumPortfolioExposure' => '',
    'minimumAssetsWeights' => [
        
    ],
    'minimumPortfolioExposure' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/portfolio/construction/mimicking');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/portfolio/construction/mimicking' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": [
    {
      "assetReturns": []
    }
  ],
  "benchmarkReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/portfolio/construction/mimicking' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": [
    {
      "assetReturns": []
    }
  ],
  "benchmarkReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  }
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ],\n  \"benchmarkReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/portfolio/construction/mimicking", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/portfolio/construction/mimicking"

payload = {
    "assets": [{ "assetReturns": [] }],
    "benchmarkReturns": [],
    "constraints": {
        "assetsGroups": [],
        "assetsGroupsMatrix": [],
        "maximumAssetsGroupsWeights": [],
        "maximumAssetsWeights": [],
        "maximumPortfolioExposure": "",
        "minimumAssetsWeights": [],
        "minimumPortfolioExposure": ""
    }
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/portfolio/construction/mimicking"

payload <- "{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ],\n  \"benchmarkReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/portfolio/construction/mimicking")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ],\n  \"benchmarkReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/portfolio/construction/mimicking') do |req|
  req.body = "{\n  \"assets\": [\n    {\n      \"assetReturns\": []\n    }\n  ],\n  \"benchmarkReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/portfolio/construction/mimicking";

    let payload = json!({
        "assets": (json!({"assetReturns": ()})),
        "benchmarkReturns": (),
        "constraints": json!({
            "assetsGroups": (),
            "assetsGroupsMatrix": (),
            "maximumAssetsGroupsWeights": (),
            "maximumAssetsWeights": (),
            "maximumPortfolioExposure": "",
            "minimumAssetsWeights": (),
            "minimumPortfolioExposure": ""
        })
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/portfolio/construction/mimicking \
  --header 'content-type: application/json' \
  --data '{
  "assets": [
    {
      "assetReturns": []
    }
  ],
  "benchmarkReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  }
}'

echo '{
  "assets": [
    {
      "assetReturns": []
    }
  ],
  "benchmarkReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  }
}' |  \
  http POST {{baseUrl}}/portfolio/construction/mimicking \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "assets": [\n    {\n      "assetReturns": []\n    }\n  ],\n  "benchmarkReturns": [],\n  "constraints": {\n    "assetsGroups": [],\n    "assetsGroupsMatrix": [],\n    "maximumAssetsGroupsWeights": [],\n    "maximumAssetsWeights": [],\n    "maximumPortfolioExposure": "",\n    "minimumAssetsWeights": [],\n    "minimumPortfolioExposure": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/portfolio/construction/mimicking

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "assets": [["assetReturns": []]],
  "benchmarkReturns": [],
  "constraints": [
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  ]
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/portfolio/construction/mimicking")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "assetsWeights": [
    0.5,
    0.5
  ]
}

POST Random Portfolio

{{baseUrl}}/portfolio/construction/random

BODY json

{
  "assets": 0,
  "constraints": {
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  },
  "portfolios": 0
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/portfolio/construction/random");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"assets\": 0,\n  \"constraints\": {\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"portfolios\": 0\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/portfolio/construction/random" {:content-type :json
                                                                          :form-params {:assets 0
                                                                                        :constraints {:maximumAssetsWeights []
                                                                                                      :maximumPortfolioExposure ""
                                                                                                      :minimumAssetsWeights []
                                                                                                      :minimumPortfolioExposure ""}
                                                                                        :portfolios 0}})

require "http/client"

url = "{{baseUrl}}/portfolio/construction/random"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"assets\": 0,\n  \"constraints\": {\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"portfolios\": 0\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/portfolio/construction/random"),
    Content = new StringContent("{\n  \"assets\": 0,\n  \"constraints\": {\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"portfolios\": 0\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/portfolio/construction/random");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"assets\": 0,\n  \"constraints\": {\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"portfolios\": 0\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/portfolio/construction/random"

	payload := strings.NewReader("{\n  \"assets\": 0,\n  \"constraints\": {\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"portfolios\": 0\n}")

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

	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/portfolio/construction/random HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 195

{
  "assets": 0,
  "constraints": {
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  },
  "portfolios": 0
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/portfolio/construction/random")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"assets\": 0,\n  \"constraints\": {\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"portfolios\": 0\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/portfolio/construction/random"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"assets\": 0,\n  \"constraints\": {\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"portfolios\": 0\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"assets\": 0,\n  \"constraints\": {\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"portfolios\": 0\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/portfolio/construction/random")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/portfolio/construction/random")
  .header("content-type", "application/json")
  .body("{\n  \"assets\": 0,\n  \"constraints\": {\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"portfolios\": 0\n}")
  .asString();

const data = JSON.stringify({
  assets: 0,
  constraints: {
    maximumAssetsWeights: [],
    maximumPortfolioExposure: '',
    minimumAssetsWeights: [],
    minimumPortfolioExposure: ''
  },
  portfolios: 0
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/portfolio/construction/random');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/construction/random',
  headers: {'content-type': 'application/json'},
  data: {
    assets: 0,
    constraints: {
      maximumAssetsWeights: [],
      maximumPortfolioExposure: '',
      minimumAssetsWeights: [],
      minimumPortfolioExposure: ''
    },
    portfolios: 0
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/portfolio/construction/random';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":0,"constraints":{"maximumAssetsWeights":[],"maximumPortfolioExposure":"","minimumAssetsWeights":[],"minimumPortfolioExposure":""},"portfolios":0}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/portfolio/construction/random',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "assets": 0,\n  "constraints": {\n    "maximumAssetsWeights": [],\n    "maximumPortfolioExposure": "",\n    "minimumAssetsWeights": [],\n    "minimumPortfolioExposure": ""\n  },\n  "portfolios": 0\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"assets\": 0,\n  \"constraints\": {\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"portfolios\": 0\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/portfolio/construction/random")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/portfolio/construction/random',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  assets: 0,
  constraints: {
    maximumAssetsWeights: [],
    maximumPortfolioExposure: '',
    minimumAssetsWeights: [],
    minimumPortfolioExposure: ''
  },
  portfolios: 0
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/construction/random',
  headers: {'content-type': 'application/json'},
  body: {
    assets: 0,
    constraints: {
      maximumAssetsWeights: [],
      maximumPortfolioExposure: '',
      minimumAssetsWeights: [],
      minimumPortfolioExposure: ''
    },
    portfolios: 0
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/portfolio/construction/random');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  assets: 0,
  constraints: {
    maximumAssetsWeights: [],
    maximumPortfolioExposure: '',
    minimumAssetsWeights: [],
    minimumPortfolioExposure: ''
  },
  portfolios: 0
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/construction/random',
  headers: {'content-type': 'application/json'},
  data: {
    assets: 0,
    constraints: {
      maximumAssetsWeights: [],
      maximumPortfolioExposure: '',
      minimumAssetsWeights: [],
      minimumPortfolioExposure: ''
    },
    portfolios: 0
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/portfolio/construction/random';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":0,"constraints":{"maximumAssetsWeights":[],"maximumPortfolioExposure":"","minimumAssetsWeights":[],"minimumPortfolioExposure":""},"portfolios":0}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"assets": @0,
                              @"constraints": @{ @"maximumAssetsWeights": @[  ], @"maximumPortfolioExposure": @"", @"minimumAssetsWeights": @[  ], @"minimumPortfolioExposure": @"" },
                              @"portfolios": @0 };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/portfolio/construction/random"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/portfolio/construction/random" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"assets\": 0,\n  \"constraints\": {\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"portfolios\": 0\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/portfolio/construction/random",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'assets' => 0,
    'constraints' => [
        'maximumAssetsWeights' => [
                
        ],
        'maximumPortfolioExposure' => '',
        'minimumAssetsWeights' => [
                
        ],
        'minimumPortfolioExposure' => ''
    ],
    'portfolios' => 0
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/portfolio/construction/random', [
  'body' => '{
  "assets": 0,
  "constraints": {
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  },
  "portfolios": 0
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/portfolio/construction/random');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'assets' => 0,
  'constraints' => [
    'maximumAssetsWeights' => [
        
    ],
    'maximumPortfolioExposure' => '',
    'minimumAssetsWeights' => [
        
    ],
    'minimumPortfolioExposure' => ''
  ],
  'portfolios' => 0
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'assets' => 0,
  'constraints' => [
    'maximumAssetsWeights' => [
        
    ],
    'maximumPortfolioExposure' => '',
    'minimumAssetsWeights' => [
        
    ],
    'minimumPortfolioExposure' => ''
  ],
  'portfolios' => 0
]));
$request->setRequestUrl('{{baseUrl}}/portfolio/construction/random');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/portfolio/construction/random' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": 0,
  "constraints": {
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  },
  "portfolios": 0
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/portfolio/construction/random' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": 0,
  "constraints": {
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  },
  "portfolios": 0
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"assets\": 0,\n  \"constraints\": {\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"portfolios\": 0\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/portfolio/construction/random", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/portfolio/construction/random"

payload = {
    "assets": 0,
    "constraints": {
        "maximumAssetsWeights": [],
        "maximumPortfolioExposure": "",
        "minimumAssetsWeights": [],
        "minimumPortfolioExposure": ""
    },
    "portfolios": 0
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/portfolio/construction/random"

payload <- "{\n  \"assets\": 0,\n  \"constraints\": {\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"portfolios\": 0\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/portfolio/construction/random")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"assets\": 0,\n  \"constraints\": {\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"portfolios\": 0\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/portfolio/construction/random') do |req|
  req.body = "{\n  \"assets\": 0,\n  \"constraints\": {\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"portfolios\": 0\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/portfolio/construction/random";

    let payload = json!({
        "assets": 0,
        "constraints": json!({
            "maximumAssetsWeights": (),
            "maximumPortfolioExposure": "",
            "minimumAssetsWeights": (),
            "minimumPortfolioExposure": ""
        }),
        "portfolios": 0
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/portfolio/construction/random \
  --header 'content-type: application/json' \
  --data '{
  "assets": 0,
  "constraints": {
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  },
  "portfolios": 0
}'

echo '{
  "assets": 0,
  "constraints": {
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  },
  "portfolios": 0
}' |  \
  http POST {{baseUrl}}/portfolio/construction/random \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "assets": 0,\n  "constraints": {\n    "maximumAssetsWeights": [],\n    "maximumPortfolioExposure": "",\n    "minimumAssetsWeights": [],\n    "minimumPortfolioExposure": ""\n  },\n  "portfolios": 0\n}' \
  --output-document \
  - {{baseUrl}}/portfolio/construction/random

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "assets": 0,
  "constraints": [
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  ],
  "portfolios": 0
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/portfolio/construction/random")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "portfolios": [
    {
      "assetsWeights": [
        0.11429744284625785,
        0.0038592674702259393,
        0.8818432896835162
      ]
    },
    {
      "assetsWeights": [
        0.546026607601722,
        0.07707923859010406,
        0.376894153808174
      ]
    }
  ]
}

POST Equal Risk Contributions Portfolio

{{baseUrl}}/portfolio/optimization/equal-risk-contributions

BODY json

{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "constraints": {
    "maximumAssetsWeights": [],
    "minimumAssetsWeights": []
  }
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/portfolio/optimization/equal-risk-contributions");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"constraints\": {\n    \"maximumAssetsWeights\": [],\n    \"minimumAssetsWeights\": []\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/portfolio/optimization/equal-risk-contributions" {:content-type :json
                                                                                            :form-params {:assets 0
                                                                                                          :assetsCovarianceMatrix []
                                                                                                          :constraints {:maximumAssetsWeights []
                                                                                                                        :minimumAssetsWeights []}}})

require "http/client"

url = "{{baseUrl}}/portfolio/optimization/equal-risk-contributions"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"constraints\": {\n    \"maximumAssetsWeights\": [],\n    \"minimumAssetsWeights\": []\n  }\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/portfolio/optimization/equal-risk-contributions"),
    Content = new StringContent("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"constraints\": {\n    \"maximumAssetsWeights\": [],\n    \"minimumAssetsWeights\": []\n  }\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/portfolio/optimization/equal-risk-contributions");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"constraints\": {\n    \"maximumAssetsWeights\": [],\n    \"minimumAssetsWeights\": []\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/portfolio/optimization/equal-risk-contributions"

	payload := strings.NewReader("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"constraints\": {\n    \"maximumAssetsWeights\": [],\n    \"minimumAssetsWeights\": []\n  }\n}")

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

	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/portfolio/optimization/equal-risk-contributions HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 136

{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "constraints": {
    "maximumAssetsWeights": [],
    "minimumAssetsWeights": []
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/portfolio/optimization/equal-risk-contributions")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"constraints\": {\n    \"maximumAssetsWeights\": [],\n    \"minimumAssetsWeights\": []\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/portfolio/optimization/equal-risk-contributions"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"constraints\": {\n    \"maximumAssetsWeights\": [],\n    \"minimumAssetsWeights\": []\n  }\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"constraints\": {\n    \"maximumAssetsWeights\": [],\n    \"minimumAssetsWeights\": []\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/portfolio/optimization/equal-risk-contributions")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/portfolio/optimization/equal-risk-contributions")
  .header("content-type", "application/json")
  .body("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"constraints\": {\n    \"maximumAssetsWeights\": [],\n    \"minimumAssetsWeights\": []\n  }\n}")
  .asString();

const data = JSON.stringify({
  assets: 0,
  assetsCovarianceMatrix: [],
  constraints: {
    maximumAssetsWeights: [],
    minimumAssetsWeights: []
  }
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/portfolio/optimization/equal-risk-contributions');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/optimization/equal-risk-contributions',
  headers: {'content-type': 'application/json'},
  data: {
    assets: 0,
    assetsCovarianceMatrix: [],
    constraints: {maximumAssetsWeights: [], minimumAssetsWeights: []}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/portfolio/optimization/equal-risk-contributions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":0,"assetsCovarianceMatrix":[],"constraints":{"maximumAssetsWeights":[],"minimumAssetsWeights":[]}}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/portfolio/optimization/equal-risk-contributions',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "assets": 0,\n  "assetsCovarianceMatrix": [],\n  "constraints": {\n    "maximumAssetsWeights": [],\n    "minimumAssetsWeights": []\n  }\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"constraints\": {\n    \"maximumAssetsWeights\": [],\n    \"minimumAssetsWeights\": []\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/portfolio/optimization/equal-risk-contributions")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/portfolio/optimization/equal-risk-contributions',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  assets: 0,
  assetsCovarianceMatrix: [],
  constraints: {maximumAssetsWeights: [], minimumAssetsWeights: []}
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/optimization/equal-risk-contributions',
  headers: {'content-type': 'application/json'},
  body: {
    assets: 0,
    assetsCovarianceMatrix: [],
    constraints: {maximumAssetsWeights: [], minimumAssetsWeights: []}
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/portfolio/optimization/equal-risk-contributions');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  assets: 0,
  assetsCovarianceMatrix: [],
  constraints: {
    maximumAssetsWeights: [],
    minimumAssetsWeights: []
  }
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/optimization/equal-risk-contributions',
  headers: {'content-type': 'application/json'},
  data: {
    assets: 0,
    assetsCovarianceMatrix: [],
    constraints: {maximumAssetsWeights: [], minimumAssetsWeights: []}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/portfolio/optimization/equal-risk-contributions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":0,"assetsCovarianceMatrix":[],"constraints":{"maximumAssetsWeights":[],"minimumAssetsWeights":[]}}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"assets": @0,
                              @"assetsCovarianceMatrix": @[  ],
                              @"constraints": @{ @"maximumAssetsWeights": @[  ], @"minimumAssetsWeights": @[  ] } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/portfolio/optimization/equal-risk-contributions"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/portfolio/optimization/equal-risk-contributions" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"constraints\": {\n    \"maximumAssetsWeights\": [],\n    \"minimumAssetsWeights\": []\n  }\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/portfolio/optimization/equal-risk-contributions",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'assets' => 0,
    'assetsCovarianceMatrix' => [
        
    ],
    'constraints' => [
        'maximumAssetsWeights' => [
                
        ],
        'minimumAssetsWeights' => [
                
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/portfolio/optimization/equal-risk-contributions', [
  'body' => '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "constraints": {
    "maximumAssetsWeights": [],
    "minimumAssetsWeights": []
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/portfolio/optimization/equal-risk-contributions');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'assets' => 0,
  'assetsCovarianceMatrix' => [
    
  ],
  'constraints' => [
    'maximumAssetsWeights' => [
        
    ],
    'minimumAssetsWeights' => [
        
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'assets' => 0,
  'assetsCovarianceMatrix' => [
    
  ],
  'constraints' => [
    'maximumAssetsWeights' => [
        
    ],
    'minimumAssetsWeights' => [
        
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/portfolio/optimization/equal-risk-contributions');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/portfolio/optimization/equal-risk-contributions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "constraints": {
    "maximumAssetsWeights": [],
    "minimumAssetsWeights": []
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/portfolio/optimization/equal-risk-contributions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "constraints": {
    "maximumAssetsWeights": [],
    "minimumAssetsWeights": []
  }
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"constraints\": {\n    \"maximumAssetsWeights\": [],\n    \"minimumAssetsWeights\": []\n  }\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/portfolio/optimization/equal-risk-contributions", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/portfolio/optimization/equal-risk-contributions"

payload = {
    "assets": 0,
    "assetsCovarianceMatrix": [],
    "constraints": {
        "maximumAssetsWeights": [],
        "minimumAssetsWeights": []
    }
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/portfolio/optimization/equal-risk-contributions"

payload <- "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"constraints\": {\n    \"maximumAssetsWeights\": [],\n    \"minimumAssetsWeights\": []\n  }\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/portfolio/optimization/equal-risk-contributions")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"constraints\": {\n    \"maximumAssetsWeights\": [],\n    \"minimumAssetsWeights\": []\n  }\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/portfolio/optimization/equal-risk-contributions') do |req|
  req.body = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"constraints\": {\n    \"maximumAssetsWeights\": [],\n    \"minimumAssetsWeights\": []\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/portfolio/optimization/equal-risk-contributions";

    let payload = json!({
        "assets": 0,
        "assetsCovarianceMatrix": (),
        "constraints": json!({
            "maximumAssetsWeights": (),
            "minimumAssetsWeights": ()
        })
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/portfolio/optimization/equal-risk-contributions \
  --header 'content-type: application/json' \
  --data '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "constraints": {
    "maximumAssetsWeights": [],
    "minimumAssetsWeights": []
  }
}'

echo '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "constraints": {
    "maximumAssetsWeights": [],
    "minimumAssetsWeights": []
  }
}' |  \
  http POST {{baseUrl}}/portfolio/optimization/equal-risk-contributions \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "assets": 0,\n  "assetsCovarianceMatrix": [],\n  "constraints": {\n    "maximumAssetsWeights": [],\n    "minimumAssetsWeights": []\n  }\n}' \
  --output-document \
  - {{baseUrl}}/portfolio/optimization/equal-risk-contributions

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "constraints": [
    "maximumAssetsWeights": [],
    "minimumAssetsWeights": []
  ]
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/portfolio/optimization/equal-risk-contributions")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "assetsWeights": [
    0.4,
    0.5999975015091795
  ]
}

POST Equal Sharpe Ratio Contributions Portfolio

{{baseUrl}}/portfolio/optimization/equal-sharpe-ratio-contributions

BODY json

{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "riskFreeRate": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/portfolio/optimization/equal-sharpe-ratio-contributions");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"riskFreeRate\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/portfolio/optimization/equal-sharpe-ratio-contributions" {:content-type :json
                                                                                                    :form-params {:assets 0
                                                                                                                  :assetsCovarianceMatrix []
                                                                                                                  :assetsReturns []
                                                                                                                  :riskFreeRate ""}})

require "http/client"

url = "{{baseUrl}}/portfolio/optimization/equal-sharpe-ratio-contributions"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"riskFreeRate\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/portfolio/optimization/equal-sharpe-ratio-contributions"),
    Content = new StringContent("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"riskFreeRate\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/portfolio/optimization/equal-sharpe-ratio-contributions");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"riskFreeRate\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/portfolio/optimization/equal-sharpe-ratio-contributions"

	payload := strings.NewReader("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"riskFreeRate\": \"\"\n}")

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

	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/portfolio/optimization/equal-sharpe-ratio-contributions HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 94

{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "riskFreeRate": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/portfolio/optimization/equal-sharpe-ratio-contributions")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"riskFreeRate\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/portfolio/optimization/equal-sharpe-ratio-contributions"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"riskFreeRate\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"riskFreeRate\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/portfolio/optimization/equal-sharpe-ratio-contributions")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/portfolio/optimization/equal-sharpe-ratio-contributions")
  .header("content-type", "application/json")
  .body("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"riskFreeRate\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  assets: 0,
  assetsCovarianceMatrix: [],
  assetsReturns: [],
  riskFreeRate: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/portfolio/optimization/equal-sharpe-ratio-contributions');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/optimization/equal-sharpe-ratio-contributions',
  headers: {'content-type': 'application/json'},
  data: {assets: 0, assetsCovarianceMatrix: [], assetsReturns: [], riskFreeRate: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/portfolio/optimization/equal-sharpe-ratio-contributions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":0,"assetsCovarianceMatrix":[],"assetsReturns":[],"riskFreeRate":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/portfolio/optimization/equal-sharpe-ratio-contributions',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "assets": 0,\n  "assetsCovarianceMatrix": [],\n  "assetsReturns": [],\n  "riskFreeRate": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"riskFreeRate\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/portfolio/optimization/equal-sharpe-ratio-contributions")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/portfolio/optimization/equal-sharpe-ratio-contributions',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({assets: 0, assetsCovarianceMatrix: [], assetsReturns: [], riskFreeRate: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/optimization/equal-sharpe-ratio-contributions',
  headers: {'content-type': 'application/json'},
  body: {assets: 0, assetsCovarianceMatrix: [], assetsReturns: [], riskFreeRate: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/portfolio/optimization/equal-sharpe-ratio-contributions');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  assets: 0,
  assetsCovarianceMatrix: [],
  assetsReturns: [],
  riskFreeRate: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/optimization/equal-sharpe-ratio-contributions',
  headers: {'content-type': 'application/json'},
  data: {assets: 0, assetsCovarianceMatrix: [], assetsReturns: [], riskFreeRate: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/portfolio/optimization/equal-sharpe-ratio-contributions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":0,"assetsCovarianceMatrix":[],"assetsReturns":[],"riskFreeRate":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"assets": @0,
                              @"assetsCovarianceMatrix": @[  ],
                              @"assetsReturns": @[  ],
                              @"riskFreeRate": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/portfolio/optimization/equal-sharpe-ratio-contributions"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/portfolio/optimization/equal-sharpe-ratio-contributions" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"riskFreeRate\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/portfolio/optimization/equal-sharpe-ratio-contributions",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'assets' => 0,
    'assetsCovarianceMatrix' => [
        
    ],
    'assetsReturns' => [
        
    ],
    'riskFreeRate' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/portfolio/optimization/equal-sharpe-ratio-contributions', [
  'body' => '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "riskFreeRate": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/portfolio/optimization/equal-sharpe-ratio-contributions');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'assets' => 0,
  'assetsCovarianceMatrix' => [
    
  ],
  'assetsReturns' => [
    
  ],
  'riskFreeRate' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'assets' => 0,
  'assetsCovarianceMatrix' => [
    
  ],
  'assetsReturns' => [
    
  ],
  'riskFreeRate' => ''
]));
$request->setRequestUrl('{{baseUrl}}/portfolio/optimization/equal-sharpe-ratio-contributions');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/portfolio/optimization/equal-sharpe-ratio-contributions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "riskFreeRate": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/portfolio/optimization/equal-sharpe-ratio-contributions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "riskFreeRate": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"riskFreeRate\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/portfolio/optimization/equal-sharpe-ratio-contributions", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/portfolio/optimization/equal-sharpe-ratio-contributions"

payload = {
    "assets": 0,
    "assetsCovarianceMatrix": [],
    "assetsReturns": [],
    "riskFreeRate": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/portfolio/optimization/equal-sharpe-ratio-contributions"

payload <- "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"riskFreeRate\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/portfolio/optimization/equal-sharpe-ratio-contributions")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"riskFreeRate\": \"\"\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/portfolio/optimization/equal-sharpe-ratio-contributions') do |req|
  req.body = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"riskFreeRate\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/portfolio/optimization/equal-sharpe-ratio-contributions";

    let payload = json!({
        "assets": 0,
        "assetsCovarianceMatrix": (),
        "assetsReturns": (),
        "riskFreeRate": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/portfolio/optimization/equal-sharpe-ratio-contributions \
  --header 'content-type: application/json' \
  --data '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "riskFreeRate": ""
}'

echo '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "riskFreeRate": ""
}' |  \
  http POST {{baseUrl}}/portfolio/optimization/equal-sharpe-ratio-contributions \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "assets": 0,\n  "assetsCovarianceMatrix": [],\n  "assetsReturns": [],\n  "riskFreeRate": ""\n}' \
  --output-document \
  - {{baseUrl}}/portfolio/optimization/equal-sharpe-ratio-contributions

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "riskFreeRate": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/portfolio/optimization/equal-sharpe-ratio-contributions")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "assetsWeights": [
    0.6666666666666666,
    0.3333333333333333
  ]
}

POST Equal Volatility Weighted Portfolio

{{baseUrl}}/portfolio/optimization/equal-volatility-weighted

BODY json

{
  "assets": 0,
  "assetsVolatilities": []
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/portfolio/optimization/equal-volatility-weighted");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"assets\": 0,\n  \"assetsVolatilities\": []\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/portfolio/optimization/equal-volatility-weighted" {:content-type :json
                                                                                             :form-params {:assets 0
                                                                                                           :assetsVolatilities []}})

require "http/client"

url = "{{baseUrl}}/portfolio/optimization/equal-volatility-weighted"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"assets\": 0,\n  \"assetsVolatilities\": []\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/portfolio/optimization/equal-volatility-weighted"),
    Content = new StringContent("{\n  \"assets\": 0,\n  \"assetsVolatilities\": []\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/portfolio/optimization/equal-volatility-weighted");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"assets\": 0,\n  \"assetsVolatilities\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/portfolio/optimization/equal-volatility-weighted"

	payload := strings.NewReader("{\n  \"assets\": 0,\n  \"assetsVolatilities\": []\n}")

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

	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/portfolio/optimization/equal-volatility-weighted HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 45

{
  "assets": 0,
  "assetsVolatilities": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/portfolio/optimization/equal-volatility-weighted")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"assets\": 0,\n  \"assetsVolatilities\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/portfolio/optimization/equal-volatility-weighted"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"assets\": 0,\n  \"assetsVolatilities\": []\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"assets\": 0,\n  \"assetsVolatilities\": []\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/portfolio/optimization/equal-volatility-weighted")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/portfolio/optimization/equal-volatility-weighted")
  .header("content-type", "application/json")
  .body("{\n  \"assets\": 0,\n  \"assetsVolatilities\": []\n}")
  .asString();

const data = JSON.stringify({
  assets: 0,
  assetsVolatilities: []
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/portfolio/optimization/equal-volatility-weighted');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/optimization/equal-volatility-weighted',
  headers: {'content-type': 'application/json'},
  data: {assets: 0, assetsVolatilities: []}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/portfolio/optimization/equal-volatility-weighted';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":0,"assetsVolatilities":[]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/portfolio/optimization/equal-volatility-weighted',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "assets": 0,\n  "assetsVolatilities": []\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"assets\": 0,\n  \"assetsVolatilities\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/portfolio/optimization/equal-volatility-weighted")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/portfolio/optimization/equal-volatility-weighted',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({assets: 0, assetsVolatilities: []}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/optimization/equal-volatility-weighted',
  headers: {'content-type': 'application/json'},
  body: {assets: 0, assetsVolatilities: []},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/portfolio/optimization/equal-volatility-weighted');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  assets: 0,
  assetsVolatilities: []
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/optimization/equal-volatility-weighted',
  headers: {'content-type': 'application/json'},
  data: {assets: 0, assetsVolatilities: []}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/portfolio/optimization/equal-volatility-weighted';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":0,"assetsVolatilities":[]}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"assets": @0,
                              @"assetsVolatilities": @[  ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/portfolio/optimization/equal-volatility-weighted"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/portfolio/optimization/equal-volatility-weighted" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"assets\": 0,\n  \"assetsVolatilities\": []\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/portfolio/optimization/equal-volatility-weighted",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'assets' => 0,
    'assetsVolatilities' => [
        
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/portfolio/optimization/equal-volatility-weighted', [
  'body' => '{
  "assets": 0,
  "assetsVolatilities": []
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/portfolio/optimization/equal-volatility-weighted');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'assets' => 0,
  'assetsVolatilities' => [
    
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'assets' => 0,
  'assetsVolatilities' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/portfolio/optimization/equal-volatility-weighted');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/portfolio/optimization/equal-volatility-weighted' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": 0,
  "assetsVolatilities": []
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/portfolio/optimization/equal-volatility-weighted' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": 0,
  "assetsVolatilities": []
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"assets\": 0,\n  \"assetsVolatilities\": []\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/portfolio/optimization/equal-volatility-weighted", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/portfolio/optimization/equal-volatility-weighted"

payload = {
    "assets": 0,
    "assetsVolatilities": []
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/portfolio/optimization/equal-volatility-weighted"

payload <- "{\n  \"assets\": 0,\n  \"assetsVolatilities\": []\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/portfolio/optimization/equal-volatility-weighted")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"assets\": 0,\n  \"assetsVolatilities\": []\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/portfolio/optimization/equal-volatility-weighted') do |req|
  req.body = "{\n  \"assets\": 0,\n  \"assetsVolatilities\": []\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/portfolio/optimization/equal-volatility-weighted";

    let payload = json!({
        "assets": 0,
        "assetsVolatilities": ()
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/portfolio/optimization/equal-volatility-weighted \
  --header 'content-type: application/json' \
  --data '{
  "assets": 0,
  "assetsVolatilities": []
}'

echo '{
  "assets": 0,
  "assetsVolatilities": []
}' |  \
  http POST {{baseUrl}}/portfolio/optimization/equal-volatility-weighted \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "assets": 0,\n  "assetsVolatilities": []\n}' \
  --output-document \
  - {{baseUrl}}/portfolio/optimization/equal-volatility-weighted

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "assets": 0,
  "assetsVolatilities": []
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/portfolio/optimization/equal-volatility-weighted")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "assetsWeights": [
    0.3333333333333333,
    0.6666666666666666
  ]
}

POST Equal Weighted Portfolio

{{baseUrl}}/portfolio/optimization/equal-weighted

BODY json

{
  "assets": 0
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/portfolio/optimization/equal-weighted");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"assets\": 0\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/portfolio/optimization/equal-weighted" {:content-type :json
                                                                                  :form-params {:assets 0}})

require "http/client"

url = "{{baseUrl}}/portfolio/optimization/equal-weighted"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"assets\": 0\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/portfolio/optimization/equal-weighted"),
    Content = new StringContent("{\n  \"assets\": 0\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/portfolio/optimization/equal-weighted");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"assets\": 0\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/portfolio/optimization/equal-weighted"

	payload := strings.NewReader("{\n  \"assets\": 0\n}")

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

	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/portfolio/optimization/equal-weighted HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 17

{
  "assets": 0
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/portfolio/optimization/equal-weighted")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"assets\": 0\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/portfolio/optimization/equal-weighted"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"assets\": 0\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"assets\": 0\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/portfolio/optimization/equal-weighted")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/portfolio/optimization/equal-weighted")
  .header("content-type", "application/json")
  .body("{\n  \"assets\": 0\n}")
  .asString();

const data = JSON.stringify({
  assets: 0
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/portfolio/optimization/equal-weighted');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/optimization/equal-weighted',
  headers: {'content-type': 'application/json'},
  data: {assets: 0}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/portfolio/optimization/equal-weighted';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":0}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/portfolio/optimization/equal-weighted',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "assets": 0\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"assets\": 0\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/portfolio/optimization/equal-weighted")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/portfolio/optimization/equal-weighted',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({assets: 0}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/optimization/equal-weighted',
  headers: {'content-type': 'application/json'},
  body: {assets: 0},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/portfolio/optimization/equal-weighted');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  assets: 0
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/optimization/equal-weighted',
  headers: {'content-type': 'application/json'},
  data: {assets: 0}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/portfolio/optimization/equal-weighted';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":0}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"assets": @0 };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/portfolio/optimization/equal-weighted"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/portfolio/optimization/equal-weighted" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"assets\": 0\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/portfolio/optimization/equal-weighted",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'assets' => 0
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/portfolio/optimization/equal-weighted', [
  'body' => '{
  "assets": 0
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/portfolio/optimization/equal-weighted');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'assets' => 0
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'assets' => 0
]));
$request->setRequestUrl('{{baseUrl}}/portfolio/optimization/equal-weighted');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/portfolio/optimization/equal-weighted' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": 0
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/portfolio/optimization/equal-weighted' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": 0
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"assets\": 0\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/portfolio/optimization/equal-weighted", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/portfolio/optimization/equal-weighted"

payload = { "assets": 0 }
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/portfolio/optimization/equal-weighted"

payload <- "{\n  \"assets\": 0\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/portfolio/optimization/equal-weighted")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"assets\": 0\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/portfolio/optimization/equal-weighted') do |req|
  req.body = "{\n  \"assets\": 0\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/portfolio/optimization/equal-weighted";

    let payload = json!({"assets": 0});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/portfolio/optimization/equal-weighted \
  --header 'content-type: application/json' \
  --data '{
  "assets": 0
}'

echo '{
  "assets": 0
}' |  \
  http POST {{baseUrl}}/portfolio/optimization/equal-weighted \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "assets": 0\n}' \
  --output-document \
  - {{baseUrl}}/portfolio/optimization/equal-weighted

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["assets": 0] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/portfolio/optimization/equal-weighted")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "assetsWeights": [
    0.5,
    0.5
  ]
}

POST Hierarchical Clustering-Based Risk Parity Portfolio

{{baseUrl}}/portfolio/optimization/hierarchical-risk-parity/clustering-based

BODY json

{
  "acrossClusterAllocationMethod": "",
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "clusteringMethod": "",
  "clusteringOrdering": "",
  "clusters": 0,
  "constraints": {
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  },
  "withinClusterAllocationMethod": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/portfolio/optimization/hierarchical-risk-parity/clustering-based");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"acrossClusterAllocationMethod\": \"\",\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"clusteringMethod\": \"\",\n  \"clusteringOrdering\": \"\",\n  \"clusters\": 0,\n  \"constraints\": {\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"withinClusterAllocationMethod\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/portfolio/optimization/hierarchical-risk-parity/clustering-based" {:content-type :json
                                                                                                             :form-params {:acrossClusterAllocationMethod ""
                                                                                                                           :assets 0
                                                                                                                           :assetsCovarianceMatrix []
                                                                                                                           :clusteringMethod ""
                                                                                                                           :clusteringOrdering ""
                                                                                                                           :clusters 0
                                                                                                                           :constraints {:maximumAssetsWeights []
                                                                                                                                         :maximumPortfolioExposure ""
                                                                                                                                         :minimumAssetsWeights []
                                                                                                                                         :minimumPortfolioExposure ""}
                                                                                                                           :withinClusterAllocationMethod ""}})

require "http/client"

url = "{{baseUrl}}/portfolio/optimization/hierarchical-risk-parity/clustering-based"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"acrossClusterAllocationMethod\": \"\",\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"clusteringMethod\": \"\",\n  \"clusteringOrdering\": \"\",\n  \"clusters\": 0,\n  \"constraints\": {\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"withinClusterAllocationMethod\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/portfolio/optimization/hierarchical-risk-parity/clustering-based"),
    Content = new StringContent("{\n  \"acrossClusterAllocationMethod\": \"\",\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"clusteringMethod\": \"\",\n  \"clusteringOrdering\": \"\",\n  \"clusters\": 0,\n  \"constraints\": {\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"withinClusterAllocationMethod\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/portfolio/optimization/hierarchical-risk-parity/clustering-based");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"acrossClusterAllocationMethod\": \"\",\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"clusteringMethod\": \"\",\n  \"clusteringOrdering\": \"\",\n  \"clusters\": 0,\n  \"constraints\": {\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"withinClusterAllocationMethod\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/portfolio/optimization/hierarchical-risk-parity/clustering-based"

	payload := strings.NewReader("{\n  \"acrossClusterAllocationMethod\": \"\",\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"clusteringMethod\": \"\",\n  \"clusteringOrdering\": \"\",\n  \"clusters\": 0,\n  \"constraints\": {\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"withinClusterAllocationMethod\": \"\"\n}")

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

	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/portfolio/optimization/hierarchical-risk-parity/clustering-based HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 357

{
  "acrossClusterAllocationMethod": "",
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "clusteringMethod": "",
  "clusteringOrdering": "",
  "clusters": 0,
  "constraints": {
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  },
  "withinClusterAllocationMethod": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/portfolio/optimization/hierarchical-risk-parity/clustering-based")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"acrossClusterAllocationMethod\": \"\",\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"clusteringMethod\": \"\",\n  \"clusteringOrdering\": \"\",\n  \"clusters\": 0,\n  \"constraints\": {\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"withinClusterAllocationMethod\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/portfolio/optimization/hierarchical-risk-parity/clustering-based"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"acrossClusterAllocationMethod\": \"\",\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"clusteringMethod\": \"\",\n  \"clusteringOrdering\": \"\",\n  \"clusters\": 0,\n  \"constraints\": {\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"withinClusterAllocationMethod\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"acrossClusterAllocationMethod\": \"\",\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"clusteringMethod\": \"\",\n  \"clusteringOrdering\": \"\",\n  \"clusters\": 0,\n  \"constraints\": {\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"withinClusterAllocationMethod\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/portfolio/optimization/hierarchical-risk-parity/clustering-based")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/portfolio/optimization/hierarchical-risk-parity/clustering-based")
  .header("content-type", "application/json")
  .body("{\n  \"acrossClusterAllocationMethod\": \"\",\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"clusteringMethod\": \"\",\n  \"clusteringOrdering\": \"\",\n  \"clusters\": 0,\n  \"constraints\": {\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"withinClusterAllocationMethod\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  acrossClusterAllocationMethod: '',
  assets: 0,
  assetsCovarianceMatrix: [],
  clusteringMethod: '',
  clusteringOrdering: '',
  clusters: 0,
  constraints: {
    maximumAssetsWeights: [],
    maximumPortfolioExposure: '',
    minimumAssetsWeights: [],
    minimumPortfolioExposure: ''
  },
  withinClusterAllocationMethod: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/portfolio/optimization/hierarchical-risk-parity/clustering-based');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/optimization/hierarchical-risk-parity/clustering-based',
  headers: {'content-type': 'application/json'},
  data: {
    acrossClusterAllocationMethod: '',
    assets: 0,
    assetsCovarianceMatrix: [],
    clusteringMethod: '',
    clusteringOrdering: '',
    clusters: 0,
    constraints: {
      maximumAssetsWeights: [],
      maximumPortfolioExposure: '',
      minimumAssetsWeights: [],
      minimumPortfolioExposure: ''
    },
    withinClusterAllocationMethod: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/portfolio/optimization/hierarchical-risk-parity/clustering-based';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"acrossClusterAllocationMethod":"","assets":0,"assetsCovarianceMatrix":[],"clusteringMethod":"","clusteringOrdering":"","clusters":0,"constraints":{"maximumAssetsWeights":[],"maximumPortfolioExposure":"","minimumAssetsWeights":[],"minimumPortfolioExposure":""},"withinClusterAllocationMethod":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/portfolio/optimization/hierarchical-risk-parity/clustering-based',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "acrossClusterAllocationMethod": "",\n  "assets": 0,\n  "assetsCovarianceMatrix": [],\n  "clusteringMethod": "",\n  "clusteringOrdering": "",\n  "clusters": 0,\n  "constraints": {\n    "maximumAssetsWeights": [],\n    "maximumPortfolioExposure": "",\n    "minimumAssetsWeights": [],\n    "minimumPortfolioExposure": ""\n  },\n  "withinClusterAllocationMethod": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"acrossClusterAllocationMethod\": \"\",\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"clusteringMethod\": \"\",\n  \"clusteringOrdering\": \"\",\n  \"clusters\": 0,\n  \"constraints\": {\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"withinClusterAllocationMethod\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/portfolio/optimization/hierarchical-risk-parity/clustering-based")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/portfolio/optimization/hierarchical-risk-parity/clustering-based',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  acrossClusterAllocationMethod: '',
  assets: 0,
  assetsCovarianceMatrix: [],
  clusteringMethod: '',
  clusteringOrdering: '',
  clusters: 0,
  constraints: {
    maximumAssetsWeights: [],
    maximumPortfolioExposure: '',
    minimumAssetsWeights: [],
    minimumPortfolioExposure: ''
  },
  withinClusterAllocationMethod: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/optimization/hierarchical-risk-parity/clustering-based',
  headers: {'content-type': 'application/json'},
  body: {
    acrossClusterAllocationMethod: '',
    assets: 0,
    assetsCovarianceMatrix: [],
    clusteringMethod: '',
    clusteringOrdering: '',
    clusters: 0,
    constraints: {
      maximumAssetsWeights: [],
      maximumPortfolioExposure: '',
      minimumAssetsWeights: [],
      minimumPortfolioExposure: ''
    },
    withinClusterAllocationMethod: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/portfolio/optimization/hierarchical-risk-parity/clustering-based');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  acrossClusterAllocationMethod: '',
  assets: 0,
  assetsCovarianceMatrix: [],
  clusteringMethod: '',
  clusteringOrdering: '',
  clusters: 0,
  constraints: {
    maximumAssetsWeights: [],
    maximumPortfolioExposure: '',
    minimumAssetsWeights: [],
    minimumPortfolioExposure: ''
  },
  withinClusterAllocationMethod: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/optimization/hierarchical-risk-parity/clustering-based',
  headers: {'content-type': 'application/json'},
  data: {
    acrossClusterAllocationMethod: '',
    assets: 0,
    assetsCovarianceMatrix: [],
    clusteringMethod: '',
    clusteringOrdering: '',
    clusters: 0,
    constraints: {
      maximumAssetsWeights: [],
      maximumPortfolioExposure: '',
      minimumAssetsWeights: [],
      minimumPortfolioExposure: ''
    },
    withinClusterAllocationMethod: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/portfolio/optimization/hierarchical-risk-parity/clustering-based';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"acrossClusterAllocationMethod":"","assets":0,"assetsCovarianceMatrix":[],"clusteringMethod":"","clusteringOrdering":"","clusters":0,"constraints":{"maximumAssetsWeights":[],"maximumPortfolioExposure":"","minimumAssetsWeights":[],"minimumPortfolioExposure":""},"withinClusterAllocationMethod":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"acrossClusterAllocationMethod": @"",
                              @"assets": @0,
                              @"assetsCovarianceMatrix": @[  ],
                              @"clusteringMethod": @"",
                              @"clusteringOrdering": @"",
                              @"clusters": @0,
                              @"constraints": @{ @"maximumAssetsWeights": @[  ], @"maximumPortfolioExposure": @"", @"minimumAssetsWeights": @[  ], @"minimumPortfolioExposure": @"" },
                              @"withinClusterAllocationMethod": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/portfolio/optimization/hierarchical-risk-parity/clustering-based"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/portfolio/optimization/hierarchical-risk-parity/clustering-based" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"acrossClusterAllocationMethod\": \"\",\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"clusteringMethod\": \"\",\n  \"clusteringOrdering\": \"\",\n  \"clusters\": 0,\n  \"constraints\": {\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"withinClusterAllocationMethod\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/portfolio/optimization/hierarchical-risk-parity/clustering-based",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'acrossClusterAllocationMethod' => '',
    'assets' => 0,
    'assetsCovarianceMatrix' => [
        
    ],
    'clusteringMethod' => '',
    'clusteringOrdering' => '',
    'clusters' => 0,
    'constraints' => [
        'maximumAssetsWeights' => [
                
        ],
        'maximumPortfolioExposure' => '',
        'minimumAssetsWeights' => [
                
        ],
        'minimumPortfolioExposure' => ''
    ],
    'withinClusterAllocationMethod' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/portfolio/optimization/hierarchical-risk-parity/clustering-based', [
  'body' => '{
  "acrossClusterAllocationMethod": "",
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "clusteringMethod": "",
  "clusteringOrdering": "",
  "clusters": 0,
  "constraints": {
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  },
  "withinClusterAllocationMethod": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/portfolio/optimization/hierarchical-risk-parity/clustering-based');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'acrossClusterAllocationMethod' => '',
  'assets' => 0,
  'assetsCovarianceMatrix' => [
    
  ],
  'clusteringMethod' => '',
  'clusteringOrdering' => '',
  'clusters' => 0,
  'constraints' => [
    'maximumAssetsWeights' => [
        
    ],
    'maximumPortfolioExposure' => '',
    'minimumAssetsWeights' => [
        
    ],
    'minimumPortfolioExposure' => ''
  ],
  'withinClusterAllocationMethod' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'acrossClusterAllocationMethod' => '',
  'assets' => 0,
  'assetsCovarianceMatrix' => [
    
  ],
  'clusteringMethod' => '',
  'clusteringOrdering' => '',
  'clusters' => 0,
  'constraints' => [
    'maximumAssetsWeights' => [
        
    ],
    'maximumPortfolioExposure' => '',
    'minimumAssetsWeights' => [
        
    ],
    'minimumPortfolioExposure' => ''
  ],
  'withinClusterAllocationMethod' => ''
]));
$request->setRequestUrl('{{baseUrl}}/portfolio/optimization/hierarchical-risk-parity/clustering-based');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/portfolio/optimization/hierarchical-risk-parity/clustering-based' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "acrossClusterAllocationMethod": "",
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "clusteringMethod": "",
  "clusteringOrdering": "",
  "clusters": 0,
  "constraints": {
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  },
  "withinClusterAllocationMethod": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/portfolio/optimization/hierarchical-risk-parity/clustering-based' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "acrossClusterAllocationMethod": "",
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "clusteringMethod": "",
  "clusteringOrdering": "",
  "clusters": 0,
  "constraints": {
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  },
  "withinClusterAllocationMethod": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"acrossClusterAllocationMethod\": \"\",\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"clusteringMethod\": \"\",\n  \"clusteringOrdering\": \"\",\n  \"clusters\": 0,\n  \"constraints\": {\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"withinClusterAllocationMethod\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/portfolio/optimization/hierarchical-risk-parity/clustering-based", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/portfolio/optimization/hierarchical-risk-parity/clustering-based"

payload = {
    "acrossClusterAllocationMethod": "",
    "assets": 0,
    "assetsCovarianceMatrix": [],
    "clusteringMethod": "",
    "clusteringOrdering": "",
    "clusters": 0,
    "constraints": {
        "maximumAssetsWeights": [],
        "maximumPortfolioExposure": "",
        "minimumAssetsWeights": [],
        "minimumPortfolioExposure": ""
    },
    "withinClusterAllocationMethod": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/portfolio/optimization/hierarchical-risk-parity/clustering-based"

payload <- "{\n  \"acrossClusterAllocationMethod\": \"\",\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"clusteringMethod\": \"\",\n  \"clusteringOrdering\": \"\",\n  \"clusters\": 0,\n  \"constraints\": {\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"withinClusterAllocationMethod\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/portfolio/optimization/hierarchical-risk-parity/clustering-based")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"acrossClusterAllocationMethod\": \"\",\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"clusteringMethod\": \"\",\n  \"clusteringOrdering\": \"\",\n  \"clusters\": 0,\n  \"constraints\": {\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"withinClusterAllocationMethod\": \"\"\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/portfolio/optimization/hierarchical-risk-parity/clustering-based') do |req|
  req.body = "{\n  \"acrossClusterAllocationMethod\": \"\",\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"clusteringMethod\": \"\",\n  \"clusteringOrdering\": \"\",\n  \"clusters\": 0,\n  \"constraints\": {\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"withinClusterAllocationMethod\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/portfolio/optimization/hierarchical-risk-parity/clustering-based";

    let payload = json!({
        "acrossClusterAllocationMethod": "",
        "assets": 0,
        "assetsCovarianceMatrix": (),
        "clusteringMethod": "",
        "clusteringOrdering": "",
        "clusters": 0,
        "constraints": json!({
            "maximumAssetsWeights": (),
            "maximumPortfolioExposure": "",
            "minimumAssetsWeights": (),
            "minimumPortfolioExposure": ""
        }),
        "withinClusterAllocationMethod": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/portfolio/optimization/hierarchical-risk-parity/clustering-based \
  --header 'content-type: application/json' \
  --data '{
  "acrossClusterAllocationMethod": "",
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "clusteringMethod": "",
  "clusteringOrdering": "",
  "clusters": 0,
  "constraints": {
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  },
  "withinClusterAllocationMethod": ""
}'

echo '{
  "acrossClusterAllocationMethod": "",
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "clusteringMethod": "",
  "clusteringOrdering": "",
  "clusters": 0,
  "constraints": {
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  },
  "withinClusterAllocationMethod": ""
}' |  \
  http POST {{baseUrl}}/portfolio/optimization/hierarchical-risk-parity/clustering-based \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "acrossClusterAllocationMethod": "",\n  "assets": 0,\n  "assetsCovarianceMatrix": [],\n  "clusteringMethod": "",\n  "clusteringOrdering": "",\n  "clusters": 0,\n  "constraints": {\n    "maximumAssetsWeights": [],\n    "maximumPortfolioExposure": "",\n    "minimumAssetsWeights": [],\n    "minimumPortfolioExposure": ""\n  },\n  "withinClusterAllocationMethod": ""\n}' \
  --output-document \
  - {{baseUrl}}/portfolio/optimization/hierarchical-risk-parity/clustering-based

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "acrossClusterAllocationMethod": "",
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "clusteringMethod": "",
  "clusteringOrdering": "",
  "clusters": 0,
  "constraints": [
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  ],
  "withinClusterAllocationMethod": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/portfolio/optimization/hierarchical-risk-parity/clustering-based")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "assetsWeights": [
    0.4,
    0.09999999999998999
  ]
}

POST Hierarchical Risk Parity Portfolio

{{baseUrl}}/portfolio/optimization/hierarchical-risk-parity

BODY json

{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "clusteringMethod": "",
  "clusteringOrdering": "",
  "constraints": {
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  }
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/portfolio/optimization/hierarchical-risk-parity");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"clusteringMethod\": \"\",\n  \"clusteringOrdering\": \"\",\n  \"constraints\": {\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/portfolio/optimization/hierarchical-risk-parity" {:content-type :json
                                                                                            :form-params {:assets 0
                                                                                                          :assetsCovarianceMatrix []
                                                                                                          :clusteringMethod ""
                                                                                                          :clusteringOrdering ""
                                                                                                          :constraints {:maximumAssetsWeights []
                                                                                                                        :maximumPortfolioExposure ""
                                                                                                                        :minimumAssetsWeights []
                                                                                                                        :minimumPortfolioExposure ""}}})

require "http/client"

url = "{{baseUrl}}/portfolio/optimization/hierarchical-risk-parity"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"clusteringMethod\": \"\",\n  \"clusteringOrdering\": \"\",\n  \"constraints\": {\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/portfolio/optimization/hierarchical-risk-parity"),
    Content = new StringContent("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"clusteringMethod\": \"\",\n  \"clusteringOrdering\": \"\",\n  \"constraints\": {\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/portfolio/optimization/hierarchical-risk-parity");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"clusteringMethod\": \"\",\n  \"clusteringOrdering\": \"\",\n  \"constraints\": {\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/portfolio/optimization/hierarchical-risk-parity"

	payload := strings.NewReader("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"clusteringMethod\": \"\",\n  \"clusteringOrdering\": \"\",\n  \"constraints\": {\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}")

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

	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/portfolio/optimization/hierarchical-risk-parity HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 262

{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "clusteringMethod": "",
  "clusteringOrdering": "",
  "constraints": {
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/portfolio/optimization/hierarchical-risk-parity")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"clusteringMethod\": \"\",\n  \"clusteringOrdering\": \"\",\n  \"constraints\": {\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/portfolio/optimization/hierarchical-risk-parity"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"clusteringMethod\": \"\",\n  \"clusteringOrdering\": \"\",\n  \"constraints\": {\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"clusteringMethod\": \"\",\n  \"clusteringOrdering\": \"\",\n  \"constraints\": {\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/portfolio/optimization/hierarchical-risk-parity")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/portfolio/optimization/hierarchical-risk-parity")
  .header("content-type", "application/json")
  .body("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"clusteringMethod\": \"\",\n  \"clusteringOrdering\": \"\",\n  \"constraints\": {\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  assets: 0,
  assetsCovarianceMatrix: [],
  clusteringMethod: '',
  clusteringOrdering: '',
  constraints: {
    maximumAssetsWeights: [],
    maximumPortfolioExposure: '',
    minimumAssetsWeights: [],
    minimumPortfolioExposure: ''
  }
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/portfolio/optimization/hierarchical-risk-parity');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/optimization/hierarchical-risk-parity',
  headers: {'content-type': 'application/json'},
  data: {
    assets: 0,
    assetsCovarianceMatrix: [],
    clusteringMethod: '',
    clusteringOrdering: '',
    constraints: {
      maximumAssetsWeights: [],
      maximumPortfolioExposure: '',
      minimumAssetsWeights: [],
      minimumPortfolioExposure: ''
    }
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/portfolio/optimization/hierarchical-risk-parity';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":0,"assetsCovarianceMatrix":[],"clusteringMethod":"","clusteringOrdering":"","constraints":{"maximumAssetsWeights":[],"maximumPortfolioExposure":"","minimumAssetsWeights":[],"minimumPortfolioExposure":""}}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/portfolio/optimization/hierarchical-risk-parity',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "assets": 0,\n  "assetsCovarianceMatrix": [],\n  "clusteringMethod": "",\n  "clusteringOrdering": "",\n  "constraints": {\n    "maximumAssetsWeights": [],\n    "maximumPortfolioExposure": "",\n    "minimumAssetsWeights": [],\n    "minimumPortfolioExposure": ""\n  }\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"clusteringMethod\": \"\",\n  \"clusteringOrdering\": \"\",\n  \"constraints\": {\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/portfolio/optimization/hierarchical-risk-parity")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/portfolio/optimization/hierarchical-risk-parity',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  assets: 0,
  assetsCovarianceMatrix: [],
  clusteringMethod: '',
  clusteringOrdering: '',
  constraints: {
    maximumAssetsWeights: [],
    maximumPortfolioExposure: '',
    minimumAssetsWeights: [],
    minimumPortfolioExposure: ''
  }
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/optimization/hierarchical-risk-parity',
  headers: {'content-type': 'application/json'},
  body: {
    assets: 0,
    assetsCovarianceMatrix: [],
    clusteringMethod: '',
    clusteringOrdering: '',
    constraints: {
      maximumAssetsWeights: [],
      maximumPortfolioExposure: '',
      minimumAssetsWeights: [],
      minimumPortfolioExposure: ''
    }
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/portfolio/optimization/hierarchical-risk-parity');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  assets: 0,
  assetsCovarianceMatrix: [],
  clusteringMethod: '',
  clusteringOrdering: '',
  constraints: {
    maximumAssetsWeights: [],
    maximumPortfolioExposure: '',
    minimumAssetsWeights: [],
    minimumPortfolioExposure: ''
  }
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/optimization/hierarchical-risk-parity',
  headers: {'content-type': 'application/json'},
  data: {
    assets: 0,
    assetsCovarianceMatrix: [],
    clusteringMethod: '',
    clusteringOrdering: '',
    constraints: {
      maximumAssetsWeights: [],
      maximumPortfolioExposure: '',
      minimumAssetsWeights: [],
      minimumPortfolioExposure: ''
    }
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/portfolio/optimization/hierarchical-risk-parity';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":0,"assetsCovarianceMatrix":[],"clusteringMethod":"","clusteringOrdering":"","constraints":{"maximumAssetsWeights":[],"maximumPortfolioExposure":"","minimumAssetsWeights":[],"minimumPortfolioExposure":""}}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"assets": @0,
                              @"assetsCovarianceMatrix": @[  ],
                              @"clusteringMethod": @"",
                              @"clusteringOrdering": @"",
                              @"constraints": @{ @"maximumAssetsWeights": @[  ], @"maximumPortfolioExposure": @"", @"minimumAssetsWeights": @[  ], @"minimumPortfolioExposure": @"" } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/portfolio/optimization/hierarchical-risk-parity"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/portfolio/optimization/hierarchical-risk-parity" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"clusteringMethod\": \"\",\n  \"clusteringOrdering\": \"\",\n  \"constraints\": {\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/portfolio/optimization/hierarchical-risk-parity",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'assets' => 0,
    'assetsCovarianceMatrix' => [
        
    ],
    'clusteringMethod' => '',
    'clusteringOrdering' => '',
    'constraints' => [
        'maximumAssetsWeights' => [
                
        ],
        'maximumPortfolioExposure' => '',
        'minimumAssetsWeights' => [
                
        ],
        'minimumPortfolioExposure' => ''
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/portfolio/optimization/hierarchical-risk-parity', [
  'body' => '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "clusteringMethod": "",
  "clusteringOrdering": "",
  "constraints": {
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/portfolio/optimization/hierarchical-risk-parity');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'assets' => 0,
  'assetsCovarianceMatrix' => [
    
  ],
  'clusteringMethod' => '',
  'clusteringOrdering' => '',
  'constraints' => [
    'maximumAssetsWeights' => [
        
    ],
    'maximumPortfolioExposure' => '',
    'minimumAssetsWeights' => [
        
    ],
    'minimumPortfolioExposure' => ''
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'assets' => 0,
  'assetsCovarianceMatrix' => [
    
  ],
  'clusteringMethod' => '',
  'clusteringOrdering' => '',
  'constraints' => [
    'maximumAssetsWeights' => [
        
    ],
    'maximumPortfolioExposure' => '',
    'minimumAssetsWeights' => [
        
    ],
    'minimumPortfolioExposure' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/portfolio/optimization/hierarchical-risk-parity');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/portfolio/optimization/hierarchical-risk-parity' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "clusteringMethod": "",
  "clusteringOrdering": "",
  "constraints": {
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/portfolio/optimization/hierarchical-risk-parity' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "clusteringMethod": "",
  "clusteringOrdering": "",
  "constraints": {
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  }
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"clusteringMethod\": \"\",\n  \"clusteringOrdering\": \"\",\n  \"constraints\": {\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/portfolio/optimization/hierarchical-risk-parity", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/portfolio/optimization/hierarchical-risk-parity"

payload = {
    "assets": 0,
    "assetsCovarianceMatrix": [],
    "clusteringMethod": "",
    "clusteringOrdering": "",
    "constraints": {
        "maximumAssetsWeights": [],
        "maximumPortfolioExposure": "",
        "minimumAssetsWeights": [],
        "minimumPortfolioExposure": ""
    }
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/portfolio/optimization/hierarchical-risk-parity"

payload <- "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"clusteringMethod\": \"\",\n  \"clusteringOrdering\": \"\",\n  \"constraints\": {\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/portfolio/optimization/hierarchical-risk-parity")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"clusteringMethod\": \"\",\n  \"clusteringOrdering\": \"\",\n  \"constraints\": {\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/portfolio/optimization/hierarchical-risk-parity') do |req|
  req.body = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"clusteringMethod\": \"\",\n  \"clusteringOrdering\": \"\",\n  \"constraints\": {\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/portfolio/optimization/hierarchical-risk-parity";

    let payload = json!({
        "assets": 0,
        "assetsCovarianceMatrix": (),
        "clusteringMethod": "",
        "clusteringOrdering": "",
        "constraints": json!({
            "maximumAssetsWeights": (),
            "maximumPortfolioExposure": "",
            "minimumAssetsWeights": (),
            "minimumPortfolioExposure": ""
        })
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/portfolio/optimization/hierarchical-risk-parity \
  --header 'content-type: application/json' \
  --data '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "clusteringMethod": "",
  "clusteringOrdering": "",
  "constraints": {
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  }
}'

echo '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "clusteringMethod": "",
  "clusteringOrdering": "",
  "constraints": {
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  }
}' |  \
  http POST {{baseUrl}}/portfolio/optimization/hierarchical-risk-parity \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "assets": 0,\n  "assetsCovarianceMatrix": [],\n  "clusteringMethod": "",\n  "clusteringOrdering": "",\n  "constraints": {\n    "maximumAssetsWeights": [],\n    "maximumPortfolioExposure": "",\n    "minimumAssetsWeights": [],\n    "minimumPortfolioExposure": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/portfolio/optimization/hierarchical-risk-parity

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "clusteringMethod": "",
  "clusteringOrdering": "",
  "constraints": [
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  ]
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/portfolio/optimization/hierarchical-risk-parity")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "assetsWeights": [
    0.4,
    0.09999999999998999
  ]
}

POST Inverse Variance Weighted Portfolio

{{baseUrl}}/portfolio/optimization/inverse-variance-weighted

BODY json

{
  "assets": 0,
  "assetsVariances": []
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/portfolio/optimization/inverse-variance-weighted");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"assets\": 0,\n  \"assetsVariances\": []\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/portfolio/optimization/inverse-variance-weighted" {:content-type :json
                                                                                             :form-params {:assets 0
                                                                                                           :assetsVariances []}})

require "http/client"

url = "{{baseUrl}}/portfolio/optimization/inverse-variance-weighted"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"assets\": 0,\n  \"assetsVariances\": []\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/portfolio/optimization/inverse-variance-weighted"),
    Content = new StringContent("{\n  \"assets\": 0,\n  \"assetsVariances\": []\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/portfolio/optimization/inverse-variance-weighted");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"assets\": 0,\n  \"assetsVariances\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/portfolio/optimization/inverse-variance-weighted"

	payload := strings.NewReader("{\n  \"assets\": 0,\n  \"assetsVariances\": []\n}")

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

	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/portfolio/optimization/inverse-variance-weighted HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 42

{
  "assets": 0,
  "assetsVariances": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/portfolio/optimization/inverse-variance-weighted")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"assets\": 0,\n  \"assetsVariances\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/portfolio/optimization/inverse-variance-weighted"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"assets\": 0,\n  \"assetsVariances\": []\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"assets\": 0,\n  \"assetsVariances\": []\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/portfolio/optimization/inverse-variance-weighted")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/portfolio/optimization/inverse-variance-weighted")
  .header("content-type", "application/json")
  .body("{\n  \"assets\": 0,\n  \"assetsVariances\": []\n}")
  .asString();

const data = JSON.stringify({
  assets: 0,
  assetsVariances: []
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/portfolio/optimization/inverse-variance-weighted');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/optimization/inverse-variance-weighted',
  headers: {'content-type': 'application/json'},
  data: {assets: 0, assetsVariances: []}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/portfolio/optimization/inverse-variance-weighted';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":0,"assetsVariances":[]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/portfolio/optimization/inverse-variance-weighted',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "assets": 0,\n  "assetsVariances": []\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"assets\": 0,\n  \"assetsVariances\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/portfolio/optimization/inverse-variance-weighted")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/portfolio/optimization/inverse-variance-weighted',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({assets: 0, assetsVariances: []}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/optimization/inverse-variance-weighted',
  headers: {'content-type': 'application/json'},
  body: {assets: 0, assetsVariances: []},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/portfolio/optimization/inverse-variance-weighted');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  assets: 0,
  assetsVariances: []
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/optimization/inverse-variance-weighted',
  headers: {'content-type': 'application/json'},
  data: {assets: 0, assetsVariances: []}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/portfolio/optimization/inverse-variance-weighted';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":0,"assetsVariances":[]}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"assets": @0,
                              @"assetsVariances": @[  ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/portfolio/optimization/inverse-variance-weighted"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/portfolio/optimization/inverse-variance-weighted" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"assets\": 0,\n  \"assetsVariances\": []\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/portfolio/optimization/inverse-variance-weighted",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'assets' => 0,
    'assetsVariances' => [
        
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/portfolio/optimization/inverse-variance-weighted', [
  'body' => '{
  "assets": 0,
  "assetsVariances": []
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/portfolio/optimization/inverse-variance-weighted');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'assets' => 0,
  'assetsVariances' => [
    
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'assets' => 0,
  'assetsVariances' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/portfolio/optimization/inverse-variance-weighted');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/portfolio/optimization/inverse-variance-weighted' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": 0,
  "assetsVariances": []
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/portfolio/optimization/inverse-variance-weighted' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": 0,
  "assetsVariances": []
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"assets\": 0,\n  \"assetsVariances\": []\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/portfolio/optimization/inverse-variance-weighted", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/portfolio/optimization/inverse-variance-weighted"

payload = {
    "assets": 0,
    "assetsVariances": []
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/portfolio/optimization/inverse-variance-weighted"

payload <- "{\n  \"assets\": 0,\n  \"assetsVariances\": []\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/portfolio/optimization/inverse-variance-weighted")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"assets\": 0,\n  \"assetsVariances\": []\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/portfolio/optimization/inverse-variance-weighted') do |req|
  req.body = "{\n  \"assets\": 0,\n  \"assetsVariances\": []\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/portfolio/optimization/inverse-variance-weighted";

    let payload = json!({
        "assets": 0,
        "assetsVariances": ()
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/portfolio/optimization/inverse-variance-weighted \
  --header 'content-type: application/json' \
  --data '{
  "assets": 0,
  "assetsVariances": []
}'

echo '{
  "assets": 0,
  "assetsVariances": []
}' |  \
  http POST {{baseUrl}}/portfolio/optimization/inverse-variance-weighted \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "assets": 0,\n  "assetsVariances": []\n}' \
  --output-document \
  - {{baseUrl}}/portfolio/optimization/inverse-variance-weighted

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "assets": 0,
  "assetsVariances": []
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/portfolio/optimization/inverse-variance-weighted")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "assetsWeights": [
    0.3333333333333333,
    0.6666666666666666
  ]
}

POST Inverse Volatility Weighted Portfolio

{{baseUrl}}/portfolio/optimization/inverse-volatility-weighted

BODY json

{
  "assets": 0,
  "assetsVolatilities": []
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/portfolio/optimization/inverse-volatility-weighted");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"assets\": 0,\n  \"assetsVolatilities\": []\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/portfolio/optimization/inverse-volatility-weighted" {:content-type :json
                                                                                               :form-params {:assets 0
                                                                                                             :assetsVolatilities []}})

require "http/client"

url = "{{baseUrl}}/portfolio/optimization/inverse-volatility-weighted"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"assets\": 0,\n  \"assetsVolatilities\": []\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/portfolio/optimization/inverse-volatility-weighted"),
    Content = new StringContent("{\n  \"assets\": 0,\n  \"assetsVolatilities\": []\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/portfolio/optimization/inverse-volatility-weighted");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"assets\": 0,\n  \"assetsVolatilities\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/portfolio/optimization/inverse-volatility-weighted"

	payload := strings.NewReader("{\n  \"assets\": 0,\n  \"assetsVolatilities\": []\n}")

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

	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/portfolio/optimization/inverse-volatility-weighted HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 45

{
  "assets": 0,
  "assetsVolatilities": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/portfolio/optimization/inverse-volatility-weighted")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"assets\": 0,\n  \"assetsVolatilities\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/portfolio/optimization/inverse-volatility-weighted"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"assets\": 0,\n  \"assetsVolatilities\": []\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"assets\": 0,\n  \"assetsVolatilities\": []\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/portfolio/optimization/inverse-volatility-weighted")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/portfolio/optimization/inverse-volatility-weighted")
  .header("content-type", "application/json")
  .body("{\n  \"assets\": 0,\n  \"assetsVolatilities\": []\n}")
  .asString();

const data = JSON.stringify({
  assets: 0,
  assetsVolatilities: []
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/portfolio/optimization/inverse-volatility-weighted');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/optimization/inverse-volatility-weighted',
  headers: {'content-type': 'application/json'},
  data: {assets: 0, assetsVolatilities: []}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/portfolio/optimization/inverse-volatility-weighted';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":0,"assetsVolatilities":[]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/portfolio/optimization/inverse-volatility-weighted',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "assets": 0,\n  "assetsVolatilities": []\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"assets\": 0,\n  \"assetsVolatilities\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/portfolio/optimization/inverse-volatility-weighted")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/portfolio/optimization/inverse-volatility-weighted',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({assets: 0, assetsVolatilities: []}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/optimization/inverse-volatility-weighted',
  headers: {'content-type': 'application/json'},
  body: {assets: 0, assetsVolatilities: []},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/portfolio/optimization/inverse-volatility-weighted');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  assets: 0,
  assetsVolatilities: []
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/optimization/inverse-volatility-weighted',
  headers: {'content-type': 'application/json'},
  data: {assets: 0, assetsVolatilities: []}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/portfolio/optimization/inverse-volatility-weighted';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":0,"assetsVolatilities":[]}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"assets": @0,
                              @"assetsVolatilities": @[  ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/portfolio/optimization/inverse-volatility-weighted"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/portfolio/optimization/inverse-volatility-weighted" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"assets\": 0,\n  \"assetsVolatilities\": []\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/portfolio/optimization/inverse-volatility-weighted",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'assets' => 0,
    'assetsVolatilities' => [
        
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/portfolio/optimization/inverse-volatility-weighted', [
  'body' => '{
  "assets": 0,
  "assetsVolatilities": []
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/portfolio/optimization/inverse-volatility-weighted');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'assets' => 0,
  'assetsVolatilities' => [
    
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'assets' => 0,
  'assetsVolatilities' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/portfolio/optimization/inverse-volatility-weighted');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/portfolio/optimization/inverse-volatility-weighted' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": 0,
  "assetsVolatilities": []
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/portfolio/optimization/inverse-volatility-weighted' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": 0,
  "assetsVolatilities": []
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"assets\": 0,\n  \"assetsVolatilities\": []\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/portfolio/optimization/inverse-volatility-weighted", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/portfolio/optimization/inverse-volatility-weighted"

payload = {
    "assets": 0,
    "assetsVolatilities": []
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/portfolio/optimization/inverse-volatility-weighted"

payload <- "{\n  \"assets\": 0,\n  \"assetsVolatilities\": []\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/portfolio/optimization/inverse-volatility-weighted")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"assets\": 0,\n  \"assetsVolatilities\": []\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/portfolio/optimization/inverse-volatility-weighted') do |req|
  req.body = "{\n  \"assets\": 0,\n  \"assetsVolatilities\": []\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/portfolio/optimization/inverse-volatility-weighted";

    let payload = json!({
        "assets": 0,
        "assetsVolatilities": ()
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/portfolio/optimization/inverse-volatility-weighted \
  --header 'content-type: application/json' \
  --data '{
  "assets": 0,
  "assetsVolatilities": []
}'

echo '{
  "assets": 0,
  "assetsVolatilities": []
}' |  \
  http POST {{baseUrl}}/portfolio/optimization/inverse-volatility-weighted \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "assets": 0,\n  "assetsVolatilities": []\n}' \
  --output-document \
  - {{baseUrl}}/portfolio/optimization/inverse-volatility-weighted

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "assets": 0,
  "assetsVolatilities": []
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/portfolio/optimization/inverse-volatility-weighted")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "assetsWeights": [
    0.6666666666666666,
    0.3333333333333333
  ]
}

POST Market Capitalization Weighted Portfolio

{{baseUrl}}/portfolio/optimization/market-capitalization-weighted

BODY json

{
  "assets": 0,
  "assetsMarketCapitalizations": []
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/portfolio/optimization/market-capitalization-weighted");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"assets\": 0,\n  \"assetsMarketCapitalizations\": []\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/portfolio/optimization/market-capitalization-weighted" {:content-type :json
                                                                                                  :form-params {:assets 0
                                                                                                                :assetsMarketCapitalizations []}})

require "http/client"

url = "{{baseUrl}}/portfolio/optimization/market-capitalization-weighted"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"assets\": 0,\n  \"assetsMarketCapitalizations\": []\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/portfolio/optimization/market-capitalization-weighted"),
    Content = new StringContent("{\n  \"assets\": 0,\n  \"assetsMarketCapitalizations\": []\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/portfolio/optimization/market-capitalization-weighted");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"assets\": 0,\n  \"assetsMarketCapitalizations\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/portfolio/optimization/market-capitalization-weighted"

	payload := strings.NewReader("{\n  \"assets\": 0,\n  \"assetsMarketCapitalizations\": []\n}")

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

	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/portfolio/optimization/market-capitalization-weighted HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 54

{
  "assets": 0,
  "assetsMarketCapitalizations": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/portfolio/optimization/market-capitalization-weighted")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"assets\": 0,\n  \"assetsMarketCapitalizations\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/portfolio/optimization/market-capitalization-weighted"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"assets\": 0,\n  \"assetsMarketCapitalizations\": []\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"assets\": 0,\n  \"assetsMarketCapitalizations\": []\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/portfolio/optimization/market-capitalization-weighted")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/portfolio/optimization/market-capitalization-weighted")
  .header("content-type", "application/json")
  .body("{\n  \"assets\": 0,\n  \"assetsMarketCapitalizations\": []\n}")
  .asString();

const data = JSON.stringify({
  assets: 0,
  assetsMarketCapitalizations: []
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/portfolio/optimization/market-capitalization-weighted');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/optimization/market-capitalization-weighted',
  headers: {'content-type': 'application/json'},
  data: {assets: 0, assetsMarketCapitalizations: []}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/portfolio/optimization/market-capitalization-weighted';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":0,"assetsMarketCapitalizations":[]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/portfolio/optimization/market-capitalization-weighted',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "assets": 0,\n  "assetsMarketCapitalizations": []\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"assets\": 0,\n  \"assetsMarketCapitalizations\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/portfolio/optimization/market-capitalization-weighted")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/portfolio/optimization/market-capitalization-weighted',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({assets: 0, assetsMarketCapitalizations: []}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/optimization/market-capitalization-weighted',
  headers: {'content-type': 'application/json'},
  body: {assets: 0, assetsMarketCapitalizations: []},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/portfolio/optimization/market-capitalization-weighted');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  assets: 0,
  assetsMarketCapitalizations: []
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/optimization/market-capitalization-weighted',
  headers: {'content-type': 'application/json'},
  data: {assets: 0, assetsMarketCapitalizations: []}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/portfolio/optimization/market-capitalization-weighted';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":0,"assetsMarketCapitalizations":[]}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"assets": @0,
                              @"assetsMarketCapitalizations": @[  ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/portfolio/optimization/market-capitalization-weighted"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/portfolio/optimization/market-capitalization-weighted" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"assets\": 0,\n  \"assetsMarketCapitalizations\": []\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/portfolio/optimization/market-capitalization-weighted",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'assets' => 0,
    'assetsMarketCapitalizations' => [
        
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/portfolio/optimization/market-capitalization-weighted', [
  'body' => '{
  "assets": 0,
  "assetsMarketCapitalizations": []
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/portfolio/optimization/market-capitalization-weighted');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'assets' => 0,
  'assetsMarketCapitalizations' => [
    
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'assets' => 0,
  'assetsMarketCapitalizations' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/portfolio/optimization/market-capitalization-weighted');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/portfolio/optimization/market-capitalization-weighted' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": 0,
  "assetsMarketCapitalizations": []
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/portfolio/optimization/market-capitalization-weighted' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": 0,
  "assetsMarketCapitalizations": []
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"assets\": 0,\n  \"assetsMarketCapitalizations\": []\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/portfolio/optimization/market-capitalization-weighted", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/portfolio/optimization/market-capitalization-weighted"

payload = {
    "assets": 0,
    "assetsMarketCapitalizations": []
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/portfolio/optimization/market-capitalization-weighted"

payload <- "{\n  \"assets\": 0,\n  \"assetsMarketCapitalizations\": []\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/portfolio/optimization/market-capitalization-weighted")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"assets\": 0,\n  \"assetsMarketCapitalizations\": []\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/portfolio/optimization/market-capitalization-weighted') do |req|
  req.body = "{\n  \"assets\": 0,\n  \"assetsMarketCapitalizations\": []\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/portfolio/optimization/market-capitalization-weighted";

    let payload = json!({
        "assets": 0,
        "assetsMarketCapitalizations": ()
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/portfolio/optimization/market-capitalization-weighted \
  --header 'content-type: application/json' \
  --data '{
  "assets": 0,
  "assetsMarketCapitalizations": []
}'

echo '{
  "assets": 0,
  "assetsMarketCapitalizations": []
}' |  \
  http POST {{baseUrl}}/portfolio/optimization/market-capitalization-weighted \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "assets": 0,\n  "assetsMarketCapitalizations": []\n}' \
  --output-document \
  - {{baseUrl}}/portfolio/optimization/market-capitalization-weighted

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "assets": 0,
  "assetsMarketCapitalizations": []
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/portfolio/optimization/market-capitalization-weighted")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "assetsWeights": [
    0.3333333333333333,
    0.6666666666666666
  ]
}

POST Maximum Decorrelation Portfolio

{{baseUrl}}/portfolio/optimization/maximum-decorrelation

BODY json

{
  "assets": 0,
  "assetsCorrelationMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  }
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/portfolio/optimization/maximum-decorrelation");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"assets\": 0,\n  \"assetsCorrelationMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/portfolio/optimization/maximum-decorrelation" {:content-type :json
                                                                                         :form-params {:assets 0
                                                                                                       :assetsCorrelationMatrix []
                                                                                                       :assetsReturns []
                                                                                                       :constraints {:assetsGroups []
                                                                                                                     :assetsGroupsMatrix []
                                                                                                                     :maximumAssetsGroupsWeights []
                                                                                                                     :maximumAssetsWeights []
                                                                                                                     :maximumPortfolioExposure ""
                                                                                                                     :minimumAssetsWeights []
                                                                                                                     :minimumPortfolioExposure ""}}})

require "http/client"

url = "{{baseUrl}}/portfolio/optimization/maximum-decorrelation"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"assets\": 0,\n  \"assetsCorrelationMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/portfolio/optimization/maximum-decorrelation"),
    Content = new StringContent("{\n  \"assets\": 0,\n  \"assetsCorrelationMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/portfolio/optimization/maximum-decorrelation");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"assets\": 0,\n  \"assetsCorrelationMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/portfolio/optimization/maximum-decorrelation"

	payload := strings.NewReader("{\n  \"assets\": 0,\n  \"assetsCorrelationMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}")

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

	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/portfolio/optimization/maximum-decorrelation HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 324

{
  "assets": 0,
  "assetsCorrelationMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/portfolio/optimization/maximum-decorrelation")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"assets\": 0,\n  \"assetsCorrelationMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/portfolio/optimization/maximum-decorrelation"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"assets\": 0,\n  \"assetsCorrelationMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"assets\": 0,\n  \"assetsCorrelationMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/portfolio/optimization/maximum-decorrelation")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/portfolio/optimization/maximum-decorrelation")
  .header("content-type", "application/json")
  .body("{\n  \"assets\": 0,\n  \"assetsCorrelationMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  assets: 0,
  assetsCorrelationMatrix: [],
  assetsReturns: [],
  constraints: {
    assetsGroups: [],
    assetsGroupsMatrix: [],
    maximumAssetsGroupsWeights: [],
    maximumAssetsWeights: [],
    maximumPortfolioExposure: '',
    minimumAssetsWeights: [],
    minimumPortfolioExposure: ''
  }
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/portfolio/optimization/maximum-decorrelation');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/optimization/maximum-decorrelation',
  headers: {'content-type': 'application/json'},
  data: {
    assets: 0,
    assetsCorrelationMatrix: [],
    assetsReturns: [],
    constraints: {
      assetsGroups: [],
      assetsGroupsMatrix: [],
      maximumAssetsGroupsWeights: [],
      maximumAssetsWeights: [],
      maximumPortfolioExposure: '',
      minimumAssetsWeights: [],
      minimumPortfolioExposure: ''
    }
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/portfolio/optimization/maximum-decorrelation';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":0,"assetsCorrelationMatrix":[],"assetsReturns":[],"constraints":{"assetsGroups":[],"assetsGroupsMatrix":[],"maximumAssetsGroupsWeights":[],"maximumAssetsWeights":[],"maximumPortfolioExposure":"","minimumAssetsWeights":[],"minimumPortfolioExposure":""}}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/portfolio/optimization/maximum-decorrelation',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "assets": 0,\n  "assetsCorrelationMatrix": [],\n  "assetsReturns": [],\n  "constraints": {\n    "assetsGroups": [],\n    "assetsGroupsMatrix": [],\n    "maximumAssetsGroupsWeights": [],\n    "maximumAssetsWeights": [],\n    "maximumPortfolioExposure": "",\n    "minimumAssetsWeights": [],\n    "minimumPortfolioExposure": ""\n  }\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"assets\": 0,\n  \"assetsCorrelationMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/portfolio/optimization/maximum-decorrelation")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/portfolio/optimization/maximum-decorrelation',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  assets: 0,
  assetsCorrelationMatrix: [],
  assetsReturns: [],
  constraints: {
    assetsGroups: [],
    assetsGroupsMatrix: [],
    maximumAssetsGroupsWeights: [],
    maximumAssetsWeights: [],
    maximumPortfolioExposure: '',
    minimumAssetsWeights: [],
    minimumPortfolioExposure: ''
  }
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/optimization/maximum-decorrelation',
  headers: {'content-type': 'application/json'},
  body: {
    assets: 0,
    assetsCorrelationMatrix: [],
    assetsReturns: [],
    constraints: {
      assetsGroups: [],
      assetsGroupsMatrix: [],
      maximumAssetsGroupsWeights: [],
      maximumAssetsWeights: [],
      maximumPortfolioExposure: '',
      minimumAssetsWeights: [],
      minimumPortfolioExposure: ''
    }
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/portfolio/optimization/maximum-decorrelation');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  assets: 0,
  assetsCorrelationMatrix: [],
  assetsReturns: [],
  constraints: {
    assetsGroups: [],
    assetsGroupsMatrix: [],
    maximumAssetsGroupsWeights: [],
    maximumAssetsWeights: [],
    maximumPortfolioExposure: '',
    minimumAssetsWeights: [],
    minimumPortfolioExposure: ''
  }
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/optimization/maximum-decorrelation',
  headers: {'content-type': 'application/json'},
  data: {
    assets: 0,
    assetsCorrelationMatrix: [],
    assetsReturns: [],
    constraints: {
      assetsGroups: [],
      assetsGroupsMatrix: [],
      maximumAssetsGroupsWeights: [],
      maximumAssetsWeights: [],
      maximumPortfolioExposure: '',
      minimumAssetsWeights: [],
      minimumPortfolioExposure: ''
    }
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/portfolio/optimization/maximum-decorrelation';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":0,"assetsCorrelationMatrix":[],"assetsReturns":[],"constraints":{"assetsGroups":[],"assetsGroupsMatrix":[],"maximumAssetsGroupsWeights":[],"maximumAssetsWeights":[],"maximumPortfolioExposure":"","minimumAssetsWeights":[],"minimumPortfolioExposure":""}}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"assets": @0,
                              @"assetsCorrelationMatrix": @[  ],
                              @"assetsReturns": @[  ],
                              @"constraints": @{ @"assetsGroups": @[  ], @"assetsGroupsMatrix": @[  ], @"maximumAssetsGroupsWeights": @[  ], @"maximumAssetsWeights": @[  ], @"maximumPortfolioExposure": @"", @"minimumAssetsWeights": @[  ], @"minimumPortfolioExposure": @"" } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/portfolio/optimization/maximum-decorrelation"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/portfolio/optimization/maximum-decorrelation" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"assets\": 0,\n  \"assetsCorrelationMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/portfolio/optimization/maximum-decorrelation",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'assets' => 0,
    'assetsCorrelationMatrix' => [
        
    ],
    'assetsReturns' => [
        
    ],
    'constraints' => [
        'assetsGroups' => [
                
        ],
        'assetsGroupsMatrix' => [
                
        ],
        'maximumAssetsGroupsWeights' => [
                
        ],
        'maximumAssetsWeights' => [
                
        ],
        'maximumPortfolioExposure' => '',
        'minimumAssetsWeights' => [
                
        ],
        'minimumPortfolioExposure' => ''
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/portfolio/optimization/maximum-decorrelation', [
  'body' => '{
  "assets": 0,
  "assetsCorrelationMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/portfolio/optimization/maximum-decorrelation');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'assets' => 0,
  'assetsCorrelationMatrix' => [
    
  ],
  'assetsReturns' => [
    
  ],
  'constraints' => [
    'assetsGroups' => [
        
    ],
    'assetsGroupsMatrix' => [
        
    ],
    'maximumAssetsGroupsWeights' => [
        
    ],
    'maximumAssetsWeights' => [
        
    ],
    'maximumPortfolioExposure' => '',
    'minimumAssetsWeights' => [
        
    ],
    'minimumPortfolioExposure' => ''
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'assets' => 0,
  'assetsCorrelationMatrix' => [
    
  ],
  'assetsReturns' => [
    
  ],
  'constraints' => [
    'assetsGroups' => [
        
    ],
    'assetsGroupsMatrix' => [
        
    ],
    'maximumAssetsGroupsWeights' => [
        
    ],
    'maximumAssetsWeights' => [
        
    ],
    'maximumPortfolioExposure' => '',
    'minimumAssetsWeights' => [
        
    ],
    'minimumPortfolioExposure' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/portfolio/optimization/maximum-decorrelation');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/portfolio/optimization/maximum-decorrelation' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": 0,
  "assetsCorrelationMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/portfolio/optimization/maximum-decorrelation' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": 0,
  "assetsCorrelationMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  }
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"assets\": 0,\n  \"assetsCorrelationMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/portfolio/optimization/maximum-decorrelation", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/portfolio/optimization/maximum-decorrelation"

payload = {
    "assets": 0,
    "assetsCorrelationMatrix": [],
    "assetsReturns": [],
    "constraints": {
        "assetsGroups": [],
        "assetsGroupsMatrix": [],
        "maximumAssetsGroupsWeights": [],
        "maximumAssetsWeights": [],
        "maximumPortfolioExposure": "",
        "minimumAssetsWeights": [],
        "minimumPortfolioExposure": ""
    }
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/portfolio/optimization/maximum-decorrelation"

payload <- "{\n  \"assets\": 0,\n  \"assetsCorrelationMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/portfolio/optimization/maximum-decorrelation")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"assets\": 0,\n  \"assetsCorrelationMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/portfolio/optimization/maximum-decorrelation') do |req|
  req.body = "{\n  \"assets\": 0,\n  \"assetsCorrelationMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/portfolio/optimization/maximum-decorrelation";

    let payload = json!({
        "assets": 0,
        "assetsCorrelationMatrix": (),
        "assetsReturns": (),
        "constraints": json!({
            "assetsGroups": (),
            "assetsGroupsMatrix": (),
            "maximumAssetsGroupsWeights": (),
            "maximumAssetsWeights": (),
            "maximumPortfolioExposure": "",
            "minimumAssetsWeights": (),
            "minimumPortfolioExposure": ""
        })
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/portfolio/optimization/maximum-decorrelation \
  --header 'content-type: application/json' \
  --data '{
  "assets": 0,
  "assetsCorrelationMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  }
}'

echo '{
  "assets": 0,
  "assetsCorrelationMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  }
}' |  \
  http POST {{baseUrl}}/portfolio/optimization/maximum-decorrelation \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "assets": 0,\n  "assetsCorrelationMatrix": [],\n  "assetsReturns": [],\n  "constraints": {\n    "assetsGroups": [],\n    "assetsGroupsMatrix": [],\n    "maximumAssetsGroupsWeights": [],\n    "maximumAssetsWeights": [],\n    "maximumPortfolioExposure": "",\n    "minimumAssetsWeights": [],\n    "minimumPortfolioExposure": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/portfolio/optimization/maximum-decorrelation

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "assets": 0,
  "assetsCorrelationMatrix": [],
  "assetsReturns": [],
  "constraints": [
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  ]
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/portfolio/optimization/maximum-decorrelation")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "assetsWeights": [
    0,
    0.5,
    0.5
  ]
}

POST Maximum Ulcer Performance Index Portfolio

{{baseUrl}}/portfolio/optimization/maximum-ulcer-performance-index

BODY json

{
  "assets": [
    {
      "assetPrices": []
    }
  ],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  },
  "riskFreeRate": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/portfolio/optimization/maximum-ulcer-performance-index");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"riskFreeRate\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/portfolio/optimization/maximum-ulcer-performance-index" {:content-type :json
                                                                                                   :form-params {:assets [{:assetPrices []}]
                                                                                                                 :constraints {:assetsGroups []
                                                                                                                               :assetsGroupsMatrix []
                                                                                                                               :maximumAssetsGroupsWeights []
                                                                                                                               :maximumAssetsWeights []
                                                                                                                               :maximumPortfolioExposure ""
                                                                                                                               :minimumAssetsWeights []
                                                                                                                               :minimumPortfolioExposure ""}
                                                                                                                 :riskFreeRate ""}})

require "http/client"

url = "{{baseUrl}}/portfolio/optimization/maximum-ulcer-performance-index"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"riskFreeRate\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/portfolio/optimization/maximum-ulcer-performance-index"),
    Content = new StringContent("{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"riskFreeRate\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/portfolio/optimization/maximum-ulcer-performance-index");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"riskFreeRate\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/portfolio/optimization/maximum-ulcer-performance-index"

	payload := strings.NewReader("{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"riskFreeRate\": \"\"\n}")

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

	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/portfolio/optimization/maximum-ulcer-performance-index HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 330

{
  "assets": [
    {
      "assetPrices": []
    }
  ],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  },
  "riskFreeRate": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/portfolio/optimization/maximum-ulcer-performance-index")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"riskFreeRate\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/portfolio/optimization/maximum-ulcer-performance-index"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"riskFreeRate\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"riskFreeRate\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/portfolio/optimization/maximum-ulcer-performance-index")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/portfolio/optimization/maximum-ulcer-performance-index")
  .header("content-type", "application/json")
  .body("{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"riskFreeRate\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  assets: [
    {
      assetPrices: []
    }
  ],
  constraints: {
    assetsGroups: [],
    assetsGroupsMatrix: [],
    maximumAssetsGroupsWeights: [],
    maximumAssetsWeights: [],
    maximumPortfolioExposure: '',
    minimumAssetsWeights: [],
    minimumPortfolioExposure: ''
  },
  riskFreeRate: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/portfolio/optimization/maximum-ulcer-performance-index');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/optimization/maximum-ulcer-performance-index',
  headers: {'content-type': 'application/json'},
  data: {
    assets: [{assetPrices: []}],
    constraints: {
      assetsGroups: [],
      assetsGroupsMatrix: [],
      maximumAssetsGroupsWeights: [],
      maximumAssetsWeights: [],
      maximumPortfolioExposure: '',
      minimumAssetsWeights: [],
      minimumPortfolioExposure: ''
    },
    riskFreeRate: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/portfolio/optimization/maximum-ulcer-performance-index';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":[{"assetPrices":[]}],"constraints":{"assetsGroups":[],"assetsGroupsMatrix":[],"maximumAssetsGroupsWeights":[],"maximumAssetsWeights":[],"maximumPortfolioExposure":"","minimumAssetsWeights":[],"minimumPortfolioExposure":""},"riskFreeRate":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/portfolio/optimization/maximum-ulcer-performance-index',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "assets": [\n    {\n      "assetPrices": []\n    }\n  ],\n  "constraints": {\n    "assetsGroups": [],\n    "assetsGroupsMatrix": [],\n    "maximumAssetsGroupsWeights": [],\n    "maximumAssetsWeights": [],\n    "maximumPortfolioExposure": "",\n    "minimumAssetsWeights": [],\n    "minimumPortfolioExposure": ""\n  },\n  "riskFreeRate": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"riskFreeRate\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/portfolio/optimization/maximum-ulcer-performance-index")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/portfolio/optimization/maximum-ulcer-performance-index',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  assets: [{assetPrices: []}],
  constraints: {
    assetsGroups: [],
    assetsGroupsMatrix: [],
    maximumAssetsGroupsWeights: [],
    maximumAssetsWeights: [],
    maximumPortfolioExposure: '',
    minimumAssetsWeights: [],
    minimumPortfolioExposure: ''
  },
  riskFreeRate: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/optimization/maximum-ulcer-performance-index',
  headers: {'content-type': 'application/json'},
  body: {
    assets: [{assetPrices: []}],
    constraints: {
      assetsGroups: [],
      assetsGroupsMatrix: [],
      maximumAssetsGroupsWeights: [],
      maximumAssetsWeights: [],
      maximumPortfolioExposure: '',
      minimumAssetsWeights: [],
      minimumPortfolioExposure: ''
    },
    riskFreeRate: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/portfolio/optimization/maximum-ulcer-performance-index');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  assets: [
    {
      assetPrices: []
    }
  ],
  constraints: {
    assetsGroups: [],
    assetsGroupsMatrix: [],
    maximumAssetsGroupsWeights: [],
    maximumAssetsWeights: [],
    maximumPortfolioExposure: '',
    minimumAssetsWeights: [],
    minimumPortfolioExposure: ''
  },
  riskFreeRate: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/optimization/maximum-ulcer-performance-index',
  headers: {'content-type': 'application/json'},
  data: {
    assets: [{assetPrices: []}],
    constraints: {
      assetsGroups: [],
      assetsGroupsMatrix: [],
      maximumAssetsGroupsWeights: [],
      maximumAssetsWeights: [],
      maximumPortfolioExposure: '',
      minimumAssetsWeights: [],
      minimumPortfolioExposure: ''
    },
    riskFreeRate: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/portfolio/optimization/maximum-ulcer-performance-index';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":[{"assetPrices":[]}],"constraints":{"assetsGroups":[],"assetsGroupsMatrix":[],"maximumAssetsGroupsWeights":[],"maximumAssetsWeights":[],"maximumPortfolioExposure":"","minimumAssetsWeights":[],"minimumPortfolioExposure":""},"riskFreeRate":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"assets": @[ @{ @"assetPrices": @[  ] } ],
                              @"constraints": @{ @"assetsGroups": @[  ], @"assetsGroupsMatrix": @[  ], @"maximumAssetsGroupsWeights": @[  ], @"maximumAssetsWeights": @[  ], @"maximumPortfolioExposure": @"", @"minimumAssetsWeights": @[  ], @"minimumPortfolioExposure": @"" },
                              @"riskFreeRate": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/portfolio/optimization/maximum-ulcer-performance-index"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/portfolio/optimization/maximum-ulcer-performance-index" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"riskFreeRate\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/portfolio/optimization/maximum-ulcer-performance-index",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'assets' => [
        [
                'assetPrices' => [
                                
                ]
        ]
    ],
    'constraints' => [
        'assetsGroups' => [
                
        ],
        'assetsGroupsMatrix' => [
                
        ],
        'maximumAssetsGroupsWeights' => [
                
        ],
        'maximumAssetsWeights' => [
                
        ],
        'maximumPortfolioExposure' => '',
        'minimumAssetsWeights' => [
                
        ],
        'minimumPortfolioExposure' => ''
    ],
    'riskFreeRate' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/portfolio/optimization/maximum-ulcer-performance-index', [
  'body' => '{
  "assets": [
    {
      "assetPrices": []
    }
  ],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  },
  "riskFreeRate": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/portfolio/optimization/maximum-ulcer-performance-index');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'assets' => [
    [
        'assetPrices' => [
                
        ]
    ]
  ],
  'constraints' => [
    'assetsGroups' => [
        
    ],
    'assetsGroupsMatrix' => [
        
    ],
    'maximumAssetsGroupsWeights' => [
        
    ],
    'maximumAssetsWeights' => [
        
    ],
    'maximumPortfolioExposure' => '',
    'minimumAssetsWeights' => [
        
    ],
    'minimumPortfolioExposure' => ''
  ],
  'riskFreeRate' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'assets' => [
    [
        'assetPrices' => [
                
        ]
    ]
  ],
  'constraints' => [
    'assetsGroups' => [
        
    ],
    'assetsGroupsMatrix' => [
        
    ],
    'maximumAssetsGroupsWeights' => [
        
    ],
    'maximumAssetsWeights' => [
        
    ],
    'maximumPortfolioExposure' => '',
    'minimumAssetsWeights' => [
        
    ],
    'minimumPortfolioExposure' => ''
  ],
  'riskFreeRate' => ''
]));
$request->setRequestUrl('{{baseUrl}}/portfolio/optimization/maximum-ulcer-performance-index');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/portfolio/optimization/maximum-ulcer-performance-index' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": [
    {
      "assetPrices": []
    }
  ],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  },
  "riskFreeRate": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/portfolio/optimization/maximum-ulcer-performance-index' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": [
    {
      "assetPrices": []
    }
  ],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  },
  "riskFreeRate": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"riskFreeRate\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/portfolio/optimization/maximum-ulcer-performance-index", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/portfolio/optimization/maximum-ulcer-performance-index"

payload = {
    "assets": [{ "assetPrices": [] }],
    "constraints": {
        "assetsGroups": [],
        "assetsGroupsMatrix": [],
        "maximumAssetsGroupsWeights": [],
        "maximumAssetsWeights": [],
        "maximumPortfolioExposure": "",
        "minimumAssetsWeights": [],
        "minimumPortfolioExposure": ""
    },
    "riskFreeRate": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/portfolio/optimization/maximum-ulcer-performance-index"

payload <- "{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"riskFreeRate\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/portfolio/optimization/maximum-ulcer-performance-index")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"riskFreeRate\": \"\"\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/portfolio/optimization/maximum-ulcer-performance-index') do |req|
  req.body = "{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"riskFreeRate\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/portfolio/optimization/maximum-ulcer-performance-index";

    let payload = json!({
        "assets": (json!({"assetPrices": ()})),
        "constraints": json!({
            "assetsGroups": (),
            "assetsGroupsMatrix": (),
            "maximumAssetsGroupsWeights": (),
            "maximumAssetsWeights": (),
            "maximumPortfolioExposure": "",
            "minimumAssetsWeights": (),
            "minimumPortfolioExposure": ""
        }),
        "riskFreeRate": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/portfolio/optimization/maximum-ulcer-performance-index \
  --header 'content-type: application/json' \
  --data '{
  "assets": [
    {
      "assetPrices": []
    }
  ],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  },
  "riskFreeRate": ""
}'

echo '{
  "assets": [
    {
      "assetPrices": []
    }
  ],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  },
  "riskFreeRate": ""
}' |  \
  http POST {{baseUrl}}/portfolio/optimization/maximum-ulcer-performance-index \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "assets": [\n    {\n      "assetPrices": []\n    }\n  ],\n  "constraints": {\n    "assetsGroups": [],\n    "assetsGroupsMatrix": [],\n    "maximumAssetsGroupsWeights": [],\n    "maximumAssetsWeights": [],\n    "maximumPortfolioExposure": "",\n    "minimumAssetsWeights": [],\n    "minimumPortfolioExposure": ""\n  },\n  "riskFreeRate": ""\n}' \
  --output-document \
  - {{baseUrl}}/portfolio/optimization/maximum-ulcer-performance-index

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "assets": [["assetPrices": []]],
  "constraints": [
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  ],
  "riskFreeRate": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/portfolio/optimization/maximum-ulcer-performance-index")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "assetsWeights": [
    0.3101913068855954,
    0.6898086931144047
  ]
}

POST Minimum Correlation Portfolio

{{baseUrl}}/portfolio/optimization/minimum-correlation

BODY json

{
  "assets": 0,
  "assetsCorrelationMatrix": [],
  "assetsVolatilities": []
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/portfolio/optimization/minimum-correlation");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"assets\": 0,\n  \"assetsCorrelationMatrix\": [],\n  \"assetsVolatilities\": []\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/portfolio/optimization/minimum-correlation" {:content-type :json
                                                                                       :form-params {:assets 0
                                                                                                     :assetsCorrelationMatrix []
                                                                                                     :assetsVolatilities []}})

require "http/client"

url = "{{baseUrl}}/portfolio/optimization/minimum-correlation"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"assets\": 0,\n  \"assetsCorrelationMatrix\": [],\n  \"assetsVolatilities\": []\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/portfolio/optimization/minimum-correlation"),
    Content = new StringContent("{\n  \"assets\": 0,\n  \"assetsCorrelationMatrix\": [],\n  \"assetsVolatilities\": []\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/portfolio/optimization/minimum-correlation");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"assets\": 0,\n  \"assetsCorrelationMatrix\": [],\n  \"assetsVolatilities\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/portfolio/optimization/minimum-correlation"

	payload := strings.NewReader("{\n  \"assets\": 0,\n  \"assetsCorrelationMatrix\": [],\n  \"assetsVolatilities\": []\n}")

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

	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/portfolio/optimization/minimum-correlation HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 78

{
  "assets": 0,
  "assetsCorrelationMatrix": [],
  "assetsVolatilities": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/portfolio/optimization/minimum-correlation")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"assets\": 0,\n  \"assetsCorrelationMatrix\": [],\n  \"assetsVolatilities\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/portfolio/optimization/minimum-correlation"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"assets\": 0,\n  \"assetsCorrelationMatrix\": [],\n  \"assetsVolatilities\": []\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"assets\": 0,\n  \"assetsCorrelationMatrix\": [],\n  \"assetsVolatilities\": []\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/portfolio/optimization/minimum-correlation")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/portfolio/optimization/minimum-correlation")
  .header("content-type", "application/json")
  .body("{\n  \"assets\": 0,\n  \"assetsCorrelationMatrix\": [],\n  \"assetsVolatilities\": []\n}")
  .asString();

const data = JSON.stringify({
  assets: 0,
  assetsCorrelationMatrix: [],
  assetsVolatilities: []
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/portfolio/optimization/minimum-correlation');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/optimization/minimum-correlation',
  headers: {'content-type': 'application/json'},
  data: {assets: 0, assetsCorrelationMatrix: [], assetsVolatilities: []}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/portfolio/optimization/minimum-correlation';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":0,"assetsCorrelationMatrix":[],"assetsVolatilities":[]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/portfolio/optimization/minimum-correlation',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "assets": 0,\n  "assetsCorrelationMatrix": [],\n  "assetsVolatilities": []\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"assets\": 0,\n  \"assetsCorrelationMatrix\": [],\n  \"assetsVolatilities\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/portfolio/optimization/minimum-correlation")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/portfolio/optimization/minimum-correlation',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({assets: 0, assetsCorrelationMatrix: [], assetsVolatilities: []}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/optimization/minimum-correlation',
  headers: {'content-type': 'application/json'},
  body: {assets: 0, assetsCorrelationMatrix: [], assetsVolatilities: []},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/portfolio/optimization/minimum-correlation');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  assets: 0,
  assetsCorrelationMatrix: [],
  assetsVolatilities: []
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/optimization/minimum-correlation',
  headers: {'content-type': 'application/json'},
  data: {assets: 0, assetsCorrelationMatrix: [], assetsVolatilities: []}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/portfolio/optimization/minimum-correlation';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":0,"assetsCorrelationMatrix":[],"assetsVolatilities":[]}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"assets": @0,
                              @"assetsCorrelationMatrix": @[  ],
                              @"assetsVolatilities": @[  ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/portfolio/optimization/minimum-correlation"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/portfolio/optimization/minimum-correlation" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"assets\": 0,\n  \"assetsCorrelationMatrix\": [],\n  \"assetsVolatilities\": []\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/portfolio/optimization/minimum-correlation",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'assets' => 0,
    'assetsCorrelationMatrix' => [
        
    ],
    'assetsVolatilities' => [
        
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/portfolio/optimization/minimum-correlation', [
  'body' => '{
  "assets": 0,
  "assetsCorrelationMatrix": [],
  "assetsVolatilities": []
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/portfolio/optimization/minimum-correlation');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'assets' => 0,
  'assetsCorrelationMatrix' => [
    
  ],
  'assetsVolatilities' => [
    
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'assets' => 0,
  'assetsCorrelationMatrix' => [
    
  ],
  'assetsVolatilities' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/portfolio/optimization/minimum-correlation');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/portfolio/optimization/minimum-correlation' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": 0,
  "assetsCorrelationMatrix": [],
  "assetsVolatilities": []
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/portfolio/optimization/minimum-correlation' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": 0,
  "assetsCorrelationMatrix": [],
  "assetsVolatilities": []
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"assets\": 0,\n  \"assetsCorrelationMatrix\": [],\n  \"assetsVolatilities\": []\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/portfolio/optimization/minimum-correlation", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/portfolio/optimization/minimum-correlation"

payload = {
    "assets": 0,
    "assetsCorrelationMatrix": [],
    "assetsVolatilities": []
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/portfolio/optimization/minimum-correlation"

payload <- "{\n  \"assets\": 0,\n  \"assetsCorrelationMatrix\": [],\n  \"assetsVolatilities\": []\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/portfolio/optimization/minimum-correlation")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"assets\": 0,\n  \"assetsCorrelationMatrix\": [],\n  \"assetsVolatilities\": []\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/portfolio/optimization/minimum-correlation') do |req|
  req.body = "{\n  \"assets\": 0,\n  \"assetsCorrelationMatrix\": [],\n  \"assetsVolatilities\": []\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/portfolio/optimization/minimum-correlation";

    let payload = json!({
        "assets": 0,
        "assetsCorrelationMatrix": (),
        "assetsVolatilities": ()
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/portfolio/optimization/minimum-correlation \
  --header 'content-type: application/json' \
  --data '{
  "assets": 0,
  "assetsCorrelationMatrix": [],
  "assetsVolatilities": []
}'

echo '{
  "assets": 0,
  "assetsCorrelationMatrix": [],
  "assetsVolatilities": []
}' |  \
  http POST {{baseUrl}}/portfolio/optimization/minimum-correlation \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "assets": 0,\n  "assetsCorrelationMatrix": [],\n  "assetsVolatilities": []\n}' \
  --output-document \
  - {{baseUrl}}/portfolio/optimization/minimum-correlation

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "assets": 0,
  "assetsCorrelationMatrix": [],
  "assetsVolatilities": []
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/portfolio/optimization/minimum-correlation")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "assetsWeights": [
    0.21059806981924115,
    0.3087866303991204,
    0.48061529978163836
  ]
}

POST Minimum Ulcer Index Portfolio

{{baseUrl}}/portfolio/optimization/minimum-ulcer-index

BODY json

{
  "assets": [
    {
      "assetPrices": []
    }
  ],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  }
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/portfolio/optimization/minimum-ulcer-index");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/portfolio/optimization/minimum-ulcer-index" {:content-type :json
                                                                                       :form-params {:assets [{:assetPrices []}]
                                                                                                     :constraints {:assetsGroups []
                                                                                                                   :assetsGroupsMatrix []
                                                                                                                   :maximumAssetsGroupsWeights []
                                                                                                                   :maximumAssetsWeights []
                                                                                                                   :maximumPortfolioExposure ""
                                                                                                                   :minimumAssetsWeights []
                                                                                                                   :minimumPortfolioExposure ""}}})

require "http/client"

url = "{{baseUrl}}/portfolio/optimization/minimum-ulcer-index"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/portfolio/optimization/minimum-ulcer-index"),
    Content = new StringContent("{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/portfolio/optimization/minimum-ulcer-index");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/portfolio/optimization/minimum-ulcer-index"

	payload := strings.NewReader("{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}")

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

	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/portfolio/optimization/minimum-ulcer-index HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 308

{
  "assets": [
    {
      "assetPrices": []
    }
  ],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/portfolio/optimization/minimum-ulcer-index")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/portfolio/optimization/minimum-ulcer-index"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/portfolio/optimization/minimum-ulcer-index")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/portfolio/optimization/minimum-ulcer-index")
  .header("content-type", "application/json")
  .body("{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  assets: [
    {
      assetPrices: []
    }
  ],
  constraints: {
    assetsGroups: [],
    assetsGroupsMatrix: [],
    maximumAssetsGroupsWeights: [],
    maximumAssetsWeights: [],
    maximumPortfolioExposure: '',
    minimumAssetsWeights: [],
    minimumPortfolioExposure: ''
  }
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/portfolio/optimization/minimum-ulcer-index');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/optimization/minimum-ulcer-index',
  headers: {'content-type': 'application/json'},
  data: {
    assets: [{assetPrices: []}],
    constraints: {
      assetsGroups: [],
      assetsGroupsMatrix: [],
      maximumAssetsGroupsWeights: [],
      maximumAssetsWeights: [],
      maximumPortfolioExposure: '',
      minimumAssetsWeights: [],
      minimumPortfolioExposure: ''
    }
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/portfolio/optimization/minimum-ulcer-index';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":[{"assetPrices":[]}],"constraints":{"assetsGroups":[],"assetsGroupsMatrix":[],"maximumAssetsGroupsWeights":[],"maximumAssetsWeights":[],"maximumPortfolioExposure":"","minimumAssetsWeights":[],"minimumPortfolioExposure":""}}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/portfolio/optimization/minimum-ulcer-index',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "assets": [\n    {\n      "assetPrices": []\n    }\n  ],\n  "constraints": {\n    "assetsGroups": [],\n    "assetsGroupsMatrix": [],\n    "maximumAssetsGroupsWeights": [],\n    "maximumAssetsWeights": [],\n    "maximumPortfolioExposure": "",\n    "minimumAssetsWeights": [],\n    "minimumPortfolioExposure": ""\n  }\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/portfolio/optimization/minimum-ulcer-index")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/portfolio/optimization/minimum-ulcer-index',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  assets: [{assetPrices: []}],
  constraints: {
    assetsGroups: [],
    assetsGroupsMatrix: [],
    maximumAssetsGroupsWeights: [],
    maximumAssetsWeights: [],
    maximumPortfolioExposure: '',
    minimumAssetsWeights: [],
    minimumPortfolioExposure: ''
  }
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/optimization/minimum-ulcer-index',
  headers: {'content-type': 'application/json'},
  body: {
    assets: [{assetPrices: []}],
    constraints: {
      assetsGroups: [],
      assetsGroupsMatrix: [],
      maximumAssetsGroupsWeights: [],
      maximumAssetsWeights: [],
      maximumPortfolioExposure: '',
      minimumAssetsWeights: [],
      minimumPortfolioExposure: ''
    }
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/portfolio/optimization/minimum-ulcer-index');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  assets: [
    {
      assetPrices: []
    }
  ],
  constraints: {
    assetsGroups: [],
    assetsGroupsMatrix: [],
    maximumAssetsGroupsWeights: [],
    maximumAssetsWeights: [],
    maximumPortfolioExposure: '',
    minimumAssetsWeights: [],
    minimumPortfolioExposure: ''
  }
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/optimization/minimum-ulcer-index',
  headers: {'content-type': 'application/json'},
  data: {
    assets: [{assetPrices: []}],
    constraints: {
      assetsGroups: [],
      assetsGroupsMatrix: [],
      maximumAssetsGroupsWeights: [],
      maximumAssetsWeights: [],
      maximumPortfolioExposure: '',
      minimumAssetsWeights: [],
      minimumPortfolioExposure: ''
    }
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/portfolio/optimization/minimum-ulcer-index';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":[{"assetPrices":[]}],"constraints":{"assetsGroups":[],"assetsGroupsMatrix":[],"maximumAssetsGroupsWeights":[],"maximumAssetsWeights":[],"maximumPortfolioExposure":"","minimumAssetsWeights":[],"minimumPortfolioExposure":""}}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"assets": @[ @{ @"assetPrices": @[  ] } ],
                              @"constraints": @{ @"assetsGroups": @[  ], @"assetsGroupsMatrix": @[  ], @"maximumAssetsGroupsWeights": @[  ], @"maximumAssetsWeights": @[  ], @"maximumPortfolioExposure": @"", @"minimumAssetsWeights": @[  ], @"minimumPortfolioExposure": @"" } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/portfolio/optimization/minimum-ulcer-index"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/portfolio/optimization/minimum-ulcer-index" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/portfolio/optimization/minimum-ulcer-index",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'assets' => [
        [
                'assetPrices' => [
                                
                ]
        ]
    ],
    'constraints' => [
        'assetsGroups' => [
                
        ],
        'assetsGroupsMatrix' => [
                
        ],
        'maximumAssetsGroupsWeights' => [
                
        ],
        'maximumAssetsWeights' => [
                
        ],
        'maximumPortfolioExposure' => '',
        'minimumAssetsWeights' => [
                
        ],
        'minimumPortfolioExposure' => ''
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/portfolio/optimization/minimum-ulcer-index', [
  'body' => '{
  "assets": [
    {
      "assetPrices": []
    }
  ],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/portfolio/optimization/minimum-ulcer-index');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'assets' => [
    [
        'assetPrices' => [
                
        ]
    ]
  ],
  'constraints' => [
    'assetsGroups' => [
        
    ],
    'assetsGroupsMatrix' => [
        
    ],
    'maximumAssetsGroupsWeights' => [
        
    ],
    'maximumAssetsWeights' => [
        
    ],
    'maximumPortfolioExposure' => '',
    'minimumAssetsWeights' => [
        
    ],
    'minimumPortfolioExposure' => ''
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'assets' => [
    [
        'assetPrices' => [
                
        ]
    ]
  ],
  'constraints' => [
    'assetsGroups' => [
        
    ],
    'assetsGroupsMatrix' => [
        
    ],
    'maximumAssetsGroupsWeights' => [
        
    ],
    'maximumAssetsWeights' => [
        
    ],
    'maximumPortfolioExposure' => '',
    'minimumAssetsWeights' => [
        
    ],
    'minimumPortfolioExposure' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/portfolio/optimization/minimum-ulcer-index');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/portfolio/optimization/minimum-ulcer-index' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": [
    {
      "assetPrices": []
    }
  ],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/portfolio/optimization/minimum-ulcer-index' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": [
    {
      "assetPrices": []
    }
  ],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  }
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/portfolio/optimization/minimum-ulcer-index", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/portfolio/optimization/minimum-ulcer-index"

payload = {
    "assets": [{ "assetPrices": [] }],
    "constraints": {
        "assetsGroups": [],
        "assetsGroupsMatrix": [],
        "maximumAssetsGroupsWeights": [],
        "maximumAssetsWeights": [],
        "maximumPortfolioExposure": "",
        "minimumAssetsWeights": [],
        "minimumPortfolioExposure": ""
    }
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/portfolio/optimization/minimum-ulcer-index"

payload <- "{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/portfolio/optimization/minimum-ulcer-index")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/portfolio/optimization/minimum-ulcer-index') do |req|
  req.body = "{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/portfolio/optimization/minimum-ulcer-index";

    let payload = json!({
        "assets": (json!({"assetPrices": ()})),
        "constraints": json!({
            "assetsGroups": (),
            "assetsGroupsMatrix": (),
            "maximumAssetsGroupsWeights": (),
            "maximumAssetsWeights": (),
            "maximumPortfolioExposure": "",
            "minimumAssetsWeights": (),
            "minimumPortfolioExposure": ""
        })
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/portfolio/optimization/minimum-ulcer-index \
  --header 'content-type: application/json' \
  --data '{
  "assets": [
    {
      "assetPrices": []
    }
  ],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  }
}'

echo '{
  "assets": [
    {
      "assetPrices": []
    }
  ],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  }
}' |  \
  http POST {{baseUrl}}/portfolio/optimization/minimum-ulcer-index \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "assets": [\n    {\n      "assetPrices": []\n    }\n  ],\n  "constraints": {\n    "assetsGroups": [],\n    "assetsGroupsMatrix": [],\n    "maximumAssetsGroupsWeights": [],\n    "maximumAssetsWeights": [],\n    "maximumPortfolioExposure": "",\n    "minimumAssetsWeights": [],\n    "minimumPortfolioExposure": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/portfolio/optimization/minimum-ulcer-index

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "assets": [["assetPrices": []]],
  "constraints": [
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  ]
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/portfolio/optimization/minimum-ulcer-index")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "assetsWeights": [
    0.24615095383708674,
    0.7538490461629133
  ]
}

POST Most Diversified Portfolio

{{baseUrl}}/portfolio/optimization/most-diversified

BODY json

{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  }
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/portfolio/optimization/most-diversified");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/portfolio/optimization/most-diversified" {:content-type :json
                                                                                    :form-params {:assets 0
                                                                                                  :assetsCovarianceMatrix []
                                                                                                  :constraints {:assetsGroups []
                                                                                                                :assetsGroupsMatrix []
                                                                                                                :maximumAssetsGroupsWeights []
                                                                                                                :maximumAssetsWeights []
                                                                                                                :maximumPortfolioExposure ""
                                                                                                                :minimumAssetsWeights []
                                                                                                                :minimumPortfolioExposure ""}}})

require "http/client"

url = "{{baseUrl}}/portfolio/optimization/most-diversified"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/portfolio/optimization/most-diversified"),
    Content = new StringContent("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/portfolio/optimization/most-diversified");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/portfolio/optimization/most-diversified"

	payload := strings.NewReader("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}")

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

	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/portfolio/optimization/most-diversified HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 300

{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/portfolio/optimization/most-diversified")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/portfolio/optimization/most-diversified"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/portfolio/optimization/most-diversified")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/portfolio/optimization/most-diversified")
  .header("content-type", "application/json")
  .body("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  assets: 0,
  assetsCovarianceMatrix: [],
  constraints: {
    assetsGroups: [],
    assetsGroupsMatrix: [],
    maximumAssetsGroupsWeights: [],
    maximumAssetsWeights: [],
    maximumPortfolioExposure: '',
    minimumAssetsWeights: [],
    minimumPortfolioExposure: ''
  }
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/portfolio/optimization/most-diversified');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/optimization/most-diversified',
  headers: {'content-type': 'application/json'},
  data: {
    assets: 0,
    assetsCovarianceMatrix: [],
    constraints: {
      assetsGroups: [],
      assetsGroupsMatrix: [],
      maximumAssetsGroupsWeights: [],
      maximumAssetsWeights: [],
      maximumPortfolioExposure: '',
      minimumAssetsWeights: [],
      minimumPortfolioExposure: ''
    }
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/portfolio/optimization/most-diversified';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":0,"assetsCovarianceMatrix":[],"constraints":{"assetsGroups":[],"assetsGroupsMatrix":[],"maximumAssetsGroupsWeights":[],"maximumAssetsWeights":[],"maximumPortfolioExposure":"","minimumAssetsWeights":[],"minimumPortfolioExposure":""}}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/portfolio/optimization/most-diversified',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "assets": 0,\n  "assetsCovarianceMatrix": [],\n  "constraints": {\n    "assetsGroups": [],\n    "assetsGroupsMatrix": [],\n    "maximumAssetsGroupsWeights": [],\n    "maximumAssetsWeights": [],\n    "maximumPortfolioExposure": "",\n    "minimumAssetsWeights": [],\n    "minimumPortfolioExposure": ""\n  }\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/portfolio/optimization/most-diversified")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/portfolio/optimization/most-diversified',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  assets: 0,
  assetsCovarianceMatrix: [],
  constraints: {
    assetsGroups: [],
    assetsGroupsMatrix: [],
    maximumAssetsGroupsWeights: [],
    maximumAssetsWeights: [],
    maximumPortfolioExposure: '',
    minimumAssetsWeights: [],
    minimumPortfolioExposure: ''
  }
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/optimization/most-diversified',
  headers: {'content-type': 'application/json'},
  body: {
    assets: 0,
    assetsCovarianceMatrix: [],
    constraints: {
      assetsGroups: [],
      assetsGroupsMatrix: [],
      maximumAssetsGroupsWeights: [],
      maximumAssetsWeights: [],
      maximumPortfolioExposure: '',
      minimumAssetsWeights: [],
      minimumPortfolioExposure: ''
    }
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/portfolio/optimization/most-diversified');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  assets: 0,
  assetsCovarianceMatrix: [],
  constraints: {
    assetsGroups: [],
    assetsGroupsMatrix: [],
    maximumAssetsGroupsWeights: [],
    maximumAssetsWeights: [],
    maximumPortfolioExposure: '',
    minimumAssetsWeights: [],
    minimumPortfolioExposure: ''
  }
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/optimization/most-diversified',
  headers: {'content-type': 'application/json'},
  data: {
    assets: 0,
    assetsCovarianceMatrix: [],
    constraints: {
      assetsGroups: [],
      assetsGroupsMatrix: [],
      maximumAssetsGroupsWeights: [],
      maximumAssetsWeights: [],
      maximumPortfolioExposure: '',
      minimumAssetsWeights: [],
      minimumPortfolioExposure: ''
    }
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/portfolio/optimization/most-diversified';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":0,"assetsCovarianceMatrix":[],"constraints":{"assetsGroups":[],"assetsGroupsMatrix":[],"maximumAssetsGroupsWeights":[],"maximumAssetsWeights":[],"maximumPortfolioExposure":"","minimumAssetsWeights":[],"minimumPortfolioExposure":""}}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"assets": @0,
                              @"assetsCovarianceMatrix": @[  ],
                              @"constraints": @{ @"assetsGroups": @[  ], @"assetsGroupsMatrix": @[  ], @"maximumAssetsGroupsWeights": @[  ], @"maximumAssetsWeights": @[  ], @"maximumPortfolioExposure": @"", @"minimumAssetsWeights": @[  ], @"minimumPortfolioExposure": @"" } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/portfolio/optimization/most-diversified"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/portfolio/optimization/most-diversified" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/portfolio/optimization/most-diversified",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'assets' => 0,
    'assetsCovarianceMatrix' => [
        
    ],
    'constraints' => [
        'assetsGroups' => [
                
        ],
        'assetsGroupsMatrix' => [
                
        ],
        'maximumAssetsGroupsWeights' => [
                
        ],
        'maximumAssetsWeights' => [
                
        ],
        'maximumPortfolioExposure' => '',
        'minimumAssetsWeights' => [
                
        ],
        'minimumPortfolioExposure' => ''
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/portfolio/optimization/most-diversified', [
  'body' => '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/portfolio/optimization/most-diversified');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'assets' => 0,
  'assetsCovarianceMatrix' => [
    
  ],
  'constraints' => [
    'assetsGroups' => [
        
    ],
    'assetsGroupsMatrix' => [
        
    ],
    'maximumAssetsGroupsWeights' => [
        
    ],
    'maximumAssetsWeights' => [
        
    ],
    'maximumPortfolioExposure' => '',
    'minimumAssetsWeights' => [
        
    ],
    'minimumPortfolioExposure' => ''
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'assets' => 0,
  'assetsCovarianceMatrix' => [
    
  ],
  'constraints' => [
    'assetsGroups' => [
        
    ],
    'assetsGroupsMatrix' => [
        
    ],
    'maximumAssetsGroupsWeights' => [
        
    ],
    'maximumAssetsWeights' => [
        
    ],
    'maximumPortfolioExposure' => '',
    'minimumAssetsWeights' => [
        
    ],
    'minimumPortfolioExposure' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/portfolio/optimization/most-diversified');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/portfolio/optimization/most-diversified' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/portfolio/optimization/most-diversified' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  }
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/portfolio/optimization/most-diversified", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/portfolio/optimization/most-diversified"

payload = {
    "assets": 0,
    "assetsCovarianceMatrix": [],
    "constraints": {
        "assetsGroups": [],
        "assetsGroupsMatrix": [],
        "maximumAssetsGroupsWeights": [],
        "maximumAssetsWeights": [],
        "maximumPortfolioExposure": "",
        "minimumAssetsWeights": [],
        "minimumPortfolioExposure": ""
    }
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/portfolio/optimization/most-diversified"

payload <- "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/portfolio/optimization/most-diversified")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/portfolio/optimization/most-diversified') do |req|
  req.body = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/portfolio/optimization/most-diversified";

    let payload = json!({
        "assets": 0,
        "assetsCovarianceMatrix": (),
        "constraints": json!({
            "assetsGroups": (),
            "assetsGroupsMatrix": (),
            "maximumAssetsGroupsWeights": (),
            "maximumAssetsWeights": (),
            "maximumPortfolioExposure": "",
            "minimumAssetsWeights": (),
            "minimumPortfolioExposure": ""
        })
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/portfolio/optimization/most-diversified \
  --header 'content-type: application/json' \
  --data '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  }
}'

echo '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  }
}' |  \
  http POST {{baseUrl}}/portfolio/optimization/most-diversified \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "assets": 0,\n  "assetsCovarianceMatrix": [],\n  "constraints": {\n    "assetsGroups": [],\n    "assetsGroupsMatrix": [],\n    "maximumAssetsGroupsWeights": [],\n    "maximumAssetsWeights": [],\n    "maximumPortfolioExposure": "",\n    "minimumAssetsWeights": [],\n    "minimumPortfolioExposure": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/portfolio/optimization/most-diversified

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "constraints": [
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  ]
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/portfolio/optimization/most-diversified")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "assetsWeights": [
    0.33333333333333337,
    0.6666666666666666
  ]
}

POST Diversified Maximum Return Portfolio

{{baseUrl}}/portfolio/optimization/maximum-return/diversified

BODY json

{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "deltaReturn": "",
    "deltaVolatility": "",
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  }
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/portfolio/optimization/maximum-return/diversified");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"deltaReturn\": \"\",\n    \"deltaVolatility\": \"\",\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/portfolio/optimization/maximum-return/diversified" {:content-type :json
                                                                                              :form-params {:assets 0
                                                                                                            :assetsCovarianceMatrix []
                                                                                                            :assetsReturns []
                                                                                                            :constraints {:assetsGroups []
                                                                                                                          :assetsGroupsMatrix []
                                                                                                                          :deltaReturn ""
                                                                                                                          :deltaVolatility ""
                                                                                                                          :maximumAssetsGroupsWeights []
                                                                                                                          :maximumAssetsWeights []
                                                                                                                          :maximumPortfolioExposure ""
                                                                                                                          :minimumAssetsWeights []
                                                                                                                          :minimumPortfolioExposure ""}}})

require "http/client"

url = "{{baseUrl}}/portfolio/optimization/maximum-return/diversified"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"deltaReturn\": \"\",\n    \"deltaVolatility\": \"\",\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/portfolio/optimization/maximum-return/diversified"),
    Content = new StringContent("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"deltaReturn\": \"\",\n    \"deltaVolatility\": \"\",\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/portfolio/optimization/maximum-return/diversified");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"deltaReturn\": \"\",\n    \"deltaVolatility\": \"\",\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/portfolio/optimization/maximum-return/diversified"

	payload := strings.NewReader("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"deltaReturn\": \"\",\n    \"deltaVolatility\": \"\",\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}")

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

	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/portfolio/optimization/maximum-return/diversified HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 373

{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "deltaReturn": "",
    "deltaVolatility": "",
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/portfolio/optimization/maximum-return/diversified")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"deltaReturn\": \"\",\n    \"deltaVolatility\": \"\",\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/portfolio/optimization/maximum-return/diversified"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"deltaReturn\": \"\",\n    \"deltaVolatility\": \"\",\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"deltaReturn\": \"\",\n    \"deltaVolatility\": \"\",\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/portfolio/optimization/maximum-return/diversified")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/portfolio/optimization/maximum-return/diversified")
  .header("content-type", "application/json")
  .body("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"deltaReturn\": \"\",\n    \"deltaVolatility\": \"\",\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  assets: 0,
  assetsCovarianceMatrix: [],
  assetsReturns: [],
  constraints: {
    assetsGroups: [],
    assetsGroupsMatrix: [],
    deltaReturn: '',
    deltaVolatility: '',
    maximumAssetsGroupsWeights: [],
    maximumAssetsWeights: [],
    maximumPortfolioExposure: '',
    minimumAssetsWeights: [],
    minimumPortfolioExposure: ''
  }
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/portfolio/optimization/maximum-return/diversified');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/optimization/maximum-return/diversified',
  headers: {'content-type': 'application/json'},
  data: {
    assets: 0,
    assetsCovarianceMatrix: [],
    assetsReturns: [],
    constraints: {
      assetsGroups: [],
      assetsGroupsMatrix: [],
      deltaReturn: '',
      deltaVolatility: '',
      maximumAssetsGroupsWeights: [],
      maximumAssetsWeights: [],
      maximumPortfolioExposure: '',
      minimumAssetsWeights: [],
      minimumPortfolioExposure: ''
    }
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/portfolio/optimization/maximum-return/diversified';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":0,"assetsCovarianceMatrix":[],"assetsReturns":[],"constraints":{"assetsGroups":[],"assetsGroupsMatrix":[],"deltaReturn":"","deltaVolatility":"","maximumAssetsGroupsWeights":[],"maximumAssetsWeights":[],"maximumPortfolioExposure":"","minimumAssetsWeights":[],"minimumPortfolioExposure":""}}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/portfolio/optimization/maximum-return/diversified',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "assets": 0,\n  "assetsCovarianceMatrix": [],\n  "assetsReturns": [],\n  "constraints": {\n    "assetsGroups": [],\n    "assetsGroupsMatrix": [],\n    "deltaReturn": "",\n    "deltaVolatility": "",\n    "maximumAssetsGroupsWeights": [],\n    "maximumAssetsWeights": [],\n    "maximumPortfolioExposure": "",\n    "minimumAssetsWeights": [],\n    "minimumPortfolioExposure": ""\n  }\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"deltaReturn\": \"\",\n    \"deltaVolatility\": \"\",\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/portfolio/optimization/maximum-return/diversified")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/portfolio/optimization/maximum-return/diversified',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  assets: 0,
  assetsCovarianceMatrix: [],
  assetsReturns: [],
  constraints: {
    assetsGroups: [],
    assetsGroupsMatrix: [],
    deltaReturn: '',
    deltaVolatility: '',
    maximumAssetsGroupsWeights: [],
    maximumAssetsWeights: [],
    maximumPortfolioExposure: '',
    minimumAssetsWeights: [],
    minimumPortfolioExposure: ''
  }
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/optimization/maximum-return/diversified',
  headers: {'content-type': 'application/json'},
  body: {
    assets: 0,
    assetsCovarianceMatrix: [],
    assetsReturns: [],
    constraints: {
      assetsGroups: [],
      assetsGroupsMatrix: [],
      deltaReturn: '',
      deltaVolatility: '',
      maximumAssetsGroupsWeights: [],
      maximumAssetsWeights: [],
      maximumPortfolioExposure: '',
      minimumAssetsWeights: [],
      minimumPortfolioExposure: ''
    }
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/portfolio/optimization/maximum-return/diversified');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  assets: 0,
  assetsCovarianceMatrix: [],
  assetsReturns: [],
  constraints: {
    assetsGroups: [],
    assetsGroupsMatrix: [],
    deltaReturn: '',
    deltaVolatility: '',
    maximumAssetsGroupsWeights: [],
    maximumAssetsWeights: [],
    maximumPortfolioExposure: '',
    minimumAssetsWeights: [],
    minimumPortfolioExposure: ''
  }
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/optimization/maximum-return/diversified',
  headers: {'content-type': 'application/json'},
  data: {
    assets: 0,
    assetsCovarianceMatrix: [],
    assetsReturns: [],
    constraints: {
      assetsGroups: [],
      assetsGroupsMatrix: [],
      deltaReturn: '',
      deltaVolatility: '',
      maximumAssetsGroupsWeights: [],
      maximumAssetsWeights: [],
      maximumPortfolioExposure: '',
      minimumAssetsWeights: [],
      minimumPortfolioExposure: ''
    }
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/portfolio/optimization/maximum-return/diversified';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":0,"assetsCovarianceMatrix":[],"assetsReturns":[],"constraints":{"assetsGroups":[],"assetsGroupsMatrix":[],"deltaReturn":"","deltaVolatility":"","maximumAssetsGroupsWeights":[],"maximumAssetsWeights":[],"maximumPortfolioExposure":"","minimumAssetsWeights":[],"minimumPortfolioExposure":""}}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"assets": @0,
                              @"assetsCovarianceMatrix": @[  ],
                              @"assetsReturns": @[  ],
                              @"constraints": @{ @"assetsGroups": @[  ], @"assetsGroupsMatrix": @[  ], @"deltaReturn": @"", @"deltaVolatility": @"", @"maximumAssetsGroupsWeights": @[  ], @"maximumAssetsWeights": @[  ], @"maximumPortfolioExposure": @"", @"minimumAssetsWeights": @[  ], @"minimumPortfolioExposure": @"" } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/portfolio/optimization/maximum-return/diversified"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/portfolio/optimization/maximum-return/diversified" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"deltaReturn\": \"\",\n    \"deltaVolatility\": \"\",\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/portfolio/optimization/maximum-return/diversified",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'assets' => 0,
    'assetsCovarianceMatrix' => [
        
    ],
    'assetsReturns' => [
        
    ],
    'constraints' => [
        'assetsGroups' => [
                
        ],
        'assetsGroupsMatrix' => [
                
        ],
        'deltaReturn' => '',
        'deltaVolatility' => '',
        'maximumAssetsGroupsWeights' => [
                
        ],
        'maximumAssetsWeights' => [
                
        ],
        'maximumPortfolioExposure' => '',
        'minimumAssetsWeights' => [
                
        ],
        'minimumPortfolioExposure' => ''
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/portfolio/optimization/maximum-return/diversified', [
  'body' => '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "deltaReturn": "",
    "deltaVolatility": "",
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/portfolio/optimization/maximum-return/diversified');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'assets' => 0,
  'assetsCovarianceMatrix' => [
    
  ],
  'assetsReturns' => [
    
  ],
  'constraints' => [
    'assetsGroups' => [
        
    ],
    'assetsGroupsMatrix' => [
        
    ],
    'deltaReturn' => '',
    'deltaVolatility' => '',
    'maximumAssetsGroupsWeights' => [
        
    ],
    'maximumAssetsWeights' => [
        
    ],
    'maximumPortfolioExposure' => '',
    'minimumAssetsWeights' => [
        
    ],
    'minimumPortfolioExposure' => ''
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'assets' => 0,
  'assetsCovarianceMatrix' => [
    
  ],
  'assetsReturns' => [
    
  ],
  'constraints' => [
    'assetsGroups' => [
        
    ],
    'assetsGroupsMatrix' => [
        
    ],
    'deltaReturn' => '',
    'deltaVolatility' => '',
    'maximumAssetsGroupsWeights' => [
        
    ],
    'maximumAssetsWeights' => [
        
    ],
    'maximumPortfolioExposure' => '',
    'minimumAssetsWeights' => [
        
    ],
    'minimumPortfolioExposure' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/portfolio/optimization/maximum-return/diversified');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/portfolio/optimization/maximum-return/diversified' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "deltaReturn": "",
    "deltaVolatility": "",
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/portfolio/optimization/maximum-return/diversified' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "deltaReturn": "",
    "deltaVolatility": "",
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  }
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"deltaReturn\": \"\",\n    \"deltaVolatility\": \"\",\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/portfolio/optimization/maximum-return/diversified", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/portfolio/optimization/maximum-return/diversified"

payload = {
    "assets": 0,
    "assetsCovarianceMatrix": [],
    "assetsReturns": [],
    "constraints": {
        "assetsGroups": [],
        "assetsGroupsMatrix": [],
        "deltaReturn": "",
        "deltaVolatility": "",
        "maximumAssetsGroupsWeights": [],
        "maximumAssetsWeights": [],
        "maximumPortfolioExposure": "",
        "minimumAssetsWeights": [],
        "minimumPortfolioExposure": ""
    }
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/portfolio/optimization/maximum-return/diversified"

payload <- "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"deltaReturn\": \"\",\n    \"deltaVolatility\": \"\",\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/portfolio/optimization/maximum-return/diversified")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"deltaReturn\": \"\",\n    \"deltaVolatility\": \"\",\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/portfolio/optimization/maximum-return/diversified') do |req|
  req.body = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"deltaReturn\": \"\",\n    \"deltaVolatility\": \"\",\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/portfolio/optimization/maximum-return/diversified";

    let payload = json!({
        "assets": 0,
        "assetsCovarianceMatrix": (),
        "assetsReturns": (),
        "constraints": json!({
            "assetsGroups": (),
            "assetsGroupsMatrix": (),
            "deltaReturn": "",
            "deltaVolatility": "",
            "maximumAssetsGroupsWeights": (),
            "maximumAssetsWeights": (),
            "maximumPortfolioExposure": "",
            "minimumAssetsWeights": (),
            "minimumPortfolioExposure": ""
        })
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/portfolio/optimization/maximum-return/diversified \
  --header 'content-type: application/json' \
  --data '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "deltaReturn": "",
    "deltaVolatility": "",
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  }
}'

echo '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "deltaReturn": "",
    "deltaVolatility": "",
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  }
}' |  \
  http POST {{baseUrl}}/portfolio/optimization/maximum-return/diversified \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "assets": 0,\n  "assetsCovarianceMatrix": [],\n  "assetsReturns": [],\n  "constraints": {\n    "assetsGroups": [],\n    "assetsGroupsMatrix": [],\n    "deltaReturn": "",\n    "deltaVolatility": "",\n    "maximumAssetsGroupsWeights": [],\n    "maximumAssetsWeights": [],\n    "maximumPortfolioExposure": "",\n    "minimumAssetsWeights": [],\n    "minimumPortfolioExposure": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/portfolio/optimization/maximum-return/diversified

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": [
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "deltaReturn": "",
    "deltaVolatility": "",
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/portfolio/optimization/maximum-return/diversified")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "assetsWeights": [
    0.3999998369710335,
    0.6000001630289665
  ]
}

POST Diversified Maximum Sharpe Ratio Portfolio

{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio/diversified

BODY json

{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "deltaReturn": "",
    "deltaVolatility": "",
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  },
  "riskFreeRate": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio/diversified");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"deltaReturn\": \"\",\n    \"deltaVolatility\": \"\",\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"riskFreeRate\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio/diversified" {:content-type :json
                                                                                                    :form-params {:assets 0
                                                                                                                  :assetsCovarianceMatrix []
                                                                                                                  :assetsReturns []
                                                                                                                  :constraints {:assetsGroups []
                                                                                                                                :assetsGroupsMatrix []
                                                                                                                                :deltaReturn ""
                                                                                                                                :deltaVolatility ""
                                                                                                                                :maximumAssetsGroupsWeights []
                                                                                                                                :maximumAssetsWeights []
                                                                                                                                :maximumPortfolioExposure ""
                                                                                                                                :minimumAssetsWeights []
                                                                                                                                :minimumPortfolioExposure ""}
                                                                                                                  :riskFreeRate ""}})

require "http/client"

url = "{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio/diversified"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"deltaReturn\": \"\",\n    \"deltaVolatility\": \"\",\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"riskFreeRate\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio/diversified"),
    Content = new StringContent("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"deltaReturn\": \"\",\n    \"deltaVolatility\": \"\",\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"riskFreeRate\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio/diversified");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"deltaReturn\": \"\",\n    \"deltaVolatility\": \"\",\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"riskFreeRate\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio/diversified"

	payload := strings.NewReader("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"deltaReturn\": \"\",\n    \"deltaVolatility\": \"\",\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"riskFreeRate\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/portfolio/optimization/maximum-sharpe-ratio/diversified HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 395

{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "deltaReturn": "",
    "deltaVolatility": "",
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  },
  "riskFreeRate": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio/diversified")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"deltaReturn\": \"\",\n    \"deltaVolatility\": \"\",\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"riskFreeRate\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio/diversified"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"deltaReturn\": \"\",\n    \"deltaVolatility\": \"\",\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"riskFreeRate\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"deltaReturn\": \"\",\n    \"deltaVolatility\": \"\",\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"riskFreeRate\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio/diversified")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio/diversified")
  .header("content-type", "application/json")
  .body("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"deltaReturn\": \"\",\n    \"deltaVolatility\": \"\",\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"riskFreeRate\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  assets: 0,
  assetsCovarianceMatrix: [],
  assetsReturns: [],
  constraints: {
    assetsGroups: [],
    assetsGroupsMatrix: [],
    deltaReturn: '',
    deltaVolatility: '',
    maximumAssetsGroupsWeights: [],
    maximumAssetsWeights: [],
    maximumPortfolioExposure: '',
    minimumAssetsWeights: [],
    minimumPortfolioExposure: ''
  },
  riskFreeRate: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio/diversified');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio/diversified',
  headers: {'content-type': 'application/json'},
  data: {
    assets: 0,
    assetsCovarianceMatrix: [],
    assetsReturns: [],
    constraints: {
      assetsGroups: [],
      assetsGroupsMatrix: [],
      deltaReturn: '',
      deltaVolatility: '',
      maximumAssetsGroupsWeights: [],
      maximumAssetsWeights: [],
      maximumPortfolioExposure: '',
      minimumAssetsWeights: [],
      minimumPortfolioExposure: ''
    },
    riskFreeRate: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio/diversified';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":0,"assetsCovarianceMatrix":[],"assetsReturns":[],"constraints":{"assetsGroups":[],"assetsGroupsMatrix":[],"deltaReturn":"","deltaVolatility":"","maximumAssetsGroupsWeights":[],"maximumAssetsWeights":[],"maximumPortfolioExposure":"","minimumAssetsWeights":[],"minimumPortfolioExposure":""},"riskFreeRate":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio/diversified',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "assets": 0,\n  "assetsCovarianceMatrix": [],\n  "assetsReturns": [],\n  "constraints": {\n    "assetsGroups": [],\n    "assetsGroupsMatrix": [],\n    "deltaReturn": "",\n    "deltaVolatility": "",\n    "maximumAssetsGroupsWeights": [],\n    "maximumAssetsWeights": [],\n    "maximumPortfolioExposure": "",\n    "minimumAssetsWeights": [],\n    "minimumPortfolioExposure": ""\n  },\n  "riskFreeRate": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"deltaReturn\": \"\",\n    \"deltaVolatility\": \"\",\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"riskFreeRate\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio/diversified")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/portfolio/optimization/maximum-sharpe-ratio/diversified',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  assets: 0,
  assetsCovarianceMatrix: [],
  assetsReturns: [],
  constraints: {
    assetsGroups: [],
    assetsGroupsMatrix: [],
    deltaReturn: '',
    deltaVolatility: '',
    maximumAssetsGroupsWeights: [],
    maximumAssetsWeights: [],
    maximumPortfolioExposure: '',
    minimumAssetsWeights: [],
    minimumPortfolioExposure: ''
  },
  riskFreeRate: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio/diversified',
  headers: {'content-type': 'application/json'},
  body: {
    assets: 0,
    assetsCovarianceMatrix: [],
    assetsReturns: [],
    constraints: {
      assetsGroups: [],
      assetsGroupsMatrix: [],
      deltaReturn: '',
      deltaVolatility: '',
      maximumAssetsGroupsWeights: [],
      maximumAssetsWeights: [],
      maximumPortfolioExposure: '',
      minimumAssetsWeights: [],
      minimumPortfolioExposure: ''
    },
    riskFreeRate: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio/diversified');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  assets: 0,
  assetsCovarianceMatrix: [],
  assetsReturns: [],
  constraints: {
    assetsGroups: [],
    assetsGroupsMatrix: [],
    deltaReturn: '',
    deltaVolatility: '',
    maximumAssetsGroupsWeights: [],
    maximumAssetsWeights: [],
    maximumPortfolioExposure: '',
    minimumAssetsWeights: [],
    minimumPortfolioExposure: ''
  },
  riskFreeRate: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio/diversified',
  headers: {'content-type': 'application/json'},
  data: {
    assets: 0,
    assetsCovarianceMatrix: [],
    assetsReturns: [],
    constraints: {
      assetsGroups: [],
      assetsGroupsMatrix: [],
      deltaReturn: '',
      deltaVolatility: '',
      maximumAssetsGroupsWeights: [],
      maximumAssetsWeights: [],
      maximumPortfolioExposure: '',
      minimumAssetsWeights: [],
      minimumPortfolioExposure: ''
    },
    riskFreeRate: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio/diversified';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":0,"assetsCovarianceMatrix":[],"assetsReturns":[],"constraints":{"assetsGroups":[],"assetsGroupsMatrix":[],"deltaReturn":"","deltaVolatility":"","maximumAssetsGroupsWeights":[],"maximumAssetsWeights":[],"maximumPortfolioExposure":"","minimumAssetsWeights":[],"minimumPortfolioExposure":""},"riskFreeRate":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"assets": @0,
                              @"assetsCovarianceMatrix": @[  ],
                              @"assetsReturns": @[  ],
                              @"constraints": @{ @"assetsGroups": @[  ], @"assetsGroupsMatrix": @[  ], @"deltaReturn": @"", @"deltaVolatility": @"", @"maximumAssetsGroupsWeights": @[  ], @"maximumAssetsWeights": @[  ], @"maximumPortfolioExposure": @"", @"minimumAssetsWeights": @[  ], @"minimumPortfolioExposure": @"" },
                              @"riskFreeRate": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio/diversified"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio/diversified" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"deltaReturn\": \"\",\n    \"deltaVolatility\": \"\",\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"riskFreeRate\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio/diversified",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'assets' => 0,
    'assetsCovarianceMatrix' => [
        
    ],
    'assetsReturns' => [
        
    ],
    'constraints' => [
        'assetsGroups' => [
                
        ],
        'assetsGroupsMatrix' => [
                
        ],
        'deltaReturn' => '',
        'deltaVolatility' => '',
        'maximumAssetsGroupsWeights' => [
                
        ],
        'maximumAssetsWeights' => [
                
        ],
        'maximumPortfolioExposure' => '',
        'minimumAssetsWeights' => [
                
        ],
        'minimumPortfolioExposure' => ''
    ],
    'riskFreeRate' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio/diversified', [
  'body' => '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "deltaReturn": "",
    "deltaVolatility": "",
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  },
  "riskFreeRate": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio/diversified');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'assets' => 0,
  'assetsCovarianceMatrix' => [
    
  ],
  'assetsReturns' => [
    
  ],
  'constraints' => [
    'assetsGroups' => [
        
    ],
    'assetsGroupsMatrix' => [
        
    ],
    'deltaReturn' => '',
    'deltaVolatility' => '',
    'maximumAssetsGroupsWeights' => [
        
    ],
    'maximumAssetsWeights' => [
        
    ],
    'maximumPortfolioExposure' => '',
    'minimumAssetsWeights' => [
        
    ],
    'minimumPortfolioExposure' => ''
  ],
  'riskFreeRate' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'assets' => 0,
  'assetsCovarianceMatrix' => [
    
  ],
  'assetsReturns' => [
    
  ],
  'constraints' => [
    'assetsGroups' => [
        
    ],
    'assetsGroupsMatrix' => [
        
    ],
    'deltaReturn' => '',
    'deltaVolatility' => '',
    'maximumAssetsGroupsWeights' => [
        
    ],
    'maximumAssetsWeights' => [
        
    ],
    'maximumPortfolioExposure' => '',
    'minimumAssetsWeights' => [
        
    ],
    'minimumPortfolioExposure' => ''
  ],
  'riskFreeRate' => ''
]));
$request->setRequestUrl('{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio/diversified');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio/diversified' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "deltaReturn": "",
    "deltaVolatility": "",
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  },
  "riskFreeRate": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio/diversified' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "deltaReturn": "",
    "deltaVolatility": "",
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  },
  "riskFreeRate": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"deltaReturn\": \"\",\n    \"deltaVolatility\": \"\",\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"riskFreeRate\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/portfolio/optimization/maximum-sharpe-ratio/diversified", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio/diversified"

payload = {
    "assets": 0,
    "assetsCovarianceMatrix": [],
    "assetsReturns": [],
    "constraints": {
        "assetsGroups": [],
        "assetsGroupsMatrix": [],
        "deltaReturn": "",
        "deltaVolatility": "",
        "maximumAssetsGroupsWeights": [],
        "maximumAssetsWeights": [],
        "maximumPortfolioExposure": "",
        "minimumAssetsWeights": [],
        "minimumPortfolioExposure": ""
    },
    "riskFreeRate": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio/diversified"

payload <- "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"deltaReturn\": \"\",\n    \"deltaVolatility\": \"\",\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"riskFreeRate\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio/diversified")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"deltaReturn\": \"\",\n    \"deltaVolatility\": \"\",\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"riskFreeRate\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/portfolio/optimization/maximum-sharpe-ratio/diversified') do |req|
  req.body = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"deltaReturn\": \"\",\n    \"deltaVolatility\": \"\",\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"riskFreeRate\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio/diversified";

    let payload = json!({
        "assets": 0,
        "assetsCovarianceMatrix": (),
        "assetsReturns": (),
        "constraints": json!({
            "assetsGroups": (),
            "assetsGroupsMatrix": (),
            "deltaReturn": "",
            "deltaVolatility": "",
            "maximumAssetsGroupsWeights": (),
            "maximumAssetsWeights": (),
            "maximumPortfolioExposure": "",
            "minimumAssetsWeights": (),
            "minimumPortfolioExposure": ""
        }),
        "riskFreeRate": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio/diversified \
  --header 'content-type: application/json' \
  --data '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "deltaReturn": "",
    "deltaVolatility": "",
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  },
  "riskFreeRate": ""
}'

echo '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "deltaReturn": "",
    "deltaVolatility": "",
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  },
  "riskFreeRate": ""
}' |  \
  http POST {{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio/diversified \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "assets": 0,\n  "assetsCovarianceMatrix": [],\n  "assetsReturns": [],\n  "constraints": {\n    "assetsGroups": [],\n    "assetsGroupsMatrix": [],\n    "deltaReturn": "",\n    "deltaVolatility": "",\n    "maximumAssetsGroupsWeights": [],\n    "maximumAssetsWeights": [],\n    "maximumPortfolioExposure": "",\n    "minimumAssetsWeights": [],\n    "minimumPortfolioExposure": ""\n  },\n  "riskFreeRate": ""\n}' \
  --output-document \
  - {{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio/diversified

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": [
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "deltaReturn": "",
    "deltaVolatility": "",
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  ],
  "riskFreeRate": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio/diversified")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "assetsWeights": [
    0.44545623478220464,
    0.5545437652177954
  ]
}

POST Diversified Mean-Variance Efficient Portfolio

{{baseUrl}}/portfolio/optimization/mean-variance-efficient/diversified

BODY json

{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "deltaReturn": "",
    "deltaVolatility": "",
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": "",
    "portfolioReturn": "",
    "portfolioVolatility": "",
    "riskTolerance": ""
  }
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/portfolio/optimization/mean-variance-efficient/diversified");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"deltaReturn\": \"\",\n    \"deltaVolatility\": \"\",\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\",\n    \"portfolioReturn\": \"\",\n    \"portfolioVolatility\": \"\",\n    \"riskTolerance\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/portfolio/optimization/mean-variance-efficient/diversified" {:content-type :json
                                                                                                       :form-params {:assets 0
                                                                                                                     :assetsCovarianceMatrix []
                                                                                                                     :assetsReturns []
                                                                                                                     :constraints {:assetsGroups []
                                                                                                                                   :assetsGroupsMatrix []
                                                                                                                                   :deltaReturn ""
                                                                                                                                   :deltaVolatility ""
                                                                                                                                   :maximumAssetsGroupsWeights []
                                                                                                                                   :maximumAssetsWeights []
                                                                                                                                   :maximumPortfolioExposure ""
                                                                                                                                   :minimumAssetsWeights []
                                                                                                                                   :minimumPortfolioExposure ""
                                                                                                                                   :portfolioReturn ""
                                                                                                                                   :portfolioVolatility ""
                                                                                                                                   :riskTolerance ""}}})

require "http/client"

url = "{{baseUrl}}/portfolio/optimization/mean-variance-efficient/diversified"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"deltaReturn\": \"\",\n    \"deltaVolatility\": \"\",\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\",\n    \"portfolioReturn\": \"\",\n    \"portfolioVolatility\": \"\",\n    \"riskTolerance\": \"\"\n  }\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/portfolio/optimization/mean-variance-efficient/diversified"),
    Content = new StringContent("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"deltaReturn\": \"\",\n    \"deltaVolatility\": \"\",\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\",\n    \"portfolioReturn\": \"\",\n    \"portfolioVolatility\": \"\",\n    \"riskTolerance\": \"\"\n  }\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/portfolio/optimization/mean-variance-efficient/diversified");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"deltaReturn\": \"\",\n    \"deltaVolatility\": \"\",\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\",\n    \"portfolioReturn\": \"\",\n    \"portfolioVolatility\": \"\",\n    \"riskTolerance\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/portfolio/optimization/mean-variance-efficient/diversified"

	payload := strings.NewReader("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"deltaReturn\": \"\",\n    \"deltaVolatility\": \"\",\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\",\n    \"portfolioReturn\": \"\",\n    \"portfolioVolatility\": \"\",\n    \"riskTolerance\": \"\"\n  }\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/portfolio/optimization/mean-variance-efficient/diversified HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 456

{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "deltaReturn": "",
    "deltaVolatility": "",
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": "",
    "portfolioReturn": "",
    "portfolioVolatility": "",
    "riskTolerance": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/portfolio/optimization/mean-variance-efficient/diversified")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"deltaReturn\": \"\",\n    \"deltaVolatility\": \"\",\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\",\n    \"portfolioReturn\": \"\",\n    \"portfolioVolatility\": \"\",\n    \"riskTolerance\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/portfolio/optimization/mean-variance-efficient/diversified"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"deltaReturn\": \"\",\n    \"deltaVolatility\": \"\",\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\",\n    \"portfolioReturn\": \"\",\n    \"portfolioVolatility\": \"\",\n    \"riskTolerance\": \"\"\n  }\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"deltaReturn\": \"\",\n    \"deltaVolatility\": \"\",\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\",\n    \"portfolioReturn\": \"\",\n    \"portfolioVolatility\": \"\",\n    \"riskTolerance\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/portfolio/optimization/mean-variance-efficient/diversified")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/portfolio/optimization/mean-variance-efficient/diversified")
  .header("content-type", "application/json")
  .body("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"deltaReturn\": \"\",\n    \"deltaVolatility\": \"\",\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\",\n    \"portfolioReturn\": \"\",\n    \"portfolioVolatility\": \"\",\n    \"riskTolerance\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  assets: 0,
  assetsCovarianceMatrix: [],
  assetsReturns: [],
  constraints: {
    assetsGroups: [],
    assetsGroupsMatrix: [],
    deltaReturn: '',
    deltaVolatility: '',
    maximumAssetsGroupsWeights: [],
    maximumAssetsWeights: [],
    maximumPortfolioExposure: '',
    minimumAssetsWeights: [],
    minimumPortfolioExposure: '',
    portfolioReturn: '',
    portfolioVolatility: '',
    riskTolerance: ''
  }
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/portfolio/optimization/mean-variance-efficient/diversified');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/optimization/mean-variance-efficient/diversified',
  headers: {'content-type': 'application/json'},
  data: {
    assets: 0,
    assetsCovarianceMatrix: [],
    assetsReturns: [],
    constraints: {
      assetsGroups: [],
      assetsGroupsMatrix: [],
      deltaReturn: '',
      deltaVolatility: '',
      maximumAssetsGroupsWeights: [],
      maximumAssetsWeights: [],
      maximumPortfolioExposure: '',
      minimumAssetsWeights: [],
      minimumPortfolioExposure: '',
      portfolioReturn: '',
      portfolioVolatility: '',
      riskTolerance: ''
    }
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/portfolio/optimization/mean-variance-efficient/diversified';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":0,"assetsCovarianceMatrix":[],"assetsReturns":[],"constraints":{"assetsGroups":[],"assetsGroupsMatrix":[],"deltaReturn":"","deltaVolatility":"","maximumAssetsGroupsWeights":[],"maximumAssetsWeights":[],"maximumPortfolioExposure":"","minimumAssetsWeights":[],"minimumPortfolioExposure":"","portfolioReturn":"","portfolioVolatility":"","riskTolerance":""}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/portfolio/optimization/mean-variance-efficient/diversified',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "assets": 0,\n  "assetsCovarianceMatrix": [],\n  "assetsReturns": [],\n  "constraints": {\n    "assetsGroups": [],\n    "assetsGroupsMatrix": [],\n    "deltaReturn": "",\n    "deltaVolatility": "",\n    "maximumAssetsGroupsWeights": [],\n    "maximumAssetsWeights": [],\n    "maximumPortfolioExposure": "",\n    "minimumAssetsWeights": [],\n    "minimumPortfolioExposure": "",\n    "portfolioReturn": "",\n    "portfolioVolatility": "",\n    "riskTolerance": ""\n  }\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"deltaReturn\": \"\",\n    \"deltaVolatility\": \"\",\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\",\n    \"portfolioReturn\": \"\",\n    \"portfolioVolatility\": \"\",\n    \"riskTolerance\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/portfolio/optimization/mean-variance-efficient/diversified")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/portfolio/optimization/mean-variance-efficient/diversified',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  assets: 0,
  assetsCovarianceMatrix: [],
  assetsReturns: [],
  constraints: {
    assetsGroups: [],
    assetsGroupsMatrix: [],
    deltaReturn: '',
    deltaVolatility: '',
    maximumAssetsGroupsWeights: [],
    maximumAssetsWeights: [],
    maximumPortfolioExposure: '',
    minimumAssetsWeights: [],
    minimumPortfolioExposure: '',
    portfolioReturn: '',
    portfolioVolatility: '',
    riskTolerance: ''
  }
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/optimization/mean-variance-efficient/diversified',
  headers: {'content-type': 'application/json'},
  body: {
    assets: 0,
    assetsCovarianceMatrix: [],
    assetsReturns: [],
    constraints: {
      assetsGroups: [],
      assetsGroupsMatrix: [],
      deltaReturn: '',
      deltaVolatility: '',
      maximumAssetsGroupsWeights: [],
      maximumAssetsWeights: [],
      maximumPortfolioExposure: '',
      minimumAssetsWeights: [],
      minimumPortfolioExposure: '',
      portfolioReturn: '',
      portfolioVolatility: '',
      riskTolerance: ''
    }
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/portfolio/optimization/mean-variance-efficient/diversified');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  assets: 0,
  assetsCovarianceMatrix: [],
  assetsReturns: [],
  constraints: {
    assetsGroups: [],
    assetsGroupsMatrix: [],
    deltaReturn: '',
    deltaVolatility: '',
    maximumAssetsGroupsWeights: [],
    maximumAssetsWeights: [],
    maximumPortfolioExposure: '',
    minimumAssetsWeights: [],
    minimumPortfolioExposure: '',
    portfolioReturn: '',
    portfolioVolatility: '',
    riskTolerance: ''
  }
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/optimization/mean-variance-efficient/diversified',
  headers: {'content-type': 'application/json'},
  data: {
    assets: 0,
    assetsCovarianceMatrix: [],
    assetsReturns: [],
    constraints: {
      assetsGroups: [],
      assetsGroupsMatrix: [],
      deltaReturn: '',
      deltaVolatility: '',
      maximumAssetsGroupsWeights: [],
      maximumAssetsWeights: [],
      maximumPortfolioExposure: '',
      minimumAssetsWeights: [],
      minimumPortfolioExposure: '',
      portfolioReturn: '',
      portfolioVolatility: '',
      riskTolerance: ''
    }
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/portfolio/optimization/mean-variance-efficient/diversified';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":0,"assetsCovarianceMatrix":[],"assetsReturns":[],"constraints":{"assetsGroups":[],"assetsGroupsMatrix":[],"deltaReturn":"","deltaVolatility":"","maximumAssetsGroupsWeights":[],"maximumAssetsWeights":[],"maximumPortfolioExposure":"","minimumAssetsWeights":[],"minimumPortfolioExposure":"","portfolioReturn":"","portfolioVolatility":"","riskTolerance":""}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"assets": @0,
                              @"assetsCovarianceMatrix": @[  ],
                              @"assetsReturns": @[  ],
                              @"constraints": @{ @"assetsGroups": @[  ], @"assetsGroupsMatrix": @[  ], @"deltaReturn": @"", @"deltaVolatility": @"", @"maximumAssetsGroupsWeights": @[  ], @"maximumAssetsWeights": @[  ], @"maximumPortfolioExposure": @"", @"minimumAssetsWeights": @[  ], @"minimumPortfolioExposure": @"", @"portfolioReturn": @"", @"portfolioVolatility": @"", @"riskTolerance": @"" } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/portfolio/optimization/mean-variance-efficient/diversified"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/portfolio/optimization/mean-variance-efficient/diversified" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"deltaReturn\": \"\",\n    \"deltaVolatility\": \"\",\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\",\n    \"portfolioReturn\": \"\",\n    \"portfolioVolatility\": \"\",\n    \"riskTolerance\": \"\"\n  }\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/portfolio/optimization/mean-variance-efficient/diversified",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'assets' => 0,
    'assetsCovarianceMatrix' => [
        
    ],
    'assetsReturns' => [
        
    ],
    'constraints' => [
        'assetsGroups' => [
                
        ],
        'assetsGroupsMatrix' => [
                
        ],
        'deltaReturn' => '',
        'deltaVolatility' => '',
        'maximumAssetsGroupsWeights' => [
                
        ],
        'maximumAssetsWeights' => [
                
        ],
        'maximumPortfolioExposure' => '',
        'minimumAssetsWeights' => [
                
        ],
        'minimumPortfolioExposure' => '',
        'portfolioReturn' => '',
        'portfolioVolatility' => '',
        'riskTolerance' => ''
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/portfolio/optimization/mean-variance-efficient/diversified', [
  'body' => '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "deltaReturn": "",
    "deltaVolatility": "",
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": "",
    "portfolioReturn": "",
    "portfolioVolatility": "",
    "riskTolerance": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/portfolio/optimization/mean-variance-efficient/diversified');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'assets' => 0,
  'assetsCovarianceMatrix' => [
    
  ],
  'assetsReturns' => [
    
  ],
  'constraints' => [
    'assetsGroups' => [
        
    ],
    'assetsGroupsMatrix' => [
        
    ],
    'deltaReturn' => '',
    'deltaVolatility' => '',
    'maximumAssetsGroupsWeights' => [
        
    ],
    'maximumAssetsWeights' => [
        
    ],
    'maximumPortfolioExposure' => '',
    'minimumAssetsWeights' => [
        
    ],
    'minimumPortfolioExposure' => '',
    'portfolioReturn' => '',
    'portfolioVolatility' => '',
    'riskTolerance' => ''
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'assets' => 0,
  'assetsCovarianceMatrix' => [
    
  ],
  'assetsReturns' => [
    
  ],
  'constraints' => [
    'assetsGroups' => [
        
    ],
    'assetsGroupsMatrix' => [
        
    ],
    'deltaReturn' => '',
    'deltaVolatility' => '',
    'maximumAssetsGroupsWeights' => [
        
    ],
    'maximumAssetsWeights' => [
        
    ],
    'maximumPortfolioExposure' => '',
    'minimumAssetsWeights' => [
        
    ],
    'minimumPortfolioExposure' => '',
    'portfolioReturn' => '',
    'portfolioVolatility' => '',
    'riskTolerance' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/portfolio/optimization/mean-variance-efficient/diversified');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/portfolio/optimization/mean-variance-efficient/diversified' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "deltaReturn": "",
    "deltaVolatility": "",
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": "",
    "portfolioReturn": "",
    "portfolioVolatility": "",
    "riskTolerance": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/portfolio/optimization/mean-variance-efficient/diversified' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "deltaReturn": "",
    "deltaVolatility": "",
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": "",
    "portfolioReturn": "",
    "portfolioVolatility": "",
    "riskTolerance": ""
  }
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"deltaReturn\": \"\",\n    \"deltaVolatility\": \"\",\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\",\n    \"portfolioReturn\": \"\",\n    \"portfolioVolatility\": \"\",\n    \"riskTolerance\": \"\"\n  }\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/portfolio/optimization/mean-variance-efficient/diversified", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/portfolio/optimization/mean-variance-efficient/diversified"

payload = {
    "assets": 0,
    "assetsCovarianceMatrix": [],
    "assetsReturns": [],
    "constraints": {
        "assetsGroups": [],
        "assetsGroupsMatrix": [],
        "deltaReturn": "",
        "deltaVolatility": "",
        "maximumAssetsGroupsWeights": [],
        "maximumAssetsWeights": [],
        "maximumPortfolioExposure": "",
        "minimumAssetsWeights": [],
        "minimumPortfolioExposure": "",
        "portfolioReturn": "",
        "portfolioVolatility": "",
        "riskTolerance": ""
    }
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/portfolio/optimization/mean-variance-efficient/diversified"

payload <- "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"deltaReturn\": \"\",\n    \"deltaVolatility\": \"\",\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\",\n    \"portfolioReturn\": \"\",\n    \"portfolioVolatility\": \"\",\n    \"riskTolerance\": \"\"\n  }\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/portfolio/optimization/mean-variance-efficient/diversified")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"deltaReturn\": \"\",\n    \"deltaVolatility\": \"\",\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\",\n    \"portfolioReturn\": \"\",\n    \"portfolioVolatility\": \"\",\n    \"riskTolerance\": \"\"\n  }\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/portfolio/optimization/mean-variance-efficient/diversified') do |req|
  req.body = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"deltaReturn\": \"\",\n    \"deltaVolatility\": \"\",\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\",\n    \"portfolioReturn\": \"\",\n    \"portfolioVolatility\": \"\",\n    \"riskTolerance\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/portfolio/optimization/mean-variance-efficient/diversified";

    let payload = json!({
        "assets": 0,
        "assetsCovarianceMatrix": (),
        "assetsReturns": (),
        "constraints": json!({
            "assetsGroups": (),
            "assetsGroupsMatrix": (),
            "deltaReturn": "",
            "deltaVolatility": "",
            "maximumAssetsGroupsWeights": (),
            "maximumAssetsWeights": (),
            "maximumPortfolioExposure": "",
            "minimumAssetsWeights": (),
            "minimumPortfolioExposure": "",
            "portfolioReturn": "",
            "portfolioVolatility": "",
            "riskTolerance": ""
        })
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/portfolio/optimization/mean-variance-efficient/diversified \
  --header 'content-type: application/json' \
  --data '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "deltaReturn": "",
    "deltaVolatility": "",
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": "",
    "portfolioReturn": "",
    "portfolioVolatility": "",
    "riskTolerance": ""
  }
}'

echo '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "deltaReturn": "",
    "deltaVolatility": "",
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": "",
    "portfolioReturn": "",
    "portfolioVolatility": "",
    "riskTolerance": ""
  }
}' |  \
  http POST {{baseUrl}}/portfolio/optimization/mean-variance-efficient/diversified \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "assets": 0,\n  "assetsCovarianceMatrix": [],\n  "assetsReturns": [],\n  "constraints": {\n    "assetsGroups": [],\n    "assetsGroupsMatrix": [],\n    "deltaReturn": "",\n    "deltaVolatility": "",\n    "maximumAssetsGroupsWeights": [],\n    "maximumAssetsWeights": [],\n    "maximumPortfolioExposure": "",\n    "minimumAssetsWeights": [],\n    "minimumPortfolioExposure": "",\n    "portfolioReturn": "",\n    "portfolioVolatility": "",\n    "riskTolerance": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/portfolio/optimization/mean-variance-efficient/diversified

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": [
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "deltaReturn": "",
    "deltaVolatility": "",
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": "",
    "portfolioReturn": "",
    "portfolioVolatility": "",
    "riskTolerance": ""
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/portfolio/optimization/mean-variance-efficient/diversified")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "assetsWeights": [
    0.3375016499673578,
    0.6624983500326422
  ]
}

POST Diversified Minimum Variance Portfolio

{{baseUrl}}/portfolio/optimization/minimum-variance/diversified

BODY json

{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "deltaReturn": "",
    "deltaVolatility": "",
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  }
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/portfolio/optimization/minimum-variance/diversified");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"deltaReturn\": \"\",\n    \"deltaVolatility\": \"\",\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/portfolio/optimization/minimum-variance/diversified" {:content-type :json
                                                                                                :form-params {:assets 0
                                                                                                              :assetsCovarianceMatrix []
                                                                                                              :assetsReturns []
                                                                                                              :constraints {:assetsGroups []
                                                                                                                            :assetsGroupsMatrix []
                                                                                                                            :deltaReturn ""
                                                                                                                            :deltaVolatility ""
                                                                                                                            :maximumAssetsGroupsWeights []
                                                                                                                            :maximumAssetsWeights []
                                                                                                                            :maximumPortfolioExposure ""
                                                                                                                            :minimumAssetsWeights []
                                                                                                                            :minimumPortfolioExposure ""}}})

require "http/client"

url = "{{baseUrl}}/portfolio/optimization/minimum-variance/diversified"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"deltaReturn\": \"\",\n    \"deltaVolatility\": \"\",\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/portfolio/optimization/minimum-variance/diversified"),
    Content = new StringContent("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"deltaReturn\": \"\",\n    \"deltaVolatility\": \"\",\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/portfolio/optimization/minimum-variance/diversified");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"deltaReturn\": \"\",\n    \"deltaVolatility\": \"\",\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/portfolio/optimization/minimum-variance/diversified"

	payload := strings.NewReader("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"deltaReturn\": \"\",\n    \"deltaVolatility\": \"\",\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/portfolio/optimization/minimum-variance/diversified HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 373

{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "deltaReturn": "",
    "deltaVolatility": "",
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/portfolio/optimization/minimum-variance/diversified")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"deltaReturn\": \"\",\n    \"deltaVolatility\": \"\",\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/portfolio/optimization/minimum-variance/diversified"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"deltaReturn\": \"\",\n    \"deltaVolatility\": \"\",\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"deltaReturn\": \"\",\n    \"deltaVolatility\": \"\",\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/portfolio/optimization/minimum-variance/diversified")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/portfolio/optimization/minimum-variance/diversified")
  .header("content-type", "application/json")
  .body("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"deltaReturn\": \"\",\n    \"deltaVolatility\": \"\",\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  assets: 0,
  assetsCovarianceMatrix: [],
  assetsReturns: [],
  constraints: {
    assetsGroups: [],
    assetsGroupsMatrix: [],
    deltaReturn: '',
    deltaVolatility: '',
    maximumAssetsGroupsWeights: [],
    maximumAssetsWeights: [],
    maximumPortfolioExposure: '',
    minimumAssetsWeights: [],
    minimumPortfolioExposure: ''
  }
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/portfolio/optimization/minimum-variance/diversified');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/optimization/minimum-variance/diversified',
  headers: {'content-type': 'application/json'},
  data: {
    assets: 0,
    assetsCovarianceMatrix: [],
    assetsReturns: [],
    constraints: {
      assetsGroups: [],
      assetsGroupsMatrix: [],
      deltaReturn: '',
      deltaVolatility: '',
      maximumAssetsGroupsWeights: [],
      maximumAssetsWeights: [],
      maximumPortfolioExposure: '',
      minimumAssetsWeights: [],
      minimumPortfolioExposure: ''
    }
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/portfolio/optimization/minimum-variance/diversified';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":0,"assetsCovarianceMatrix":[],"assetsReturns":[],"constraints":{"assetsGroups":[],"assetsGroupsMatrix":[],"deltaReturn":"","deltaVolatility":"","maximumAssetsGroupsWeights":[],"maximumAssetsWeights":[],"maximumPortfolioExposure":"","minimumAssetsWeights":[],"minimumPortfolioExposure":""}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/portfolio/optimization/minimum-variance/diversified',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "assets": 0,\n  "assetsCovarianceMatrix": [],\n  "assetsReturns": [],\n  "constraints": {\n    "assetsGroups": [],\n    "assetsGroupsMatrix": [],\n    "deltaReturn": "",\n    "deltaVolatility": "",\n    "maximumAssetsGroupsWeights": [],\n    "maximumAssetsWeights": [],\n    "maximumPortfolioExposure": "",\n    "minimumAssetsWeights": [],\n    "minimumPortfolioExposure": ""\n  }\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"deltaReturn\": \"\",\n    \"deltaVolatility\": \"\",\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/portfolio/optimization/minimum-variance/diversified")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/portfolio/optimization/minimum-variance/diversified',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  assets: 0,
  assetsCovarianceMatrix: [],
  assetsReturns: [],
  constraints: {
    assetsGroups: [],
    assetsGroupsMatrix: [],
    deltaReturn: '',
    deltaVolatility: '',
    maximumAssetsGroupsWeights: [],
    maximumAssetsWeights: [],
    maximumPortfolioExposure: '',
    minimumAssetsWeights: [],
    minimumPortfolioExposure: ''
  }
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/optimization/minimum-variance/diversified',
  headers: {'content-type': 'application/json'},
  body: {
    assets: 0,
    assetsCovarianceMatrix: [],
    assetsReturns: [],
    constraints: {
      assetsGroups: [],
      assetsGroupsMatrix: [],
      deltaReturn: '',
      deltaVolatility: '',
      maximumAssetsGroupsWeights: [],
      maximumAssetsWeights: [],
      maximumPortfolioExposure: '',
      minimumAssetsWeights: [],
      minimumPortfolioExposure: ''
    }
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/portfolio/optimization/minimum-variance/diversified');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  assets: 0,
  assetsCovarianceMatrix: [],
  assetsReturns: [],
  constraints: {
    assetsGroups: [],
    assetsGroupsMatrix: [],
    deltaReturn: '',
    deltaVolatility: '',
    maximumAssetsGroupsWeights: [],
    maximumAssetsWeights: [],
    maximumPortfolioExposure: '',
    minimumAssetsWeights: [],
    minimumPortfolioExposure: ''
  }
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/optimization/minimum-variance/diversified',
  headers: {'content-type': 'application/json'},
  data: {
    assets: 0,
    assetsCovarianceMatrix: [],
    assetsReturns: [],
    constraints: {
      assetsGroups: [],
      assetsGroupsMatrix: [],
      deltaReturn: '',
      deltaVolatility: '',
      maximumAssetsGroupsWeights: [],
      maximumAssetsWeights: [],
      maximumPortfolioExposure: '',
      minimumAssetsWeights: [],
      minimumPortfolioExposure: ''
    }
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/portfolio/optimization/minimum-variance/diversified';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":0,"assetsCovarianceMatrix":[],"assetsReturns":[],"constraints":{"assetsGroups":[],"assetsGroupsMatrix":[],"deltaReturn":"","deltaVolatility":"","maximumAssetsGroupsWeights":[],"maximumAssetsWeights":[],"maximumPortfolioExposure":"","minimumAssetsWeights":[],"minimumPortfolioExposure":""}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"assets": @0,
                              @"assetsCovarianceMatrix": @[  ],
                              @"assetsReturns": @[  ],
                              @"constraints": @{ @"assetsGroups": @[  ], @"assetsGroupsMatrix": @[  ], @"deltaReturn": @"", @"deltaVolatility": @"", @"maximumAssetsGroupsWeights": @[  ], @"maximumAssetsWeights": @[  ], @"maximumPortfolioExposure": @"", @"minimumAssetsWeights": @[  ], @"minimumPortfolioExposure": @"" } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/portfolio/optimization/minimum-variance/diversified"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/portfolio/optimization/minimum-variance/diversified" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"deltaReturn\": \"\",\n    \"deltaVolatility\": \"\",\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/portfolio/optimization/minimum-variance/diversified",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'assets' => 0,
    'assetsCovarianceMatrix' => [
        
    ],
    'assetsReturns' => [
        
    ],
    'constraints' => [
        'assetsGroups' => [
                
        ],
        'assetsGroupsMatrix' => [
                
        ],
        'deltaReturn' => '',
        'deltaVolatility' => '',
        'maximumAssetsGroupsWeights' => [
                
        ],
        'maximumAssetsWeights' => [
                
        ],
        'maximumPortfolioExposure' => '',
        'minimumAssetsWeights' => [
                
        ],
        'minimumPortfolioExposure' => ''
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/portfolio/optimization/minimum-variance/diversified', [
  'body' => '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "deltaReturn": "",
    "deltaVolatility": "",
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/portfolio/optimization/minimum-variance/diversified');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'assets' => 0,
  'assetsCovarianceMatrix' => [
    
  ],
  'assetsReturns' => [
    
  ],
  'constraints' => [
    'assetsGroups' => [
        
    ],
    'assetsGroupsMatrix' => [
        
    ],
    'deltaReturn' => '',
    'deltaVolatility' => '',
    'maximumAssetsGroupsWeights' => [
        
    ],
    'maximumAssetsWeights' => [
        
    ],
    'maximumPortfolioExposure' => '',
    'minimumAssetsWeights' => [
        
    ],
    'minimumPortfolioExposure' => ''
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'assets' => 0,
  'assetsCovarianceMatrix' => [
    
  ],
  'assetsReturns' => [
    
  ],
  'constraints' => [
    'assetsGroups' => [
        
    ],
    'assetsGroupsMatrix' => [
        
    ],
    'deltaReturn' => '',
    'deltaVolatility' => '',
    'maximumAssetsGroupsWeights' => [
        
    ],
    'maximumAssetsWeights' => [
        
    ],
    'maximumPortfolioExposure' => '',
    'minimumAssetsWeights' => [
        
    ],
    'minimumPortfolioExposure' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/portfolio/optimization/minimum-variance/diversified');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/portfolio/optimization/minimum-variance/diversified' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "deltaReturn": "",
    "deltaVolatility": "",
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/portfolio/optimization/minimum-variance/diversified' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "deltaReturn": "",
    "deltaVolatility": "",
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  }
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"deltaReturn\": \"\",\n    \"deltaVolatility\": \"\",\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/portfolio/optimization/minimum-variance/diversified", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/portfolio/optimization/minimum-variance/diversified"

payload = {
    "assets": 0,
    "assetsCovarianceMatrix": [],
    "assetsReturns": [],
    "constraints": {
        "assetsGroups": [],
        "assetsGroupsMatrix": [],
        "deltaReturn": "",
        "deltaVolatility": "",
        "maximumAssetsGroupsWeights": [],
        "maximumAssetsWeights": [],
        "maximumPortfolioExposure": "",
        "minimumAssetsWeights": [],
        "minimumPortfolioExposure": ""
    }
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/portfolio/optimization/minimum-variance/diversified"

payload <- "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"deltaReturn\": \"\",\n    \"deltaVolatility\": \"\",\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/portfolio/optimization/minimum-variance/diversified")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"deltaReturn\": \"\",\n    \"deltaVolatility\": \"\",\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/portfolio/optimization/minimum-variance/diversified') do |req|
  req.body = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"deltaReturn\": \"\",\n    \"deltaVolatility\": \"\",\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/portfolio/optimization/minimum-variance/diversified";

    let payload = json!({
        "assets": 0,
        "assetsCovarianceMatrix": (),
        "assetsReturns": (),
        "constraints": json!({
            "assetsGroups": (),
            "assetsGroupsMatrix": (),
            "deltaReturn": "",
            "deltaVolatility": "",
            "maximumAssetsGroupsWeights": (),
            "maximumAssetsWeights": (),
            "maximumPortfolioExposure": "",
            "minimumAssetsWeights": (),
            "minimumPortfolioExposure": ""
        })
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/portfolio/optimization/minimum-variance/diversified \
  --header 'content-type: application/json' \
  --data '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "deltaReturn": "",
    "deltaVolatility": "",
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  }
}'

echo '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "deltaReturn": "",
    "deltaVolatility": "",
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  }
}' |  \
  http POST {{baseUrl}}/portfolio/optimization/minimum-variance/diversified \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "assets": 0,\n  "assetsCovarianceMatrix": [],\n  "assetsReturns": [],\n  "constraints": {\n    "assetsGroups": [],\n    "assetsGroupsMatrix": [],\n    "deltaReturn": "",\n    "deltaVolatility": "",\n    "maximumAssetsGroupsWeights": [],\n    "maximumAssetsWeights": [],\n    "maximumPortfolioExposure": "",\n    "minimumAssetsWeights": [],\n    "minimumPortfolioExposure": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/portfolio/optimization/minimum-variance/diversified

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": [
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "deltaReturn": "",
    "deltaVolatility": "",
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/portfolio/optimization/minimum-variance/diversified")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "assetsWeights": [
    0.31288809725799416,
    0.18711190967754268
  ]
}

POST Maximum Return Portfolio

{{baseUrl}}/portfolio/optimization/maximum-return

BODY json

{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  }
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/portfolio/optimization/maximum-return");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/portfolio/optimization/maximum-return" {:content-type :json
                                                                                  :form-params {:assets 0
                                                                                                :assetsCovarianceMatrix []
                                                                                                :assetsReturns []
                                                                                                :constraints {:assetsGroups []
                                                                                                              :assetsGroupsMatrix []
                                                                                                              :maximumAssetsGroupsWeights []
                                                                                                              :maximumAssetsWeights []
                                                                                                              :maximumPortfolioExposure ""
                                                                                                              :minimumAssetsWeights []
                                                                                                              :minimumPortfolioExposure ""}}})

require "http/client"

url = "{{baseUrl}}/portfolio/optimization/maximum-return"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/portfolio/optimization/maximum-return"),
    Content = new StringContent("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/portfolio/optimization/maximum-return");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/portfolio/optimization/maximum-return"

	payload := strings.NewReader("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/portfolio/optimization/maximum-return HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 323

{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/portfolio/optimization/maximum-return")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/portfolio/optimization/maximum-return"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/portfolio/optimization/maximum-return")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/portfolio/optimization/maximum-return")
  .header("content-type", "application/json")
  .body("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  assets: 0,
  assetsCovarianceMatrix: [],
  assetsReturns: [],
  constraints: {
    assetsGroups: [],
    assetsGroupsMatrix: [],
    maximumAssetsGroupsWeights: [],
    maximumAssetsWeights: [],
    maximumPortfolioExposure: '',
    minimumAssetsWeights: [],
    minimumPortfolioExposure: ''
  }
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/portfolio/optimization/maximum-return');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/optimization/maximum-return',
  headers: {'content-type': 'application/json'},
  data: {
    assets: 0,
    assetsCovarianceMatrix: [],
    assetsReturns: [],
    constraints: {
      assetsGroups: [],
      assetsGroupsMatrix: [],
      maximumAssetsGroupsWeights: [],
      maximumAssetsWeights: [],
      maximumPortfolioExposure: '',
      minimumAssetsWeights: [],
      minimumPortfolioExposure: ''
    }
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/portfolio/optimization/maximum-return';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":0,"assetsCovarianceMatrix":[],"assetsReturns":[],"constraints":{"assetsGroups":[],"assetsGroupsMatrix":[],"maximumAssetsGroupsWeights":[],"maximumAssetsWeights":[],"maximumPortfolioExposure":"","minimumAssetsWeights":[],"minimumPortfolioExposure":""}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/portfolio/optimization/maximum-return',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "assets": 0,\n  "assetsCovarianceMatrix": [],\n  "assetsReturns": [],\n  "constraints": {\n    "assetsGroups": [],\n    "assetsGroupsMatrix": [],\n    "maximumAssetsGroupsWeights": [],\n    "maximumAssetsWeights": [],\n    "maximumPortfolioExposure": "",\n    "minimumAssetsWeights": [],\n    "minimumPortfolioExposure": ""\n  }\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/portfolio/optimization/maximum-return")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/portfolio/optimization/maximum-return',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  assets: 0,
  assetsCovarianceMatrix: [],
  assetsReturns: [],
  constraints: {
    assetsGroups: [],
    assetsGroupsMatrix: [],
    maximumAssetsGroupsWeights: [],
    maximumAssetsWeights: [],
    maximumPortfolioExposure: '',
    minimumAssetsWeights: [],
    minimumPortfolioExposure: ''
  }
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/optimization/maximum-return',
  headers: {'content-type': 'application/json'},
  body: {
    assets: 0,
    assetsCovarianceMatrix: [],
    assetsReturns: [],
    constraints: {
      assetsGroups: [],
      assetsGroupsMatrix: [],
      maximumAssetsGroupsWeights: [],
      maximumAssetsWeights: [],
      maximumPortfolioExposure: '',
      minimumAssetsWeights: [],
      minimumPortfolioExposure: ''
    }
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/portfolio/optimization/maximum-return');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  assets: 0,
  assetsCovarianceMatrix: [],
  assetsReturns: [],
  constraints: {
    assetsGroups: [],
    assetsGroupsMatrix: [],
    maximumAssetsGroupsWeights: [],
    maximumAssetsWeights: [],
    maximumPortfolioExposure: '',
    minimumAssetsWeights: [],
    minimumPortfolioExposure: ''
  }
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/optimization/maximum-return',
  headers: {'content-type': 'application/json'},
  data: {
    assets: 0,
    assetsCovarianceMatrix: [],
    assetsReturns: [],
    constraints: {
      assetsGroups: [],
      assetsGroupsMatrix: [],
      maximumAssetsGroupsWeights: [],
      maximumAssetsWeights: [],
      maximumPortfolioExposure: '',
      minimumAssetsWeights: [],
      minimumPortfolioExposure: ''
    }
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/portfolio/optimization/maximum-return';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":0,"assetsCovarianceMatrix":[],"assetsReturns":[],"constraints":{"assetsGroups":[],"assetsGroupsMatrix":[],"maximumAssetsGroupsWeights":[],"maximumAssetsWeights":[],"maximumPortfolioExposure":"","minimumAssetsWeights":[],"minimumPortfolioExposure":""}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"assets": @0,
                              @"assetsCovarianceMatrix": @[  ],
                              @"assetsReturns": @[  ],
                              @"constraints": @{ @"assetsGroups": @[  ], @"assetsGroupsMatrix": @[  ], @"maximumAssetsGroupsWeights": @[  ], @"maximumAssetsWeights": @[  ], @"maximumPortfolioExposure": @"", @"minimumAssetsWeights": @[  ], @"minimumPortfolioExposure": @"" } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/portfolio/optimization/maximum-return"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/portfolio/optimization/maximum-return" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/portfolio/optimization/maximum-return",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'assets' => 0,
    'assetsCovarianceMatrix' => [
        
    ],
    'assetsReturns' => [
        
    ],
    'constraints' => [
        'assetsGroups' => [
                
        ],
        'assetsGroupsMatrix' => [
                
        ],
        'maximumAssetsGroupsWeights' => [
                
        ],
        'maximumAssetsWeights' => [
                
        ],
        'maximumPortfolioExposure' => '',
        'minimumAssetsWeights' => [
                
        ],
        'minimumPortfolioExposure' => ''
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/portfolio/optimization/maximum-return', [
  'body' => '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/portfolio/optimization/maximum-return');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'assets' => 0,
  'assetsCovarianceMatrix' => [
    
  ],
  'assetsReturns' => [
    
  ],
  'constraints' => [
    'assetsGroups' => [
        
    ],
    'assetsGroupsMatrix' => [
        
    ],
    'maximumAssetsGroupsWeights' => [
        
    ],
    'maximumAssetsWeights' => [
        
    ],
    'maximumPortfolioExposure' => '',
    'minimumAssetsWeights' => [
        
    ],
    'minimumPortfolioExposure' => ''
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'assets' => 0,
  'assetsCovarianceMatrix' => [
    
  ],
  'assetsReturns' => [
    
  ],
  'constraints' => [
    'assetsGroups' => [
        
    ],
    'assetsGroupsMatrix' => [
        
    ],
    'maximumAssetsGroupsWeights' => [
        
    ],
    'maximumAssetsWeights' => [
        
    ],
    'maximumPortfolioExposure' => '',
    'minimumAssetsWeights' => [
        
    ],
    'minimumPortfolioExposure' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/portfolio/optimization/maximum-return');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/portfolio/optimization/maximum-return' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/portfolio/optimization/maximum-return' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  }
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/portfolio/optimization/maximum-return", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/portfolio/optimization/maximum-return"

payload = {
    "assets": 0,
    "assetsCovarianceMatrix": [],
    "assetsReturns": [],
    "constraints": {
        "assetsGroups": [],
        "assetsGroupsMatrix": [],
        "maximumAssetsGroupsWeights": [],
        "maximumAssetsWeights": [],
        "maximumPortfolioExposure": "",
        "minimumAssetsWeights": [],
        "minimumPortfolioExposure": ""
    }
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/portfolio/optimization/maximum-return"

payload <- "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/portfolio/optimization/maximum-return")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/portfolio/optimization/maximum-return') do |req|
  req.body = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/portfolio/optimization/maximum-return";

    let payload = json!({
        "assets": 0,
        "assetsCovarianceMatrix": (),
        "assetsReturns": (),
        "constraints": json!({
            "assetsGroups": (),
            "assetsGroupsMatrix": (),
            "maximumAssetsGroupsWeights": (),
            "maximumAssetsWeights": (),
            "maximumPortfolioExposure": "",
            "minimumAssetsWeights": (),
            "minimumPortfolioExposure": ""
        })
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/portfolio/optimization/maximum-return \
  --header 'content-type: application/json' \
  --data '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  }
}'

echo '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  }
}' |  \
  http POST {{baseUrl}}/portfolio/optimization/maximum-return \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "assets": 0,\n  "assetsCovarianceMatrix": [],\n  "assetsReturns": [],\n  "constraints": {\n    "assetsGroups": [],\n    "assetsGroupsMatrix": [],\n    "maximumAssetsGroupsWeights": [],\n    "maximumAssetsWeights": [],\n    "maximumPortfolioExposure": "",\n    "minimumAssetsWeights": [],\n    "minimumPortfolioExposure": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/portfolio/optimization/maximum-return

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": [
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/portfolio/optimization/maximum-return")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "assetsWeights": [
    0.4,
    0.6
  ]
}

POST Maximum Sharpe Ratio Portfolio

{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio

BODY json

{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  },
  "riskFreeRate": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"riskFreeRate\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio" {:content-type :json
                                                                                        :form-params {:assets 0
                                                                                                      :assetsCovarianceMatrix []
                                                                                                      :assetsReturns []
                                                                                                      :constraints {:assetsGroups []
                                                                                                                    :assetsGroupsMatrix []
                                                                                                                    :maximumAssetsGroupsWeights []
                                                                                                                    :maximumAssetsWeights []
                                                                                                                    :maximumPortfolioExposure ""
                                                                                                                    :minimumAssetsWeights []
                                                                                                                    :minimumPortfolioExposure ""}
                                                                                                      :riskFreeRate ""}})

require "http/client"

url = "{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"riskFreeRate\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio"),
    Content = new StringContent("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"riskFreeRate\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"riskFreeRate\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio"

	payload := strings.NewReader("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"riskFreeRate\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/portfolio/optimization/maximum-sharpe-ratio HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 345

{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  },
  "riskFreeRate": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"riskFreeRate\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"riskFreeRate\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"riskFreeRate\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio")
  .header("content-type", "application/json")
  .body("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"riskFreeRate\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  assets: 0,
  assetsCovarianceMatrix: [],
  assetsReturns: [],
  constraints: {
    assetsGroups: [],
    assetsGroupsMatrix: [],
    maximumAssetsGroupsWeights: [],
    maximumAssetsWeights: [],
    maximumPortfolioExposure: '',
    minimumAssetsWeights: [],
    minimumPortfolioExposure: ''
  },
  riskFreeRate: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio',
  headers: {'content-type': 'application/json'},
  data: {
    assets: 0,
    assetsCovarianceMatrix: [],
    assetsReturns: [],
    constraints: {
      assetsGroups: [],
      assetsGroupsMatrix: [],
      maximumAssetsGroupsWeights: [],
      maximumAssetsWeights: [],
      maximumPortfolioExposure: '',
      minimumAssetsWeights: [],
      minimumPortfolioExposure: ''
    },
    riskFreeRate: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":0,"assetsCovarianceMatrix":[],"assetsReturns":[],"constraints":{"assetsGroups":[],"assetsGroupsMatrix":[],"maximumAssetsGroupsWeights":[],"maximumAssetsWeights":[],"maximumPortfolioExposure":"","minimumAssetsWeights":[],"minimumPortfolioExposure":""},"riskFreeRate":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "assets": 0,\n  "assetsCovarianceMatrix": [],\n  "assetsReturns": [],\n  "constraints": {\n    "assetsGroups": [],\n    "assetsGroupsMatrix": [],\n    "maximumAssetsGroupsWeights": [],\n    "maximumAssetsWeights": [],\n    "maximumPortfolioExposure": "",\n    "minimumAssetsWeights": [],\n    "minimumPortfolioExposure": ""\n  },\n  "riskFreeRate": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"riskFreeRate\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/portfolio/optimization/maximum-sharpe-ratio',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  assets: 0,
  assetsCovarianceMatrix: [],
  assetsReturns: [],
  constraints: {
    assetsGroups: [],
    assetsGroupsMatrix: [],
    maximumAssetsGroupsWeights: [],
    maximumAssetsWeights: [],
    maximumPortfolioExposure: '',
    minimumAssetsWeights: [],
    minimumPortfolioExposure: ''
  },
  riskFreeRate: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio',
  headers: {'content-type': 'application/json'},
  body: {
    assets: 0,
    assetsCovarianceMatrix: [],
    assetsReturns: [],
    constraints: {
      assetsGroups: [],
      assetsGroupsMatrix: [],
      maximumAssetsGroupsWeights: [],
      maximumAssetsWeights: [],
      maximumPortfolioExposure: '',
      minimumAssetsWeights: [],
      minimumPortfolioExposure: ''
    },
    riskFreeRate: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  assets: 0,
  assetsCovarianceMatrix: [],
  assetsReturns: [],
  constraints: {
    assetsGroups: [],
    assetsGroupsMatrix: [],
    maximumAssetsGroupsWeights: [],
    maximumAssetsWeights: [],
    maximumPortfolioExposure: '',
    minimumAssetsWeights: [],
    minimumPortfolioExposure: ''
  },
  riskFreeRate: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio',
  headers: {'content-type': 'application/json'},
  data: {
    assets: 0,
    assetsCovarianceMatrix: [],
    assetsReturns: [],
    constraints: {
      assetsGroups: [],
      assetsGroupsMatrix: [],
      maximumAssetsGroupsWeights: [],
      maximumAssetsWeights: [],
      maximumPortfolioExposure: '',
      minimumAssetsWeights: [],
      minimumPortfolioExposure: ''
    },
    riskFreeRate: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":0,"assetsCovarianceMatrix":[],"assetsReturns":[],"constraints":{"assetsGroups":[],"assetsGroupsMatrix":[],"maximumAssetsGroupsWeights":[],"maximumAssetsWeights":[],"maximumPortfolioExposure":"","minimumAssetsWeights":[],"minimumPortfolioExposure":""},"riskFreeRate":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"assets": @0,
                              @"assetsCovarianceMatrix": @[  ],
                              @"assetsReturns": @[  ],
                              @"constraints": @{ @"assetsGroups": @[  ], @"assetsGroupsMatrix": @[  ], @"maximumAssetsGroupsWeights": @[  ], @"maximumAssetsWeights": @[  ], @"maximumPortfolioExposure": @"", @"minimumAssetsWeights": @[  ], @"minimumPortfolioExposure": @"" },
                              @"riskFreeRate": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"riskFreeRate\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'assets' => 0,
    'assetsCovarianceMatrix' => [
        
    ],
    'assetsReturns' => [
        
    ],
    'constraints' => [
        'assetsGroups' => [
                
        ],
        'assetsGroupsMatrix' => [
                
        ],
        'maximumAssetsGroupsWeights' => [
                
        ],
        'maximumAssetsWeights' => [
                
        ],
        'maximumPortfolioExposure' => '',
        'minimumAssetsWeights' => [
                
        ],
        'minimumPortfolioExposure' => ''
    ],
    'riskFreeRate' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio', [
  'body' => '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  },
  "riskFreeRate": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'assets' => 0,
  'assetsCovarianceMatrix' => [
    
  ],
  'assetsReturns' => [
    
  ],
  'constraints' => [
    'assetsGroups' => [
        
    ],
    'assetsGroupsMatrix' => [
        
    ],
    'maximumAssetsGroupsWeights' => [
        
    ],
    'maximumAssetsWeights' => [
        
    ],
    'maximumPortfolioExposure' => '',
    'minimumAssetsWeights' => [
        
    ],
    'minimumPortfolioExposure' => ''
  ],
  'riskFreeRate' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'assets' => 0,
  'assetsCovarianceMatrix' => [
    
  ],
  'assetsReturns' => [
    
  ],
  'constraints' => [
    'assetsGroups' => [
        
    ],
    'assetsGroupsMatrix' => [
        
    ],
    'maximumAssetsGroupsWeights' => [
        
    ],
    'maximumAssetsWeights' => [
        
    ],
    'maximumPortfolioExposure' => '',
    'minimumAssetsWeights' => [
        
    ],
    'minimumPortfolioExposure' => ''
  ],
  'riskFreeRate' => ''
]));
$request->setRequestUrl('{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  },
  "riskFreeRate": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  },
  "riskFreeRate": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"riskFreeRate\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/portfolio/optimization/maximum-sharpe-ratio", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio"

payload = {
    "assets": 0,
    "assetsCovarianceMatrix": [],
    "assetsReturns": [],
    "constraints": {
        "assetsGroups": [],
        "assetsGroupsMatrix": [],
        "maximumAssetsGroupsWeights": [],
        "maximumAssetsWeights": [],
        "maximumPortfolioExposure": "",
        "minimumAssetsWeights": [],
        "minimumPortfolioExposure": ""
    },
    "riskFreeRate": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio"

payload <- "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"riskFreeRate\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"riskFreeRate\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/portfolio/optimization/maximum-sharpe-ratio') do |req|
  req.body = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"riskFreeRate\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio";

    let payload = json!({
        "assets": 0,
        "assetsCovarianceMatrix": (),
        "assetsReturns": (),
        "constraints": json!({
            "assetsGroups": (),
            "assetsGroupsMatrix": (),
            "maximumAssetsGroupsWeights": (),
            "maximumAssetsWeights": (),
            "maximumPortfolioExposure": "",
            "minimumAssetsWeights": (),
            "minimumPortfolioExposure": ""
        }),
        "riskFreeRate": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio \
  --header 'content-type: application/json' \
  --data '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  },
  "riskFreeRate": ""
}'

echo '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  },
  "riskFreeRate": ""
}' |  \
  http POST {{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "assets": 0,\n  "assetsCovarianceMatrix": [],\n  "assetsReturns": [],\n  "constraints": {\n    "assetsGroups": [],\n    "assetsGroupsMatrix": [],\n    "maximumAssetsGroupsWeights": [],\n    "maximumAssetsWeights": [],\n    "maximumPortfolioExposure": "",\n    "minimumAssetsWeights": [],\n    "minimumPortfolioExposure": ""\n  },\n  "riskFreeRate": ""\n}' \
  --output-document \
  - {{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": [
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  ],
  "riskFreeRate": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "assetsWeights": [
    0.27272727272727276,
    0.7272727272727273
  ]
}

POST Mean-Variance Efficient Portfolio

{{baseUrl}}/portfolio/optimization/mean-variance-efficient

BODY json

{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": "",
    "portfolioReturn": "",
    "portfolioVolatility": "",
    "riskTolerance": ""
  }
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/portfolio/optimization/mean-variance-efficient");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\",\n    \"portfolioReturn\": \"\",\n    \"portfolioVolatility\": \"\",\n    \"riskTolerance\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/portfolio/optimization/mean-variance-efficient" {:content-type :json
                                                                                           :form-params {:assets 0
                                                                                                         :assetsCovarianceMatrix []
                                                                                                         :assetsReturns []
                                                                                                         :constraints {:assetsGroups []
                                                                                                                       :assetsGroupsMatrix []
                                                                                                                       :maximumAssetsGroupsWeights []
                                                                                                                       :maximumAssetsWeights []
                                                                                                                       :maximumPortfolioExposure ""
                                                                                                                       :minimumAssetsWeights []
                                                                                                                       :minimumPortfolioExposure ""
                                                                                                                       :portfolioReturn ""
                                                                                                                       :portfolioVolatility ""
                                                                                                                       :riskTolerance ""}}})

require "http/client"

url = "{{baseUrl}}/portfolio/optimization/mean-variance-efficient"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\",\n    \"portfolioReturn\": \"\",\n    \"portfolioVolatility\": \"\",\n    \"riskTolerance\": \"\"\n  }\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/portfolio/optimization/mean-variance-efficient"),
    Content = new StringContent("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\",\n    \"portfolioReturn\": \"\",\n    \"portfolioVolatility\": \"\",\n    \"riskTolerance\": \"\"\n  }\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/portfolio/optimization/mean-variance-efficient");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\",\n    \"portfolioReturn\": \"\",\n    \"portfolioVolatility\": \"\",\n    \"riskTolerance\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/portfolio/optimization/mean-variance-efficient"

	payload := strings.NewReader("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\",\n    \"portfolioReturn\": \"\",\n    \"portfolioVolatility\": \"\",\n    \"riskTolerance\": \"\"\n  }\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/portfolio/optimization/mean-variance-efficient HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 406

{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": "",
    "portfolioReturn": "",
    "portfolioVolatility": "",
    "riskTolerance": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/portfolio/optimization/mean-variance-efficient")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\",\n    \"portfolioReturn\": \"\",\n    \"portfolioVolatility\": \"\",\n    \"riskTolerance\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/portfolio/optimization/mean-variance-efficient"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\",\n    \"portfolioReturn\": \"\",\n    \"portfolioVolatility\": \"\",\n    \"riskTolerance\": \"\"\n  }\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\",\n    \"portfolioReturn\": \"\",\n    \"portfolioVolatility\": \"\",\n    \"riskTolerance\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/portfolio/optimization/mean-variance-efficient")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/portfolio/optimization/mean-variance-efficient")
  .header("content-type", "application/json")
  .body("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\",\n    \"portfolioReturn\": \"\",\n    \"portfolioVolatility\": \"\",\n    \"riskTolerance\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  assets: 0,
  assetsCovarianceMatrix: [],
  assetsReturns: [],
  constraints: {
    assetsGroups: [],
    assetsGroupsMatrix: [],
    maximumAssetsGroupsWeights: [],
    maximumAssetsWeights: [],
    maximumPortfolioExposure: '',
    minimumAssetsWeights: [],
    minimumPortfolioExposure: '',
    portfolioReturn: '',
    portfolioVolatility: '',
    riskTolerance: ''
  }
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/portfolio/optimization/mean-variance-efficient');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/optimization/mean-variance-efficient',
  headers: {'content-type': 'application/json'},
  data: {
    assets: 0,
    assetsCovarianceMatrix: [],
    assetsReturns: [],
    constraints: {
      assetsGroups: [],
      assetsGroupsMatrix: [],
      maximumAssetsGroupsWeights: [],
      maximumAssetsWeights: [],
      maximumPortfolioExposure: '',
      minimumAssetsWeights: [],
      minimumPortfolioExposure: '',
      portfolioReturn: '',
      portfolioVolatility: '',
      riskTolerance: ''
    }
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/portfolio/optimization/mean-variance-efficient';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":0,"assetsCovarianceMatrix":[],"assetsReturns":[],"constraints":{"assetsGroups":[],"assetsGroupsMatrix":[],"maximumAssetsGroupsWeights":[],"maximumAssetsWeights":[],"maximumPortfolioExposure":"","minimumAssetsWeights":[],"minimumPortfolioExposure":"","portfolioReturn":"","portfolioVolatility":"","riskTolerance":""}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/portfolio/optimization/mean-variance-efficient',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "assets": 0,\n  "assetsCovarianceMatrix": [],\n  "assetsReturns": [],\n  "constraints": {\n    "assetsGroups": [],\n    "assetsGroupsMatrix": [],\n    "maximumAssetsGroupsWeights": [],\n    "maximumAssetsWeights": [],\n    "maximumPortfolioExposure": "",\n    "minimumAssetsWeights": [],\n    "minimumPortfolioExposure": "",\n    "portfolioReturn": "",\n    "portfolioVolatility": "",\n    "riskTolerance": ""\n  }\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\",\n    \"portfolioReturn\": \"\",\n    \"portfolioVolatility\": \"\",\n    \"riskTolerance\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/portfolio/optimization/mean-variance-efficient")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/portfolio/optimization/mean-variance-efficient',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  assets: 0,
  assetsCovarianceMatrix: [],
  assetsReturns: [],
  constraints: {
    assetsGroups: [],
    assetsGroupsMatrix: [],
    maximumAssetsGroupsWeights: [],
    maximumAssetsWeights: [],
    maximumPortfolioExposure: '',
    minimumAssetsWeights: [],
    minimumPortfolioExposure: '',
    portfolioReturn: '',
    portfolioVolatility: '',
    riskTolerance: ''
  }
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/optimization/mean-variance-efficient',
  headers: {'content-type': 'application/json'},
  body: {
    assets: 0,
    assetsCovarianceMatrix: [],
    assetsReturns: [],
    constraints: {
      assetsGroups: [],
      assetsGroupsMatrix: [],
      maximumAssetsGroupsWeights: [],
      maximumAssetsWeights: [],
      maximumPortfolioExposure: '',
      minimumAssetsWeights: [],
      minimumPortfolioExposure: '',
      portfolioReturn: '',
      portfolioVolatility: '',
      riskTolerance: ''
    }
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/portfolio/optimization/mean-variance-efficient');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  assets: 0,
  assetsCovarianceMatrix: [],
  assetsReturns: [],
  constraints: {
    assetsGroups: [],
    assetsGroupsMatrix: [],
    maximumAssetsGroupsWeights: [],
    maximumAssetsWeights: [],
    maximumPortfolioExposure: '',
    minimumAssetsWeights: [],
    minimumPortfolioExposure: '',
    portfolioReturn: '',
    portfolioVolatility: '',
    riskTolerance: ''
  }
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/optimization/mean-variance-efficient',
  headers: {'content-type': 'application/json'},
  data: {
    assets: 0,
    assetsCovarianceMatrix: [],
    assetsReturns: [],
    constraints: {
      assetsGroups: [],
      assetsGroupsMatrix: [],
      maximumAssetsGroupsWeights: [],
      maximumAssetsWeights: [],
      maximumPortfolioExposure: '',
      minimumAssetsWeights: [],
      minimumPortfolioExposure: '',
      portfolioReturn: '',
      portfolioVolatility: '',
      riskTolerance: ''
    }
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/portfolio/optimization/mean-variance-efficient';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":0,"assetsCovarianceMatrix":[],"assetsReturns":[],"constraints":{"assetsGroups":[],"assetsGroupsMatrix":[],"maximumAssetsGroupsWeights":[],"maximumAssetsWeights":[],"maximumPortfolioExposure":"","minimumAssetsWeights":[],"minimumPortfolioExposure":"","portfolioReturn":"","portfolioVolatility":"","riskTolerance":""}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"assets": @0,
                              @"assetsCovarianceMatrix": @[  ],
                              @"assetsReturns": @[  ],
                              @"constraints": @{ @"assetsGroups": @[  ], @"assetsGroupsMatrix": @[  ], @"maximumAssetsGroupsWeights": @[  ], @"maximumAssetsWeights": @[  ], @"maximumPortfolioExposure": @"", @"minimumAssetsWeights": @[  ], @"minimumPortfolioExposure": @"", @"portfolioReturn": @"", @"portfolioVolatility": @"", @"riskTolerance": @"" } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/portfolio/optimization/mean-variance-efficient"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/portfolio/optimization/mean-variance-efficient" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\",\n    \"portfolioReturn\": \"\",\n    \"portfolioVolatility\": \"\",\n    \"riskTolerance\": \"\"\n  }\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/portfolio/optimization/mean-variance-efficient",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'assets' => 0,
    'assetsCovarianceMatrix' => [
        
    ],
    'assetsReturns' => [
        
    ],
    'constraints' => [
        'assetsGroups' => [
                
        ],
        'assetsGroupsMatrix' => [
                
        ],
        'maximumAssetsGroupsWeights' => [
                
        ],
        'maximumAssetsWeights' => [
                
        ],
        'maximumPortfolioExposure' => '',
        'minimumAssetsWeights' => [
                
        ],
        'minimumPortfolioExposure' => '',
        'portfolioReturn' => '',
        'portfolioVolatility' => '',
        'riskTolerance' => ''
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/portfolio/optimization/mean-variance-efficient', [
  'body' => '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": "",
    "portfolioReturn": "",
    "portfolioVolatility": "",
    "riskTolerance": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/portfolio/optimization/mean-variance-efficient');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'assets' => 0,
  'assetsCovarianceMatrix' => [
    
  ],
  'assetsReturns' => [
    
  ],
  'constraints' => [
    'assetsGroups' => [
        
    ],
    'assetsGroupsMatrix' => [
        
    ],
    'maximumAssetsGroupsWeights' => [
        
    ],
    'maximumAssetsWeights' => [
        
    ],
    'maximumPortfolioExposure' => '',
    'minimumAssetsWeights' => [
        
    ],
    'minimumPortfolioExposure' => '',
    'portfolioReturn' => '',
    'portfolioVolatility' => '',
    'riskTolerance' => ''
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'assets' => 0,
  'assetsCovarianceMatrix' => [
    
  ],
  'assetsReturns' => [
    
  ],
  'constraints' => [
    'assetsGroups' => [
        
    ],
    'assetsGroupsMatrix' => [
        
    ],
    'maximumAssetsGroupsWeights' => [
        
    ],
    'maximumAssetsWeights' => [
        
    ],
    'maximumPortfolioExposure' => '',
    'minimumAssetsWeights' => [
        
    ],
    'minimumPortfolioExposure' => '',
    'portfolioReturn' => '',
    'portfolioVolatility' => '',
    'riskTolerance' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/portfolio/optimization/mean-variance-efficient');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/portfolio/optimization/mean-variance-efficient' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": "",
    "portfolioReturn": "",
    "portfolioVolatility": "",
    "riskTolerance": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/portfolio/optimization/mean-variance-efficient' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": "",
    "portfolioReturn": "",
    "portfolioVolatility": "",
    "riskTolerance": ""
  }
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\",\n    \"portfolioReturn\": \"\",\n    \"portfolioVolatility\": \"\",\n    \"riskTolerance\": \"\"\n  }\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/portfolio/optimization/mean-variance-efficient", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/portfolio/optimization/mean-variance-efficient"

payload = {
    "assets": 0,
    "assetsCovarianceMatrix": [],
    "assetsReturns": [],
    "constraints": {
        "assetsGroups": [],
        "assetsGroupsMatrix": [],
        "maximumAssetsGroupsWeights": [],
        "maximumAssetsWeights": [],
        "maximumPortfolioExposure": "",
        "minimumAssetsWeights": [],
        "minimumPortfolioExposure": "",
        "portfolioReturn": "",
        "portfolioVolatility": "",
        "riskTolerance": ""
    }
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/portfolio/optimization/mean-variance-efficient"

payload <- "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\",\n    \"portfolioReturn\": \"\",\n    \"portfolioVolatility\": \"\",\n    \"riskTolerance\": \"\"\n  }\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/portfolio/optimization/mean-variance-efficient")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\",\n    \"portfolioReturn\": \"\",\n    \"portfolioVolatility\": \"\",\n    \"riskTolerance\": \"\"\n  }\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/portfolio/optimization/mean-variance-efficient') do |req|
  req.body = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\",\n    \"portfolioReturn\": \"\",\n    \"portfolioVolatility\": \"\",\n    \"riskTolerance\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/portfolio/optimization/mean-variance-efficient";

    let payload = json!({
        "assets": 0,
        "assetsCovarianceMatrix": (),
        "assetsReturns": (),
        "constraints": json!({
            "assetsGroups": (),
            "assetsGroupsMatrix": (),
            "maximumAssetsGroupsWeights": (),
            "maximumAssetsWeights": (),
            "maximumPortfolioExposure": "",
            "minimumAssetsWeights": (),
            "minimumPortfolioExposure": "",
            "portfolioReturn": "",
            "portfolioVolatility": "",
            "riskTolerance": ""
        })
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/portfolio/optimization/mean-variance-efficient \
  --header 'content-type: application/json' \
  --data '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": "",
    "portfolioReturn": "",
    "portfolioVolatility": "",
    "riskTolerance": ""
  }
}'

echo '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": "",
    "portfolioReturn": "",
    "portfolioVolatility": "",
    "riskTolerance": ""
  }
}' |  \
  http POST {{baseUrl}}/portfolio/optimization/mean-variance-efficient \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "assets": 0,\n  "assetsCovarianceMatrix": [],\n  "assetsReturns": [],\n  "constraints": {\n    "assetsGroups": [],\n    "assetsGroupsMatrix": [],\n    "maximumAssetsGroupsWeights": [],\n    "maximumAssetsWeights": [],\n    "maximumPortfolioExposure": "",\n    "minimumAssetsWeights": [],\n    "minimumPortfolioExposure": "",\n    "portfolioReturn": "",\n    "portfolioVolatility": "",\n    "riskTolerance": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/portfolio/optimization/mean-variance-efficient

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": [
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": "",
    "portfolioReturn": "",
    "portfolioVolatility": "",
    "riskTolerance": ""
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/portfolio/optimization/mean-variance-efficient")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "assetsWeights": [
    0.5,
    0.5
  ]
}

POST Minimum Variance Portfolio

{{baseUrl}}/portfolio/optimization/minimum-variance

BODY json

{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  }
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/portfolio/optimization/minimum-variance");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/portfolio/optimization/minimum-variance" {:content-type :json
                                                                                    :form-params {:assets 0
                                                                                                  :assetsCovarianceMatrix []
                                                                                                  :assetsReturns []
                                                                                                  :constraints {:assetsGroups []
                                                                                                                :assetsGroupsMatrix []
                                                                                                                :maximumAssetsGroupsWeights []
                                                                                                                :maximumAssetsWeights []
                                                                                                                :maximumPortfolioExposure ""
                                                                                                                :minimumAssetsWeights []
                                                                                                                :minimumPortfolioExposure ""}}})

require "http/client"

url = "{{baseUrl}}/portfolio/optimization/minimum-variance"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/portfolio/optimization/minimum-variance"),
    Content = new StringContent("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/portfolio/optimization/minimum-variance");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/portfolio/optimization/minimum-variance"

	payload := strings.NewReader("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/portfolio/optimization/minimum-variance HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 323

{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/portfolio/optimization/minimum-variance")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/portfolio/optimization/minimum-variance"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/portfolio/optimization/minimum-variance")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/portfolio/optimization/minimum-variance")
  .header("content-type", "application/json")
  .body("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  assets: 0,
  assetsCovarianceMatrix: [],
  assetsReturns: [],
  constraints: {
    assetsGroups: [],
    assetsGroupsMatrix: [],
    maximumAssetsGroupsWeights: [],
    maximumAssetsWeights: [],
    maximumPortfolioExposure: '',
    minimumAssetsWeights: [],
    minimumPortfolioExposure: ''
  }
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/portfolio/optimization/minimum-variance');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/optimization/minimum-variance',
  headers: {'content-type': 'application/json'},
  data: {
    assets: 0,
    assetsCovarianceMatrix: [],
    assetsReturns: [],
    constraints: {
      assetsGroups: [],
      assetsGroupsMatrix: [],
      maximumAssetsGroupsWeights: [],
      maximumAssetsWeights: [],
      maximumPortfolioExposure: '',
      minimumAssetsWeights: [],
      minimumPortfolioExposure: ''
    }
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/portfolio/optimization/minimum-variance';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":0,"assetsCovarianceMatrix":[],"assetsReturns":[],"constraints":{"assetsGroups":[],"assetsGroupsMatrix":[],"maximumAssetsGroupsWeights":[],"maximumAssetsWeights":[],"maximumPortfolioExposure":"","minimumAssetsWeights":[],"minimumPortfolioExposure":""}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/portfolio/optimization/minimum-variance',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "assets": 0,\n  "assetsCovarianceMatrix": [],\n  "assetsReturns": [],\n  "constraints": {\n    "assetsGroups": [],\n    "assetsGroupsMatrix": [],\n    "maximumAssetsGroupsWeights": [],\n    "maximumAssetsWeights": [],\n    "maximumPortfolioExposure": "",\n    "minimumAssetsWeights": [],\n    "minimumPortfolioExposure": ""\n  }\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/portfolio/optimization/minimum-variance")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/portfolio/optimization/minimum-variance',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  assets: 0,
  assetsCovarianceMatrix: [],
  assetsReturns: [],
  constraints: {
    assetsGroups: [],
    assetsGroupsMatrix: [],
    maximumAssetsGroupsWeights: [],
    maximumAssetsWeights: [],
    maximumPortfolioExposure: '',
    minimumAssetsWeights: [],
    minimumPortfolioExposure: ''
  }
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/optimization/minimum-variance',
  headers: {'content-type': 'application/json'},
  body: {
    assets: 0,
    assetsCovarianceMatrix: [],
    assetsReturns: [],
    constraints: {
      assetsGroups: [],
      assetsGroupsMatrix: [],
      maximumAssetsGroupsWeights: [],
      maximumAssetsWeights: [],
      maximumPortfolioExposure: '',
      minimumAssetsWeights: [],
      minimumPortfolioExposure: ''
    }
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/portfolio/optimization/minimum-variance');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  assets: 0,
  assetsCovarianceMatrix: [],
  assetsReturns: [],
  constraints: {
    assetsGroups: [],
    assetsGroupsMatrix: [],
    maximumAssetsGroupsWeights: [],
    maximumAssetsWeights: [],
    maximumPortfolioExposure: '',
    minimumAssetsWeights: [],
    minimumPortfolioExposure: ''
  }
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/optimization/minimum-variance',
  headers: {'content-type': 'application/json'},
  data: {
    assets: 0,
    assetsCovarianceMatrix: [],
    assetsReturns: [],
    constraints: {
      assetsGroups: [],
      assetsGroupsMatrix: [],
      maximumAssetsGroupsWeights: [],
      maximumAssetsWeights: [],
      maximumPortfolioExposure: '',
      minimumAssetsWeights: [],
      minimumPortfolioExposure: ''
    }
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/portfolio/optimization/minimum-variance';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":0,"assetsCovarianceMatrix":[],"assetsReturns":[],"constraints":{"assetsGroups":[],"assetsGroupsMatrix":[],"maximumAssetsGroupsWeights":[],"maximumAssetsWeights":[],"maximumPortfolioExposure":"","minimumAssetsWeights":[],"minimumPortfolioExposure":""}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"assets": @0,
                              @"assetsCovarianceMatrix": @[  ],
                              @"assetsReturns": @[  ],
                              @"constraints": @{ @"assetsGroups": @[  ], @"assetsGroupsMatrix": @[  ], @"maximumAssetsGroupsWeights": @[  ], @"maximumAssetsWeights": @[  ], @"maximumPortfolioExposure": @"", @"minimumAssetsWeights": @[  ], @"minimumPortfolioExposure": @"" } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/portfolio/optimization/minimum-variance"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/portfolio/optimization/minimum-variance" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/portfolio/optimization/minimum-variance",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'assets' => 0,
    'assetsCovarianceMatrix' => [
        
    ],
    'assetsReturns' => [
        
    ],
    'constraints' => [
        'assetsGroups' => [
                
        ],
        'assetsGroupsMatrix' => [
                
        ],
        'maximumAssetsGroupsWeights' => [
                
        ],
        'maximumAssetsWeights' => [
                
        ],
        'maximumPortfolioExposure' => '',
        'minimumAssetsWeights' => [
                
        ],
        'minimumPortfolioExposure' => ''
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/portfolio/optimization/minimum-variance', [
  'body' => '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/portfolio/optimization/minimum-variance');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'assets' => 0,
  'assetsCovarianceMatrix' => [
    
  ],
  'assetsReturns' => [
    
  ],
  'constraints' => [
    'assetsGroups' => [
        
    ],
    'assetsGroupsMatrix' => [
        
    ],
    'maximumAssetsGroupsWeights' => [
        
    ],
    'maximumAssetsWeights' => [
        
    ],
    'maximumPortfolioExposure' => '',
    'minimumAssetsWeights' => [
        
    ],
    'minimumPortfolioExposure' => ''
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'assets' => 0,
  'assetsCovarianceMatrix' => [
    
  ],
  'assetsReturns' => [
    
  ],
  'constraints' => [
    'assetsGroups' => [
        
    ],
    'assetsGroupsMatrix' => [
        
    ],
    'maximumAssetsGroupsWeights' => [
        
    ],
    'maximumAssetsWeights' => [
        
    ],
    'maximumPortfolioExposure' => '',
    'minimumAssetsWeights' => [
        
    ],
    'minimumPortfolioExposure' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/portfolio/optimization/minimum-variance');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/portfolio/optimization/minimum-variance' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/portfolio/optimization/minimum-variance' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  }
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/portfolio/optimization/minimum-variance", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/portfolio/optimization/minimum-variance"

payload = {
    "assets": 0,
    "assetsCovarianceMatrix": [],
    "assetsReturns": [],
    "constraints": {
        "assetsGroups": [],
        "assetsGroupsMatrix": [],
        "maximumAssetsGroupsWeights": [],
        "maximumAssetsWeights": [],
        "maximumPortfolioExposure": "",
        "minimumAssetsWeights": [],
        "minimumPortfolioExposure": ""
    }
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/portfolio/optimization/minimum-variance"

payload <- "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/portfolio/optimization/minimum-variance")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/portfolio/optimization/minimum-variance') do |req|
  req.body = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/portfolio/optimization/minimum-variance";

    let payload = json!({
        "assets": 0,
        "assetsCovarianceMatrix": (),
        "assetsReturns": (),
        "constraints": json!({
            "assetsGroups": (),
            "assetsGroupsMatrix": (),
            "maximumAssetsGroupsWeights": (),
            "maximumAssetsWeights": (),
            "maximumPortfolioExposure": "",
            "minimumAssetsWeights": (),
            "minimumPortfolioExposure": ""
        })
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/portfolio/optimization/minimum-variance \
  --header 'content-type: application/json' \
  --data '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  }
}'

echo '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  }
}' |  \
  http POST {{baseUrl}}/portfolio/optimization/minimum-variance \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "assets": 0,\n  "assetsCovarianceMatrix": [],\n  "assetsReturns": [],\n  "constraints": {\n    "assetsGroups": [],\n    "assetsGroupsMatrix": [],\n    "maximumAssetsGroupsWeights": [],\n    "maximumAssetsWeights": [],\n    "maximumPortfolioExposure": "",\n    "minimumAssetsWeights": [],\n    "minimumPortfolioExposure": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/portfolio/optimization/minimum-variance

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": [
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/portfolio/optimization/minimum-variance")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "assetsWeights": [
    0.4,
    0.09999999999998999
  ]
}

POST Subset Resampling-Based Maximum Return Portfolio

{{baseUrl}}/portfolio/optimization/maximum-return/subset-resampling-based

BODY json

{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  },
  "subsetPortfolios": 0,
  "subsetPortfoliosAggregationMethod": "",
  "subsetPortfoliosEnumerationMethod": "",
  "subsetSize": 0
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/portfolio/optimization/maximum-return/subset-resampling-based");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"subsetPortfolios\": 0,\n  \"subsetPortfoliosAggregationMethod\": \"\",\n  \"subsetPortfoliosEnumerationMethod\": \"\",\n  \"subsetSize\": 0\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/portfolio/optimization/maximum-return/subset-resampling-based" {:content-type :json
                                                                                                          :form-params {:assets 0
                                                                                                                        :assetsCovarianceMatrix []
                                                                                                                        :assetsReturns []
                                                                                                                        :constraints {:assetsGroups []
                                                                                                                                      :assetsGroupsMatrix []
                                                                                                                                      :maximumAssetsGroupsWeights []
                                                                                                                                      :maximumAssetsWeights []
                                                                                                                                      :maximumPortfolioExposure ""
                                                                                                                                      :minimumAssetsWeights []
                                                                                                                                      :minimumPortfolioExposure ""}
                                                                                                                        :subsetPortfolios 0
                                                                                                                        :subsetPortfoliosAggregationMethod ""
                                                                                                                        :subsetPortfoliosEnumerationMethod ""
                                                                                                                        :subsetSize 0}})

require "http/client"

url = "{{baseUrl}}/portfolio/optimization/maximum-return/subset-resampling-based"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"subsetPortfolios\": 0,\n  \"subsetPortfoliosAggregationMethod\": \"\",\n  \"subsetPortfoliosEnumerationMethod\": \"\",\n  \"subsetSize\": 0\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/portfolio/optimization/maximum-return/subset-resampling-based"),
    Content = new StringContent("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"subsetPortfolios\": 0,\n  \"subsetPortfoliosAggregationMethod\": \"\",\n  \"subsetPortfoliosEnumerationMethod\": \"\",\n  \"subsetSize\": 0\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/portfolio/optimization/maximum-return/subset-resampling-based");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"subsetPortfolios\": 0,\n  \"subsetPortfoliosAggregationMethod\": \"\",\n  \"subsetPortfoliosEnumerationMethod\": \"\",\n  \"subsetSize\": 0\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/portfolio/optimization/maximum-return/subset-resampling-based"

	payload := strings.NewReader("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"subsetPortfolios\": 0,\n  \"subsetPortfoliosAggregationMethod\": \"\",\n  \"subsetPortfoliosEnumerationMethod\": \"\",\n  \"subsetSize\": 0\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/portfolio/optimization/maximum-return/subset-resampling-based HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 453

{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  },
  "subsetPortfolios": 0,
  "subsetPortfoliosAggregationMethod": "",
  "subsetPortfoliosEnumerationMethod": "",
  "subsetSize": 0
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/portfolio/optimization/maximum-return/subset-resampling-based")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"subsetPortfolios\": 0,\n  \"subsetPortfoliosAggregationMethod\": \"\",\n  \"subsetPortfoliosEnumerationMethod\": \"\",\n  \"subsetSize\": 0\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/portfolio/optimization/maximum-return/subset-resampling-based"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"subsetPortfolios\": 0,\n  \"subsetPortfoliosAggregationMethod\": \"\",\n  \"subsetPortfoliosEnumerationMethod\": \"\",\n  \"subsetSize\": 0\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"subsetPortfolios\": 0,\n  \"subsetPortfoliosAggregationMethod\": \"\",\n  \"subsetPortfoliosEnumerationMethod\": \"\",\n  \"subsetSize\": 0\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/portfolio/optimization/maximum-return/subset-resampling-based")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/portfolio/optimization/maximum-return/subset-resampling-based")
  .header("content-type", "application/json")
  .body("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"subsetPortfolios\": 0,\n  \"subsetPortfoliosAggregationMethod\": \"\",\n  \"subsetPortfoliosEnumerationMethod\": \"\",\n  \"subsetSize\": 0\n}")
  .asString();

const data = JSON.stringify({
  assets: 0,
  assetsCovarianceMatrix: [],
  assetsReturns: [],
  constraints: {
    assetsGroups: [],
    assetsGroupsMatrix: [],
    maximumAssetsGroupsWeights: [],
    maximumAssetsWeights: [],
    maximumPortfolioExposure: '',
    minimumAssetsWeights: [],
    minimumPortfolioExposure: ''
  },
  subsetPortfolios: 0,
  subsetPortfoliosAggregationMethod: '',
  subsetPortfoliosEnumerationMethod: '',
  subsetSize: 0
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/portfolio/optimization/maximum-return/subset-resampling-based');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/optimization/maximum-return/subset-resampling-based',
  headers: {'content-type': 'application/json'},
  data: {
    assets: 0,
    assetsCovarianceMatrix: [],
    assetsReturns: [],
    constraints: {
      assetsGroups: [],
      assetsGroupsMatrix: [],
      maximumAssetsGroupsWeights: [],
      maximumAssetsWeights: [],
      maximumPortfolioExposure: '',
      minimumAssetsWeights: [],
      minimumPortfolioExposure: ''
    },
    subsetPortfolios: 0,
    subsetPortfoliosAggregationMethod: '',
    subsetPortfoliosEnumerationMethod: '',
    subsetSize: 0
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/portfolio/optimization/maximum-return/subset-resampling-based';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":0,"assetsCovarianceMatrix":[],"assetsReturns":[],"constraints":{"assetsGroups":[],"assetsGroupsMatrix":[],"maximumAssetsGroupsWeights":[],"maximumAssetsWeights":[],"maximumPortfolioExposure":"","minimumAssetsWeights":[],"minimumPortfolioExposure":""},"subsetPortfolios":0,"subsetPortfoliosAggregationMethod":"","subsetPortfoliosEnumerationMethod":"","subsetSize":0}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/portfolio/optimization/maximum-return/subset-resampling-based',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "assets": 0,\n  "assetsCovarianceMatrix": [],\n  "assetsReturns": [],\n  "constraints": {\n    "assetsGroups": [],\n    "assetsGroupsMatrix": [],\n    "maximumAssetsGroupsWeights": [],\n    "maximumAssetsWeights": [],\n    "maximumPortfolioExposure": "",\n    "minimumAssetsWeights": [],\n    "minimumPortfolioExposure": ""\n  },\n  "subsetPortfolios": 0,\n  "subsetPortfoliosAggregationMethod": "",\n  "subsetPortfoliosEnumerationMethod": "",\n  "subsetSize": 0\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"subsetPortfolios\": 0,\n  \"subsetPortfoliosAggregationMethod\": \"\",\n  \"subsetPortfoliosEnumerationMethod\": \"\",\n  \"subsetSize\": 0\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/portfolio/optimization/maximum-return/subset-resampling-based")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/portfolio/optimization/maximum-return/subset-resampling-based',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  assets: 0,
  assetsCovarianceMatrix: [],
  assetsReturns: [],
  constraints: {
    assetsGroups: [],
    assetsGroupsMatrix: [],
    maximumAssetsGroupsWeights: [],
    maximumAssetsWeights: [],
    maximumPortfolioExposure: '',
    minimumAssetsWeights: [],
    minimumPortfolioExposure: ''
  },
  subsetPortfolios: 0,
  subsetPortfoliosAggregationMethod: '',
  subsetPortfoliosEnumerationMethod: '',
  subsetSize: 0
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/optimization/maximum-return/subset-resampling-based',
  headers: {'content-type': 'application/json'},
  body: {
    assets: 0,
    assetsCovarianceMatrix: [],
    assetsReturns: [],
    constraints: {
      assetsGroups: [],
      assetsGroupsMatrix: [],
      maximumAssetsGroupsWeights: [],
      maximumAssetsWeights: [],
      maximumPortfolioExposure: '',
      minimumAssetsWeights: [],
      minimumPortfolioExposure: ''
    },
    subsetPortfolios: 0,
    subsetPortfoliosAggregationMethod: '',
    subsetPortfoliosEnumerationMethod: '',
    subsetSize: 0
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/portfolio/optimization/maximum-return/subset-resampling-based');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  assets: 0,
  assetsCovarianceMatrix: [],
  assetsReturns: [],
  constraints: {
    assetsGroups: [],
    assetsGroupsMatrix: [],
    maximumAssetsGroupsWeights: [],
    maximumAssetsWeights: [],
    maximumPortfolioExposure: '',
    minimumAssetsWeights: [],
    minimumPortfolioExposure: ''
  },
  subsetPortfolios: 0,
  subsetPortfoliosAggregationMethod: '',
  subsetPortfoliosEnumerationMethod: '',
  subsetSize: 0
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/optimization/maximum-return/subset-resampling-based',
  headers: {'content-type': 'application/json'},
  data: {
    assets: 0,
    assetsCovarianceMatrix: [],
    assetsReturns: [],
    constraints: {
      assetsGroups: [],
      assetsGroupsMatrix: [],
      maximumAssetsGroupsWeights: [],
      maximumAssetsWeights: [],
      maximumPortfolioExposure: '',
      minimumAssetsWeights: [],
      minimumPortfolioExposure: ''
    },
    subsetPortfolios: 0,
    subsetPortfoliosAggregationMethod: '',
    subsetPortfoliosEnumerationMethod: '',
    subsetSize: 0
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/portfolio/optimization/maximum-return/subset-resampling-based';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":0,"assetsCovarianceMatrix":[],"assetsReturns":[],"constraints":{"assetsGroups":[],"assetsGroupsMatrix":[],"maximumAssetsGroupsWeights":[],"maximumAssetsWeights":[],"maximumPortfolioExposure":"","minimumAssetsWeights":[],"minimumPortfolioExposure":""},"subsetPortfolios":0,"subsetPortfoliosAggregationMethod":"","subsetPortfoliosEnumerationMethod":"","subsetSize":0}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"assets": @0,
                              @"assetsCovarianceMatrix": @[  ],
                              @"assetsReturns": @[  ],
                              @"constraints": @{ @"assetsGroups": @[  ], @"assetsGroupsMatrix": @[  ], @"maximumAssetsGroupsWeights": @[  ], @"maximumAssetsWeights": @[  ], @"maximumPortfolioExposure": @"", @"minimumAssetsWeights": @[  ], @"minimumPortfolioExposure": @"" },
                              @"subsetPortfolios": @0,
                              @"subsetPortfoliosAggregationMethod": @"",
                              @"subsetPortfoliosEnumerationMethod": @"",
                              @"subsetSize": @0 };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/portfolio/optimization/maximum-return/subset-resampling-based"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/portfolio/optimization/maximum-return/subset-resampling-based" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"subsetPortfolios\": 0,\n  \"subsetPortfoliosAggregationMethod\": \"\",\n  \"subsetPortfoliosEnumerationMethod\": \"\",\n  \"subsetSize\": 0\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/portfolio/optimization/maximum-return/subset-resampling-based",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'assets' => 0,
    'assetsCovarianceMatrix' => [
        
    ],
    'assetsReturns' => [
        
    ],
    'constraints' => [
        'assetsGroups' => [
                
        ],
        'assetsGroupsMatrix' => [
                
        ],
        'maximumAssetsGroupsWeights' => [
                
        ],
        'maximumAssetsWeights' => [
                
        ],
        'maximumPortfolioExposure' => '',
        'minimumAssetsWeights' => [
                
        ],
        'minimumPortfolioExposure' => ''
    ],
    'subsetPortfolios' => 0,
    'subsetPortfoliosAggregationMethod' => '',
    'subsetPortfoliosEnumerationMethod' => '',
    'subsetSize' => 0
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/portfolio/optimization/maximum-return/subset-resampling-based', [
  'body' => '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  },
  "subsetPortfolios": 0,
  "subsetPortfoliosAggregationMethod": "",
  "subsetPortfoliosEnumerationMethod": "",
  "subsetSize": 0
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/portfolio/optimization/maximum-return/subset-resampling-based');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'assets' => 0,
  'assetsCovarianceMatrix' => [
    
  ],
  'assetsReturns' => [
    
  ],
  'constraints' => [
    'assetsGroups' => [
        
    ],
    'assetsGroupsMatrix' => [
        
    ],
    'maximumAssetsGroupsWeights' => [
        
    ],
    'maximumAssetsWeights' => [
        
    ],
    'maximumPortfolioExposure' => '',
    'minimumAssetsWeights' => [
        
    ],
    'minimumPortfolioExposure' => ''
  ],
  'subsetPortfolios' => 0,
  'subsetPortfoliosAggregationMethod' => '',
  'subsetPortfoliosEnumerationMethod' => '',
  'subsetSize' => 0
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'assets' => 0,
  'assetsCovarianceMatrix' => [
    
  ],
  'assetsReturns' => [
    
  ],
  'constraints' => [
    'assetsGroups' => [
        
    ],
    'assetsGroupsMatrix' => [
        
    ],
    'maximumAssetsGroupsWeights' => [
        
    ],
    'maximumAssetsWeights' => [
        
    ],
    'maximumPortfolioExposure' => '',
    'minimumAssetsWeights' => [
        
    ],
    'minimumPortfolioExposure' => ''
  ],
  'subsetPortfolios' => 0,
  'subsetPortfoliosAggregationMethod' => '',
  'subsetPortfoliosEnumerationMethod' => '',
  'subsetSize' => 0
]));
$request->setRequestUrl('{{baseUrl}}/portfolio/optimization/maximum-return/subset-resampling-based');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/portfolio/optimization/maximum-return/subset-resampling-based' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  },
  "subsetPortfolios": 0,
  "subsetPortfoliosAggregationMethod": "",
  "subsetPortfoliosEnumerationMethod": "",
  "subsetSize": 0
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/portfolio/optimization/maximum-return/subset-resampling-based' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  },
  "subsetPortfolios": 0,
  "subsetPortfoliosAggregationMethod": "",
  "subsetPortfoliosEnumerationMethod": "",
  "subsetSize": 0
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"subsetPortfolios\": 0,\n  \"subsetPortfoliosAggregationMethod\": \"\",\n  \"subsetPortfoliosEnumerationMethod\": \"\",\n  \"subsetSize\": 0\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/portfolio/optimization/maximum-return/subset-resampling-based", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/portfolio/optimization/maximum-return/subset-resampling-based"

payload = {
    "assets": 0,
    "assetsCovarianceMatrix": [],
    "assetsReturns": [],
    "constraints": {
        "assetsGroups": [],
        "assetsGroupsMatrix": [],
        "maximumAssetsGroupsWeights": [],
        "maximumAssetsWeights": [],
        "maximumPortfolioExposure": "",
        "minimumAssetsWeights": [],
        "minimumPortfolioExposure": ""
    },
    "subsetPortfolios": 0,
    "subsetPortfoliosAggregationMethod": "",
    "subsetPortfoliosEnumerationMethod": "",
    "subsetSize": 0
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/portfolio/optimization/maximum-return/subset-resampling-based"

payload <- "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"subsetPortfolios\": 0,\n  \"subsetPortfoliosAggregationMethod\": \"\",\n  \"subsetPortfoliosEnumerationMethod\": \"\",\n  \"subsetSize\": 0\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/portfolio/optimization/maximum-return/subset-resampling-based")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"subsetPortfolios\": 0,\n  \"subsetPortfoliosAggregationMethod\": \"\",\n  \"subsetPortfoliosEnumerationMethod\": \"\",\n  \"subsetSize\": 0\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/portfolio/optimization/maximum-return/subset-resampling-based') do |req|
  req.body = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"subsetPortfolios\": 0,\n  \"subsetPortfoliosAggregationMethod\": \"\",\n  \"subsetPortfoliosEnumerationMethod\": \"\",\n  \"subsetSize\": 0\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/portfolio/optimization/maximum-return/subset-resampling-based";

    let payload = json!({
        "assets": 0,
        "assetsCovarianceMatrix": (),
        "assetsReturns": (),
        "constraints": json!({
            "assetsGroups": (),
            "assetsGroupsMatrix": (),
            "maximumAssetsGroupsWeights": (),
            "maximumAssetsWeights": (),
            "maximumPortfolioExposure": "",
            "minimumAssetsWeights": (),
            "minimumPortfolioExposure": ""
        }),
        "subsetPortfolios": 0,
        "subsetPortfoliosAggregationMethod": "",
        "subsetPortfoliosEnumerationMethod": "",
        "subsetSize": 0
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/portfolio/optimization/maximum-return/subset-resampling-based \
  --header 'content-type: application/json' \
  --data '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  },
  "subsetPortfolios": 0,
  "subsetPortfoliosAggregationMethod": "",
  "subsetPortfoliosEnumerationMethod": "",
  "subsetSize": 0
}'

echo '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  },
  "subsetPortfolios": 0,
  "subsetPortfoliosAggregationMethod": "",
  "subsetPortfoliosEnumerationMethod": "",
  "subsetSize": 0
}' |  \
  http POST {{baseUrl}}/portfolio/optimization/maximum-return/subset-resampling-based \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "assets": 0,\n  "assetsCovarianceMatrix": [],\n  "assetsReturns": [],\n  "constraints": {\n    "assetsGroups": [],\n    "assetsGroupsMatrix": [],\n    "maximumAssetsGroupsWeights": [],\n    "maximumAssetsWeights": [],\n    "maximumPortfolioExposure": "",\n    "minimumAssetsWeights": [],\n    "minimumPortfolioExposure": ""\n  },\n  "subsetPortfolios": 0,\n  "subsetPortfoliosAggregationMethod": "",\n  "subsetPortfoliosEnumerationMethod": "",\n  "subsetSize": 0\n}' \
  --output-document \
  - {{baseUrl}}/portfolio/optimization/maximum-return/subset-resampling-based

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": [
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  ],
  "subsetPortfolios": 0,
  "subsetPortfoliosAggregationMethod": "",
  "subsetPortfoliosEnumerationMethod": "",
  "subsetSize": 0
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/portfolio/optimization/maximum-return/subset-resampling-based")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "assetsWeights": [
    0,
    0.3333333333333333,
    0.6666666666666666
  ]
}

POST Subset Resampling-Based Maximum Sharpe Ratio Portfolio

{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio/subset-resampling-based

BODY json

{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  },
  "riskFreeRate": "",
  "subsetPortfolios": 0,
  "subsetPortfoliosAggregationMethod": "",
  "subsetPortfoliosEnumerationMethod": "",
  "subsetSize": 0
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio/subset-resampling-based");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"riskFreeRate\": \"\",\n  \"subsetPortfolios\": 0,\n  \"subsetPortfoliosAggregationMethod\": \"\",\n  \"subsetPortfoliosEnumerationMethod\": \"\",\n  \"subsetSize\": 0\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio/subset-resampling-based" {:content-type :json
                                                                                                                :form-params {:assets 0
                                                                                                                              :assetsCovarianceMatrix []
                                                                                                                              :assetsReturns []
                                                                                                                              :constraints {:assetsGroups []
                                                                                                                                            :assetsGroupsMatrix []
                                                                                                                                            :maximumAssetsGroupsWeights []
                                                                                                                                            :maximumAssetsWeights []
                                                                                                                                            :maximumPortfolioExposure ""
                                                                                                                                            :minimumAssetsWeights []
                                                                                                                                            :minimumPortfolioExposure ""}
                                                                                                                              :riskFreeRate ""
                                                                                                                              :subsetPortfolios 0
                                                                                                                              :subsetPortfoliosAggregationMethod ""
                                                                                                                              :subsetPortfoliosEnumerationMethod ""
                                                                                                                              :subsetSize 0}})

require "http/client"

url = "{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio/subset-resampling-based"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"riskFreeRate\": \"\",\n  \"subsetPortfolios\": 0,\n  \"subsetPortfoliosAggregationMethod\": \"\",\n  \"subsetPortfoliosEnumerationMethod\": \"\",\n  \"subsetSize\": 0\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio/subset-resampling-based"),
    Content = new StringContent("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"riskFreeRate\": \"\",\n  \"subsetPortfolios\": 0,\n  \"subsetPortfoliosAggregationMethod\": \"\",\n  \"subsetPortfoliosEnumerationMethod\": \"\",\n  \"subsetSize\": 0\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio/subset-resampling-based");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"riskFreeRate\": \"\",\n  \"subsetPortfolios\": 0,\n  \"subsetPortfoliosAggregationMethod\": \"\",\n  \"subsetPortfoliosEnumerationMethod\": \"\",\n  \"subsetSize\": 0\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio/subset-resampling-based"

	payload := strings.NewReader("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"riskFreeRate\": \"\",\n  \"subsetPortfolios\": 0,\n  \"subsetPortfoliosAggregationMethod\": \"\",\n  \"subsetPortfoliosEnumerationMethod\": \"\",\n  \"subsetSize\": 0\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/portfolio/optimization/maximum-sharpe-ratio/subset-resampling-based HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 475

{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  },
  "riskFreeRate": "",
  "subsetPortfolios": 0,
  "subsetPortfoliosAggregationMethod": "",
  "subsetPortfoliosEnumerationMethod": "",
  "subsetSize": 0
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio/subset-resampling-based")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"riskFreeRate\": \"\",\n  \"subsetPortfolios\": 0,\n  \"subsetPortfoliosAggregationMethod\": \"\",\n  \"subsetPortfoliosEnumerationMethod\": \"\",\n  \"subsetSize\": 0\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio/subset-resampling-based"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"riskFreeRate\": \"\",\n  \"subsetPortfolios\": 0,\n  \"subsetPortfoliosAggregationMethod\": \"\",\n  \"subsetPortfoliosEnumerationMethod\": \"\",\n  \"subsetSize\": 0\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"riskFreeRate\": \"\",\n  \"subsetPortfolios\": 0,\n  \"subsetPortfoliosAggregationMethod\": \"\",\n  \"subsetPortfoliosEnumerationMethod\": \"\",\n  \"subsetSize\": 0\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio/subset-resampling-based")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio/subset-resampling-based")
  .header("content-type", "application/json")
  .body("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"riskFreeRate\": \"\",\n  \"subsetPortfolios\": 0,\n  \"subsetPortfoliosAggregationMethod\": \"\",\n  \"subsetPortfoliosEnumerationMethod\": \"\",\n  \"subsetSize\": 0\n}")
  .asString();

const data = JSON.stringify({
  assets: 0,
  assetsCovarianceMatrix: [],
  assetsReturns: [],
  constraints: {
    assetsGroups: [],
    assetsGroupsMatrix: [],
    maximumAssetsGroupsWeights: [],
    maximumAssetsWeights: [],
    maximumPortfolioExposure: '',
    minimumAssetsWeights: [],
    minimumPortfolioExposure: ''
  },
  riskFreeRate: '',
  subsetPortfolios: 0,
  subsetPortfoliosAggregationMethod: '',
  subsetPortfoliosEnumerationMethod: '',
  subsetSize: 0
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio/subset-resampling-based');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio/subset-resampling-based',
  headers: {'content-type': 'application/json'},
  data: {
    assets: 0,
    assetsCovarianceMatrix: [],
    assetsReturns: [],
    constraints: {
      assetsGroups: [],
      assetsGroupsMatrix: [],
      maximumAssetsGroupsWeights: [],
      maximumAssetsWeights: [],
      maximumPortfolioExposure: '',
      minimumAssetsWeights: [],
      minimumPortfolioExposure: ''
    },
    riskFreeRate: '',
    subsetPortfolios: 0,
    subsetPortfoliosAggregationMethod: '',
    subsetPortfoliosEnumerationMethod: '',
    subsetSize: 0
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio/subset-resampling-based';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":0,"assetsCovarianceMatrix":[],"assetsReturns":[],"constraints":{"assetsGroups":[],"assetsGroupsMatrix":[],"maximumAssetsGroupsWeights":[],"maximumAssetsWeights":[],"maximumPortfolioExposure":"","minimumAssetsWeights":[],"minimumPortfolioExposure":""},"riskFreeRate":"","subsetPortfolios":0,"subsetPortfoliosAggregationMethod":"","subsetPortfoliosEnumerationMethod":"","subsetSize":0}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio/subset-resampling-based',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "assets": 0,\n  "assetsCovarianceMatrix": [],\n  "assetsReturns": [],\n  "constraints": {\n    "assetsGroups": [],\n    "assetsGroupsMatrix": [],\n    "maximumAssetsGroupsWeights": [],\n    "maximumAssetsWeights": [],\n    "maximumPortfolioExposure": "",\n    "minimumAssetsWeights": [],\n    "minimumPortfolioExposure": ""\n  },\n  "riskFreeRate": "",\n  "subsetPortfolios": 0,\n  "subsetPortfoliosAggregationMethod": "",\n  "subsetPortfoliosEnumerationMethod": "",\n  "subsetSize": 0\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"riskFreeRate\": \"\",\n  \"subsetPortfolios\": 0,\n  \"subsetPortfoliosAggregationMethod\": \"\",\n  \"subsetPortfoliosEnumerationMethod\": \"\",\n  \"subsetSize\": 0\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio/subset-resampling-based")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/portfolio/optimization/maximum-sharpe-ratio/subset-resampling-based',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  assets: 0,
  assetsCovarianceMatrix: [],
  assetsReturns: [],
  constraints: {
    assetsGroups: [],
    assetsGroupsMatrix: [],
    maximumAssetsGroupsWeights: [],
    maximumAssetsWeights: [],
    maximumPortfolioExposure: '',
    minimumAssetsWeights: [],
    minimumPortfolioExposure: ''
  },
  riskFreeRate: '',
  subsetPortfolios: 0,
  subsetPortfoliosAggregationMethod: '',
  subsetPortfoliosEnumerationMethod: '',
  subsetSize: 0
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio/subset-resampling-based',
  headers: {'content-type': 'application/json'},
  body: {
    assets: 0,
    assetsCovarianceMatrix: [],
    assetsReturns: [],
    constraints: {
      assetsGroups: [],
      assetsGroupsMatrix: [],
      maximumAssetsGroupsWeights: [],
      maximumAssetsWeights: [],
      maximumPortfolioExposure: '',
      minimumAssetsWeights: [],
      minimumPortfolioExposure: ''
    },
    riskFreeRate: '',
    subsetPortfolios: 0,
    subsetPortfoliosAggregationMethod: '',
    subsetPortfoliosEnumerationMethod: '',
    subsetSize: 0
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio/subset-resampling-based');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  assets: 0,
  assetsCovarianceMatrix: [],
  assetsReturns: [],
  constraints: {
    assetsGroups: [],
    assetsGroupsMatrix: [],
    maximumAssetsGroupsWeights: [],
    maximumAssetsWeights: [],
    maximumPortfolioExposure: '',
    minimumAssetsWeights: [],
    minimumPortfolioExposure: ''
  },
  riskFreeRate: '',
  subsetPortfolios: 0,
  subsetPortfoliosAggregationMethod: '',
  subsetPortfoliosEnumerationMethod: '',
  subsetSize: 0
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio/subset-resampling-based',
  headers: {'content-type': 'application/json'},
  data: {
    assets: 0,
    assetsCovarianceMatrix: [],
    assetsReturns: [],
    constraints: {
      assetsGroups: [],
      assetsGroupsMatrix: [],
      maximumAssetsGroupsWeights: [],
      maximumAssetsWeights: [],
      maximumPortfolioExposure: '',
      minimumAssetsWeights: [],
      minimumPortfolioExposure: ''
    },
    riskFreeRate: '',
    subsetPortfolios: 0,
    subsetPortfoliosAggregationMethod: '',
    subsetPortfoliosEnumerationMethod: '',
    subsetSize: 0
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio/subset-resampling-based';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":0,"assetsCovarianceMatrix":[],"assetsReturns":[],"constraints":{"assetsGroups":[],"assetsGroupsMatrix":[],"maximumAssetsGroupsWeights":[],"maximumAssetsWeights":[],"maximumPortfolioExposure":"","minimumAssetsWeights":[],"minimumPortfolioExposure":""},"riskFreeRate":"","subsetPortfolios":0,"subsetPortfoliosAggregationMethod":"","subsetPortfoliosEnumerationMethod":"","subsetSize":0}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"assets": @0,
                              @"assetsCovarianceMatrix": @[  ],
                              @"assetsReturns": @[  ],
                              @"constraints": @{ @"assetsGroups": @[  ], @"assetsGroupsMatrix": @[  ], @"maximumAssetsGroupsWeights": @[  ], @"maximumAssetsWeights": @[  ], @"maximumPortfolioExposure": @"", @"minimumAssetsWeights": @[  ], @"minimumPortfolioExposure": @"" },
                              @"riskFreeRate": @"",
                              @"subsetPortfolios": @0,
                              @"subsetPortfoliosAggregationMethod": @"",
                              @"subsetPortfoliosEnumerationMethod": @"",
                              @"subsetSize": @0 };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio/subset-resampling-based"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio/subset-resampling-based" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"riskFreeRate\": \"\",\n  \"subsetPortfolios\": 0,\n  \"subsetPortfoliosAggregationMethod\": \"\",\n  \"subsetPortfoliosEnumerationMethod\": \"\",\n  \"subsetSize\": 0\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio/subset-resampling-based",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'assets' => 0,
    'assetsCovarianceMatrix' => [
        
    ],
    'assetsReturns' => [
        
    ],
    'constraints' => [
        'assetsGroups' => [
                
        ],
        'assetsGroupsMatrix' => [
                
        ],
        'maximumAssetsGroupsWeights' => [
                
        ],
        'maximumAssetsWeights' => [
                
        ],
        'maximumPortfolioExposure' => '',
        'minimumAssetsWeights' => [
                
        ],
        'minimumPortfolioExposure' => ''
    ],
    'riskFreeRate' => '',
    'subsetPortfolios' => 0,
    'subsetPortfoliosAggregationMethod' => '',
    'subsetPortfoliosEnumerationMethod' => '',
    'subsetSize' => 0
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio/subset-resampling-based', [
  'body' => '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  },
  "riskFreeRate": "",
  "subsetPortfolios": 0,
  "subsetPortfoliosAggregationMethod": "",
  "subsetPortfoliosEnumerationMethod": "",
  "subsetSize": 0
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio/subset-resampling-based');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'assets' => 0,
  'assetsCovarianceMatrix' => [
    
  ],
  'assetsReturns' => [
    
  ],
  'constraints' => [
    'assetsGroups' => [
        
    ],
    'assetsGroupsMatrix' => [
        
    ],
    'maximumAssetsGroupsWeights' => [
        
    ],
    'maximumAssetsWeights' => [
        
    ],
    'maximumPortfolioExposure' => '',
    'minimumAssetsWeights' => [
        
    ],
    'minimumPortfolioExposure' => ''
  ],
  'riskFreeRate' => '',
  'subsetPortfolios' => 0,
  'subsetPortfoliosAggregationMethod' => '',
  'subsetPortfoliosEnumerationMethod' => '',
  'subsetSize' => 0
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'assets' => 0,
  'assetsCovarianceMatrix' => [
    
  ],
  'assetsReturns' => [
    
  ],
  'constraints' => [
    'assetsGroups' => [
        
    ],
    'assetsGroupsMatrix' => [
        
    ],
    'maximumAssetsGroupsWeights' => [
        
    ],
    'maximumAssetsWeights' => [
        
    ],
    'maximumPortfolioExposure' => '',
    'minimumAssetsWeights' => [
        
    ],
    'minimumPortfolioExposure' => ''
  ],
  'riskFreeRate' => '',
  'subsetPortfolios' => 0,
  'subsetPortfoliosAggregationMethod' => '',
  'subsetPortfoliosEnumerationMethod' => '',
  'subsetSize' => 0
]));
$request->setRequestUrl('{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio/subset-resampling-based');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio/subset-resampling-based' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  },
  "riskFreeRate": "",
  "subsetPortfolios": 0,
  "subsetPortfoliosAggregationMethod": "",
  "subsetPortfoliosEnumerationMethod": "",
  "subsetSize": 0
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio/subset-resampling-based' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  },
  "riskFreeRate": "",
  "subsetPortfolios": 0,
  "subsetPortfoliosAggregationMethod": "",
  "subsetPortfoliosEnumerationMethod": "",
  "subsetSize": 0
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"riskFreeRate\": \"\",\n  \"subsetPortfolios\": 0,\n  \"subsetPortfoliosAggregationMethod\": \"\",\n  \"subsetPortfoliosEnumerationMethod\": \"\",\n  \"subsetSize\": 0\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/portfolio/optimization/maximum-sharpe-ratio/subset-resampling-based", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio/subset-resampling-based"

payload = {
    "assets": 0,
    "assetsCovarianceMatrix": [],
    "assetsReturns": [],
    "constraints": {
        "assetsGroups": [],
        "assetsGroupsMatrix": [],
        "maximumAssetsGroupsWeights": [],
        "maximumAssetsWeights": [],
        "maximumPortfolioExposure": "",
        "minimumAssetsWeights": [],
        "minimumPortfolioExposure": ""
    },
    "riskFreeRate": "",
    "subsetPortfolios": 0,
    "subsetPortfoliosAggregationMethod": "",
    "subsetPortfoliosEnumerationMethod": "",
    "subsetSize": 0
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio/subset-resampling-based"

payload <- "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"riskFreeRate\": \"\",\n  \"subsetPortfolios\": 0,\n  \"subsetPortfoliosAggregationMethod\": \"\",\n  \"subsetPortfoliosEnumerationMethod\": \"\",\n  \"subsetSize\": 0\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio/subset-resampling-based")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"riskFreeRate\": \"\",\n  \"subsetPortfolios\": 0,\n  \"subsetPortfoliosAggregationMethod\": \"\",\n  \"subsetPortfoliosEnumerationMethod\": \"\",\n  \"subsetSize\": 0\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/portfolio/optimization/maximum-sharpe-ratio/subset-resampling-based') do |req|
  req.body = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"riskFreeRate\": \"\",\n  \"subsetPortfolios\": 0,\n  \"subsetPortfoliosAggregationMethod\": \"\",\n  \"subsetPortfoliosEnumerationMethod\": \"\",\n  \"subsetSize\": 0\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio/subset-resampling-based";

    let payload = json!({
        "assets": 0,
        "assetsCovarianceMatrix": (),
        "assetsReturns": (),
        "constraints": json!({
            "assetsGroups": (),
            "assetsGroupsMatrix": (),
            "maximumAssetsGroupsWeights": (),
            "maximumAssetsWeights": (),
            "maximumPortfolioExposure": "",
            "minimumAssetsWeights": (),
            "minimumPortfolioExposure": ""
        }),
        "riskFreeRate": "",
        "subsetPortfolios": 0,
        "subsetPortfoliosAggregationMethod": "",
        "subsetPortfoliosEnumerationMethod": "",
        "subsetSize": 0
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio/subset-resampling-based \
  --header 'content-type: application/json' \
  --data '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  },
  "riskFreeRate": "",
  "subsetPortfolios": 0,
  "subsetPortfoliosAggregationMethod": "",
  "subsetPortfoliosEnumerationMethod": "",
  "subsetSize": 0
}'

echo '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  },
  "riskFreeRate": "",
  "subsetPortfolios": 0,
  "subsetPortfoliosAggregationMethod": "",
  "subsetPortfoliosEnumerationMethod": "",
  "subsetSize": 0
}' |  \
  http POST {{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio/subset-resampling-based \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "assets": 0,\n  "assetsCovarianceMatrix": [],\n  "assetsReturns": [],\n  "constraints": {\n    "assetsGroups": [],\n    "assetsGroupsMatrix": [],\n    "maximumAssetsGroupsWeights": [],\n    "maximumAssetsWeights": [],\n    "maximumPortfolioExposure": "",\n    "minimumAssetsWeights": [],\n    "minimumPortfolioExposure": ""\n  },\n  "riskFreeRate": "",\n  "subsetPortfolios": 0,\n  "subsetPortfoliosAggregationMethod": "",\n  "subsetPortfoliosEnumerationMethod": "",\n  "subsetSize": 0\n}' \
  --output-document \
  - {{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio/subset-resampling-based

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": [
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  ],
  "riskFreeRate": "",
  "subsetPortfolios": 0,
  "subsetPortfoliosAggregationMethod": "",
  "subsetPortfoliosEnumerationMethod": "",
  "subsetSize": 0
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/portfolio/optimization/maximum-sharpe-ratio/subset-resampling-based")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "assetsWeights": [
    0.35454545454545444,
    0.5845170454545454,
    0.06093750000000007
  ]
}

POST Subset Resampling-Based Mean-Variance Efficient Portfolio

{{baseUrl}}/portfolio/optimization/mean-variance-efficient/subset-resampling-based

BODY json

{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": "",
    "portfolioReturn": "",
    "portfolioVolatility": "",
    "riskTolerance": ""
  },
  "subsetPortfolios": 0,
  "subsetPortfoliosAggregationMethod": "",
  "subsetPortfoliosEnumerationMethod": "",
  "subsetSize": 0
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/portfolio/optimization/mean-variance-efficient/subset-resampling-based");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\",\n    \"portfolioReturn\": \"\",\n    \"portfolioVolatility\": \"\",\n    \"riskTolerance\": \"\"\n  },\n  \"subsetPortfolios\": 0,\n  \"subsetPortfoliosAggregationMethod\": \"\",\n  \"subsetPortfoliosEnumerationMethod\": \"\",\n  \"subsetSize\": 0\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/portfolio/optimization/mean-variance-efficient/subset-resampling-based" {:content-type :json
                                                                                                                   :form-params {:assets 0
                                                                                                                                 :assetsCovarianceMatrix []
                                                                                                                                 :assetsReturns []
                                                                                                                                 :constraints {:assetsGroups []
                                                                                                                                               :assetsGroupsMatrix []
                                                                                                                                               :maximumAssetsGroupsWeights []
                                                                                                                                               :maximumAssetsWeights []
                                                                                                                                               :maximumPortfolioExposure ""
                                                                                                                                               :minimumAssetsWeights []
                                                                                                                                               :minimumPortfolioExposure ""
                                                                                                                                               :portfolioReturn ""
                                                                                                                                               :portfolioVolatility ""
                                                                                                                                               :riskTolerance ""}
                                                                                                                                 :subsetPortfolios 0
                                                                                                                                 :subsetPortfoliosAggregationMethod ""
                                                                                                                                 :subsetPortfoliosEnumerationMethod ""
                                                                                                                                 :subsetSize 0}})

require "http/client"

url = "{{baseUrl}}/portfolio/optimization/mean-variance-efficient/subset-resampling-based"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\",\n    \"portfolioReturn\": \"\",\n    \"portfolioVolatility\": \"\",\n    \"riskTolerance\": \"\"\n  },\n  \"subsetPortfolios\": 0,\n  \"subsetPortfoliosAggregationMethod\": \"\",\n  \"subsetPortfoliosEnumerationMethod\": \"\",\n  \"subsetSize\": 0\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/portfolio/optimization/mean-variance-efficient/subset-resampling-based"),
    Content = new StringContent("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\",\n    \"portfolioReturn\": \"\",\n    \"portfolioVolatility\": \"\",\n    \"riskTolerance\": \"\"\n  },\n  \"subsetPortfolios\": 0,\n  \"subsetPortfoliosAggregationMethod\": \"\",\n  \"subsetPortfoliosEnumerationMethod\": \"\",\n  \"subsetSize\": 0\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/portfolio/optimization/mean-variance-efficient/subset-resampling-based");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\",\n    \"portfolioReturn\": \"\",\n    \"portfolioVolatility\": \"\",\n    \"riskTolerance\": \"\"\n  },\n  \"subsetPortfolios\": 0,\n  \"subsetPortfoliosAggregationMethod\": \"\",\n  \"subsetPortfoliosEnumerationMethod\": \"\",\n  \"subsetSize\": 0\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/portfolio/optimization/mean-variance-efficient/subset-resampling-based"

	payload := strings.NewReader("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\",\n    \"portfolioReturn\": \"\",\n    \"portfolioVolatility\": \"\",\n    \"riskTolerance\": \"\"\n  },\n  \"subsetPortfolios\": 0,\n  \"subsetPortfoliosAggregationMethod\": \"\",\n  \"subsetPortfoliosEnumerationMethod\": \"\",\n  \"subsetSize\": 0\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/portfolio/optimization/mean-variance-efficient/subset-resampling-based HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 536

{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": "",
    "portfolioReturn": "",
    "portfolioVolatility": "",
    "riskTolerance": ""
  },
  "subsetPortfolios": 0,
  "subsetPortfoliosAggregationMethod": "",
  "subsetPortfoliosEnumerationMethod": "",
  "subsetSize": 0
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/portfolio/optimization/mean-variance-efficient/subset-resampling-based")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\",\n    \"portfolioReturn\": \"\",\n    \"portfolioVolatility\": \"\",\n    \"riskTolerance\": \"\"\n  },\n  \"subsetPortfolios\": 0,\n  \"subsetPortfoliosAggregationMethod\": \"\",\n  \"subsetPortfoliosEnumerationMethod\": \"\",\n  \"subsetSize\": 0\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/portfolio/optimization/mean-variance-efficient/subset-resampling-based"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\",\n    \"portfolioReturn\": \"\",\n    \"portfolioVolatility\": \"\",\n    \"riskTolerance\": \"\"\n  },\n  \"subsetPortfolios\": 0,\n  \"subsetPortfoliosAggregationMethod\": \"\",\n  \"subsetPortfoliosEnumerationMethod\": \"\",\n  \"subsetSize\": 0\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\",\n    \"portfolioReturn\": \"\",\n    \"portfolioVolatility\": \"\",\n    \"riskTolerance\": \"\"\n  },\n  \"subsetPortfolios\": 0,\n  \"subsetPortfoliosAggregationMethod\": \"\",\n  \"subsetPortfoliosEnumerationMethod\": \"\",\n  \"subsetSize\": 0\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/portfolio/optimization/mean-variance-efficient/subset-resampling-based")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/portfolio/optimization/mean-variance-efficient/subset-resampling-based")
  .header("content-type", "application/json")
  .body("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\",\n    \"portfolioReturn\": \"\",\n    \"portfolioVolatility\": \"\",\n    \"riskTolerance\": \"\"\n  },\n  \"subsetPortfolios\": 0,\n  \"subsetPortfoliosAggregationMethod\": \"\",\n  \"subsetPortfoliosEnumerationMethod\": \"\",\n  \"subsetSize\": 0\n}")
  .asString();

const data = JSON.stringify({
  assets: 0,
  assetsCovarianceMatrix: [],
  assetsReturns: [],
  constraints: {
    assetsGroups: [],
    assetsGroupsMatrix: [],
    maximumAssetsGroupsWeights: [],
    maximumAssetsWeights: [],
    maximumPortfolioExposure: '',
    minimumAssetsWeights: [],
    minimumPortfolioExposure: '',
    portfolioReturn: '',
    portfolioVolatility: '',
    riskTolerance: ''
  },
  subsetPortfolios: 0,
  subsetPortfoliosAggregationMethod: '',
  subsetPortfoliosEnumerationMethod: '',
  subsetSize: 0
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/portfolio/optimization/mean-variance-efficient/subset-resampling-based');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/optimization/mean-variance-efficient/subset-resampling-based',
  headers: {'content-type': 'application/json'},
  data: {
    assets: 0,
    assetsCovarianceMatrix: [],
    assetsReturns: [],
    constraints: {
      assetsGroups: [],
      assetsGroupsMatrix: [],
      maximumAssetsGroupsWeights: [],
      maximumAssetsWeights: [],
      maximumPortfolioExposure: '',
      minimumAssetsWeights: [],
      minimumPortfolioExposure: '',
      portfolioReturn: '',
      portfolioVolatility: '',
      riskTolerance: ''
    },
    subsetPortfolios: 0,
    subsetPortfoliosAggregationMethod: '',
    subsetPortfoliosEnumerationMethod: '',
    subsetSize: 0
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/portfolio/optimization/mean-variance-efficient/subset-resampling-based';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":0,"assetsCovarianceMatrix":[],"assetsReturns":[],"constraints":{"assetsGroups":[],"assetsGroupsMatrix":[],"maximumAssetsGroupsWeights":[],"maximumAssetsWeights":[],"maximumPortfolioExposure":"","minimumAssetsWeights":[],"minimumPortfolioExposure":"","portfolioReturn":"","portfolioVolatility":"","riskTolerance":""},"subsetPortfolios":0,"subsetPortfoliosAggregationMethod":"","subsetPortfoliosEnumerationMethod":"","subsetSize":0}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/portfolio/optimization/mean-variance-efficient/subset-resampling-based',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "assets": 0,\n  "assetsCovarianceMatrix": [],\n  "assetsReturns": [],\n  "constraints": {\n    "assetsGroups": [],\n    "assetsGroupsMatrix": [],\n    "maximumAssetsGroupsWeights": [],\n    "maximumAssetsWeights": [],\n    "maximumPortfolioExposure": "",\n    "minimumAssetsWeights": [],\n    "minimumPortfolioExposure": "",\n    "portfolioReturn": "",\n    "portfolioVolatility": "",\n    "riskTolerance": ""\n  },\n  "subsetPortfolios": 0,\n  "subsetPortfoliosAggregationMethod": "",\n  "subsetPortfoliosEnumerationMethod": "",\n  "subsetSize": 0\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\",\n    \"portfolioReturn\": \"\",\n    \"portfolioVolatility\": \"\",\n    \"riskTolerance\": \"\"\n  },\n  \"subsetPortfolios\": 0,\n  \"subsetPortfoliosAggregationMethod\": \"\",\n  \"subsetPortfoliosEnumerationMethod\": \"\",\n  \"subsetSize\": 0\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/portfolio/optimization/mean-variance-efficient/subset-resampling-based")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/portfolio/optimization/mean-variance-efficient/subset-resampling-based',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  assets: 0,
  assetsCovarianceMatrix: [],
  assetsReturns: [],
  constraints: {
    assetsGroups: [],
    assetsGroupsMatrix: [],
    maximumAssetsGroupsWeights: [],
    maximumAssetsWeights: [],
    maximumPortfolioExposure: '',
    minimumAssetsWeights: [],
    minimumPortfolioExposure: '',
    portfolioReturn: '',
    portfolioVolatility: '',
    riskTolerance: ''
  },
  subsetPortfolios: 0,
  subsetPortfoliosAggregationMethod: '',
  subsetPortfoliosEnumerationMethod: '',
  subsetSize: 0
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/optimization/mean-variance-efficient/subset-resampling-based',
  headers: {'content-type': 'application/json'},
  body: {
    assets: 0,
    assetsCovarianceMatrix: [],
    assetsReturns: [],
    constraints: {
      assetsGroups: [],
      assetsGroupsMatrix: [],
      maximumAssetsGroupsWeights: [],
      maximumAssetsWeights: [],
      maximumPortfolioExposure: '',
      minimumAssetsWeights: [],
      minimumPortfolioExposure: '',
      portfolioReturn: '',
      portfolioVolatility: '',
      riskTolerance: ''
    },
    subsetPortfolios: 0,
    subsetPortfoliosAggregationMethod: '',
    subsetPortfoliosEnumerationMethod: '',
    subsetSize: 0
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/portfolio/optimization/mean-variance-efficient/subset-resampling-based');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  assets: 0,
  assetsCovarianceMatrix: [],
  assetsReturns: [],
  constraints: {
    assetsGroups: [],
    assetsGroupsMatrix: [],
    maximumAssetsGroupsWeights: [],
    maximumAssetsWeights: [],
    maximumPortfolioExposure: '',
    minimumAssetsWeights: [],
    minimumPortfolioExposure: '',
    portfolioReturn: '',
    portfolioVolatility: '',
    riskTolerance: ''
  },
  subsetPortfolios: 0,
  subsetPortfoliosAggregationMethod: '',
  subsetPortfoliosEnumerationMethod: '',
  subsetSize: 0
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/optimization/mean-variance-efficient/subset-resampling-based',
  headers: {'content-type': 'application/json'},
  data: {
    assets: 0,
    assetsCovarianceMatrix: [],
    assetsReturns: [],
    constraints: {
      assetsGroups: [],
      assetsGroupsMatrix: [],
      maximumAssetsGroupsWeights: [],
      maximumAssetsWeights: [],
      maximumPortfolioExposure: '',
      minimumAssetsWeights: [],
      minimumPortfolioExposure: '',
      portfolioReturn: '',
      portfolioVolatility: '',
      riskTolerance: ''
    },
    subsetPortfolios: 0,
    subsetPortfoliosAggregationMethod: '',
    subsetPortfoliosEnumerationMethod: '',
    subsetSize: 0
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/portfolio/optimization/mean-variance-efficient/subset-resampling-based';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":0,"assetsCovarianceMatrix":[],"assetsReturns":[],"constraints":{"assetsGroups":[],"assetsGroupsMatrix":[],"maximumAssetsGroupsWeights":[],"maximumAssetsWeights":[],"maximumPortfolioExposure":"","minimumAssetsWeights":[],"minimumPortfolioExposure":"","portfolioReturn":"","portfolioVolatility":"","riskTolerance":""},"subsetPortfolios":0,"subsetPortfoliosAggregationMethod":"","subsetPortfoliosEnumerationMethod":"","subsetSize":0}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"assets": @0,
                              @"assetsCovarianceMatrix": @[  ],
                              @"assetsReturns": @[  ],
                              @"constraints": @{ @"assetsGroups": @[  ], @"assetsGroupsMatrix": @[  ], @"maximumAssetsGroupsWeights": @[  ], @"maximumAssetsWeights": @[  ], @"maximumPortfolioExposure": @"", @"minimumAssetsWeights": @[  ], @"minimumPortfolioExposure": @"", @"portfolioReturn": @"", @"portfolioVolatility": @"", @"riskTolerance": @"" },
                              @"subsetPortfolios": @0,
                              @"subsetPortfoliosAggregationMethod": @"",
                              @"subsetPortfoliosEnumerationMethod": @"",
                              @"subsetSize": @0 };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/portfolio/optimization/mean-variance-efficient/subset-resampling-based"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/portfolio/optimization/mean-variance-efficient/subset-resampling-based" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\",\n    \"portfolioReturn\": \"\",\n    \"portfolioVolatility\": \"\",\n    \"riskTolerance\": \"\"\n  },\n  \"subsetPortfolios\": 0,\n  \"subsetPortfoliosAggregationMethod\": \"\",\n  \"subsetPortfoliosEnumerationMethod\": \"\",\n  \"subsetSize\": 0\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/portfolio/optimization/mean-variance-efficient/subset-resampling-based",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'assets' => 0,
    'assetsCovarianceMatrix' => [
        
    ],
    'assetsReturns' => [
        
    ],
    'constraints' => [
        'assetsGroups' => [
                
        ],
        'assetsGroupsMatrix' => [
                
        ],
        'maximumAssetsGroupsWeights' => [
                
        ],
        'maximumAssetsWeights' => [
                
        ],
        'maximumPortfolioExposure' => '',
        'minimumAssetsWeights' => [
                
        ],
        'minimumPortfolioExposure' => '',
        'portfolioReturn' => '',
        'portfolioVolatility' => '',
        'riskTolerance' => ''
    ],
    'subsetPortfolios' => 0,
    'subsetPortfoliosAggregationMethod' => '',
    'subsetPortfoliosEnumerationMethod' => '',
    'subsetSize' => 0
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/portfolio/optimization/mean-variance-efficient/subset-resampling-based', [
  'body' => '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": "",
    "portfolioReturn": "",
    "portfolioVolatility": "",
    "riskTolerance": ""
  },
  "subsetPortfolios": 0,
  "subsetPortfoliosAggregationMethod": "",
  "subsetPortfoliosEnumerationMethod": "",
  "subsetSize": 0
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/portfolio/optimization/mean-variance-efficient/subset-resampling-based');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'assets' => 0,
  'assetsCovarianceMatrix' => [
    
  ],
  'assetsReturns' => [
    
  ],
  'constraints' => [
    'assetsGroups' => [
        
    ],
    'assetsGroupsMatrix' => [
        
    ],
    'maximumAssetsGroupsWeights' => [
        
    ],
    'maximumAssetsWeights' => [
        
    ],
    'maximumPortfolioExposure' => '',
    'minimumAssetsWeights' => [
        
    ],
    'minimumPortfolioExposure' => '',
    'portfolioReturn' => '',
    'portfolioVolatility' => '',
    'riskTolerance' => ''
  ],
  'subsetPortfolios' => 0,
  'subsetPortfoliosAggregationMethod' => '',
  'subsetPortfoliosEnumerationMethod' => '',
  'subsetSize' => 0
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'assets' => 0,
  'assetsCovarianceMatrix' => [
    
  ],
  'assetsReturns' => [
    
  ],
  'constraints' => [
    'assetsGroups' => [
        
    ],
    'assetsGroupsMatrix' => [
        
    ],
    'maximumAssetsGroupsWeights' => [
        
    ],
    'maximumAssetsWeights' => [
        
    ],
    'maximumPortfolioExposure' => '',
    'minimumAssetsWeights' => [
        
    ],
    'minimumPortfolioExposure' => '',
    'portfolioReturn' => '',
    'portfolioVolatility' => '',
    'riskTolerance' => ''
  ],
  'subsetPortfolios' => 0,
  'subsetPortfoliosAggregationMethod' => '',
  'subsetPortfoliosEnumerationMethod' => '',
  'subsetSize' => 0
]));
$request->setRequestUrl('{{baseUrl}}/portfolio/optimization/mean-variance-efficient/subset-resampling-based');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/portfolio/optimization/mean-variance-efficient/subset-resampling-based' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": "",
    "portfolioReturn": "",
    "portfolioVolatility": "",
    "riskTolerance": ""
  },
  "subsetPortfolios": 0,
  "subsetPortfoliosAggregationMethod": "",
  "subsetPortfoliosEnumerationMethod": "",
  "subsetSize": 0
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/portfolio/optimization/mean-variance-efficient/subset-resampling-based' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": "",
    "portfolioReturn": "",
    "portfolioVolatility": "",
    "riskTolerance": ""
  },
  "subsetPortfolios": 0,
  "subsetPortfoliosAggregationMethod": "",
  "subsetPortfoliosEnumerationMethod": "",
  "subsetSize": 0
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\",\n    \"portfolioReturn\": \"\",\n    \"portfolioVolatility\": \"\",\n    \"riskTolerance\": \"\"\n  },\n  \"subsetPortfolios\": 0,\n  \"subsetPortfoliosAggregationMethod\": \"\",\n  \"subsetPortfoliosEnumerationMethod\": \"\",\n  \"subsetSize\": 0\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/portfolio/optimization/mean-variance-efficient/subset-resampling-based", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/portfolio/optimization/mean-variance-efficient/subset-resampling-based"

payload = {
    "assets": 0,
    "assetsCovarianceMatrix": [],
    "assetsReturns": [],
    "constraints": {
        "assetsGroups": [],
        "assetsGroupsMatrix": [],
        "maximumAssetsGroupsWeights": [],
        "maximumAssetsWeights": [],
        "maximumPortfolioExposure": "",
        "minimumAssetsWeights": [],
        "minimumPortfolioExposure": "",
        "portfolioReturn": "",
        "portfolioVolatility": "",
        "riskTolerance": ""
    },
    "subsetPortfolios": 0,
    "subsetPortfoliosAggregationMethod": "",
    "subsetPortfoliosEnumerationMethod": "",
    "subsetSize": 0
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/portfolio/optimization/mean-variance-efficient/subset-resampling-based"

payload <- "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\",\n    \"portfolioReturn\": \"\",\n    \"portfolioVolatility\": \"\",\n    \"riskTolerance\": \"\"\n  },\n  \"subsetPortfolios\": 0,\n  \"subsetPortfoliosAggregationMethod\": \"\",\n  \"subsetPortfoliosEnumerationMethod\": \"\",\n  \"subsetSize\": 0\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/portfolio/optimization/mean-variance-efficient/subset-resampling-based")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\",\n    \"portfolioReturn\": \"\",\n    \"portfolioVolatility\": \"\",\n    \"riskTolerance\": \"\"\n  },\n  \"subsetPortfolios\": 0,\n  \"subsetPortfoliosAggregationMethod\": \"\",\n  \"subsetPortfoliosEnumerationMethod\": \"\",\n  \"subsetSize\": 0\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/portfolio/optimization/mean-variance-efficient/subset-resampling-based') do |req|
  req.body = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\",\n    \"portfolioReturn\": \"\",\n    \"portfolioVolatility\": \"\",\n    \"riskTolerance\": \"\"\n  },\n  \"subsetPortfolios\": 0,\n  \"subsetPortfoliosAggregationMethod\": \"\",\n  \"subsetPortfoliosEnumerationMethod\": \"\",\n  \"subsetSize\": 0\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/portfolio/optimization/mean-variance-efficient/subset-resampling-based";

    let payload = json!({
        "assets": 0,
        "assetsCovarianceMatrix": (),
        "assetsReturns": (),
        "constraints": json!({
            "assetsGroups": (),
            "assetsGroupsMatrix": (),
            "maximumAssetsGroupsWeights": (),
            "maximumAssetsWeights": (),
            "maximumPortfolioExposure": "",
            "minimumAssetsWeights": (),
            "minimumPortfolioExposure": "",
            "portfolioReturn": "",
            "portfolioVolatility": "",
            "riskTolerance": ""
        }),
        "subsetPortfolios": 0,
        "subsetPortfoliosAggregationMethod": "",
        "subsetPortfoliosEnumerationMethod": "",
        "subsetSize": 0
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/portfolio/optimization/mean-variance-efficient/subset-resampling-based \
  --header 'content-type: application/json' \
  --data '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": "",
    "portfolioReturn": "",
    "portfolioVolatility": "",
    "riskTolerance": ""
  },
  "subsetPortfolios": 0,
  "subsetPortfoliosAggregationMethod": "",
  "subsetPortfoliosEnumerationMethod": "",
  "subsetSize": 0
}'

echo '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": "",
    "portfolioReturn": "",
    "portfolioVolatility": "",
    "riskTolerance": ""
  },
  "subsetPortfolios": 0,
  "subsetPortfoliosAggregationMethod": "",
  "subsetPortfoliosEnumerationMethod": "",
  "subsetSize": 0
}' |  \
  http POST {{baseUrl}}/portfolio/optimization/mean-variance-efficient/subset-resampling-based \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "assets": 0,\n  "assetsCovarianceMatrix": [],\n  "assetsReturns": [],\n  "constraints": {\n    "assetsGroups": [],\n    "assetsGroupsMatrix": [],\n    "maximumAssetsGroupsWeights": [],\n    "maximumAssetsWeights": [],\n    "maximumPortfolioExposure": "",\n    "minimumAssetsWeights": [],\n    "minimumPortfolioExposure": "",\n    "portfolioReturn": "",\n    "portfolioVolatility": "",\n    "riskTolerance": ""\n  },\n  "subsetPortfolios": 0,\n  "subsetPortfoliosAggregationMethod": "",\n  "subsetPortfoliosEnumerationMethod": "",\n  "subsetSize": 0\n}' \
  --output-document \
  - {{baseUrl}}/portfolio/optimization/mean-variance-efficient/subset-resampling-based

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": [
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": "",
    "portfolioReturn": "",
    "portfolioVolatility": "",
    "riskTolerance": ""
  ],
  "subsetPortfolios": 0,
  "subsetPortfoliosAggregationMethod": "",
  "subsetPortfoliosEnumerationMethod": "",
  "subsetSize": 0
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/portfolio/optimization/mean-variance-efficient/subset-resampling-based")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "assetsWeights": [
    0.24609375,
    0.3125,
    0.44140624999999994
  ]
}

POST Subset Resampling-Based Minimum Variance Portfolio

{{baseUrl}}/portfolio/optimization/minimum-variance/subset-resampling-based

BODY json

{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  },
  "subsetPortfolios": 0,
  "subsetPortfoliosAggregationMethod": "",
  "subsetPortfoliosEnumerationMethod": "",
  "subsetSize": 0
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/portfolio/optimization/minimum-variance/subset-resampling-based");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"subsetPortfolios\": 0,\n  \"subsetPortfoliosAggregationMethod\": \"\",\n  \"subsetPortfoliosEnumerationMethod\": \"\",\n  \"subsetSize\": 0\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/portfolio/optimization/minimum-variance/subset-resampling-based" {:content-type :json
                                                                                                            :form-params {:assets 0
                                                                                                                          :assetsCovarianceMatrix []
                                                                                                                          :assetsReturns []
                                                                                                                          :constraints {:assetsGroups []
                                                                                                                                        :assetsGroupsMatrix []
                                                                                                                                        :maximumAssetsGroupsWeights []
                                                                                                                                        :maximumAssetsWeights []
                                                                                                                                        :maximumPortfolioExposure ""
                                                                                                                                        :minimumAssetsWeights []
                                                                                                                                        :minimumPortfolioExposure ""}
                                                                                                                          :subsetPortfolios 0
                                                                                                                          :subsetPortfoliosAggregationMethod ""
                                                                                                                          :subsetPortfoliosEnumerationMethod ""
                                                                                                                          :subsetSize 0}})

require "http/client"

url = "{{baseUrl}}/portfolio/optimization/minimum-variance/subset-resampling-based"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"subsetPortfolios\": 0,\n  \"subsetPortfoliosAggregationMethod\": \"\",\n  \"subsetPortfoliosEnumerationMethod\": \"\",\n  \"subsetSize\": 0\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/portfolio/optimization/minimum-variance/subset-resampling-based"),
    Content = new StringContent("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"subsetPortfolios\": 0,\n  \"subsetPortfoliosAggregationMethod\": \"\",\n  \"subsetPortfoliosEnumerationMethod\": \"\",\n  \"subsetSize\": 0\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/portfolio/optimization/minimum-variance/subset-resampling-based");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"subsetPortfolios\": 0,\n  \"subsetPortfoliosAggregationMethod\": \"\",\n  \"subsetPortfoliosEnumerationMethod\": \"\",\n  \"subsetSize\": 0\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/portfolio/optimization/minimum-variance/subset-resampling-based"

	payload := strings.NewReader("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"subsetPortfolios\": 0,\n  \"subsetPortfoliosAggregationMethod\": \"\",\n  \"subsetPortfoliosEnumerationMethod\": \"\",\n  \"subsetSize\": 0\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/portfolio/optimization/minimum-variance/subset-resampling-based HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 453

{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  },
  "subsetPortfolios": 0,
  "subsetPortfoliosAggregationMethod": "",
  "subsetPortfoliosEnumerationMethod": "",
  "subsetSize": 0
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/portfolio/optimization/minimum-variance/subset-resampling-based")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"subsetPortfolios\": 0,\n  \"subsetPortfoliosAggregationMethod\": \"\",\n  \"subsetPortfoliosEnumerationMethod\": \"\",\n  \"subsetSize\": 0\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/portfolio/optimization/minimum-variance/subset-resampling-based"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"subsetPortfolios\": 0,\n  \"subsetPortfoliosAggregationMethod\": \"\",\n  \"subsetPortfoliosEnumerationMethod\": \"\",\n  \"subsetSize\": 0\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"subsetPortfolios\": 0,\n  \"subsetPortfoliosAggregationMethod\": \"\",\n  \"subsetPortfoliosEnumerationMethod\": \"\",\n  \"subsetSize\": 0\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/portfolio/optimization/minimum-variance/subset-resampling-based")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/portfolio/optimization/minimum-variance/subset-resampling-based")
  .header("content-type", "application/json")
  .body("{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"subsetPortfolios\": 0,\n  \"subsetPortfoliosAggregationMethod\": \"\",\n  \"subsetPortfoliosEnumerationMethod\": \"\",\n  \"subsetSize\": 0\n}")
  .asString();

const data = JSON.stringify({
  assets: 0,
  assetsCovarianceMatrix: [],
  assetsReturns: [],
  constraints: {
    assetsGroups: [],
    assetsGroupsMatrix: [],
    maximumAssetsGroupsWeights: [],
    maximumAssetsWeights: [],
    maximumPortfolioExposure: '',
    minimumAssetsWeights: [],
    minimumPortfolioExposure: ''
  },
  subsetPortfolios: 0,
  subsetPortfoliosAggregationMethod: '',
  subsetPortfoliosEnumerationMethod: '',
  subsetSize: 0
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/portfolio/optimization/minimum-variance/subset-resampling-based');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/optimization/minimum-variance/subset-resampling-based',
  headers: {'content-type': 'application/json'},
  data: {
    assets: 0,
    assetsCovarianceMatrix: [],
    assetsReturns: [],
    constraints: {
      assetsGroups: [],
      assetsGroupsMatrix: [],
      maximumAssetsGroupsWeights: [],
      maximumAssetsWeights: [],
      maximumPortfolioExposure: '',
      minimumAssetsWeights: [],
      minimumPortfolioExposure: ''
    },
    subsetPortfolios: 0,
    subsetPortfoliosAggregationMethod: '',
    subsetPortfoliosEnumerationMethod: '',
    subsetSize: 0
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/portfolio/optimization/minimum-variance/subset-resampling-based';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":0,"assetsCovarianceMatrix":[],"assetsReturns":[],"constraints":{"assetsGroups":[],"assetsGroupsMatrix":[],"maximumAssetsGroupsWeights":[],"maximumAssetsWeights":[],"maximumPortfolioExposure":"","minimumAssetsWeights":[],"minimumPortfolioExposure":""},"subsetPortfolios":0,"subsetPortfoliosAggregationMethod":"","subsetPortfoliosEnumerationMethod":"","subsetSize":0}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/portfolio/optimization/minimum-variance/subset-resampling-based',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "assets": 0,\n  "assetsCovarianceMatrix": [],\n  "assetsReturns": [],\n  "constraints": {\n    "assetsGroups": [],\n    "assetsGroupsMatrix": [],\n    "maximumAssetsGroupsWeights": [],\n    "maximumAssetsWeights": [],\n    "maximumPortfolioExposure": "",\n    "minimumAssetsWeights": [],\n    "minimumPortfolioExposure": ""\n  },\n  "subsetPortfolios": 0,\n  "subsetPortfoliosAggregationMethod": "",\n  "subsetPortfoliosEnumerationMethod": "",\n  "subsetSize": 0\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"subsetPortfolios\": 0,\n  \"subsetPortfoliosAggregationMethod\": \"\",\n  \"subsetPortfoliosEnumerationMethod\": \"\",\n  \"subsetSize\": 0\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/portfolio/optimization/minimum-variance/subset-resampling-based")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/portfolio/optimization/minimum-variance/subset-resampling-based',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  assets: 0,
  assetsCovarianceMatrix: [],
  assetsReturns: [],
  constraints: {
    assetsGroups: [],
    assetsGroupsMatrix: [],
    maximumAssetsGroupsWeights: [],
    maximumAssetsWeights: [],
    maximumPortfolioExposure: '',
    minimumAssetsWeights: [],
    minimumPortfolioExposure: ''
  },
  subsetPortfolios: 0,
  subsetPortfoliosAggregationMethod: '',
  subsetPortfoliosEnumerationMethod: '',
  subsetSize: 0
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/optimization/minimum-variance/subset-resampling-based',
  headers: {'content-type': 'application/json'},
  body: {
    assets: 0,
    assetsCovarianceMatrix: [],
    assetsReturns: [],
    constraints: {
      assetsGroups: [],
      assetsGroupsMatrix: [],
      maximumAssetsGroupsWeights: [],
      maximumAssetsWeights: [],
      maximumPortfolioExposure: '',
      minimumAssetsWeights: [],
      minimumPortfolioExposure: ''
    },
    subsetPortfolios: 0,
    subsetPortfoliosAggregationMethod: '',
    subsetPortfoliosEnumerationMethod: '',
    subsetSize: 0
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/portfolio/optimization/minimum-variance/subset-resampling-based');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  assets: 0,
  assetsCovarianceMatrix: [],
  assetsReturns: [],
  constraints: {
    assetsGroups: [],
    assetsGroupsMatrix: [],
    maximumAssetsGroupsWeights: [],
    maximumAssetsWeights: [],
    maximumPortfolioExposure: '',
    minimumAssetsWeights: [],
    minimumPortfolioExposure: ''
  },
  subsetPortfolios: 0,
  subsetPortfoliosAggregationMethod: '',
  subsetPortfoliosEnumerationMethod: '',
  subsetSize: 0
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/optimization/minimum-variance/subset-resampling-based',
  headers: {'content-type': 'application/json'},
  data: {
    assets: 0,
    assetsCovarianceMatrix: [],
    assetsReturns: [],
    constraints: {
      assetsGroups: [],
      assetsGroupsMatrix: [],
      maximumAssetsGroupsWeights: [],
      maximumAssetsWeights: [],
      maximumPortfolioExposure: '',
      minimumAssetsWeights: [],
      minimumPortfolioExposure: ''
    },
    subsetPortfolios: 0,
    subsetPortfoliosAggregationMethod: '',
    subsetPortfoliosEnumerationMethod: '',
    subsetSize: 0
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/portfolio/optimization/minimum-variance/subset-resampling-based';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":0,"assetsCovarianceMatrix":[],"assetsReturns":[],"constraints":{"assetsGroups":[],"assetsGroupsMatrix":[],"maximumAssetsGroupsWeights":[],"maximumAssetsWeights":[],"maximumPortfolioExposure":"","minimumAssetsWeights":[],"minimumPortfolioExposure":""},"subsetPortfolios":0,"subsetPortfoliosAggregationMethod":"","subsetPortfoliosEnumerationMethod":"","subsetSize":0}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"assets": @0,
                              @"assetsCovarianceMatrix": @[  ],
                              @"assetsReturns": @[  ],
                              @"constraints": @{ @"assetsGroups": @[  ], @"assetsGroupsMatrix": @[  ], @"maximumAssetsGroupsWeights": @[  ], @"maximumAssetsWeights": @[  ], @"maximumPortfolioExposure": @"", @"minimumAssetsWeights": @[  ], @"minimumPortfolioExposure": @"" },
                              @"subsetPortfolios": @0,
                              @"subsetPortfoliosAggregationMethod": @"",
                              @"subsetPortfoliosEnumerationMethod": @"",
                              @"subsetSize": @0 };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/portfolio/optimization/minimum-variance/subset-resampling-based"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/portfolio/optimization/minimum-variance/subset-resampling-based" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"subsetPortfolios\": 0,\n  \"subsetPortfoliosAggregationMethod\": \"\",\n  \"subsetPortfoliosEnumerationMethod\": \"\",\n  \"subsetSize\": 0\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/portfolio/optimization/minimum-variance/subset-resampling-based",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'assets' => 0,
    'assetsCovarianceMatrix' => [
        
    ],
    'assetsReturns' => [
        
    ],
    'constraints' => [
        'assetsGroups' => [
                
        ],
        'assetsGroupsMatrix' => [
                
        ],
        'maximumAssetsGroupsWeights' => [
                
        ],
        'maximumAssetsWeights' => [
                
        ],
        'maximumPortfolioExposure' => '',
        'minimumAssetsWeights' => [
                
        ],
        'minimumPortfolioExposure' => ''
    ],
    'subsetPortfolios' => 0,
    'subsetPortfoliosAggregationMethod' => '',
    'subsetPortfoliosEnumerationMethod' => '',
    'subsetSize' => 0
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/portfolio/optimization/minimum-variance/subset-resampling-based', [
  'body' => '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  },
  "subsetPortfolios": 0,
  "subsetPortfoliosAggregationMethod": "",
  "subsetPortfoliosEnumerationMethod": "",
  "subsetSize": 0
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/portfolio/optimization/minimum-variance/subset-resampling-based');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'assets' => 0,
  'assetsCovarianceMatrix' => [
    
  ],
  'assetsReturns' => [
    
  ],
  'constraints' => [
    'assetsGroups' => [
        
    ],
    'assetsGroupsMatrix' => [
        
    ],
    'maximumAssetsGroupsWeights' => [
        
    ],
    'maximumAssetsWeights' => [
        
    ],
    'maximumPortfolioExposure' => '',
    'minimumAssetsWeights' => [
        
    ],
    'minimumPortfolioExposure' => ''
  ],
  'subsetPortfolios' => 0,
  'subsetPortfoliosAggregationMethod' => '',
  'subsetPortfoliosEnumerationMethod' => '',
  'subsetSize' => 0
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'assets' => 0,
  'assetsCovarianceMatrix' => [
    
  ],
  'assetsReturns' => [
    
  ],
  'constraints' => [
    'assetsGroups' => [
        
    ],
    'assetsGroupsMatrix' => [
        
    ],
    'maximumAssetsGroupsWeights' => [
        
    ],
    'maximumAssetsWeights' => [
        
    ],
    'maximumPortfolioExposure' => '',
    'minimumAssetsWeights' => [
        
    ],
    'minimumPortfolioExposure' => ''
  ],
  'subsetPortfolios' => 0,
  'subsetPortfoliosAggregationMethod' => '',
  'subsetPortfoliosEnumerationMethod' => '',
  'subsetSize' => 0
]));
$request->setRequestUrl('{{baseUrl}}/portfolio/optimization/minimum-variance/subset-resampling-based');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/portfolio/optimization/minimum-variance/subset-resampling-based' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  },
  "subsetPortfolios": 0,
  "subsetPortfoliosAggregationMethod": "",
  "subsetPortfoliosEnumerationMethod": "",
  "subsetSize": 0
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/portfolio/optimization/minimum-variance/subset-resampling-based' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  },
  "subsetPortfolios": 0,
  "subsetPortfoliosAggregationMethod": "",
  "subsetPortfoliosEnumerationMethod": "",
  "subsetSize": 0
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"subsetPortfolios\": 0,\n  \"subsetPortfoliosAggregationMethod\": \"\",\n  \"subsetPortfoliosEnumerationMethod\": \"\",\n  \"subsetSize\": 0\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/portfolio/optimization/minimum-variance/subset-resampling-based", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/portfolio/optimization/minimum-variance/subset-resampling-based"

payload = {
    "assets": 0,
    "assetsCovarianceMatrix": [],
    "assetsReturns": [],
    "constraints": {
        "assetsGroups": [],
        "assetsGroupsMatrix": [],
        "maximumAssetsGroupsWeights": [],
        "maximumAssetsWeights": [],
        "maximumPortfolioExposure": "",
        "minimumAssetsWeights": [],
        "minimumPortfolioExposure": ""
    },
    "subsetPortfolios": 0,
    "subsetPortfoliosAggregationMethod": "",
    "subsetPortfoliosEnumerationMethod": "",
    "subsetSize": 0
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/portfolio/optimization/minimum-variance/subset-resampling-based"

payload <- "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"subsetPortfolios\": 0,\n  \"subsetPortfoliosAggregationMethod\": \"\",\n  \"subsetPortfoliosEnumerationMethod\": \"\",\n  \"subsetSize\": 0\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/portfolio/optimization/minimum-variance/subset-resampling-based")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"subsetPortfolios\": 0,\n  \"subsetPortfoliosAggregationMethod\": \"\",\n  \"subsetPortfoliosEnumerationMethod\": \"\",\n  \"subsetSize\": 0\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/portfolio/optimization/minimum-variance/subset-resampling-based') do |req|
  req.body = "{\n  \"assets\": 0,\n  \"assetsCovarianceMatrix\": [],\n  \"assetsReturns\": [],\n  \"constraints\": {\n    \"assetsGroups\": [],\n    \"assetsGroupsMatrix\": [],\n    \"maximumAssetsGroupsWeights\": [],\n    \"maximumAssetsWeights\": [],\n    \"maximumPortfolioExposure\": \"\",\n    \"minimumAssetsWeights\": [],\n    \"minimumPortfolioExposure\": \"\"\n  },\n  \"subsetPortfolios\": 0,\n  \"subsetPortfoliosAggregationMethod\": \"\",\n  \"subsetPortfoliosEnumerationMethod\": \"\",\n  \"subsetSize\": 0\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/portfolio/optimization/minimum-variance/subset-resampling-based";

    let payload = json!({
        "assets": 0,
        "assetsCovarianceMatrix": (),
        "assetsReturns": (),
        "constraints": json!({
            "assetsGroups": (),
            "assetsGroupsMatrix": (),
            "maximumAssetsGroupsWeights": (),
            "maximumAssetsWeights": (),
            "maximumPortfolioExposure": "",
            "minimumAssetsWeights": (),
            "minimumPortfolioExposure": ""
        }),
        "subsetPortfolios": 0,
        "subsetPortfoliosAggregationMethod": "",
        "subsetPortfoliosEnumerationMethod": "",
        "subsetSize": 0
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/portfolio/optimization/minimum-variance/subset-resampling-based \
  --header 'content-type: application/json' \
  --data '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  },
  "subsetPortfolios": 0,
  "subsetPortfoliosAggregationMethod": "",
  "subsetPortfoliosEnumerationMethod": "",
  "subsetSize": 0
}'

echo '{
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": {
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  },
  "subsetPortfolios": 0,
  "subsetPortfoliosAggregationMethod": "",
  "subsetPortfoliosEnumerationMethod": "",
  "subsetSize": 0
}' |  \
  http POST {{baseUrl}}/portfolio/optimization/minimum-variance/subset-resampling-based \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "assets": 0,\n  "assetsCovarianceMatrix": [],\n  "assetsReturns": [],\n  "constraints": {\n    "assetsGroups": [],\n    "assetsGroupsMatrix": [],\n    "maximumAssetsGroupsWeights": [],\n    "maximumAssetsWeights": [],\n    "maximumPortfolioExposure": "",\n    "minimumAssetsWeights": [],\n    "minimumPortfolioExposure": ""\n  },\n  "subsetPortfolios": 0,\n  "subsetPortfoliosAggregationMethod": "",\n  "subsetPortfoliosEnumerationMethod": "",\n  "subsetSize": 0\n}' \
  --output-document \
  - {{baseUrl}}/portfolio/optimization/minimum-variance/subset-resampling-based

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "assets": 0,
  "assetsCovarianceMatrix": [],
  "assetsReturns": [],
  "constraints": [
    "assetsGroups": [],
    "assetsGroupsMatrix": [],
    "maximumAssetsGroupsWeights": [],
    "maximumAssetsWeights": [],
    "maximumPortfolioExposure": "",
    "minimumAssetsWeights": [],
    "minimumPortfolioExposure": ""
  ],
  "subsetPortfolios": 0,
  "subsetPortfoliosAggregationMethod": "",
  "subsetPortfoliosEnumerationMethod": "",
  "subsetSize": 0
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/portfolio/optimization/minimum-variance/subset-resampling-based")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "assetsWeights": [
    0.4,
    0.09999999999998999
  ]
}

POST Drift-weight Portfolio Rebalancing

{{baseUrl}}/portfolio/simulation/rebalancing/drift-weight

BODY json

{
  "assets": [
    {
      "assetPrices": []
    }
  ],
  "portfolios": [
    {
      "assetsWeights": []
    }
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/portfolio/simulation/rebalancing/drift-weight");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ],\n  \"portfolios\": [\n    {\n      \"assetsWeights\": []\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/portfolio/simulation/rebalancing/drift-weight" {:content-type :json
                                                                                          :form-params {:assets [{:assetPrices []}]
                                                                                                        :portfolios [{:assetsWeights []}]}})

require "http/client"

url = "{{baseUrl}}/portfolio/simulation/rebalancing/drift-weight"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ],\n  \"portfolios\": [\n    {\n      \"assetsWeights\": []\n    }\n  ]\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/portfolio/simulation/rebalancing/drift-weight"),
    Content = new StringContent("{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ],\n  \"portfolios\": [\n    {\n      \"assetsWeights\": []\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/portfolio/simulation/rebalancing/drift-weight");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ],\n  \"portfolios\": [\n    {\n      \"assetsWeights\": []\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/portfolio/simulation/rebalancing/drift-weight"

	payload := strings.NewReader("{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ],\n  \"portfolios\": [\n    {\n      \"assetsWeights\": []\n    }\n  ]\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/portfolio/simulation/rebalancing/drift-weight HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 118

{
  "assets": [
    {
      "assetPrices": []
    }
  ],
  "portfolios": [
    {
      "assetsWeights": []
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/portfolio/simulation/rebalancing/drift-weight")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ],\n  \"portfolios\": [\n    {\n      \"assetsWeights\": []\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/portfolio/simulation/rebalancing/drift-weight"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ],\n  \"portfolios\": [\n    {\n      \"assetsWeights\": []\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ],\n  \"portfolios\": [\n    {\n      \"assetsWeights\": []\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/portfolio/simulation/rebalancing/drift-weight")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/portfolio/simulation/rebalancing/drift-weight")
  .header("content-type", "application/json")
  .body("{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ],\n  \"portfolios\": [\n    {\n      \"assetsWeights\": []\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  assets: [
    {
      assetPrices: []
    }
  ],
  portfolios: [
    {
      assetsWeights: []
    }
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/portfolio/simulation/rebalancing/drift-weight');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/simulation/rebalancing/drift-weight',
  headers: {'content-type': 'application/json'},
  data: {assets: [{assetPrices: []}], portfolios: [{assetsWeights: []}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/portfolio/simulation/rebalancing/drift-weight';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":[{"assetPrices":[]}],"portfolios":[{"assetsWeights":[]}]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/portfolio/simulation/rebalancing/drift-weight',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "assets": [\n    {\n      "assetPrices": []\n    }\n  ],\n  "portfolios": [\n    {\n      "assetsWeights": []\n    }\n  ]\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ],\n  \"portfolios\": [\n    {\n      \"assetsWeights\": []\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/portfolio/simulation/rebalancing/drift-weight")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/portfolio/simulation/rebalancing/drift-weight',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({assets: [{assetPrices: []}], portfolios: [{assetsWeights: []}]}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/simulation/rebalancing/drift-weight',
  headers: {'content-type': 'application/json'},
  body: {assets: [{assetPrices: []}], portfolios: [{assetsWeights: []}]},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/portfolio/simulation/rebalancing/drift-weight');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  assets: [
    {
      assetPrices: []
    }
  ],
  portfolios: [
    {
      assetsWeights: []
    }
  ]
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/simulation/rebalancing/drift-weight',
  headers: {'content-type': 'application/json'},
  data: {assets: [{assetPrices: []}], portfolios: [{assetsWeights: []}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/portfolio/simulation/rebalancing/drift-weight';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":[{"assetPrices":[]}],"portfolios":[{"assetsWeights":[]}]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"assets": @[ @{ @"assetPrices": @[  ] } ],
                              @"portfolios": @[ @{ @"assetsWeights": @[  ] } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/portfolio/simulation/rebalancing/drift-weight"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/portfolio/simulation/rebalancing/drift-weight" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ],\n  \"portfolios\": [\n    {\n      \"assetsWeights\": []\n    }\n  ]\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/portfolio/simulation/rebalancing/drift-weight",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'assets' => [
        [
                'assetPrices' => [
                                
                ]
        ]
    ],
    'portfolios' => [
        [
                'assetsWeights' => [
                                
                ]
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/portfolio/simulation/rebalancing/drift-weight', [
  'body' => '{
  "assets": [
    {
      "assetPrices": []
    }
  ],
  "portfolios": [
    {
      "assetsWeights": []
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/portfolio/simulation/rebalancing/drift-weight');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'assets' => [
    [
        'assetPrices' => [
                
        ]
    ]
  ],
  'portfolios' => [
    [
        'assetsWeights' => [
                
        ]
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'assets' => [
    [
        'assetPrices' => [
                
        ]
    ]
  ],
  'portfolios' => [
    [
        'assetsWeights' => [
                
        ]
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/portfolio/simulation/rebalancing/drift-weight');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/portfolio/simulation/rebalancing/drift-weight' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": [
    {
      "assetPrices": []
    }
  ],
  "portfolios": [
    {
      "assetsWeights": []
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/portfolio/simulation/rebalancing/drift-weight' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": [
    {
      "assetPrices": []
    }
  ],
  "portfolios": [
    {
      "assetsWeights": []
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ],\n  \"portfolios\": [\n    {\n      \"assetsWeights\": []\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/portfolio/simulation/rebalancing/drift-weight", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/portfolio/simulation/rebalancing/drift-weight"

payload = {
    "assets": [{ "assetPrices": [] }],
    "portfolios": [{ "assetsWeights": [] }]
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/portfolio/simulation/rebalancing/drift-weight"

payload <- "{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ],\n  \"portfolios\": [\n    {\n      \"assetsWeights\": []\n    }\n  ]\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/portfolio/simulation/rebalancing/drift-weight")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ],\n  \"portfolios\": [\n    {\n      \"assetsWeights\": []\n    }\n  ]\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/portfolio/simulation/rebalancing/drift-weight') do |req|
  req.body = "{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ],\n  \"portfolios\": [\n    {\n      \"assetsWeights\": []\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/portfolio/simulation/rebalancing/drift-weight";

    let payload = json!({
        "assets": (json!({"assetPrices": ()})),
        "portfolios": (json!({"assetsWeights": ()}))
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/portfolio/simulation/rebalancing/drift-weight \
  --header 'content-type: application/json' \
  --data '{
  "assets": [
    {
      "assetPrices": []
    }
  ],
  "portfolios": [
    {
      "assetsWeights": []
    }
  ]
}'

echo '{
  "assets": [
    {
      "assetPrices": []
    }
  ],
  "portfolios": [
    {
      "assetsWeights": []
    }
  ]
}' |  \
  http POST {{baseUrl}}/portfolio/simulation/rebalancing/drift-weight \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "assets": [\n    {\n      "assetPrices": []\n    }\n  ],\n  "portfolios": [\n    {\n      "assetsWeights": []\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/portfolio/simulation/rebalancing/drift-weight

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "assets": [["assetPrices": []]],
  "portfolios": [["assetsWeights": []]]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/portfolio/simulation/rebalancing/drift-weight")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "portfolios": [
    {
      "portfolioValues": [
        100,
        105,
        110
      ]
    },
    {
      "portfolioValues": [
        100,
        83.33333333333334,
        75
      ]
    },
    {
      "portfolioValues": [
        100,
        102,
        98
      ]
    }
  ]
}

POST Fixed-weight Portfolio Rebalancing

{{baseUrl}}/portfolio/simulation/rebalancing/fixed-weight

BODY json

{
  "assets": [
    {
      "assetPrices": []
    }
  ],
  "portfolios": [
    {
      "assetsWeights": []
    }
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/portfolio/simulation/rebalancing/fixed-weight");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ],\n  \"portfolios\": [\n    {\n      \"assetsWeights\": []\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/portfolio/simulation/rebalancing/fixed-weight" {:content-type :json
                                                                                          :form-params {:assets [{:assetPrices []}]
                                                                                                        :portfolios [{:assetsWeights []}]}})

require "http/client"

url = "{{baseUrl}}/portfolio/simulation/rebalancing/fixed-weight"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ],\n  \"portfolios\": [\n    {\n      \"assetsWeights\": []\n    }\n  ]\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/portfolio/simulation/rebalancing/fixed-weight"),
    Content = new StringContent("{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ],\n  \"portfolios\": [\n    {\n      \"assetsWeights\": []\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/portfolio/simulation/rebalancing/fixed-weight");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ],\n  \"portfolios\": [\n    {\n      \"assetsWeights\": []\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/portfolio/simulation/rebalancing/fixed-weight"

	payload := strings.NewReader("{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ],\n  \"portfolios\": [\n    {\n      \"assetsWeights\": []\n    }\n  ]\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/portfolio/simulation/rebalancing/fixed-weight HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 118

{
  "assets": [
    {
      "assetPrices": []
    }
  ],
  "portfolios": [
    {
      "assetsWeights": []
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/portfolio/simulation/rebalancing/fixed-weight")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ],\n  \"portfolios\": [\n    {\n      \"assetsWeights\": []\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/portfolio/simulation/rebalancing/fixed-weight"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ],\n  \"portfolios\": [\n    {\n      \"assetsWeights\": []\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ],\n  \"portfolios\": [\n    {\n      \"assetsWeights\": []\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/portfolio/simulation/rebalancing/fixed-weight")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/portfolio/simulation/rebalancing/fixed-weight")
  .header("content-type", "application/json")
  .body("{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ],\n  \"portfolios\": [\n    {\n      \"assetsWeights\": []\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  assets: [
    {
      assetPrices: []
    }
  ],
  portfolios: [
    {
      assetsWeights: []
    }
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/portfolio/simulation/rebalancing/fixed-weight');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/simulation/rebalancing/fixed-weight',
  headers: {'content-type': 'application/json'},
  data: {assets: [{assetPrices: []}], portfolios: [{assetsWeights: []}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/portfolio/simulation/rebalancing/fixed-weight';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":[{"assetPrices":[]}],"portfolios":[{"assetsWeights":[]}]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/portfolio/simulation/rebalancing/fixed-weight',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "assets": [\n    {\n      "assetPrices": []\n    }\n  ],\n  "portfolios": [\n    {\n      "assetsWeights": []\n    }\n  ]\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ],\n  \"portfolios\": [\n    {\n      \"assetsWeights\": []\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/portfolio/simulation/rebalancing/fixed-weight")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/portfolio/simulation/rebalancing/fixed-weight',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({assets: [{assetPrices: []}], portfolios: [{assetsWeights: []}]}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/simulation/rebalancing/fixed-weight',
  headers: {'content-type': 'application/json'},
  body: {assets: [{assetPrices: []}], portfolios: [{assetsWeights: []}]},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/portfolio/simulation/rebalancing/fixed-weight');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  assets: [
    {
      assetPrices: []
    }
  ],
  portfolios: [
    {
      assetsWeights: []
    }
  ]
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/simulation/rebalancing/fixed-weight',
  headers: {'content-type': 'application/json'},
  data: {assets: [{assetPrices: []}], portfolios: [{assetsWeights: []}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/portfolio/simulation/rebalancing/fixed-weight';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":[{"assetPrices":[]}],"portfolios":[{"assetsWeights":[]}]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"assets": @[ @{ @"assetPrices": @[  ] } ],
                              @"portfolios": @[ @{ @"assetsWeights": @[  ] } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/portfolio/simulation/rebalancing/fixed-weight"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/portfolio/simulation/rebalancing/fixed-weight" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ],\n  \"portfolios\": [\n    {\n      \"assetsWeights\": []\n    }\n  ]\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/portfolio/simulation/rebalancing/fixed-weight",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'assets' => [
        [
                'assetPrices' => [
                                
                ]
        ]
    ],
    'portfolios' => [
        [
                'assetsWeights' => [
                                
                ]
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/portfolio/simulation/rebalancing/fixed-weight', [
  'body' => '{
  "assets": [
    {
      "assetPrices": []
    }
  ],
  "portfolios": [
    {
      "assetsWeights": []
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/portfolio/simulation/rebalancing/fixed-weight');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'assets' => [
    [
        'assetPrices' => [
                
        ]
    ]
  ],
  'portfolios' => [
    [
        'assetsWeights' => [
                
        ]
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'assets' => [
    [
        'assetPrices' => [
                
        ]
    ]
  ],
  'portfolios' => [
    [
        'assetsWeights' => [
                
        ]
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/portfolio/simulation/rebalancing/fixed-weight');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/portfolio/simulation/rebalancing/fixed-weight' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": [
    {
      "assetPrices": []
    }
  ],
  "portfolios": [
    {
      "assetsWeights": []
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/portfolio/simulation/rebalancing/fixed-weight' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": [
    {
      "assetPrices": []
    }
  ],
  "portfolios": [
    {
      "assetsWeights": []
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ],\n  \"portfolios\": [\n    {\n      \"assetsWeights\": []\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/portfolio/simulation/rebalancing/fixed-weight", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/portfolio/simulation/rebalancing/fixed-weight"

payload = {
    "assets": [{ "assetPrices": [] }],
    "portfolios": [{ "assetsWeights": [] }]
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/portfolio/simulation/rebalancing/fixed-weight"

payload <- "{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ],\n  \"portfolios\": [\n    {\n      \"assetsWeights\": []\n    }\n  ]\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/portfolio/simulation/rebalancing/fixed-weight")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ],\n  \"portfolios\": [\n    {\n      \"assetsWeights\": []\n    }\n  ]\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/portfolio/simulation/rebalancing/fixed-weight') do |req|
  req.body = "{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ],\n  \"portfolios\": [\n    {\n      \"assetsWeights\": []\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/portfolio/simulation/rebalancing/fixed-weight";

    let payload = json!({
        "assets": (json!({"assetPrices": ()})),
        "portfolios": (json!({"assetsWeights": ()}))
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/portfolio/simulation/rebalancing/fixed-weight \
  --header 'content-type: application/json' \
  --data '{
  "assets": [
    {
      "assetPrices": []
    }
  ],
  "portfolios": [
    {
      "assetsWeights": []
    }
  ]
}'

echo '{
  "assets": [
    {
      "assetPrices": []
    }
  ],
  "portfolios": [
    {
      "assetsWeights": []
    }
  ]
}' |  \
  http POST {{baseUrl}}/portfolio/simulation/rebalancing/fixed-weight \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "assets": [\n    {\n      "assetPrices": []\n    }\n  ],\n  "portfolios": [\n    {\n      "assetsWeights": []\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/portfolio/simulation/rebalancing/fixed-weight

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "assets": [["assetPrices": []]],
  "portfolios": [["assetsWeights": []]]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/portfolio/simulation/rebalancing/fixed-weight")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "portfolios": [
    {
      "portfolioValues": [
        100,
        94.16666666666667,
        91.70039682539684
      ]
    },
    {
      "portfolioValues": [
        100,
        92.66666666666667,
        86.21633986928106
      ]
    },
    {
      "portfolioValues": [
        100,
        103.5,
        103.93487394957984
      ]
    }
  ]
}

POST Random-weight Portfolio Rebalancing

{{baseUrl}}/portfolio/simulation/rebalancing/random-weight

BODY json

{
  "assets": [
    {
      "assetPrices": []
    }
  ],
  "portfolios": 0
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/portfolio/simulation/rebalancing/random-weight");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ],\n  \"portfolios\": 0\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/portfolio/simulation/rebalancing/random-weight" {:content-type :json
                                                                                           :form-params {:assets [{:assetPrices []}]
                                                                                                         :portfolios 0}})

require "http/client"

url = "{{baseUrl}}/portfolio/simulation/rebalancing/random-weight"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ],\n  \"portfolios\": 0\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/portfolio/simulation/rebalancing/random-weight"),
    Content = new StringContent("{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ],\n  \"portfolios\": 0\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/portfolio/simulation/rebalancing/random-weight");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ],\n  \"portfolios\": 0\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/portfolio/simulation/rebalancing/random-weight"

	payload := strings.NewReader("{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ],\n  \"portfolios\": 0\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/portfolio/simulation/rebalancing/random-weight HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 76

{
  "assets": [
    {
      "assetPrices": []
    }
  ],
  "portfolios": 0
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/portfolio/simulation/rebalancing/random-weight")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ],\n  \"portfolios\": 0\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/portfolio/simulation/rebalancing/random-weight"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ],\n  \"portfolios\": 0\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ],\n  \"portfolios\": 0\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/portfolio/simulation/rebalancing/random-weight")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/portfolio/simulation/rebalancing/random-weight")
  .header("content-type", "application/json")
  .body("{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ],\n  \"portfolios\": 0\n}")
  .asString();

const data = JSON.stringify({
  assets: [
    {
      assetPrices: []
    }
  ],
  portfolios: 0
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/portfolio/simulation/rebalancing/random-weight');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/simulation/rebalancing/random-weight',
  headers: {'content-type': 'application/json'},
  data: {assets: [{assetPrices: []}], portfolios: 0}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/portfolio/simulation/rebalancing/random-weight';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":[{"assetPrices":[]}],"portfolios":0}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/portfolio/simulation/rebalancing/random-weight',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "assets": [\n    {\n      "assetPrices": []\n    }\n  ],\n  "portfolios": 0\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ],\n  \"portfolios\": 0\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/portfolio/simulation/rebalancing/random-weight")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/portfolio/simulation/rebalancing/random-weight',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({assets: [{assetPrices: []}], portfolios: 0}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/simulation/rebalancing/random-weight',
  headers: {'content-type': 'application/json'},
  body: {assets: [{assetPrices: []}], portfolios: 0},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/portfolio/simulation/rebalancing/random-weight');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  assets: [
    {
      assetPrices: []
    }
  ],
  portfolios: 0
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portfolio/simulation/rebalancing/random-weight',
  headers: {'content-type': 'application/json'},
  data: {assets: [{assetPrices: []}], portfolios: 0}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/portfolio/simulation/rebalancing/random-weight';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assets":[{"assetPrices":[]}],"portfolios":0}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"assets": @[ @{ @"assetPrices": @[  ] } ],
                              @"portfolios": @0 };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/portfolio/simulation/rebalancing/random-weight"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/portfolio/simulation/rebalancing/random-weight" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ],\n  \"portfolios\": 0\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/portfolio/simulation/rebalancing/random-weight",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'assets' => [
        [
                'assetPrices' => [
                                
                ]
        ]
    ],
    'portfolios' => 0
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/portfolio/simulation/rebalancing/random-weight', [
  'body' => '{
  "assets": [
    {
      "assetPrices": []
    }
  ],
  "portfolios": 0
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/portfolio/simulation/rebalancing/random-weight');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'assets' => [
    [
        'assetPrices' => [
                
        ]
    ]
  ],
  'portfolios' => 0
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'assets' => [
    [
        'assetPrices' => [
                
        ]
    ]
  ],
  'portfolios' => 0
]));
$request->setRequestUrl('{{baseUrl}}/portfolio/simulation/rebalancing/random-weight');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/portfolio/simulation/rebalancing/random-weight' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": [
    {
      "assetPrices": []
    }
  ],
  "portfolios": 0
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/portfolio/simulation/rebalancing/random-weight' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assets": [
    {
      "assetPrices": []
    }
  ],
  "portfolios": 0
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ],\n  \"portfolios\": 0\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/portfolio/simulation/rebalancing/random-weight", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/portfolio/simulation/rebalancing/random-weight"

payload = {
    "assets": [{ "assetPrices": [] }],
    "portfolios": 0
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/portfolio/simulation/rebalancing/random-weight"

payload <- "{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ],\n  \"portfolios\": 0\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/portfolio/simulation/rebalancing/random-weight")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ],\n  \"portfolios\": 0\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/portfolio/simulation/rebalancing/random-weight') do |req|
  req.body = "{\n  \"assets\": [\n    {\n      \"assetPrices\": []\n    }\n  ],\n  \"portfolios\": 0\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/portfolio/simulation/rebalancing/random-weight";

    let payload = json!({
        "assets": (json!({"assetPrices": ()})),
        "portfolios": 0
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/portfolio/simulation/rebalancing/random-weight \
  --header 'content-type: application/json' \
  --data '{
  "assets": [
    {
      "assetPrices": []
    }
  ],
  "portfolios": 0
}'

echo '{
  "assets": [
    {
      "assetPrices": []
    }
  ],
  "portfolios": 0
}' |  \
  http POST {{baseUrl}}/portfolio/simulation/rebalancing/random-weight \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "assets": [\n    {\n      "assetPrices": []\n    }\n  ],\n  "portfolios": 0\n}' \
  --output-document \
  - {{baseUrl}}/portfolio/simulation/rebalancing/random-weight

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "assets": [["assetPrices": []]],
  "portfolios": 0
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/portfolio/simulation/rebalancing/random-weight")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "portfolios": [
    {
      "portfolioValues": [
        100,
        90.8178403620342,
        84.65407625993741
      ]
    },
    {
      "portfolioValues": [
        100,
        102.43258698946813,
        101.32419718013273
      ]
    }
  ]
}