instill-sdk 0.0.1

package/dist/protogen-ts/model/model/v1alpha/task_semantic_segmentation.ts

@@ -0,0 +1,396 @@
+/* eslint-disable */
+import * as _m0 from "protobufjs/minimal";
+
+export const protobufPackage = "model.model.v1alpha";
+
+/** SemanticSegmentationStuff corresponding to a semantic segmentation stuff */
+export interface SemanticSegmentationStuff {
+  /** RLE segmentation mask */
+  rle: string;
+  /** Stuff category */
+  category: string;
+}
+
+/** SemanticSegmentationInput represents the input of semantic segmentation task */
+export interface SemanticSegmentationInput {
+  /** Image type URL */
+  imageUrl?:
+    | string
+    | undefined;
+  /** Image type base64 */
+  imageBase64?: string | undefined;
+}
+
+/**
+ * SemanticSegmentationInputStream represents the input of semantic segmentation
+ * task when using stream method
+ */
+export interface SemanticSegmentationInputStream {
+  /** The list of file length for each uploaded binary file */
+  fileLengths: number[];
+  /** Content of images in bytes */
+  content: Uint8Array;
+}
+
+/**
+ * SemanticSegmentationOutput represents the output of semantic segmentation
+ * task
+ */
+export interface SemanticSegmentationOutput {
+  /** A list of semantic segmentation stuffs */
+  stuffs: SemanticSegmentationStuff[];
+}
+
+function createBaseSemanticSegmentationStuff(): SemanticSegmentationStuff {
+  return { rle: "", category: "" };
+}
+
+export const SemanticSegmentationStuff = {
+  encode(message: SemanticSegmentationStuff, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.rle !== "") {
+      writer.uint32(10).string(message.rle);
+    }
+    if (message.category !== "") {
+      writer.uint32(18).string(message.category);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): SemanticSegmentationStuff {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseSemanticSegmentationStuff();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.rle = reader.string();
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.category = reader.string();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): SemanticSegmentationStuff {
+    return {
+      rle: isSet(object.rle) ? String(object.rle) : "",
+      category: isSet(object.category) ? String(object.category) : "",
+    };
+  },
+
+  toJSON(message: SemanticSegmentationStuff): unknown {
+    const obj: any = {};
+    if (message.rle !== "") {
+      obj.rle = message.rle;
+    }
+    if (message.category !== "") {
+      obj.category = message.category;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<SemanticSegmentationStuff>, I>>(base?: I): SemanticSegmentationStuff {
+    return SemanticSegmentationStuff.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<SemanticSegmentationStuff>, I>>(object: I): SemanticSegmentationStuff {
+    const message = createBaseSemanticSegmentationStuff();
+    message.rle = object.rle ?? "";
+    message.category = object.category ?? "";
+    return message;
+  },
+};
+
+function createBaseSemanticSegmentationInput(): SemanticSegmentationInput {
+  return { imageUrl: undefined, imageBase64: undefined };
+}
+
+export const SemanticSegmentationInput = {
+  encode(message: SemanticSegmentationInput, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.imageUrl !== undefined) {
+      writer.uint32(10).string(message.imageUrl);
+    }
+    if (message.imageBase64 !== undefined) {
+      writer.uint32(18).string(message.imageBase64);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): SemanticSegmentationInput {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseSemanticSegmentationInput();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.imageUrl = reader.string();
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.imageBase64 = reader.string();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): SemanticSegmentationInput {
+    return {
+      imageUrl: isSet(object.imageUrl) ? String(object.imageUrl) : undefined,
+      imageBase64: isSet(object.imageBase64) ? String(object.imageBase64) : undefined,
+    };
+  },
+
+  toJSON(message: SemanticSegmentationInput): unknown {
+    const obj: any = {};
+    if (message.imageUrl !== undefined) {
+      obj.imageUrl = message.imageUrl;
+    }
+    if (message.imageBase64 !== undefined) {
+      obj.imageBase64 = message.imageBase64;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<SemanticSegmentationInput>, I>>(base?: I): SemanticSegmentationInput {
+    return SemanticSegmentationInput.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<SemanticSegmentationInput>, I>>(object: I): SemanticSegmentationInput {
+    const message = createBaseSemanticSegmentationInput();
+    message.imageUrl = object.imageUrl ?? undefined;
+    message.imageBase64 = object.imageBase64 ?? undefined;
+    return message;
+  },
+};
+
+function createBaseSemanticSegmentationInputStream(): SemanticSegmentationInputStream {
+  return { fileLengths: [], content: new Uint8Array(0) };
+}
+
+export const SemanticSegmentationInputStream = {
+  encode(message: SemanticSegmentationInputStream, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    writer.uint32(10).fork();
+    for (const v of message.fileLengths) {
+      writer.uint32(v);
+    }
+    writer.ldelim();
+    if (message.content.length !== 0) {
+      writer.uint32(18).bytes(message.content);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): SemanticSegmentationInputStream {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseSemanticSegmentationInputStream();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag === 8) {
+            message.fileLengths.push(reader.uint32());
+
+            continue;
+          }
+
+          if (tag === 10) {
+            const end2 = reader.uint32() + reader.pos;
+            while (reader.pos < end2) {
+              message.fileLengths.push(reader.uint32());
+            }
+
+            continue;
+          }
+
+          break;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.content = reader.bytes();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): SemanticSegmentationInputStream {
+    return {
+      fileLengths: Array.isArray(object?.fileLengths) ? object.fileLengths.map((e: any) => Number(e)) : [],
+      content: isSet(object.content) ? bytesFromBase64(object.content) : new Uint8Array(0),
+    };
+  },
+
+  toJSON(message: SemanticSegmentationInputStream): unknown {
+    const obj: any = {};
+    if (message.fileLengths?.length) {
+      obj.fileLengths = message.fileLengths.map((e) => Math.round(e));
+    }
+    if (message.content.length !== 0) {
+      obj.content = base64FromBytes(message.content);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<SemanticSegmentationInputStream>, I>>(base?: I): SemanticSegmentationInputStream {
+    return SemanticSegmentationInputStream.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<SemanticSegmentationInputStream>, I>>(
+    object: I,
+  ): SemanticSegmentationInputStream {
+    const message = createBaseSemanticSegmentationInputStream();
+    message.fileLengths = object.fileLengths?.map((e) => e) || [];
+    message.content = object.content ?? new Uint8Array(0);
+    return message;
+  },
+};
+
+function createBaseSemanticSegmentationOutput(): SemanticSegmentationOutput {
+  return { stuffs: [] };
+}
+
+export const SemanticSegmentationOutput = {
+  encode(message: SemanticSegmentationOutput, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    for (const v of message.stuffs) {
+      SemanticSegmentationStuff.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): SemanticSegmentationOutput {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseSemanticSegmentationOutput();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.stuffs.push(SemanticSegmentationStuff.decode(reader, reader.uint32()));
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): SemanticSegmentationOutput {
+    return {
+      stuffs: Array.isArray(object?.stuffs) ? object.stuffs.map((e: any) => SemanticSegmentationStuff.fromJSON(e)) : [],
+    };
+  },
+
+  toJSON(message: SemanticSegmentationOutput): unknown {
+    const obj: any = {};
+    if (message.stuffs?.length) {
+      obj.stuffs = message.stuffs.map((e) => SemanticSegmentationStuff.toJSON(e));
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<SemanticSegmentationOutput>, I>>(base?: I): SemanticSegmentationOutput {
+    return SemanticSegmentationOutput.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<SemanticSegmentationOutput>, I>>(object: I): SemanticSegmentationOutput {
+    const message = createBaseSemanticSegmentationOutput();
+    message.stuffs = object.stuffs?.map((e) => SemanticSegmentationStuff.fromPartial(e)) || [];
+    return message;
+  },
+};
+
+declare const self: any | undefined;
+declare const window: any | undefined;
+declare const global: any | undefined;
+const tsProtoGlobalThis: any = (() => {
+  if (typeof globalThis !== "undefined") {
+    return globalThis;
+  }
+  if (typeof self !== "undefined") {
+    return self;
+  }
+  if (typeof window !== "undefined") {
+    return window;
+  }
+  if (typeof global !== "undefined") {
+    return global;
+  }
+  throw "Unable to locate global object";
+})();
+
+function bytesFromBase64(b64: string): Uint8Array {
+  if (tsProtoGlobalThis.Buffer) {
+    return Uint8Array.from(tsProtoGlobalThis.Buffer.from(b64, "base64"));
+  } else {
+    const bin = tsProtoGlobalThis.atob(b64);
+    const arr = new Uint8Array(bin.length);
+    for (let i = 0; i < bin.length; ++i) {
+      arr[i] = bin.charCodeAt(i);
+    }
+    return arr;
+  }
+}
+
+function base64FromBytes(arr: Uint8Array): string {
+  if (tsProtoGlobalThis.Buffer) {
+    return tsProtoGlobalThis.Buffer.from(arr).toString("base64");
+  } else {
+    const bin: string[] = [];
+    arr.forEach((byte) => {
+      bin.push(String.fromCharCode(byte));
+    });
+    return tsProtoGlobalThis.btoa(bin.join(""));
+  }
+}
+
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+
+export type DeepPartial<T> = T extends Builtin ? T
+  : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>>
+  : T extends {} ? { [K in keyof T]?: DeepPartial<T[K]> }
+  : Partial<T>;
+
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin ? P
+  : P & { [K in keyof P]: Exact<P[K], I[K]> } & { [K in Exclude<keyof I, KeysOfUnion<P>>]: never };
+
+function isSet(value: any): boolean {
+  return value !== null && value !== undefined;
+}

package/dist/protogen-ts/model/model/v1alpha/task_text_generation.ts

@@ -0,0 +1,247 @@
+/* eslint-disable */
+import * as _m0 from "protobufjs/minimal";
+
+export const protobufPackage = "model.model.v1alpha";
+
+/** TextGenerationInput represents the input of text generation task */
+export interface TextGenerationInput {
+  /** The prompt text */
+  prompt: string;
+  /** The maximum number of tokens for model to generate */
+  outputLen?:
+    | number
+    | undefined;
+  /** The words not to avoid being generated by the model */
+  badWordsList?:
+    | string
+    | undefined;
+  /** The trigger words to stop generation */
+  stopWordsList?:
+    | string
+    | undefined;
+  /** Top k for sampling */
+  topk?:
+    | number
+    | undefined;
+  /** The seed */
+  seed?: number | undefined;
+}
+
+/** TextGenerationOutput represents the output of text generation task */
+export interface TextGenerationOutput {
+  /** The text generated by the model */
+  text: string;
+}
+
+function createBaseTextGenerationInput(): TextGenerationInput {
+  return {
+    prompt: "",
+    outputLen: undefined,
+    badWordsList: undefined,
+    stopWordsList: undefined,
+    topk: undefined,
+    seed: undefined,
+  };
+}
+
+export const TextGenerationInput = {
+  encode(message: TextGenerationInput, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.prompt !== "") {
+      writer.uint32(10).string(message.prompt);
+    }
+    if (message.outputLen !== undefined) {
+      writer.uint32(16).int32(message.outputLen);
+    }
+    if (message.badWordsList !== undefined) {
+      writer.uint32(26).string(message.badWordsList);
+    }
+    if (message.stopWordsList !== undefined) {
+      writer.uint32(34).string(message.stopWordsList);
+    }
+    if (message.topk !== undefined) {
+      writer.uint32(40).int32(message.topk);
+    }
+    if (message.seed !== undefined) {
+      writer.uint32(48).int32(message.seed);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): TextGenerationInput {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseTextGenerationInput();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.prompt = reader.string();
+          continue;
+        case 2:
+          if (tag !== 16) {
+            break;
+          }
+
+          message.outputLen = reader.int32();
+          continue;
+        case 3:
+          if (tag !== 26) {
+            break;
+          }
+
+          message.badWordsList = reader.string();
+          continue;
+        case 4:
+          if (tag !== 34) {
+            break;
+          }
+
+          message.stopWordsList = reader.string();
+          continue;
+        case 5:
+          if (tag !== 40) {
+            break;
+          }
+
+          message.topk = reader.int32();
+          continue;
+        case 6:
+          if (tag !== 48) {
+            break;
+          }
+
+          message.seed = reader.int32();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): TextGenerationInput {
+    return {
+      prompt: isSet(object.prompt) ? String(object.prompt) : "",
+      outputLen: isSet(object.outputLen) ? Number(object.outputLen) : undefined,
+      badWordsList: isSet(object.badWordsList) ? String(object.badWordsList) : undefined,
+      stopWordsList: isSet(object.stopWordsList) ? String(object.stopWordsList) : undefined,
+      topk: isSet(object.topk) ? Number(object.topk) : undefined,
+      seed: isSet(object.seed) ? Number(object.seed) : undefined,
+    };
+  },
+
+  toJSON(message: TextGenerationInput): unknown {
+    const obj: any = {};
+    if (message.prompt !== "") {
+      obj.prompt = message.prompt;
+    }
+    if (message.outputLen !== undefined) {
+      obj.outputLen = Math.round(message.outputLen);
+    }
+    if (message.badWordsList !== undefined) {
+      obj.badWordsList = message.badWordsList;
+    }
+    if (message.stopWordsList !== undefined) {
+      obj.stopWordsList = message.stopWordsList;
+    }
+    if (message.topk !== undefined) {
+      obj.topk = Math.round(message.topk);
+    }
+    if (message.seed !== undefined) {
+      obj.seed = Math.round(message.seed);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<TextGenerationInput>, I>>(base?: I): TextGenerationInput {
+    return TextGenerationInput.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<TextGenerationInput>, I>>(object: I): TextGenerationInput {
+    const message = createBaseTextGenerationInput();
+    message.prompt = object.prompt ?? "";
+    message.outputLen = object.outputLen ?? undefined;
+    message.badWordsList = object.badWordsList ?? undefined;
+    message.stopWordsList = object.stopWordsList ?? undefined;
+    message.topk = object.topk ?? undefined;
+    message.seed = object.seed ?? undefined;
+    return message;
+  },
+};
+
+function createBaseTextGenerationOutput(): TextGenerationOutput {
+  return { text: "" };
+}
+
+export const TextGenerationOutput = {
+  encode(message: TextGenerationOutput, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.text !== "") {
+      writer.uint32(10).string(message.text);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): TextGenerationOutput {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseTextGenerationOutput();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.text = reader.string();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): TextGenerationOutput {
+    return { text: isSet(object.text) ? String(object.text) : "" };
+  },
+
+  toJSON(message: TextGenerationOutput): unknown {
+    const obj: any = {};
+    if (message.text !== "") {
+      obj.text = message.text;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<TextGenerationOutput>, I>>(base?: I): TextGenerationOutput {
+    return TextGenerationOutput.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<TextGenerationOutput>, I>>(object: I): TextGenerationOutput {
+    const message = createBaseTextGenerationOutput();
+    message.text = object.text ?? "";
+    return message;
+  },
+};
+
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+
+export type DeepPartial<T> = T extends Builtin ? T
+  : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>>
+  : T extends {} ? { [K in keyof T]?: DeepPartial<T[K]> }
+  : Partial<T>;
+
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin ? P
+  : P & { [K in keyof P]: Exact<P[K], I[K]> } & { [K in Exclude<keyof I, KeysOfUnion<P>>]: never };
+
+function isSet(value: any): boolean {
+  return value !== null && value !== undefined;
+}