@huggingface/tasks 0.13.1-test → 0.13.1-test2

package/src/snippets/js.ts

@@ -0,0 +1,305 @@
+import type { PipelineType } from "../pipelines.js";
+import type { ChatCompletionInputMessage, GenerationParameters } from "../tasks/index.js";
+import { stringifyGenerationConfig, stringifyMessages } from "./common.js";
+import { getModelInputSnippet } from "./inputs.js";
+import type { InferenceSnippet, ModelDataMinimal } from "./types.js";
+
+export const snippetBasic = (model: ModelDataMinimal, accessToken: string): InferenceSnippet => ({
+	content: `async function query(data) {
+	const response = await fetch(
+		"https://api-inference.huggingface.co/models/${model.id}",
+		{
+			headers: {
+				Authorization: "Bearer ${accessToken || `{API_TOKEN}`}"
+				"Content-Type": "application/json",
+			},
+			method: "POST",
+			body: JSON.stringify(data),
+		}
+	);
+	const result = await response.json();
+	return result;
+}
+
+query({"inputs": ${getModelInputSnippet(model)}}).then((response) => {
+	console.log(JSON.stringify(response));
+});`,
+});
+
+export const snippetTextGeneration = (
+	model: ModelDataMinimal,
+	accessToken: string,
+	opts?: {
+		streaming?: boolean;
+		messages?: ChatCompletionInputMessage[];
+		temperature?: GenerationParameters["temperature"];
+		max_tokens?: GenerationParameters["max_tokens"];
+		top_p?: GenerationParameters["top_p"];
+	}
+): InferenceSnippet | InferenceSnippet[] => {
+	if (model.tags.includes("conversational")) {
+		// Conversational model detected, so we display a code snippet that features the Messages API
+		const streaming = opts?.streaming ?? true;
+		const exampleMessages = getModelInputSnippet(model) as ChatCompletionInputMessage[];
+		const messages = opts?.messages ?? exampleMessages;
+		const messagesStr = stringifyMessages(messages, { indent: "\t" });
+
+		const config = {
+			...(opts?.temperature ? { temperature: opts.temperature } : undefined),
+			max_tokens: opts?.max_tokens ?? 500,
+			...(opts?.top_p ? { top_p: opts.top_p } : undefined),
+		};
+		const configStr = stringifyGenerationConfig(config, {
+			indent: "\n\t",
+			attributeValueConnector: ": ",
+		});
+
+		if (streaming) {
+			return [
+				{
+					client: "huggingface.js",
+					content: `import { HfInference } from "@huggingface/inference"
+
+const client = new HfInference("${accessToken || `{API_TOKEN}`}")
+
+let out = "";
+
+const stream = client.chatCompletionStream({
+	model: "${model.id}",
+	messages: ${messagesStr},
+	${configStr}
+});
+
+for await (const chunk of stream) {
+	if (chunk.choices && chunk.choices.length > 0) {
+		const newContent = chunk.choices[0].delta.content;
+		out += newContent;
+		console.log(newContent);
+	}  
+}`,
+				},
+				{
+					client: "openai",
+					content: `import { OpenAI } from "openai"
+
+const client = new OpenAI({
+	baseURL: "https://api-inference.huggingface.co/v1/",
+    apiKey: "${accessToken || `{API_TOKEN}`}"
+})
+
+let out = "";
+
+const stream = await client.chat.completions.create({
+	model: "${model.id}",
+	messages: ${messagesStr},
+	${configStr},
+	stream: true,
+});
+
+for await (const chunk of stream) {
+	if (chunk.choices && chunk.choices.length > 0) {
+		const newContent = chunk.choices[0].delta.content;
+		out += newContent;
+		console.log(newContent);
+	}  
+}`,
+				},
+			];
+		} else {
+			return [
+				{
+					client: "huggingface.js",
+					content: `import { HfInference } from "@huggingface/inference"
+
+const client = new HfInference("${accessToken || `{API_TOKEN}`}")
+
+const chatCompletion = await client.chatCompletion({
+	model: "${model.id}",
+	messages: ${messagesStr},
+	${configStr}
+});
+
+console.log(chatCompletion.choices[0].message);`,
+				},
+				{
+					client: "openai",
+					content: `import { OpenAI } from "openai"
+
+const client = new OpenAI({
+    baseURL: "https://api-inference.huggingface.co/v1/",
+    apiKey: "${accessToken || `{API_TOKEN}`}"
+})
+
+const chatCompletion = await client.chat.completions.create({
+	model: "${model.id}",
+	messages: ${messagesStr},
+	${configStr}
+});
+
+console.log(chatCompletion.choices[0].message);`,
+				},
+			];
+		}
+	} else {
+		return snippetBasic(model, accessToken);
+	}
+};
+
+export const snippetZeroShotClassification = (model: ModelDataMinimal, accessToken: string): InferenceSnippet => ({
+	content: `async function query(data) {
+	const response = await fetch(
+		"https://api-inference.huggingface.co/models/${model.id}",
+		{
+			headers: {
+				Authorization: "Bearer ${accessToken || `{API_TOKEN}`}"
+				"Content-Type": "application/json",
+			},
+			method: "POST",
+			body: JSON.stringify(data),
+		}
+	);
+	const result = await response.json();
+	return result;
+}
+
+query({"inputs": ${getModelInputSnippet(
+		model
+	)}, "parameters": {"candidate_labels": ["refund", "legal", "faq"]}}).then((response) => {
+	console.log(JSON.stringify(response));
+});`,
+});
+
+export const snippetTextToImage = (model: ModelDataMinimal, accessToken: string): InferenceSnippet => ({
+	content: `async function query(data) {
+	const response = await fetch(
+		"https://api-inference.huggingface.co/models/${model.id}",
+		{
+			headers: {
+				Authorization: "Bearer ${accessToken || `{API_TOKEN}`}"
+				"Content-Type": "application/json",
+			},
+			method: "POST",
+			body: JSON.stringify(data),
+		}
+	);
+	const result = await response.blob();
+	return result;
+}
+query({"inputs": ${getModelInputSnippet(model)}}).then((response) => {
+	// Use image
+});`,
+});
+
+export const snippetTextToAudio = (model: ModelDataMinimal, accessToken: string): InferenceSnippet => {
+	const commonSnippet = `async function query(data) {
+		const response = await fetch(
+			"https://api-inference.huggingface.co/models/${model.id}",
+			{
+				headers: {
+					Authorization: "Bearer ${accessToken || `{API_TOKEN}`}"
+					"Content-Type": "application/json",
+				},
+				method: "POST",
+				body: JSON.stringify(data),
+			}
+		);`;
+	if (model.library_name === "transformers") {
+		return {
+			content:
+				commonSnippet +
+				`
+			const result = await response.blob();
+			return result;
+		}
+		query({"inputs": ${getModelInputSnippet(model)}}).then((response) => {
+			// Returns a byte object of the Audio wavform. Use it directly!
+		});`,
+		};
+	} else {
+		return {
+			content:
+				commonSnippet +
+				`
+			const result = await response.json();
+			return result;
+		}
+		
+		query({"inputs": ${getModelInputSnippet(model)}}).then((response) => {
+			console.log(JSON.stringify(response));
+		});`,
+		};
+	}
+};
+
+export const snippetFile = (model: ModelDataMinimal, accessToken: string): InferenceSnippet => ({
+	content: `async function query(filename) {
+	const data = fs.readFileSync(filename);
+	const response = await fetch(
+		"https://api-inference.huggingface.co/models/${model.id}",
+		{
+			headers: {
+				Authorization: "Bearer ${accessToken || `{API_TOKEN}`}"
+				"Content-Type": "application/json",
+			},
+			method: "POST",
+			body: data,
+		}
+	);
+	const result = await response.json();
+	return result;
+}
+
+query(${getModelInputSnippet(model)}).then((response) => {
+	console.log(JSON.stringify(response));
+});`,
+});
+
+export const jsSnippets: Partial<
+	Record<
+		PipelineType,
+		(
+			model: ModelDataMinimal,
+			accessToken: string,
+			opts?: Record<string, unknown>
+		) => InferenceSnippet | InferenceSnippet[]
+	>
+> = {
+	// Same order as in js/src/lib/interfaces/Types.ts
+	"text-classification": snippetBasic,
+	"token-classification": snippetBasic,
+	"table-question-answering": snippetBasic,
+	"question-answering": snippetBasic,
+	"zero-shot-classification": snippetZeroShotClassification,
+	translation: snippetBasic,
+	summarization: snippetBasic,
+	"feature-extraction": snippetBasic,
+	"text-generation": snippetTextGeneration,
+	"image-text-to-text": snippetTextGeneration,
+	"text2text-generation": snippetBasic,
+	"fill-mask": snippetBasic,
+	"sentence-similarity": snippetBasic,
+	"automatic-speech-recognition": snippetFile,
+	"text-to-image": snippetTextToImage,
+	"text-to-speech": snippetTextToAudio,
+	"text-to-audio": snippetTextToAudio,
+	"audio-to-audio": snippetFile,
+	"audio-classification": snippetFile,
+	"image-classification": snippetFile,
+	"image-to-text": snippetFile,
+	"object-detection": snippetFile,
+	"image-segmentation": snippetFile,
+};
+
+export function getJsInferenceSnippet(
+	model: ModelDataMinimal,
+	accessToken: string,
+	opts?: Record<string, unknown>
+): InferenceSnippet | InferenceSnippet[] {
+	return model.pipeline_tag && model.pipeline_tag in jsSnippets
+		? jsSnippets[model.pipeline_tag]?.(model, accessToken, opts) ?? { content: "" }
+		: { content: "" };
+}
+
+export function hasJsInferenceSnippet(model: ModelDataMinimal): boolean {
+	return !!model.pipeline_tag && model.pipeline_tag in jsSnippets;
+}

