Merge pull request #674 from watson-developer-cloud/new-features

feat(visual recognition & nlc): vr: new coreML endpoint nlc: new classifyCollection endpoint

Author: anweshan

natural-language-classifier/v1-generated.ts

@@ -97,6 +97,49 @@ class NaturalLanguageClassifierV1 extends BaseService {
     return createRequest(parameters, _callback);
   };
 
+  /**
+   * Classify multiple phrases.
+   *
+   * Returns label information for multiple phrases. The status must be `Available` before you can use the classifier to classify text.  Note that classifying Japanese texts is a beta feature.
+   *
+   * @param {Object} params - The parameters to send to the service.
+   * @param {string} params.classifier_id - Classifier ID to use.
+   * @param {ClassifyInput[]} params.collection - The submitted phrases.
+   * @param {Function} [callback] - The callback that handles the response.
+   * @returns {NodeJS.ReadableStream|void}
+   */
+  public classifyCollection(params: NaturalLanguageClassifierV1.ClassifyCollectionParams, callback?: NaturalLanguageClassifierV1.Callback<NaturalLanguageClassifierV1.ClassificationCollection>): NodeJS.ReadableStream | void {
+    const _params = extend({}, params);
+    const _callback = (callback) ? callback : () => { /* noop */ };
+    const requiredParams = ['classifier_id', 'collection'];
+    const missingParams = getMissingParams(_params, requiredParams);
+    if (missingParams) {
+      return _callback(missingParams);
+    }
+    const body = {
+      'collection': _params.collection
+    };
+    const path = {
+      'classifier_id': _params.classifier_id
+    };
+    const parameters = {
+      options: {
+        url: '/v1/classifiers/{classifier_id}/classify_collection',
+        method: 'POST',
+        json: true,
+        body,
+        path,
+      },
+      defaultOptions: extend(true, {}, this._options, {
+        headers: {
+          'Accept': 'application/json',
+          'Content-Type': 'application/json',
+        }
+      })
+    };
+    return createRequest(parameters, _callback);
+  };
+
   /*************************
    * manageClassifiers
    ************************/
