Run History APIs

POST Batch post event data.

{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/batch/events

QUERY PARAMS

experimentName

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/batch/events");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/batch/events")

require "http/client"

url = "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/batch/events"

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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/batch/events"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/batch/events");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/batch/events"

	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/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/batch/events HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/batch/events")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/batch/events"))
    .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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/batch/events")
  .post(null)
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/batch/events")
  .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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/batch/events');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/batch/events'
};

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

const url = '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/batch/events';
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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/batch/events',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/batch/events")
  .post(null)
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/batch/events',
  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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/batch/events'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/batch/events');

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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/batch/events'
};

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

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

const url = '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/batch/events';
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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/batch/events"]
                                                       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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/batch/events" in

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

 "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/batch/events",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/batch/events');

echo $response->getBody();

setUrl('{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/batch/events');
$request->setMethod(HTTP_METH_POST);

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

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

setRequestUrl('{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/batch/events');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/batch/events' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/batch/events' -Method POST

import http.client

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

conn.request("POST", "/baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/batch/events")

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

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

import requests

url = "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/batch/events"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/batch/events"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/batch/events")

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/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/batch/events') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/batch/events";

    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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/batch/events

http POST {{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/batch/events

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/batch/events

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/batch/events")! 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()

POST Post event data.

{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/events

QUERY PARAMS

experimentName

runId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/events");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/events")

require "http/client"

url = "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/events"

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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/events"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/events");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/events"

	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/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/events HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/events")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/events"))
    .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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/events")
  .post(null)
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/events")
  .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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/events');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/events'
};

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

const url = '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/events';
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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/events',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/events")
  .post(null)
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/events',
  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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/events'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/events');

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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/events'
};

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

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

const url = '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/events';
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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/events"]
                                                       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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/events" in

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

 "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/events",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/events');

echo $response->getBody();

setUrl('{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/events');
$request->setMethod(HTTP_METH_POST);

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

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

setRequestUrl('{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/events');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/events' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/events' -Method POST

import http.client

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

conn.request("POST", "/baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/events")

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

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

import requests

url = "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/events"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/events"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/events")

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/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/events') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/events";

    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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/events

http POST {{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/events

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/events

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/events")! 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()

POST Create an Experiment.

{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName

QUERY PARAMS

experimentName

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName")

require "http/client"

url = "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName"

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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName"

	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/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName"))
    .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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName")
  .post(null)
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName")
  .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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName'
};

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

const url = '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName';
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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName")
  .post(null)
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName',
  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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName');

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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName'
};

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

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

const url = '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName';
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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName"]
                                                       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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName" in

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

 "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName');

echo $response->getBody();

setUrl('{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName');
$request->setMethod(HTTP_METH_POST);

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

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

setRequestUrl('{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName' -Method POST

import http.client

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

conn.request("POST", "/baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName")

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

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

import requests

url = "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName")

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/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName";

    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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName

http POST {{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName")! 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()

DELETE Delete list of Tags in an Experiment.

{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId/tags

QUERY PARAMS

experimentId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId/tags");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId/tags")

require "http/client"

url = "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId/tags"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId/tags"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId/tags");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId/tags"

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

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

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

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

}

DELETE /baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId/tags HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId/tags")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId/tags"))
    .method("DELETE", 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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId/tags")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId/tags")
  .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('DELETE', '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId/tags');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId/tags'
};

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

const url = '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId/tags';
const options = {method: 'DELETE'};

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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId/tags',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId/tags")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId/tags',
  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: 'DELETE',
  url: '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId/tags'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId/tags');

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

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

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

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId/tags'
};

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

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

const url = '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId/tags';
const options = {method: 'DELETE'};

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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId/tags"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId/tags" in

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

 "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId/tags",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

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

curl_close($curl);

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

request('DELETE', '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId/tags');

echo $response->getBody();

setUrl('{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId/tags');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId/tags');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId/tags' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId/tags' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId/tags")

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

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

import requests

url = "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId/tags"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId/tags"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId/tags")

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

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

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

require 'faraday'

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

response = conn.delete('/baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId/tags') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId/tags";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

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

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId/tags

