From 10c68658790f584b856756e54136204297c9f870 Mon Sep 17 00:00:00 2001 From: David Marx Date: Mon, 19 Sep 2022 17:45:12 -0700 Subject: [PATCH] Submodule protobuf (#41) * api-interfaces submodule * added protobuf update CI workflow --- .github/workflows/update-interfaces.yml | 55 + .gitmodules | 3 + api-interfaces | 1 + src/js/generation_pb.d.ts | 187 +- src/js/generation_pb.js | 1690 +++++++++++++++-- src/js/generation_pb_service.d.ts | 11 + src/js/generation_pb_service.js | 48 + src/proto/generation.proto | 45 +- .../gooseai/generation/generation_pb2.py | 88 +- .../gooseai/generation/generation_pb2_grpc.py | 35 +- 10 files changed, 1962 insertions(+), 201 deletions(-) create mode 100644 .github/workflows/update-interfaces.yml create mode 100644 .gitmodules create mode 160000 api-interfaces diff --git a/.github/workflows/update-interfaces.yml b/.github/workflows/update-interfaces.yml new file mode 100644 index 00000000..ba28462b --- /dev/null +++ b/.github/workflows/update-interfaces.yml @@ -0,0 +1,55 @@ +name: Update protobuf stubs + +on: + push: + workflow_dispatch: + +jobs: + update_proto: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v2 + with: + submodules: recursive + - name: Copy files + run: | + SRC=./api-interfaces/gooseai + TGT=./src/stability_sdk/interfaces/gooseai + KIND=generation + cp $SRC/$KIND/${KIND}_pb2_grpc.py $TGT/$KIND/${KIND}_pb2_grpc.py + cp $SRC/$KIND/${KIND}_pb2.py $TGT/$KIND/${KIND}_pb2.py + ############################# + # for backwards compatibility + ############################# + cp ./api-interfaces/src/proto/generation.proto ./src/proto/generation.proto + cp $SRC/$KIND/${KIND}_pb_service.d.ts ./src/js/${KIND}_pb_service.d.ts + cp $SRC/$KIND/${KIND}_pb_service.js ./src/js/${KIND}_pb_service.js + cp $SRC/$KIND/${KIND}_pb.d.ts ./src/js/${KIND}_pb.d.ts + cp $SRC/$KIND/${KIND}_pb.js ./src/js/${KIND}_pb.js + #- name: Commit files + # run: | + # shopt -s globstar + # git config --local user.name ${{ github.actor }} + # git add ./src/**/*.py + # git add ./src/**/*.js + # git add ./src/**/*.ts + # git add ./src/**/*.proto + # git commit -m "Updated protobuf files" + #- name: Push change + # uses: ad-m/github-push-action@master + # with: + # github_token: ${{ secrets.GITHUB_TOKEN }} + # branch: ${{ github.ref }} + - name: Create Pull Request + uses: peter-evans/create-pull-request@v4 + with: + token: ${{ secrets.GITHUB_TOKEN }} + add-paths: | + api-interfaces/ + src/ + base: main + delete-branch: true + branch: "actions/update-interfaces" + commit-message: "chore: update protobuf stubs" + title: "chore: update protobuf stubs" + body: "Update protobuf stubs from changes in ${{ github.sha }}" diff --git a/.gitmodules b/.gitmodules new file mode 100644 index 00000000..8c3e7ffd --- /dev/null +++ b/.gitmodules @@ -0,0 +1,3 @@ +[submodule "api-interfaces"] + path = api-interfaces + url = https://github.com/stability-ai/api-interfaces diff --git a/api-interfaces b/api-interfaces new file mode 160000 index 00000000..c54bcef5 --- /dev/null +++ b/api-interfaces @@ -0,0 +1 @@ +Subproject commit c54bcef52d6c3ba190bf98cfc660454acce4abb3 diff --git a/src/js/generation_pb.d.ts b/src/js/generation_pb.d.ts index 36553938..7669999d 100644 --- a/src/js/generation_pb.d.ts +++ b/src/js/generation_pb.d.ts @@ -366,6 +366,34 @@ export namespace ConditionerParameters { } } +export class ScheduleParameters extends jspb.Message { + hasStart(): boolean; + clearStart(): void; + getStart(): number; + setStart(value: number): void; + + hasEnd(): boolean; + clearEnd(): void; + getEnd(): number; + setEnd(value: number): void; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): ScheduleParameters.AsObject; + static toObject(includeInstance: boolean, msg: ScheduleParameters): ScheduleParameters.AsObject; + static extensions: {[key: number]: jspb.ExtensionFieldInfo}; + static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo}; + static serializeBinaryToWriter(message: ScheduleParameters, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): ScheduleParameters; + static deserializeBinaryFromReader(message: ScheduleParameters, reader: jspb.BinaryReader): ScheduleParameters; +} + +export namespace ScheduleParameters { + export type AsObject = { + start: number, + end: number, + } +} + export class StepParameter extends jspb.Message { getScaledStep(): number; setScaledStep(value: number): void; @@ -375,6 +403,11 @@ export class StepParameter extends jspb.Message { getSampler(): SamplerParameters | undefined; setSampler(value?: SamplerParameters): void; + hasSchedule(): boolean; + clearSchedule(): void; + getSchedule(): ScheduleParameters | undefined; + setSchedule(value?: ScheduleParameters): void; + serializeBinary(): Uint8Array; toObject(includeInstance?: boolean): StepParameter.AsObject; static toObject(includeInstance: boolean, msg: StepParameter): StepParameter.AsObject; @@ -389,6 +422,7 @@ export namespace StepParameter { export type AsObject = { scaledStep: number, sampler?: SamplerParameters.AsObject, + schedule?: ScheduleParameters.AsObject, } } @@ -589,6 +623,30 @@ export namespace ClassifierParameters { } } +export class AssetParameters extends jspb.Message { + getAction(): AssetActionMap[keyof AssetActionMap]; + setAction(value: AssetActionMap[keyof AssetActionMap]): void; + + getProject(): string; + setProject(value: string): void; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): AssetParameters.AsObject; + static toObject(includeInstance: boolean, msg: AssetParameters): AssetParameters.AsObject; + static extensions: {[key: number]: jspb.ExtensionFieldInfo}; + static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo}; + static serializeBinaryToWriter(message: AssetParameters, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): AssetParameters; + static deserializeBinaryFromReader(message: AssetParameters, reader: jspb.BinaryReader): AssetParameters; +} + +export namespace AssetParameters { + export type AsObject = { + action: AssetActionMap[keyof AssetActionMap], + project: string, + } +} + export class Request extends jspb.Message { getEngineId(): string; setEngineId(value: string): void; @@ -609,16 +667,21 @@ export class Request extends jspb.Message { getImage(): ImageParameters | undefined; setImage(value?: ImageParameters): void; - hasConditioner(): boolean; - clearConditioner(): void; - getConditioner(): ConditionerParameters | undefined; - setConditioner(value?: ConditionerParameters): void; - hasClassifier(): boolean; clearClassifier(): void; getClassifier(): ClassifierParameters | undefined; setClassifier(value?: ClassifierParameters): void; + hasAsset(): boolean; + clearAsset(): void; + getAsset(): AssetParameters | undefined; + setAsset(value?: AssetParameters): void; + + hasConditioner(): boolean; + clearConditioner(): void; + getConditioner(): ConditionerParameters | undefined; + setConditioner(value?: ConditionerParameters): void; + getParamsCase(): Request.ParamsCase; serializeBinary(): Uint8Array; toObject(includeInstance?: boolean): Request.AsObject; @@ -637,13 +700,108 @@ export namespace Request { requestedType: ArtifactTypeMap[keyof ArtifactTypeMap], promptList: Array, image?: ImageParameters.AsObject, - conditioner?: ConditionerParameters.AsObject, classifier?: ClassifierParameters.AsObject, + asset?: AssetParameters.AsObject, + conditioner?: ConditionerParameters.AsObject, } export enum ParamsCase { PARAMS_NOT_SET = 0, IMAGE = 5, + CLASSIFIER = 7, + ASSET = 8, + } +} + +export class OnStatus extends jspb.Message { + clearReasonList(): void; + getReasonList(): Array; + setReasonList(value: Array): void; + addReason(value: FinishReasonMap[keyof FinishReasonMap], index?: number): FinishReasonMap[keyof FinishReasonMap]; + + hasTarget(): boolean; + clearTarget(): void; + getTarget(): string; + setTarget(value: string): void; + + clearActionList(): void; + getActionList(): Array; + setActionList(value: Array): void; + addAction(value: StageActionMap[keyof StageActionMap], index?: number): StageActionMap[keyof StageActionMap]; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): OnStatus.AsObject; + static toObject(includeInstance: boolean, msg: OnStatus): OnStatus.AsObject; + static extensions: {[key: number]: jspb.ExtensionFieldInfo}; + static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo}; + static serializeBinaryToWriter(message: OnStatus, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): OnStatus; + static deserializeBinaryFromReader(message: OnStatus, reader: jspb.BinaryReader): OnStatus; +} + +export namespace OnStatus { + export type AsObject = { + reasonList: Array, + target: string, + actionList: Array, + } +} + +export class Stage extends jspb.Message { + getId(): string; + setId(value: string): void; + + hasRequest(): boolean; + clearRequest(): void; + getRequest(): Request | undefined; + setRequest(value?: Request): void; + + clearOnStatusList(): void; + getOnStatusList(): Array; + setOnStatusList(value: Array): void; + addOnStatus(value?: OnStatus, index?: number): OnStatus; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): Stage.AsObject; + static toObject(includeInstance: boolean, msg: Stage): Stage.AsObject; + static extensions: {[key: number]: jspb.ExtensionFieldInfo}; + static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo}; + static serializeBinaryToWriter(message: Stage, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): Stage; + static deserializeBinaryFromReader(message: Stage, reader: jspb.BinaryReader): Stage; +} + +export namespace Stage { + export type AsObject = { + id: string, + request?: Request.AsObject, + onStatusList: Array, + } +} + +export class ChainRequest extends jspb.Message { + getRequestId(): string; + setRequestId(value: string): void; + + clearStageList(): void; + getStageList(): Array; + setStageList(value: Array): void; + addStage(value?: Stage, index?: number): Stage; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): ChainRequest.AsObject; + static toObject(includeInstance: boolean, msg: ChainRequest): ChainRequest.AsObject; + static extensions: {[key: number]: jspb.ExtensionFieldInfo}; + static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo}; + static serializeBinaryToWriter(message: ChainRequest, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): ChainRequest; + static deserializeBinaryFromReader(message: ChainRequest, reader: jspb.BinaryReader): ChainRequest; +} + +export namespace ChainRequest { + export type AsObject = { + requestId: string, + stageList: Array, } } @@ -665,6 +823,7 @@ export interface ArtifactTypeMap { ARTIFACT_TOKENS: 4; ARTIFACT_EMBEDDING: 5; ARTIFACT_CLASSIFICATIONS: 6; + ARTIFACT_MASK: 7; } export const ArtifactType: ArtifactTypeMap; @@ -708,3 +867,19 @@ export interface ClassifierModeMap { export const ClassifierMode: ClassifierModeMap; +export interface AssetActionMap { + ASSET_PUT: 0; + ASSET_GET: 1; + ASSET_DELETE: 2; +} + +export const AssetAction: AssetActionMap; + +export interface StageActionMap { + STAGE_ACTION_PASS: 0; + STAGE_ACTION_DISCARD: 1; + STAGE_ACTION_RETURN: 2; +} + +export const StageAction: StageActionMap; + diff --git a/src/js/generation_pb.js b/src/js/generation_pb.js index 2d14d205..195967b0 100644 --- a/src/js/generation_pb.js +++ b/src/js/generation_pb.js @@ -21,19 +21,27 @@ goog.exportSymbol('proto.gooseai.AnswerMeta', null, global); goog.exportSymbol('proto.gooseai.Artifact', null, global); goog.exportSymbol('proto.gooseai.Artifact.DataCase', null, global); goog.exportSymbol('proto.gooseai.ArtifactType', null, global); +goog.exportSymbol('proto.gooseai.AssetAction', null, global); +goog.exportSymbol('proto.gooseai.AssetParameters', null, global); +goog.exportSymbol('proto.gooseai.ChainRequest', null, global); goog.exportSymbol('proto.gooseai.ClassifierCategory', null, global); goog.exportSymbol('proto.gooseai.ClassifierConcept', null, global); +goog.exportSymbol('proto.gooseai.ClassifierMode', null, global); goog.exportSymbol('proto.gooseai.ClassifierParameters', null, global); goog.exportSymbol('proto.gooseai.ConditionerParameters', null, global); goog.exportSymbol('proto.gooseai.DiffusionSampler', null, global); goog.exportSymbol('proto.gooseai.FinishReason', null, global); goog.exportSymbol('proto.gooseai.ImageParameters', null, global); +goog.exportSymbol('proto.gooseai.OnStatus', null, global); goog.exportSymbol('proto.gooseai.Prompt', null, global); goog.exportSymbol('proto.gooseai.Prompt.PromptCase', null, global); goog.exportSymbol('proto.gooseai.PromptParameters', null, global); goog.exportSymbol('proto.gooseai.Request', null, global); goog.exportSymbol('proto.gooseai.Request.ParamsCase', null, global); goog.exportSymbol('proto.gooseai.SamplerParameters', null, global); +goog.exportSymbol('proto.gooseai.ScheduleParameters', null, global); +goog.exportSymbol('proto.gooseai.Stage', null, global); +goog.exportSymbol('proto.gooseai.StageAction', null, global); goog.exportSymbol('proto.gooseai.StepParameter', null, global); goog.exportSymbol('proto.gooseai.Token', null, global); goog.exportSymbol('proto.gooseai.Tokens', null, global); @@ -229,6 +237,27 @@ if (goog.DEBUG && !COMPILED) { */ proto.gooseai.ConditionerParameters.displayName = 'proto.gooseai.ConditionerParameters'; } +/** + * Generated by JsPbCodeGenerator. + * @param {Array=} opt_data Optional initial data array, typically from a + * server response, or constructed directly in Javascript. The array is used + * in place and becomes part of the constructed object. It is not cloned. + * If no data is provided, the constructed object will be empty, but still + * valid. + * @extends {jspb.Message} + * @constructor + */ +proto.gooseai.ScheduleParameters = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.gooseai.ScheduleParameters, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.gooseai.ScheduleParameters.displayName = 'proto.gooseai.ScheduleParameters'; +} /** * Generated by JsPbCodeGenerator. * @param {Array=} opt_data Optional initial data array, typically from a @@ -355,6 +384,27 @@ if (goog.DEBUG && !COMPILED) { */ proto.gooseai.ClassifierParameters.displayName = 'proto.gooseai.ClassifierParameters'; } +/** + * Generated by JsPbCodeGenerator. + * @param {Array=} opt_data Optional initial data array, typically from a + * server response, or constructed directly in Javascript. The array is used + * in place and becomes part of the constructed object. It is not cloned. + * If no data is provided, the constructed object will be empty, but still + * valid. + * @extends {jspb.Message} + * @constructor + */ +proto.gooseai.AssetParameters = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.gooseai.AssetParameters, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.gooseai.AssetParameters.displayName = 'proto.gooseai.AssetParameters'; +} /** * Generated by JsPbCodeGenerator. * @param {Array=} opt_data Optional initial data array, typically from a @@ -376,6 +426,69 @@ if (goog.DEBUG && !COMPILED) { */ proto.gooseai.Request.displayName = 'proto.gooseai.Request'; } +/** + * Generated by JsPbCodeGenerator. + * @param {Array=} opt_data Optional initial data array, typically from a + * server response, or constructed directly in Javascript. The array is used + * in place and becomes part of the constructed object. It is not cloned. + * If no data is provided, the constructed object will be empty, but still + * valid. + * @extends {jspb.Message} + * @constructor + */ +proto.gooseai.OnStatus = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, proto.gooseai.OnStatus.repeatedFields_, null); +}; +goog.inherits(proto.gooseai.OnStatus, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.gooseai.OnStatus.displayName = 'proto.gooseai.OnStatus'; +} +/** + * Generated by JsPbCodeGenerator. + * @param {Array=} opt_data Optional initial data array, typically from a + * server response, or constructed directly in Javascript. The array is used + * in place and becomes part of the constructed object. It is not cloned. + * If no data is provided, the constructed object will be empty, but still + * valid. + * @extends {jspb.Message} + * @constructor + */ +proto.gooseai.Stage = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, proto.gooseai.Stage.repeatedFields_, null); +}; +goog.inherits(proto.gooseai.Stage, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.gooseai.Stage.displayName = 'proto.gooseai.Stage'; +} +/** + * Generated by JsPbCodeGenerator. + * @param {Array=} opt_data Optional initial data array, typically from a + * server response, or constructed directly in Javascript. The array is used + * in place and becomes part of the constructed object. It is not cloned. + * If no data is provided, the constructed object will be empty, but still + * valid. + * @extends {jspb.Message} + * @constructor + */ +proto.gooseai.ChainRequest = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, proto.gooseai.ChainRequest.repeatedFields_, null); +}; +goog.inherits(proto.gooseai.ChainRequest, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.gooseai.ChainRequest.displayName = 'proto.gooseai.ChainRequest'; +} @@ -2991,8 +3104,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.gooseai.StepParameter.prototype.toObject = function(opt_includeInstance) { - return proto.gooseai.StepParameter.toObject(opt_includeInstance, this); +proto.gooseai.ScheduleParameters.prototype.toObject = function(opt_includeInstance) { + return proto.gooseai.ScheduleParameters.toObject(opt_includeInstance, this); }; @@ -3001,14 +3114,14 @@ proto.gooseai.StepParameter.prototype.toObject = function(opt_includeInstance) { * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.gooseai.StepParameter} msg The msg instance to transform. + * @param {!proto.gooseai.ScheduleParameters} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.gooseai.StepParameter.toObject = function(includeInstance, msg) { +proto.gooseai.ScheduleParameters.toObject = function(includeInstance, msg) { var f, obj = { - scaledStep: jspb.Message.getFloatingPointFieldWithDefault(msg, 1, 0.0), - sampler: (f = msg.getSampler()) && proto.gooseai.SamplerParameters.toObject(includeInstance, f) + start: jspb.Message.getFloatingPointFieldWithDefault(msg, 1, 0.0), + end: jspb.Message.getFloatingPointFieldWithDefault(msg, 2, 0.0) }; if (includeInstance) { @@ -3022,23 +3135,23 @@ proto.gooseai.StepParameter.toObject = function(includeInstance, msg) { /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.gooseai.StepParameter} + * @return {!proto.gooseai.ScheduleParameters} */ -proto.gooseai.StepParameter.deserializeBinary = function(bytes) { +proto.gooseai.ScheduleParameters.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.gooseai.StepParameter; - return proto.gooseai.StepParameter.deserializeBinaryFromReader(msg, reader); + var msg = new proto.gooseai.ScheduleParameters; + return proto.gooseai.ScheduleParameters.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.gooseai.StepParameter} msg The message object to deserialize into. + * @param {!proto.gooseai.ScheduleParameters} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.gooseai.StepParameter} + * @return {!proto.gooseai.ScheduleParameters} */ -proto.gooseai.StepParameter.deserializeBinaryFromReader = function(msg, reader) { +proto.gooseai.ScheduleParameters.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -3047,12 +3160,11 @@ proto.gooseai.StepParameter.deserializeBinaryFromReader = function(msg, reader) switch (field) { case 1: var value = /** @type {number} */ (reader.readFloat()); - msg.setScaledStep(value); + msg.setStart(value); break; case 2: - var value = new proto.gooseai.SamplerParameters; - reader.readMessage(value,proto.gooseai.SamplerParameters.deserializeBinaryFromReader); - msg.setSampler(value); + var value = /** @type {number} */ (reader.readFloat()); + msg.setEnd(value); break; default: reader.skipField(); @@ -3067,9 +3179,9 @@ proto.gooseai.StepParameter.deserializeBinaryFromReader = function(msg, reader) * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.gooseai.StepParameter.prototype.serializeBinary = function() { +proto.gooseai.ScheduleParameters.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.gooseai.StepParameter.serializeBinaryToWriter(this, writer); + proto.gooseai.ScheduleParameters.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -3077,114 +3189,104 @@ proto.gooseai.StepParameter.prototype.serializeBinary = function() { /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.gooseai.StepParameter} message + * @param {!proto.gooseai.ScheduleParameters} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.gooseai.StepParameter.serializeBinaryToWriter = function(message, writer) { +proto.gooseai.ScheduleParameters.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getScaledStep(); - if (f !== 0.0) { + f = /** @type {number} */ (jspb.Message.getField(message, 1)); + if (f != null) { writer.writeFloat( 1, f ); } - f = message.getSampler(); + f = /** @type {number} */ (jspb.Message.getField(message, 2)); if (f != null) { - writer.writeMessage( + writer.writeFloat( 2, - f, - proto.gooseai.SamplerParameters.serializeBinaryToWriter + f ); } }; /** - * optional float scaled_step = 1; + * optional float start = 1; * @return {number} */ -proto.gooseai.StepParameter.prototype.getScaledStep = function() { +proto.gooseai.ScheduleParameters.prototype.getStart = function() { return /** @type {number} */ (jspb.Message.getFloatingPointFieldWithDefault(this, 1, 0.0)); }; /** * @param {number} value - * @return {!proto.gooseai.StepParameter} returns this + * @return {!proto.gooseai.ScheduleParameters} returns this */ -proto.gooseai.StepParameter.prototype.setScaledStep = function(value) { - return jspb.Message.setProto3FloatField(this, 1, value); +proto.gooseai.ScheduleParameters.prototype.setStart = function(value) { + return jspb.Message.setField(this, 1, value); }; /** - * optional SamplerParameters sampler = 2; - * @return {?proto.gooseai.SamplerParameters} + * Clears the field making it undefined. + * @return {!proto.gooseai.ScheduleParameters} returns this */ -proto.gooseai.StepParameter.prototype.getSampler = function() { - return /** @type{?proto.gooseai.SamplerParameters} */ ( - jspb.Message.getWrapperField(this, proto.gooseai.SamplerParameters, 2)); +proto.gooseai.ScheduleParameters.prototype.clearStart = function() { + return jspb.Message.setField(this, 1, undefined); }; /** - * @param {?proto.gooseai.SamplerParameters|undefined} value - * @return {!proto.gooseai.StepParameter} returns this -*/ -proto.gooseai.StepParameter.prototype.setSampler = function(value) { - return jspb.Message.setWrapperField(this, 2, value); + * Returns whether this field is set. + * @return {boolean} + */ +proto.gooseai.ScheduleParameters.prototype.hasStart = function() { + return jspb.Message.getField(this, 1) != null; }; /** - * Clears the message field making it undefined. - * @return {!proto.gooseai.StepParameter} returns this + * optional float end = 2; + * @return {number} */ -proto.gooseai.StepParameter.prototype.clearSampler = function() { - return this.setSampler(undefined); +proto.gooseai.ScheduleParameters.prototype.getEnd = function() { + return /** @type {number} */ (jspb.Message.getFloatingPointFieldWithDefault(this, 2, 0.0)); }; /** - * Returns whether this field is set. - * @return {boolean} + * @param {number} value + * @return {!proto.gooseai.ScheduleParameters} returns this */ -proto.gooseai.StepParameter.prototype.hasSampler = function() { - return jspb.Message.getField(this, 2) != null; +proto.gooseai.ScheduleParameters.prototype.setEnd = function(value) { + return jspb.Message.setField(this, 2, value); }; - -/** - * Oneof group definitions for this message. Each group defines the field - * numbers belonging to that group. When of these fields' value is set, all - * other fields in the group are cleared. During deserialization, if multiple - * fields are encountered for a group, only the last value seen will be kept. - * @private {!Array>} - * @const - */ -proto.gooseai.TransformType.oneofGroups_ = [[1,2]]; - /** - * @enum {number} + * Clears the field making it undefined. + * @return {!proto.gooseai.ScheduleParameters} returns this */ -proto.gooseai.TransformType.TypeCase = { - TYPE_NOT_SET: 0, - DIFFUSION: 1, - UPSCALER: 2 +proto.gooseai.ScheduleParameters.prototype.clearEnd = function() { + return jspb.Message.setField(this, 2, undefined); }; + /** - * @return {proto.gooseai.TransformType.TypeCase} + * Returns whether this field is set. + * @return {boolean} */ -proto.gooseai.TransformType.prototype.getTypeCase = function() { - return /** @type {proto.gooseai.TransformType.TypeCase} */(jspb.Message.computeOneofCase(this, proto.gooseai.TransformType.oneofGroups_[0])); +proto.gooseai.ScheduleParameters.prototype.hasEnd = function() { + return jspb.Message.getField(this, 2) != null; }; + + if (jspb.Message.GENERATE_TO_OBJECT) { /** * Creates an object representation of this proto. @@ -3198,8 +3300,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.gooseai.TransformType.prototype.toObject = function(opt_includeInstance) { - return proto.gooseai.TransformType.toObject(opt_includeInstance, this); +proto.gooseai.StepParameter.prototype.toObject = function(opt_includeInstance) { + return proto.gooseai.StepParameter.toObject(opt_includeInstance, this); }; @@ -3208,14 +3310,15 @@ proto.gooseai.TransformType.prototype.toObject = function(opt_includeInstance) { * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.gooseai.TransformType} msg The msg instance to transform. + * @param {!proto.gooseai.StepParameter} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.gooseai.TransformType.toObject = function(includeInstance, msg) { +proto.gooseai.StepParameter.toObject = function(includeInstance, msg) { var f, obj = { - diffusion: jspb.Message.getFieldWithDefault(msg, 1, 0), - upscaler: jspb.Message.getFieldWithDefault(msg, 2, 0) + scaledStep: jspb.Message.getFloatingPointFieldWithDefault(msg, 1, 0.0), + sampler: (f = msg.getSampler()) && proto.gooseai.SamplerParameters.toObject(includeInstance, f), + schedule: (f = msg.getSchedule()) && proto.gooseai.ScheduleParameters.toObject(includeInstance, f) }; if (includeInstance) { @@ -3229,23 +3332,23 @@ proto.gooseai.TransformType.toObject = function(includeInstance, msg) { /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.gooseai.TransformType} + * @return {!proto.gooseai.StepParameter} */ -proto.gooseai.TransformType.deserializeBinary = function(bytes) { +proto.gooseai.StepParameter.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.gooseai.TransformType; - return proto.gooseai.TransformType.deserializeBinaryFromReader(msg, reader); + var msg = new proto.gooseai.StepParameter; + return proto.gooseai.StepParameter.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.gooseai.TransformType} msg The message object to deserialize into. + * @param {!proto.gooseai.StepParameter} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.gooseai.TransformType} + * @return {!proto.gooseai.StepParameter} */ -proto.gooseai.TransformType.deserializeBinaryFromReader = function(msg, reader) { +proto.gooseai.StepParameter.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -3253,12 +3356,18 @@ proto.gooseai.TransformType.deserializeBinaryFromReader = function(msg, reader) var field = reader.getFieldNumber(); switch (field) { case 1: - var value = /** @type {!proto.gooseai.DiffusionSampler} */ (reader.readEnum()); - msg.setDiffusion(value); + var value = /** @type {number} */ (reader.readFloat()); + msg.setScaledStep(value); break; case 2: - var value = /** @type {!proto.gooseai.Upscaler} */ (reader.readEnum()); - msg.setUpscaler(value); + var value = new proto.gooseai.SamplerParameters; + reader.readMessage(value,proto.gooseai.SamplerParameters.deserializeBinaryFromReader); + msg.setSampler(value); + break; + case 3: + var value = new proto.gooseai.ScheduleParameters; + reader.readMessage(value,proto.gooseai.ScheduleParameters.deserializeBinaryFromReader); + msg.setSchedule(value); break; default: reader.skipField(); @@ -3273,9 +3382,9 @@ proto.gooseai.TransformType.deserializeBinaryFromReader = function(msg, reader) * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.gooseai.TransformType.prototype.serializeBinary = function() { +proto.gooseai.StepParameter.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.gooseai.TransformType.serializeBinaryToWriter(this, writer); + proto.gooseai.StepParameter.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -3283,43 +3392,294 @@ proto.gooseai.TransformType.prototype.serializeBinary = function() { /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.gooseai.TransformType} message + * @param {!proto.gooseai.StepParameter} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.gooseai.TransformType.serializeBinaryToWriter = function(message, writer) { +proto.gooseai.StepParameter.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = /** @type {!proto.gooseai.DiffusionSampler} */ (jspb.Message.getField(message, 1)); - if (f != null) { - writer.writeEnum( + f = message.getScaledStep(); + if (f !== 0.0) { + writer.writeFloat( 1, f ); } - f = /** @type {!proto.gooseai.Upscaler} */ (jspb.Message.getField(message, 2)); + f = message.getSampler(); if (f != null) { - writer.writeEnum( + writer.writeMessage( 2, - f + f, + proto.gooseai.SamplerParameters.serializeBinaryToWriter + ); + } + f = message.getSchedule(); + if (f != null) { + writer.writeMessage( + 3, + f, + proto.gooseai.ScheduleParameters.serializeBinaryToWriter ); } }; /** - * optional DiffusionSampler diffusion = 1; - * @return {!proto.gooseai.DiffusionSampler} + * optional float scaled_step = 1; + * @return {number} */ -proto.gooseai.TransformType.prototype.getDiffusion = function() { - return /** @type {!proto.gooseai.DiffusionSampler} */ (jspb.Message.getFieldWithDefault(this, 1, 0)); +proto.gooseai.StepParameter.prototype.getScaledStep = function() { + return /** @type {number} */ (jspb.Message.getFloatingPointFieldWithDefault(this, 1, 0.0)); }; /** - * @param {!proto.gooseai.DiffusionSampler} value - * @return {!proto.gooseai.TransformType} returns this + * @param {number} value + * @return {!proto.gooseai.StepParameter} returns this */ -proto.gooseai.TransformType.prototype.setDiffusion = function(value) { +proto.gooseai.StepParameter.prototype.setScaledStep = function(value) { + return jspb.Message.setProto3FloatField(this, 1, value); +}; + + +/** + * optional SamplerParameters sampler = 2; + * @return {?proto.gooseai.SamplerParameters} + */ +proto.gooseai.StepParameter.prototype.getSampler = function() { + return /** @type{?proto.gooseai.SamplerParameters} */ ( + jspb.Message.getWrapperField(this, proto.gooseai.SamplerParameters, 2)); +}; + + +/** + * @param {?proto.gooseai.SamplerParameters|undefined} value + * @return {!proto.gooseai.StepParameter} returns this +*/ +proto.gooseai.StepParameter.prototype.setSampler = function(value) { + return jspb.Message.setWrapperField(this, 2, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.gooseai.StepParameter} returns this + */ +proto.gooseai.StepParameter.prototype.clearSampler = function() { + return this.setSampler(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.gooseai.StepParameter.prototype.hasSampler = function() { + return jspb.Message.getField(this, 2) != null; +}; + + +/** + * optional ScheduleParameters schedule = 3; + * @return {?proto.gooseai.ScheduleParameters} + */ +proto.gooseai.StepParameter.prototype.getSchedule = function() { + return /** @type{?proto.gooseai.ScheduleParameters} */ ( + jspb.Message.getWrapperField(this, proto.gooseai.ScheduleParameters, 3)); +}; + + +/** + * @param {?proto.gooseai.ScheduleParameters|undefined} value + * @return {!proto.gooseai.StepParameter} returns this +*/ +proto.gooseai.StepParameter.prototype.setSchedule = function(value) { + return jspb.Message.setWrapperField(this, 3, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.gooseai.StepParameter} returns this + */ +proto.gooseai.StepParameter.prototype.clearSchedule = function() { + return this.setSchedule(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.gooseai.StepParameter.prototype.hasSchedule = function() { + return jspb.Message.getField(this, 3) != null; +}; + + + +/** + * Oneof group definitions for this message. Each group defines the field + * numbers belonging to that group. When of these fields' value is set, all + * other fields in the group are cleared. During deserialization, if multiple + * fields are encountered for a group, only the last value seen will be kept. + * @private {!Array>} + * @const + */ +proto.gooseai.TransformType.oneofGroups_ = [[1,2]]; + +/** + * @enum {number} + */ +proto.gooseai.TransformType.TypeCase = { + TYPE_NOT_SET: 0, + DIFFUSION: 1, + UPSCALER: 2 +}; + +/** + * @return {proto.gooseai.TransformType.TypeCase} + */ +proto.gooseai.TransformType.prototype.getTypeCase = function() { + return /** @type {proto.gooseai.TransformType.TypeCase} */(jspb.Message.computeOneofCase(this, proto.gooseai.TransformType.oneofGroups_[0])); +}; + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} + */ +proto.gooseai.TransformType.prototype.toObject = function(opt_includeInstance) { + return proto.gooseai.TransformType.toObject(opt_includeInstance, this); +}; + + +/** + * Static version of the {@see toObject} method. + * @param {boolean|undefined} includeInstance Deprecated. Whether to include + * the JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @param {!proto.gooseai.TransformType} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.gooseai.TransformType.toObject = function(includeInstance, msg) { + var f, obj = { + diffusion: jspb.Message.getFieldWithDefault(msg, 1, 0), + upscaler: jspb.Message.getFieldWithDefault(msg, 2, 0) + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.gooseai.TransformType} + */ +proto.gooseai.TransformType.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.gooseai.TransformType; + return proto.gooseai.TransformType.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.gooseai.TransformType} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.gooseai.TransformType} + */ +proto.gooseai.TransformType.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = /** @type {!proto.gooseai.DiffusionSampler} */ (reader.readEnum()); + msg.setDiffusion(value); + break; + case 2: + var value = /** @type {!proto.gooseai.Upscaler} */ (reader.readEnum()); + msg.setUpscaler(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.gooseai.TransformType.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.gooseai.TransformType.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.gooseai.TransformType} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.gooseai.TransformType.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = /** @type {!proto.gooseai.DiffusionSampler} */ (jspb.Message.getField(message, 1)); + if (f != null) { + writer.writeEnum( + 1, + f + ); + } + f = /** @type {!proto.gooseai.Upscaler} */ (jspb.Message.getField(message, 2)); + if (f != null) { + writer.writeEnum( + 2, + f + ); + } +}; + + +/** + * optional DiffusionSampler diffusion = 1; + * @return {!proto.gooseai.DiffusionSampler} + */ +proto.gooseai.TransformType.prototype.getDiffusion = function() { + return /** @type {!proto.gooseai.DiffusionSampler} */ (jspb.Message.getFieldWithDefault(this, 1, 0)); +}; + + +/** + * @param {!proto.gooseai.DiffusionSampler} value + * @return {!proto.gooseai.TransformType} returns this + */ +proto.gooseai.TransformType.prototype.setDiffusion = function(value) { return jspb.Message.setOneofField(this, 1, proto.gooseai.TransformType.oneofGroups_[0], value); }; @@ -4053,7 +4413,8 @@ proto.gooseai.ClassifierCategory.toObject = function(includeInstance, msg) { conceptsList: jspb.Message.toObjectList(msg.getConceptsList(), proto.gooseai.ClassifierConcept.toObject, includeInstance), adjustment: jspb.Message.getFloatingPointFieldWithDefault(msg, 3, 0.0), - action: jspb.Message.getFieldWithDefault(msg, 4, 0) + action: jspb.Message.getFieldWithDefault(msg, 4, 0), + classifierMode: jspb.Message.getFieldWithDefault(msg, 5, 0) }; if (includeInstance) { @@ -4107,6 +4468,10 @@ proto.gooseai.ClassifierCategory.deserializeBinaryFromReader = function(msg, rea var value = /** @type {!proto.gooseai.Action} */ (reader.readEnum()); msg.setAction(value); break; + case 5: + var value = /** @type {!proto.gooseai.ClassifierMode} */ (reader.readEnum()); + msg.setClassifierMode(value); + break; default: reader.skipField(); break; @@ -4165,6 +4530,13 @@ proto.gooseai.ClassifierCategory.serializeBinaryToWriter = function(message, wri f ); } + f = /** @type {!proto.gooseai.ClassifierMode} */ (jspb.Message.getField(message, 5)); + if (f != null) { + writer.writeEnum( + 5, + f + ); + } }; @@ -4296,21 +4668,57 @@ proto.gooseai.ClassifierCategory.prototype.hasAction = function() { }; - /** - * List of repeated fields within this message type. - * @private {!Array} - * @const + * optional ClassifierMode classifier_mode = 5; + * @return {!proto.gooseai.ClassifierMode} */ -proto.gooseai.ClassifierParameters.repeatedFields_ = [1,2]; +proto.gooseai.ClassifierCategory.prototype.getClassifierMode = function() { + return /** @type {!proto.gooseai.ClassifierMode} */ (jspb.Message.getFieldWithDefault(this, 5, 0)); +}; +/** + * @param {!proto.gooseai.ClassifierMode} value + * @return {!proto.gooseai.ClassifierCategory} returns this + */ +proto.gooseai.ClassifierCategory.prototype.setClassifierMode = function(value) { + return jspb.Message.setField(this, 5, value); +}; + -if (jspb.Message.GENERATE_TO_OBJECT) { /** - * Creates an object representation of this proto. - * Field names that are reserved in JavaScript and will be renamed to pb_name. - * Optional fields that are not set will be set to undefined. + * Clears the field making it undefined. + * @return {!proto.gooseai.ClassifierCategory} returns this + */ +proto.gooseai.ClassifierCategory.prototype.clearClassifierMode = function() { + return jspb.Message.setField(this, 5, undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.gooseai.ClassifierCategory.prototype.hasClassifierMode = function() { + return jspb.Message.getField(this, 5) != null; +}; + + + +/** + * List of repeated fields within this message type. + * @private {!Array} + * @const + */ +proto.gooseai.ClassifierParameters.repeatedFields_ = [1,2]; + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. * To access a reserved field use, foo.pb_, eg, foo.pb_default. * For the list of reserved names please see: * net/proto2/compiler/js/internal/generator.cc#kKeyword. @@ -4558,6 +4966,166 @@ proto.gooseai.ClassifierParameters.prototype.hasRealizedAction = function() { + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} + */ +proto.gooseai.AssetParameters.prototype.toObject = function(opt_includeInstance) { + return proto.gooseai.AssetParameters.toObject(opt_includeInstance, this); +}; + + +/** + * Static version of the {@see toObject} method. + * @param {boolean|undefined} includeInstance Deprecated. Whether to include + * the JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @param {!proto.gooseai.AssetParameters} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.gooseai.AssetParameters.toObject = function(includeInstance, msg) { + var f, obj = { + action: jspb.Message.getFieldWithDefault(msg, 1, 0), + project: jspb.Message.getFieldWithDefault(msg, 2, "") + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.gooseai.AssetParameters} + */ +proto.gooseai.AssetParameters.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.gooseai.AssetParameters; + return proto.gooseai.AssetParameters.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.gooseai.AssetParameters} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.gooseai.AssetParameters} + */ +proto.gooseai.AssetParameters.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = /** @type {!proto.gooseai.AssetAction} */ (reader.readEnum()); + msg.setAction(value); + break; + case 2: + var value = /** @type {string} */ (reader.readString()); + msg.setProject(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.gooseai.AssetParameters.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.gooseai.AssetParameters.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.gooseai.AssetParameters} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.gooseai.AssetParameters.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getAction(); + if (f !== 0.0) { + writer.writeEnum( + 1, + f + ); + } + f = message.getProject(); + if (f.length > 0) { + writer.writeString( + 2, + f + ); + } +}; + + +/** + * optional AssetAction action = 1; + * @return {!proto.gooseai.AssetAction} + */ +proto.gooseai.AssetParameters.prototype.getAction = function() { + return /** @type {!proto.gooseai.AssetAction} */ (jspb.Message.getFieldWithDefault(this, 1, 0)); +}; + + +/** + * @param {!proto.gooseai.AssetAction} value + * @return {!proto.gooseai.AssetParameters} returns this + */ +proto.gooseai.AssetParameters.prototype.setAction = function(value) { + return jspb.Message.setProto3EnumField(this, 1, value); +}; + + +/** + * optional string project = 2; + * @return {string} + */ +proto.gooseai.AssetParameters.prototype.getProject = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +}; + + +/** + * @param {string} value + * @return {!proto.gooseai.AssetParameters} returns this + */ +proto.gooseai.AssetParameters.prototype.setProject = function(value) { + return jspb.Message.setProto3StringField(this, 2, value); +}; + + + /** * List of repeated fields within this message type. * @private {!Array} @@ -4573,14 +5141,16 @@ proto.gooseai.Request.repeatedFields_ = [4]; * @private {!Array>} * @const */ -proto.gooseai.Request.oneofGroups_ = [[5]]; +proto.gooseai.Request.oneofGroups_ = [[5,7,8]]; /** * @enum {number} */ proto.gooseai.Request.ParamsCase = { PARAMS_NOT_SET: 0, - IMAGE: 5 + IMAGE: 5, + CLASSIFIER: 7, + ASSET: 8 }; /** @@ -4627,8 +5197,9 @@ proto.gooseai.Request.toObject = function(includeInstance, msg) { promptList: jspb.Message.toObjectList(msg.getPromptList(), proto.gooseai.Prompt.toObject, includeInstance), image: (f = msg.getImage()) && proto.gooseai.ImageParameters.toObject(includeInstance, f), - conditioner: (f = msg.getConditioner()) && proto.gooseai.ConditionerParameters.toObject(includeInstance, f), - classifier: (f = msg.getClassifier()) && proto.gooseai.ClassifierParameters.toObject(includeInstance, f) + classifier: (f = msg.getClassifier()) && proto.gooseai.ClassifierParameters.toObject(includeInstance, f), + asset: (f = msg.getAsset()) && proto.gooseai.AssetParameters.toObject(includeInstance, f), + conditioner: (f = msg.getConditioner()) && proto.gooseai.ConditionerParameters.toObject(includeInstance, f) }; if (includeInstance) { @@ -4687,16 +5258,21 @@ proto.gooseai.Request.deserializeBinaryFromReader = function(msg, reader) { reader.readMessage(value,proto.gooseai.ImageParameters.deserializeBinaryFromReader); msg.setImage(value); break; - case 6: - var value = new proto.gooseai.ConditionerParameters; - reader.readMessage(value,proto.gooseai.ConditionerParameters.deserializeBinaryFromReader); - msg.setConditioner(value); - break; case 7: var value = new proto.gooseai.ClassifierParameters; reader.readMessage(value,proto.gooseai.ClassifierParameters.deserializeBinaryFromReader); msg.setClassifier(value); break; + case 8: + var value = new proto.gooseai.AssetParameters; + reader.readMessage(value,proto.gooseai.AssetParameters.deserializeBinaryFromReader); + msg.setAsset(value); + break; + case 6: + var value = new proto.gooseai.ConditionerParameters; + reader.readMessage(value,proto.gooseai.ConditionerParameters.deserializeBinaryFromReader); + msg.setConditioner(value); + break; default: reader.skipField(); break; @@ -4763,20 +5339,28 @@ proto.gooseai.Request.serializeBinaryToWriter = function(message, writer) { proto.gooseai.ImageParameters.serializeBinaryToWriter ); } - f = message.getConditioner(); + f = message.getClassifier(); if (f != null) { writer.writeMessage( - 6, + 7, f, - proto.gooseai.ConditionerParameters.serializeBinaryToWriter + proto.gooseai.ClassifierParameters.serializeBinaryToWriter ); } - f = message.getClassifier(); + f = message.getAsset(); if (f != null) { writer.writeMessage( - 7, + 8, f, - proto.gooseai.ClassifierParameters.serializeBinaryToWriter + proto.gooseai.AssetParameters.serializeBinaryToWriter + ); + } + f = message.getConditioner(); + if (f != null) { + writer.writeMessage( + 6, + f, + proto.gooseai.ConditionerParameters.serializeBinaryToWriter ); } }; @@ -4912,21 +5496,21 @@ proto.gooseai.Request.prototype.hasImage = function() { /** - * optional ConditionerParameters conditioner = 6; - * @return {?proto.gooseai.ConditionerParameters} + * optional ClassifierParameters classifier = 7; + * @return {?proto.gooseai.ClassifierParameters} */ -proto.gooseai.Request.prototype.getConditioner = function() { - return /** @type{?proto.gooseai.ConditionerParameters} */ ( - jspb.Message.getWrapperField(this, proto.gooseai.ConditionerParameters, 6)); +proto.gooseai.Request.prototype.getClassifier = function() { + return /** @type{?proto.gooseai.ClassifierParameters} */ ( + jspb.Message.getWrapperField(this, proto.gooseai.ClassifierParameters, 7)); }; /** - * @param {?proto.gooseai.ConditionerParameters|undefined} value + * @param {?proto.gooseai.ClassifierParameters|undefined} value * @return {!proto.gooseai.Request} returns this */ -proto.gooseai.Request.prototype.setConditioner = function(value) { - return jspb.Message.setWrapperField(this, 6, value); +proto.gooseai.Request.prototype.setClassifier = function(value) { + return jspb.Message.setOneofWrapperField(this, 7, proto.gooseai.Request.oneofGroups_[0], value); }; @@ -4934,8 +5518,8 @@ proto.gooseai.Request.prototype.setConditioner = function(value) { * Clears the message field making it undefined. * @return {!proto.gooseai.Request} returns this */ -proto.gooseai.Request.prototype.clearConditioner = function() { - return this.setConditioner(undefined); +proto.gooseai.Request.prototype.clearClassifier = function() { + return this.setClassifier(undefined); }; @@ -4943,27 +5527,27 @@ proto.gooseai.Request.prototype.clearConditioner = function() { * Returns whether this field is set. * @return {boolean} */ -proto.gooseai.Request.prototype.hasConditioner = function() { - return jspb.Message.getField(this, 6) != null; +proto.gooseai.Request.prototype.hasClassifier = function() { + return jspb.Message.getField(this, 7) != null; }; /** - * optional ClassifierParameters classifier = 7; - * @return {?proto.gooseai.ClassifierParameters} + * optional AssetParameters asset = 8; + * @return {?proto.gooseai.AssetParameters} */ -proto.gooseai.Request.prototype.getClassifier = function() { - return /** @type{?proto.gooseai.ClassifierParameters} */ ( - jspb.Message.getWrapperField(this, proto.gooseai.ClassifierParameters, 7)); +proto.gooseai.Request.prototype.getAsset = function() { + return /** @type{?proto.gooseai.AssetParameters} */ ( + jspb.Message.getWrapperField(this, proto.gooseai.AssetParameters, 8)); }; /** - * @param {?proto.gooseai.ClassifierParameters|undefined} value + * @param {?proto.gooseai.AssetParameters|undefined} value * @return {!proto.gooseai.Request} returns this */ -proto.gooseai.Request.prototype.setClassifier = function(value) { - return jspb.Message.setWrapperField(this, 7, value); +proto.gooseai.Request.prototype.setAsset = function(value) { + return jspb.Message.setOneofWrapperField(this, 8, proto.gooseai.Request.oneofGroups_[0], value); }; @@ -4971,8 +5555,8 @@ proto.gooseai.Request.prototype.setClassifier = function(value) { * Clears the message field making it undefined. * @return {!proto.gooseai.Request} returns this */ -proto.gooseai.Request.prototype.clearClassifier = function() { - return this.setClassifier(undefined); +proto.gooseai.Request.prototype.clearAsset = function() { + return this.setAsset(undefined); }; @@ -4980,41 +5564,767 @@ proto.gooseai.Request.prototype.clearClassifier = function() { * Returns whether this field is set. * @return {boolean} */ -proto.gooseai.Request.prototype.hasClassifier = function() { - return jspb.Message.getField(this, 7) != null; +proto.gooseai.Request.prototype.hasAsset = function() { + return jspb.Message.getField(this, 8) != null; }; /** - * @enum {number} + * optional ConditionerParameters conditioner = 6; + * @return {?proto.gooseai.ConditionerParameters} */ -proto.gooseai.FinishReason = { - NULL: 0, - LENGTH: 1, - STOP: 2, - ERROR: 3, - FILTER: 4 +proto.gooseai.Request.prototype.getConditioner = function() { + return /** @type{?proto.gooseai.ConditionerParameters} */ ( + jspb.Message.getWrapperField(this, proto.gooseai.ConditionerParameters, 6)); }; + /** - * @enum {number} - */ -proto.gooseai.ArtifactType = { - ARTIFACT_NONE: 0, - ARTIFACT_IMAGE: 1, - ARTIFACT_VIDEO: 2, - ARTIFACT_TEXT: 3, - ARTIFACT_TOKENS: 4, - ARTIFACT_EMBEDDING: 5, - ARTIFACT_CLASSIFICATIONS: 6 + * @param {?proto.gooseai.ConditionerParameters|undefined} value + * @return {!proto.gooseai.Request} returns this +*/ +proto.gooseai.Request.prototype.setConditioner = function(value) { + return jspb.Message.setWrapperField(this, 6, value); }; + /** - * @enum {number} + * Clears the message field making it undefined. + * @return {!proto.gooseai.Request} returns this */ -proto.gooseai.DiffusionSampler = { - SAMPLER_DDIM: 0, - SAMPLER_DDPM: 1, +proto.gooseai.Request.prototype.clearConditioner = function() { + return this.setConditioner(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.gooseai.Request.prototype.hasConditioner = function() { + return jspb.Message.getField(this, 6) != null; +}; + + + +/** + * List of repeated fields within this message type. + * @private {!Array} + * @const + */ +proto.gooseai.OnStatus.repeatedFields_ = [1,3]; + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} + */ +proto.gooseai.OnStatus.prototype.toObject = function(opt_includeInstance) { + return proto.gooseai.OnStatus.toObject(opt_includeInstance, this); +}; + + +/** + * Static version of the {@see toObject} method. + * @param {boolean|undefined} includeInstance Deprecated. Whether to include + * the JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @param {!proto.gooseai.OnStatus} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.gooseai.OnStatus.toObject = function(includeInstance, msg) { + var f, obj = { + reasonList: (f = jspb.Message.getRepeatedField(msg, 1)) == null ? undefined : f, + target: jspb.Message.getFieldWithDefault(msg, 2, ""), + actionList: (f = jspb.Message.getRepeatedField(msg, 3)) == null ? undefined : f + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.gooseai.OnStatus} + */ +proto.gooseai.OnStatus.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.gooseai.OnStatus; + return proto.gooseai.OnStatus.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.gooseai.OnStatus} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.gooseai.OnStatus} + */ +proto.gooseai.OnStatus.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var values = /** @type {!Array} */ (reader.isDelimited() ? reader.readPackedEnum() : [reader.readEnum()]); + for (var i = 0; i < values.length; i++) { + msg.addReason(values[i]); + } + break; + case 2: + var value = /** @type {string} */ (reader.readString()); + msg.setTarget(value); + break; + case 3: + var values = /** @type {!Array} */ (reader.isDelimited() ? reader.readPackedEnum() : [reader.readEnum()]); + for (var i = 0; i < values.length; i++) { + msg.addAction(values[i]); + } + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.gooseai.OnStatus.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.gooseai.OnStatus.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.gooseai.OnStatus} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.gooseai.OnStatus.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getReasonList(); + if (f.length > 0) { + writer.writePackedEnum( + 1, + f + ); + } + f = /** @type {string} */ (jspb.Message.getField(message, 2)); + if (f != null) { + writer.writeString( + 2, + f + ); + } + f = message.getActionList(); + if (f.length > 0) { + writer.writePackedEnum( + 3, + f + ); + } +}; + + +/** + * repeated FinishReason reason = 1; + * @return {!Array} + */ +proto.gooseai.OnStatus.prototype.getReasonList = function() { + return /** @type {!Array} */ (jspb.Message.getRepeatedField(this, 1)); +}; + + +/** + * @param {!Array} value + * @return {!proto.gooseai.OnStatus} returns this + */ +proto.gooseai.OnStatus.prototype.setReasonList = function(value) { + return jspb.Message.setField(this, 1, value || []); +}; + + +/** + * @param {!proto.gooseai.FinishReason} value + * @param {number=} opt_index + * @return {!proto.gooseai.OnStatus} returns this + */ +proto.gooseai.OnStatus.prototype.addReason = function(value, opt_index) { + return jspb.Message.addToRepeatedField(this, 1, value, opt_index); +}; + + +/** + * Clears the list making it empty but non-null. + * @return {!proto.gooseai.OnStatus} returns this + */ +proto.gooseai.OnStatus.prototype.clearReasonList = function() { + return this.setReasonList([]); +}; + + +/** + * optional string target = 2; + * @return {string} + */ +proto.gooseai.OnStatus.prototype.getTarget = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +}; + + +/** + * @param {string} value + * @return {!proto.gooseai.OnStatus} returns this + */ +proto.gooseai.OnStatus.prototype.setTarget = function(value) { + return jspb.Message.setField(this, 2, value); +}; + + +/** + * Clears the field making it undefined. + * @return {!proto.gooseai.OnStatus} returns this + */ +proto.gooseai.OnStatus.prototype.clearTarget = function() { + return jspb.Message.setField(this, 2, undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.gooseai.OnStatus.prototype.hasTarget = function() { + return jspb.Message.getField(this, 2) != null; +}; + + +/** + * repeated StageAction action = 3; + * @return {!Array} + */ +proto.gooseai.OnStatus.prototype.getActionList = function() { + return /** @type {!Array} */ (jspb.Message.getRepeatedField(this, 3)); +}; + + +/** + * @param {!Array} value + * @return {!proto.gooseai.OnStatus} returns this + */ +proto.gooseai.OnStatus.prototype.setActionList = function(value) { + return jspb.Message.setField(this, 3, value || []); +}; + + +/** + * @param {!proto.gooseai.StageAction} value + * @param {number=} opt_index + * @return {!proto.gooseai.OnStatus} returns this + */ +proto.gooseai.OnStatus.prototype.addAction = function(value, opt_index) { + return jspb.Message.addToRepeatedField(this, 3, value, opt_index); +}; + + +/** + * Clears the list making it empty but non-null. + * @return {!proto.gooseai.OnStatus} returns this + */ +proto.gooseai.OnStatus.prototype.clearActionList = function() { + return this.setActionList([]); +}; + + + +/** + * List of repeated fields within this message type. + * @private {!Array} + * @const + */ +proto.gooseai.Stage.repeatedFields_ = [3]; + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} + */ +proto.gooseai.Stage.prototype.toObject = function(opt_includeInstance) { + return proto.gooseai.Stage.toObject(opt_includeInstance, this); +}; + + +/** + * Static version of the {@see toObject} method. + * @param {boolean|undefined} includeInstance Deprecated. Whether to include + * the JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @param {!proto.gooseai.Stage} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.gooseai.Stage.toObject = function(includeInstance, msg) { + var f, obj = { + id: jspb.Message.getFieldWithDefault(msg, 1, ""), + request: (f = msg.getRequest()) && proto.gooseai.Request.toObject(includeInstance, f), + onStatusList: jspb.Message.toObjectList(msg.getOnStatusList(), + proto.gooseai.OnStatus.toObject, includeInstance) + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.gooseai.Stage} + */ +proto.gooseai.Stage.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.gooseai.Stage; + return proto.gooseai.Stage.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.gooseai.Stage} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.gooseai.Stage} + */ +proto.gooseai.Stage.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = /** @type {string} */ (reader.readString()); + msg.setId(value); + break; + case 2: + var value = new proto.gooseai.Request; + reader.readMessage(value,proto.gooseai.Request.deserializeBinaryFromReader); + msg.setRequest(value); + break; + case 3: + var value = new proto.gooseai.OnStatus; + reader.readMessage(value,proto.gooseai.OnStatus.deserializeBinaryFromReader); + msg.addOnStatus(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.gooseai.Stage.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.gooseai.Stage.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.gooseai.Stage} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.gooseai.Stage.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getId(); + if (f.length > 0) { + writer.writeString( + 1, + f + ); + } + f = message.getRequest(); + if (f != null) { + writer.writeMessage( + 2, + f, + proto.gooseai.Request.serializeBinaryToWriter + ); + } + f = message.getOnStatusList(); + if (f.length > 0) { + writer.writeRepeatedMessage( + 3, + f, + proto.gooseai.OnStatus.serializeBinaryToWriter + ); + } +}; + + +/** + * optional string id = 1; + * @return {string} + */ +proto.gooseai.Stage.prototype.getId = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + + +/** + * @param {string} value + * @return {!proto.gooseai.Stage} returns this + */ +proto.gooseai.Stage.prototype.setId = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); +}; + + +/** + * optional Request request = 2; + * @return {?proto.gooseai.Request} + */ +proto.gooseai.Stage.prototype.getRequest = function() { + return /** @type{?proto.gooseai.Request} */ ( + jspb.Message.getWrapperField(this, proto.gooseai.Request, 2)); +}; + + +/** + * @param {?proto.gooseai.Request|undefined} value + * @return {!proto.gooseai.Stage} returns this +*/ +proto.gooseai.Stage.prototype.setRequest = function(value) { + return jspb.Message.setWrapperField(this, 2, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.gooseai.Stage} returns this + */ +proto.gooseai.Stage.prototype.clearRequest = function() { + return this.setRequest(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.gooseai.Stage.prototype.hasRequest = function() { + return jspb.Message.getField(this, 2) != null; +}; + + +/** + * repeated OnStatus on_status = 3; + * @return {!Array} + */ +proto.gooseai.Stage.prototype.getOnStatusList = function() { + return /** @type{!Array} */ ( + jspb.Message.getRepeatedWrapperField(this, proto.gooseai.OnStatus, 3)); +}; + + +/** + * @param {!Array} value + * @return {!proto.gooseai.Stage} returns this +*/ +proto.gooseai.Stage.prototype.setOnStatusList = function(value) { + return jspb.Message.setRepeatedWrapperField(this, 3, value); +}; + + +/** + * @param {!proto.gooseai.OnStatus=} opt_value + * @param {number=} opt_index + * @return {!proto.gooseai.OnStatus} + */ +proto.gooseai.Stage.prototype.addOnStatus = function(opt_value, opt_index) { + return jspb.Message.addToRepeatedWrapperField(this, 3, opt_value, proto.gooseai.OnStatus, opt_index); +}; + + +/** + * Clears the list making it empty but non-null. + * @return {!proto.gooseai.Stage} returns this + */ +proto.gooseai.Stage.prototype.clearOnStatusList = function() { + return this.setOnStatusList([]); +}; + + + +/** + * List of repeated fields within this message type. + * @private {!Array} + * @const + */ +proto.gooseai.ChainRequest.repeatedFields_ = [2]; + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} + */ +proto.gooseai.ChainRequest.prototype.toObject = function(opt_includeInstance) { + return proto.gooseai.ChainRequest.toObject(opt_includeInstance, this); +}; + + +/** + * Static version of the {@see toObject} method. + * @param {boolean|undefined} includeInstance Deprecated. Whether to include + * the JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @param {!proto.gooseai.ChainRequest} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.gooseai.ChainRequest.toObject = function(includeInstance, msg) { + var f, obj = { + requestId: jspb.Message.getFieldWithDefault(msg, 1, ""), + stageList: jspb.Message.toObjectList(msg.getStageList(), + proto.gooseai.Stage.toObject, includeInstance) + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.gooseai.ChainRequest} + */ +proto.gooseai.ChainRequest.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.gooseai.ChainRequest; + return proto.gooseai.ChainRequest.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.gooseai.ChainRequest} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.gooseai.ChainRequest} + */ +proto.gooseai.ChainRequest.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = /** @type {string} */ (reader.readString()); + msg.setRequestId(value); + break; + case 2: + var value = new proto.gooseai.Stage; + reader.readMessage(value,proto.gooseai.Stage.deserializeBinaryFromReader); + msg.addStage(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.gooseai.ChainRequest.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.gooseai.ChainRequest.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.gooseai.ChainRequest} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.gooseai.ChainRequest.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getRequestId(); + if (f.length > 0) { + writer.writeString( + 1, + f + ); + } + f = message.getStageList(); + if (f.length > 0) { + writer.writeRepeatedMessage( + 2, + f, + proto.gooseai.Stage.serializeBinaryToWriter + ); + } +}; + + +/** + * optional string request_id = 1; + * @return {string} + */ +proto.gooseai.ChainRequest.prototype.getRequestId = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + + +/** + * @param {string} value + * @return {!proto.gooseai.ChainRequest} returns this + */ +proto.gooseai.ChainRequest.prototype.setRequestId = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); +}; + + +/** + * repeated Stage stage = 2; + * @return {!Array} + */ +proto.gooseai.ChainRequest.prototype.getStageList = function() { + return /** @type{!Array} */ ( + jspb.Message.getRepeatedWrapperField(this, proto.gooseai.Stage, 2)); +}; + + +/** + * @param {!Array} value + * @return {!proto.gooseai.ChainRequest} returns this +*/ +proto.gooseai.ChainRequest.prototype.setStageList = function(value) { + return jspb.Message.setRepeatedWrapperField(this, 2, value); +}; + + +/** + * @param {!proto.gooseai.Stage=} opt_value + * @param {number=} opt_index + * @return {!proto.gooseai.Stage} + */ +proto.gooseai.ChainRequest.prototype.addStage = function(opt_value, opt_index) { + return jspb.Message.addToRepeatedWrapperField(this, 2, opt_value, proto.gooseai.Stage, opt_index); +}; + + +/** + * Clears the list making it empty but non-null. + * @return {!proto.gooseai.ChainRequest} returns this + */ +proto.gooseai.ChainRequest.prototype.clearStageList = function() { + return this.setStageList([]); +}; + + +/** + * @enum {number} + */ +proto.gooseai.FinishReason = { + NULL: 0, + LENGTH: 1, + STOP: 2, + ERROR: 3, + FILTER: 4 +}; + +/** + * @enum {number} + */ +proto.gooseai.ArtifactType = { + ARTIFACT_NONE: 0, + ARTIFACT_IMAGE: 1, + ARTIFACT_VIDEO: 2, + ARTIFACT_TEXT: 3, + ARTIFACT_TOKENS: 4, + ARTIFACT_EMBEDDING: 5, + ARTIFACT_CLASSIFICATIONS: 6, + ARTIFACT_MASK: 7 +}; + +/** + * @enum {number} + */ +proto.gooseai.DiffusionSampler = { + SAMPLER_DDIM: 0, + SAMPLER_DDPM: 1, SAMPLER_K_EULER: 2, SAMPLER_K_EULER_ANCESTRAL: 3, SAMPLER_K_HEUN: 4, @@ -5037,9 +6347,37 @@ proto.gooseai.Upscaler = { */ proto.gooseai.Action = { ACTION_PASSTHROUGH: 0, - ACTION_REGENERATE: 1, - ACTION_OBFUSCATE: 2, - ACTION_DISCARD: 3 + ACTION_REGENERATE_DUPLICATE: 1, + ACTION_REGENERATE: 2, + ACTION_OBFUSCATE_DUPLICATE: 3, + ACTION_OBFUSCATE: 4, + ACTION_DISCARD: 5 +}; + +/** + * @enum {number} + */ +proto.gooseai.ClassifierMode = { + CLSFR_MODE_ZEROSHOT: 0, + CLSFR_MODE_MULTICLASS: 1 +}; + +/** + * @enum {number} + */ +proto.gooseai.AssetAction = { + ASSET_PUT: 0, + ASSET_GET: 1, + ASSET_DELETE: 2 +}; + +/** + * @enum {number} + */ +proto.gooseai.StageAction = { + STAGE_ACTION_PASS: 0, + STAGE_ACTION_DISCARD: 1, + STAGE_ACTION_RETURN: 2 }; goog.object.extend(exports, proto.gooseai); diff --git a/src/js/generation_pb_service.d.ts b/src/js/generation_pb_service.d.ts index 5eebd9c5..ae4428ae 100644 --- a/src/js/generation_pb_service.d.ts +++ b/src/js/generation_pb_service.d.ts @@ -13,9 +13,19 @@ type GenerationServiceGenerate = { readonly responseType: typeof generation_pb.Answer; }; +type GenerationServiceChainGenerate = { + readonly methodName: string; + readonly service: typeof GenerationService; + readonly requestStream: false; + readonly responseStream: true; + readonly requestType: typeof generation_pb.ChainRequest; + readonly responseType: typeof generation_pb.Answer; +}; + export class GenerationService { static readonly serviceName: string; static readonly Generate: GenerationServiceGenerate; + static readonly ChainGenerate: GenerationServiceChainGenerate; } export type ServiceError = { message: string, code: number; metadata: grpc.Metadata } @@ -51,5 +61,6 @@ export class GenerationServiceClient { constructor(serviceHost: string, options?: grpc.RpcOptions); generate(requestMessage: generation_pb.Request, metadata?: grpc.Metadata): ResponseStream; + chainGenerate(requestMessage: generation_pb.ChainRequest, metadata?: grpc.Metadata): ResponseStream; } diff --git a/src/js/generation_pb_service.js b/src/js/generation_pb_service.js index ebc30eca..a03f5940 100644 --- a/src/js/generation_pb_service.js +++ b/src/js/generation_pb_service.js @@ -19,6 +19,15 @@ GenerationService.Generate = { responseType: generation_pb.Answer }; +GenerationService.ChainGenerate = { + methodName: "ChainGenerate", + service: GenerationService, + requestStream: false, + responseStream: true, + requestType: generation_pb.ChainRequest, + responseType: generation_pb.Answer +}; + exports.GenerationService = GenerationService; function GenerationServiceClient(serviceHost, options) { @@ -65,5 +74,44 @@ GenerationServiceClient.prototype.generate = function generate(requestMessage, m }; }; +GenerationServiceClient.prototype.chainGenerate = function chainGenerate(requestMessage, metadata) { + var listeners = { + data: [], + end: [], + status: [] + }; + var client = grpc.invoke(GenerationService.ChainGenerate, { + request: requestMessage, + host: this.serviceHost, + metadata: metadata, + transport: this.options.transport, + debug: this.options.debug, + onMessage: function (responseMessage) { + listeners.data.forEach(function (handler) { + handler(responseMessage); + }); + }, + onEnd: function (status, statusMessage, trailers) { + listeners.status.forEach(function (handler) { + handler({ code: status, details: statusMessage, metadata: trailers }); + }); + listeners.end.forEach(function (handler) { + handler({ code: status, details: statusMessage, metadata: trailers }); + }); + listeners = null; + } + }); + return { + on: function (type, handler) { + listeners[type].push(handler); + return this; + }, + cancel: function () { + listeners = null; + client.close(); + } + }; +}; + exports.GenerationServiceClient = GenerationServiceClient; diff --git a/src/proto/generation.proto b/src/proto/generation.proto index cf4bb134..48029ada 100644 --- a/src/proto/generation.proto +++ b/src/proto/generation.proto @@ -19,6 +19,7 @@ enum ArtifactType { ARTIFACT_TOKENS = 4; ARTIFACT_EMBEDDING = 5; ARTIFACT_CLASSIFICATIONS = 6; + ARTIFACT_MASK = 7; } message Token { @@ -106,9 +107,15 @@ enum Upscaler { UPSCALER_ESRGAN = 2; } +message ScheduleParameters { + optional float start = 1; // 0.0 to 1.0 + optional float end = 2; // 0.0 to 1.0 +} + message StepParameter { float scaled_step = 1; optional SamplerParameters sampler = 2; + optional ScheduleParameters schedule = 3; } message TransformType { @@ -162,6 +169,17 @@ message ClassifierParameters { optional Action realized_action = 3; } +enum AssetAction { + ASSET_PUT = 0; + ASSET_GET = 1; + ASSET_DELETE = 2; +} + +message AssetParameters { + AssetAction action = 1; + string project = 2; +} + message Request { string engine_id = 1; string request_id = 2; @@ -169,11 +187,36 @@ message Request { repeated Prompt prompt = 4; oneof params { ImageParameters image = 5; + ClassifierParameters classifier = 7; + AssetParameters asset = 8; } optional ConditionerParameters conditioner = 6; - optional ClassifierParameters classifier = 7; +} + +enum StageAction { + STAGE_ACTION_PASS = 0; + STAGE_ACTION_DISCARD = 1; + STAGE_ACTION_RETURN = 2; +} + +message OnStatus { + repeated FinishReason reason = 1; + optional string target = 2; + repeated StageAction action = 3; +} + +message Stage { + string id = 1; + Request request = 2; + repeated OnStatus on_status = 3; +} + +message ChainRequest { + string request_id = 1; + repeated Stage stage = 2; } service GenerationService { rpc Generate (Request) returns (stream Answer) {}; + rpc ChainGenerate (ChainRequest) returns (stream Answer) {}; } diff --git a/src/stability_sdk/interfaces/gooseai/generation/generation_pb2.py b/src/stability_sdk/interfaces/gooseai/generation/generation_pb2.py index 256b47d6..979c6cd4 100644 --- a/src/stability_sdk/interfaces/gooseai/generation/generation_pb2.py +++ b/src/stability_sdk/interfaces/gooseai/generation/generation_pb2.py @@ -15,7 +15,7 @@ -DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x10generation.proto\x12\x07gooseai\"/\n\x05Token\x12\x11\n\x04text\x18\x01 \x01(\tH\x00\x88\x01\x01\x12\n\n\x02id\x18\x02 \x01(\rB\x07\n\x05_text\"T\n\x06Tokens\x12\x1e\n\x06tokens\x18\x01 \x03(\x0b\x32\x0e.gooseai.Token\x12\x19\n\x0ctokenizer_id\x18\x02 \x01(\tH\x00\x88\x01\x01\x42\x0f\n\r_tokenizer_id\"\xb4\x02\n\x08\x41rtifact\x12\n\n\x02id\x18\x01 \x01(\x04\x12#\n\x04type\x18\x02 \x01(\x0e\x32\x15.gooseai.ArtifactType\x12\x0c\n\x04mime\x18\x03 \x01(\t\x12\x12\n\x05magic\x18\x04 \x01(\tH\x01\x88\x01\x01\x12\x10\n\x06\x62inary\x18\x05 \x01(\x0cH\x00\x12\x0e\n\x04text\x18\x06 \x01(\tH\x00\x12!\n\x06tokens\x18\x07 \x01(\x0b\x32\x0f.gooseai.TokensH\x00\x12\x33\n\nclassifier\x18\x0b \x01(\x0b\x32\x1d.gooseai.ClassifierParametersH\x00\x12\r\n\x05index\x18\x08 \x01(\r\x12,\n\rfinish_reason\x18\t \x01(\x0e\x32\x15.gooseai.FinishReason\x12\x0c\n\x04seed\x18\n \x01(\rB\x06\n\x04\x64\x61taB\x08\n\x06_magic\"N\n\x10PromptParameters\x12\x11\n\x04init\x18\x01 \x01(\x08H\x00\x88\x01\x01\x12\x13\n\x06weight\x18\x02 \x01(\x02H\x01\x88\x01\x01\x42\x07\n\x05_initB\t\n\x07_weight\"\xaf\x01\n\x06Prompt\x12\x32\n\nparameters\x18\x01 \x01(\x0b\x32\x19.gooseai.PromptParametersH\x01\x88\x01\x01\x12\x0e\n\x04text\x18\x02 \x01(\tH\x00\x12!\n\x06tokens\x18\x03 \x01(\x0b\x32\x0f.gooseai.TokensH\x00\x12%\n\x08\x61rtifact\x18\x04 \x01(\x0b\x32\x11.gooseai.ArtifactH\x00\x42\x08\n\x06promptB\r\n\x0b_parameters\"\x94\x01\n\nAnswerMeta\x12\x13\n\x06gpu_id\x18\x01 \x01(\tH\x00\x88\x01\x01\x12\x13\n\x06\x63pu_id\x18\x02 \x01(\tH\x01\x88\x01\x01\x12\x14\n\x07node_id\x18\x03 \x01(\tH\x02\x88\x01\x01\x12\x16\n\tengine_id\x18\x04 \x01(\tH\x03\x88\x01\x01\x42\t\n\x07_gpu_idB\t\n\x07_cpu_idB\n\n\x08_node_idB\x0c\n\n_engine_id\"\xa9\x01\n\x06\x41nswer\x12\x11\n\tanswer_id\x18\x01 \x01(\t\x12\x12\n\nrequest_id\x18\x02 \x01(\t\x12\x10\n\x08received\x18\x03 \x01(\x04\x12\x0f\n\x07\x63reated\x18\x04 \x01(\x04\x12&\n\x04meta\x18\x06 \x01(\x0b\x32\x13.gooseai.AnswerMetaH\x00\x88\x01\x01\x12$\n\tartifacts\x18\x07 \x03(\x0b\x32\x11.gooseai.ArtifactB\x07\n\x05_meta\"\xef\x01\n\x11SamplerParameters\x12\x10\n\x03\x65ta\x18\x01 \x01(\x02H\x00\x88\x01\x01\x12\x1b\n\x0esampling_steps\x18\x02 \x01(\x04H\x01\x88\x01\x01\x12\x1c\n\x0flatent_channels\x18\x03 \x01(\x04H\x02\x88\x01\x01\x12 \n\x13\x64ownsampling_factor\x18\x04 \x01(\x04H\x03\x88\x01\x01\x12\x16\n\tcfg_scale\x18\x05 \x01(\x02H\x04\x88\x01\x01\x42\x06\n\x04_etaB\x11\n\x0f_sampling_stepsB\x12\n\x10_latent_channelsB\x16\n\x14_downsampling_factorB\x0c\n\n_cfg_scale\"Q\n\x15\x43onditionerParameters\x12 \n\x13vector_adjust_prior\x18\x01 \x01(\tH\x00\x88\x01\x01\x42\x16\n\x14_vector_adjust_prior\"L\n\x12ScheduleParameters\x12\x12\n\x05start\x18\x01 \x01(\x02H\x00\x88\x01\x01\x12\x10\n\x03\x65nd\x18\x02 \x01(\x02H\x01\x88\x01\x01\x42\x08\n\x06_startB\x06\n\x04_end\"\xa3\x01\n\rStepParameter\x12\x13\n\x0bscaled_step\x18\x01 \x01(\x02\x12\x30\n\x07sampler\x18\x02 \x01(\x0b\x32\x1a.gooseai.SamplerParametersH\x00\x88\x01\x01\x12\x32\n\x08schedule\x18\x03 \x01(\x0b\x32\x1b.gooseai.ScheduleParametersH\x01\x88\x01\x01\x42\n\n\x08_samplerB\x0b\n\t_schedule\"n\n\rTransformType\x12.\n\tdiffusion\x18\x01 \x01(\x0e\x32\x19.gooseai.DiffusionSamplerH\x00\x12%\n\x08upscaler\x18\x02 \x01(\x0e\x32\x11.gooseai.UpscalerH\x00\x42\x06\n\x04type\"\x87\x02\n\x0fImageParameters\x12\x13\n\x06height\x18\x01 \x01(\x04H\x00\x88\x01\x01\x12\x12\n\x05width\x18\x02 \x01(\x04H\x01\x88\x01\x01\x12\x0c\n\x04seed\x18\x03 \x03(\r\x12\x14\n\x07samples\x18\x04 \x01(\x04H\x02\x88\x01\x01\x12\x12\n\x05steps\x18\x05 \x01(\x04H\x03\x88\x01\x01\x12.\n\ttransform\x18\x06 \x01(\x0b\x32\x16.gooseai.TransformTypeH\x04\x88\x01\x01\x12*\n\nparameters\x18\x07 \x03(\x0b\x32\x16.gooseai.StepParameterB\t\n\x07_heightB\x08\n\x06_widthB\n\n\x08_samplesB\x08\n\x06_stepsB\x0c\n\n_transform\"J\n\x11\x43lassifierConcept\x12\x0f\n\x07\x63oncept\x18\x01 \x01(\t\x12\x16\n\tthreshold\x18\x02 \x01(\x02H\x00\x88\x01\x01\x42\x0c\n\n_threshold\"\xf4\x01\n\x12\x43lassifierCategory\x12\x0c\n\x04name\x18\x01 \x01(\t\x12,\n\x08\x63oncepts\x18\x02 \x03(\x0b\x32\x1a.gooseai.ClassifierConcept\x12\x17\n\nadjustment\x18\x03 \x01(\x02H\x00\x88\x01\x01\x12$\n\x06\x61\x63tion\x18\x04 \x01(\x0e\x32\x0f.gooseai.ActionH\x01\x88\x01\x01\x12\x35\n\x0f\x63lassifier_mode\x18\x05 \x01(\x0e\x32\x17.gooseai.ClassifierModeH\x02\x88\x01\x01\x42\r\n\x0b_adjustmentB\t\n\x07_actionB\x12\n\x10_classifier_mode\"\xb8\x01\n\x14\x43lassifierParameters\x12/\n\ncategories\x18\x01 \x03(\x0b\x32\x1b.gooseai.ClassifierCategory\x12,\n\x07\x65xceeds\x18\x02 \x03(\x0b\x32\x1b.gooseai.ClassifierCategory\x12-\n\x0frealized_action\x18\x03 \x01(\x0e\x32\x0f.gooseai.ActionH\x00\x88\x01\x01\x42\x12\n\x10_realized_action\"\xc6\x02\n\x07Request\x12\x11\n\tengine_id\x18\x01 \x01(\t\x12\x12\n\nrequest_id\x18\x02 \x01(\t\x12-\n\x0erequested_type\x18\x03 \x01(\x0e\x32\x15.gooseai.ArtifactType\x12\x1f\n\x06prompt\x18\x04 \x03(\x0b\x32\x0f.gooseai.Prompt\x12)\n\x05image\x18\x05 \x01(\x0b\x32\x18.gooseai.ImageParametersH\x00\x12\x38\n\x0b\x63onditioner\x18\x06 \x01(\x0b\x32\x1e.gooseai.ConditionerParametersH\x01\x88\x01\x01\x12\x36\n\nclassifier\x18\x07 \x01(\x0b\x32\x1d.gooseai.ClassifierParametersH\x02\x88\x01\x01\x42\x08\n\x06paramsB\x0e\n\x0c_conditionerB\r\n\x0b_classifier*E\n\x0c\x46inishReason\x12\x08\n\x04NULL\x10\x00\x12\n\n\x06LENGTH\x10\x01\x12\x08\n\x04STOP\x10\x02\x12\t\n\x05\x45RROR\x10\x03\x12\n\n\x06\x46ILTER\x10\x04*\xba\x01\n\x0c\x41rtifactType\x12\x11\n\rARTIFACT_NONE\x10\x00\x12\x12\n\x0e\x41RTIFACT_IMAGE\x10\x01\x12\x12\n\x0e\x41RTIFACT_VIDEO\x10\x02\x12\x11\n\rARTIFACT_TEXT\x10\x03\x12\x13\n\x0f\x41RTIFACT_TOKENS\x10\x04\x12\x16\n\x12\x41RTIFACT_EMBEDDING\x10\x05\x12\x1c\n\x18\x41RTIFACT_CLASSIFICATIONS\x10\x06\x12\x11\n\rARTIFACT_MASK\x10\x07*\xc5\x01\n\x10\x44iffusionSampler\x12\x10\n\x0cSAMPLER_DDIM\x10\x00\x12\x10\n\x0cSAMPLER_DDPM\x10\x01\x12\x13\n\x0fSAMPLER_K_EULER\x10\x02\x12\x1d\n\x19SAMPLER_K_EULER_ANCESTRAL\x10\x03\x12\x12\n\x0eSAMPLER_K_HEUN\x10\x04\x12\x13\n\x0fSAMPLER_K_DPM_2\x10\x05\x12\x1d\n\x19SAMPLER_K_DPM_2_ANCESTRAL\x10\x06\x12\x11\n\rSAMPLER_K_LMS\x10\x07*F\n\x08Upscaler\x12\x10\n\x0cUPSCALER_RGB\x10\x00\x12\x13\n\x0fUPSCALER_GFPGAN\x10\x01\x12\x13\n\x0fUPSCALER_ESRGAN\x10\x02*\xa2\x01\n\x06\x41\x63tion\x12\x16\n\x12\x41\x43TION_PASSTHROUGH\x10\x00\x12\x1f\n\x1b\x41\x43TION_REGENERATE_DUPLICATE\x10\x01\x12\x15\n\x11\x41\x43TION_REGENERATE\x10\x02\x12\x1e\n\x1a\x41\x43TION_OBFUSCATE_DUPLICATE\x10\x03\x12\x14\n\x10\x41\x43TION_OBFUSCATE\x10\x04\x12\x12\n\x0e\x41\x43TION_DISCARD\x10\x05*D\n\x0e\x43lassifierMode\x12\x17\n\x13\x43LSFR_MODE_ZEROSHOT\x10\x00\x12\x19\n\x15\x43LSFR_MODE_MULTICLASS\x10\x01\x32\x46\n\x11GenerationService\x12\x31\n\x08Generate\x12\x10.gooseai.Request\x1a\x0f.gooseai.Answer\"\x00\x30\x01\x42\x0fZ\r./;generationb\x06proto3') +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x10generation.proto\x12\x07gooseai\"/\n\x05Token\x12\x11\n\x04text\x18\x01 \x01(\tH\x00\x88\x01\x01\x12\n\n\x02id\x18\x02 \x01(\rB\x07\n\x05_text\"T\n\x06Tokens\x12\x1e\n\x06tokens\x18\x01 \x03(\x0b\x32\x0e.gooseai.Token\x12\x19\n\x0ctokenizer_id\x18\x02 \x01(\tH\x00\x88\x01\x01\x42\x0f\n\r_tokenizer_id\"\xb4\x02\n\x08\x41rtifact\x12\n\n\x02id\x18\x01 \x01(\x04\x12#\n\x04type\x18\x02 \x01(\x0e\x32\x15.gooseai.ArtifactType\x12\x0c\n\x04mime\x18\x03 \x01(\t\x12\x12\n\x05magic\x18\x04 \x01(\tH\x01\x88\x01\x01\x12\x10\n\x06\x62inary\x18\x05 \x01(\x0cH\x00\x12\x0e\n\x04text\x18\x06 \x01(\tH\x00\x12!\n\x06tokens\x18\x07 \x01(\x0b\x32\x0f.gooseai.TokensH\x00\x12\x33\n\nclassifier\x18\x0b \x01(\x0b\x32\x1d.gooseai.ClassifierParametersH\x00\x12\r\n\x05index\x18\x08 \x01(\r\x12,\n\rfinish_reason\x18\t \x01(\x0e\x32\x15.gooseai.FinishReason\x12\x0c\n\x04seed\x18\n \x01(\rB\x06\n\x04\x64\x61taB\x08\n\x06_magic\"N\n\x10PromptParameters\x12\x11\n\x04init\x18\x01 \x01(\x08H\x00\x88\x01\x01\x12\x13\n\x06weight\x18\x02 \x01(\x02H\x01\x88\x01\x01\x42\x07\n\x05_initB\t\n\x07_weight\"\xaf\x01\n\x06Prompt\x12\x32\n\nparameters\x18\x01 \x01(\x0b\x32\x19.gooseai.PromptParametersH\x01\x88\x01\x01\x12\x0e\n\x04text\x18\x02 \x01(\tH\x00\x12!\n\x06tokens\x18\x03 \x01(\x0b\x32\x0f.gooseai.TokensH\x00\x12%\n\x08\x61rtifact\x18\x04 \x01(\x0b\x32\x11.gooseai.ArtifactH\x00\x42\x08\n\x06promptB\r\n\x0b_parameters\"\x94\x01\n\nAnswerMeta\x12\x13\n\x06gpu_id\x18\x01 \x01(\tH\x00\x88\x01\x01\x12\x13\n\x06\x63pu_id\x18\x02 \x01(\tH\x01\x88\x01\x01\x12\x14\n\x07node_id\x18\x03 \x01(\tH\x02\x88\x01\x01\x12\x16\n\tengine_id\x18\x04 \x01(\tH\x03\x88\x01\x01\x42\t\n\x07_gpu_idB\t\n\x07_cpu_idB\n\n\x08_node_idB\x0c\n\n_engine_id\"\xa9\x01\n\x06\x41nswer\x12\x11\n\tanswer_id\x18\x01 \x01(\t\x12\x12\n\nrequest_id\x18\x02 \x01(\t\x12\x10\n\x08received\x18\x03 \x01(\x04\x12\x0f\n\x07\x63reated\x18\x04 \x01(\x04\x12&\n\x04meta\x18\x06 \x01(\x0b\x32\x13.gooseai.AnswerMetaH\x00\x88\x01\x01\x12$\n\tartifacts\x18\x07 \x03(\x0b\x32\x11.gooseai.ArtifactB\x07\n\x05_meta\"\xef\x01\n\x11SamplerParameters\x12\x10\n\x03\x65ta\x18\x01 \x01(\x02H\x00\x88\x01\x01\x12\x1b\n\x0esampling_steps\x18\x02 \x01(\x04H\x01\x88\x01\x01\x12\x1c\n\x0flatent_channels\x18\x03 \x01(\x04H\x02\x88\x01\x01\x12 \n\x13\x64ownsampling_factor\x18\x04 \x01(\x04H\x03\x88\x01\x01\x12\x16\n\tcfg_scale\x18\x05 \x01(\x02H\x04\x88\x01\x01\x42\x06\n\x04_etaB\x11\n\x0f_sampling_stepsB\x12\n\x10_latent_channelsB\x16\n\x14_downsampling_factorB\x0c\n\n_cfg_scale\"Q\n\x15\x43onditionerParameters\x12 \n\x13vector_adjust_prior\x18\x01 \x01(\tH\x00\x88\x01\x01\x42\x16\n\x14_vector_adjust_prior\"L\n\x12ScheduleParameters\x12\x12\n\x05start\x18\x01 \x01(\x02H\x00\x88\x01\x01\x12\x10\n\x03\x65nd\x18\x02 \x01(\x02H\x01\x88\x01\x01\x42\x08\n\x06_startB\x06\n\x04_end\"\xa3\x01\n\rStepParameter\x12\x13\n\x0bscaled_step\x18\x01 \x01(\x02\x12\x30\n\x07sampler\x18\x02 \x01(\x0b\x32\x1a.gooseai.SamplerParametersH\x00\x88\x01\x01\x12\x32\n\x08schedule\x18\x03 \x01(\x0b\x32\x1b.gooseai.ScheduleParametersH\x01\x88\x01\x01\x42\n\n\x08_samplerB\x0b\n\t_schedule\"n\n\rTransformType\x12.\n\tdiffusion\x18\x01 \x01(\x0e\x32\x19.gooseai.DiffusionSamplerH\x00\x12%\n\x08upscaler\x18\x02 \x01(\x0e\x32\x11.gooseai.UpscalerH\x00\x42\x06\n\x04type\"\x87\x02\n\x0fImageParameters\x12\x13\n\x06height\x18\x01 \x01(\x04H\x00\x88\x01\x01\x12\x12\n\x05width\x18\x02 \x01(\x04H\x01\x88\x01\x01\x12\x0c\n\x04seed\x18\x03 \x03(\r\x12\x14\n\x07samples\x18\x04 \x01(\x04H\x02\x88\x01\x01\x12\x12\n\x05steps\x18\x05 \x01(\x04H\x03\x88\x01\x01\x12.\n\ttransform\x18\x06 \x01(\x0b\x32\x16.gooseai.TransformTypeH\x04\x88\x01\x01\x12*\n\nparameters\x18\x07 \x03(\x0b\x32\x16.gooseai.StepParameterB\t\n\x07_heightB\x08\n\x06_widthB\n\n\x08_samplesB\x08\n\x06_stepsB\x0c\n\n_transform\"J\n\x11\x43lassifierConcept\x12\x0f\n\x07\x63oncept\x18\x01 \x01(\t\x12\x16\n\tthreshold\x18\x02 \x01(\x02H\x00\x88\x01\x01\x42\x0c\n\n_threshold\"\xf4\x01\n\x12\x43lassifierCategory\x12\x0c\n\x04name\x18\x01 \x01(\t\x12,\n\x08\x63oncepts\x18\x02 \x03(\x0b\x32\x1a.gooseai.ClassifierConcept\x12\x17\n\nadjustment\x18\x03 \x01(\x02H\x00\x88\x01\x01\x12$\n\x06\x61\x63tion\x18\x04 \x01(\x0e\x32\x0f.gooseai.ActionH\x01\x88\x01\x01\x12\x35\n\x0f\x63lassifier_mode\x18\x05 \x01(\x0e\x32\x17.gooseai.ClassifierModeH\x02\x88\x01\x01\x42\r\n\x0b_adjustmentB\t\n\x07_actionB\x12\n\x10_classifier_mode\"\xb8\x01\n\x14\x43lassifierParameters\x12/\n\ncategories\x18\x01 \x03(\x0b\x32\x1b.gooseai.ClassifierCategory\x12,\n\x07\x65xceeds\x18\x02 \x03(\x0b\x32\x1b.gooseai.ClassifierCategory\x12-\n\x0frealized_action\x18\x03 \x01(\x0e\x32\x0f.gooseai.ActionH\x00\x88\x01\x01\x42\x12\n\x10_realized_action\"H\n\x0f\x41ssetParameters\x12$\n\x06\x61\x63tion\x18\x01 \x01(\x0e\x32\x14.gooseai.AssetAction\x12\x0f\n\x07project\x18\x02 \x01(\t\"\xdf\x02\n\x07Request\x12\x11\n\tengine_id\x18\x01 \x01(\t\x12\x12\n\nrequest_id\x18\x02 \x01(\t\x12-\n\x0erequested_type\x18\x03 \x01(\x0e\x32\x15.gooseai.ArtifactType\x12\x1f\n\x06prompt\x18\x04 \x03(\x0b\x32\x0f.gooseai.Prompt\x12)\n\x05image\x18\x05 \x01(\x0b\x32\x18.gooseai.ImageParametersH\x00\x12\x33\n\nclassifier\x18\x07 \x01(\x0b\x32\x1d.gooseai.ClassifierParametersH\x00\x12)\n\x05\x61sset\x18\x08 \x01(\x0b\x32\x18.gooseai.AssetParametersH\x00\x12\x38\n\x0b\x63onditioner\x18\x06 \x01(\x0b\x32\x1e.gooseai.ConditionerParametersH\x01\x88\x01\x01\x42\x08\n\x06paramsB\x0e\n\x0c_conditioner\"w\n\x08OnStatus\x12%\n\x06reason\x18\x01 \x03(\x0e\x32\x15.gooseai.FinishReason\x12\x13\n\x06target\x18\x02 \x01(\tH\x00\x88\x01\x01\x12$\n\x06\x61\x63tion\x18\x03 \x03(\x0e\x32\x14.gooseai.StageActionB\t\n\x07_target\"\\\n\x05Stage\x12\n\n\x02id\x18\x01 \x01(\t\x12!\n\x07request\x18\x02 \x01(\x0b\x32\x10.gooseai.Request\x12$\n\ton_status\x18\x03 \x03(\x0b\x32\x11.gooseai.OnStatus\"A\n\x0c\x43hainRequest\x12\x12\n\nrequest_id\x18\x01 \x01(\t\x12\x1d\n\x05stage\x18\x02 \x03(\x0b\x32\x0e.gooseai.Stage*E\n\x0c\x46inishReason\x12\x08\n\x04NULL\x10\x00\x12\n\n\x06LENGTH\x10\x01\x12\x08\n\x04STOP\x10\x02\x12\t\n\x05\x45RROR\x10\x03\x12\n\n\x06\x46ILTER\x10\x04*\xba\x01\n\x0c\x41rtifactType\x12\x11\n\rARTIFACT_NONE\x10\x00\x12\x12\n\x0e\x41RTIFACT_IMAGE\x10\x01\x12\x12\n\x0e\x41RTIFACT_VIDEO\x10\x02\x12\x11\n\rARTIFACT_TEXT\x10\x03\x12\x13\n\x0f\x41RTIFACT_TOKENS\x10\x04\x12\x16\n\x12\x41RTIFACT_EMBEDDING\x10\x05\x12\x1c\n\x18\x41RTIFACT_CLASSIFICATIONS\x10\x06\x12\x11\n\rARTIFACT_MASK\x10\x07*\xc5\x01\n\x10\x44iffusionSampler\x12\x10\n\x0cSAMPLER_DDIM\x10\x00\x12\x10\n\x0cSAMPLER_DDPM\x10\x01\x12\x13\n\x0fSAMPLER_K_EULER\x10\x02\x12\x1d\n\x19SAMPLER_K_EULER_ANCESTRAL\x10\x03\x12\x12\n\x0eSAMPLER_K_HEUN\x10\x04\x12\x13\n\x0fSAMPLER_K_DPM_2\x10\x05\x12\x1d\n\x19SAMPLER_K_DPM_2_ANCESTRAL\x10\x06\x12\x11\n\rSAMPLER_K_LMS\x10\x07*F\n\x08Upscaler\x12\x10\n\x0cUPSCALER_RGB\x10\x00\x12\x13\n\x0fUPSCALER_GFPGAN\x10\x01\x12\x13\n\x0fUPSCALER_ESRGAN\x10\x02*\xa2\x01\n\x06\x41\x63tion\x12\x16\n\x12\x41\x43TION_PASSTHROUGH\x10\x00\x12\x1f\n\x1b\x41\x43TION_REGENERATE_DUPLICATE\x10\x01\x12\x15\n\x11\x41\x43TION_REGENERATE\x10\x02\x12\x1e\n\x1a\x41\x43TION_OBFUSCATE_DUPLICATE\x10\x03\x12\x14\n\x10\x41\x43TION_OBFUSCATE\x10\x04\x12\x12\n\x0e\x41\x43TION_DISCARD\x10\x05*D\n\x0e\x43lassifierMode\x12\x17\n\x13\x43LSFR_MODE_ZEROSHOT\x10\x00\x12\x19\n\x15\x43LSFR_MODE_MULTICLASS\x10\x01*=\n\x0b\x41ssetAction\x12\r\n\tASSET_PUT\x10\x00\x12\r\n\tASSET_GET\x10\x01\x12\x10\n\x0c\x41SSET_DELETE\x10\x02*W\n\x0bStageAction\x12\x15\n\x11STAGE_ACTION_PASS\x10\x00\x12\x18\n\x14STAGE_ACTION_DISCARD\x10\x01\x12\x17\n\x13STAGE_ACTION_RETURN\x10\x02\x32\x83\x01\n\x11GenerationService\x12\x31\n\x08Generate\x12\x10.gooseai.Request\x1a\x0f.gooseai.Answer\"\x00\x30\x01\x12;\n\rChainGenerate\x12\x15.gooseai.ChainRequest\x1a\x0f.gooseai.Answer\"\x00\x30\x01\x42\x0fZ\r./;generationb\x06proto3') _FINISHREASON = DESCRIPTOR.enum_types_by_name['FinishReason'] FinishReason = enum_type_wrapper.EnumTypeWrapper(_FINISHREASON) @@ -29,6 +29,10 @@ Action = enum_type_wrapper.EnumTypeWrapper(_ACTION) _CLASSIFIERMODE = DESCRIPTOR.enum_types_by_name['ClassifierMode'] ClassifierMode = enum_type_wrapper.EnumTypeWrapper(_CLASSIFIERMODE) +_ASSETACTION = DESCRIPTOR.enum_types_by_name['AssetAction'] +AssetAction = enum_type_wrapper.EnumTypeWrapper(_ASSETACTION) +_STAGEACTION = DESCRIPTOR.enum_types_by_name['StageAction'] +StageAction = enum_type_wrapper.EnumTypeWrapper(_STAGEACTION) NULL = 0 LENGTH = 1 STOP = 2 @@ -61,6 +65,12 @@ ACTION_DISCARD = 5 CLSFR_MODE_ZEROSHOT = 0 CLSFR_MODE_MULTICLASS = 1 +ASSET_PUT = 0 +ASSET_GET = 1 +ASSET_DELETE = 2 +STAGE_ACTION_PASS = 0 +STAGE_ACTION_DISCARD = 1 +STAGE_ACTION_RETURN = 2 _TOKEN = DESCRIPTOR.message_types_by_name['Token'] @@ -79,7 +89,11 @@ _CLASSIFIERCONCEPT = DESCRIPTOR.message_types_by_name['ClassifierConcept'] _CLASSIFIERCATEGORY = DESCRIPTOR.message_types_by_name['ClassifierCategory'] _CLASSIFIERPARAMETERS = DESCRIPTOR.message_types_by_name['ClassifierParameters'] +_ASSETPARAMETERS = DESCRIPTOR.message_types_by_name['AssetParameters'] _REQUEST = DESCRIPTOR.message_types_by_name['Request'] +_ONSTATUS = DESCRIPTOR.message_types_by_name['OnStatus'] +_STAGE = DESCRIPTOR.message_types_by_name['Stage'] +_CHAINREQUEST = DESCRIPTOR.message_types_by_name['ChainRequest'] Token = _reflection.GeneratedProtocolMessageType('Token', (_message.Message,), { 'DESCRIPTOR' : _TOKEN, '__module__' : 'generation_pb2' @@ -192,6 +206,13 @@ }) _sym_db.RegisterMessage(ClassifierParameters) +AssetParameters = _reflection.GeneratedProtocolMessageType('AssetParameters', (_message.Message,), { + 'DESCRIPTOR' : _ASSETPARAMETERS, + '__module__' : 'generation_pb2' + # @@protoc_insertion_point(class_scope:gooseai.AssetParameters) + }) +_sym_db.RegisterMessage(AssetParameters) + Request = _reflection.GeneratedProtocolMessageType('Request', (_message.Message,), { 'DESCRIPTOR' : _REQUEST, '__module__' : 'generation_pb2' @@ -199,23 +220,48 @@ }) _sym_db.RegisterMessage(Request) +OnStatus = _reflection.GeneratedProtocolMessageType('OnStatus', (_message.Message,), { + 'DESCRIPTOR' : _ONSTATUS, + '__module__' : 'generation_pb2' + # @@protoc_insertion_point(class_scope:gooseai.OnStatus) + }) +_sym_db.RegisterMessage(OnStatus) + +Stage = _reflection.GeneratedProtocolMessageType('Stage', (_message.Message,), { + 'DESCRIPTOR' : _STAGE, + '__module__' : 'generation_pb2' + # @@protoc_insertion_point(class_scope:gooseai.Stage) + }) +_sym_db.RegisterMessage(Stage) + +ChainRequest = _reflection.GeneratedProtocolMessageType('ChainRequest', (_message.Message,), { + 'DESCRIPTOR' : _CHAINREQUEST, + '__module__' : 'generation_pb2' + # @@protoc_insertion_point(class_scope:gooseai.ChainRequest) + }) +_sym_db.RegisterMessage(ChainRequest) + _GENERATIONSERVICE = DESCRIPTOR.services_by_name['GenerationService'] if _descriptor._USE_C_DESCRIPTORS == False: DESCRIPTOR._options = None DESCRIPTOR._serialized_options = b'Z\r./;generation' - _FINISHREASON._serialized_start=2842 - _FINISHREASON._serialized_end=2911 - _ARTIFACTTYPE._serialized_start=2914 - _ARTIFACTTYPE._serialized_end=3100 - _DIFFUSIONSAMPLER._serialized_start=3103 - _DIFFUSIONSAMPLER._serialized_end=3300 - _UPSCALER._serialized_start=3302 - _UPSCALER._serialized_end=3372 - _ACTION._serialized_start=3375 - _ACTION._serialized_end=3537 - _CLASSIFIERMODE._serialized_start=3539 - _CLASSIFIERMODE._serialized_end=3607 + _FINISHREASON._serialized_start=3223 + _FINISHREASON._serialized_end=3292 + _ARTIFACTTYPE._serialized_start=3295 + _ARTIFACTTYPE._serialized_end=3481 + _DIFFUSIONSAMPLER._serialized_start=3484 + _DIFFUSIONSAMPLER._serialized_end=3681 + _UPSCALER._serialized_start=3683 + _UPSCALER._serialized_end=3753 + _ACTION._serialized_start=3756 + _ACTION._serialized_end=3918 + _CLASSIFIERMODE._serialized_start=3920 + _CLASSIFIERMODE._serialized_end=3988 + _ASSETACTION._serialized_start=3990 + _ASSETACTION._serialized_end=4051 + _STAGEACTION._serialized_start=4053 + _STAGEACTION._serialized_end=4140 _TOKEN._serialized_start=29 _TOKEN._serialized_end=76 _TOKENS._serialized_start=78 @@ -248,8 +294,16 @@ _CLASSIFIERCATEGORY._serialized_end=2324 _CLASSIFIERPARAMETERS._serialized_start=2327 _CLASSIFIERPARAMETERS._serialized_end=2511 - _REQUEST._serialized_start=2514 - _REQUEST._serialized_end=2840 - _GENERATIONSERVICE._serialized_start=3609 - _GENERATIONSERVICE._serialized_end=3679 + _ASSETPARAMETERS._serialized_start=2513 + _ASSETPARAMETERS._serialized_end=2585 + _REQUEST._serialized_start=2588 + _REQUEST._serialized_end=2939 + _ONSTATUS._serialized_start=2941 + _ONSTATUS._serialized_end=3060 + _STAGE._serialized_start=3062 + _STAGE._serialized_end=3154 + _CHAINREQUEST._serialized_start=3156 + _CHAINREQUEST._serialized_end=3221 + _GENERATIONSERVICE._serialized_start=4143 + _GENERATIONSERVICE._serialized_end=4274 # @@protoc_insertion_point(module_scope) diff --git a/src/stability_sdk/interfaces/gooseai/generation/generation_pb2_grpc.py b/src/stability_sdk/interfaces/gooseai/generation/generation_pb2_grpc.py index 6b9a892a..bf13960d 100644 --- a/src/stability_sdk/interfaces/gooseai/generation/generation_pb2_grpc.py +++ b/src/stability_sdk/interfaces/gooseai/generation/generation_pb2_grpc.py @@ -19,6 +19,11 @@ def __init__(self, channel): request_serializer=generation__pb2.Request.SerializeToString, response_deserializer=generation__pb2.Answer.FromString, ) + self.ChainGenerate = channel.unary_stream( + '/gooseai.GenerationService/ChainGenerate', + request_serializer=generation__pb2.ChainRequest.SerializeToString, + response_deserializer=generation__pb2.Answer.FromString, + ) class GenerationServiceServicer(object): @@ -30,6 +35,12 @@ def Generate(self, request, context): context.set_details('Method not implemented!') raise NotImplementedError('Method not implemented!') + def ChainGenerate(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + def add_GenerationServiceServicer_to_server(servicer, server): rpc_method_handlers = { @@ -38,6 +49,11 @@ def add_GenerationServiceServicer_to_server(servicer, server): request_deserializer=generation__pb2.Request.FromString, response_serializer=generation__pb2.Answer.SerializeToString, ), + 'ChainGenerate': grpc.unary_stream_rpc_method_handler( + servicer.ChainGenerate, + request_deserializer=generation__pb2.ChainRequest.FromString, + response_serializer=generation__pb2.Answer.SerializeToString, + ), } generic_handler = grpc.method_handlers_generic_handler( 'gooseai.GenerationService', rpc_method_handlers) @@ -63,4 +79,21 @@ def Generate(request, generation__pb2.Request.SerializeToString, generation__pb2.Answer.FromString, options, channel_credentials, - insecure, call_credentials, compression, wait_for_ready, timeout, metadata) \ No newline at end of file + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def ChainGenerate(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_stream(request, target, '/gooseai.GenerationService/ChainGenerate', + generation__pb2.ChainRequest.SerializeToString, + generation__pb2.Answer.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata)