add entity recognition for alchemy language #72

Author: germanattanasio

lib/helper.js

@@ -38,6 +38,15 @@ module.exports = {
         missing.push(require);
     });
     return missing.length > 0 ? missing : null;
+  },
+
+  /**
+   * Return true if 'text' is html
+   * @param  {String}  text The 'text' to analyze
+   * @return {Boolean}      true if 'text' has html tags
+   */
+  isHTML: function (text){
+    return /<[a-z][\s\S]*>/i.test(text);
   }
 
 };

lib/index.js

@@ -27,6 +27,16 @@ var omit    = require('object.omit');
 function createServiceAPI(serviceName) {
   return function(user_options) {
     var options = extend({}, user_options);
+    var alchemy = (serviceName.indexOf('alchemy_') === 0);
+
+    // For Alchemy we use 'v1' by default,
+    // and check if `apikey` was specified.
+    // We don't use VCAP_SERVICES
+    if (alchemy) {
+      options.alchemy = true;
+      options.version = 'v1';
+      options.api_key = options.apikey || options.api_key;
+    }
 
     // Check if 'version' was provided
     var version = options.version;
@@ -49,7 +59,10 @@ function createServiceAPI(serviceName) {
       // Check if 'api_key' or 'username' and 'password' were provided
       if (typeof api_key === 'undefined') {
         if (typeof user === 'undefined' || typeof pass === 'undefined') {
-          throw new Error('Argument error: api_key or username and password were not specified');
+          if (alchemy)
+            throw new Error('Argument error: api_key was not specified');
+          else
+            throw new Error('Argument error: api_key or username and password were not specified');
         }
 
         // Calculate and add api_key
@@ -58,7 +71,7 @@ function createServiceAPI(serviceName) {
     }
 
     options = omit(options, ['version', 'username', 'password',
-      'use_vcap_services', 'use_unauthenticated']);
+      'use_vcap_services', 'use_unauthenticated', 'apikey']);
 
     if (options.url)
       options.url = helper.stripTrailingSlash(options.url);
@@ -97,7 +110,10 @@ var watson = {};
   // deprecated
   'language_identification',
   'machine_translation',
-  'user_modeling'
+  'user_modeling',
+
+  // alchemy
+  'alchemy_language'
 
 ].forEach(function(api) {
   watson[api] = createServiceAPI(api);

lib/requestwrapper.js

@@ -100,19 +100,25 @@ function createRequest(parameters, callback) {
   options.url = parsePath(options.url, path);
   delete options.path;
 
-  // Query params
-  if (options.qs && Object.keys(options.qs).length > 0)
-  options.useQuerystring = true;
-
   // Headers
   options.headers = extend({}, options.headers);
   options.headers['User-Agent'] = pkg.name + '-nodejs-'+ pkg.version;
 
   if (typeof(options.api_key) !== 'undefined') {
-    options.headers['Authorization'] = 'Basic ' + options.api_key;
+    // Alchemy uses the apikey(a.k.a api_key) as query parameter
+    if (options.alchemy)
+      options.qs.apikey = options.api_key;
+    else
+      // IBM Watson uses Basic auth
+      options.headers['Authorization'] = 'Basic ' + options.api_key;
     delete options.api_key;
   }
 
+  // Query params
+  if (options.qs && Object.keys(options.qs).length > 0)
+  options.useQuerystring = true;
+
+
   // Add service default endpoint if options.url start with /
   if(options.url.charAt(0) === '/'){
       options.url = parameters.defaultOptions.url + options.url;

services/alchemy_language/v1.js

@@ -0,0 +1,79 @@
+/**
+ * Copyright 2015 IBM Corp. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+'use strict';
+
+var extend         = require('extend');
+var requestFactory = require('../../lib/requestwrapper');
+var pick           = require('object.pick');
+var omit           = require('object.omit');
+var isStream       = require('isstream');
+
+function AlchemyLanguage(options) {
+  // Default URL
+  var serviceDefaults = {
+    url: 'https://access.alchemyapi.com/calls',
+    alchmemy: true
+  };
+
+  this.paths = {
+    text: 'text/TextGetRankedNamedEntities',
+    url: 'url/URLGetRankedNamedEntities',
+    html: 'html/HTMLGetRankedNamedEntities'
+  };
+
+  // Replace default options with user provided
+  this._options = extend(serviceDefaults, options);
+}
+
+/**
+ * Extracts a grouped, ranked list of named entities (people, companies,
+ * organizations, etc.) from within a text, url or html.
+ */
+AlchemyLanguage.prototype.entities = function(_params, callback) {
+  var params = _params || {};
+  var path = null;
+
+  if (typeof(params.text) === 'undefined' &&
+      typeof(params.url)  === 'undefined' &&
+      typeof(params.html) === 'undefined') {
+    callback(new Error('Missing required parameters: either text, ' +
+      'url or html needs to be specified'));
+    return;
+  }
+
+  if (typeof(params.text) !== 'undefined')
+    path = '/text/TextGetRankedNamedEntities';
+  else if (typeof(params.url) !== 'undefined')
+    path = '/url/URLGetRankedNamedEntities';
+  else
+    path = '/url/HTMLGetRankedNamedEntities';
+
+  var parameters = {
+    options: {
+      url: path,
+      method: 'GET',
+      json: true,
+      path: params,
+      qs: extend({outputMode: 'json'}, params) // change default output to json
+    },
+    requiredParams: ['text'],
+    defaultOptions: this._options
+  };
+  return requestFactory(parameters, callback);
+};
+
+module.exports = AlchemyLanguage;

test/test.wrapper.js

@@ -99,6 +99,16 @@ describe('wrapper', function() {
     assert.equal(service._options.api_key, 'dXNlcjpwYXNz');
   });
 
+  it('should use apikey (not documented) for alchemy service', function() {
+    var service = watson.alchemy_language({ apikey: 'not-gonna-work'});
+    assert.equal(service._options.api_key, 'not-gonna-work');
+  });
+
+  it('should use api_key for alchemy service', function() {
+    var service = watson.alchemy_language({ api_key: 'not-gonna-work'});
+    assert.equal(service._options.api_key, 'not-gonna-work');
+  });
+
   it('should not use VCAP_SERVICES if use_vcap_services is false', function() {
     process.env.VCAP_SERVICES = JSON.stringify(vcap_services);
     var service = create_service({