http DELETE {{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId/tags

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId/tags

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId/tags")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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()

POST Get all Experiments in a specific workspace.

{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments:query

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments:query");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments:query")

require "http/client"

url = "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments:query"

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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments:query"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments:query");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments:query"

	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/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments:query HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments:query")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments:query"))
    .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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments:query")
  .post(null)
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments:query")
  .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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments:query');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments:query'
};

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

const url = '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments:query';
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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments:query',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments:query")
  .post(null)
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments:query',
  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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments:query'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments:query');

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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments:query'
};

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

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

const url = '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments:query';
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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments:query"]
                                                       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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments:query" in

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

 "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments:query",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments:query');

echo $response->getBody();

setUrl('{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments:query');
$request->setMethod(HTTP_METH_POST);

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

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

setRequestUrl('{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments:query');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments:query' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments:query' -Method POST

import http.client

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

conn.request("POST", "/baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments:query")

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

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

import requests

url = "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments:query"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments:query"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments:query")

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/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments:query') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments:query";

    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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments:query

http POST {{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments:query

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments:query

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments:query")! 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()

GET Get details of an Experiment. (GET)

{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName

QUERY PARAMS

experimentName

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName")

require "http/client"

url = "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName"

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

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

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

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

}

GET /baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName"))
    .method("GET", 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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName")
  .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('GET', '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName'
};

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

const url = '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName';
const options = {method: 'GET'};

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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName',
  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: 'GET',
  url: '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName');

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

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

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

const options = {
  method: 'GET',
  url: '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName'
};

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

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

const url = '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName';
const options = {method: 'GET'};

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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName" in

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

 "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName');

echo $response->getBody();

setUrl('{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName")

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

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

import requests

url = "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName";

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName

http GET {{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()

GET Get details of an Experiment.

{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId

QUERY PARAMS

experimentId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId")

require "http/client"

url = "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId"

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

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

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

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

}

GET /baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId"))
    .method("GET", 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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId")
  .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('GET', '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId'
};

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

const url = '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId';
const options = {method: 'GET'};

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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId',
  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: 'GET',
  url: '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId');

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

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

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

const options = {
  method: 'GET',
  url: '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId'
};

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

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

const url = '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId';
const options = {method: 'GET'};

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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId" in

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

 "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId');

echo $response->getBody();

setUrl('{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId")

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

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

import requests

url = "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId";

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId

http GET {{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()

PATCH Update details of an Experiment.

{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId

QUERY PARAMS

experimentId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/patch "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId")

require "http/client"

url = "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Patch,
    RequestUri = new Uri("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId");
var request = new RestRequest("", Method.Patch);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId"

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

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

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

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

}

PATCH /baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId"))
    .method("PATCH", 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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId")
  .patch(null)
  .build();

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

HttpResponse response = Unirest.patch("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId")
  .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('PATCH', '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId'
};

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

const url = '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId';
const options = {method: 'PATCH'};

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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId',
  method: 'PATCH',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId")
  .patch(null)
  .build()

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

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId',
  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: 'PATCH',
  url: '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId');

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

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

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

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId'
};

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

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

const url = '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId';
const options = {method: 'PATCH'};

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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];

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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId" in

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

 "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
]);

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

curl_close($curl);

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

request('PATCH', '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId');

echo $response->getBody();

setUrl('{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

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

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

setRequestUrl('{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId');
$request->setRequestMethod('PATCH');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId' -Method PATCH

$response = Invoke-RestMethod -Uri '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId' -Method PATCH

import http.client

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

conn.request("PATCH", "/baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId")

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

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

import requests

url = "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId"

response = requests.patch(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId"

response <- VERB("PATCH", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId")

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

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

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

require 'faraday'

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

response = conn.patch('/baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PATCH").unwrap(), url)
        .send()
        .await;

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

    dbg!(results);
}

curl --request PATCH \
  --url {{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId

http PATCH {{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId

wget --quiet \
  --method PATCH \
  --output-document \
  - {{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experimentids/:experimentId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"

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()

PATCH Add or Modify a Run.

{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId

QUERY PARAMS

experimentName

runId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/patch "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId")

require "http/client"

url = "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Patch,
    RequestUri = new Uri("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId");
var request = new RestRequest("", Method.Patch);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId"

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

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

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

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

}

PATCH /baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId"))
    .method("PATCH", 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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId")
  .patch(null)
  .build();

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

HttpResponse response = Unirest.patch("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId")
  .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('PATCH', '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId'
};

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

const url = '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId';
const options = {method: 'PATCH'};

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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId',
  method: 'PATCH',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId")
  .patch(null)
  .build()

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

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId',
  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: 'PATCH',
  url: '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId');

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

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

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

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId'
};

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

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

const url = '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId';
const options = {method: 'PATCH'};

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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];

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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId" in

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

 "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
]);

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

curl_close($curl);

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

request('PATCH', '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId');

echo $response->getBody();

setUrl('{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

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

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

setRequestUrl('{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId');
$request->setRequestMethod('PATCH');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId' -Method PATCH

$response = Invoke-RestMethod -Uri '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId' -Method PATCH

import http.client

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

conn.request("PATCH", "/baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId")

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

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

import requests

url = "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId"

response = requests.patch(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId"

response <- VERB("PATCH", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId")

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

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

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

require 'faraday'

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

response = conn.patch('/baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PATCH").unwrap(), url)
        .send()
        .await;

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

    dbg!(results);
}

curl --request PATCH \
  --url {{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId

http PATCH {{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId

wget --quiet \
  --method PATCH \
  --output-document \
  - {{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"

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()

PATCH Add or Modify a batch of Runs.

{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/batch/runs

QUERY PARAMS

experimentName

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/batch/runs");

CURLcode ret = curl_easy_perform(hnd);

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

(client/patch "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/batch/runs")

require "http/client"

url = "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/batch/runs"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Patch,
    RequestUri = new Uri("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/batch/runs"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/batch/runs");
var request = new RestRequest("", Method.Patch);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/batch/runs"

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

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

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

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

}

PATCH /baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/batch/runs HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/batch/runs")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/batch/runs"))
    .method("PATCH", 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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/batch/runs")
  .patch(null)
  .build();

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

HttpResponse response = Unirest.patch("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/batch/runs")
  .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('PATCH', '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/batch/runs');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/batch/runs'
};

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

const url = '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/batch/runs';
const options = {method: 'PATCH'};

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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/batch/runs',
  method: 'PATCH',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/batch/runs")
  .patch(null)
  .build()

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

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/batch/runs',
  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: 'PATCH',
  url: '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/batch/runs'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/batch/runs');

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

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

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

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/batch/runs'
};

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

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

const url = '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/batch/runs';
const options = {method: 'PATCH'};

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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/batch/runs"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];

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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/batch/runs" in

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

 "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/batch/runs",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
]);

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

curl_close($curl);

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

request('PATCH', '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/batch/runs');

echo $response->getBody();

setUrl('{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/batch/runs');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

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

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

setRequestUrl('{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/batch/runs');
$request->setRequestMethod('PATCH');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/batch/runs' -Method PATCH

$response = Invoke-RestMethod -Uri '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/batch/runs' -Method PATCH

import http.client

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

conn.request("PATCH", "/baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/batch/runs")

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

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

import requests

url = "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/batch/runs"

response = requests.patch(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/batch/runs"

response <- VERB("PATCH", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/batch/runs")

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

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

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

require 'faraday'

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

response = conn.patch('/baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/batch/runs') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/batch/runs";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PATCH").unwrap(), url)
        .send()
        .await;

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

    dbg!(results);
}

curl --request PATCH \
  --url {{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/batch/runs

http PATCH {{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/batch/runs

wget --quiet \
  --method PATCH \
  --output-document \
  - {{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/batch/runs

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/batch/runs")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"

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()

DELETE Delete list of Tags in a Run.

QUERY PARAMS

experimentName

runId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/tags");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/tags")

require "http/client"

url = "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/tags"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/tags"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/tags");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/tags"

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

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

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

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

}

DELETE /baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/tags HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/tags")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/tags"))
    .method("DELETE", 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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/tags")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/tags")
  .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('DELETE', '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/tags');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/tags'
};

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

const url = '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/tags';
const options = {method: 'DELETE'};

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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/tags',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/tags")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/tags',
  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: 'DELETE',
  url: '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/tags'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/tags');

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

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

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

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/tags'
};

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

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

const url = '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/tags';
const options = {method: 'DELETE'};

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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/tags"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/tags" in

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

 "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/tags",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

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

curl_close($curl);

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

request('DELETE', '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/tags');

echo $response->getBody();

setUrl('{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/tags');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/tags');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/tags' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/tags' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/tags")

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

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

import requests

url = "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/tags"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/tags"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/tags")

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

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

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

require 'faraday'

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

response = conn.delete('/baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/tags') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/tags";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

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

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/tags

http DELETE {{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/tags

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/tags

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/tags")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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()

GET Get Run Details.

QUERY PARAMS

experimentName

runId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/details");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/details")

require "http/client"

url = "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/details"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/details"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/details");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/details"

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

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

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

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

}

GET /baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/details HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/details")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/details"))
    .method("GET", 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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/details")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/details")
  .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('GET', '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/details');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/details'
};

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

const url = '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/details';
const options = {method: 'GET'};

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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/details',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/details")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/details',
  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: 'GET',
  url: '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/details'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/details');

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

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

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

const options = {
  method: 'GET',
  url: '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/details'
};

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

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

const url = '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/details';
const options = {method: 'GET'};

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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/details"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/details" in

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

 "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/details",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/details');

echo $response->getBody();

setUrl('{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/details');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/details');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/details' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/details' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/details")

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

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

import requests

url = "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/details"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/details"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/details")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/details') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/details";

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/details

http GET {{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/details

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/details

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/details")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()

GET Get Run details.

{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId

QUERY PARAMS

experimentName

runId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId")

require "http/client"

url = "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId"

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

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

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

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

}

GET /baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId"))
    .method("GET", 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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId")
  .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('GET', '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId'
};

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

const url = '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId';
const options = {method: 'GET'};

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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId',
  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: 'GET',
  url: '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId');

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

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

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

const options = {
  method: 'GET',
  url: '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId'
};

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

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

const url = '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId';
const options = {method: 'GET'};

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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId" in

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

 "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId');

echo $response->getBody();

setUrl('{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId")

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

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

import requests

url = "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId";

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId

http GET {{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()

POST Get all Runs for a specific Experiment.

{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs:query

QUERY PARAMS

experimentName

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs:query");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs:query")

require "http/client"

url = "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs:query"

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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs:query"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs:query");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs:query"

	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/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs:query HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs:query")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs:query"))
    .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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs:query")
  .post(null)
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs:query")
  .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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs:query');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs:query'
};

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

const url = '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs:query';
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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs:query',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs:query")
  .post(null)
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs:query',
  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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs:query'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs:query');

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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs:query'
};

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

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

const url = '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs:query';
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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs:query"]
                                                       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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs:query" in

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

 "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs:query",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs:query');

echo $response->getBody();

setUrl('{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs:query');
$request->setMethod(HTTP_METH_POST);

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

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

setRequestUrl('{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs:query');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs:query' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs:query' -Method POST

import http.client

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

conn.request("POST", "/baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs:query")

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

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

import requests

url = "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs:query"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs:query"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs:query")

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/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs:query') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs:query";

    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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs:query

http POST {{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs:query

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs:query

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs:query")! 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()

GET Get details of all child runs.

QUERY PARAMS

experimentName

runId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/children");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/children")

require "http/client"

url = "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/children"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/children"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/children");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/children"

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

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

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

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

}

GET /baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/children HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/children")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/children"))
    .method("GET", 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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/children")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/children")
  .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('GET', '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/children');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/children'
};

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