package/src/snippets/python.spec.ts

@@ -0,0 +1,144 @@
+import type { InferenceSnippet, ModelDataMinimal } from "./types.js";
+import { describe, expect, it } from "vitest";
+import { getPythonInferenceSnippet } from "./python.js";
+
+describe("inference API snippets", () => {
+	it("conversational llm", async () => {
+		const model: ModelDataMinimal = {
+			id: "meta-llama/Llama-3.1-8B-Instruct",
+			pipeline_tag: "text-generation",
+			tags: ["conversational"],
+			inference: "",
+		};
+		const snippet = getPythonInferenceSnippet(model, "api_token") as InferenceSnippet[];
+
+		expect(snippet[0].content).toEqual(`from huggingface_hub import InferenceClient
+
+client = InferenceClient(api_key="api_token")
+
+messages = [
+	{
+		"role": "user",
+		"content": "What is the capital of France?"
+	}
+]
+
+stream = client.chat.completions.create(
+    model="meta-llama/Llama-3.1-8B-Instruct", 
+	messages=messages, 
+	max_tokens=500,
+	stream=True
+)
+
+for chunk in stream:
+    print(chunk.choices[0].delta.content, end="")`);
+	});
+
+	it("conversational llm non-streaming", async () => {
+		const model: ModelDataMinimal = {
+			id: "meta-llama/Llama-3.1-8B-Instruct",
+			pipeline_tag: "text-generation",
+			tags: ["conversational"],
+			inference: "",
+		};
+		const snippet = getPythonInferenceSnippet(model, "api_token", { streaming: false }) as InferenceSnippet[];
+
+		expect(snippet[0].content).toEqual(`from huggingface_hub import InferenceClient
+
+client = InferenceClient(api_key="api_token")
+
+messages = [
+	{
+		"role": "user",
+		"content": "What is the capital of France?"
+	}
+]
+
+completion = client.chat.completions.create(
+    model="meta-llama/Llama-3.1-8B-Instruct", 
+	messages=messages, 
+	max_tokens=500
+)
+
+print(completion.choices[0].message)`);
+	});
+
+	it("conversational vlm", async () => {
+		const model: ModelDataMinimal = {
+			id: "meta-llama/Llama-3.2-11B-Vision-Instruct",
+			pipeline_tag: "image-text-to-text",
+			tags: ["conversational"],
+			inference: "",
+		};
+		const snippet = getPythonInferenceSnippet(model, "api_token") as InferenceSnippet[];
+
+		expect(snippet[0].content).toEqual(`from huggingface_hub import InferenceClient
+
+client = InferenceClient(api_key="api_token")
+
+messages = [
+	{
+		"role": "user",
+		"content": [
+			{
+				"type": "text",
+				"text": "Describe this image in one sentence."
+			},
+			{
+				"type": "image_url",
+				"image_url": {
+					"url": "https://cdn.britannica.com/61/93061-050-99147DCE/Statue-of-Liberty-Island-New-York-Bay.jpg"
+				}
+			}
+		]
+	}
+]
+
+stream = client.chat.completions.create(
+    model="meta-llama/Llama-3.2-11B-Vision-Instruct", 
+	messages=messages, 
+	max_tokens=500,
+	stream=True
+)
+
+for chunk in stream:
+    print(chunk.choices[0].delta.content, end="")`);
+	});
+
+	it("text-to-image", async () => {
+		const model: ModelDataMinimal = {
+			id: "black-forest-labs/FLUX.1-schnell",
+			pipeline_tag: "text-to-image",
+			tags: [],
+			inference: "",
+		};
+		const snippets = getPythonInferenceSnippet(model, "api_token") as InferenceSnippet[];
+
+		expect(snippets.length).toEqual(2);
+
+		expect(snippets[0].client).toEqual("huggingface_hub");
+		expect(snippets[0].content).toEqual(`from huggingface_hub import InferenceClient
+client = InferenceClient("black-forest-labs/FLUX.1-schnell", token="api_token")
+
+# output is a PIL.Image object
+image = client.text_to_image("Astronaut riding a horse")`);
+
+		expect(snippets[1].client).toEqual("requests");
+		expect(snippets[1].content).toEqual(`import requests
+
+API_URL = "https://api-inference.huggingface.co/models/black-forest-labs/FLUX.1-schnell"
+headers = {"Authorization": "Bearer api_token"}
+
+def query(payload):
+	response = requests.post(API_URL, headers=headers, json=payload)
+	return response.content
+image_bytes = query({
+	"inputs": "Astronaut riding a horse",
+})
+
+# You can access the image with PIL.Image for example
+import io
+from PIL import Image
+image = Image.open(io.BytesIO(image_bytes))`);
+	});
+});