public async Task GetModelVersionResponseShouldBeCorrect()
{
var httpClient = new FkClarifaiHttpClient(
getResponse: @"
{
""status"": {
""code"": 10000,
""description"": ""Ok""
},
""model_version"": {
""id"": ""@versionID"",
""created_at"": ""2017-01-01T00:00:00.000000Z"",
""status"": {
""code"": 21100,
""description"": ""Model trained successfully""
},
""active_concept_count"": 2,
""metrics"": {
""status"": {
""code"": 21303,
""description"": ""@modelDESCRIPTION""
}
},
""total_input_count"": 30
}
}
");
var client = new ClarifaiClient(httpClient);
ClarifaiResponse <ModelVersion> response = await client.GetModelVersion("@modelID", "@versionID").ExecuteAsync();
Assert.True(response.IsSuccessful);
Assert.AreEqual(response.Get().ID, "@versionID");
Assert.AreEqual(response.Get().ActiveConceptCount, 2);
Assert.AreEqual(response.Get().ModelMetricsStatus.Description, "@modelDESCRIPTION");
}
public async Task ModifyConceptRequestAndResponseShouldBeCorrect()
{
var httpClient = new FkClarifaiHttpClient(
patchResponse: @"
{
""status"": {
""code"": 10000,
""description"": ""Ok""
},
""concepts"": [{
""id"": ""@positiveConcept1"",
""name"": ""@positiveConceptName1"",
""created_at"": ""2017-10-15T16:28:28.901994Z"",
""language"": ""en"",
""app_id"": ""@appID""
}, {
""id"": ""@positiveConcept2"",
""created_at"": ""2017-10-15T16:26:46.667104Z"",
""language"": ""en"",
""app_id"": ""@appID""
}]
}
");
var client = new ClarifaiClient(httpClient);
ClarifaiResponse <List <Concept> > response = await client.ModifyConcepts(
new List <Concept>
{
new Concept("@positiveConcept1", "@positiveConceptName1"),
new Concept("@positiveConcept2")
}
).ExecuteAsync();
var expectedRequestBody = JObject.Parse(@"
{
""action"": ""overwrite"",
""concepts"": [
{
""id"": ""@positiveConcept1"",
""name"": ""@positiveConceptName1""
},
{
""id"": ""@positiveConcept2"",
""name"": null
}
]
}
");
Assert.True(JToken.DeepEquals(expectedRequestBody, httpClient.PatchedBody));
Assert.True(response.IsSuccessful);
Assert.AreEqual("Ok", response.Status.Description);
Assert.AreEqual(response.Get()[0].ID, "@positiveConcept1");
Assert.AreEqual(response.Get()[0].Name, "@positiveConceptName1");
Assert.AreEqual(response.Get()[1].ID, "@positiveConcept2");
}
public async Task SearchModelsByNameShouldBeSuccessful()
{
ClarifaiResponse <List <IModel> > response = await Client.SearchModels("celeb*")
.ExecuteAsync();
Assert.NotNull(response.Get());
Assert.True(response.Get().Count > 0);
}
public async Task TrainModelRequestAndResponseShouldBeCorrect()
{
var httpClient = new FkClarifaiHttpClient(
postResponse: @"
{
""status"": {
""code"": 10000,
""description"": ""Ok""
},
""model"": {
""id"": ""some-model-id"",
""name"": ""some-model-name"",
""created_at"": ""2017-05-16T19:20:38.733764Z"",
""app_id"": ""main"",
""output_info"": {
""data"": {
""concepts"": [{
""id"": ""some-concept-id"",
""name"": ""safe"",
""created_at"": ""2017-05-16T19:20:38.450157Z"",
""language"": ""en"",
""app_id"": ""main""
}]
},
""type"": ""concept"",
""type_ext"": ""concept""
},
""model_version"": {
""id"": ""some-model-version-id"",
""created_at"": ""2017-05-16T19:20:38.733764Z"",
""status"": {
""code"": 21100,
""description"": ""Model trained successfully""
},
""active_concept_count"": 5
},
""display_name"": ""Moderation""
}
}
");
var client = new ClarifaiClient(httpClient);
ClarifaiResponse <IModel <Concept> > response = await client.TrainModel <Concept>("some-model-id").ExecuteAsync();
var expectedRequestBody = JObject.Parse(@"
{}
");
Assert.True(JToken.DeepEquals(expectedRequestBody, httpClient.PostedBody));
Assert.True(response.IsSuccessful);
Assert.AreEqual("Ok", response.Status.Description);
Assert.AreEqual(response.Get().Name, "some-model-name");
Assert.AreEqual(response.Get().ModelID, "some-model-id");
Assert.AreEqual(response.Get().ModelVersion.ID, "some-model-version-id");
}
public async Task SearchModelsByTypeShouldBeSuccessful()
{
ClarifaiResponse <List <IModel> > response = await Client.SearchModels("*",
ModelType.Color)
.ExecuteAsync();
AssertResponseSuccess(response);
Assert.NotNull(response.Get());
Assert.True(response.Get().Count > 0);
}
public async Task ModifyConceptRequestShouldUpdateConceptName()
{
string conceptID = "someConceptID";
string originalConceptName = "originalConceptName";
string newConceptName = "newConceptName";
try
{
// Create a concept. It's fine if it already exists.
await Client.AddConcepts(new Concept(conceptID, originalConceptName))
.ExecuteAsync();
// Modify the concept.
ClarifaiResponse <List <Concept> > modifyResponse = await Client.ModifyConcepts(
new Concept(conceptID, newConceptName))
.ExecuteAsync();
Assert.True(modifyResponse.IsSuccessful);
Assert.AreEqual(newConceptName, modifyResponse.Get()[0].Name);
// Get the modified concept again to make sure the name was really updated.
ClarifaiResponse <Concept> getResponse = await Client.GetConcept(conceptID)
.ExecuteAsync();
Assert.AreEqual(newConceptName, getResponse.Get().Name);
}
finally
{
// Revert the concept's name back to the original name.
await Client.ModifyConcepts(new Concept(conceptID, originalConceptName))
.ExecuteAsync();
}
}
public async Task GetConceptsShouldBeSuccessful()
{
ClarifaiResponse <List <Concept> > response = await Client.GetConcepts().ExecuteAsync();
Assert.True(response.IsSuccessful);
Assert.NotNull(response.Get());
}
public async Task ShorthandGetModelInputsShouldBeSuccessful()
{
/*
* Create a model.
*/
string modelID = GenerateRandomID();
ClarifaiResponse <ConceptModel> createModelResponse = await Client.CreateModel(
modelID,
concepts : new List <Concept> {
new Concept("cat")
})
.ExecuteAsync();
Assert.True(createModelResponse.IsSuccessful);
try
{
ConceptModel model = createModelResponse.Get();
var getModelInputsResponse = await model.GetModelInputs().ExecuteAsync();
Assert.True(getModelInputsResponse.IsSuccessful);
Assert.NotNull(getModelInputsResponse.Get());
}
finally
{
/*
* Delete the model.
*/
var deleteResponse = await Client.DeleteModel(modelID)
.ExecuteAsync();
Assert.True(deleteResponse.IsSuccessful);
}
}
public async Task GetInputsStatusResponseShouldBeCorrect()
{
var httpClient = new FkClarifaiHttpClient(
getResponse: @"
{
""status"": {
""code"": 10000,
""description"": ""Ok""
},
""counts"": {
""processed"": 1,
""to_process"": 2,
""errors"": 3,
""processing"": 4,
""reindexed"": 5,
""to_reindex"": 6,
""reindex_errors"": 7,
""reindexing"": 8
}
}
");
var client = new ClarifaiClient(httpClient);
ClarifaiResponse <ClarifaiInputsStatus> response = await client.GetInputsStatus().ExecuteAsync();
var status = (ClarifaiInputsStatus)response.Get();
Assert.True(response.IsSuccessful);
Assert.AreEqual(status.Processed, 1);
Assert.AreEqual(status.ToProcess, 2);
Assert.AreEqual(status.Errors, 3);
Assert.AreEqual(status.Processing, 4);
}
public async Task AddingImageFileWithCropShouldBeSuccessful()
{
string inputID = GenerateRandomID();
try
{
/*
* Add input with concepts.
*/
ClarifaiResponse <List <IClarifaiInput> > addResponse = await Client.AddInputs(
new ClarifaiFileImage(
ReadResource(BALLOONS_IMAGE_FILE),
id : inputID,
crop : new Crop(0.1M, 0.2M, 0.3M, 0.4M)))
.ExecuteAsync();
Assert.True(addResponse.IsSuccessful);
ClarifaiURLImage input = (ClarifaiURLImage)addResponse.Get()[0];
Assert.AreEqual(new Crop(0.1M, 0.2M, 0.3M, 0.4M), input.Crop);
}
finally
{
/*
* Delete the input.
*/
await DeleteInput(inputID);
}
}
public async Task ShorthandDeleteModelVersionRequestShouldBeSuccessful()
{
string modelID = GenerateRandomID();
ClarifaiResponse <ConceptModel> createResponse
= await Client.CreateModel(
modelID,
name : modelID,
concepts : new List <Concept> {
new Concept("dog"), new Concept("cat")
})
.ExecuteAsync();
AssertResponseSuccess(createResponse);
ConceptModel model = createResponse.Get();
ClarifaiResponse <ModelVersion> getVersionResponse =
await Client.GetModelVersion(modelID, model.ModelVersion.ID).ExecuteAsync();
string modelVersionID = getVersionResponse.Get().ID;
ClarifaiResponse <EmptyResponse> deleteVersionResponse =
await model.DeleteModelVersion(modelVersionID).ExecuteAsync();
AssertResponseSuccess(deleteVersionResponse);
/*
* The model version should not exist anymore.
*/
ClarifaiResponse <ModelVersion> getVersionResponse2 =
await Client.GetModelVersion(modelID, modelVersionID).ExecuteAsync();
Assert.False(getVersionResponse2.IsSuccessful);
}
public async Task AddingImageUrlWithCropShouldBeSuccessful()
{
string inputID = GenerateRandomID();
try
{
/*
* Add input with concepts.
*/
ClarifaiResponse <List <IClarifaiInput> > addResponse = await Client.AddInputs(
new ClarifaiURLImage(
CELEB1,
id : inputID,
crop : new Crop(0.1M, 0.2M, 0.3M, 0.4M),
allowDuplicateUrl : true))
.ExecuteAsync();
Assert.True(addResponse.IsSuccessful);
var input = (ClarifaiURLImage)addResponse.Get()[0];
Assert.AreEqual(new Crop(0.1M, 0.2M, 0.3M, 0.4M), input.Crop);
}
finally
{
/*
* Delete the input.
*/
await DeleteInput(inputID);
}
}
public async Task SearchByMetadataShouldBeSuccessful()
{
string randomValue = GenerateRandomID();
ClarifaiResponse <List <IClarifaiInput> > addInputResponse =
await Client.AddInputs(
new ClarifaiURLImage(
CAT1,
positiveConcepts : new List <Concept> {
new Concept("cat")
},
allowDuplicateUrl : true,
metadata : new JObject(
new JProperty("key1", "val1"),
new JProperty("key2", randomValue))))
.ExecuteAsync();
AssertResponseSuccess(addInputResponse);
string inputID = addInputResponse.Get()[0].ID;
try
{
await WaitForSpecificInputsUpload(inputID);
ClarifaiResponse <SearchInputsResult> response =
await Client.SearchInputs(new List <SearchBy>
{
SearchBy.Metadata(new JObject(new JProperty("key2", randomValue)))
})
.ExecuteAsync();
Console.WriteLine(response.RawBody);
AssertResponseSuccess(response);
Assert.NotNull(response.Get().SearchHits);
// Because the value we set is random, there should be exactly one hit.
Assert.AreEqual(1, response.Get().SearchHits.Count);
}
finally
{
ClarifaiResponse <EmptyResponse> deleteInputResponse =
await Client.DeleteInputs(inputID).ExecuteAsync();
AssertResponseSuccess(deleteInputResponse);
}
}
public async Task SearchConceptsShouldBeSuccessful()
{
ClarifaiResponse <List <Concept> > response = await Client.SearchConcepts("conc*")
.ExecuteAsync();
AssertResponseSuccess(response);
Assert.IsNotNull(response.Get());
}
public async Task ShorthandGetModelVersionRequestShouldBeSuccessful()
{
string modelID = Client.PublicModels.ModerationModel.ModelID;
var getModelResponse = await Client.GetModel <Concept>(modelID).ExecuteAsync();
IModel <Concept> model = getModelResponse.Get();
ClarifaiResponse <ModelVersion> response =
await model.GetModelVersion(model.ModelVersion.ID)
.ExecuteAsync();
AssertResponseSuccess(response);
Assert.AreEqual(10000, response.Status.StatusCode);
Assert.AreEqual(HttpStatusCode.OK, response.HttpCode);
Assert.AreEqual(model.ModelVersion.ID, response.Get().ID);
Assert.IsNotNull(response.Get().Status);
}
public async Task SearchByImageUrlShouldBeSuccessful()
{
ClarifaiResponse <SearchInputsResult> response =
await Client.SearchInputs(SearchBy.ImageURL(CELEB1))
.ExecuteAsync();
Assert.True(response.IsSuccessful);
Assert.NotNull(response.Get().SearchHits);
}
public async Task SearchVisuallyByImageUrlUsingImageShouldBeSuccessful()
{
ClarifaiResponse <SearchInputsResult> response =
await Client.SearchInputs(SearchBy.ImageVisually(new ClarifaiURLImage(CELEB1)))
.ExecuteAsync();
AssertResponseSuccess(response);
Assert.NotNull(response.Get().SearchHits);
}
public async Task SearchByUserTaggedConceptIDShouldBeSuccessful()
{
ClarifaiResponse <SearchInputsResult> response =
await Client.SearchInputs(SearchBy.UserTaggedConceptID("cat"))
.ExecuteAsync();
AssertResponseSuccess(response);
Assert.NotNull(response.Get().SearchHits);
}
public async Task SearchConceptsWithLanguageShouldBeSuccessful()
{
ClarifaiResponse <List <Concept> > response = await Client.SearchConcepts("狗*",
language : "zh") // "zh" = Chinese
.ExecuteAsync();
Assert.True(response.IsSuccessful);
Assert.IsNotNull(response.Get());
}
public async Task SearchByConceptIDShouldBeSuccessful()
{
ClarifaiResponse <SearchInputsResult> response =
await Client.SearchInputs(SearchBy.ConceptID("ai_mFqxrph2"))
.ExecuteAsync();
Assert.True(response.IsSuccessful);
Assert.NotNull(response.Get().SearchHits);
}
private async Task <List <Concept> > GetConcepts(string inputID)
{
ClarifaiResponse <IClarifaiInput> getResponse = await Client.GetInput(inputID)
.ExecuteAsync();
AssertResponseSuccess(getResponse);
List <Concept> concepts = getResponse.Get().PositiveConcepts.ToList();
return(concepts);
}
public async Task SearchVisuallyByImageFileShouldBeSuccessful()
{
ClarifaiResponse <SearchInputsResult> response =
await Client.SearchInputs(SearchBy.ImageVisually(
new ClarifaiFileImage(ReadResource(BALLOONS_IMAGE_FILE))))
.ExecuteAsync();
AssertResponseSuccess(response);
Assert.NotNull(response.Get().SearchHits);
}
public async Task SearchVisuallyByImageUrlWithCropShouldBeSuccessful()
{
ClarifaiResponse <SearchInputsResult> response =
await Client.SearchInputs(SearchBy.ImageVisually(
CELEB1,
new Crop(0.1M, 0.2M, 0.3M, 0.4M)))
.ExecuteAsync();
Assert.True(response.IsSuccessful);
Assert.NotNull(response.Get().SearchHits);
}
public async Task SearchVisuallyByImageFileWithCropShouldBeSuccessful()
{
ClarifaiResponse <SearchInputsResult> response =
await Client.SearchInputs(SearchBy.ImageVisually(
new ClarifaiFileImage(ReadResource(BALLOONS_IMAGE_FILE)),
new Crop(0.1M, 0.2M, 0.3M, 0.4M)))
.ExecuteAsync();
Assert.True(response.IsSuccessful);
Assert.NotNull(response.Get().SearchHits);
}
public async Task ShorthandConceptPredictImageShouldBeSuccessful()
{
ClarifaiResponse <ClarifaiOutput <Concept> > response =
await Client.PublicModels.GeneralModel.Predict(new ClarifaiURLImage(CELEB1))
.ExecuteAsync();
Assert.True(response.IsSuccessful);
Assert.AreEqual(10000, response.Status.StatusCode);
Assert.AreEqual(HttpStatusCode.OK, response.HttpCode);
Assert.NotNull(response.RawBody);
Assert.NotNull(response.Get().Data[0]);
}
public async Task GettingModelShouldBeSuccessful()
{
ClarifaiResponse <IModel <Concept> > response =
await Client.GetModel <Concept>(Client.PublicModels.ModerationModel.ModelID)
.ExecuteAsync();
Assert.True(response.IsSuccessful);
Assert.AreEqual(10000, response.Status.StatusCode);
Assert.AreEqual(HttpStatusCode.OK, response.HttpCode);
Assert.NotNull(response.RawBody);
Assert.NotNull(response.Get().ModelID);
}
public async Task GetInputResponseShouldBeCorrect()
{
var httpClient = new FkClarifaiHttpClient(
getResponse: @"
{
""status"": {
""code"": 10000,
""description"": ""Ok""
},
""input"": {
""id"": ""@inputID"",
""data"": {
""image"": {
""url"": ""@imageURL""
},
""concepts"": [
{
""id"": ""@positiveConcept"",
""value"": 1
},
{
""id"": ""@negativeConcept1"",
""value"": 0
},
{
""id"": ""@negativeConcept2"",
""value"": 0
}
]
},
""created_at"": ""2017-10-13T20:53:00.253139Z"",
""modified_at"": ""2017-10-13T20:53:00.868659782Z"",
""status"": {
""code"": 30200,
""description"": ""Input image modification success""
}
}
}
");
var client = new ClarifaiClient(httpClient);
ClarifaiResponse <IClarifaiInput> response = await client.GetInput("@inputID").ExecuteAsync();
var input = (ClarifaiURLImage)response.Get();
Assert.True(response.IsSuccessful);
Assert.AreEqual(input.ID, "@inputID");
Assert.AreEqual(input.URL, "@imageURL");
Assert.AreEqual(input.PositiveConcepts.ElementAt(0).ID, "@positiveConcept");
Assert.AreEqual(input.NegativeConcepts.ElementAt(0).ID, "@negativeConcept1");
Assert.AreEqual(input.NegativeConcepts.ElementAt(1).ID, "@negativeConcept2");
}
public async Task PredictOnEmbeddingModelShouldBeSuccessful()
{
string modelID = Client.PublicModels.GeneralEmbeddingModel.ModelID;
ClarifaiResponse <ClarifaiOutput <Embedding> > predictResponse =
await Client.Predict <Embedding>(
modelID,
new ClarifaiURLImage(CELEB1))
.ExecuteAsync();
AssertResponseSuccess(predictResponse);
Embedding embedding = predictResponse.Get().Data[0];
Assert.NotNull(embedding.Vector);
}
public async Task PredictOnColorModelShouldBeSuccessful()
{
string modelID = Client.PublicModels.ColorModel.ModelID;
ClarifaiResponse <ClarifaiOutput <Color> > predictResponse =
await Client.Predict <Color>(
modelID,
new ClarifaiURLImage(APPAREL1))
.ExecuteAsync();
AssertResponseSuccess(predictResponse);
Color color = predictResponse.Get().Data[0];
Assert.NotNull(color.Name);
}
public async Task GetModelsShouldBeSuccessful()
{
ClarifaiResponse <List <IModel> > response = await Client.GetModels().ExecuteAsync();
List <IModel> models = response.Get();
Assert.IsNotNull(models);
Assert.AreNotEqual(0, models.Count);
foreach (IModel model in models)
{
Assert.IsNotNull(model.Name);
Assert.IsNotNull(model.OutputInfo.Type);
Assert.IsNotNull(model.OutputInfo.TypeExt);
}
}