const url = '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/children';
const options = {method: 'GET'};

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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/children',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/children")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/children',
  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: 'GET',
  url: '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/children'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/children');

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

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

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

const options = {
  method: 'GET',
  url: '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/children'
};

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

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

const url = '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/children';
const options = {method: 'GET'};

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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/children"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/children" in

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

 "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/children",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/children');

echo $response->getBody();

setUrl('{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/children');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/children');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/children' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/children' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/children")

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

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

import requests

url = "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/children"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/children"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/children")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/children') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/children";

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/children

http GET {{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/children

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/children

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/children")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()

POST Create a batch of empty Artifacts.

QUERY PARAMS

experimentName

runId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/batch/metadata");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/batch/metadata")

require "http/client"

url = "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/batch/metadata"

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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/batch/metadata"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/batch/metadata");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/batch/metadata"

	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/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/batch/metadata HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/batch/metadata")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/batch/metadata"))
    .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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/batch/metadata")
  .post(null)
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/batch/metadata")
  .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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/batch/metadata');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/batch/metadata'
};

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

const url = '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/batch/metadata';
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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/batch/metadata',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/batch/metadata")
  .post(null)
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/batch/metadata',
  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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/batch/metadata'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/batch/metadata');

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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/batch/metadata'
};

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

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

const url = '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/batch/metadata';
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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/batch/metadata"]
                                                       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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/batch/metadata" in

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

 "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/batch/metadata",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/batch/metadata');