@@ -107,8 +150,8 @@ class NaturalLanguageClassifierV1 extends BaseService {
    * Sends data to create and train a classifier and returns information about the new classifier.
    *
    * @param {Object} params - The parameters to send to the service.
-   * @param {NodeJS.ReadableStream|FileObject|Buffer} params.metadata - Metadata in JSON format. The metadata identifies the language of the data, and an optional name to identify the classifier.
-   * @param {NodeJS.ReadableStream|FileObject|Buffer} params.training_data - Training data in CSV format. Each text value must have at least one class. The data can include up to 15,000 records. For details, see [Using your own data](https://console.bluemix.net/docs/services/natural-language-classifier/using-your-data.html).
+   * @param {NodeJS.ReadableStream|FileObject|Buffer} params.metadata - Metadata in JSON format. The metadata identifies the language of the data, and an optional name to identify the classifier. Specify the language with the 2-letter primary language code as assigned in ISO standard 639.  Supported languages are English (`en`), Arabic (`ar`), French (`fr`), German, (`de`), Italian (`it`), Japanese (`ja`), Korean (`ko`), Brazilian Portuguese (`pt`), and Spanish (`es`).
+   * @param {NodeJS.ReadableStream|FileObject|Buffer} params.training_data - Training data in CSV format. Each text value must have at least one class. The data can include up to 20,000 records. For details, see [Data preparation](https://console.bluemix.net/docs/services/natural-language-classifier/using-your-data.html).
    * @param {Function} [callback] - The callback that handles the response.
    * @returns {NodeJS.ReadableStream|void}
    */
@@ -283,11 +326,19 @@ namespace NaturalLanguageClassifierV1 {
     text: string;
   }
 
+  /** Parameters for the `classifyCollection` operation. */
+  export interface ClassifyCollectionParams {
+    /** Classifier ID to use. */
+    classifier_id: string;
+    /** The submitted phrases. */
+    collection: ClassifyInput[];
+  }
+
   /** Parameters for the `createClassifier` operation. */
   export interface CreateClassifierParams {
-    /** Metadata in JSON format. The metadata identifies the language of the data, and an optional name to identify the classifier. */
+    /** Metadata in JSON format. The metadata identifies the language of the data, and an optional name to identify the classifier. Specify the language with the 2-letter primary language code as assigned in ISO standard 639.  Supported languages are English (`en`), Arabic (`ar`), French (`fr`), German, (`de`), Italian (`it`), Japanese (`ja`), Korean (`ko`), Brazilian Portuguese (`pt`), and Spanish (`es`). */
     metadata: NodeJS.ReadableStream|FileObject|Buffer;
-    /** Training data in CSV format. Each text value must have at least one class. The data can include up to 15,000 records. For details, see [Using your own data](https://console.bluemix.net/docs/services/natural-language-classifier/using-your-data.html). */
+    /** Training data in CSV format. Each text value must have at least one class. The data can include up to 20,000 records. For details, see [Data preparation](https://console.bluemix.net/docs/services/natural-language-classifier/using-your-data.html). */
     training_data: NodeJS.ReadableStream|FileObject|Buffer;
   }
 
@@ -325,6 +376,16 @@ namespace NaturalLanguageClassifierV1 {
     classes?: ClassifiedClass[];
   }
 
+  /** Response from the classifier for multiple phrases. */
+  export interface ClassificationCollection {
+    /** Unique identifier for this classifier. */
+    classifier_id?: string;
+    /** Link to the classifier. */
+    url?: string;
+    /** An array of classifier responses for each submitted phrase. */
+    collection?: CollectionItem[];
+  }
+
   /** Class and confidence. */
   export interface ClassifiedClass {
     /** A decimal percentage that represents the confidence that Watson has in this class. Higher values represent higher confidences. */
@@ -357,6 +418,22 @@ namespace NaturalLanguageClassifierV1 {
     classifiers: Classifier[];
   }
 
+  /** Request payload to classify. */
+  export interface ClassifyInput {
+    /** The submitted phrase. */
+    text: string;
+  }
+
+  /** Response from the classifier for a phrase in a collection. */
+  export interface CollectionItem {
+    /** The submitted phrase. */
+    text?: string;
+    /** The class with the highest confidence. */
+    top_class?: string;
+    /** An array of up to ten class-confidence pairs sorted in descending order of confidence. */
+    classes?: ClassifiedClass[];
+  }
+
 }
 
 export = NaturalLanguageClassifierV1;

test/integration/test.natural_language_classifier.js

@@ -0,0 +1,56 @@
+'use strict';
+
+const nock = require('nock');
+const watson = require('../../index');
+const assert = require('assert');
+const authHelper = require('./auth_helper.js');
+const auth = authHelper.auth;
+const describe = authHelper.describe; // this runs describe.skip if there is no auth.js file :)
+const TWENTY_SECONDS = 20000;
+const TWO_SECONDS = 2000;
+
+describe('natural_language_classifier_integration', function() {
+  this.retries(1);
+
+  this.slow(TWO_SECONDS); // this controls when the tests get a colored warning for taking too long
+  this.timeout(TWENTY_SECONDS);
+  let natural_language_classifier;
+
+  before(function() {
+    natural_language_classifier = new watson.NaturalLanguageClassifierV1(
+      auth.natural_language_classifier
+    );
+    nock.enableNetConnect();
+  });
+
+  after(function() {
+    nock.disableNetConnect();
+  });
+
+  it('getClassifier', function(done) {
+    const params = {
+      classifier_id: '842a87x335-nlc-94',
+    };
+    natural_language_classifier.getClassifier(params, function(err, result) {
+      if (err) {
+        return done(err);
+      }
+      assert.equal(result.classifier_id, params.classifier_id);
+      done();
+    });
+  });
+
+  it('classifyCollection', function(done) {
+    const params = {
+      classifier_id: '842a87x335-nlc-94',
+      collection: [{ text: 'string' }],
+    };
+    natural_language_classifier.classifyCollection(params, function(err, result) {
+      if (err) {
+        return done(err);
+      }
+      assert.equal(result.classifier_id, params.classifier_id);
+      done();
+    });
+  });
+});

test/integration/test.visual_recognition.js

@@ -121,7 +121,6 @@ describe('visual_recognition_integration', function() {
         assert.equal(result.images[0].faces.length, 1, 'There should be exactly one face detected'); // note: the api was sometimes failing to detect any faces right after the release
         const face = result.images[0].faces[0];
         assert.equal(face.gender.gender, 'MALE');
-        assert.equal(face.identity.name, 'Barack Obama');
         done();
       });
     });
@@ -147,7 +146,6 @@ describe('visual_recognition_integration', function() {
         assert.equal(result.images[0].faces.length, 1, 'There should be exactly one face detected'); // note: the api was sometimes failing to detect any faces right after the release
         const face = result.images[0].faces[0];
         assert.equal(face.gender.gender, 'MALE');
-        assert.equal(face.identity.name, 'Barack Obama');
         done();
       });
     });

