public void TestClassifiers_Success()
{
var listClassifiersResult = ListClassifiers();
string classifierId = null;
if (listClassifiersResult.Classifiers.Count > 0)
{
classifierId = listClassifiersResult.Classifiers[0].ClassifierId;
}
Classification classifyResult = null;
if (!string.IsNullOrEmpty(classifierId))
{
ClassifyInput classifyInput = new ClassifyInput
{
Text = _textToClassify
};
classifyResult = Classify(classifierId, classifyInput);
}
Classifier createClassifierResult = null;
using (FileStream classifierData = File.OpenRead(_classifierDataFilePath), metadata = File.OpenRead(_metadataDataFilePath))
{
createClassifierResult = _service.CreateClassifier(metadata, classifierData);
}
var createdClassifierId = createClassifierResult.ClassifierId;
var getClassifierResult = GetClassifier(createdClassifierId);
if (!string.IsNullOrEmpty(classifierId) && !string.IsNullOrEmpty(createdClassifierId))
{
DeleteClassifier(createdClassifierId);
}
if (!string.IsNullOrEmpty(classifierId))
{
Assert.IsNotNull(classifyResult);
}
Assert.IsNotNull(getClassifierResult);
Assert.IsTrue(createdClassifierId == getClassifierResult.ClassifierId);
Assert.IsNotNull(createClassifierResult);
Assert.IsNotNull(listClassifiersResult);
}
public void CreateClassifier()
{
TokenOptions tokenOptions = new TokenOptions()
{
IamApiKey = apikey,
ServiceUrl = url
};
NaturalLanguageClassifierService service = new NaturalLanguageClassifierService(tokenOptions);
DetailedResponse <Classifier> result = null;
using (FileStream trainingDataFile = File.OpenRead(classifierDataFilePath), metadataFile = File.OpenRead(metadataDataFilePath))
{
using (MemoryStream trainingData = new MemoryStream(), metadata = new MemoryStream())
{
trainingDataFile.CopyTo(trainingData);
metadataFile.CopyTo(metadata);
result = service.CreateClassifier(
metadata: metadata,
trainingData: trainingData
);
}
}
Console.WriteLine(result.Response);
classifierId = result.Result.ClassifierId;
}
public void CreateClassifier()
{
IamConfig config = new IamConfig(
apikey: apikey
);
NaturalLanguageClassifierService service = new NaturalLanguageClassifierService(config);
service.SetEndpoint(url);
DetailedResponse <Classifier> result = null;
using (FileStream trainingDataFile = File.OpenRead(classifierDataFilePath), metadataFile = File.OpenRead(metadataDataFilePath))
{
using (MemoryStream trainingData = new MemoryStream(), metadata = new MemoryStream())
{
trainingDataFile.CopyTo(trainingData);
metadataFile.CopyTo(metadata);
result = service.CreateClassifier(
metadata: metadata,
trainingData: trainingData
);
}
}
Console.WriteLine(result.Response);
classifierId = result.Result.ClassifierId;
}
public void CreateClassifier()
{
IamAuthenticator authenticator = new IamAuthenticator(
apikey: "{apikey}");
NaturalLanguageClassifierService service = new NaturalLanguageClassifierService(authenticator);
service.SetServiceUrl("{serviceUrl}");
DetailedResponse <Classifier> result = null;
using (FileStream trainingDataFile = File.OpenRead("./train.csv"), metadataFile = File.OpenRead("./metadata.json"))
{
using (MemoryStream trainingData = new MemoryStream(), metadata = new MemoryStream())
{
trainingDataFile.CopyTo(trainingData);
metadataFile.CopyTo(metadata);
result = service.CreateClassifier(
trainingMetadata: metadata,
trainingData: trainingData
);
}
}
Console.WriteLine(result.Response);
classifierId = result.Result.ClassifierId;
}
public void CreateClassifier_Success()
{
IClient client = Substitute.For <IClient>();
IRequest request = Substitute.For <IRequest>();
client.PostAsync(Arg.Any <string>())
.Returns(request);
NaturalLanguageClassifierService service = new NaturalLanguageClassifierService(client);
var trainingMetadata = new MemoryStream();
var trainingData = new MemoryStream();
var result = service.CreateClassifier(trainingMetadata: trainingMetadata, trainingData: trainingData);
}
public IEnumerator TestCreateClassifier()
{
Log.Debug("NaturalLanguageClassifierServiceV1IntegrationTests", "Attempting to CreateClassifier...");
Classifier createClassifierResponse = null;
using (FileStream fs0 = File.OpenRead(metadataDataFilePath))
{
using (FileStream fs1 = File.OpenRead(classifierDataFilePath))
{
using (MemoryStream ms0 = new MemoryStream())
{
using (MemoryStream ms1 = new MemoryStream())
{
fs0.CopyTo(ms0);
fs1.CopyTo(ms1);
service.CreateClassifier(
callback: (DetailedResponse <Classifier> response, IBMError error) =>
{
Log.Debug("NaturalLanguageClassifierServiceV1IntegrationTests", "CreateClassifier result: {0}", response.Response);
createClassifierResponse = response.Result;
createdClassifierId = createClassifierResponse.ClassifierId;
Assert.IsNotNull(createClassifierResponse);
Assert.IsNotNull(createdClassifierId);
Assert.IsTrue(createClassifierResponse.Name == "unity-classifier-delete");
Assert.IsTrue(createClassifierResponse.Language == "en");
Assert.IsNull(error);
},
trainingMetadata: ms0,
trainingData: ms1
);
while (createClassifierResponse == null)
{
yield return(null);
}
}
}
}
}
}
public void TestClassifiers_Success()
{
service.WithHeader("X-Watson-Test", "1");
var listClassifiersResult = service.ListClassifiers();
string classifierId = null;
if (listClassifiersResult.Result.Classifiers.Count > 0)
{
classifierId = listClassifiersResult.Result.Classifiers[0].ClassifierId;
}
DetailedResponse <Classification> classifyResult = null;
if (!string.IsNullOrEmpty(classifierId))
{
service.WithHeader("X-Watson-Test", "1");
classifyResult = service.Classify(
classifierId: classifierId,
text: textToClassify1
);
}
DetailedResponse <ClassificationCollection> classifyCollectionResult = null;
if (!string.IsNullOrEmpty(classifierId))
{
var collection = new List <ClassifyInput>()
{
new ClassifyInput()
{
Text = textToClassify0
},
new ClassifyInput()
{
Text = textToClassify1
}
};
service.WithHeader("X-Watson-Test", "1");
classifyCollectionResult = service.ClassifyCollection(
classifierId: classifierId,
collection: collection
);
}
DetailedResponse <Classifier> createClassifierResult = null;
using (FileStream trainingDataFile = File.OpenRead(classifierDataFilePath), metadataFile = File.OpenRead(metadataDataFilePath))
{
using (MemoryStream trainingData = new MemoryStream(), metadata = new MemoryStream())
{
trainingDataFile.CopyTo(trainingData);
metadataFile.CopyTo(metadata);
service.WithHeader("X-Watson-Test", "1");
createClassifierResult = service.CreateClassifier(
trainingMetadata: metadata,
trainingData: trainingData
);
}
}
var createdClassifierId = createClassifierResult.Result.ClassifierId;
service.WithHeader("X-Watson-Test", "1");
var getClassifierResult = service.GetClassifier(
classifierId: createdClassifierId
);
if (!string.IsNullOrEmpty(classifierId) && !string.IsNullOrEmpty(createdClassifierId))
{
service.WithHeader("X-Watson-Test", "1");
service.DeleteClassifier(
classifierId: createdClassifierId
);
}
if (!string.IsNullOrEmpty(classifierId))
{
Assert.IsNotNull(classifyResult);
Assert.IsNotNull(classifyCollectionResult);
}
Assert.IsNotNull(getClassifierResult);
Assert.IsTrue(createdClassifierId == getClassifierResult.Result.ClassifierId);
Assert.IsNotNull(createClassifierResult);
Assert.IsNotNull(listClassifiersResult);
}