echo $response->getBody();

setUrl('{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/batch/metadata');
$request->setMethod(HTTP_METH_POST);

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

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

setRequestUrl('{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/batch/metadata');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/batch/metadata' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/batch/metadata' -Method POST

import http.client

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

conn.request("POST", "/baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/batch/metadata")

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

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

import requests

url = "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/batch/metadata"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/batch/metadata"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/batch/metadata")

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/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/batch/metadata') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/batch/metadata";

    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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/batch/metadata

http POST {{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/batch/metadata

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/batch/metadata

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/batch/metadata")! 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()

GET Get Artifact by Id.

QUERY PARAMS

experimentName

runId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/metadata");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/metadata")

require "http/client"

url = "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/metadata"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/metadata"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/metadata");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/metadata"

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

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

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

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

}

GET /baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/metadata HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/metadata")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/metadata"))
    .method("GET", 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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/metadata")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/metadata")
  .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('GET', '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/metadata');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/metadata'
};

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

const url = '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/metadata';
const options = {method: 'GET'};

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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/metadata',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/metadata")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/metadata',
  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: 'GET',
  url: '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/metadata'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/metadata');

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

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

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

const options = {
  method: 'GET',
  url: '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/metadata'
};

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

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

const url = '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/metadata';
const options = {method: 'GET'};

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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/metadata"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/metadata" in

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

 "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/metadata",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/metadata');