test/unit/test.adapter.natural_language_classifier.v1.js

@@ -5,6 +5,7 @@ const watson = require('../../index');
 const nock = require('nock');
 const fs = require('fs');
 const extend = require('extend');
+const pick = require('object.pick');
 
 const service = {
   username: 'foo',
@@ -72,7 +73,7 @@ const createWithJson = extend(
 );
 
 describe('natural_language_classifer', function() {
-  it('should fail if no parameters are provided for create, classify, status and delete requests', function() {
+  it('should fail if no parameters are provided for create, classify, classifyCollection, status and delete requests', function() {
     natural_language_classifier.classify({}, missingParameter);
     natural_language_classifier.classify(null, missingParameter);
     natural_language_classifier.classify(undefined, missingParameter);
@@ -88,9 +89,13 @@ describe('natural_language_classifer', function() {
     natural_language_classifier.remove({}, missingParameter);
     natural_language_classifier.remove(null, missingParameter);
     natural_language_classifier.remove(undefined, missingParameter);
+
+    natural_language_classifier.classifyCollection({}, missingParameter);
+    natural_language_classifier.classifyCollection(null, missingParameter);
+    natural_language_classifier.classifyCollection(undefined, missingParameter);
   });
 
-  it('should fail if no classifier is provided for classify, status and delete requests', function() {
+  it('should fail if no classifier is provided for classify, status, classifyCollection, and delete requests', function() {
     natural_language_classifier.classify(emptyData, missingParameter);
     natural_language_classifier.classify(emptyClassifier, missingParameter);
     natural_language_classifier.classify(nullClassifier, missingParameter);
@@ -110,6 +115,13 @@ describe('natural_language_classifer', function() {
     natural_language_classifier.remove(undefinedClassifier, missingParameter);
     natural_language_classifier.remove(emptyDataClassifier, missingParameter);
     natural_language_classifier.remove(nullDataClassifier, missingParameter);
+
+    natural_language_classifier.classifyCollection(emptyData, missingParameter);
+    natural_language_classifier.classifyCollection(emptyClassifier, missingParameter);
+    natural_language_classifier.classifyCollection(nullClassifier, missingParameter);
+    natural_language_classifier.classifyCollection(undefinedClassifier, missingParameter);
+    natural_language_classifier.classifyCollection(emptyDataClassifier, missingParameter);
+    natural_language_classifier.classifyCollection(nullDataClassifier, missingParameter);
   });
 
   it('should fail if no data provided create and classify requests', function() {
@@ -159,4 +171,16 @@ describe('natural_language_classifer', function() {
     params.training_data = [{ json: 'bad' }];
     natural_language_classifier.create(params, invalidFormatParameter);
   });
+
+  it('should classify collection', function() {
+    const params = {
+      classifier_id: 'good',
+      collection: { text: 'text' },
+    };
+    const req = natural_language_classifier.classifyCollection(params, goodRequest);
+    const body = Buffer.from(req.body).toString('ascii');
+    assert.deepEqual(JSON.parse(body), pick(params, ['collection']));
+    assert.equal(req.method, 'POST');
+    assert.equal(req.uri.href, 'http://ibm.com:80/v1/classifiers/good/classify_collection');
+  });
 });

test/unit/test.assistant.v1.js

@@ -2,7 +2,6 @@
 
 const assert = require('assert');
 const watson = require('../../index');
-const sinon = require('sinon');
 const nock = require('nock');
 const extend = require('extend');
 const pick = require('object.pick');

test/unit/test.visual_recognition.v3.js

@@ -523,6 +523,25 @@ describe('visual_recognition', function() {
     });
   });
 
+  describe('getCoreMlModel()', function() {
+    it('should check no parameters provided', function() {
+      visual_recognition.getCoreMlModel({}, missingParameter);
+      visual_recognition.getCoreMlModel(null, missingParameter);
+      visual_recognition.getCoreMlModel(undefined, missingParameter);
+    });
+
+    it('should generate a valid payload ', function() {
+      const params = { classifier_id: 'foo' };
+
+      const req = visual_recognition.getCoreMlModel(params, noop);
+      assert.equal(
+        req.uri.href,
+        service.url + '/v3/classifiers/foo/core_ml_model?' + api_key_qs + '&' + version_qs
+      );
+      assert.equal(req.method, 'GET');
+    });
+  });
+
   describe('Print a warning for deprecated methods()', function() {
     let spy;
     beforeEach(function() {