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 ClassifyCollection()
{
TokenOptions tokenOptions = new TokenOptions()
{
IamApiKey = apikey,
ServiceUrl = url
};
NaturalLanguageClassifierService service = new NaturalLanguageClassifierService(tokenOptions);
var collection = new List <ClassifyInput>()
{
new ClassifyInput()
{
Text = "Will it be hot today?"
},
new ClassifyInput()
{
Text = "Is it raining?"
}
};
var result = service.ClassifyCollection(
classifierId: classifierId,
collection: collection
);
Console.WriteLine(result.Response);
}
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 Setup()
{
if (string.IsNullOrEmpty(credentials))
{
try
{
credentials = Utility.SimpleGet(
Environment.GetEnvironmentVariable("VCAP_URL"),
Environment.GetEnvironmentVariable("VCAP_USERNAME"),
Environment.GetEnvironmentVariable("VCAP_PASSWORD")).Result;
}
catch (Exception e)
{
Console.WriteLine(string.Format("Failed to get credentials: {0}", e.Message));
}
Task.WaitAll();
var vcapServices = JObject.Parse(credentials);
_endpoint = vcapServices["natural_language_classifier"]["url"].Value <string>();
_username = vcapServices["natural_language_classifier"]["username"].Value <string>();
_password = vcapServices["natural_language_classifier"]["password"].Value <string>();
}
_service = new NaturalLanguageClassifierService(_username, _password);
_service.Endpoint = _endpoint;
}
public void Classify_Success()
{
IClient client = Substitute.For <IClient>();
IRequest request = Substitute.For <IRequest>();
client.PostAsync(Arg.Any <string>())
.Returns(request);
NaturalLanguageClassifierService service = new NaturalLanguageClassifierService(client);
var classifierId = "classifierId";
var text = "text";
var result = service.Classify(classifierId: classifierId, text: text);
JObject bodyObject = new JObject();
if (!string.IsNullOrEmpty(text))
{
bodyObject["text"] = JToken.FromObject(text);
}
var json = JsonConvert.SerializeObject(bodyObject);
request.Received().WithBodyContent(Arg.Is <StringContent>(x => x.ReadAsStringAsync().Result.Equals(json)));
client.Received().PostAsync($"{service.ServiceUrl}/v1/classifiers/{classifierId}/classify");
}
public void ClassifyCollection()
{
IamAuthenticator authenticator = new IamAuthenticator(
apikey: "{apikey}");
NaturalLanguageClassifierService service = new NaturalLanguageClassifierService(authenticator);
service.SetServiceUrl("{serviceUrl}");
var collection = new List <ClassifyInput>()
{
new ClassifyInput()
{
Text = "How hot will it be today?"
},
new ClassifyInput()
{
Text = "Is it hot outside?"
}
};
var result = service.ClassifyCollection(
classifierId: "10D41B-nlc-1",
collection: collection
);
Console.WriteLine(result.Response);
}
public void NaturalLanguageClassifierV1WithLoadedCredentials_Success()
{
NaturalLanguageClassifierService service = new NaturalLanguageClassifierService();
Assert.IsTrue(!string.IsNullOrEmpty(service.ApiKey));
Assert.IsTrue(!string.IsNullOrEmpty(service.Url));
}
public async Task <IActionResult> NaturalLanguageClassifierTraining([FromForm] IFormCollection collection)
{
var watch = System.Diagnostics.Stopwatch.StartNew();
string methodName = "NaturalLanguageClassifierTraining";
ResponseDTO response = new ResponseDTO();
try
{
Log.Write(appSettings, LogEnum.DEBUG.ToString(), label, className, methodName, $"REQUEST: {JsonConvert.SerializeObject(collection)}");
var file = collection.Files[0];
response.Result = await Task.Run(() => NaturalLanguageClassifierService.NaturalLanguageClassifierTraining(appSettings, file, collection));
response.Success = true;
watch.Stop();
Log.Write(appSettings, LogEnum.DEBUG.ToString(), label, className, methodName, $"RESULT: {JsonConvert.SerializeObject(response)} Execution Time: {watch.ElapsedMilliseconds} ms");
return(Ok(response));
}
catch (Exception e)
{
response.Success = false;
response.Msg = e.Message;
watch.Stop();
Log.Write(appSettings, LogEnum.ERROR.ToString(), label, className, methodName, $"ERROR: {JsonConvert.SerializeObject(collection)}");
Log.Write(appSettings, LogEnum.ERROR.ToString(), label, className, methodName, $"ERROR: {e.Source + Environment.NewLine + e.Message + Environment.NewLine + e.StackTrace}");
return(BadRequest(response));
}
}
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 ClassifyCollection_Success()
{
IClient client = Substitute.For <IClient>();
IRequest request = Substitute.For <IRequest>();
client.PostAsync(Arg.Any <string>())
.Returns(request);
NaturalLanguageClassifierService service = new NaturalLanguageClassifierService(client);
var classifierId = "classifierId";
var collection = new List <ClassifyInput>();
var result = service.ClassifyCollection(classifierId: classifierId, collection: collection);
JObject bodyObject = new JObject();
if (collection != null && collection.Count > 0)
{
bodyObject["collection"] = JToken.FromObject(collection);
}
var json = JsonConvert.SerializeObject(bodyObject);
request.Received().WithBodyContent(Arg.Is <StringContent>(x => x.ReadAsStringAsync().Result.Equals(json)));
client.Received().PostAsync($"{service.ServiceUrl}/v1/classifiers/{classifierId}/classify_collection");
}
public void ClassifyCollection()
{
IamConfig config = new IamConfig(
apikey: apikey
);
NaturalLanguageClassifierService service = new NaturalLanguageClassifierService(config);
service.SetEndpoint(url);
var collection = new List <ClassifyInput>()
{
new ClassifyInput()
{
Text = "Will it be hot today?"
},
new ClassifyInput()
{
Text = "Is it raining?"
}
};
var result = service.ClassifyCollection(
classifierId: classifierId,
collection: collection
);
Console.WriteLine(result.Response);
}
public void ConstructorExternalConfig()
{
var apikey = System.Environment.GetEnvironmentVariable("NATURAL_LANGUAGE_CLASSIFIER_APIKEY");
System.Environment.SetEnvironmentVariable("NATURAL_LANGUAGE_CLASSIFIER_APIKEY", "apikey");
NaturalLanguageClassifierService service = Substitute.For <NaturalLanguageClassifierService>();
Assert.IsNotNull(service);
System.Environment.SetEnvironmentVariable("NATURAL_LANGUAGE_CLASSIFIER_APIKEY", apikey);
}
public IEnumerator UnityTestSetup()
{
if (service == null)
{
service = new NaturalLanguageClassifierService();
}
while (!service.Authenticator.CanAuthenticate())
{
yield return(null);
}
}
public IEnumerator UnityTestSetup()
{
if (service == null)
{
service = new NaturalLanguageClassifierService();
}
while (!service.Credentials.HasIamTokenData())
{
yield return(null);
}
}
public void ListClassifiers_Success()
{
IClient client = Substitute.For <IClient>();
IRequest request = Substitute.For <IRequest>();
client.GetAsync(Arg.Any <string>())
.Returns(request);
NaturalLanguageClassifierService service = new NaturalLanguageClassifierService(client);
var result = service.ListClassifiers();
}
public async Task <IActionResult> NaturalLanguageClassifier([FromBody] JObject request)
{
var watch = System.Diagnostics.Stopwatch.StartNew();
string methodName = "NaturalLanguageClassifier";
ResponseDTO response = new ResponseDTO();
try
{
Log.Write(appSettings, LogEnum.DEBUG.ToString(), label, className, methodName, $"REQUEST: {JsonConvert.SerializeObject(request)}");
NaturalLanguageClassifierRequest requestBody = request.ToObject <NaturalLanguageClassifierRequest>();
switch (requestBody.Method.ToLower())
{
case "classify":
response.Result = await Task.Run(() => NaturalLanguageClassifierService.NaturalLanguageClassifier(appSettings, requestBody));
break;
case "list":
response.Result = await Task.Run(() => NaturalLanguageClassifierService.NaturalLanguageClassifierList(appSettings, requestBody));
break;
case "detail":
response.Result = await Task.Run(() => NaturalLanguageClassifierService.NaturalLanguageClassifierDetail(appSettings, requestBody));
break;
case "delete":
response.Result = await Task.Run(() => NaturalLanguageClassifierService.NaturalLanguageClassifierDelete(appSettings, requestBody));
break;
default:
break;
}
response.Success = true;
watch.Stop();
Log.Write(appSettings, LogEnum.DEBUG.ToString(), label, className, methodName, $"RESULT: {JsonConvert.SerializeObject(response)} Execution Time: {watch.ElapsedMilliseconds} ms");
return(Ok(response));
}
catch (Exception e)
{
response.Success = false;
response.Msg = e.Message;
watch.Stop();
Log.Write(appSettings, LogEnum.ERROR.ToString(), label, className, methodName, $"ERROR: {JsonConvert.SerializeObject(request)}");
Log.Write(appSettings, LogEnum.ERROR.ToString(), label, className, methodName, $"ERROR: {e.Source + Environment.NewLine + e.Message + Environment.NewLine + e.StackTrace}");
return(BadRequest(response));
}
}
public void ConstructorNoUrl()
{
var apikey = System.Environment.GetEnvironmentVariable("NATURAL_LANGUAGE_CLASSIFIER_APIKEY");
System.Environment.SetEnvironmentVariable("NATURAL_LANGUAGE_CLASSIFIER_APIKEY", "apikey");
var url = System.Environment.GetEnvironmentVariable("NATURAL_LANGUAGE_CLASSIFIER_URL");
System.Environment.SetEnvironmentVariable("NATURAL_LANGUAGE_CLASSIFIER_URL", null);
NaturalLanguageClassifierService service = Substitute.For <NaturalLanguageClassifierService>();
Assert.IsTrue(service.ServiceUrl == "https://gateway.watsonplatform.net/natural-language-classifier/api");
System.Environment.SetEnvironmentVariable("NATURAL_LANGUAGE_CLASSIFIER_URL", url);
System.Environment.SetEnvironmentVariable("NATURAL_LANGUAGE_CLASSIFIER_APIKEY", apikey);
}
public void DeleteClassifier()
{
IamAuthenticator authenticator = new IamAuthenticator(
apikey: "{apikey}");
NaturalLanguageClassifierService service = new NaturalLanguageClassifierService(authenticator);
service.SetServiceUrl("{serviceUrl}");
var result = service.DeleteClassifier(
classifierId: "10D41B-nlc-1"
);
Console.WriteLine(result.Response);
}
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 void DeleteClassifier()
{
IamConfig config = new IamConfig(
apikey: apikey
);
NaturalLanguageClassifierService service = new NaturalLanguageClassifierService(config);
service.SetEndpoint(url);
var result = service.DeleteClassifier(
classifierId: classifierId
);
Console.WriteLine(result.Response);
}
public void DeleteClassifier_Success()
{
IClient client = Substitute.For <IClient>();
IRequest request = Substitute.For <IRequest>();
client.DeleteAsync(Arg.Any <string>())
.Returns(request);
NaturalLanguageClassifierService service = new NaturalLanguageClassifierService(client);
var classifierId = "classifierId";
var result = service.DeleteClassifier(classifierId: classifierId);
client.Received().DeleteAsync($"{service.ServiceUrl}/v1/classifiers/{classifierId}");
}
public void Classify()
{
IamAuthenticator authenticator = new IamAuthenticator(
apikey: "{apikey}");
NaturalLanguageClassifierService service = new NaturalLanguageClassifierService(authenticator);
service.SetServiceUrl("{serviceUrl}");
var result = service.Classify(
classifierId: "10D41B-nlc-1",
text: "How hot will it be today?"
);
Console.WriteLine(result.Response);
}
public void DeleteClassifier()
{
TokenOptions tokenOptions = new TokenOptions()
{
IamApiKey = apikey,
ServiceUrl = url
};
NaturalLanguageClassifierService service = new NaturalLanguageClassifierService(tokenOptions);
var result = service.DeleteClassifier(
classifierId: classifierId
);
Console.WriteLine(result.Response);
}
/**
* @author Ethan Knez
**/
private void ThisAddIn_Startup(object sender, EventArgs e)
{
// For Windows 7 and later
ServicePointManager.Expect100Continue = true;
ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;
// Create and set credentials for both classifiers
_subClassifier = new NaturalLanguageClassifierService();
_subClassifier.SetCredential(subUsername, subPassword);
_bodyClassifier = new NaturalLanguageClassifierService();
_bodyClassifier.SetCredential(bodyUsername, bodyPassword);
EnsureFolderExists("WatsonSpam");
this.Application.NewMail += new Outlook.ApplicationEvents_11_NewMailEventHandler(NewMailMethod);
}
public void Classify()
{
TokenOptions tokenOptions = new TokenOptions()
{
IamApiKey = apikey,
ServiceUrl = url
};
NaturalLanguageClassifierService service = new NaturalLanguageClassifierService(tokenOptions);
var result = service.Classify(
classifierId: classifierId,
text: "Will it be hot today?"
);
Console.WriteLine(result.Response);
}
public void Classify()
{
IamConfig config = new IamConfig(
apikey: apikey
);
NaturalLanguageClassifierService service = new NaturalLanguageClassifierService(config);
service.SetEndpoint(url);
var result = service.Classify(
classifierId: classifierId,
text: "Will it be hot today?"
);
Console.WriteLine(result.Response);
}
public void ListClassifiers()
{
IamAuthenticator authenticator = new IamAuthenticator(
apikey: "{apikey}");
NaturalLanguageClassifierService service = new NaturalLanguageClassifierService(authenticator);
service.SetServiceUrl("{serviceUrl}");
var result = service.ListClassifiers();
Console.WriteLine(result.Response);
if (result.Result.Classifiers != null && result.Result.Classifiers.Count > 0)
{
classifierId = result.Result.Classifiers[0].ClassifierId;
}
}
private IEnumerator CreateService()
{
if (string.IsNullOrEmpty(iamApikey))
{
throw new IBMException("Please add IAM ApiKey to the Iam Apikey field in the inspector.");
}
IamAuthenticator authenticator = new IamAuthenticator(apikey: iamApikey);
while (!authenticator.CanAuthenticate())
{
yield return(null);
}
service = new NaturalLanguageClassifierService(authenticator);
Runnable.Run(ExampleListClassifiers());
}
public void ListClassifiers()
{
IamConfig config = new IamConfig(
apikey: apikey
);
NaturalLanguageClassifierService service = new NaturalLanguageClassifierService(config);
service.SetEndpoint(url);
var result = service.ListClassifiers();
Console.WriteLine(result.Response);
if (result.Result.Classifiers != null && result.Result.Classifiers.Count > 0)
{
classifierId = result.Result.Classifiers[0].ClassifierId;
}
}
public void ListClassifiers()
{
TokenOptions tokenOptions = new TokenOptions()
{
IamApiKey = apikey,
ServiceUrl = url
};
NaturalLanguageClassifierService service = new NaturalLanguageClassifierService(tokenOptions);
var result = service.ListClassifiers();
Console.WriteLine(result.Response);
if (result.Result.Classifiers != null && result.Result.Classifiers.Count > 0)
{
classifierId = result.Result.Classifiers[0].ClassifierId;
}
}