echo $response->getBody();

setUrl('{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/metadata');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/metadata');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/metadata' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/metadata' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/metadata")

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

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

import requests

url = "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/metadata"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/metadata"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/metadata")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/metadata') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/metadata";

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/metadata

http GET {{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/metadata

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/metadata

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/metadata")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()

GET Get Artifact content information.

QUERY PARAMS

experimentName

runId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/contentinfo");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/contentinfo")

require "http/client"

url = "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/contentinfo"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/contentinfo"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/contentinfo");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/contentinfo"

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

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

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

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

}

GET /baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/contentinfo HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/contentinfo")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/contentinfo"))
    .method("GET", 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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/contentinfo")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/contentinfo")
  .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('GET', '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/contentinfo');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/contentinfo'
};

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

const url = '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/contentinfo';
const options = {method: 'GET'};

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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/contentinfo',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/contentinfo")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/contentinfo',
  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: 'GET',
  url: '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/contentinfo'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/contentinfo');

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

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

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

const options = {
  method: 'GET',
  url: '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/contentinfo'
};

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

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

const url = '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/contentinfo';
const options = {method: 'GET'};

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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/contentinfo"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/contentinfo" in

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

 "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/contentinfo",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/contentinfo');

echo $response->getBody();

setUrl('{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/contentinfo');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/contentinfo');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/contentinfo' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/contentinfo' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/contentinfo")

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

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

import requests

url = "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/contentinfo"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/contentinfo"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/contentinfo")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/contentinfo') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/contentinfo";

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/contentinfo

http GET {{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/contentinfo

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/contentinfo

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/contentinfo")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()

GET Get Artifacts in a container.

QUERY PARAMS

experimentName

runId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts")

require "http/client"

url = "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts"

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

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

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

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

}

GET /baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts"))
    .method("GET", 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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts")
  .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('GET', '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts'
};

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

const url = '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts';
const options = {method: 'GET'};

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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts',
  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: 'GET',
  url: '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts');

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

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

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

const options = {
  method: 'GET',
  url: '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts'
};

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

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

const url = '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts';
const options = {method: 'GET'};

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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts" in

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

 "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts');

echo $response->getBody();

setUrl('{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts")

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

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

import requests

url = "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts";

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts

http GET {{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()

GET Get Artifacts in the provided path.

QUERY PARAMS

experimentName

runId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/path");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/path")

require "http/client"

url = "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/path"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/path"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/path");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/path"

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

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

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

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

}

GET /baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/path HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/path")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/path"))
    .method("GET", 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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/path")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/path")
  .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('GET', '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/path');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/path'
};

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

const url = '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/path';
const options = {method: 'GET'};

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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/path',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/path")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/path',
  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: 'GET',
  url: '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/path'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/path');

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

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

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

const options = {
  method: 'GET',
  url: '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/path'
};

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

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

const url = '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/path';
const options = {method: 'GET'};

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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/path"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/path" in

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

 "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/path",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/path');

