Endpoint testing with js or python

Samme test script i hhv
- python med deps i requirements.txt
- js, uden eksterne dependencies, så kan køres med node cli direkte

hf_endpoint_testing/hf_endpoint_client.js

@@ -0,0 +1,151 @@
+const fs = require("fs");
+const path = require("path");
+const https = require("https");
+
+const API_URL = process.env.HF_ENDPOINT;
+const HF_TOKEN = process.env.HF_TOKEN;
+
+if (!HF_TOKEN) {
+  console.error("Error: HF_TOKEN environment variable is not set.");
+  process.exit(1);
+}
+
+if (!API_URL) {
+  console.error("Error: HF_ENDPOINT environment variable is not set.");
+  process.exit(1);
+}
+
+const headers = {
+  Accept: "application/json",
+  Authorization: `Bearer ${HF_TOKEN}`,
+  "Content-Type": "application/json",
+};
+
+function transcribe(filename, params = null) {
+  // Check if file exists
+  if (!fs.existsSync(filename)) {
+    console.error(`Error: File '${filename}' does not exist.`);
+    process.exit(1);
+  }
+
+  const parameters = params || {
+    word_timestamps: false,
+    temperature: [0.0, 0.1, 0.3, 0.5, 0.7, 0.9, 1],
+    repetition_penalty: 1.2,
+    log_prob_threshold: -1.0,
+  };
+
+  callEndpoint(filename, parameters)
+    .then((response) => {
+      const txt = response.text;
+      if (!txt) {
+        console.error("Error: No text returned");
+        console.error(response);
+        process.exit(1);
+      }
+
+      console.log(txt);
+      const isodate = new Date().toISOString().replace(/:/g, "_").split(".")[0];
+
+      const resultfile = `${path.basename(filename)}_${isodate}.txt`;
+
+      fs.writeFileSync(
+        resultfile,
+        `----- PARAMETERS -----\n${JSON.stringify(
+          parameters,
+          null,
+          2
+        )}\n----- RESULT -----\n${JSON.stringify(response, null, 2)}\n`,
+        "utf-8"
+      );
+    })
+    .catch((error) => {
+      console.error(`Error during transcription: ${error.message}`);
+      process.exit(1);
+    });
+}
+
+function callEndpoint(filename, params) {
+  // Check if file exists
+  if (!fs.existsSync(filename)) {
+    console.error(`Error: File '${filename}' does not exist.`);
+    process.exit(1);
+  }
+
+  const data = fs.readFileSync(filename);
+  const base64Data = data.toString("base64");
+
+  const payload = {
+    inputs: `data:audio/wav;base64,${base64Data}`,
+    language: "da",
+    parameters: params,
+  };
+
+  const jsonData = JSON.stringify(payload);
+
+  return new Promise((resolve, reject) => {
+    // Parse the API_URL correctly
+    let url;
+    try {
+      url = new URL(API_URL);
+    } catch (e) {
+      console.error(
+        `Error: Invalid API_URL '${API_URL}'. It should be a complete URL.`
+      );
+      process.exit(1);
+    }
+
+    const options = {
+      hostname: url.hostname,
+      port: 443,
+      path: url.pathname === "/" ? "/" : url.pathname,
+      method: "POST",
+      headers: {
+        ...headers,
+        "Content-Length": jsonData.length,
+      },
+    };
+
+    const req = https.request(options, (res) => {
+      let data = "";
+
+      res.on("data", (chunk) => {
+        data += chunk;
+      });
+
+      res.on("end", () => {
+        resolve(JSON.parse(data));
+      });
+    });
+
+    req.on("error", (error) => {
+      console.error(`Error: ${error.message}`);
+      reject(error);
+    });
+
+    req.write(jsonData);
+    req.end();
+  });
+}
+
+// CLI
+const scriptName = path.basename(process.argv[1]);
+if (process.argv.length < 3) {
+  console.error(`Usage: node ${scriptName} <command> <filename>`);
+  process.exit(1);
+}
+
+const command = process.argv[2];
+const filename = process.argv[3];
+
+if (command === "transcribe") {
+  if (!filename) {
+    console.error(`Usage: node ${scriptName} transcribe <filename>`);
+    process.exit(1);
+  }
+
+  transcribe(filename);
+} else {
+  console.error(`Unknown command. Supported commands: transcribe`);
+  process.exit(1);
+}

hf_endpoint_testing/hf_endpoint_client.py

