fix(extension-huggingface): change to use axios to send huggingface api to prevent huggingface.js node version issue.

- remove "huggingface" and "node-fetch" library.
- use "axios" to send API request to huggingface.
- support passing "wait_for_model" and "use_cache" options when using "huggingface_table_question_answering" filter.
- update test cases

Author: kokokuo

packages/extension-huggingface/package.json

@@ -22,14 +22,7 @@
     "url": "https://github.com/Canner/vulcan.git"
   },
   "license": "MIT",
-  "dependencies": {
-    "@huggingface/inference": "^2.6.1",
-    "node-fetch": "2"
-  },
   "peerDependencies": {
     "@vulcan-sql/core": "~0.6.0-0"
-  },
-  "devDependencies": {
-    "@types/node-fetch": "^2.6.4"
   }
 }

packages/extension-huggingface/src/index.ts

@@ -1,15 +1,3 @@
-/**
- *
- * References:
- * https://github.com/jestjs/jest/issues/2071#issuecomment-259709487
- * https://nodejs.org/en/blog/release/v16.15.0
- * https://stackoverflow.com/questions/48433783/referenceerror-fetch-is-not-defined
- *
- * In the Node.js 16, fetch API is an experimental function, but huggingface.js need to use fetch API, so import the "node-fetch" package and set it, This is a workaround.
- *  */
-import fetch from 'node-fetch';
-globalThis.fetch = fetch as any;
-
 // Alias the Builder and Runner from the package and export them to prevent Extension loader loading the same Builder and Runner class when creating multiple Functional Filters or Tags.
 import {
   Builder as HuggingFaceTableQuestionAnsweringFilterBuilder,

packages/extension-huggingface/src/lib/tableQuestionAnswering.ts

@@ -3,56 +3,86 @@ import {
   InternalError,
   createFilterExtension,
 } from '@vulcan-sql/core';
-
-import {
-  HuggingFaceOptions,
-  createHuggingFaceInference,
-  convertToHuggingFaceTable,
-} from './utils';
+import axios, { AxiosError } from 'axios';
+import { convertToHuggingFaceTable } from './utils';
 import { isArray } from 'class-validator';
 import { has } from 'lodash';
 
+type HuggingFaceOptions = {
+  accessToken: string;
+};
+
+// More information described the options, see: https://huggingface.co/docs/api-inference/detailed_parameters#table-question-answering-task
 type TableQuestionAnsweringOptions = {
-  model?: string;
   inputs: {
     query: string;
     table: Record<string, string[]>;
   };
+  options: {
+    use_cache: boolean;
+    wait_for_model: boolean;
+  };
+};
+
+const request = async (url: string, data: any, token: string) => {
+  try {
+    const result = await axios.post(url, data, {
+      headers: { Authorization: `Bearer ${token}` },
+    });
+    return result.data;
+  } catch (error) {
+    const axiosError = error as AxiosError;
+    // https://axios-http.com/docs/handling_errors
+    // if response has error, throw the response error, or throw the request error
+    if (axiosError.response)
+      throw new Error(JSON.stringify(axiosError.response?.data));
+    throw new Error(axiosError.message);
+  }
 };
 
+// default recommended model, see https://huggingface.co/docs/api-inference/detailed_parameters#table-question-answering-task
+const getUrl = (model = 'google/tapas-base-finetuned-wtq') =>
+  `https://api-inference.huggingface.co/models/${model}`;
+
 export const TableQuestionAnsweringFilter: FunctionalFilter = async ({
   args,
   value,
   options,
 }) => {
-  const hf = createHuggingFaceInference(options as HuggingFaceOptions);
+  if (!options || !(options as HuggingFaceOptions).accessToken)
+    throw new InternalError('please given access token');
 
   if (!isArray(value))
     throw new InternalError('Input value must be an array of object');
 
   if (!(typeof args === 'object') || !has(args, 'query'))
     throw new InternalError('Must provide "query" keyword argument');
-
   if (!args['query'])
     throw new InternalError('The "query" argument must have value');
 
+  const token = (options as HuggingFaceOptions).accessToken;
   // Convert the data result format to table value format
   const table = convertToHuggingFaceTable(value);
   const context = {
-    // default recommended model, see https://huggingface.co/docs/api-inference/detailed_parameters#table-question-answering-task
-    model: 'google/tapas-base-finetuned-wtq',
     inputs: {
       query: args['query'],
       table,
     },
+    options: {
+      use_cache: args['use_cache'] ? args['use_cache'] : true,
+      wait_for_model: args['wait_for_model'] ? args['wait_for_model'] : false,
+    },
   } as TableQuestionAnsweringOptions;
-  // if model is specified, assign the model provided
-  if (args['model']) context.model = args['model'];
+
+  // Get table question answering url
+  const url = args['model'] ? getUrl(args['model']) : getUrl();
 
   try {
-    const results = await hf.tableQuestionAnswering(context);
+    const results = await request(url, context, token);
     // result format, convert to suitable FunctionalFilter response => https://huggingface.co/docs/api-inference/detailed_parameters#question-answering-task
-    if (results.aggregator === 'NONE') return results.answer;
+    if (!results.aggregator || results.aggregator === 'NONE')
+      // trim the beginning & ending space if model returned answer exist the space, e.g: ' hello world'
+      return (results.answer as string).trim();
     return results.cells.join(', ');
   } catch (error) {
     throw new InternalError(

packages/extension-huggingface/src/lib/utils/factory.ts

@@ -1,2 +1 @@
-export * from './factory';
 export * from './converter';

packages/extension-huggingface/src/lib/utils/index.ts

@@ -1,3 +1,4 @@
+import faker from '@faker-js/faker';
 import { getTestCompiler } from '@vulcan-sql/test-utility';
 import * as dotenv from 'dotenv';
 import * as path from 'path';
@@ -32,53 +33,6 @@ const data = [
   },
 ];
 
-it.each([
-  { question: 'what repository has most stars?', expected: 'vulcan-sql' },
-  { question: 'what repository has lowest stars?', expected: 'hell-word' },
-  {
-    question: 'How many stars does the vulcan-sql repository have?',
-    expected: '1000',
-  },
-  {
-    question: 'How many stars does the accio repository have?',
-    expected: '500',
-  },
-  {
-    question: 'How many repositories related to data-lake topic?',
-    expected: 'vulcan-sql, accio',
-  },
-])(
-  'Should get correct expected $answer when asking $question',
-  async ({ question, expected }) => {
-    // Arrange
-
-    const token = process.env['HF_ACCESS_TOKEN'];
-    const { compileAndLoad, execute, getExecutedQueries, getCreatedBinding } =
-      await getTestCompiler({
-        extensions: { huggingface: path.join(__dirname, '..', 'src') },
-        huggingface: {
-          accessToken: token,
-        },
-      });
-
-    const sql = `{% set data = ${JSON.stringify(
-      data
-    )} %}SELECT {{ data | huggingface_table_question_answering(query="${question}") }}`;
-
-    // Act
-    await compileAndLoad(sql);
-    await execute({});
-
-    // Assert
-    const queries = await getExecutedQueries();
-    const bindings = await getCreatedBinding();
-
-    expect(queries[0]).toBe('SELECT $1');
-    expect(bindings[0].get('$1')).toEqual(expected);
-  },
-  50 * 1000
-);
-
 it(
   'Should throw error when not pass the "query" argument',
   async () => {
@@ -152,27 +106,121 @@ it('Should throw error when input value not be array of object', async () => {
 });
 
 it(
-  'Should throw error when provided model cause the Hugging Face tableQuestionAnswering task failed',
+  'Should throw error when not provide access token',
   async () => {
-    const token = process.env['HF_ACCESS_TOKEN'];
     const { compileAndLoad, execute } = await getTestCompiler({
       extensions: { huggingface: path.join(__dirname, '..', 'src') },
       huggingface: {
-        accessToken: token,
+        accessToken: '',
       },
     });
 
     const sql = `{% set data = ${JSON.stringify(
       data
-    )} %}SELECT {{ data | huggingface_table_question_answering(query="what repository has most stars?", model="neulab/omnitab-large-1024shot-finetuned-wtq-1024shot") }}`;
+    )} %}SELECT {{ data | huggingface_table_question_answering("${faker.internet.password()}") }}`;
 
     // Act
     await compileAndLoad(sql);
 
     // Assert
-    await expect(execute({})).rejects.toThrow(
-      "Error when sending data to Hugging Face for executing TableQuestionAnswering tasks, details: Invalid inference output: Expected {aggregator: string, answer: string, cells: string[], coordinates: number[][]}. Use the 'request' method with the same parameters to do a custom call with no type checking."
-    );
+    await expect(execute({})).rejects.toThrow('please given access token');
+  },
+  50 * 1000
+);
+
+it(
+  'Should throw error when not set hugging face options',
+  async () => {
+    const { compileAndLoad, execute } = await getTestCompiler({
+      extensions: { huggingface: path.join(__dirname, '..', 'src') },
+    });
+
+    const sql = `{% set data = ${JSON.stringify(
+      data
+    )} %}SELECT {{ data | huggingface_table_question_answering("${faker.internet.password()}") }}`;
+
+    // Act
+    await compileAndLoad(sql);
+
+    // Assert
+    await expect(execute({})).rejects.toThrow('please given access token');
+  },
+  50 * 1000
+);
+
+it(
+  'Should get correct expected value when provided "neulab/omnitab-large-1024shot-finetuned-wtq-1024shot" model and wait it for model',
+  async () => {
+    const token = process.env['HF_ACCESS_TOKEN'];
+    const { compileAndLoad, execute, getExecutedQueries, getCreatedBinding } =
+      await getTestCompiler({
+        extensions: { huggingface: path.join(__dirname, '..', 'src') },
+        huggingface: {
+          accessToken: token,
+        },
+      });
+
+    const sql = `{% set data = ${JSON.stringify(
+      data
+    )} %}SELECT {{ data | huggingface_table_question_answering(query="what repository has most stars?", model="neulab/omnitab-large-1024shot-finetuned-wtq-1024shot", wait_for_model=true) }}`;
+
+    // Act
+    await compileAndLoad(sql);
+    await execute({});
+
+    // Assert
+    const queries = await getExecutedQueries();
+    const bindings = await getCreatedBinding();
+
+    expect(queries[0]).toBe('SELECT $1');
+    expect(bindings[0].get('$1')).toEqual('vulcan-sql');
+  },
+  50 * 1000
+);
+
+it.each([
+  { question: 'what repository has most stars?', expected: 'vulcan-sql' },
+  { question: 'what repository has lowest stars?', expected: 'hell-word' },
+  {
+    question: 'How many stars does the vulcan-sql repository have?',
+    expected: '1000',
+  },
+  {
+    question: 'How many stars does the accio repository have?',
+    expected: '500',
+  },
+  {
+    question: 'How many repositories related to data-lake topic?',
+    expected: 'vulcan-sql, accio',
+  },
+])(
+  'Should get correct expected $answer when asking $question',
+  async ({ question, expected }) => {
+    // Arrange
+
+    const token = process.env['HF_ACCESS_TOKEN'];
+    const { compileAndLoad, execute, getExecutedQueries, getCreatedBinding } =
+      await getTestCompiler({
+        extensions: { huggingface: path.join(__dirname, '..', 'src') },
+        huggingface: {
+          accessToken: token,
+        },
+      });
+
+    const sql = `{% set data = ${JSON.stringify(
+      data
+    )} %}SELECT {{ data | huggingface_table_question_answering(query="${question}", wait_for_model=true) }}`;
+
+    // Act
+    await compileAndLoad(sql);
+    await execute({});
+
+    // Assert
+    const queries = await getExecutedQueries();
+    const bindings = await getCreatedBinding();
+
+    expect(queries[0]).toBe('SELECT $1');
+    expect(bindings[0].get('$1')).toEqual(expected);
   },
   50 * 1000
 );