echo $response->getBody();

setUrl('{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/path');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/path');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/path' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/path' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/path")

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

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

import requests

url = "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/path"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/path"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/path")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/path') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/path";

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/path

http GET {{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/path

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/path

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/path")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()

GET Get SAS of an Artifact.

QUERY PARAMS

experimentName

runId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/prefix/contentinfo");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/prefix/contentinfo")

require "http/client"

url = "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/prefix/contentinfo"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/prefix/contentinfo"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/prefix/contentinfo");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/prefix/contentinfo"

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

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

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

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

}

GET /baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/prefix/contentinfo HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/prefix/contentinfo")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/prefix/contentinfo"))
    .method("GET", 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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/prefix/contentinfo")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/prefix/contentinfo")
  .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('GET', '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/prefix/contentinfo');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/prefix/contentinfo'
};

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

const url = '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/prefix/contentinfo';
const options = {method: 'GET'};

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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/prefix/contentinfo',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/prefix/contentinfo")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/prefix/contentinfo',
  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: 'GET',
  url: '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/prefix/contentinfo'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/prefix/contentinfo');

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

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

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

const options = {
  method: 'GET',
  url: '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/prefix/contentinfo'
};

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

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

const url = '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/prefix/contentinfo';
const options = {method: 'GET'};

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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/prefix/contentinfo"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/prefix/contentinfo" in

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

 "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/prefix/contentinfo",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/prefix/contentinfo');

echo $response->getBody();

setUrl('{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/prefix/contentinfo');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/prefix/contentinfo');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/prefix/contentinfo' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/prefix/contentinfo' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/prefix/contentinfo")

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

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

import requests

url = "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/prefix/contentinfo"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/prefix/contentinfo"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/prefix/contentinfo")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/prefix/contentinfo') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/prefix/contentinfo";

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/prefix/contentinfo

http GET {{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/prefix/contentinfo

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/prefix/contentinfo

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/prefix/contentinfo")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()

GET Get URI of an Artifact.

QUERY PARAMS

experimentName

runId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/artifacturi");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/artifacturi")

require "http/client"

url = "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/artifacturi"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/artifacturi"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/artifacturi");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/artifacturi"

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

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

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

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

}

GET /baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/artifacturi HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/artifacturi")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/artifacturi"))
    .method("GET", 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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/artifacturi")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/artifacturi")
  .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('GET', '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/artifacturi');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/artifacturi'
};

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

const url = '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/artifacturi';
const options = {method: 'GET'};

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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/artifacturi',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/artifacturi")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/artifacturi',
  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: 'GET',
  url: '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/artifacturi'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/artifacturi');

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

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

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

const options = {
  method: 'GET',
  url: '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/artifacturi'
};

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

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

const url = '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/artifacturi';
const options = {method: 'GET'};

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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/artifacturi"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/artifacturi" in

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

 "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/artifacturi",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/artifacturi');

echo $response->getBody();

setUrl('{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/artifacturi');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/artifacturi');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/artifacturi' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/artifacturi' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/artifacturi")

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

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

import requests

url = "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/artifacturi"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/artifacturi"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/artifacturi")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/artifacturi') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/artifacturi";

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/artifacturi

http GET {{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/artifacturi

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/artifacturi

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/artifacts/artifacturi")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()

GET Get Metric details.

QUERY PARAMS

experimentName

metricId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/metrics/:metricId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/metrics/:metricId")

require "http/client"

url = "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/metrics/:metricId"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/metrics/:metricId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/metrics/:metricId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/metrics/:metricId"

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

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

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

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

}

GET /baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/metrics/:metricId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/metrics/:metricId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/metrics/:metricId"))
    .method("GET", 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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/metrics/:metricId")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/metrics/:metricId")
  .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('GET', '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/metrics/:metricId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/metrics/:metricId'
};

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

const url = '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/metrics/:metricId';
const options = {method: 'GET'};

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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/metrics/:metricId',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/metrics/:metricId")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/metrics/:metricId',
  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: 'GET',
  url: '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/metrics/:metricId'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/metrics/:metricId');

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

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

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

const options = {
  method: 'GET',
  url: '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/metrics/:metricId'
};

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

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

const url = '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/metrics/:metricId';
const options = {method: 'GET'};

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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/metrics/:metricId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/metrics/:metricId" in

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

 "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/metrics/:metricId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/metrics/:metricId');

echo $response->getBody();

setUrl('{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/metrics/:metricId');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/metrics/:metricId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/metrics/:metricId' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/metrics/:metricId' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/metrics/:metricId")

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

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

import requests

url = "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/metrics/:metricId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/metrics/:metricId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/metrics/:metricId")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/metrics/:metricId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/metrics/:metricId";

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/metrics/:metricId

