@gradio/client 0.1.3 → 0.2.1

package/dist/index.js

@@ -13,13 +13,12 @@ function determine_protocol(endpoint) {
         host,
         http_protocol: protocol
       };
-    } else {
-      return {
-        ws_protocol: protocol === "https:" ? "wss" : "ws",
-        http_protocol: protocol,
-        host
-      };
     }
+    return {
+      ws_protocol: protocol === "https:" ? "wss" : "ws",
+      http_protocol: protocol,
+      host
+    };
   }
   return {
     ws_protocol: "wss",
@@ -86,8 +85,7 @@ async function discussions_enabled(space_id) {
     const error = r.headers.get("x-error-message");
     if (error && RE_DISABLED_DISCUSSION.test(error))
       return false;
-    else
-      return true;
+    return true;
   } catch (e) {
     return false;
   }
@@ -161,45 +159,7 @@ const hardware_types = [
 ];
 const QUEUE_FULL_MSG = "This application is too busy. Keep trying!";
 const BROKEN_CONNECTION_MSG = "Connection errored out.";
-async function post_data(url, body, token) {
-  const headers = { "Content-Type": "application/json" };
-  if (token) {
-    headers.Authorization = `Bearer ${token}`;
-  }
-  try {
-    var response = await fetch(url, {
-      method: "POST",
-      body: JSON.stringify(body),
-      headers
-    });
-  } catch (e) {
-    return [{ error: BROKEN_CONNECTION_MSG }, 500];
-  }
-  const output = await response.json();
-  return [output, response.status];
-}
 let NodeBlob;
-async function upload_files(root, files, token) {
-  const headers = {};
-  if (token) {
-    headers.Authorization = `Bearer ${token}`;
-  }
-  const formData = new FormData();
-  files.forEach((file) => {
-    formData.append("files", file);
-  });
-  try {
-    var response = await fetch(`${root}/upload`, {
-      method: "POST",
-      body: formData,
-      headers
-    });
-  } catch (e) {
-    return { error: BROKEN_CONNECTION_MSG };
-  }
-  const output = await response.json();
-  return { files: output };
-}
 async function duplicate(app_reference, options) {
   const { hf_token, private: _private, hardware, timeout } = options;
   if (hardware && !hardware_types.includes(hardware)) {
@@ -231,437 +191,551 @@ async function duplicate(app_reference, options) {
     );
     if (response.status === 409) {
       return client(`${user}/${space_name}`, options);
-    } else {
-      const duplicated_space = await response.json();
-      let original_hardware;
-      if (!hardware) {
-        original_hardware = await get_space_hardware(app_reference, hf_token);
-      }
-      const requested_hardware = hardware || original_hardware || "cpu-basic";
-      await set_space_hardware(
-        `${user}/${space_name}`,
-        requested_hardware,
-        hf_token
-      );
-      await set_space_timeout(
-        `${user}/${space_name}`,
-        timeout || 300,
-        hf_token
-      );
-      return client(duplicated_space.url, options);
     }
+    const duplicated_space = await response.json();
+    let original_hardware;
+    if (!hardware) {
+      original_hardware = await get_space_hardware(app_reference, hf_token);
+    }
+    const requested_hardware = hardware || original_hardware || "cpu-basic";
+    await set_space_hardware(
+      `${user}/${space_name}`,
+      requested_hardware,
+      hf_token
+    );
+    await set_space_timeout(`${user}/${space_name}`, timeout || 300, hf_token);
+    return client(duplicated_space.url, options);
   } catch (e) {
     throw new Error(e);
   }
 }
-async function client(app_reference, options = { normalise_files: true }) {
-  return new Promise(async (res) => {
-    const { status_callback, hf_token, normalise_files } = options;
-    const return_obj = {
-      predict,
-      submit,
-      view_api
-      // duplicate
-    };
-    const transform_files = normalise_files ?? true;
-    if (typeof window === "undefined" || !("WebSocket" in window)) {
-      const ws = await import("./wrapper-6f348d45.js");
-      NodeBlob = (await import("node:buffer")).Blob;
-      global.WebSocket = ws.WebSocket;
+function api_factory(fetch_implementation) {
+  return { post_data: post_data2, upload_files: upload_files2, client: client2, handle_blob: handle_blob2 };
+  async function post_data2(url, body, token) {
+    const headers = { "Content-Type": "application/json" };
+    if (token) {
+      headers.Authorization = `Bearer ${token}`;
+    }
+    try {
+      var response = await fetch_implementation(url, {
+        method: "POST",
+        body: JSON.stringify(body),
+        headers
+      });
+    } catch (e) {
+      return [{ error: BROKEN_CONNECTION_MSG }, 500];
     }
-    const { ws_protocol, http_protocol, host, space_id } = await process_endpoint(app_reference, hf_token);
-    const session_hash = Math.random().toString(36).substring(2);
-    const last_status = {};
-    let config;
-    let api_map = {};
-    let jwt = false;
-    if (hf_token && space_id) {
-      jwt = await get_jwt(space_id, hf_token);
+    const output = await response.json();
+    return [output, response.status];
+  }
+  async function upload_files2(root, files, token) {
+    const headers = {};
+    if (token) {
+      headers.Authorization = `Bearer ${token}`;
     }
-    async function config_success(_config) {
-      config = _config;
-      api_map = map_names_to_ids((_config == null ? void 0 : _config.dependencies) || []);
+    const chunkSize = 1e3;
+    const uploadResponses = [];
+    for (let i = 0; i < files.length; i += chunkSize) {
+      const chunk = files.slice(i, i + chunkSize);
+      const formData = new FormData();
+      chunk.forEach((file) => {
+        formData.append("files", file);
+      });
       try {
-        api = await view_api(config);
+        var response = await fetch_implementation(`${root}/upload`, {
+          method: "POST",
+          body: formData,
+          headers
+        });
       } catch (e) {
-        console.error(`Could not get api details: ${e.message}`);
+        return { error: BROKEN_CONNECTION_MSG };
       }
-      return {
-        config,
-        ...return_obj
-      };
+      const output = await response.json();
+      uploadResponses.push(...output);
     }
-    let api;
-    async function handle_space_sucess(status) {
-      if (status_callback)
-        status_callback(status);
-      if (status.status === "running")
+    return { files: uploadResponses };
+  }
+  async function client2(app_reference, options = { normalise_files: true }) {
+    return new Promise(async (res) => {
+      const { status_callback, hf_token, normalise_files } = options;
+      const return_obj = {
+        predict,
+        submit,
+        view_api
+        // duplicate
+      };
+      const transform_files = normalise_files ?? true;
+      if (typeof window === "undefined" || !("WebSocket" in window)) {
+        const ws = await import("./wrapper-6f348d45.js");
+        NodeBlob = (await import("node:buffer")).Blob;
+        global.WebSocket = ws.WebSocket;
+      }
+      const { ws_protocol, http_protocol, host, space_id } = await process_endpoint(app_reference, hf_token);
+      const session_hash = Math.random().toString(36).substring(2);
+      const last_status = {};
+      let config;
+      let api_map = {};
+      let jwt = false;
+      if (hf_token && space_id) {
+        jwt = await get_jwt(space_id, hf_token);
+      }
+      async function config_success(_config) {
+        config = _config;
+        api_map = map_names_to_ids((_config == null ? void 0 : _config.dependencies) || []);
         try {
-          config = await resolve_config(`${http_protocol}//${host}`, hf_token);
-          const _config = await config_success(config);
-          res(_config);
+          api = await view_api(config);
         } catch (e) {
-          if (status_callback) {
+          console.error(`Could not get api details: ${e.message}`);
+        }
+        return {
+          config,
+          ...return_obj
+        };
+      }
+      let api;
+      async function handle_space_sucess(status) {
+        if (status_callback)
+          status_callback(status);
+        if (status.status === "running")
+          try {
+            config = await resolve_config(
+              fetch_implementation,
+              `${http_protocol}//${host}`,
+              hf_token
+            );
+            const _config = await config_success(config);
+            res(_config);
+          } catch (e) {
+            console.error(e);
+            if (status_callback) {
+              status_callback({
+                status: "error",
+                message: "Could not load this space.",
+                load_status: "error",
+                detail: "NOT_FOUND"
+              });
+            }
+          }
+      }
+      try {
+        config = await resolve_config(
+          fetch_implementation,
+          `${http_protocol}//${host}`,
+          hf_token
+        );
+        const _config = await config_success(config);
+        res(_config);
+      } catch (e) {
+        console.error(e);
+        if (space_id) {
+          check_space_status(
+            space_id,
+            RE_SPACE_NAME.test(space_id) ? "space_name" : "subdomain",
+            handle_space_sucess
+          );
+        } else {
+          if (status_callback)
             status_callback({
               status: "error",
               message: "Could not load this space.",
               load_status: "error",
               detail: "NOT_FOUND"
             });
-          }
         }
-    }
-    try {
-      config = await resolve_config(`${http_protocol}//${host}`, hf_token);
-      const _config = await config_success(config);
-      res(_config);
-    } catch (e) {
-      if (space_id) {
-        check_space_status(
-          space_id,
-          RE_SPACE_NAME.test(space_id) ? "space_name" : "subdomain",
-          handle_space_sucess
-        );
-      } else {
-        if (status_callback)
-          status_callback({
-            status: "error",
-            message: "Could not load this space.",
-            load_status: "error",
-            detail: "NOT_FOUND"
-          });
       }
-    }
-    function predict(endpoint, data, event_data) {
-      let data_returned = false;
-      let status_complete = false;
-      return new Promise((res2, rej) => {
-        const app = submit(endpoint, data, event_data);
-        app.on("data", (d) => {
-          data_returned = true;
-          if (status_complete) {
-            app.destroy();
-          }
-          res2(d);
-        }).on("status", (status) => {
-          if (status.stage === "error")
-            rej(status);
-          if (status.stage === "complete" && data_returned) {
-            app.destroy();
-          }
-          if (status.stage === "complete") {
-            status_complete = true;
-          }
+      function predict(endpoint, data, event_data) {
+        let data_returned = false;
+        let status_complete = false;
+        let dependency;
+        if (typeof endpoint === "number") {
+          dependency = config.dependencies[endpoint];
+        } else {
+          const trimmed_endpoint = endpoint.replace(/^\//, "");
+          dependency = config.dependencies[api_map[trimmed_endpoint]];
+        }
+        if (dependency.types.continuous) {
+          throw new Error(
+            "Cannot call predict on this function as it may run forever. Use submit instead"
+          );
+        }
+        return new Promise((res2, rej) => {
+          const app = submit(endpoint, data, event_data);
+          let result;
+          app.on("data", (d) => {
+            if (status_complete) {
+              app.destroy();
+              res2(d);
+            }
+            data_returned = true;
+            result = d;
+          }).on("status", (status) => {
+            if (status.stage === "error")
+              rej(status);
+            if (status.stage === "complete") {
+              status_complete = true;
+              app.destroy();
+              if (data_returned) {
+                res2(result);
+              }
+            }
+          });
         });
-      });
-    }
-    function submit(endpoint, data, event_data) {
-      let fn_index;
-      let api_info;
-      if (typeof endpoint === "number") {
-        fn_index = endpoint;
-        api_info = api.unnamed_endpoints[fn_index];
-      } else {
-        const trimmed_endpoint = endpoint.replace(/^\//, "");
-        fn_index = api_map[trimmed_endpoint];
-        api_info = api.named_endpoints[endpoint.trim()];
-      }
-      if (typeof fn_index !== "number") {
-        throw new Error(
-          "There is no endpoint matching that name of fn_index matching that number."
-        );
       }
-      let websocket;
-      const _endpoint = typeof endpoint === "number" ? "/predict" : endpoint;
-      let payload;
-      let complete = false;
-      const listener_map = {};
-      handle_blob(
-        `${http_protocol}//${host + config.path}`,
-        data,
-        api_info,
-        hf_token
-      ).then((_payload) => {
-        payload = { data: _payload || [], event_data, fn_index };
-        if (skip_queue(fn_index, config)) {
-          fire_event({
-            type: "status",
-            endpoint: _endpoint,
-            stage: "pending",
-            queue: false,
-            fn_index,
-            time: /* @__PURE__ */ new Date()
-          });
-          post_data(
-            `${http_protocol}//${host + config.path}/run${_endpoint.startsWith("/") ? _endpoint : `/${_endpoint}`}`,
-            {
-              ...payload,
-              session_hash
-            },
-            hf_token
-          ).then(([output, status_code]) => {
-            const data2 = transform_files ? transform_output(
-              output.data,
-              api_info,
-              config.root,
-              config.root_url
-            ) : output.data;
-            if (status_code == 200) {
-              fire_event({
-                type: "data",
-                endpoint: _endpoint,
-                fn_index,
-                data: data2,
-                time: /* @__PURE__ */ new Date()
-              });
-              fire_event({
-                type: "status",
-                endpoint: _endpoint,
-                fn_index,
-                stage: "complete",
-                eta: output.average_duration,
-                queue: false,
-                time: /* @__PURE__ */ new Date()
-              });
-            } else {
+      function submit(endpoint, data, event_data) {
+        let fn_index;
+        let api_info;
+        if (typeof endpoint === "number") {
+          fn_index = endpoint;
+          api_info = api.unnamed_endpoints[fn_index];
+        } else {
+          const trimmed_endpoint = endpoint.replace(/^\//, "");
+          fn_index = api_map[trimmed_endpoint];
+          api_info = api.named_endpoints[endpoint.trim()];
+        }
+        if (typeof fn_index !== "number") {
+          throw new Error(
+            "There is no endpoint matching that name of fn_index matching that number."
+          );
+        }
+        let websocket;
+        const _endpoint = typeof endpoint === "number" ? "/predict" : endpoint;
+        let payload;
+        let complete = false;
+        const listener_map = {};
+        handle_blob2(
+          `${http_protocol}//${host + config.path}`,
+          data,
+          api_info,
+          hf_token
+        ).then((_payload) => {
+          payload = { data: _payload || [], event_data, fn_index };
+          if (skip_queue(fn_index, config)) {
+            fire_event({
+              type: "status",
+              endpoint: _endpoint,
+              stage: "pending",
+              queue: false,
+              fn_index,
+              time: /* @__PURE__ */ new Date()
+            });
+            post_data2(
+              `${http_protocol}//${host + config.path}/run${_endpoint.startsWith("/") ? _endpoint : `/${_endpoint}`}`,
+              {
+                ...payload,
+                session_hash
+              },
+              hf_token
+            ).then(([output, status_code]) => {
+              const data2 = transform_files ? transform_output(
+                output.data,
+                api_info,
+                config.root,
+                config.root_url
+              ) : output.data;
+              if (status_code == 200) {
+                fire_event({
+                  type: "data",
+                  endpoint: _endpoint,
+                  fn_index,
+                  data: data2,
+                  time: /* @__PURE__ */ new Date()
+                });
+                fire_event({
+                  type: "status",
+                  endpoint: _endpoint,
+                  fn_index,
+                  stage: "complete",
+                  eta: output.average_duration,
+                  queue: false,
+                  time: /* @__PURE__ */ new Date()
+                });
+              } else {
+                fire_event({
+                  type: "status",
+                  stage: "error",
+                  endpoint: _endpoint,
+                  fn_index,
+                  message: output.error,
+                  queue: false,
+                  time: /* @__PURE__ */ new Date()
+                });
+              }
+            }).catch((e) => {
               fire_event({
                 type: "status",
                 stage: "error",
+                message: e.message,
                 endpoint: _endpoint,
                 fn_index,
-                message: output.error,
                 queue: false,
                 time: /* @__PURE__ */ new Date()
               });
-            }
-          }).catch((e) => {
+            });
+          } else {
             fire_event({
               type: "status",
-              stage: "error",
-              message: e.message,
+              stage: "pending",
+              queue: true,
               endpoint: _endpoint,
               fn_index,
-              queue: false,
               time: /* @__PURE__ */ new Date()
             });
-          });
-        } else {
-          fire_event({
-            type: "status",
-            stage: "pending",
-            queue: true,
-            endpoint: _endpoint,
-            fn_index,
-            time: /* @__PURE__ */ new Date()
-          });
-          let url = new URL(`${ws_protocol}://${host}${config.path}
-						/queue/join`);
-          if (jwt) {
-            url.searchParams.set("__sign", jwt);
-          }
-          websocket = new WebSocket(url);
-          websocket.onclose = (evt) => {
-            if (!evt.wasClean) {
-              fire_event({
-                type: "status",
-                stage: "error",
-                message: BROKEN_CONNECTION_MSG,
-                queue: true,
-                endpoint: _endpoint,
-                fn_index,
-                time: /* @__PURE__ */ new Date()
-              });
+            let url = new URL(`${ws_protocol}://${host}${config.path}
+							/queue/join`);
+            if (jwt) {
+              url.searchParams.set("__sign", jwt);
             }
-          };
-          websocket.onmessage = function(event) {
-            const _data = JSON.parse(event.data);
-            const { type, status, data: data2 } = handle_message(
-              _data,
-              last_status[fn_index]
-            );
-            if (type === "update" && status && !complete) {
-              fire_event({
-                type: "status",
-                endpoint: _endpoint,
-                fn_index,
-                time: /* @__PURE__ */ new Date(),
-                ...status
-              });
-              if (status.stage === "error") {
-                websocket.close();
+            websocket = new WebSocket(url);
+            websocket.onclose = (evt) => {
+              if (!evt.wasClean) {
+                fire_event({
+                  type: "status",
+                  stage: "error",
+                  broken: true,
+                  message: BROKEN_CONNECTION_MSG,
+                  queue: true,
+                  endpoint: _endpoint,
+                  fn_index,
+                  time: /* @__PURE__ */ new Date()
+                });
               }
-            } else if (type === "hash") {
-              websocket.send(JSON.stringify({ fn_index, session_hash }));
-              return;
-            } else if (type === "data") {
-              websocket.send(JSON.stringify({ ...payload, session_hash }));
-            } else if (type === "complete") {
-              complete = status;
-            } else if (type === "generating") {
-              fire_event({
-                type: "status",
-                time: /* @__PURE__ */ new Date(),
-                ...status,
-                stage: status == null ? void 0 : status.stage,
-                queue: true,
-                endpoint: _endpoint,
-                fn_index
-              });
-            }
-            if (data2) {
-              fire_event({
-                type: "data",
-                time: /* @__PURE__ */ new Date(),
-                data: transform_files ? transform_output(
-                  data2.data,
-                  api_info,
-                  config.root,
-                  config.root_url
-                ) : data2.data,
-                endpoint: _endpoint,
-                fn_index
-              });
-              if (complete) {
+            };
+            websocket.onmessage = function(event) {
+              const _data = JSON.parse(event.data);
+              const { type, status, data: data2 } = handle_message(
+                _data,
+                last_status[fn_index]
+              );
+              if (type === "update" && status && !complete) {
+                fire_event({
+                  type: "status",
+                  endpoint: _endpoint,
+                  fn_index,
+                  time: /* @__PURE__ */ new Date(),
+                  ...status
+                });
+                if (status.stage === "error") {
+                  websocket.close();
+                }
+              } else if (type === "hash") {
+                websocket.send(JSON.stringify({ fn_index, session_hash }));
+                return;
+              } else if (type === "data") {
+                websocket.send(JSON.stringify({ ...payload, session_hash }));
+              } else if (type === "complete") {
+                complete = status;
+              } else if (type === "log") {
+                fire_event({
+                  type: "log",
+                  log: data2.log,
+                  level: data2.level,
+                  endpoint: _endpoint,
+                  fn_index
+                });
+              } else if (type === "generating") {
                 fire_event({
                   type: "status",
                   time: /* @__PURE__ */ new Date(),
-                  ...complete,
+                  ...status,
                   stage: status == null ? void 0 : status.stage,
                   queue: true,
                   endpoint: _endpoint,
                   fn_index
                 });
-                websocket.close();
               }
+              if (data2) {
+                fire_event({
+                  type: "data",
+                  time: /* @__PURE__ */ new Date(),
+                  data: transform_files ? transform_output(
+                    data2.data,
+                    api_info,
+                    config.root,
+                    config.root_url
+                  ) : data2.data,
+                  endpoint: _endpoint,
+                  fn_index
+                });
+                if (complete) {
+                  fire_event({
+                    type: "status",
+                    time: /* @__PURE__ */ new Date(),
+                    ...complete,
+                    stage: status == null ? void 0 : status.stage,
+                    queue: true,
+                    endpoint: _endpoint,
+                    fn_index
+                  });
+                  websocket.close();
+                }
+              }
+            };
+            if (semiver(config.version || "2.0.0", "3.6") < 0) {
+              addEventListener(
+                "open",
+                () => websocket.send(JSON.stringify({ hash: session_hash }))
+              );
             }
+          }
+        });
+        function fire_event(event) {
+          const narrowed_listener_map = listener_map;
+          const listeners = narrowed_listener_map[event.type] || [];
+          listeners == null ? void 0 : listeners.forEach((l) => l(event));
+        }
+        function on(eventType, listener) {
+          const narrowed_listener_map = listener_map;
+          const listeners = narrowed_listener_map[eventType] || [];
+          narrowed_listener_map[eventType] = listeners;
+          listeners == null ? void 0 : listeners.push(listener);
+          return { on, off, cancel, destroy };
+        }
+        function off(eventType, listener) {
+          const narrowed_listener_map = listener_map;
+          let listeners = narrowed_listener_map[eventType] || [];
+          listeners = listeners == null ? void 0 : listeners.filter((l) => l !== listener);
+          narrowed_listener_map[eventType] = listeners;
+          return { on, off, cancel, destroy };
+        }
+        async function cancel() {
+          const _status = {
+            stage: "complete",
+            queue: false,
+            time: /* @__PURE__ */ new Date()
           };
-          if (semiver(config.version || "2.0.0", "3.6") < 0) {
-            addEventListener(
-              "open",
-              () => websocket.send(JSON.stringify({ hash: session_hash }))
+          complete = _status;
+          fire_event({
+            ..._status,
+            type: "status",
+            endpoint: _endpoint,
+            fn_index
+          });
+          if (websocket && websocket.readyState === 0) {
+            websocket.addEventListener("open", () => {
+              websocket.close();
+            });
+          } else {
+            websocket.close();
+          }
+          try {
+            await fetch_implementation(
+              `${http_protocol}//${host + config.path}/reset`,
+              {
+                headers: { "Content-Type": "application/json" },
+                method: "POST",
+                body: JSON.stringify({ fn_index, session_hash })
+              }
+            );
+          } catch (e) {
+            console.warn(
+              "The `/reset` endpoint could not be called. Subsequent endpoint results may be unreliable."
             );
           }
         }
-      });
-      function fire_event(event) {
-        const narrowed_listener_map = listener_map;
-        const listeners = narrowed_listener_map[event.type] || [];
-        listeners == null ? void 0 : listeners.forEach((l) => l(event));
-      }
-      function on(eventType, listener) {
-        const narrowed_listener_map = listener_map;
-        const listeners = narrowed_listener_map[eventType] || [];
-        narrowed_listener_map[eventType] = listeners;
-        listeners == null ? void 0 : listeners.push(listener);
-        return { on, off, cancel, destroy };
-      }
-      function off(eventType, listener) {
-        const narrowed_listener_map = listener_map;
-        let listeners = narrowed_listener_map[eventType] || [];
-        listeners = listeners == null ? void 0 : listeners.filter((l) => l !== listener);
-        narrowed_listener_map[eventType] = listeners;
-        return { on, off, cancel, destroy };
-      }
-      async function cancel() {
-        const _status = {
-          stage: "complete",
-          queue: false,
-          time: /* @__PURE__ */ new Date()
+        function destroy() {
+          for (const event_type in listener_map) {
+            listener_map[event_type].forEach((fn2) => {
+              off(event_type, fn2);
+            });
+          }
+        }
+        return {
+          on,
+          off,
+          cancel,
+          destroy
         };
-        complete = _status;
-        fire_event({
-          ..._status,
-          type: "status",
-          endpoint: _endpoint,
-          fn_index
-        });
-        if (websocket && websocket.readyState === 0) {
-          websocket.addEventListener("open", () => {
-            websocket.close();
-          });
-        } else {
-          websocket.close();
+      }
+      async function view_api(config2) {
+        if (api)
+          return api;
+        const headers = { "Content-Type": "application/json" };
+        if (hf_token) {
+          headers.Authorization = `Bearer ${hf_token}`;
         }
-        try {
-          await fetch(`${http_protocol}//${host + config.path}/reset`, {
-            headers: { "Content-Type": "application/json" },
-            method: "POST",
-            body: JSON.stringify({ fn_index, session_hash })
-          });
-        } catch (e) {
-          console.warn(
-            "The `/reset` endpoint could not be called. Subsequent endpoint results may be unreliable."
+        let response;
+        if (semiver(config2.version || "2.0.0", "3.30") < 0) {
+          response = await fetch_implementation(
+            "https://gradio-space-api-fetcher-v2.hf.space/api",
+            {
+              method: "POST",
+              body: JSON.stringify({
+                serialize: false,
+                config: JSON.stringify(config2)
+              }),
+              headers
+            }
           );
-        }
-      }
-      function destroy() {
-        for (const event_type in listener_map) {
-          listener_map[event_type].forEach((fn2) => {
-            off(event_type, fn2);
+        } else {
+          response = await fetch_implementation(`${config2.root}/info`, {
+            headers
           });
         }
+        if (!response.ok) {
+          throw new Error(BROKEN_CONNECTION_MSG);
+        }
+        let api_info = await response.json();
+        if ("api" in api_info) {
+          api_info = api_info.api;
+        }
+        if (api_info.named_endpoints["/predict"] && !api_info.unnamed_endpoints["0"]) {
+          api_info.unnamed_endpoints[0] = api_info.named_endpoints["/predict"];
+        }
+        const x = transform_api_info(api_info, config2, api_map);
+        return x;
       }
-      return {
-        on,
-        off,
-        cancel,
-        destroy
-      };
-    }
-    async function view_api(config2) {
-      if (api)
-        return api;
-      const headers = { "Content-Type": "application/json" };
-      if (hf_token) {
-        headers.Authorization = `Bearer ${hf_token}`;
-      }
-      let response;
-      if (semiver(config2.version || "2.0.0", "3.30") < 0) {
-        response = await fetch(
-          "https://gradio-space-api-fetcher-v2.hf.space/api",
-          {
-            method: "POST",
-            body: JSON.stringify({
-              serialize: false,
-              config: JSON.stringify(config2)
-            }),
-            headers
-          }
-        );
-      } else {
-        response = await fetch(`${config2.root}/info`, {
-          headers
-        });
-      }
-      if (!response.ok) {
-        throw new Error(BROKEN_CONNECTION_MSG);
-      }
-      let api_info = await response.json();
-      if ("api" in api_info) {
-        api_info = api_info.api;
-      }
-      if (api_info.named_endpoints["/predict"] && !api_info.unnamed_endpoints["0"]) {
-        api_info.unnamed_endpoints[0] = api_info.named_endpoints["/predict"];
-      }
-      const x = transform_api_info(api_info, config2, api_map);
-      return x;
-    }
-  });
+    });
+  }
+  async function handle_blob2(endpoint, data, api_info, token) {
+    const blob_refs = await walk_and_store_blobs(
+      data,
+      void 0,
+      [],
+      true,
+      api_info
+    );
+    return Promise.all(
+      blob_refs.map(async ({ path, blob, data: data2, type }) => {
+        if (blob) {
+          const file_url = (await upload_files2(endpoint, [blob], token)).files[0];
+          return { path, file_url, type };
+        }
+        return { path, base64: data2, type };
+      })
+    ).then((r) => {
+      r.forEach(({ path, file_url, base64, type }) => {
+        if (base64) {
+          update_object(data, base64, path);
+        } else if (type === "Gallery") {
+          update_object(data, file_url, path);
+        } else if (file_url) {
+          const o = {
+            is_file: true,
+            name: `${file_url}`,
+            data: null
+            // orig_name: "file.csv"
+          };
+          update_object(data, o, path);
+        }
+      });
+      return data;
+    });
+  }
 }
+const { post_data, upload_files, client, handle_blob } = api_factory(fetch);
 function transform_output(data, api_info, root_url, remote_url) {
   return data.map((d, i) => {
     var _a, _b, _c, _d;
-    if (((_b = (_a = api_info.returns) == null ? void 0 : _a[i]) == null ? void 0 : _b.component) === "File") {
+    if (((_b = (_a = api_info == null ? void 0 : api_info.returns) == null ? void 0 : _a[i]) == null ? void 0 : _b.component) === "File") {
       return normalise_file(d, root_url, remote_url);
-    } else if (((_d = (_c = api_info.returns) == null ? void 0 : _c[i]) == null ? void 0 : _d.component) === "Gallery") {
+    } else if (((_d = (_c = api_info == null ? void 0 : api_info.returns) == null ? void 0 : _c[i]) == null ? void 0 : _d.component) === "Gallery") {
       return d.map((img) => {
         return Array.isArray(img) ? [normalise_file(img[0], root_url, remote_url), img[1]] : [normalise_file(img, root_url, remote_url), null];
       });
-    } else if (typeof d === "object" && d.is_file) {
+    } else if (typeof d === "object" && (d == null ? void 0 : d.is_file)) {
       return normalise_file(d, root_url, remote_url);
-    } else {
-      return d;
     }
+    return d;
   });
 }
 function normalise_file(file, root, root_url) {
@@ -709,9 +783,8 @@ function get_type(type, component, serializer, signature_type) {
   } else if (serializer === "FileSerializable") {
     if ((type == null ? void 0 : type.type) === "array") {
       return signature_type === "parameter" ? "(Blob | File | Buffer)[]" : `{ name: string; data: string; size?: number; is_file?: boolean; orig_name?: string}[]`;
-    } else {
-      return signature_type === "parameter" ? "Blob | File | Buffer" : `{ name: string; data: string; size?: number; is_file?: boolean; orig_name?: string}`;
     }
+    return signature_type === "parameter" ? "Blob | File | Buffer" : `{ name: string; data: string; size?: number; is_file?: boolean; orig_name?: string}`;
   } else if (serializer === "GallerySerializable") {
     return signature_type === "parameter" ? "[(Blob | File | Buffer), (string | null)][]" : `[{ name: string; data: string; size?: number; is_file?: boolean; orig_name?: string}, (string | null))][]`;
   }
@@ -723,9 +796,8 @@ function get_description(type, serializer) {
     return "array of strings";
   } else if (serializer === "FileSerializable") {
     return "array of files or single file";
-  } else {
-    return type.description;
   }
+  return type.description;
 }
 function transform_api_info(api_info, config, api_map) {
   const new_data = {
@@ -775,42 +847,6 @@ async function get_jwt(space, token) {
     return false;
   }
 }
-async function handle_blob(endpoint, data, api_info, token) {
-  const blob_refs = await walk_and_store_blobs(
-    data,
-    void 0,
-    [],
-    true,
-    api_info
-  );
-  return Promise.all(
-    blob_refs.map(async ({ path, blob, data: data2, type }) => {
-      if (blob) {
-        const file_url = (await upload_files(endpoint, [blob], token)).files[0];
-        return { path, file_url, type };
-      } else {
-        return { path, base64: data2, type };
-      }
-    })
-  ).then((r) => {
-    r.forEach(({ path, file_url, base64, type }) => {
-      if (base64) {
-        update_object(data, base64, path);
-      } else if (type === "Gallery") {
-        update_object(data, file_url, path);
-      } else if (file_url) {
-        const o = {
-          is_file: true,
-          name: `${file_url}`,
-          data: null
-          // orig_name: "file.csv"
-        };
-        update_object(data, o, path);
-      }
-    });
-    return data;
-  });
-}
 function update_object(object, newValue, stack) {
   while (stack.length > 1) {
     object = object[stack.shift()];
@@ -855,10 +891,9 @@ async function walk_and_store_blobs(param, type = void 0, path = [], root = fals
         const buffer = await param.arrayBuffer();
         data = Buffer.from(buffer).toString("base64");
       }
-      return [{ path, data, type }];
-    } else {
-      return [{ path, blob: param, type }];
+      return [{ path, data, type, blob: false }];
     }
+    return [{ path, blob: param, type, data: false }];
   } else if (typeof param === "object") {
     let blob_refs = [];
     for (let key in param) {
@@ -877,9 +912,8 @@ async function walk_and_store_blobs(param, type = void 0, path = [], root = fals
       }
     }
     return blob_refs;
-  } else {
-    return [];
   }
+  return [];
 }
 function image_to_data_uri(blob) {
   return new Promise((resolve, _) => {
@@ -892,7 +926,7 @@ function skip_queue(id, config) {
   var _a, _b, _c, _d;
   return !(((_b = (_a = config == null ? void 0 : config.dependencies) == null ? void 0 : _a[id]) == null ? void 0 : _b.queue) === null ? config.enable_queue : (_d = (_c = config == null ? void 0 : config.dependencies) == null ? void 0 : _c[id]) == null ? void 0 : _d.queue) || false;
 }
-async function resolve_config(endpoint, token) {
+async function resolve_config(fetch_implementation, endpoint, token) {
   const headers = {};
   if (token) {
     headers.Authorization = `Bearer ${token}`;
@@ -903,15 +937,16 @@ async function resolve_config(endpoint, token) {
     config.root = endpoint + config.root;
     return { ...config, path };
   } else if (endpoint) {
-    let response = await fetch(`${endpoint}/config`, { headers });
+    let response = await fetch_implementation(`${endpoint}/config`, {
+      headers
+    });
     if (response.status === 200) {
       const config = await response.json();
       config.path = config.path ?? "";
       config.root = endpoint;
       return config;
-    } else {
-      throw new Error("Could not get config.");
     }
+    throw new Error("Could not get config.");
   }
   throw new Error("No config or app endpoint found");
 }
@@ -1036,6 +1071,8 @@ function handle_message(data, last_status) {
           success: data.success
         }
       };
+    case "log":
+      return { type: "log", data };
     case "process_generating":
       return {
         type: "generating",
@@ -1061,20 +1098,19 @@ function handle_message(data, last_status) {
             success: data.success
           }
         };
-      } else {
-        return {
-          type: "complete",
-          status: {
-            queue,
-            message: !data.success ? data.output.error : void 0,
-            stage: data.success ? "complete" : "error",
-            code: data.code,
-            progress_data: data.progress_data,
-            eta: data.output.average_duration
-          },
-          data: data.success ? data.output : null
-        };
       }
+      return {
+        type: "complete",
+        status: {
+          queue,
+          message: !data.success ? data.output.error : void 0,
+          stage: data.success ? "complete" : "error",
+          code: data.code,
+          progress_data: data.progress_data,
+          eta: data.output.average_duration
+        },
+        data: data.success ? data.output : null
+      };
     case "process_starts":
       return {
         type: "update",
@@ -1091,6 +1127,7 @@ function handle_message(data, last_status) {
   return { type: "none", status: { stage: "error", queue } };
 }
 export {
+  api_factory,
   client,
   duplicate,
   post_data,