substarte 120240617.1.9

package/src/SubstrateStreamingResponse.ts

@@ -0,0 +1,152 @@
+import { createParser } from "substrate/EventSource";
+import { NodeMessage, SSEMessage } from "substrate/Streaming";
+import { SubstrateError } from "substrate/Error";
+import { AnyNode, NodeOutput } from "substrate/Nodes";
+
+/**
+ * `StreamingResponse` is an async iterator that is used to interact with a stream of Server-Sent Events
+ */
+export class StreamingResponse {
+  apiResponse: Response;
+  iterator: any;
+
+  constructor(response: Response, iterator: any) {
+    this.apiResponse = response;
+    this.iterator = iterator;
+  }
+
+  [Symbol.asyncIterator]() {
+    return this.iterator;
+  }
+
+  tee(n: number = 2) {
+    return tee(n, this.iterator).map(
+      (iterator) => new StreamingResponse(this.apiResponse, iterator),
+    );
+  }
+
+  static async fromReponse(response: Response) {
+    if (!response.body) {
+      throw new SubstrateError("Response body must be present");
+    }
+
+    const decoder = new TextDecoder("utf-8");
+    const parser = createParser();
+
+    async function* iterator(): AsyncGenerator<SSEMessage> {
+      for await (const chunk of readableStreamAsyncIterable(response.body)) {
+        for (const message of parser.getMessages(
+          decoder.decode(chunk as any),
+        )) {
+          if (message.data) {
+            try {
+              const sseMessage = JSON.parse(message.data);
+              yield sseMessage as SSEMessage;
+            } catch (_err) {
+              throw new SubstrateError(
+                `Bad Server-Sent Event message: ${message}`,
+              );
+            }
+          }
+        }
+      }
+    }
+
+    return new StreamingResponse(response, iterator());
+  }
+}
+
+/**
+ * `SubstrateStreamingResponse`
+ */
+export class SubstrateStreamingResponse extends StreamingResponse {
+  public apiRequest: Request;
+
+  constructor(request: Request, response: Response, iterator: any) {
+    super(response, iterator);
+    this.apiRequest = request;
+  }
+
+  async *get<T extends AnyNode>(
+    node: T,
+  ): AsyncGenerator<NodeMessage<NodeOutput<T>>> {
+    for await (let message of this) {
+      if (message?.node_id === node.id) {
+        yield message as NodeMessage<NodeOutput<T>>;
+      }
+    }
+  }
+
+  override tee(n: number = 2) {
+    return tee(n, this.iterator).map(
+      (iterator) =>
+        new SubstrateStreamingResponse(
+          this.apiRequest,
+          this.apiResponse,
+          iterator,
+        ),
+    );
+  }
+
+  static async fromRequestReponse(request: Request, response: Response) {
+    const streamingResponse = await StreamingResponse.fromReponse(response);
+    return new SubstrateStreamingResponse(
+      request,
+      response,
+      streamingResponse.iterator,
+    );
+  }
+}
+
+function readableStreamAsyncIterable(stream: any) {
+  // When stream is already an iterator we return it. This is the case when using a
+  // `response.body` from node-fetch.
+  if (stream[Symbol.asyncIterator]) return stream;
+
+  // Otherwise we use getReader and produce an async iterable from the ReadableStream.
+  // This is the variant we would see when using an implementation of fetch closer to
+  // the web.
+  const reader = stream.getReader();
+  return {
+    async next() {
+      try {
+        const result = await reader.read();
+        if (result?.done) reader.releaseLock(); // release lock when stream becomes closed
+        return result;
+      } catch (e) {
+        reader.releaseLock(); // release lock when stream becomes errored
+        throw e;
+      }
+    },
+    async return() {
+      const cancelPromise = reader.cancel();
+      reader.releaseLock();
+      await cancelPromise;
+      return { done: true, value: undefined };
+    },
+    [Symbol.asyncIterator]() {
+      return this;
+    },
+  };
+}
+
+function tee(n: number = 2, iterator: any) {
+  const queues: any[] = [];
+  for (let i = 0; i < n; i++) {
+    queues.push([]);
+  }
+
+  const teeIterator = (queue: SSEMessage[]) => {
+    return {
+      next: () => {
+        if (queue.length === 0) {
+          const result = iterator.next();
+          for (let q of queues) q.push(result);
+        }
+        return queue.shift();
+      },
+    };
+  };
+
+  return queues.map((q) => teeIterator(q));
+}

package/src/idGenerator.ts

@@ -0,0 +1,20 @@
+export function randomString(length: number): string {
+  const alphabet: string =
+    "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_-";
+  let randomString: string = "";
+  for (let i = 0; i < length; i++) {
+    const randomIndex: number = Math.floor(Math.random() * alphabet.length);
+    randomString += alphabet[randomIndex];
+  }
+  return randomString;
+}
+
+// Generates incrementing ids, for better legibility
+export function idGenerator(prefix: string, start: number = 1): any {
+  let n = start;
+  return () => {
+    const id = `${prefix}${n.toString()}_${randomString(8)}`;
+    n = n + 1;
+    return id;
+  };
+}

package/src/index.ts

@@ -0,0 +1,58 @@
+/**
+ * 𐃏 Substrate TypeScript SDK
+ * @generated file
+ * 20240617.20240806
+ */
+
+export { SubstrateError } from "substrate/Error";
+export {
+  Experimental,
+  Box,
+  If,
+  ComputeText,
+  MultiComputeText,
+  BatchComputeText,
+  BatchComputeJSON,
+  ComputeJSON,
+  MultiComputeJSON,
+  Mistral7BInstruct,
+  Mixtral8x7BInstruct,
+  Llama3Instruct8B,
+  Llama3Instruct70B,
+  Firellava13B,
+  GenerateImage,
+  MultiGenerateImage,
+  InpaintImage,
+  MultiInpaintImage,
+  StableDiffusionXLLightning,
+  StableDiffusionXLInpaint,
+  StableDiffusionXLControlNet,
+  StableVideoDiffusion,
+  InterpolateFrames,
+  TranscribeSpeech,
+  GenerateSpeech,
+  RemoveBackground,
+  EraseImage,
+  UpscaleImage,
+  SegmentUnderPoint,
+  SegmentAnything,
+  SplitDocument,
+  EmbedText,
+  MultiEmbedText,
+  EmbedImage,
+  MultiEmbedImage,
+  JinaV2,
+  CLIP,
+  FindOrCreateVectorStore,
+  ListVectorStores,
+  DeleteVectorStore,
+  QueryVectorStore,
+  FetchVectors,
+  UpdateVectors,
+  DeleteVectors,
+} from "substrate/Nodes";
+
+export { sb } from "substrate/sb";
+export { Substrate };
+import { Substrate } from "substrate/Substrate";
+export default Substrate;

package/src/nodejs/index.ts

@@ -0,0 +1,3 @@
+// entrypoint for nodejs build
+import "substrate/nodejs/polyfill";
+export * from "..";

package/src/nodejs/polyfill.ts

@@ -0,0 +1,16 @@
+/**
+ * While we're generally aiming to support ES2022 and Node 18+ we're also including
+ * polyfill code for now for some of the Standard Web APIs that we use in this SDK.
+ */
+import fetch, { Headers, Request, Response } from "node-fetch";
+
+if (!globalThis.fetch) {
+  // @ts-ignore
+  globalThis.fetch = fetch;
+  // @ts-ignore
+  globalThis.Headers = Headers;
+  // @ts-ignore
+  globalThis.Request = Request;
+  // @ts-ignore
+  globalThis.Response = Response;
+}