http GET {{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/metrics/:metricId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/metrics/:metricId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/metrics/:metricId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()

POST Get all Run Metrics for the specific Experiment.

QUERY PARAMS

experimentName

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/metrics:query");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/metrics:query")

require "http/client"

url = "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/metrics:query"

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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/metrics:query"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/metrics:query");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/metrics:query"

	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/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/metrics:query HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/metrics:query")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/metrics:query"))
    .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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/metrics:query")
  .post(null)
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/metrics:query")
  .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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/metrics:query');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/metrics:query'
};

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

const url = '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/metrics:query';
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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/metrics:query',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/metrics:query")
  .post(null)
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/metrics:query',
  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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/metrics:query'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/metrics:query');

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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/metrics:query'
};

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

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

const url = '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/metrics:query';
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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/metrics:query"]
                                                       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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/metrics:query" in

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

 "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/metrics:query",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/metrics:query');

echo $response->getBody();

setUrl('{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/metrics:query');
$request->setMethod(HTTP_METH_POST);

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

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

setRequestUrl('{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/metrics:query');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/metrics:query' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/metrics:query' -Method POST

import http.client

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

conn.request("POST", "/baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/metrics:query")

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

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

import requests

url = "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/metrics:query"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/metrics:query"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/metrics:query")

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/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/metrics:query') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/metrics:query";

    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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/metrics:query

http POST {{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/metrics:query

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/metrics:query

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/metrics:query")! 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()

POST Post Metric to a Run.

QUERY PARAMS

experimentName

runId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/metrics");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/metrics")

require "http/client"

url = "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/metrics"

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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/metrics"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/metrics");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/metrics"

	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/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/metrics HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/metrics")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/metrics"))
    .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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/metrics")
  .post(null)
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/metrics")
  .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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/metrics');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/metrics'
};

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

const url = '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/metrics';
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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/metrics',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/metrics")
  .post(null)
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/metrics',
  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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/metrics'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/metrics');

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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/metrics'
};

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

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

const url = '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/metrics';
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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/metrics"]
                                                       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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/metrics" in

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

 "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/metrics",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/metrics');

echo $response->getBody();

setUrl('{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/metrics');
$request->setMethod(HTTP_METH_POST);

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

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

setRequestUrl('{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/metrics');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/metrics' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/metrics' -Method POST

import http.client

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

conn.request("POST", "/baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/metrics")

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

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

import requests

url = "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/metrics"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/metrics"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/metrics")

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/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/metrics') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/metrics";

    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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/metrics

http POST {{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/metrics

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/metrics

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/metrics")! 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()

POST Post Metrics to a Run.

QUERY PARAMS

experimentName

runId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/batch/metrics");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/batch/metrics")

require "http/client"

url = "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/batch/metrics"

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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/batch/metrics"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/batch/metrics");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/batch/metrics"

	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/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/batch/metrics HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/batch/metrics")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/batch/metrics"))
    .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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/batch/metrics")
  .post(null)
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/batch/metrics")
  .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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/batch/metrics');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/batch/metrics'
};

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

const url = '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/batch/metrics';
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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/batch/metrics',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/batch/metrics")
  .post(null)
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/batch/metrics',
  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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/batch/metrics'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/batch/metrics');

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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/batch/metrics'
};

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

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

const url = '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/batch/metrics';
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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/batch/metrics"]
                                                       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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/batch/metrics" in

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

 "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/batch/metrics",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/batch/metrics');

echo $response->getBody();

setUrl('{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/batch/metrics');
$request->setMethod(HTTP_METH_POST);

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

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

setRequestUrl('{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/batch/metrics');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/batch/metrics' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/batch/metrics' -Method POST

import http.client

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

conn.request("POST", "/baseUrl/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/batch/metrics")

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

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

import requests

url = "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/batch/metrics"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/batch/metrics"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/batch/metrics")

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/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/batch/metrics') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/batch/metrics";

    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}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/batch/metrics

http POST {{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/batch/metrics

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/batch/metrics

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/history/v1.0/subscriptions/:subscriptionId/resourceGroups/:resourceGroupName/providers/Microsoft.MachineLearningServices/workspaces/:workspaceName/experiments/:experimentName/runs/:runId/batch/metrics")! 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()