@@ -0,0 +1,138 @@
+import base64
+import datetime
+import json
+import sys
+import requests
+
+# get waw files in the current directory
+import os
+import glob
+import re
+import subprocess
+
+# load dotenv
+from dotenv import load_dotenv
+
+load_dotenv()
+
+
+API_URL = os.getenv(
+    "HF_ENDPOINT", "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX.endpoints.huggingface.cloud"
+)
+headers = {
+    "Accept": "application/json",
+    "Authorization": f"Bearer {os.getenv('HF_TOKEN')}",
+    "Content-Type": "application/json",
+}
+
+
+def transcribe(filename, params=None):
+    parameters = params or {
+        "word_timestamps": False,
+        # "initial_prompt": "",
+        "temperature": [0.0, 0.1, 0.3, 0.5, 0.7, 0.9, 1],
+        "repetition_penalty": 1.2,
+        "log_prob_threshold": -1.0,
+    }
+    result = call_endpoint(filename, parameters)
+    txt = result.get("text")
+    if txt is None:
+        print("Error: No text returned")
+        print(result)
+        sys.exit(1)
+
+    print(txt)
+    isodate = datetime.datetime.now().isoformat()
+    isodate = isodate.split(".")[0]
+    isodate = isodate.replace(":", "_")
+
+    # strip extension from filename
+    resultfile = os.path.basename(filename)
+    resultfile = f"{resultfile}_{isodate}.txt"
+
+    with open(resultfile, "w", encoding="utf-8") as f:
+        f.write("----- PARAMETERS -----\n")
+        f.write(json.dumps(parameters, indent=2, ensure_ascii=False))
+        f.write("\n----- RESULT -----\n")
+        f.write(json.dumps(result, indent=2, ensure_ascii=False))
+        f.write("\n")
+
+
+def call_endpoint(filename, params=None):
+    with open(filename, "rb") as f:
+        data = f.read()
+
+    # Convert to base64 string
+    data = base64.b64encode(data).decode("utf-8")
+    # print(data)
+    if params is None:
+        parameters = {
+            "initial_prompt": "Her går det godt når vi taler om det",
+            "word_timestamps": False,
+            "vad_parameters": dict(min_silence_duration_ms=500),
+        }
+    else:
+        parameters = params
+
+    print(f"Parameters: {parameters}")
+    payload = {
+        "inputs": f"data:audio/wav,base64,{data}",
+        "language": "da",
+        "parameters": parameters,
+    }
+    json_data = json.dumps(payload)
+    # print(json_data)
+    now = datetime.datetime.now()
+    print(f"Sending request to {API_URL}...")
+    response = requests.post(API_URL, headers=headers, data=json_data)
+    elapsed_time = datetime.datetime.now() - now
+    print(f"Elapsed time: {elapsed_time}")
+
+    return response.json()
+
+
+def convert(filename):
+    # Convert to 16kHz mono WAV using ffmpeg
+    output_file = filename.replace(".wav", "_16k.wav")
+    print(f"Converting {filename} to 16khz mono --> {output_file}...")
+
+    if not os.path.exists(output_file):
+        subprocess.run(
+            [
+                "ffmpeg",
+                "-i",
+                filename,
+                "-ar",
+                "16000",
+                "-ac",
+                "1",
+                "-c:a",
+                "pcm_s16le",
+                output_file,
+            ],
+            check=True,
+        )
+    return output_file
+
+
+# cli
+
+if sys.argv[1] == "convert":
+    if len(sys.argv) < 2:
+        print("Usage: python test_endpoint.py convert <filename>")
+        exit(1)
+
+    filename = sys.argv[2]
+    convert(filename)
+    exit(0)
+
+
+if (len(sys.argv) > 1 and sys.argv[1] == "transcribe") or len(sys.argv) < 2:
+    if len(sys.argv) < 2:
+        print("Usage: python test_endpoint.py transcribe <filename>")
+        exit(1)
+
+    filename = sys.argv[2]
+    output = transcribe(filename)
+    print(output)
+    exit(0)

hf_endpoint_testing/requirements.txt

@@ -0,0 +1,11 @@
+certifi==2025.1.31
+cffi==1.17.1
+charset-normalizer==3.4.1
+dotenv==0.9.9
+idna==3.10
+numpy==2.2.4
+pycparser==2.22
+python-dotenv==1.1.0
+requests==2.32.3
+soundfile==0.13.1
+urllib3==2.3.0