├── .dockerignore
├── .gitattributes
├── .github
└── workflows
│ ├── buf.yml
│ └── docker.yml
├── .gitignore
├── .gitmodules
├── .idea
└── .gitignore
├── CMakeLists.txt
├── Dockerfile
├── README.md
├── __init__.py
├── buf.work.yaml
├── buf.yaml
├── cmake
└── .gitkeep
├── gooseai
├── __init__.py
├── dashboard
│ ├── dashboard.pb.go
│ ├── dashboard_grpc.pb.go
│ ├── dashboard_grpc_pb.d.ts
│ ├── dashboard_grpc_pb.js
│ ├── dashboard_pb.d.ts
│ ├── dashboard_pb.js
│ ├── dashboard_pb2.py
│ ├── dashboard_pb2_grpc.py
│ ├── dashboard_pb_service.d.ts
│ └── dashboard_pb_service.js
├── engines
│ ├── engines.pb.go
│ ├── engines_grpc.pb.go
│ ├── engines_grpc_pb.d.ts
│ ├── engines_grpc_pb.js
│ ├── engines_pb.d.ts
│ ├── engines_pb.js
│ ├── engines_pb2.py
│ ├── engines_pb2_grpc.py
│ ├── engines_pb_service.d.ts
│ └── engines_pb_service.js
├── finetuning
│ ├── finetuning.pb.go
│ ├── finetuning_grpc.pb.go
│ ├── finetuning_grpc_pb.d.ts
│ ├── finetuning_grpc_pb.js
│ ├── finetuning_pb.d.ts
│ ├── finetuning_pb.js
│ ├── finetuning_pb2.py
│ ├── finetuning_pb2_grpc.py
│ ├── finetuning_pb_service.d.ts
│ └── finetuning_pb_service.js
├── generation
│ ├── __init__.py
│ ├── generation.pb.go
│ ├── generation_grpc.pb.go
│ ├── generation_grpc_pb.d.ts
│ ├── generation_grpc_pb.js
│ ├── generation_pb.d.ts
│ ├── generation_pb.js
│ ├── generation_pb2.py
│ ├── generation_pb2_grpc.py
│ ├── generation_pb_service.d.ts
│ ├── generation_pb_service.js
│ ├── tensors_pb.d.ts
│ ├── tensors_pb.js
│ └── tensors_pb2.py
├── go.mod
├── go.sum
└── project
│ ├── project.pb.go
│ ├── project_grpc.pb.go
│ ├── project_grpc_pb.d.ts
│ ├── project_grpc_pb.js
│ ├── project_pb.d.ts
│ ├── project_pb.js
│ ├── project_pb2.py
│ ├── project_pb2_grpc.py
│ ├── project_pb_service.d.ts
│ └── project_pb_service.js
├── package-lock.json
├── package.json
├── requirements.txt
├── samples
├── witch_multi.json
├── witch_noprob.json
└── witch_stream.json
├── src
├── bin
│ └── protoc
├── cmake
│ ├── FindProtobufWithTargets.cmake
│ └── FindgRPC.cmake
└── proto
│ ├── dashboard.proto
│ ├── engines.proto
│ ├── finetuning.proto
│ ├── generation.proto
│ └── project.proto
└── update.sh
/.dockerignore:
--------------------------------------------------------------------------------
1 | # CMake ignores
2 | CMakeLists.txt.user
3 | CMakeCache.txt
4 | CMakeFiles
5 | CMakeScripts
6 | Testing
7 | Makefile
8 | cmake_install.cmake
9 | install_manifest.txt
10 | compile_commands.json
11 | CTestTestfile.cmake
12 | _deps
13 |
14 | # Project specific
15 | cmake/*
16 | !cmake/.gitkeep
17 | node_modules
18 | .idea
19 |
20 | # protoc output
21 | gooseai/*/*pb*
22 |
--------------------------------------------------------------------------------
/.gitattributes:
--------------------------------------------------------------------------------
1 | /gooseai/** linguist-generated
2 |
--------------------------------------------------------------------------------
/.github/workflows/buf.yml:
--------------------------------------------------------------------------------
1 | name: buf-pull-request
2 | on: pull_request
3 | jobs:
4 | build:
5 | runs-on: ubuntu-latest
6 | steps:
7 | - uses: actions/checkout@v3
8 | with:
9 | submodules: recursive
10 | - uses: bufbuild/buf-setup-action@v1
11 | - uses: bufbuild/buf-breaking-action@v1
12 | with:
13 | against: "https://github.com/${GITHUB_REPOSITORY}.git#branch=main"
14 |
--------------------------------------------------------------------------------
/.github/workflows/docker.yml:
--------------------------------------------------------------------------------
1 | name: Docker
2 |
3 | on:
4 | push: {}
5 |
6 | jobs:
7 | generate-language-bindings:
8 | name: Generate Language Bindings
9 | runs-on: ubuntu-24.04
10 | steps:
11 | # By default, when you use actions/checkout on a PR, it will checkout the
12 | # head commit in a detached head state. If you want to make some changes,
13 | # you have to checkout the branch the PR is coming from in the head repo.
14 | #
15 | # https://github.com/EndBug/add-and-commit#working-with-prs
16 | - uses: actions/checkout@v3
17 | with:
18 | repository: ${{ github.event.pull_request.head.repo.full_name }}
19 | ref: ${{ github.event.pull_request.head.ref }}
20 | submodules: recursive
21 | if: github.event_name == 'pull_request'
22 | - uses: actions/checkout@v3
23 | with:
24 | submodules: recursive
25 | if: github.event_name != 'pull_request'
26 | - uses: docker/setup-buildx-action@v2
27 | - uses: docker/build-push-action@v3
28 | with:
29 | push: false
30 | context: .
31 | cache-from: type=gha
32 | cache-to: type=gha,mode=max
33 | outputs: |
34 | type=local,dest=${{ runner.temp }}/docker-build
35 | - uses: actions/upload-artifact@v4
36 | with:
37 | name: gooseai
38 | path: ${{ runner.temp }}/docker-build/gooseai
39 | - name: Prepare artifacts for commit
40 | run: |
41 | cp -r ${{ runner.temp }}/docker-build/gooseai ./
42 | - name: Commit modified artifacts (if any)
43 | uses: EndBug/add-and-commit@v9
44 | with:
45 | add: 'gooseai/'
46 | message: 'chore: update generated files'
47 | committer_name: GitHub Actions
48 | committer_email: actions@github.com
49 |
--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | # CMake ignores
2 | CMakeLists.txt.user
3 | CMakeCache.txt
4 | CMakeFiles
5 | CMakeScripts
6 | Testing
7 | Makefile
8 | cmake_install.cmake
9 | install_manifest.txt
10 | compile_commands.json
11 | CTestTestfile.cmake
12 | _deps
13 |
14 | # Project specific
15 | cmake/*
16 | !cmake/.gitkeep
17 | node_modules
18 | .idea
19 |
20 | pybuild/
21 | .history/
--------------------------------------------------------------------------------
/.gitmodules:
--------------------------------------------------------------------------------
1 | [submodule "src/tensorizer"]
2 | path = src/tensorizer
3 | url = https://github.com/coreweave/tensorizer.git
4 |
--------------------------------------------------------------------------------
/.idea/.gitignore:
--------------------------------------------------------------------------------
1 | # Default ignored files
2 | /shelf/
3 | /workspace.xml
4 | # Editor-based HTTP Client requests
5 | /httpRequests/
6 | # Datasource local storage ignored files
7 | /dataSources/
8 | /dataSources.local.xml
9 |
--------------------------------------------------------------------------------
/CMakeLists.txt:
--------------------------------------------------------------------------------
1 | cmake_minimum_required(VERSION 3.14)
2 | project(interfaces)
3 |
4 | # Automatically determine our project namespace.
5 | find_package(Git)
6 | execute_process(
7 | COMMAND ${GIT_EXECUTABLE} config --get remote.origin.url
8 | OUTPUT_VARIABLE REMOTE_ORIGIN
9 | OUTPUT_STRIP_TRAILING_WHITESPACE)
10 |
11 | string(REPLACE "git@github.com:" "" REPO_PATH "${REMOTE_ORIGIN}")
12 | string(REPLACE "https://github.com/" "" REPO_PATH "${REPO_PATH}")
13 |
14 | string(REPLACE ".git" "" PROJECT_REF "${REPO_PATH}")
15 | string(TOLOWER ${PROJECT_REF} PROJECT_REF)
16 |
17 | include(src/cmake/FindgRPC.cmake)
18 |
19 | find_package(PkgConfig REQUIRED)
20 | find_package(Protobuf REQUIRED)
21 | #find_package(gRPC CONFIG REQUIRED)
22 | set(PROTO_PATH "${PROJECT_SOURCE_DIR}/src/proto")
23 | set(TENSORIZER_PROTO_PATH "${PROJECT_SOURCE_DIR}/src/tensorizer/proto")
24 | set(GENERATED_PROTOBUF_PATH "${PROJECT_SOURCE_DIR}/gooseai")
25 | file(MAKE_DIRECTORY ${GENERATED_PROTOBUF_PATH})
26 |
27 | ## Python target support
28 | find_package(Python3 REQUIRED COMPONENTS Interpreter)
29 |
30 | set(PYBUILD_PATH "${PROJECT_BINARY_DIR}/pybuild")
31 | execute_process(COMMAND python3 -m venv ${PYBUILD_PATH}
32 | RESULT_VARIABLE EXIT_CODE
33 | OUTPUT_QUIET)
34 | if (NOT ${EXIT_CODE} EQUAL 0)
35 | message(FATAL_ERROR
36 | "Could not create python3 env at ${PYBUILD_PATH}")
37 | endif()
38 |
39 | execute_process(COMMAND ${PYBUILD_PATH}/bin/pip3 show grpcio-tools grpcio protobuf
40 | RESULT_VARIABLE EXIT_CODE
41 | OUTPUT_QUIET)
42 | if (NOT ${EXIT_CODE} EQUAL 0)
43 | execute_process(COMMAND ${PYBUILD_PATH}/bin/pip3 install -r ${PROJECT_SOURCE_DIR}/requirements.txt
44 | RESULT_VARIABLE EXIT_CODE)
45 | if (NOT ${EXIT_CODE} EQUAL 0)
46 | message(FATAL_ERROR
47 | "Could not install python3 requirements at ${PYBUILD_PATH}")
48 | endif()
49 | endif()
50 |
51 |
52 | set(python_exec "${PYBUILD_PATH}/bin/python3")
53 | set(python_args "-m" "grpc_tools.protoc")
54 | set(python_plugin "")
55 | set(python_output "--python_out=")
56 | set(python_output_dir "${PROJECT_SOURCE_DIR}/gooseai")
57 | file(MAKE_DIRECTORY "${python_output_dir}")
58 | file(WRITE "${PROJECT_SOURCE_DIR}/gooseai/__init__.py")
59 | set(python_exts "_pb2.py")
60 |
61 | set(python_grpc_exec "${PYBUILD_PATH}/bin/python3")
62 | set(python_grpc_args "-m" "grpc_tools.protoc")
63 | set(python_grpc_output "--grpc_python_out=")
64 | set(python_grpc_output_dir "${PROJECT_SOURCE_DIR}/gooseai")
65 | set(python_grpc_plugin "")
66 | set(python_grpc_exts "_grpc.py")
67 |
68 | ## Golang target support
69 | execute_Process(COMMAND go version
70 | RESULT_VARIABLE EXIT_CODE)
71 | if (NOT ${EXIT_CODE} EQUAL 0)
72 | message(FATAL_ERROR
73 | "You need to have a `golang` environment installed with an appropriately set GOROOT.")
74 | endif()
75 |
76 | execute_process(COMMAND go install google.golang.org/protobuf/cmd/protoc-gen-go@v1.26
77 | RESULT_VARIABLE EXIT_CODE)
78 | if (NOT ${EXIT_CODE} EQUAL 0)
79 | message(FATAL_ERROR
80 | "Error ensuring that `protoc-gen-go` is installed.")
81 | endif()
82 | execute_process(COMMAND go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@v1.1.0
83 | RESULT_VARIABLE EXIT_CODE)
84 | if (NOT ${EXIT_CODE} EQUAL 0)
85 | message(FATAL_ERROR
86 | "Error ensuring that `protoc-gen-go-grpc` is installed.")
87 | endif()
88 |
89 | set(golang_plugin "")
90 | set(golang_output "--go_out=paths=source_relative:")
91 | set(golang_output_dir "${PROJECT_SOURCE_DIR}/gooseai")
92 | file(MAKE_DIRECTORY "${golang_output_dir}")
93 | set(golang_exts ".go")
94 |
95 | set(golang_grpc "")
96 | set(golang_grpc_output "--go-grpc_out=paths=source_relative:")
97 | set(golang_grpc_output_dir "${PROJECT_SOURCE_DIR}/gooseai")
98 | file(MAKE_DIRECTORY "${golang_grpc_output_dir}")
99 | set(golang_grpc_exts "-grpc.go")
100 |
101 | # Javascript / Typescript target support
102 | execute_process(COMMAND npm version
103 | RESULT_VARIABLE EXIT_CODE
104 | OUTPUT_QUIET)
105 | if (NOT ${EXIT_CODE} EQUAL 0)
106 | message(FATAL_ERROR
107 | "npm is not installed. Please ensure that it is installed by using your favorite package manager.")
108 | endif()
109 |
110 | set(ENV{npm_config_target_arch} x64)
111 | execute_process(COMMAND npm install
112 | RESULT_VARIABLE EXIT_CODE)
113 | if (NOT ${EXIT_CODE} EQUAL 0)
114 | message(FATAL_ERROR
115 | "npm install failed!")
116 | endif()
117 | set(NODE_BIN_DIRECTORY "${PROJECT_SOURCE_DIR}/node_modules/.bin")
118 |
119 | set(javascript_exec "${PROJECT_SOURCE_DIR}/src/bin/protoc")
120 | set(javascript_plugin "--plugin=protoc-gen-ts=${NODE_BIN_DIRECTORY}/protoc-gen-ts")
121 | set(javascript_args "")
122 | set(javascript_output "--js_out=import_style=commonjs,binary:")
123 | set(javascript_output_dir "${PROJECT_SOURCE_DIR}/gooseai")
124 | file(MAKE_DIRECTORY "${javascript_output_dir}")
125 | set(javascript_exts "_pb.js")
126 |
127 | set(javascript_grpc_exec "${PROJECT_SOURCE_DIR}/src/bin/protoc")
128 | set(javascript_grpc_plugin "--plugin=protoc-gen-ts=${NODE_BIN_DIRECTORY}/protoc-gen-ts" "--plugin=protoc-gen-grpc=${NODE_BIN_DIRECTORY}/grpc_tools_node_protoc_plugin")
129 | set(javascript_grpc_args "")
130 | set(javascript_grpc_output "--grpc_out=import_style=commonjs,binary:")
131 | set(javascript_grpc_output_dir "${PROJECT_SOURCE_DIR}/gooseai")
132 | file(MAKE_DIRECTORY "${javascript_grpc_output_dir}")
133 | set(javascript_grpc_exts "_grpc_pb.js")
134 |
135 | set(typescript_web_exec "${PROJECT_SOURCE_DIR}/src/bin/protoc")
136 | set(typescript_web_plugin "--plugin=protoc-gen-ts=${NODE_BIN_DIRECTORY}/protoc-gen-ts")
137 | set(typescript_web_args "")
138 | set(typescript_web_output "--ts_out=service=grpc-web:")
139 | set(typescript_web_output_dir "${PROJECT_SOURCE_DIR}/gooseai")
140 | file(MAKE_DIRECTORY "${typescript_output_dir}")
141 | set(typescript_web_exts "_grpc_pb_service.d.ts;_grpc_pb_service.js")
142 |
143 | set(typescript_node_exec "${PROJECT_SOURCE_DIR}/src/bin/protoc")
144 | set(typescript_node_plugin "--plugin=protoc-gen-ts=${NODE_BIN_DIRECTORY}/protoc-gen-ts" "--plugin=protoc-gen-grpc=${NODE_BIN_DIRECTORY}/grpc_tools_node_protoc_plugin")
145 | set(typescript_node_args "")
146 | set(typescript_node_output "--ts_out=service=grpc-node:")
147 | set(typescript_node_output_dir "${PROJECT_SOURCE_DIR}/gooseai")
148 | file(MAKE_DIRECTORY "${typescript_output_dir}")
149 | set(typescript_node_exts "_grpc_pb.d.ts")
150 |
151 | ## Protobuf and GRPC stub building macros
152 | macro (_add_pb_file _src TYP VAR)
153 | message("Will generate stub ${VAR} for ${_src}")
154 | list(APPEND SRC_${VAR} ${_src})
155 | endmacro()
156 |
157 | macro (add_protobufs)
158 | foreach (_src ${ARGN})
159 | _add_pb_file(${_src} PROTO Protobufs)
160 | endforeach()
161 | endmacro()
162 |
163 | macro(_generate_interface LANG INTERFACE_FILE)
164 | get_filename_component(_PROTOBUF_DIR "${INTERFACE_FILE}" DIRECTORY)
165 | get_filename_component(_PROTOBUF_SHORT "${INTERFACE_FILE}" NAME_WE)
166 | file(MAKE_DIRECTORY "${${_lang}_output_dir}")
167 | file(MAKE_DIRECTORY "${_PROTOBUF_DIR}")
168 | set(_PROTOBUF_NAME "${_PROTOBUF_DIR}/${_PROTOBUF_SHORT}")
169 | set(OUTPUT_FILES)
170 | set(CMD_EXEC)
171 | foreach(_ext ${${LANG}_exts})
172 | set(OUTPUT_FILE_NAME "${${LANG}_output_dir}/${_PROTOBUF_SHORT}/${_PROTOBUF_SHORT}${_ext}")
173 | list(APPEND GENERATED_PROTOBUF_FILES_${LANG} "${OUTPUT_FILE_NAME}")
174 | list(APPEND OUTPUT_FILES "${OUTPUT_FILE_NAME}")
175 | message("${INTERFACE_FILE} => ${OUTPUT_FILE_NAME}")
176 | endforeach()
177 | if(DEFINED ${LANG}_exec)
178 | set(CMD_EXEC ${${LANG}_exec})
179 | else()
180 | set(CMD_EXEC "${PROTOBUF_PROTOC_EXECUTABLE}")
181 | endif()
182 | add_custom_command(
183 | OUTPUT ${OUTPUT_FILES}
184 |
185 | COMMAND "mkdir"
186 | ARGS "-p"
187 | ARGS "${${LANG}_output_dir}/${_PROTOBUF_SHORT}"
188 |
189 | COMMAND ${CMD_EXEC}
190 | ARGS ${${LANG}_args}
191 | ARGS "--proto_path=${PROTOBUF_INCLUDE_DIRS}"
192 | ARGS "--proto_path=${PROTO_PATH}"
193 | ARGS "--proto_path=${TENSORIZER_PROTO_PATH}"
194 | ARGS "--experimental_allow_proto3_optional"
195 | ARGS ${${LANG}_plugin}
196 | ARGS "${${LANG}_output}${${LANG}_output_dir}/${_PROTOBUF_SHORT}"
197 | ARGS "${INTERFACE_FILE}")
198 | endmacro()
199 |
200 | macro(generate_interfaces)
201 | foreach(_lang ${TARGET_LANGUAGES})
202 | foreach(_src ${SRC_Interfaces} ${SRC_Protobufs})
203 | _generate_interface("${_lang}" ${_src})
204 | endforeach()
205 | foreach(_src ${SRC_Interfaces})
206 | if(DEFINED ${_lang}_grpc_output)
207 | _generate_interface(${_lang}_grpc ${_src})
208 | endif()
209 | endforeach()
210 | endforeach()
211 | endmacro()
212 |
213 | macro(add_target_languages)
214 | foreach(_lang ${ARGN})
215 | message("Will generate stubs for ${_lang}")
216 | #file(MAKE_DIRECTORY "${GENERATED_PROTOBUF_PATH}/${_lang}")
217 | file(MAKE_DIRECTORY "${${_lang}_output_dir}")
218 | list(APPEND TARGET_LANGUAGES ${_lang})
219 | endforeach()
220 | endmacro()
221 |
222 | set(RESOURCES)
223 | macro(add_resource)
224 | foreach(_res ${ARGN})
225 | list(APPEND RESOURCES "${CMAKE_CURRENT_BINARY_DIR}/${_res}")
226 | add_custom_command(
227 | OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/${_res}"
228 | COMMAND ${CMAKE_COMMAND} -E copy "${CMAKE_CURRENT_SOURCE_DIR}/${_res}"
229 | "${CMAKE_CURRENT_BINARY_DIR}/${_res}"
230 | DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/${_res}")
231 | endforeach()
232 | endmacro()
233 |
234 | # Set our build targets.
235 | add_target_languages(
236 | python
237 | python_grpc
238 | golang
239 | golang_grpc
240 | javascript
241 | javascript_grpc
242 | typescript_web
243 | typescript_node
244 | )
245 |
246 | # Generate base protobufs
247 | add_protobufs(${CMAKE_SOURCE_DIR}/src/proto/dashboard.proto)
248 | add_protobufs(${CMAKE_SOURCE_DIR}/src/proto/generation.proto)
249 | add_protobufs(${CMAKE_SOURCE_DIR}/src/proto/engines.proto)
250 | add_protobufs(${CMAKE_SOURCE_DIR}/src/proto/project.proto)
251 | add_protobufs(${CMAKE_SOURCE_DIR}/src/proto/finetuning.proto)
252 | generate_interfaces()
253 |
254 | add_custom_command(
255 | OUTPUT "${golang_grpc_output_dir}/go.mod"
256 | WORKING_DIRECTORY "${GENERATED_PROTOBUF_PATH}"
257 | COMMAND rm -f go.mod
258 | COMMAND GOPROXY=direct go mod init github.com/${PROJECT_REF}/gooseai
259 | COMMAND go mod tidy
260 | DEPENDS ${GENERATED_PROTOBUF_FILES_golang_grpc})
261 |
262 | # Tensorizer files
263 | macro(copy_files FILES SRC DEST)
264 | set(DEPENDS_FILES "")
265 | foreach(_file ${FILES})
266 | list(APPEND OUTPUT_FILES "${DEST}/${_file}")
267 | add_custom_command(
268 | OUTPUT "${DEST}/${_file}"
269 |
270 | COMMAND "mkdir"
271 | ARGS "-p"
272 | ARGS "${DEST}"
273 |
274 | COMMAND cp
275 | ARGS "${SRC}/${_file}"
276 | ARGS "${DEST}"
277 | DEPENDS "${SRC}/${_file}")
278 | endforeach()
279 | endmacro()
280 |
281 | set(TENSORIZER_FILES "tensors_pb.d.ts;tensors_pb.js;tensors_pb2.py")
282 | set(TENSORIZER_SRC "${PROJECT_SOURCE_DIR}/src/tensorizer/tensors")
283 | set(TENSORIZER_DEST "${PROJECT_SOURCE_DIR}/gooseai/generation")
284 |
285 | set(OUTPUT_FILES "")
286 | copy_files("${TENSORIZER_FILES}" "${TENSORIZER_SRC}" "${TENSORIZER_DEST}")
287 |
288 | add_custom_target(
289 | generated ALL
290 | DEPENDS
291 | ${GENERATED_PROTOBUF_FILES_python}
292 | ${GENERATED_PROTOBUF_FILES_python_grpc}
293 | ${GENERATED_PROTOBUF_FILES_golang}
294 | ${GENERATED_PROTOBUF_FILES_golang_grpc}
295 | ${GENERATED_PROTOBUF_FILES_javascript}
296 | ${GENERATED_PROTOBUF_FILES_javascript_grpc}
297 | ${GENERATED_PROTOBUF_FILES_typescript_web}
298 | ${GENERATED_PROTOBUF_FILES_typescript_node}
299 | ${PROJECT_SOURCE_DIR}/gooseai/go.mod
300 | ${OUTPUT_FILES}
301 | )
302 |
--------------------------------------------------------------------------------
/Dockerfile:
--------------------------------------------------------------------------------
1 | ARG NODE_IMAGE_TAG=16-bullseye
2 | FROM --platform=linux/amd64 node:${NODE_IMAGE_TAG} as builder
3 | ARG GOLANG_VERSION=1.18.6
4 | ARG GOLANG_PACKAGE=https://go.dev/dl/go${GOLANG_VERSION}.linux-amd64.tar.gz
5 | ARG GRPC_VERSION=v1.48.2
6 | ARG PROTOC_GEN_GO_VERSION=v1.28.1
7 | ARG PROTOC_GEN_GO_GRPC_VERSION=v1.1.0
8 |
9 | # Install python and build tools from apt
10 | RUN apt-get update && apt-get install -y cmake git build-essential python3-venv wget && rm -rf /var/lib/apt/lists/*
11 |
12 | # Install golang from binary package
13 | RUN rm -rf /go && wget ${GOLANG_PACKAGE} -qO- | tar -C / -xz
14 | ENV GOPATH=/go
15 | ENV PATH $GOPATH/bin:$PATH
16 | RUN mkdir -p "$GOPATH/src" "$GOPATH/bin" && chmod -R 777 "$GOPATH"
17 | RUN mkdir -p /build
18 |
19 | # Build GRPC; note this issue before updating: https://github.com/protocolbuffers/protobuf-javascript/issues/127
20 | WORKDIR /build
21 | RUN git clone --recurse-submodules -b ${GRPC_VERSION} --depth 1 --shallow-submodules https://github.com/grpc/grpc
22 | WORKDIR /build/grpc
23 | RUN mkdir -p cmake/build; cd cmake/build; cmake -DgRPC_INSTALL=ON -DgRPC_BUILD_TESTS=OFF -DCMAKE_INSTALL_PREFIX=/usr/local ../.. && make -j 8 && make install
24 |
25 | # Build api-interfaces
26 | RUN go install google.golang.org/protobuf/cmd/protoc-gen-go@${PROTOC_GEN_GO_VERSION}
27 | RUN go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@${PROTOC_GEN_GO_GRPC_VERSION}
28 |
29 | COPY package.json package-lock.json requirements.txt /build/api-interfaces/
30 | COPY .git /build/api-interfaces/.git/
31 | COPY src/ /build/api-interfaces/src/
32 | COPY gooseai/ /build/api-interfaces/gooseai/
33 | WORKDIR /build/api-interfaces
34 | COPY CMakeLists.txt /build/api-interfaces/
35 | RUN cmake .
36 | RUN make clean && cmake --build .
37 |
38 | # Copy output to a bare container
39 | FROM debian:bullseye-slim
40 | COPY --from=builder /build/api-interfaces/gooseai /gooseai
41 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | ## 📝 Table of Contents
2 |
3 | - [About](#about)
4 | - [Getting Started](#getting_started)
5 | - [Usage](#usage)
6 |
7 | ## About
8 |
9 | Api-Interfaces is the gRPC protocol for communication between the
10 | [api-bridge](https://github.com/Stability-AI/api-bridge), the [api-web](https://github.com/Stability-AI/api-web),
11 | and the [generator_server](https://github.com/Stability-AI/generator_server). Additionally, any
12 | other client application communicating directly with `api-web` also use the interfaces generated
13 | from this repository.
14 |
15 | See [here](https://www.notion.so/stabilityai/Protocol-Buffer-Development-Guidelines-94c6a5b9082d4aa6a2d6bf50b86fe0ac) for some development guides.
16 |
17 | ## Getting Started
18 |
19 | These instructions will get you an environment setup to build the interface files from the proto source files.
20 |
21 | ### Prerequisites
22 |
23 | The following items are needed to develop api-interfaces:
24 | - [golang](https://go.dev/) >= 1.18
25 | - [nodejs](https://nodejs.org/en/) >= 16.16.0
26 | - [cmake](https://cmake.org/) >= 3.14
27 | - [protoc](https://github.com/protocolbuffers/protobuf#protocol-compiler-installation)
28 | - [grpc](https://grpc.io/)
29 |
30 | It is recommended to use ssh cloning with this project for `git` and for `go get`, although `https`
31 | does appear to work. To force ssh (for github) put the following in your `.gitconfig`:
32 |
33 | ```ini
34 | [url "ssh://git@github.com/"]
35 | insteadOf = https://github.com/
36 | ```
37 |
38 | ### Setup and building
39 |
40 | After all the prerequisites are installed and available, this project can be setup by the following:
41 |
42 | ```shell
43 | git clone --recurse-submodules git@github.com:Stability-AI/api-interfaces.git
44 | cd api-interfaces
45 | cmake .
46 | cmake --build .
47 | ```
48 |
49 | This will produce files for the various languages in [gooseai](./gooseai) to support the proto
50 | files in [src](./src). *When rebuilding the files it is recommended to do a clean before as there
51 | have been instances of not all files being regenerated without it.*
52 |
53 | ## 🎈 Usage
54 |
55 | The generated files are all output in [gooseai](./gooseai). How to use these files depends on the
56 | programming language being used. The following sections provide details for each of the supported
57 | languages.
58 |
59 | The files have different usages and not all are required depending on the situation:
60 | | Suffix | Client | Server |
61 | |-------------|--------|--------|
62 | | _grpc_pb | ✔️1 | ✔️ |
63 | | _pb_service | ✔️2 | |
64 | | _pb | ✔️ | ✔️ |
65 |
66 |
67 | 1. Not needed for typescript/javascript clients.
68 | 2. Only needed for typscript/javascripts clients.
69 |
70 |
71 | ### Golang
72 |
73 | For Golang the interfaces can be added to the project as a normal module require. To add them run:
74 |
75 | ```shell
76 | go get github.com/Stability-AI/api-interfaces@latest
77 | ```
78 |
79 | Similarly to update them just run the same command with the short sha of the version to update to.
80 | Use them as you would a normal module.
81 |
82 | ### Python
83 |
84 | With the current output, the best way to consume these is to add them as a git submodule to your
85 | project. It is recommended to use ssh clone when adding the submodule. To update them just
86 | checkout the newer version from within the submodule (and remember to commit the submodule change
87 | to your project).
88 |
89 | To use them make sure the files are on the python path.
90 |
91 |
92 | ### Typescript / Javascript
93 |
94 | With the current output, the best way to consume these is to add them as a git submodule to your
95 | project. It is recommended to use ssh clone when adding the submodule. To update them just
96 | checkout the newer version from within the submodule (and remember to commit the submodule change
97 | to your project).
98 |
99 | To use them make sure they are in a location that can be found by your typescript/javascript files.
100 |
101 | *NOTE: Typescript requires both the typescript and javascript files to be available.*
102 |
103 | ### Other Languages / Custom Build
104 |
105 | If not using the CMake defined builds to generate make sure when building from the source proto
106 | files that the following proto include paths are set:
107 | - `src/proto`
108 | - `src/tensorizer/proto`
109 |
--------------------------------------------------------------------------------
/__init__.py:
--------------------------------------------------------------------------------
1 |
2 |
--------------------------------------------------------------------------------
/buf.work.yaml:
--------------------------------------------------------------------------------
1 | version: v1
2 | directories:
3 | - src/proto
4 | - src/tensorizer/proto
5 |
--------------------------------------------------------------------------------
/buf.yaml:
--------------------------------------------------------------------------------
1 | version: v1
2 | breaking:
3 | use:
4 | - FILE
5 | build:
6 | excludes:
7 | - node_modules
8 | - build
9 |
--------------------------------------------------------------------------------
/cmake/.gitkeep:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Stability-AI/api-interfaces/0c30849b5d12274b1858658df796366c06b8c3fa/cmake/.gitkeep
--------------------------------------------------------------------------------
/gooseai/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Stability-AI/api-interfaces/0c30849b5d12274b1858658df796366c06b8c3fa/gooseai/__init__.py
--------------------------------------------------------------------------------
/gooseai/engines/engines_grpc.pb.go:
--------------------------------------------------------------------------------
1 | // Code generated by protoc-gen-go-grpc. DO NOT EDIT.
2 |
3 | package engines
4 |
5 | import (
6 | context "context"
7 | grpc "google.golang.org/grpc"
8 | codes "google.golang.org/grpc/codes"
9 | status "google.golang.org/grpc/status"
10 | )
11 |
12 | // This is a compile-time assertion to ensure that this generated file
13 | // is compatible with the grpc package it is being compiled against.
14 | // Requires gRPC-Go v1.32.0 or later.
15 | const _ = grpc.SupportPackageIsVersion7
16 |
17 | // EnginesServiceClient is the client API for EnginesService service.
18 | //
19 | // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
20 | type EnginesServiceClient interface {
21 | ListEngines(ctx context.Context, in *ListEnginesRequest, opts ...grpc.CallOption) (*Engines, error)
22 | }
23 |
24 | type enginesServiceClient struct {
25 | cc grpc.ClientConnInterface
26 | }
27 |
28 | func NewEnginesServiceClient(cc grpc.ClientConnInterface) EnginesServiceClient {
29 | return &enginesServiceClient{cc}
30 | }
31 |
32 | func (c *enginesServiceClient) ListEngines(ctx context.Context, in *ListEnginesRequest, opts ...grpc.CallOption) (*Engines, error) {
33 | out := new(Engines)
34 | err := c.cc.Invoke(ctx, "/gooseai.EnginesService/ListEngines", in, out, opts...)
35 | if err != nil {
36 | return nil, err
37 | }
38 | return out, nil
39 | }
40 |
41 | // EnginesServiceServer is the server API for EnginesService service.
42 | // All implementations must embed UnimplementedEnginesServiceServer
43 | // for forward compatibility
44 | type EnginesServiceServer interface {
45 | ListEngines(context.Context, *ListEnginesRequest) (*Engines, error)
46 | mustEmbedUnimplementedEnginesServiceServer()
47 | }
48 |
49 | // UnimplementedEnginesServiceServer must be embedded to have forward compatible implementations.
50 | type UnimplementedEnginesServiceServer struct {
51 | }
52 |
53 | func (UnimplementedEnginesServiceServer) ListEngines(context.Context, *ListEnginesRequest) (*Engines, error) {
54 | return nil, status.Errorf(codes.Unimplemented, "method ListEngines not implemented")
55 | }
56 | func (UnimplementedEnginesServiceServer) mustEmbedUnimplementedEnginesServiceServer() {}
57 |
58 | // UnsafeEnginesServiceServer may be embedded to opt out of forward compatibility for this service.
59 | // Use of this interface is not recommended, as added methods to EnginesServiceServer will
60 | // result in compilation errors.
61 | type UnsafeEnginesServiceServer interface {
62 | mustEmbedUnimplementedEnginesServiceServer()
63 | }
64 |
65 | func RegisterEnginesServiceServer(s grpc.ServiceRegistrar, srv EnginesServiceServer) {
66 | s.RegisterService(&EnginesService_ServiceDesc, srv)
67 | }
68 |
69 | func _EnginesService_ListEngines_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
70 | in := new(ListEnginesRequest)
71 | if err := dec(in); err != nil {
72 | return nil, err
73 | }
74 | if interceptor == nil {
75 | return srv.(EnginesServiceServer).ListEngines(ctx, in)
76 | }
77 | info := &grpc.UnaryServerInfo{
78 | Server: srv,
79 | FullMethod: "/gooseai.EnginesService/ListEngines",
80 | }
81 | handler := func(ctx context.Context, req interface{}) (interface{}, error) {
82 | return srv.(EnginesServiceServer).ListEngines(ctx, req.(*ListEnginesRequest))
83 | }
84 | return interceptor(ctx, in, info, handler)
85 | }
86 |
87 | // EnginesService_ServiceDesc is the grpc.ServiceDesc for EnginesService service.
88 | // It's only intended for direct use with grpc.RegisterService,
89 | // and not to be introspected or modified (even as a copy)
90 | var EnginesService_ServiceDesc = grpc.ServiceDesc{
91 | ServiceName: "gooseai.EnginesService",
92 | HandlerType: (*EnginesServiceServer)(nil),
93 | Methods: []grpc.MethodDesc{
94 | {
95 | MethodName: "ListEngines",
96 | Handler: _EnginesService_ListEngines_Handler,
97 | },
98 | },
99 | Streams: []grpc.StreamDesc{},
100 | Metadata: "engines.proto",
101 | }
102 |
--------------------------------------------------------------------------------
/gooseai/engines/engines_grpc_pb.d.ts:
--------------------------------------------------------------------------------
1 | // GENERATED CODE -- DO NOT EDIT!
2 |
3 | // package: gooseai
4 | // file: engines.proto
5 |
6 | import * as engines_pb from "./engines_pb";
7 | import * as grpc from "grpc";
8 |
9 | interface IEnginesServiceService extends grpc.ServiceDefinition {
10 | listEngines: grpc.MethodDefinition;
11 | }
12 |
13 | export const EnginesServiceService: IEnginesServiceService;
14 |
15 | export interface IEnginesServiceServer extends grpc.UntypedServiceImplementation {
16 | listEngines: grpc.handleUnaryCall;
17 | }
18 |
19 | export class EnginesServiceClient extends grpc.Client {
20 | constructor(address: string, credentials: grpc.ChannelCredentials, options?: object);
21 | listEngines(argument: engines_pb.ListEnginesRequest, callback: grpc.requestCallback): grpc.ClientUnaryCall;
22 | listEngines(argument: engines_pb.ListEnginesRequest, metadataOrOptions: grpc.Metadata | grpc.CallOptions | null, callback: grpc.requestCallback): grpc.ClientUnaryCall;
23 | listEngines(argument: engines_pb.ListEnginesRequest, metadata: grpc.Metadata | null, options: grpc.CallOptions | null, callback: grpc.requestCallback): grpc.ClientUnaryCall;
24 | }
25 |
--------------------------------------------------------------------------------
/gooseai/engines/engines_grpc_pb.js:
--------------------------------------------------------------------------------
1 | // GENERATED CODE -- DO NOT EDIT!
2 |
3 | 'use strict';
4 | var grpc = require('grpc');
5 | var engines_pb = require('./engines_pb.js');
6 |
7 | function serialize_gooseai_Engines(arg) {
8 | if (!(arg instanceof engines_pb.Engines)) {
9 | throw new Error('Expected argument of type gooseai.Engines');
10 | }
11 | return Buffer.from(arg.serializeBinary());
12 | }
13 |
14 | function deserialize_gooseai_Engines(buffer_arg) {
15 | return engines_pb.Engines.deserializeBinary(new Uint8Array(buffer_arg));
16 | }
17 |
18 | function serialize_gooseai_ListEnginesRequest(arg) {
19 | if (!(arg instanceof engines_pb.ListEnginesRequest)) {
20 | throw new Error('Expected argument of type gooseai.ListEnginesRequest');
21 | }
22 | return Buffer.from(arg.serializeBinary());
23 | }
24 |
25 | function deserialize_gooseai_ListEnginesRequest(buffer_arg) {
26 | return engines_pb.ListEnginesRequest.deserializeBinary(new Uint8Array(buffer_arg));
27 | }
28 |
29 |
30 | var EnginesServiceService = exports.EnginesServiceService = {
31 | listEngines: {
32 | path: '/gooseai.EnginesService/ListEngines',
33 | requestStream: false,
34 | responseStream: false,
35 | requestType: engines_pb.ListEnginesRequest,
36 | responseType: engines_pb.Engines,
37 | requestSerialize: serialize_gooseai_ListEnginesRequest,
38 | requestDeserialize: deserialize_gooseai_ListEnginesRequest,
39 | responseSerialize: serialize_gooseai_Engines,
40 | responseDeserialize: deserialize_gooseai_Engines,
41 | },
42 | };
43 |
44 | exports.EnginesServiceClient = grpc.makeGenericClientConstructor(EnginesServiceService);
45 |
--------------------------------------------------------------------------------
/gooseai/engines/engines_pb.d.ts:
--------------------------------------------------------------------------------
1 | // package: gooseai
2 | // file: engines.proto
3 |
4 | import * as jspb from "google-protobuf";
5 |
6 | export class EngineInfo extends jspb.Message {
7 | getId(): string;
8 | setId(value: string): void;
9 |
10 | getOwner(): string;
11 | setOwner(value: string): void;
12 |
13 | getReady(): boolean;
14 | setReady(value: boolean): void;
15 |
16 | getType(): EngineTypeMap[keyof EngineTypeMap];
17 | setType(value: EngineTypeMap[keyof EngineTypeMap]): void;
18 |
19 | getTokenizer(): EngineTokenizerMap[keyof EngineTokenizerMap];
20 | setTokenizer(value: EngineTokenizerMap[keyof EngineTokenizerMap]): void;
21 |
22 | getName(): string;
23 | setName(value: string): void;
24 |
25 | getDescription(): string;
26 | setDescription(value: string): void;
27 |
28 | getCanFineTune(): boolean;
29 | setCanFineTune(value: boolean): void;
30 |
31 | getIsAdaptive(): boolean;
32 | setIsAdaptive(value: boolean): void;
33 |
34 | serializeBinary(): Uint8Array;
35 | toObject(includeInstance?: boolean): EngineInfo.AsObject;
36 | static toObject(includeInstance: boolean, msg: EngineInfo): EngineInfo.AsObject;
37 | static extensions: {[key: number]: jspb.ExtensionFieldInfo};
38 | static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo};
39 | static serializeBinaryToWriter(message: EngineInfo, writer: jspb.BinaryWriter): void;
40 | static deserializeBinary(bytes: Uint8Array): EngineInfo;
41 | static deserializeBinaryFromReader(message: EngineInfo, reader: jspb.BinaryReader): EngineInfo;
42 | }
43 |
44 | export namespace EngineInfo {
45 | export type AsObject = {
46 | id: string,
47 | owner: string,
48 | ready: boolean,
49 | type: EngineTypeMap[keyof EngineTypeMap],
50 | tokenizer: EngineTokenizerMap[keyof EngineTokenizerMap],
51 | name: string,
52 | description: string,
53 | canFineTune: boolean,
54 | isAdaptive: boolean,
55 | }
56 | }
57 |
58 | export class ListEnginesRequest extends jspb.Message {
59 | serializeBinary(): Uint8Array;
60 | toObject(includeInstance?: boolean): ListEnginesRequest.AsObject;
61 | static toObject(includeInstance: boolean, msg: ListEnginesRequest): ListEnginesRequest.AsObject;
62 | static extensions: {[key: number]: jspb.ExtensionFieldInfo};
63 | static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo};
64 | static serializeBinaryToWriter(message: ListEnginesRequest, writer: jspb.BinaryWriter): void;
65 | static deserializeBinary(bytes: Uint8Array): ListEnginesRequest;
66 | static deserializeBinaryFromReader(message: ListEnginesRequest, reader: jspb.BinaryReader): ListEnginesRequest;
67 | }
68 |
69 | export namespace ListEnginesRequest {
70 | export type AsObject = {
71 | }
72 | }
73 |
74 | export class Engines extends jspb.Message {
75 | clearEngineList(): void;
76 | getEngineList(): Array;
77 | setEngineList(value: Array): void;
78 | addEngine(value?: EngineInfo, index?: number): EngineInfo;
79 |
80 | serializeBinary(): Uint8Array;
81 | toObject(includeInstance?: boolean): Engines.AsObject;
82 | static toObject(includeInstance: boolean, msg: Engines): Engines.AsObject;
83 | static extensions: {[key: number]: jspb.ExtensionFieldInfo};
84 | static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo};
85 | static serializeBinaryToWriter(message: Engines, writer: jspb.BinaryWriter): void;
86 | static deserializeBinary(bytes: Uint8Array): Engines;
87 | static deserializeBinaryFromReader(message: Engines, reader: jspb.BinaryReader): Engines;
88 | }
89 |
90 | export namespace Engines {
91 | export type AsObject = {
92 | engineList: Array,
93 | }
94 | }
95 |
96 | export interface EngineTypeMap {
97 | TEXT: 0;
98 | PICTURE: 1;
99 | AUDIO: 2;
100 | VIDEO: 3;
101 | CLASSIFICATION: 4;
102 | STORAGE: 5;
103 | }
104 |
105 | export const EngineType: EngineTypeMap;
106 |
107 | export interface EngineTokenizerMap {
108 | GPT2: 0;
109 | PILE: 1;
110 | }
111 |
112 | export const EngineTokenizer: EngineTokenizerMap;
113 |
114 |
--------------------------------------------------------------------------------
/gooseai/engines/engines_pb2.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | # Generated by the protocol buffer compiler. DO NOT EDIT!
3 | # source: engines.proto
4 | """Generated protocol buffer code."""
5 | from google.protobuf.internal import enum_type_wrapper
6 | from google.protobuf import descriptor as _descriptor
7 | from google.protobuf import descriptor_pool as _descriptor_pool
8 | from google.protobuf import message as _message
9 | from google.protobuf import reflection as _reflection
10 | from google.protobuf import symbol_database as _symbol_database
11 | # @@protoc_insertion_point(imports)
12 |
13 | _sym_db = _symbol_database.Default()
14 |
15 |
16 |
17 |
18 | DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\rengines.proto\x12\x07gooseai\"\xd5\x01\n\nEngineInfo\x12\n\n\x02id\x18\x01 \x01(\t\x12\r\n\x05owner\x18\x02 \x01(\t\x12\r\n\x05ready\x18\x03 \x01(\x08\x12!\n\x04type\x18\x04 \x01(\x0e\x32\x13.gooseai.EngineType\x12+\n\ttokenizer\x18\x05 \x01(\x0e\x32\x18.gooseai.EngineTokenizer\x12\x0c\n\x04name\x18\x06 \x01(\t\x12\x13\n\x0b\x64\x65scription\x18\x07 \x01(\t\x12\x15\n\rcan_fine_tune\x18\x08 \x01(\x08\x12\x13\n\x0bis_adaptive\x18\t \x01(\x08\"\x14\n\x12ListEnginesRequest\".\n\x07\x45ngines\x12#\n\x06\x65ngine\x18\x01 \x03(\x0b\x32\x13.gooseai.EngineInfo*Z\n\nEngineType\x12\x08\n\x04TEXT\x10\x00\x12\x0b\n\x07PICTURE\x10\x01\x12\t\n\x05\x41UDIO\x10\x02\x12\t\n\x05VIDEO\x10\x03\x12\x12\n\x0e\x43LASSIFICATION\x10\x04\x12\x0b\n\x07STORAGE\x10\x05*%\n\x0f\x45ngineTokenizer\x12\x08\n\x04GPT2\x10\x00\x12\x08\n\x04PILE\x10\x01\x32P\n\x0e\x45nginesService\x12>\n\x0bListEngines\x12\x1b.gooseai.ListEnginesRequest\x1a\x10.gooseai.Engines\"\x00\x42\x38Z6github.com/stability-ai/api-interfaces/gooseai/enginesb\x06proto3')
19 |
20 | _ENGINETYPE = DESCRIPTOR.enum_types_by_name['EngineType']
21 | EngineType = enum_type_wrapper.EnumTypeWrapper(_ENGINETYPE)
22 | _ENGINETOKENIZER = DESCRIPTOR.enum_types_by_name['EngineTokenizer']
23 | EngineTokenizer = enum_type_wrapper.EnumTypeWrapper(_ENGINETOKENIZER)
24 | TEXT = 0
25 | PICTURE = 1
26 | AUDIO = 2
27 | VIDEO = 3
28 | CLASSIFICATION = 4
29 | STORAGE = 5
30 | GPT2 = 0
31 | PILE = 1
32 |
33 |
34 | _ENGINEINFO = DESCRIPTOR.message_types_by_name['EngineInfo']
35 | _LISTENGINESREQUEST = DESCRIPTOR.message_types_by_name['ListEnginesRequest']
36 | _ENGINES = DESCRIPTOR.message_types_by_name['Engines']
37 | EngineInfo = _reflection.GeneratedProtocolMessageType('EngineInfo', (_message.Message,), {
38 | 'DESCRIPTOR' : _ENGINEINFO,
39 | '__module__' : 'engines_pb2'
40 | # @@protoc_insertion_point(class_scope:gooseai.EngineInfo)
41 | })
42 | _sym_db.RegisterMessage(EngineInfo)
43 |
44 | ListEnginesRequest = _reflection.GeneratedProtocolMessageType('ListEnginesRequest', (_message.Message,), {
45 | 'DESCRIPTOR' : _LISTENGINESREQUEST,
46 | '__module__' : 'engines_pb2'
47 | # @@protoc_insertion_point(class_scope:gooseai.ListEnginesRequest)
48 | })
49 | _sym_db.RegisterMessage(ListEnginesRequest)
50 |
51 | Engines = _reflection.GeneratedProtocolMessageType('Engines', (_message.Message,), {
52 | 'DESCRIPTOR' : _ENGINES,
53 | '__module__' : 'engines_pb2'
54 | # @@protoc_insertion_point(class_scope:gooseai.Engines)
55 | })
56 | _sym_db.RegisterMessage(Engines)
57 |
58 | _ENGINESSERVICE = DESCRIPTOR.services_by_name['EnginesService']
59 | if _descriptor._USE_C_DESCRIPTORS == False:
60 |
61 | DESCRIPTOR._options = None
62 | DESCRIPTOR._serialized_options = b'Z6github.com/stability-ai/api-interfaces/gooseai/engines'
63 | _ENGINETYPE._serialized_start=312
64 | _ENGINETYPE._serialized_end=402
65 | _ENGINETOKENIZER._serialized_start=404
66 | _ENGINETOKENIZER._serialized_end=441
67 | _ENGINEINFO._serialized_start=27
68 | _ENGINEINFO._serialized_end=240
69 | _LISTENGINESREQUEST._serialized_start=242
70 | _LISTENGINESREQUEST._serialized_end=262
71 | _ENGINES._serialized_start=264
72 | _ENGINES._serialized_end=310
73 | _ENGINESSERVICE._serialized_start=443
74 | _ENGINESSERVICE._serialized_end=523
75 | # @@protoc_insertion_point(module_scope)
76 |
--------------------------------------------------------------------------------
/gooseai/engines/engines_pb2_grpc.py:
--------------------------------------------------------------------------------
1 | # Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
2 | """Client and server classes corresponding to protobuf-defined services."""
3 | import grpc
4 |
5 | import engines_pb2 as engines__pb2
6 |
7 |
8 | class EnginesServiceStub(object):
9 | """Missing associated documentation comment in .proto file."""
10 |
11 | def __init__(self, channel):
12 | """Constructor.
13 |
14 | Args:
15 | channel: A grpc.Channel.
16 | """
17 | self.ListEngines = channel.unary_unary(
18 | '/gooseai.EnginesService/ListEngines',
19 | request_serializer=engines__pb2.ListEnginesRequest.SerializeToString,
20 | response_deserializer=engines__pb2.Engines.FromString,
21 | )
22 |
23 |
24 | class EnginesServiceServicer(object):
25 | """Missing associated documentation comment in .proto file."""
26 |
27 | def ListEngines(self, request, context):
28 | """Missing associated documentation comment in .proto file."""
29 | context.set_code(grpc.StatusCode.UNIMPLEMENTED)
30 | context.set_details('Method not implemented!')
31 | raise NotImplementedError('Method not implemented!')
32 |
33 |
34 | def add_EnginesServiceServicer_to_server(servicer, server):
35 | rpc_method_handlers = {
36 | 'ListEngines': grpc.unary_unary_rpc_method_handler(
37 | servicer.ListEngines,
38 | request_deserializer=engines__pb2.ListEnginesRequest.FromString,
39 | response_serializer=engines__pb2.Engines.SerializeToString,
40 | ),
41 | }
42 | generic_handler = grpc.method_handlers_generic_handler(
43 | 'gooseai.EnginesService', rpc_method_handlers)
44 | server.add_generic_rpc_handlers((generic_handler,))
45 |
46 |
47 | # This class is part of an EXPERIMENTAL API.
48 | class EnginesService(object):
49 | """Missing associated documentation comment in .proto file."""
50 |
51 | @staticmethod
52 | def ListEngines(request,
53 | target,
54 | options=(),
55 | channel_credentials=None,
56 | call_credentials=None,
57 | insecure=False,
58 | compression=None,
59 | wait_for_ready=None,
60 | timeout=None,
61 | metadata=None):
62 | return grpc.experimental.unary_unary(request, target, '/gooseai.EnginesService/ListEngines',
63 | engines__pb2.ListEnginesRequest.SerializeToString,
64 | engines__pb2.Engines.FromString,
65 | options, channel_credentials,
66 | insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
67 |
--------------------------------------------------------------------------------
/gooseai/engines/engines_pb_service.d.ts:
--------------------------------------------------------------------------------
1 | // package: gooseai
2 | // file: engines.proto
3 |
4 | import * as engines_pb from "./engines_pb";
5 | import {grpc} from "@improbable-eng/grpc-web";
6 |
7 | type EnginesServiceListEngines = {
8 | readonly methodName: string;
9 | readonly service: typeof EnginesService;
10 | readonly requestStream: false;
11 | readonly responseStream: false;
12 | readonly requestType: typeof engines_pb.ListEnginesRequest;
13 | readonly responseType: typeof engines_pb.Engines;
14 | };
15 |
16 | export class EnginesService {
17 | static readonly serviceName: string;
18 | static readonly ListEngines: EnginesServiceListEngines;
19 | }
20 |
21 | export type ServiceError = { message: string, code: number; metadata: grpc.Metadata }
22 | export type Status = { details: string, code: number; metadata: grpc.Metadata }
23 |
24 | interface UnaryResponse {
25 | cancel(): void;
26 | }
27 | interface ResponseStream {
28 | cancel(): void;
29 | on(type: 'data', handler: (message: T) => void): ResponseStream;
30 | on(type: 'end', handler: (status?: Status) => void): ResponseStream;
31 | on(type: 'status', handler: (status: Status) => void): ResponseStream;
32 | }
33 | interface RequestStream {
34 | write(message: T): RequestStream;
35 | end(): void;
36 | cancel(): void;
37 | on(type: 'end', handler: (status?: Status) => void): RequestStream;
38 | on(type: 'status', handler: (status: Status) => void): RequestStream;
39 | }
40 | interface BidirectionalStream {
41 | write(message: ReqT): BidirectionalStream;
42 | end(): void;
43 | cancel(): void;
44 | on(type: 'data', handler: (message: ResT) => void): BidirectionalStream;
45 | on(type: 'end', handler: (status?: Status) => void): BidirectionalStream;
46 | on(type: 'status', handler: (status: Status) => void): BidirectionalStream;
47 | }
48 |
49 | export class EnginesServiceClient {
50 | readonly serviceHost: string;
51 |
52 | constructor(serviceHost: string, options?: grpc.RpcOptions);
53 | listEngines(
54 | requestMessage: engines_pb.ListEnginesRequest,
55 | metadata: grpc.Metadata,
56 | callback: (error: ServiceError|null, responseMessage: engines_pb.Engines|null) => void
57 | ): UnaryResponse;
58 | listEngines(
59 | requestMessage: engines_pb.ListEnginesRequest,
60 | callback: (error: ServiceError|null, responseMessage: engines_pb.Engines|null) => void
61 | ): UnaryResponse;
62 | }
63 |
64 |
--------------------------------------------------------------------------------
/gooseai/engines/engines_pb_service.js:
--------------------------------------------------------------------------------
1 | // package: gooseai
2 | // file: engines.proto
3 |
4 | var engines_pb = require("./engines_pb");
5 | var grpc = require("@improbable-eng/grpc-web").grpc;
6 |
7 | var EnginesService = (function () {
8 | function EnginesService() {}
9 | EnginesService.serviceName = "gooseai.EnginesService";
10 | return EnginesService;
11 | }());
12 |
13 | EnginesService.ListEngines = {
14 | methodName: "ListEngines",
15 | service: EnginesService,
16 | requestStream: false,
17 | responseStream: false,
18 | requestType: engines_pb.ListEnginesRequest,
19 | responseType: engines_pb.Engines
20 | };
21 |
22 | exports.EnginesService = EnginesService;
23 |
24 | function EnginesServiceClient(serviceHost, options) {
25 | this.serviceHost = serviceHost;
26 | this.options = options || {};
27 | }
28 |
29 | EnginesServiceClient.prototype.listEngines = function listEngines(requestMessage, metadata, callback) {
30 | if (arguments.length === 2) {
31 | callback = arguments[1];
32 | }
33 | var client = grpc.unary(EnginesService.ListEngines, {
34 | request: requestMessage,
35 | host: this.serviceHost,
36 | metadata: metadata,
37 | transport: this.options.transport,
38 | debug: this.options.debug,
39 | onEnd: function (response) {
40 | if (callback) {
41 | if (response.status !== grpc.Code.OK) {
42 | var err = new Error(response.statusMessage);
43 | err.code = response.status;
44 | err.metadata = response.trailers;
45 | callback(err, null);
46 | } else {
47 | callback(null, response.message);
48 | }
49 | }
50 | }
51 | });
52 | return {
53 | cancel: function () {
54 | callback = null;
55 | client.close();
56 | }
57 | };
58 | };
59 |
60 | exports.EnginesServiceClient = EnginesServiceClient;
61 |
62 |
--------------------------------------------------------------------------------
/gooseai/finetuning/finetuning_grpc.pb.go:
--------------------------------------------------------------------------------
1 | // Code generated by protoc-gen-go-grpc. DO NOT EDIT.
2 |
3 | package finetuning
4 |
5 | import (
6 | context "context"
7 | grpc "google.golang.org/grpc"
8 | codes "google.golang.org/grpc/codes"
9 | status "google.golang.org/grpc/status"
10 | )
11 |
12 | // This is a compile-time assertion to ensure that this generated file
13 | // is compatible with the grpc package it is being compiled against.
14 | // Requires gRPC-Go v1.32.0 or later.
15 | const _ = grpc.SupportPackageIsVersion7
16 |
17 | // FineTuningServiceClient is the client API for FineTuningService service.
18 | //
19 | // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
20 | type FineTuningServiceClient interface {
21 | // Create a new model and begin the fine tuning process
22 | CreateModel(ctx context.Context, in *CreateModelRequest, opts ...grpc.CallOption) (*CreateModelResponse, error)
23 | // Get a FineTuningModel
24 | GetModel(ctx context.Context, in *GetModelRequest, opts ...grpc.CallOption) (*GetModelResponse, error)
25 | // Update a FineTuningModel by id
26 | UpdateModel(ctx context.Context, in *UpdateModelRequest, opts ...grpc.CallOption) (*UpdateModelResponse, error)
27 | // Delete a fine tuned model
28 | DeleteModel(ctx context.Context, in *DeleteModelRequest, opts ...grpc.CallOption) (*DeleteModelResponse, error)
29 | // Re-run training, does not create a new model
30 | ResubmitModel(ctx context.Context, in *ResubmitModelRequest, opts ...grpc.CallOption) (*ResubmitModelResponse, error)
31 | // List all the fine tuned models for an organization or user
32 | ListModels(ctx context.Context, in *ListModelsRequest, opts ...grpc.CallOption) (*ListModelsResponse, error)
33 | }
34 |
35 | type fineTuningServiceClient struct {
36 | cc grpc.ClientConnInterface
37 | }
38 |
39 | func NewFineTuningServiceClient(cc grpc.ClientConnInterface) FineTuningServiceClient {
40 | return &fineTuningServiceClient{cc}
41 | }
42 |
43 | func (c *fineTuningServiceClient) CreateModel(ctx context.Context, in *CreateModelRequest, opts ...grpc.CallOption) (*CreateModelResponse, error) {
44 | out := new(CreateModelResponse)
45 | err := c.cc.Invoke(ctx, "/gooseai.FineTuningService/CreateModel", in, out, opts...)
46 | if err != nil {
47 | return nil, err
48 | }
49 | return out, nil
50 | }
51 |
52 | func (c *fineTuningServiceClient) GetModel(ctx context.Context, in *GetModelRequest, opts ...grpc.CallOption) (*GetModelResponse, error) {
53 | out := new(GetModelResponse)
54 | err := c.cc.Invoke(ctx, "/gooseai.FineTuningService/GetModel", in, out, opts...)
55 | if err != nil {
56 | return nil, err
57 | }
58 | return out, nil
59 | }
60 |
61 | func (c *fineTuningServiceClient) UpdateModel(ctx context.Context, in *UpdateModelRequest, opts ...grpc.CallOption) (*UpdateModelResponse, error) {
62 | out := new(UpdateModelResponse)
63 | err := c.cc.Invoke(ctx, "/gooseai.FineTuningService/UpdateModel", in, out, opts...)
64 | if err != nil {
65 | return nil, err
66 | }
67 | return out, nil
68 | }
69 |
70 | func (c *fineTuningServiceClient) DeleteModel(ctx context.Context, in *DeleteModelRequest, opts ...grpc.CallOption) (*DeleteModelResponse, error) {
71 | out := new(DeleteModelResponse)
72 | err := c.cc.Invoke(ctx, "/gooseai.FineTuningService/DeleteModel", in, out, opts...)
73 | if err != nil {
74 | return nil, err
75 | }
76 | return out, nil
77 | }
78 |
79 | func (c *fineTuningServiceClient) ResubmitModel(ctx context.Context, in *ResubmitModelRequest, opts ...grpc.CallOption) (*ResubmitModelResponse, error) {
80 | out := new(ResubmitModelResponse)
81 | err := c.cc.Invoke(ctx, "/gooseai.FineTuningService/ResubmitModel", in, out, opts...)
82 | if err != nil {
83 | return nil, err
84 | }
85 | return out, nil
86 | }
87 |
88 | func (c *fineTuningServiceClient) ListModels(ctx context.Context, in *ListModelsRequest, opts ...grpc.CallOption) (*ListModelsResponse, error) {
89 | out := new(ListModelsResponse)
90 | err := c.cc.Invoke(ctx, "/gooseai.FineTuningService/ListModels", in, out, opts...)
91 | if err != nil {
92 | return nil, err
93 | }
94 | return out, nil
95 | }
96 |
97 | // FineTuningServiceServer is the server API for FineTuningService service.
98 | // All implementations must embed UnimplementedFineTuningServiceServer
99 | // for forward compatibility
100 | type FineTuningServiceServer interface {
101 | // Create a new model and begin the fine tuning process
102 | CreateModel(context.Context, *CreateModelRequest) (*CreateModelResponse, error)
103 | // Get a FineTuningModel
104 | GetModel(context.Context, *GetModelRequest) (*GetModelResponse, error)
105 | // Update a FineTuningModel by id
106 | UpdateModel(context.Context, *UpdateModelRequest) (*UpdateModelResponse, error)
107 | // Delete a fine tuned model
108 | DeleteModel(context.Context, *DeleteModelRequest) (*DeleteModelResponse, error)
109 | // Re-run training, does not create a new model
110 | ResubmitModel(context.Context, *ResubmitModelRequest) (*ResubmitModelResponse, error)
111 | // List all the fine tuned models for an organization or user
112 | ListModels(context.Context, *ListModelsRequest) (*ListModelsResponse, error)
113 | mustEmbedUnimplementedFineTuningServiceServer()
114 | }
115 |
116 | // UnimplementedFineTuningServiceServer must be embedded to have forward compatible implementations.
117 | type UnimplementedFineTuningServiceServer struct {
118 | }
119 |
120 | func (UnimplementedFineTuningServiceServer) CreateModel(context.Context, *CreateModelRequest) (*CreateModelResponse, error) {
121 | return nil, status.Errorf(codes.Unimplemented, "method CreateModel not implemented")
122 | }
123 | func (UnimplementedFineTuningServiceServer) GetModel(context.Context, *GetModelRequest) (*GetModelResponse, error) {
124 | return nil, status.Errorf(codes.Unimplemented, "method GetModel not implemented")
125 | }
126 | func (UnimplementedFineTuningServiceServer) UpdateModel(context.Context, *UpdateModelRequest) (*UpdateModelResponse, error) {
127 | return nil, status.Errorf(codes.Unimplemented, "method UpdateModel not implemented")
128 | }
129 | func (UnimplementedFineTuningServiceServer) DeleteModel(context.Context, *DeleteModelRequest) (*DeleteModelResponse, error) {
130 | return nil, status.Errorf(codes.Unimplemented, "method DeleteModel not implemented")
131 | }
132 | func (UnimplementedFineTuningServiceServer) ResubmitModel(context.Context, *ResubmitModelRequest) (*ResubmitModelResponse, error) {
133 | return nil, status.Errorf(codes.Unimplemented, "method ResubmitModel not implemented")
134 | }
135 | func (UnimplementedFineTuningServiceServer) ListModels(context.Context, *ListModelsRequest) (*ListModelsResponse, error) {
136 | return nil, status.Errorf(codes.Unimplemented, "method ListModels not implemented")
137 | }
138 | func (UnimplementedFineTuningServiceServer) mustEmbedUnimplementedFineTuningServiceServer() {}
139 |
140 | // UnsafeFineTuningServiceServer may be embedded to opt out of forward compatibility for this service.
141 | // Use of this interface is not recommended, as added methods to FineTuningServiceServer will
142 | // result in compilation errors.
143 | type UnsafeFineTuningServiceServer interface {
144 | mustEmbedUnimplementedFineTuningServiceServer()
145 | }
146 |
147 | func RegisterFineTuningServiceServer(s grpc.ServiceRegistrar, srv FineTuningServiceServer) {
148 | s.RegisterService(&FineTuningService_ServiceDesc, srv)
149 | }
150 |
151 | func _FineTuningService_CreateModel_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
152 | in := new(CreateModelRequest)
153 | if err := dec(in); err != nil {
154 | return nil, err
155 | }
156 | if interceptor == nil {
157 | return srv.(FineTuningServiceServer).CreateModel(ctx, in)
158 | }
159 | info := &grpc.UnaryServerInfo{
160 | Server: srv,
161 | FullMethod: "/gooseai.FineTuningService/CreateModel",
162 | }
163 | handler := func(ctx context.Context, req interface{}) (interface{}, error) {
164 | return srv.(FineTuningServiceServer).CreateModel(ctx, req.(*CreateModelRequest))
165 | }
166 | return interceptor(ctx, in, info, handler)
167 | }
168 |
169 | func _FineTuningService_GetModel_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
170 | in := new(GetModelRequest)
171 | if err := dec(in); err != nil {
172 | return nil, err
173 | }
174 | if interceptor == nil {
175 | return srv.(FineTuningServiceServer).GetModel(ctx, in)
176 | }
177 | info := &grpc.UnaryServerInfo{
178 | Server: srv,
179 | FullMethod: "/gooseai.FineTuningService/GetModel",
180 | }
181 | handler := func(ctx context.Context, req interface{}) (interface{}, error) {
182 | return srv.(FineTuningServiceServer).GetModel(ctx, req.(*GetModelRequest))
183 | }
184 | return interceptor(ctx, in, info, handler)
185 | }
186 |
187 | func _FineTuningService_UpdateModel_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
188 | in := new(UpdateModelRequest)
189 | if err := dec(in); err != nil {
190 | return nil, err
191 | }
192 | if interceptor == nil {
193 | return srv.(FineTuningServiceServer).UpdateModel(ctx, in)
194 | }
195 | info := &grpc.UnaryServerInfo{
196 | Server: srv,
197 | FullMethod: "/gooseai.FineTuningService/UpdateModel",
198 | }
199 | handler := func(ctx context.Context, req interface{}) (interface{}, error) {
200 | return srv.(FineTuningServiceServer).UpdateModel(ctx, req.(*UpdateModelRequest))
201 | }
202 | return interceptor(ctx, in, info, handler)
203 | }
204 |
205 | func _FineTuningService_DeleteModel_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
206 | in := new(DeleteModelRequest)
207 | if err := dec(in); err != nil {
208 | return nil, err
209 | }
210 | if interceptor == nil {
211 | return srv.(FineTuningServiceServer).DeleteModel(ctx, in)
212 | }
213 | info := &grpc.UnaryServerInfo{
214 | Server: srv,
215 | FullMethod: "/gooseai.FineTuningService/DeleteModel",
216 | }
217 | handler := func(ctx context.Context, req interface{}) (interface{}, error) {
218 | return srv.(FineTuningServiceServer).DeleteModel(ctx, req.(*DeleteModelRequest))
219 | }
220 | return interceptor(ctx, in, info, handler)
221 | }
222 |
223 | func _FineTuningService_ResubmitModel_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
224 | in := new(ResubmitModelRequest)
225 | if err := dec(in); err != nil {
226 | return nil, err
227 | }
228 | if interceptor == nil {
229 | return srv.(FineTuningServiceServer).ResubmitModel(ctx, in)
230 | }
231 | info := &grpc.UnaryServerInfo{
232 | Server: srv,
233 | FullMethod: "/gooseai.FineTuningService/ResubmitModel",
234 | }
235 | handler := func(ctx context.Context, req interface{}) (interface{}, error) {
236 | return srv.(FineTuningServiceServer).ResubmitModel(ctx, req.(*ResubmitModelRequest))
237 | }
238 | return interceptor(ctx, in, info, handler)
239 | }
240 |
241 | func _FineTuningService_ListModels_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
242 | in := new(ListModelsRequest)
243 | if err := dec(in); err != nil {
244 | return nil, err
245 | }
246 | if interceptor == nil {
247 | return srv.(FineTuningServiceServer).ListModels(ctx, in)
248 | }
249 | info := &grpc.UnaryServerInfo{
250 | Server: srv,
251 | FullMethod: "/gooseai.FineTuningService/ListModels",
252 | }
253 | handler := func(ctx context.Context, req interface{}) (interface{}, error) {
254 | return srv.(FineTuningServiceServer).ListModels(ctx, req.(*ListModelsRequest))
255 | }
256 | return interceptor(ctx, in, info, handler)
257 | }
258 |
259 | // FineTuningService_ServiceDesc is the grpc.ServiceDesc for FineTuningService service.
260 | // It's only intended for direct use with grpc.RegisterService,
261 | // and not to be introspected or modified (even as a copy)
262 | var FineTuningService_ServiceDesc = grpc.ServiceDesc{
263 | ServiceName: "gooseai.FineTuningService",
264 | HandlerType: (*FineTuningServiceServer)(nil),
265 | Methods: []grpc.MethodDesc{
266 | {
267 | MethodName: "CreateModel",
268 | Handler: _FineTuningService_CreateModel_Handler,
269 | },
270 | {
271 | MethodName: "GetModel",
272 | Handler: _FineTuningService_GetModel_Handler,
273 | },
274 | {
275 | MethodName: "UpdateModel",
276 | Handler: _FineTuningService_UpdateModel_Handler,
277 | },
278 | {
279 | MethodName: "DeleteModel",
280 | Handler: _FineTuningService_DeleteModel_Handler,
281 | },
282 | {
283 | MethodName: "ResubmitModel",
284 | Handler: _FineTuningService_ResubmitModel_Handler,
285 | },
286 | {
287 | MethodName: "ListModels",
288 | Handler: _FineTuningService_ListModels_Handler,
289 | },
290 | },
291 | Streams: []grpc.StreamDesc{},
292 | Metadata: "finetuning.proto",
293 | }
294 |
--------------------------------------------------------------------------------
/gooseai/finetuning/finetuning_grpc_pb.d.ts:
--------------------------------------------------------------------------------
1 | // GENERATED CODE -- DO NOT EDIT!
2 |
3 | // package: gooseai
4 | // file: finetuning.proto
5 |
6 | import * as finetuning_pb from "./finetuning_pb";
7 | import * as grpc from "grpc";
8 |
9 | interface IFineTuningServiceService extends grpc.ServiceDefinition {
10 | createModel: grpc.MethodDefinition;
11 | getModel: grpc.MethodDefinition;
12 | updateModel: grpc.MethodDefinition;
13 | deleteModel: grpc.MethodDefinition;
14 | resubmitModel: grpc.MethodDefinition;
15 | listModels: grpc.MethodDefinition;
16 | }
17 |
18 | export const FineTuningServiceService: IFineTuningServiceService;
19 |
20 | export interface IFineTuningServiceServer extends grpc.UntypedServiceImplementation {
21 | createModel: grpc.handleUnaryCall;
22 | getModel: grpc.handleUnaryCall;
23 | updateModel: grpc.handleUnaryCall;
24 | deleteModel: grpc.handleUnaryCall;
25 | resubmitModel: grpc.handleUnaryCall;
26 | listModels: grpc.handleUnaryCall;
27 | }
28 |
29 | export class FineTuningServiceClient extends grpc.Client {
30 | constructor(address: string, credentials: grpc.ChannelCredentials, options?: object);
31 | createModel(argument: finetuning_pb.CreateModelRequest, callback: grpc.requestCallback): grpc.ClientUnaryCall;
32 | createModel(argument: finetuning_pb.CreateModelRequest, metadataOrOptions: grpc.Metadata | grpc.CallOptions | null, callback: grpc.requestCallback): grpc.ClientUnaryCall;
33 | createModel(argument: finetuning_pb.CreateModelRequest, metadata: grpc.Metadata | null, options: grpc.CallOptions | null, callback: grpc.requestCallback): grpc.ClientUnaryCall;
34 | getModel(argument: finetuning_pb.GetModelRequest, callback: grpc.requestCallback): grpc.ClientUnaryCall;
35 | getModel(argument: finetuning_pb.GetModelRequest, metadataOrOptions: grpc.Metadata | grpc.CallOptions | null, callback: grpc.requestCallback): grpc.ClientUnaryCall;
36 | getModel(argument: finetuning_pb.GetModelRequest, metadata: grpc.Metadata | null, options: grpc.CallOptions | null, callback: grpc.requestCallback): grpc.ClientUnaryCall;
37 | updateModel(argument: finetuning_pb.UpdateModelRequest, callback: grpc.requestCallback): grpc.ClientUnaryCall;
38 | updateModel(argument: finetuning_pb.UpdateModelRequest, metadataOrOptions: grpc.Metadata | grpc.CallOptions | null, callback: grpc.requestCallback): grpc.ClientUnaryCall;
39 | updateModel(argument: finetuning_pb.UpdateModelRequest, metadata: grpc.Metadata | null, options: grpc.CallOptions | null, callback: grpc.requestCallback): grpc.ClientUnaryCall;
40 | deleteModel(argument: finetuning_pb.DeleteModelRequest, callback: grpc.requestCallback): grpc.ClientUnaryCall;
41 | deleteModel(argument: finetuning_pb.DeleteModelRequest, metadataOrOptions: grpc.Metadata | grpc.CallOptions | null, callback: grpc.requestCallback): grpc.ClientUnaryCall;
42 | deleteModel(argument: finetuning_pb.DeleteModelRequest, metadata: grpc.Metadata | null, options: grpc.CallOptions | null, callback: grpc.requestCallback): grpc.ClientUnaryCall;
43 | resubmitModel(argument: finetuning_pb.ResubmitModelRequest, callback: grpc.requestCallback): grpc.ClientUnaryCall;
44 | resubmitModel(argument: finetuning_pb.ResubmitModelRequest, metadataOrOptions: grpc.Metadata | grpc.CallOptions | null, callback: grpc.requestCallback): grpc.ClientUnaryCall;
45 | resubmitModel(argument: finetuning_pb.ResubmitModelRequest, metadata: grpc.Metadata | null, options: grpc.CallOptions | null, callback: grpc.requestCallback): grpc.ClientUnaryCall;
46 | listModels(argument: finetuning_pb.ListModelsRequest, callback: grpc.requestCallback): grpc.ClientUnaryCall;
47 | listModels(argument: finetuning_pb.ListModelsRequest, metadataOrOptions: grpc.Metadata | grpc.CallOptions | null, callback: grpc.requestCallback): grpc.ClientUnaryCall;
48 | listModels(argument: finetuning_pb.ListModelsRequest, metadata: grpc.Metadata | null, options: grpc.CallOptions | null, callback: grpc.requestCallback): grpc.ClientUnaryCall;
49 | }
50 |
--------------------------------------------------------------------------------
/gooseai/finetuning/finetuning_grpc_pb.js:
--------------------------------------------------------------------------------
1 | // GENERATED CODE -- DO NOT EDIT!
2 |
3 | 'use strict';
4 | var grpc = require('grpc');
5 | var finetuning_pb = require('./finetuning_pb.js');
6 | var google_protobuf_struct_pb = require('google-protobuf/google/protobuf/struct_pb.js');
7 |
8 | function serialize_gooseai_CreateModelRequest(arg) {
9 | if (!(arg instanceof finetuning_pb.CreateModelRequest)) {
10 | throw new Error('Expected argument of type gooseai.CreateModelRequest');
11 | }
12 | return Buffer.from(arg.serializeBinary());
13 | }
14 |
15 | function deserialize_gooseai_CreateModelRequest(buffer_arg) {
16 | return finetuning_pb.CreateModelRequest.deserializeBinary(new Uint8Array(buffer_arg));
17 | }
18 |
19 | function serialize_gooseai_CreateModelResponse(arg) {
20 | if (!(arg instanceof finetuning_pb.CreateModelResponse)) {
21 | throw new Error('Expected argument of type gooseai.CreateModelResponse');
22 | }
23 | return Buffer.from(arg.serializeBinary());
24 | }
25 |
26 | function deserialize_gooseai_CreateModelResponse(buffer_arg) {
27 | return finetuning_pb.CreateModelResponse.deserializeBinary(new Uint8Array(buffer_arg));
28 | }
29 |
30 | function serialize_gooseai_DeleteModelRequest(arg) {
31 | if (!(arg instanceof finetuning_pb.DeleteModelRequest)) {
32 | throw new Error('Expected argument of type gooseai.DeleteModelRequest');
33 | }
34 | return Buffer.from(arg.serializeBinary());
35 | }
36 |
37 | function deserialize_gooseai_DeleteModelRequest(buffer_arg) {
38 | return finetuning_pb.DeleteModelRequest.deserializeBinary(new Uint8Array(buffer_arg));
39 | }
40 |
41 | function serialize_gooseai_DeleteModelResponse(arg) {
42 | if (!(arg instanceof finetuning_pb.DeleteModelResponse)) {
43 | throw new Error('Expected argument of type gooseai.DeleteModelResponse');
44 | }
45 | return Buffer.from(arg.serializeBinary());
46 | }
47 |
48 | function deserialize_gooseai_DeleteModelResponse(buffer_arg) {
49 | return finetuning_pb.DeleteModelResponse.deserializeBinary(new Uint8Array(buffer_arg));
50 | }
51 |
52 | function serialize_gooseai_GetModelRequest(arg) {
53 | if (!(arg instanceof finetuning_pb.GetModelRequest)) {
54 | throw new Error('Expected argument of type gooseai.GetModelRequest');
55 | }
56 | return Buffer.from(arg.serializeBinary());
57 | }
58 |
59 | function deserialize_gooseai_GetModelRequest(buffer_arg) {
60 | return finetuning_pb.GetModelRequest.deserializeBinary(new Uint8Array(buffer_arg));
61 | }
62 |
63 | function serialize_gooseai_GetModelResponse(arg) {
64 | if (!(arg instanceof finetuning_pb.GetModelResponse)) {
65 | throw new Error('Expected argument of type gooseai.GetModelResponse');
66 | }
67 | return Buffer.from(arg.serializeBinary());
68 | }
69 |
70 | function deserialize_gooseai_GetModelResponse(buffer_arg) {
71 | return finetuning_pb.GetModelResponse.deserializeBinary(new Uint8Array(buffer_arg));
72 | }
73 |
74 | function serialize_gooseai_ListModelsRequest(arg) {
75 | if (!(arg instanceof finetuning_pb.ListModelsRequest)) {
76 | throw new Error('Expected argument of type gooseai.ListModelsRequest');
77 | }
78 | return Buffer.from(arg.serializeBinary());
79 | }
80 |
81 | function deserialize_gooseai_ListModelsRequest(buffer_arg) {
82 | return finetuning_pb.ListModelsRequest.deserializeBinary(new Uint8Array(buffer_arg));
83 | }
84 |
85 | function serialize_gooseai_ListModelsResponse(arg) {
86 | if (!(arg instanceof finetuning_pb.ListModelsResponse)) {
87 | throw new Error('Expected argument of type gooseai.ListModelsResponse');
88 | }
89 | return Buffer.from(arg.serializeBinary());
90 | }
91 |
92 | function deserialize_gooseai_ListModelsResponse(buffer_arg) {
93 | return finetuning_pb.ListModelsResponse.deserializeBinary(new Uint8Array(buffer_arg));
94 | }
95 |
96 | function serialize_gooseai_ResubmitModelRequest(arg) {
97 | if (!(arg instanceof finetuning_pb.ResubmitModelRequest)) {
98 | throw new Error('Expected argument of type gooseai.ResubmitModelRequest');
99 | }
100 | return Buffer.from(arg.serializeBinary());
101 | }
102 |
103 | function deserialize_gooseai_ResubmitModelRequest(buffer_arg) {
104 | return finetuning_pb.ResubmitModelRequest.deserializeBinary(new Uint8Array(buffer_arg));
105 | }
106 |
107 | function serialize_gooseai_ResubmitModelResponse(arg) {
108 | if (!(arg instanceof finetuning_pb.ResubmitModelResponse)) {
109 | throw new Error('Expected argument of type gooseai.ResubmitModelResponse');
110 | }
111 | return Buffer.from(arg.serializeBinary());
112 | }
113 |
114 | function deserialize_gooseai_ResubmitModelResponse(buffer_arg) {
115 | return finetuning_pb.ResubmitModelResponse.deserializeBinary(new Uint8Array(buffer_arg));
116 | }
117 |
118 | function serialize_gooseai_UpdateModelRequest(arg) {
119 | if (!(arg instanceof finetuning_pb.UpdateModelRequest)) {
120 | throw new Error('Expected argument of type gooseai.UpdateModelRequest');
121 | }
122 | return Buffer.from(arg.serializeBinary());
123 | }
124 |
125 | function deserialize_gooseai_UpdateModelRequest(buffer_arg) {
126 | return finetuning_pb.UpdateModelRequest.deserializeBinary(new Uint8Array(buffer_arg));
127 | }
128 |
129 | function serialize_gooseai_UpdateModelResponse(arg) {
130 | if (!(arg instanceof finetuning_pb.UpdateModelResponse)) {
131 | throw new Error('Expected argument of type gooseai.UpdateModelResponse');
132 | }
133 | return Buffer.from(arg.serializeBinary());
134 | }
135 |
136 | function deserialize_gooseai_UpdateModelResponse(buffer_arg) {
137 | return finetuning_pb.UpdateModelResponse.deserializeBinary(new Uint8Array(buffer_arg));
138 | }
139 |
140 |
141 | var FineTuningServiceService = exports.FineTuningServiceService = {
142 | // Create a new model and begin the fine tuning process
143 | createModel: {
144 | path: '/gooseai.FineTuningService/CreateModel',
145 | requestStream: false,
146 | responseStream: false,
147 | requestType: finetuning_pb.CreateModelRequest,
148 | responseType: finetuning_pb.CreateModelResponse,
149 | requestSerialize: serialize_gooseai_CreateModelRequest,
150 | requestDeserialize: deserialize_gooseai_CreateModelRequest,
151 | responseSerialize: serialize_gooseai_CreateModelResponse,
152 | responseDeserialize: deserialize_gooseai_CreateModelResponse,
153 | },
154 | // Get a FineTuningModel
155 | getModel: {
156 | path: '/gooseai.FineTuningService/GetModel',
157 | requestStream: false,
158 | responseStream: false,
159 | requestType: finetuning_pb.GetModelRequest,
160 | responseType: finetuning_pb.GetModelResponse,
161 | requestSerialize: serialize_gooseai_GetModelRequest,
162 | requestDeserialize: deserialize_gooseai_GetModelRequest,
163 | responseSerialize: serialize_gooseai_GetModelResponse,
164 | responseDeserialize: deserialize_gooseai_GetModelResponse,
165 | },
166 | // Update a FineTuningModel by id
167 | updateModel: {
168 | path: '/gooseai.FineTuningService/UpdateModel',
169 | requestStream: false,
170 | responseStream: false,
171 | requestType: finetuning_pb.UpdateModelRequest,
172 | responseType: finetuning_pb.UpdateModelResponse,
173 | requestSerialize: serialize_gooseai_UpdateModelRequest,
174 | requestDeserialize: deserialize_gooseai_UpdateModelRequest,
175 | responseSerialize: serialize_gooseai_UpdateModelResponse,
176 | responseDeserialize: deserialize_gooseai_UpdateModelResponse,
177 | },
178 | // Delete a fine tuned model
179 | deleteModel: {
180 | path: '/gooseai.FineTuningService/DeleteModel',
181 | requestStream: false,
182 | responseStream: false,
183 | requestType: finetuning_pb.DeleteModelRequest,
184 | responseType: finetuning_pb.DeleteModelResponse,
185 | requestSerialize: serialize_gooseai_DeleteModelRequest,
186 | requestDeserialize: deserialize_gooseai_DeleteModelRequest,
187 | responseSerialize: serialize_gooseai_DeleteModelResponse,
188 | responseDeserialize: deserialize_gooseai_DeleteModelResponse,
189 | },
190 | // Re-run training, does not create a new model
191 | resubmitModel: {
192 | path: '/gooseai.FineTuningService/ResubmitModel',
193 | requestStream: false,
194 | responseStream: false,
195 | requestType: finetuning_pb.ResubmitModelRequest,
196 | responseType: finetuning_pb.ResubmitModelResponse,
197 | requestSerialize: serialize_gooseai_ResubmitModelRequest,
198 | requestDeserialize: deserialize_gooseai_ResubmitModelRequest,
199 | responseSerialize: serialize_gooseai_ResubmitModelResponse,
200 | responseDeserialize: deserialize_gooseai_ResubmitModelResponse,
201 | },
202 | // List all the fine tuned models for an organization or user
203 | listModels: {
204 | path: '/gooseai.FineTuningService/ListModels',
205 | requestStream: false,
206 | responseStream: false,
207 | requestType: finetuning_pb.ListModelsRequest,
208 | responseType: finetuning_pb.ListModelsResponse,
209 | requestSerialize: serialize_gooseai_ListModelsRequest,
210 | requestDeserialize: deserialize_gooseai_ListModelsRequest,
211 | responseSerialize: serialize_gooseai_ListModelsResponse,
212 | responseDeserialize: deserialize_gooseai_ListModelsResponse,
213 | },
214 | };
215 |
216 | exports.FineTuningServiceClient = grpc.makeGenericClientConstructor(FineTuningServiceService);
217 |
--------------------------------------------------------------------------------
/gooseai/finetuning/finetuning_pb2.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | # Generated by the protocol buffer compiler. DO NOT EDIT!
3 | # source: finetuning.proto
4 | """Generated protocol buffer code."""
5 | from google.protobuf.internal import enum_type_wrapper
6 | from google.protobuf import descriptor as _descriptor
7 | from google.protobuf import descriptor_pool as _descriptor_pool
8 | from google.protobuf import message as _message
9 | from google.protobuf import reflection as _reflection
10 | from google.protobuf import symbol_database as _symbol_database
11 | # @@protoc_insertion_point(imports)
12 |
13 | _sym_db = _symbol_database.Default()
14 |
15 |
16 | from google.protobuf import struct_pb2 as google_dot_protobuf_dot_struct__pb2
17 |
18 |
19 | DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x10\x66inetuning.proto\x12\x07gooseai\x1a\x1cgoogle/protobuf/struct.proto\"\xb3\x02\n\x0f\x46ineTuningModel\x12\n\n\x02id\x18\x01 \x01(\t\x12\x0f\n\x07user_id\x18\x02 \x01(\t\x12\x0c\n\x04name\x18\x03 \x01(\t\x12*\n\x04mode\x18\x04 \x01(\x0e\x32\x17.gooseai.FineTuningModeH\x00\x88\x01\x01\x12\x1a\n\robject_prompt\x18\x05 \x01(\tH\x01\x88\x01\x01\x12\x12\n\nproject_id\x18\x06 \x01(\t\x12\x10\n\x08\x64uration\x18\x07 \x01(\x01\x12)\n\x06status\x18\x08 \x01(\x0e\x32\x19.gooseai.FineTuningStatus\x12\x11\n\tengine_id\x18\t \x01(\t\x12\x1b\n\x0e\x66\x61ilure_reason\x18\n \x01(\tH\x02\x88\x01\x01\x42\x07\n\x05_modeB\x10\n\x0e_object_promptB\x11\n\x0f_failure_reason\"\xe6\x01\n\x12\x43reateModelRequest\x12\x0c\n\x04name\x18\x01 \x01(\t\x12*\n\x04mode\x18\x02 \x01(\x0e\x32\x17.gooseai.FineTuningModeH\x00\x88\x01\x01\x12\x1a\n\robject_prompt\x18\x03 \x01(\tH\x01\x88\x01\x01\x12\x12\n\nproject_id\x18\x04 \x01(\t\x12\x11\n\tengine_id\x18\x05 \x01(\t\x12-\n\x06\x65xtras\x18\xff\x0f \x01(\x0b\x32\x17.google.protobuf.StructH\x02\x88\x01\x01\x42\x07\n\x05_modeB\x10\n\x0e_object_promptB\t\n\x07_extras\">\n\x13\x43reateModelResponse\x12\'\n\x05model\x18\x01 \x01(\x0b\x32\x18.gooseai.FineTuningModel\"\x1d\n\x0fGetModelRequest\x12\n\n\x02id\x18\x01 \x01(\t\";\n\x10GetModelResponse\x12\'\n\x05model\x18\x01 \x01(\x0b\x32\x18.gooseai.FineTuningModel\"\xc5\x01\n\x12UpdateModelRequest\x12\n\n\x02id\x18\x01 \x01(\t\x12\x11\n\x04name\x18\x02 \x01(\tH\x00\x88\x01\x01\x12*\n\x04mode\x18\x03 \x01(\x0e\x32\x17.gooseai.FineTuningModeH\x01\x88\x01\x01\x12\x1a\n\robject_prompt\x18\x04 \x01(\tH\x02\x88\x01\x01\x12\x16\n\tengine_id\x18\x05 \x01(\tH\x03\x88\x01\x01\x42\x07\n\x05_nameB\x07\n\x05_modeB\x10\n\x0e_object_promptB\x0c\n\n_engine_id\">\n\x13UpdateModelResponse\x12\'\n\x05model\x18\x01 \x01(\x0b\x32\x18.gooseai.FineTuningModel\" \n\x12\x44\x65leteModelRequest\x12\n\n\x02id\x18\x01 \x01(\t\">\n\x13\x44\x65leteModelResponse\x12\'\n\x05model\x18\x01 \x01(\x0b\x32\x18.gooseai.FineTuningModel\"\"\n\x14ResubmitModelRequest\x12\n\n\x02id\x18\x01 \x01(\t\"@\n\x15ResubmitModelResponse\x12\'\n\x05model\x18\x01 \x01(\x0b\x32\x18.gooseai.FineTuningModel\">\n\x11ListModelsRequest\x12\x10\n\x06org_id\x18\x01 \x01(\tH\x00\x12\x11\n\x07user_id\x18\x02 \x01(\tH\x00\x42\x04\n\x02id\">\n\x12ListModelsResponse\x12(\n\x06models\x18\x01 \x03(\x0b\x32\x18.gooseai.FineTuningModel*\x86\x01\n\x0e\x46ineTuningMode\x12 \n\x1c\x46INE_TUNING_MODE_UNSPECIFIED\x10\x00\x12\x19\n\x15\x46INE_TUNING_MODE_FACE\x10\x01\x12\x1a\n\x16\x46INE_TUNING_MODE_STYLE\x10\x02\x12\x1b\n\x17\x46INE_TUNING_MODE_OBJECT\x10\x03*\xb9\x01\n\x10\x46ineTuningStatus\x12\"\n\x1e\x46INE_TUNING_STATUS_NOT_STARTED\x10\x00\x12\x1e\n\x1a\x46INE_TUNING_STATUS_RUNNING\x10\x01\x12 \n\x1c\x46INE_TUNING_STATUS_COMPLETED\x10\x02\x12\x1d\n\x19\x46INE_TUNING_STATUS_FAILED\x10\x03\x12 \n\x1c\x46INE_TUNING_STATUS_SUBMITTED\x10\x04\x32\xc9\x03\n\x11\x46ineTuningService\x12H\n\x0b\x43reateModel\x12\x1b.gooseai.CreateModelRequest\x1a\x1c.gooseai.CreateModelResponse\x12?\n\x08GetModel\x12\x18.gooseai.GetModelRequest\x1a\x19.gooseai.GetModelResponse\x12H\n\x0bUpdateModel\x12\x1b.gooseai.UpdateModelRequest\x1a\x1c.gooseai.UpdateModelResponse\x12H\n\x0b\x44\x65leteModel\x12\x1b.gooseai.DeleteModelRequest\x1a\x1c.gooseai.DeleteModelResponse\x12N\n\rResubmitModel\x12\x1d.gooseai.ResubmitModelRequest\x1a\x1e.gooseai.ResubmitModelResponse\x12\x45\n\nListModels\x12\x1a.gooseai.ListModelsRequest\x1a\x1b.gooseai.ListModelsResponseB;Z9github.com/stability-ai/api-interfaces/gooseai/finetuningb\x06proto3')
20 |
21 | _FINETUNINGMODE = DESCRIPTOR.enum_types_by_name['FineTuningMode']
22 | FineTuningMode = enum_type_wrapper.EnumTypeWrapper(_FINETUNINGMODE)
23 | _FINETUNINGSTATUS = DESCRIPTOR.enum_types_by_name['FineTuningStatus']
24 | FineTuningStatus = enum_type_wrapper.EnumTypeWrapper(_FINETUNINGSTATUS)
25 | FINE_TUNING_MODE_UNSPECIFIED = 0
26 | FINE_TUNING_MODE_FACE = 1
27 | FINE_TUNING_MODE_STYLE = 2
28 | FINE_TUNING_MODE_OBJECT = 3
29 | FINE_TUNING_STATUS_NOT_STARTED = 0
30 | FINE_TUNING_STATUS_RUNNING = 1
31 | FINE_TUNING_STATUS_COMPLETED = 2
32 | FINE_TUNING_STATUS_FAILED = 3
33 | FINE_TUNING_STATUS_SUBMITTED = 4
34 |
35 |
36 | _FINETUNINGMODEL = DESCRIPTOR.message_types_by_name['FineTuningModel']
37 | _CREATEMODELREQUEST = DESCRIPTOR.message_types_by_name['CreateModelRequest']
38 | _CREATEMODELRESPONSE = DESCRIPTOR.message_types_by_name['CreateModelResponse']
39 | _GETMODELREQUEST = DESCRIPTOR.message_types_by_name['GetModelRequest']
40 | _GETMODELRESPONSE = DESCRIPTOR.message_types_by_name['GetModelResponse']
41 | _UPDATEMODELREQUEST = DESCRIPTOR.message_types_by_name['UpdateModelRequest']
42 | _UPDATEMODELRESPONSE = DESCRIPTOR.message_types_by_name['UpdateModelResponse']
43 | _DELETEMODELREQUEST = DESCRIPTOR.message_types_by_name['DeleteModelRequest']
44 | _DELETEMODELRESPONSE = DESCRIPTOR.message_types_by_name['DeleteModelResponse']
45 | _RESUBMITMODELREQUEST = DESCRIPTOR.message_types_by_name['ResubmitModelRequest']
46 | _RESUBMITMODELRESPONSE = DESCRIPTOR.message_types_by_name['ResubmitModelResponse']
47 | _LISTMODELSREQUEST = DESCRIPTOR.message_types_by_name['ListModelsRequest']
48 | _LISTMODELSRESPONSE = DESCRIPTOR.message_types_by_name['ListModelsResponse']
49 | FineTuningModel = _reflection.GeneratedProtocolMessageType('FineTuningModel', (_message.Message,), {
50 | 'DESCRIPTOR' : _FINETUNINGMODEL,
51 | '__module__' : 'finetuning_pb2'
52 | # @@protoc_insertion_point(class_scope:gooseai.FineTuningModel)
53 | })
54 | _sym_db.RegisterMessage(FineTuningModel)
55 |
56 | CreateModelRequest = _reflection.GeneratedProtocolMessageType('CreateModelRequest', (_message.Message,), {
57 | 'DESCRIPTOR' : _CREATEMODELREQUEST,
58 | '__module__' : 'finetuning_pb2'
59 | # @@protoc_insertion_point(class_scope:gooseai.CreateModelRequest)
60 | })
61 | _sym_db.RegisterMessage(CreateModelRequest)
62 |
63 | CreateModelResponse = _reflection.GeneratedProtocolMessageType('CreateModelResponse', (_message.Message,), {
64 | 'DESCRIPTOR' : _CREATEMODELRESPONSE,
65 | '__module__' : 'finetuning_pb2'
66 | # @@protoc_insertion_point(class_scope:gooseai.CreateModelResponse)
67 | })
68 | _sym_db.RegisterMessage(CreateModelResponse)
69 |
70 | GetModelRequest = _reflection.GeneratedProtocolMessageType('GetModelRequest', (_message.Message,), {
71 | 'DESCRIPTOR' : _GETMODELREQUEST,
72 | '__module__' : 'finetuning_pb2'
73 | # @@protoc_insertion_point(class_scope:gooseai.GetModelRequest)
74 | })
75 | _sym_db.RegisterMessage(GetModelRequest)
76 |
77 | GetModelResponse = _reflection.GeneratedProtocolMessageType('GetModelResponse', (_message.Message,), {
78 | 'DESCRIPTOR' : _GETMODELRESPONSE,
79 | '__module__' : 'finetuning_pb2'
80 | # @@protoc_insertion_point(class_scope:gooseai.GetModelResponse)
81 | })
82 | _sym_db.RegisterMessage(GetModelResponse)
83 |
84 | UpdateModelRequest = _reflection.GeneratedProtocolMessageType('UpdateModelRequest', (_message.Message,), {
85 | 'DESCRIPTOR' : _UPDATEMODELREQUEST,
86 | '__module__' : 'finetuning_pb2'
87 | # @@protoc_insertion_point(class_scope:gooseai.UpdateModelRequest)
88 | })
89 | _sym_db.RegisterMessage(UpdateModelRequest)
90 |
91 | UpdateModelResponse = _reflection.GeneratedProtocolMessageType('UpdateModelResponse', (_message.Message,), {
92 | 'DESCRIPTOR' : _UPDATEMODELRESPONSE,
93 | '__module__' : 'finetuning_pb2'
94 | # @@protoc_insertion_point(class_scope:gooseai.UpdateModelResponse)
95 | })
96 | _sym_db.RegisterMessage(UpdateModelResponse)
97 |
98 | DeleteModelRequest = _reflection.GeneratedProtocolMessageType('DeleteModelRequest', (_message.Message,), {
99 | 'DESCRIPTOR' : _DELETEMODELREQUEST,
100 | '__module__' : 'finetuning_pb2'
101 | # @@protoc_insertion_point(class_scope:gooseai.DeleteModelRequest)
102 | })
103 | _sym_db.RegisterMessage(DeleteModelRequest)
104 |
105 | DeleteModelResponse = _reflection.GeneratedProtocolMessageType('DeleteModelResponse', (_message.Message,), {
106 | 'DESCRIPTOR' : _DELETEMODELRESPONSE,
107 | '__module__' : 'finetuning_pb2'
108 | # @@protoc_insertion_point(class_scope:gooseai.DeleteModelResponse)
109 | })
110 | _sym_db.RegisterMessage(DeleteModelResponse)
111 |
112 | ResubmitModelRequest = _reflection.GeneratedProtocolMessageType('ResubmitModelRequest', (_message.Message,), {
113 | 'DESCRIPTOR' : _RESUBMITMODELREQUEST,
114 | '__module__' : 'finetuning_pb2'
115 | # @@protoc_insertion_point(class_scope:gooseai.ResubmitModelRequest)
116 | })
117 | _sym_db.RegisterMessage(ResubmitModelRequest)
118 |
119 | ResubmitModelResponse = _reflection.GeneratedProtocolMessageType('ResubmitModelResponse', (_message.Message,), {
120 | 'DESCRIPTOR' : _RESUBMITMODELRESPONSE,
121 | '__module__' : 'finetuning_pb2'
122 | # @@protoc_insertion_point(class_scope:gooseai.ResubmitModelResponse)
123 | })
124 | _sym_db.RegisterMessage(ResubmitModelResponse)
125 |
126 | ListModelsRequest = _reflection.GeneratedProtocolMessageType('ListModelsRequest', (_message.Message,), {
127 | 'DESCRIPTOR' : _LISTMODELSREQUEST,
128 | '__module__' : 'finetuning_pb2'
129 | # @@protoc_insertion_point(class_scope:gooseai.ListModelsRequest)
130 | })
131 | _sym_db.RegisterMessage(ListModelsRequest)
132 |
133 | ListModelsResponse = _reflection.GeneratedProtocolMessageType('ListModelsResponse', (_message.Message,), {
134 | 'DESCRIPTOR' : _LISTMODELSRESPONSE,
135 | '__module__' : 'finetuning_pb2'
136 | # @@protoc_insertion_point(class_scope:gooseai.ListModelsResponse)
137 | })
138 | _sym_db.RegisterMessage(ListModelsResponse)
139 |
140 | _FINETUNINGSERVICE = DESCRIPTOR.services_by_name['FineTuningService']
141 | if _descriptor._USE_C_DESCRIPTORS == False:
142 |
143 | DESCRIPTOR._options = None
144 | DESCRIPTOR._serialized_options = b'Z9github.com/stability-ai/api-interfaces/gooseai/finetuning'
145 | _FINETUNINGMODE._serialized_start=1351
146 | _FINETUNINGMODE._serialized_end=1485
147 | _FINETUNINGSTATUS._serialized_start=1488
148 | _FINETUNINGSTATUS._serialized_end=1673
149 | _FINETUNINGMODEL._serialized_start=60
150 | _FINETUNINGMODEL._serialized_end=367
151 | _CREATEMODELREQUEST._serialized_start=370
152 | _CREATEMODELREQUEST._serialized_end=600
153 | _CREATEMODELRESPONSE._serialized_start=602
154 | _CREATEMODELRESPONSE._serialized_end=664
155 | _GETMODELREQUEST._serialized_start=666
156 | _GETMODELREQUEST._serialized_end=695
157 | _GETMODELRESPONSE._serialized_start=697
158 | _GETMODELRESPONSE._serialized_end=756
159 | _UPDATEMODELREQUEST._serialized_start=759
160 | _UPDATEMODELREQUEST._serialized_end=956
161 | _UPDATEMODELRESPONSE._serialized_start=958
162 | _UPDATEMODELRESPONSE._serialized_end=1020
163 | _DELETEMODELREQUEST._serialized_start=1022
164 | _DELETEMODELREQUEST._serialized_end=1054
165 | _DELETEMODELRESPONSE._serialized_start=1056
166 | _DELETEMODELRESPONSE._serialized_end=1118
167 | _RESUBMITMODELREQUEST._serialized_start=1120
168 | _RESUBMITMODELREQUEST._serialized_end=1154
169 | _RESUBMITMODELRESPONSE._serialized_start=1156
170 | _RESUBMITMODELRESPONSE._serialized_end=1220
171 | _LISTMODELSREQUEST._serialized_start=1222
172 | _LISTMODELSREQUEST._serialized_end=1284
173 | _LISTMODELSRESPONSE._serialized_start=1286
174 | _LISTMODELSRESPONSE._serialized_end=1348
175 | _FINETUNINGSERVICE._serialized_start=1676
176 | _FINETUNINGSERVICE._serialized_end=2133
177 | # @@protoc_insertion_point(module_scope)
178 |
--------------------------------------------------------------------------------
/gooseai/finetuning/finetuning_pb2_grpc.py:
--------------------------------------------------------------------------------
1 | # Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
2 | """Client and server classes corresponding to protobuf-defined services."""
3 | import grpc
4 |
5 | import finetuning_pb2 as finetuning__pb2
6 |
7 |
8 | class FineTuningServiceStub(object):
9 | """Missing associated documentation comment in .proto file."""
10 |
11 | def __init__(self, channel):
12 | """Constructor.
13 |
14 | Args:
15 | channel: A grpc.Channel.
16 | """
17 | self.CreateModel = channel.unary_unary(
18 | '/gooseai.FineTuningService/CreateModel',
19 | request_serializer=finetuning__pb2.CreateModelRequest.SerializeToString,
20 | response_deserializer=finetuning__pb2.CreateModelResponse.FromString,
21 | )
22 | self.GetModel = channel.unary_unary(
23 | '/gooseai.FineTuningService/GetModel',
24 | request_serializer=finetuning__pb2.GetModelRequest.SerializeToString,
25 | response_deserializer=finetuning__pb2.GetModelResponse.FromString,
26 | )
27 | self.UpdateModel = channel.unary_unary(
28 | '/gooseai.FineTuningService/UpdateModel',
29 | request_serializer=finetuning__pb2.UpdateModelRequest.SerializeToString,
30 | response_deserializer=finetuning__pb2.UpdateModelResponse.FromString,
31 | )
32 | self.DeleteModel = channel.unary_unary(
33 | '/gooseai.FineTuningService/DeleteModel',
34 | request_serializer=finetuning__pb2.DeleteModelRequest.SerializeToString,
35 | response_deserializer=finetuning__pb2.DeleteModelResponse.FromString,
36 | )
37 | self.ResubmitModel = channel.unary_unary(
38 | '/gooseai.FineTuningService/ResubmitModel',
39 | request_serializer=finetuning__pb2.ResubmitModelRequest.SerializeToString,
40 | response_deserializer=finetuning__pb2.ResubmitModelResponse.FromString,
41 | )
42 | self.ListModels = channel.unary_unary(
43 | '/gooseai.FineTuningService/ListModels',
44 | request_serializer=finetuning__pb2.ListModelsRequest.SerializeToString,
45 | response_deserializer=finetuning__pb2.ListModelsResponse.FromString,
46 | )
47 |
48 |
49 | class FineTuningServiceServicer(object):
50 | """Missing associated documentation comment in .proto file."""
51 |
52 | def CreateModel(self, request, context):
53 | """Create a new model and begin the fine tuning process
54 | """
55 | context.set_code(grpc.StatusCode.UNIMPLEMENTED)
56 | context.set_details('Method not implemented!')
57 | raise NotImplementedError('Method not implemented!')
58 |
59 | def GetModel(self, request, context):
60 | """Get a FineTuningModel
61 | """
62 | context.set_code(grpc.StatusCode.UNIMPLEMENTED)
63 | context.set_details('Method not implemented!')
64 | raise NotImplementedError('Method not implemented!')
65 |
66 | def UpdateModel(self, request, context):
67 | """Update a FineTuningModel by id
68 | """
69 | context.set_code(grpc.StatusCode.UNIMPLEMENTED)
70 | context.set_details('Method not implemented!')
71 | raise NotImplementedError('Method not implemented!')
72 |
73 | def DeleteModel(self, request, context):
74 | """Delete a fine tuned model
75 | """
76 | context.set_code(grpc.StatusCode.UNIMPLEMENTED)
77 | context.set_details('Method not implemented!')
78 | raise NotImplementedError('Method not implemented!')
79 |
80 | def ResubmitModel(self, request, context):
81 | """Re-run training, does not create a new model
82 | """
83 | context.set_code(grpc.StatusCode.UNIMPLEMENTED)
84 | context.set_details('Method not implemented!')
85 | raise NotImplementedError('Method not implemented!')
86 |
87 | def ListModels(self, request, context):
88 | """List all the fine tuned models for an organization or user
89 | """
90 | context.set_code(grpc.StatusCode.UNIMPLEMENTED)
91 | context.set_details('Method not implemented!')
92 | raise NotImplementedError('Method not implemented!')
93 |
94 |
95 | def add_FineTuningServiceServicer_to_server(servicer, server):
96 | rpc_method_handlers = {
97 | 'CreateModel': grpc.unary_unary_rpc_method_handler(
98 | servicer.CreateModel,
99 | request_deserializer=finetuning__pb2.CreateModelRequest.FromString,
100 | response_serializer=finetuning__pb2.CreateModelResponse.SerializeToString,
101 | ),
102 | 'GetModel': grpc.unary_unary_rpc_method_handler(
103 | servicer.GetModel,
104 | request_deserializer=finetuning__pb2.GetModelRequest.FromString,
105 | response_serializer=finetuning__pb2.GetModelResponse.SerializeToString,
106 | ),
107 | 'UpdateModel': grpc.unary_unary_rpc_method_handler(
108 | servicer.UpdateModel,
109 | request_deserializer=finetuning__pb2.UpdateModelRequest.FromString,
110 | response_serializer=finetuning__pb2.UpdateModelResponse.SerializeToString,
111 | ),
112 | 'DeleteModel': grpc.unary_unary_rpc_method_handler(
113 | servicer.DeleteModel,
114 | request_deserializer=finetuning__pb2.DeleteModelRequest.FromString,
115 | response_serializer=finetuning__pb2.DeleteModelResponse.SerializeToString,
116 | ),
117 | 'ResubmitModel': grpc.unary_unary_rpc_method_handler(
118 | servicer.ResubmitModel,
119 | request_deserializer=finetuning__pb2.ResubmitModelRequest.FromString,
120 | response_serializer=finetuning__pb2.ResubmitModelResponse.SerializeToString,
121 | ),
122 | 'ListModels': grpc.unary_unary_rpc_method_handler(
123 | servicer.ListModels,
124 | request_deserializer=finetuning__pb2.ListModelsRequest.FromString,
125 | response_serializer=finetuning__pb2.ListModelsResponse.SerializeToString,
126 | ),
127 | }
128 | generic_handler = grpc.method_handlers_generic_handler(
129 | 'gooseai.FineTuningService', rpc_method_handlers)
130 | server.add_generic_rpc_handlers((generic_handler,))
131 |
132 |
133 | # This class is part of an EXPERIMENTAL API.
134 | class FineTuningService(object):
135 | """Missing associated documentation comment in .proto file."""
136 |
137 | @staticmethod
138 | def CreateModel(request,
139 | target,
140 | options=(),
141 | channel_credentials=None,
142 | call_credentials=None,
143 | insecure=False,
144 | compression=None,
145 | wait_for_ready=None,
146 | timeout=None,
147 | metadata=None):
148 | return grpc.experimental.unary_unary(request, target, '/gooseai.FineTuningService/CreateModel',
149 | finetuning__pb2.CreateModelRequest.SerializeToString,
150 | finetuning__pb2.CreateModelResponse.FromString,
151 | options, channel_credentials,
152 | insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
153 |
154 | @staticmethod
155 | def GetModel(request,
156 | target,
157 | options=(),
158 | channel_credentials=None,
159 | call_credentials=None,
160 | insecure=False,
161 | compression=None,
162 | wait_for_ready=None,
163 | timeout=None,
164 | metadata=None):
165 | return grpc.experimental.unary_unary(request, target, '/gooseai.FineTuningService/GetModel',
166 | finetuning__pb2.GetModelRequest.SerializeToString,
167 | finetuning__pb2.GetModelResponse.FromString,
168 | options, channel_credentials,
169 | insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
170 |
171 | @staticmethod
172 | def UpdateModel(request,
173 | target,
174 | options=(),
175 | channel_credentials=None,
176 | call_credentials=None,
177 | insecure=False,
178 | compression=None,
179 | wait_for_ready=None,
180 | timeout=None,
181 | metadata=None):
182 | return grpc.experimental.unary_unary(request, target, '/gooseai.FineTuningService/UpdateModel',
183 | finetuning__pb2.UpdateModelRequest.SerializeToString,
184 | finetuning__pb2.UpdateModelResponse.FromString,
185 | options, channel_credentials,
186 | insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
187 |
188 | @staticmethod
189 | def DeleteModel(request,
190 | target,
191 | options=(),
192 | channel_credentials=None,
193 | call_credentials=None,
194 | insecure=False,
195 | compression=None,
196 | wait_for_ready=None,
197 | timeout=None,
198 | metadata=None):
199 | return grpc.experimental.unary_unary(request, target, '/gooseai.FineTuningService/DeleteModel',
200 | finetuning__pb2.DeleteModelRequest.SerializeToString,
201 | finetuning__pb2.DeleteModelResponse.FromString,
202 | options, channel_credentials,
203 | insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
204 |
205 | @staticmethod
206 | def ResubmitModel(request,
207 | target,
208 | options=(),
209 | channel_credentials=None,
210 | call_credentials=None,
211 | insecure=False,
212 | compression=None,
213 | wait_for_ready=None,
214 | timeout=None,
215 | metadata=None):
216 | return grpc.experimental.unary_unary(request, target, '/gooseai.FineTuningService/ResubmitModel',
217 | finetuning__pb2.ResubmitModelRequest.SerializeToString,
218 | finetuning__pb2.ResubmitModelResponse.FromString,
219 | options, channel_credentials,
220 | insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
221 |
222 | @staticmethod
223 | def ListModels(request,
224 | target,
225 | options=(),
226 | channel_credentials=None,
227 | call_credentials=None,
228 | insecure=False,
229 | compression=None,
230 | wait_for_ready=None,
231 | timeout=None,
232 | metadata=None):
233 | return grpc.experimental.unary_unary(request, target, '/gooseai.FineTuningService/ListModels',
234 | finetuning__pb2.ListModelsRequest.SerializeToString,
235 | finetuning__pb2.ListModelsResponse.FromString,
236 | options, channel_credentials,
237 | insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
238 |
--------------------------------------------------------------------------------
/gooseai/finetuning/finetuning_pb_service.d.ts:
--------------------------------------------------------------------------------
1 | // package: gooseai
2 | // file: finetuning.proto
3 |
4 | import * as finetuning_pb from "./finetuning_pb";
5 | import {grpc} from "@improbable-eng/grpc-web";
6 |
7 | type FineTuningServiceCreateModel = {
8 | readonly methodName: string;
9 | readonly service: typeof FineTuningService;
10 | readonly requestStream: false;
11 | readonly responseStream: false;
12 | readonly requestType: typeof finetuning_pb.CreateModelRequest;
13 | readonly responseType: typeof finetuning_pb.CreateModelResponse;
14 | };
15 |
16 | type FineTuningServiceGetModel = {
17 | readonly methodName: string;
18 | readonly service: typeof FineTuningService;
19 | readonly requestStream: false;
20 | readonly responseStream: false;
21 | readonly requestType: typeof finetuning_pb.GetModelRequest;
22 | readonly responseType: typeof finetuning_pb.GetModelResponse;
23 | };
24 |
25 | type FineTuningServiceUpdateModel = {
26 | readonly methodName: string;
27 | readonly service: typeof FineTuningService;
28 | readonly requestStream: false;
29 | readonly responseStream: false;
30 | readonly requestType: typeof finetuning_pb.UpdateModelRequest;
31 | readonly responseType: typeof finetuning_pb.UpdateModelResponse;
32 | };
33 |
34 | type FineTuningServiceDeleteModel = {
35 | readonly methodName: string;
36 | readonly service: typeof FineTuningService;
37 | readonly requestStream: false;
38 | readonly responseStream: false;
39 | readonly requestType: typeof finetuning_pb.DeleteModelRequest;
40 | readonly responseType: typeof finetuning_pb.DeleteModelResponse;
41 | };
42 |
43 | type FineTuningServiceResubmitModel = {
44 | readonly methodName: string;
45 | readonly service: typeof FineTuningService;
46 | readonly requestStream: false;
47 | readonly responseStream: false;
48 | readonly requestType: typeof finetuning_pb.ResubmitModelRequest;
49 | readonly responseType: typeof finetuning_pb.ResubmitModelResponse;
50 | };
51 |
52 | type FineTuningServiceListModels = {
53 | readonly methodName: string;
54 | readonly service: typeof FineTuningService;
55 | readonly requestStream: false;
56 | readonly responseStream: false;
57 | readonly requestType: typeof finetuning_pb.ListModelsRequest;
58 | readonly responseType: typeof finetuning_pb.ListModelsResponse;
59 | };
60 |
61 | export class FineTuningService {
62 | static readonly serviceName: string;
63 | static readonly CreateModel: FineTuningServiceCreateModel;
64 | static readonly GetModel: FineTuningServiceGetModel;
65 | static readonly UpdateModel: FineTuningServiceUpdateModel;
66 | static readonly DeleteModel: FineTuningServiceDeleteModel;
67 | static readonly ResubmitModel: FineTuningServiceResubmitModel;
68 | static readonly ListModels: FineTuningServiceListModels;
69 | }
70 |
71 | export type ServiceError = { message: string, code: number; metadata: grpc.Metadata }
72 | export type Status = { details: string, code: number; metadata: grpc.Metadata }
73 |
74 | interface UnaryResponse {
75 | cancel(): void;
76 | }
77 | interface ResponseStream {
78 | cancel(): void;
79 | on(type: 'data', handler: (message: T) => void): ResponseStream;
80 | on(type: 'end', handler: (status?: Status) => void): ResponseStream;
81 | on(type: 'status', handler: (status: Status) => void): ResponseStream;
82 | }
83 | interface RequestStream {
84 | write(message: T): RequestStream;
85 | end(): void;
86 | cancel(): void;
87 | on(type: 'end', handler: (status?: Status) => void): RequestStream;
88 | on(type: 'status', handler: (status: Status) => void): RequestStream;
89 | }
90 | interface BidirectionalStream {
91 | write(message: ReqT): BidirectionalStream;
92 | end(): void;
93 | cancel(): void;
94 | on(type: 'data', handler: (message: ResT) => void): BidirectionalStream;
95 | on(type: 'end', handler: (status?: Status) => void): BidirectionalStream;
96 | on(type: 'status', handler: (status: Status) => void): BidirectionalStream;
97 | }
98 |
99 | export class FineTuningServiceClient {
100 | readonly serviceHost: string;
101 |
102 | constructor(serviceHost: string, options?: grpc.RpcOptions);
103 | createModel(
104 | requestMessage: finetuning_pb.CreateModelRequest,
105 | metadata: grpc.Metadata,
106 | callback: (error: ServiceError|null, responseMessage: finetuning_pb.CreateModelResponse|null) => void
107 | ): UnaryResponse;
108 | createModel(
109 | requestMessage: finetuning_pb.CreateModelRequest,
110 | callback: (error: ServiceError|null, responseMessage: finetuning_pb.CreateModelResponse|null) => void
111 | ): UnaryResponse;
112 | getModel(
113 | requestMessage: finetuning_pb.GetModelRequest,
114 | metadata: grpc.Metadata,
115 | callback: (error: ServiceError|null, responseMessage: finetuning_pb.GetModelResponse|null) => void
116 | ): UnaryResponse;
117 | getModel(
118 | requestMessage: finetuning_pb.GetModelRequest,
119 | callback: (error: ServiceError|null, responseMessage: finetuning_pb.GetModelResponse|null) => void
120 | ): UnaryResponse;
121 | updateModel(
122 | requestMessage: finetuning_pb.UpdateModelRequest,
123 | metadata: grpc.Metadata,
124 | callback: (error: ServiceError|null, responseMessage: finetuning_pb.UpdateModelResponse|null) => void
125 | ): UnaryResponse;
126 | updateModel(
127 | requestMessage: finetuning_pb.UpdateModelRequest,
128 | callback: (error: ServiceError|null, responseMessage: finetuning_pb.UpdateModelResponse|null) => void
129 | ): UnaryResponse;
130 | deleteModel(
131 | requestMessage: finetuning_pb.DeleteModelRequest,
132 | metadata: grpc.Metadata,
133 | callback: (error: ServiceError|null, responseMessage: finetuning_pb.DeleteModelResponse|null) => void
134 | ): UnaryResponse;
135 | deleteModel(
136 | requestMessage: finetuning_pb.DeleteModelRequest,
137 | callback: (error: ServiceError|null, responseMessage: finetuning_pb.DeleteModelResponse|null) => void
138 | ): UnaryResponse;
139 | resubmitModel(
140 | requestMessage: finetuning_pb.ResubmitModelRequest,
141 | metadata: grpc.Metadata,
142 | callback: (error: ServiceError|null, responseMessage: finetuning_pb.ResubmitModelResponse|null) => void
143 | ): UnaryResponse;
144 | resubmitModel(
145 | requestMessage: finetuning_pb.ResubmitModelRequest,
146 | callback: (error: ServiceError|null, responseMessage: finetuning_pb.ResubmitModelResponse|null) => void
147 | ): UnaryResponse;
148 | listModels(
149 | requestMessage: finetuning_pb.ListModelsRequest,
150 | metadata: grpc.Metadata,
151 | callback: (error: ServiceError|null, responseMessage: finetuning_pb.ListModelsResponse|null) => void
152 | ): UnaryResponse;
153 | listModels(
154 | requestMessage: finetuning_pb.ListModelsRequest,
155 | callback: (error: ServiceError|null, responseMessage: finetuning_pb.ListModelsResponse|null) => void
156 | ): UnaryResponse;
157 | }
158 |
159 |
--------------------------------------------------------------------------------
/gooseai/finetuning/finetuning_pb_service.js:
--------------------------------------------------------------------------------
1 | // package: gooseai
2 | // file: finetuning.proto
3 |
4 | var finetuning_pb = require("./finetuning_pb");
5 | var grpc = require("@improbable-eng/grpc-web").grpc;
6 |
7 | var FineTuningService = (function () {
8 | function FineTuningService() {}
9 | FineTuningService.serviceName = "gooseai.FineTuningService";
10 | return FineTuningService;
11 | }());
12 |
13 | FineTuningService.CreateModel = {
14 | methodName: "CreateModel",
15 | service: FineTuningService,
16 | requestStream: false,
17 | responseStream: false,
18 | requestType: finetuning_pb.CreateModelRequest,
19 | responseType: finetuning_pb.CreateModelResponse
20 | };
21 |
22 | FineTuningService.GetModel = {
23 | methodName: "GetModel",
24 | service: FineTuningService,
25 | requestStream: false,
26 | responseStream: false,
27 | requestType: finetuning_pb.GetModelRequest,
28 | responseType: finetuning_pb.GetModelResponse
29 | };
30 |
31 | FineTuningService.UpdateModel = {
32 | methodName: "UpdateModel",
33 | service: FineTuningService,
34 | requestStream: false,
35 | responseStream: false,
36 | requestType: finetuning_pb.UpdateModelRequest,
37 | responseType: finetuning_pb.UpdateModelResponse
38 | };
39 |
40 | FineTuningService.DeleteModel = {
41 | methodName: "DeleteModel",
42 | service: FineTuningService,
43 | requestStream: false,
44 | responseStream: false,
45 | requestType: finetuning_pb.DeleteModelRequest,
46 | responseType: finetuning_pb.DeleteModelResponse
47 | };
48 |
49 | FineTuningService.ResubmitModel = {
50 | methodName: "ResubmitModel",
51 | service: FineTuningService,
52 | requestStream: false,
53 | responseStream: false,
54 | requestType: finetuning_pb.ResubmitModelRequest,
55 | responseType: finetuning_pb.ResubmitModelResponse
56 | };
57 |
58 | FineTuningService.ListModels = {
59 | methodName: "ListModels",
60 | service: FineTuningService,
61 | requestStream: false,
62 | responseStream: false,
63 | requestType: finetuning_pb.ListModelsRequest,
64 | responseType: finetuning_pb.ListModelsResponse
65 | };
66 |
67 | exports.FineTuningService = FineTuningService;
68 |
69 | function FineTuningServiceClient(serviceHost, options) {
70 | this.serviceHost = serviceHost;
71 | this.options = options || {};
72 | }
73 |
74 | FineTuningServiceClient.prototype.createModel = function createModel(requestMessage, metadata, callback) {
75 | if (arguments.length === 2) {
76 | callback = arguments[1];
77 | }
78 | var client = grpc.unary(FineTuningService.CreateModel, {
79 | request: requestMessage,
80 | host: this.serviceHost,
81 | metadata: metadata,
82 | transport: this.options.transport,
83 | debug: this.options.debug,
84 | onEnd: function (response) {
85 | if (callback) {
86 | if (response.status !== grpc.Code.OK) {
87 | var err = new Error(response.statusMessage);
88 | err.code = response.status;
89 | err.metadata = response.trailers;
90 | callback(err, null);
91 | } else {
92 | callback(null, response.message);
93 | }
94 | }
95 | }
96 | });
97 | return {
98 | cancel: function () {
99 | callback = null;
100 | client.close();
101 | }
102 | };
103 | };
104 |
105 | FineTuningServiceClient.prototype.getModel = function getModel(requestMessage, metadata, callback) {
106 | if (arguments.length === 2) {
107 | callback = arguments[1];
108 | }
109 | var client = grpc.unary(FineTuningService.GetModel, {
110 | request: requestMessage,
111 | host: this.serviceHost,
112 | metadata: metadata,
113 | transport: this.options.transport,
114 | debug: this.options.debug,
115 | onEnd: function (response) {
116 | if (callback) {
117 | if (response.status !== grpc.Code.OK) {
118 | var err = new Error(response.statusMessage);
119 | err.code = response.status;
120 | err.metadata = response.trailers;
121 | callback(err, null);
122 | } else {
123 | callback(null, response.message);
124 | }
125 | }
126 | }
127 | });
128 | return {
129 | cancel: function () {
130 | callback = null;
131 | client.close();
132 | }
133 | };
134 | };
135 |
136 | FineTuningServiceClient.prototype.updateModel = function updateModel(requestMessage, metadata, callback) {
137 | if (arguments.length === 2) {
138 | callback = arguments[1];
139 | }
140 | var client = grpc.unary(FineTuningService.UpdateModel, {
141 | request: requestMessage,
142 | host: this.serviceHost,
143 | metadata: metadata,
144 | transport: this.options.transport,
145 | debug: this.options.debug,
146 | onEnd: function (response) {
147 | if (callback) {
148 | if (response.status !== grpc.Code.OK) {
149 | var err = new Error(response.statusMessage);
150 | err.code = response.status;
151 | err.metadata = response.trailers;
152 | callback(err, null);
153 | } else {
154 | callback(null, response.message);
155 | }
156 | }
157 | }
158 | });
159 | return {
160 | cancel: function () {
161 | callback = null;
162 | client.close();
163 | }
164 | };
165 | };
166 |
167 | FineTuningServiceClient.prototype.deleteModel = function deleteModel(requestMessage, metadata, callback) {
168 | if (arguments.length === 2) {
169 | callback = arguments[1];
170 | }
171 | var client = grpc.unary(FineTuningService.DeleteModel, {
172 | request: requestMessage,
173 | host: this.serviceHost,
174 | metadata: metadata,
175 | transport: this.options.transport,
176 | debug: this.options.debug,
177 | onEnd: function (response) {
178 | if (callback) {
179 | if (response.status !== grpc.Code.OK) {
180 | var err = new Error(response.statusMessage);
181 | err.code = response.status;
182 | err.metadata = response.trailers;
183 | callback(err, null);
184 | } else {
185 | callback(null, response.message);
186 | }
187 | }
188 | }
189 | });
190 | return {
191 | cancel: function () {
192 | callback = null;
193 | client.close();
194 | }
195 | };
196 | };
197 |
198 | FineTuningServiceClient.prototype.resubmitModel = function resubmitModel(requestMessage, metadata, callback) {
199 | if (arguments.length === 2) {
200 | callback = arguments[1];
201 | }
202 | var client = grpc.unary(FineTuningService.ResubmitModel, {
203 | request: requestMessage,
204 | host: this.serviceHost,
205 | metadata: metadata,
206 | transport: this.options.transport,
207 | debug: this.options.debug,
208 | onEnd: function (response) {
209 | if (callback) {
210 | if (response.status !== grpc.Code.OK) {
211 | var err = new Error(response.statusMessage);
212 | err.code = response.status;
213 | err.metadata = response.trailers;
214 | callback(err, null);
215 | } else {
216 | callback(null, response.message);
217 | }
218 | }
219 | }
220 | });
221 | return {
222 | cancel: function () {
223 | callback = null;
224 | client.close();
225 | }
226 | };
227 | };
228 |
229 | FineTuningServiceClient.prototype.listModels = function listModels(requestMessage, metadata, callback) {
230 | if (arguments.length === 2) {
231 | callback = arguments[1];
232 | }
233 | var client = grpc.unary(FineTuningService.ListModels, {
234 | request: requestMessage,
235 | host: this.serviceHost,
236 | metadata: metadata,
237 | transport: this.options.transport,
238 | debug: this.options.debug,
239 | onEnd: function (response) {
240 | if (callback) {
241 | if (response.status !== grpc.Code.OK) {
242 | var err = new Error(response.statusMessage);
243 | err.code = response.status;
244 | err.metadata = response.trailers;
245 | callback(err, null);
246 | } else {
247 | callback(null, response.message);
248 | }
249 | }
250 | }
251 | });
252 | return {
253 | cancel: function () {
254 | callback = null;
255 | client.close();
256 | }
257 | };
258 | };
259 |
260 | exports.FineTuningServiceClient = FineTuningServiceClient;
261 |
262 |
--------------------------------------------------------------------------------
/gooseai/generation/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Stability-AI/api-interfaces/0c30849b5d12274b1858658df796366c06b8c3fa/gooseai/generation/__init__.py
--------------------------------------------------------------------------------
/gooseai/generation/generation_grpc.pb.go:
--------------------------------------------------------------------------------
1 | // Code generated by protoc-gen-go-grpc. DO NOT EDIT.
2 |
3 | package generation
4 |
5 | import (
6 | context "context"
7 | grpc "google.golang.org/grpc"
8 | codes "google.golang.org/grpc/codes"
9 | status "google.golang.org/grpc/status"
10 | )
11 |
12 | // This is a compile-time assertion to ensure that this generated file
13 | // is compatible with the grpc package it is being compiled against.
14 | // Requires gRPC-Go v1.32.0 or later.
15 | const _ = grpc.SupportPackageIsVersion7
16 |
17 | // GenerationServiceClient is the client API for GenerationService service.
18 | //
19 | // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
20 | type GenerationServiceClient interface {
21 | Generate(ctx context.Context, in *Request, opts ...grpc.CallOption) (GenerationService_GenerateClient, error)
22 | ChainGenerate(ctx context.Context, in *ChainRequest, opts ...grpc.CallOption) (GenerationService_ChainGenerateClient, error)
23 | }
24 |
25 | type generationServiceClient struct {
26 | cc grpc.ClientConnInterface
27 | }
28 |
29 | func NewGenerationServiceClient(cc grpc.ClientConnInterface) GenerationServiceClient {
30 | return &generationServiceClient{cc}
31 | }
32 |
33 | func (c *generationServiceClient) Generate(ctx context.Context, in *Request, opts ...grpc.CallOption) (GenerationService_GenerateClient, error) {
34 | stream, err := c.cc.NewStream(ctx, &GenerationService_ServiceDesc.Streams[0], "/gooseai.GenerationService/Generate", opts...)
35 | if err != nil {
36 | return nil, err
37 | }
38 | x := &generationServiceGenerateClient{stream}
39 | if err := x.ClientStream.SendMsg(in); err != nil {
40 | return nil, err
41 | }
42 | if err := x.ClientStream.CloseSend(); err != nil {
43 | return nil, err
44 | }
45 | return x, nil
46 | }
47 |
48 | type GenerationService_GenerateClient interface {
49 | Recv() (*Answer, error)
50 | grpc.ClientStream
51 | }
52 |
53 | type generationServiceGenerateClient struct {
54 | grpc.ClientStream
55 | }
56 |
57 | func (x *generationServiceGenerateClient) Recv() (*Answer, error) {
58 | m := new(Answer)
59 | if err := x.ClientStream.RecvMsg(m); err != nil {
60 | return nil, err
61 | }
62 | return m, nil
63 | }
64 |
65 | func (c *generationServiceClient) ChainGenerate(ctx context.Context, in *ChainRequest, opts ...grpc.CallOption) (GenerationService_ChainGenerateClient, error) {
66 | stream, err := c.cc.NewStream(ctx, &GenerationService_ServiceDesc.Streams[1], "/gooseai.GenerationService/ChainGenerate", opts...)
67 | if err != nil {
68 | return nil, err
69 | }
70 | x := &generationServiceChainGenerateClient{stream}
71 | if err := x.ClientStream.SendMsg(in); err != nil {
72 | return nil, err
73 | }
74 | if err := x.ClientStream.CloseSend(); err != nil {
75 | return nil, err
76 | }
77 | return x, nil
78 | }
79 |
80 | type GenerationService_ChainGenerateClient interface {
81 | Recv() (*Answer, error)
82 | grpc.ClientStream
83 | }
84 |
85 | type generationServiceChainGenerateClient struct {
86 | grpc.ClientStream
87 | }
88 |
89 | func (x *generationServiceChainGenerateClient) Recv() (*Answer, error) {
90 | m := new(Answer)
91 | if err := x.ClientStream.RecvMsg(m); err != nil {
92 | return nil, err
93 | }
94 | return m, nil
95 | }
96 |
97 | // GenerationServiceServer is the server API for GenerationService service.
98 | // All implementations must embed UnimplementedGenerationServiceServer
99 | // for forward compatibility
100 | type GenerationServiceServer interface {
101 | Generate(*Request, GenerationService_GenerateServer) error
102 | ChainGenerate(*ChainRequest, GenerationService_ChainGenerateServer) error
103 | mustEmbedUnimplementedGenerationServiceServer()
104 | }
105 |
106 | // UnimplementedGenerationServiceServer must be embedded to have forward compatible implementations.
107 | type UnimplementedGenerationServiceServer struct {
108 | }
109 |
110 | func (UnimplementedGenerationServiceServer) Generate(*Request, GenerationService_GenerateServer) error {
111 | return status.Errorf(codes.Unimplemented, "method Generate not implemented")
112 | }
113 | func (UnimplementedGenerationServiceServer) ChainGenerate(*ChainRequest, GenerationService_ChainGenerateServer) error {
114 | return status.Errorf(codes.Unimplemented, "method ChainGenerate not implemented")
115 | }
116 | func (UnimplementedGenerationServiceServer) mustEmbedUnimplementedGenerationServiceServer() {}
117 |
118 | // UnsafeGenerationServiceServer may be embedded to opt out of forward compatibility for this service.
119 | // Use of this interface is not recommended, as added methods to GenerationServiceServer will
120 | // result in compilation errors.
121 | type UnsafeGenerationServiceServer interface {
122 | mustEmbedUnimplementedGenerationServiceServer()
123 | }
124 |
125 | func RegisterGenerationServiceServer(s grpc.ServiceRegistrar, srv GenerationServiceServer) {
126 | s.RegisterService(&GenerationService_ServiceDesc, srv)
127 | }
128 |
129 | func _GenerationService_Generate_Handler(srv interface{}, stream grpc.ServerStream) error {
130 | m := new(Request)
131 | if err := stream.RecvMsg(m); err != nil {
132 | return err
133 | }
134 | return srv.(GenerationServiceServer).Generate(m, &generationServiceGenerateServer{stream})
135 | }
136 |
137 | type GenerationService_GenerateServer interface {
138 | Send(*Answer) error
139 | grpc.ServerStream
140 | }
141 |
142 | type generationServiceGenerateServer struct {
143 | grpc.ServerStream
144 | }
145 |
146 | func (x *generationServiceGenerateServer) Send(m *Answer) error {
147 | return x.ServerStream.SendMsg(m)
148 | }
149 |
150 | func _GenerationService_ChainGenerate_Handler(srv interface{}, stream grpc.ServerStream) error {
151 | m := new(ChainRequest)
152 | if err := stream.RecvMsg(m); err != nil {
153 | return err
154 | }
155 | return srv.(GenerationServiceServer).ChainGenerate(m, &generationServiceChainGenerateServer{stream})
156 | }
157 |
158 | type GenerationService_ChainGenerateServer interface {
159 | Send(*Answer) error
160 | grpc.ServerStream
161 | }
162 |
163 | type generationServiceChainGenerateServer struct {
164 | grpc.ServerStream
165 | }
166 |
167 | func (x *generationServiceChainGenerateServer) Send(m *Answer) error {
168 | return x.ServerStream.SendMsg(m)
169 | }
170 |
171 | // GenerationService_ServiceDesc is the grpc.ServiceDesc for GenerationService service.
172 | // It's only intended for direct use with grpc.RegisterService,
173 | // and not to be introspected or modified (even as a copy)
174 | var GenerationService_ServiceDesc = grpc.ServiceDesc{
175 | ServiceName: "gooseai.GenerationService",
176 | HandlerType: (*GenerationServiceServer)(nil),
177 | Methods: []grpc.MethodDesc{},
178 | Streams: []grpc.StreamDesc{
179 | {
180 | StreamName: "Generate",
181 | Handler: _GenerationService_Generate_Handler,
182 | ServerStreams: true,
183 | },
184 | {
185 | StreamName: "ChainGenerate",
186 | Handler: _GenerationService_ChainGenerate_Handler,
187 | ServerStreams: true,
188 | },
189 | },
190 | Metadata: "generation.proto",
191 | }
192 |
--------------------------------------------------------------------------------
/gooseai/generation/generation_grpc_pb.d.ts:
--------------------------------------------------------------------------------
1 | // GENERATED CODE -- DO NOT EDIT!
2 |
3 | // package: gooseai
4 | // file: generation.proto
5 |
6 | import * as generation_pb from "./generation_pb";
7 | import * as grpc from "grpc";
8 |
9 | interface IGenerationServiceService extends grpc.ServiceDefinition {
10 | generate: grpc.MethodDefinition;
11 | chainGenerate: grpc.MethodDefinition;
12 | }
13 |
14 | export const GenerationServiceService: IGenerationServiceService;
15 |
16 | export interface IGenerationServiceServer extends grpc.UntypedServiceImplementation {
17 | generate: grpc.handleServerStreamingCall;
18 | chainGenerate: grpc.handleServerStreamingCall;
19 | }
20 |
21 | export class GenerationServiceClient extends grpc.Client {
22 | constructor(address: string, credentials: grpc.ChannelCredentials, options?: object);
23 | generate(argument: generation_pb.Request, metadataOrOptions?: grpc.Metadata | grpc.CallOptions | null): grpc.ClientReadableStream;
24 | generate(argument: generation_pb.Request, metadata?: grpc.Metadata | null, options?: grpc.CallOptions | null): grpc.ClientReadableStream;
25 | chainGenerate(argument: generation_pb.ChainRequest, metadataOrOptions?: grpc.Metadata | grpc.CallOptions | null): grpc.ClientReadableStream;
26 | chainGenerate(argument: generation_pb.ChainRequest, metadata?: grpc.Metadata | null, options?: grpc.CallOptions | null): grpc.ClientReadableStream;
27 | }
28 |
--------------------------------------------------------------------------------
/gooseai/generation/generation_grpc_pb.js:
--------------------------------------------------------------------------------
1 | // GENERATED CODE -- DO NOT EDIT!
2 |
3 | 'use strict';
4 | var grpc = require('grpc');
5 | var generation_pb = require('./generation_pb.js');
6 | var google_protobuf_struct_pb = require('google-protobuf/google/protobuf/struct_pb.js');
7 | var tensors_pb = require('./tensors_pb.js');
8 |
9 | function serialize_gooseai_Answer(arg) {
10 | if (!(arg instanceof generation_pb.Answer)) {
11 | throw new Error('Expected argument of type gooseai.Answer');
12 | }
13 | return Buffer.from(arg.serializeBinary());
14 | }
15 |
16 | function deserialize_gooseai_Answer(buffer_arg) {
17 | return generation_pb.Answer.deserializeBinary(new Uint8Array(buffer_arg));
18 | }
19 |
20 | function serialize_gooseai_ChainRequest(arg) {
21 | if (!(arg instanceof generation_pb.ChainRequest)) {
22 | throw new Error('Expected argument of type gooseai.ChainRequest');
23 | }
24 | return Buffer.from(arg.serializeBinary());
25 | }
26 |
27 | function deserialize_gooseai_ChainRequest(buffer_arg) {
28 | return generation_pb.ChainRequest.deserializeBinary(new Uint8Array(buffer_arg));
29 | }
30 |
31 | function serialize_gooseai_Request(arg) {
32 | if (!(arg instanceof generation_pb.Request)) {
33 | throw new Error('Expected argument of type gooseai.Request');
34 | }
35 | return Buffer.from(arg.serializeBinary());
36 | }
37 |
38 | function deserialize_gooseai_Request(buffer_arg) {
39 | return generation_pb.Request.deserializeBinary(new Uint8Array(buffer_arg));
40 | }
41 |
42 |
43 | //
44 | // gRPC services
45 | //
46 | var GenerationServiceService = exports.GenerationServiceService = {
47 | generate: {
48 | path: '/gooseai.GenerationService/Generate',
49 | requestStream: false,
50 | responseStream: true,
51 | requestType: generation_pb.Request,
52 | responseType: generation_pb.Answer,
53 | requestSerialize: serialize_gooseai_Request,
54 | requestDeserialize: deserialize_gooseai_Request,
55 | responseSerialize: serialize_gooseai_Answer,
56 | responseDeserialize: deserialize_gooseai_Answer,
57 | },
58 | chainGenerate: {
59 | path: '/gooseai.GenerationService/ChainGenerate',
60 | requestStream: false,
61 | responseStream: true,
62 | requestType: generation_pb.ChainRequest,
63 | responseType: generation_pb.Answer,
64 | requestSerialize: serialize_gooseai_ChainRequest,
65 | requestDeserialize: deserialize_gooseai_ChainRequest,
66 | responseSerialize: serialize_gooseai_Answer,
67 | responseDeserialize: deserialize_gooseai_Answer,
68 | },
69 | };
70 |
71 | exports.GenerationServiceClient = grpc.makeGenericClientConstructor(GenerationServiceService);
72 |
--------------------------------------------------------------------------------
/gooseai/generation/generation_pb2_grpc.py:
--------------------------------------------------------------------------------
1 | # Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
2 | """Client and server classes corresponding to protobuf-defined services."""
3 | import grpc
4 |
5 | import generation_pb2 as generation__pb2
6 |
7 |
8 | class GenerationServiceStub(object):
9 | """
10 | gRPC services
11 |
12 | """
13 |
14 | def __init__(self, channel):
15 | """Constructor.
16 |
17 | Args:
18 | channel: A grpc.Channel.
19 | """
20 | self.Generate = channel.unary_stream(
21 | '/gooseai.GenerationService/Generate',
22 | request_serializer=generation__pb2.Request.SerializeToString,
23 | response_deserializer=generation__pb2.Answer.FromString,
24 | )
25 | self.ChainGenerate = channel.unary_stream(
26 | '/gooseai.GenerationService/ChainGenerate',
27 | request_serializer=generation__pb2.ChainRequest.SerializeToString,
28 | response_deserializer=generation__pb2.Answer.FromString,
29 | )
30 |
31 |
32 | class GenerationServiceServicer(object):
33 | """
34 | gRPC services
35 |
36 | """
37 |
38 | def Generate(self, request, context):
39 | """Missing associated documentation comment in .proto file."""
40 | context.set_code(grpc.StatusCode.UNIMPLEMENTED)
41 | context.set_details('Method not implemented!')
42 | raise NotImplementedError('Method not implemented!')
43 |
44 | def ChainGenerate(self, request, context):
45 | """Missing associated documentation comment in .proto file."""
46 | context.set_code(grpc.StatusCode.UNIMPLEMENTED)
47 | context.set_details('Method not implemented!')
48 | raise NotImplementedError('Method not implemented!')
49 |
50 |
51 | def add_GenerationServiceServicer_to_server(servicer, server):
52 | rpc_method_handlers = {
53 | 'Generate': grpc.unary_stream_rpc_method_handler(
54 | servicer.Generate,
55 | request_deserializer=generation__pb2.Request.FromString,
56 | response_serializer=generation__pb2.Answer.SerializeToString,
57 | ),
58 | 'ChainGenerate': grpc.unary_stream_rpc_method_handler(
59 | servicer.ChainGenerate,
60 | request_deserializer=generation__pb2.ChainRequest.FromString,
61 | response_serializer=generation__pb2.Answer.SerializeToString,
62 | ),
63 | }
64 | generic_handler = grpc.method_handlers_generic_handler(
65 | 'gooseai.GenerationService', rpc_method_handlers)
66 | server.add_generic_rpc_handlers((generic_handler,))
67 |
68 |
69 | # This class is part of an EXPERIMENTAL API.
70 | class GenerationService(object):
71 | """
72 | gRPC services
73 |
74 | """
75 |
76 | @staticmethod
77 | def Generate(request,
78 | target,
79 | options=(),
80 | channel_credentials=None,
81 | call_credentials=None,
82 | insecure=False,
83 | compression=None,
84 | wait_for_ready=None,
85 | timeout=None,
86 | metadata=None):
87 | return grpc.experimental.unary_stream(request, target, '/gooseai.GenerationService/Generate',
88 | generation__pb2.Request.SerializeToString,
89 | generation__pb2.Answer.FromString,
90 | options, channel_credentials,
91 | insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
92 |
93 | @staticmethod
94 | def ChainGenerate(request,
95 | target,
96 | options=(),
97 | channel_credentials=None,
98 | call_credentials=None,
99 | insecure=False,
100 | compression=None,
101 | wait_for_ready=None,
102 | timeout=None,
103 | metadata=None):
104 | return grpc.experimental.unary_stream(request, target, '/gooseai.GenerationService/ChainGenerate',
105 | generation__pb2.ChainRequest.SerializeToString,
106 | generation__pb2.Answer.FromString,
107 | options, channel_credentials,
108 | insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
109 |
--------------------------------------------------------------------------------
/gooseai/generation/generation_pb_service.d.ts:
--------------------------------------------------------------------------------
1 | // package: gooseai
2 | // file: generation.proto
3 |
4 | import * as generation_pb from "./generation_pb";
5 | import {grpc} from "@improbable-eng/grpc-web";
6 |
7 | type GenerationServiceGenerate = {
8 | readonly methodName: string;
9 | readonly service: typeof GenerationService;
10 | readonly requestStream: false;
11 | readonly responseStream: true;
12 | readonly requestType: typeof generation_pb.Request;
13 | readonly responseType: typeof generation_pb.Answer;
14 | };
15 |
16 | type GenerationServiceChainGenerate = {
17 | readonly methodName: string;
18 | readonly service: typeof GenerationService;
19 | readonly requestStream: false;
20 | readonly responseStream: true;
21 | readonly requestType: typeof generation_pb.ChainRequest;
22 | readonly responseType: typeof generation_pb.Answer;
23 | };
24 |
25 | export class GenerationService {
26 | static readonly serviceName: string;
27 | static readonly Generate: GenerationServiceGenerate;
28 | static readonly ChainGenerate: GenerationServiceChainGenerate;
29 | }
30 |
31 | export type ServiceError = { message: string, code: number; metadata: grpc.Metadata }
32 | export type Status = { details: string, code: number; metadata: grpc.Metadata }
33 |
34 | interface UnaryResponse {
35 | cancel(): void;
36 | }
37 | interface ResponseStream {
38 | cancel(): void;
39 | on(type: 'data', handler: (message: T) => void): ResponseStream;
40 | on(type: 'end', handler: (status?: Status) => void): ResponseStream;
41 | on(type: 'status', handler: (status: Status) => void): ResponseStream;
42 | }
43 | interface RequestStream {
44 | write(message: T): RequestStream;
45 | end(): void;
46 | cancel(): void;
47 | on(type: 'end', handler: (status?: Status) => void): RequestStream;
48 | on(type: 'status', handler: (status: Status) => void): RequestStream;
49 | }
50 | interface BidirectionalStream {
51 | write(message: ReqT): BidirectionalStream;
52 | end(): void;
53 | cancel(): void;
54 | on(type: 'data', handler: (message: ResT) => void): BidirectionalStream;
55 | on(type: 'end', handler: (status?: Status) => void): BidirectionalStream;
56 | on(type: 'status', handler: (status: Status) => void): BidirectionalStream;
57 | }
58 |
59 | export class GenerationServiceClient {
60 | readonly serviceHost: string;
61 |
62 | constructor(serviceHost: string, options?: grpc.RpcOptions);
63 | generate(requestMessage: generation_pb.Request, metadata?: grpc.Metadata): ResponseStream;
64 | chainGenerate(requestMessage: generation_pb.ChainRequest, metadata?: grpc.Metadata): ResponseStream;
65 | }
66 |
67 |
--------------------------------------------------------------------------------
/gooseai/generation/generation_pb_service.js:
--------------------------------------------------------------------------------
1 | // package: gooseai
2 | // file: generation.proto
3 |
4 | var generation_pb = require("./generation_pb");
5 | var grpc = require("@improbable-eng/grpc-web").grpc;
6 |
7 | var GenerationService = (function () {
8 | function GenerationService() {}
9 | GenerationService.serviceName = "gooseai.GenerationService";
10 | return GenerationService;
11 | }());
12 |
13 | GenerationService.Generate = {
14 | methodName: "Generate",
15 | service: GenerationService,
16 | requestStream: false,
17 | responseStream: true,
18 | requestType: generation_pb.Request,
19 | responseType: generation_pb.Answer
20 | };
21 |
22 | GenerationService.ChainGenerate = {
23 | methodName: "ChainGenerate",
24 | service: GenerationService,
25 | requestStream: false,
26 | responseStream: true,
27 | requestType: generation_pb.ChainRequest,
28 | responseType: generation_pb.Answer
29 | };
30 |
31 | exports.GenerationService = GenerationService;
32 |
33 | function GenerationServiceClient(serviceHost, options) {
34 | this.serviceHost = serviceHost;
35 | this.options = options || {};
36 | }
37 |
38 | GenerationServiceClient.prototype.generate = function generate(requestMessage, metadata) {
39 | var listeners = {
40 | data: [],
41 | end: [],
42 | status: []
43 | };
44 | var client = grpc.invoke(GenerationService.Generate, {
45 | request: requestMessage,
46 | host: this.serviceHost,
47 | metadata: metadata,
48 | transport: this.options.transport,
49 | debug: this.options.debug,
50 | onMessage: function (responseMessage) {
51 | listeners.data.forEach(function (handler) {
52 | handler(responseMessage);
53 | });
54 | },
55 | onEnd: function (status, statusMessage, trailers) {
56 | listeners.status.forEach(function (handler) {
57 | handler({ code: status, details: statusMessage, metadata: trailers });
58 | });
59 | listeners.end.forEach(function (handler) {
60 | handler({ code: status, details: statusMessage, metadata: trailers });
61 | });
62 | listeners = null;
63 | }
64 | });
65 | return {
66 | on: function (type, handler) {
67 | listeners[type].push(handler);
68 | return this;
69 | },
70 | cancel: function () {
71 | listeners = null;
72 | client.close();
73 | }
74 | };
75 | };
76 |
77 | GenerationServiceClient.prototype.chainGenerate = function chainGenerate(requestMessage, metadata) {
78 | var listeners = {
79 | data: [],
80 | end: [],
81 | status: []
82 | };
83 | var client = grpc.invoke(GenerationService.ChainGenerate, {
84 | request: requestMessage,
85 | host: this.serviceHost,
86 | metadata: metadata,
87 | transport: this.options.transport,
88 | debug: this.options.debug,
89 | onMessage: function (responseMessage) {
90 | listeners.data.forEach(function (handler) {
91 | handler(responseMessage);
92 | });
93 | },
94 | onEnd: function (status, statusMessage, trailers) {
95 | listeners.status.forEach(function (handler) {
96 | handler({ code: status, details: statusMessage, metadata: trailers });
97 | });
98 | listeners.end.forEach(function (handler) {
99 | handler({ code: status, details: statusMessage, metadata: trailers });
100 | });
101 | listeners = null;
102 | }
103 | });
104 | return {
105 | on: function (type, handler) {
106 | listeners[type].push(handler);
107 | return this;
108 | },
109 | cancel: function () {
110 | listeners = null;
111 | client.close();
112 | }
113 | };
114 | };
115 |
116 | exports.GenerationServiceClient = GenerationServiceClient;
117 |
118 |
--------------------------------------------------------------------------------
/gooseai/generation/tensors_pb.d.ts:
--------------------------------------------------------------------------------
1 | // package: tensors
2 | // file: tensors.proto
3 |
4 | import * as jspb from "google-protobuf";
5 |
6 | export class Tensor extends jspb.Message {
7 | getDtype(): DtypeMap[keyof DtypeMap];
8 | setDtype(value: DtypeMap[keyof DtypeMap]): void;
9 |
10 | clearShapeList(): void;
11 | getShapeList(): Array;
12 | setShapeList(value: Array): void;
13 | addShape(value: number, index?: number): number;
14 |
15 | getData(): Uint8Array | string;
16 | getData_asU8(): Uint8Array;
17 | getData_asB64(): string;
18 | setData(value: Uint8Array | string): void;
19 |
20 | hasAttrType(): boolean;
21 | clearAttrType(): void;
22 | getAttrType(): AttributeTypeMap[keyof AttributeTypeMap];
23 | setAttrType(value: AttributeTypeMap[keyof AttributeTypeMap]): void;
24 |
25 | serializeBinary(): Uint8Array;
26 | toObject(includeInstance?: boolean): Tensor.AsObject;
27 | static toObject(includeInstance: boolean, msg: Tensor): Tensor.AsObject;
28 | static extensions: {[key: number]: jspb.ExtensionFieldInfo};
29 | static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo};
30 | static serializeBinaryToWriter(message: Tensor, writer: jspb.BinaryWriter): void;
31 | static deserializeBinary(bytes: Uint8Array): Tensor;
32 | static deserializeBinaryFromReader(message: Tensor, reader: jspb.BinaryReader): Tensor;
33 | }
34 |
35 | export namespace Tensor {
36 | export type AsObject = {
37 | dtype: DtypeMap[keyof DtypeMap],
38 | shapeList: Array,
39 | data: Uint8Array | string,
40 | attrType: AttributeTypeMap[keyof AttributeTypeMap],
41 | }
42 | }
43 |
44 | export class Attribute extends jspb.Message {
45 | getName(): string;
46 | setName(value: string): void;
47 |
48 | hasModule(): boolean;
49 | clearModule(): void;
50 | getModule(): Module | undefined;
51 | setModule(value?: Module): void;
52 |
53 | hasTensor(): boolean;
54 | clearTensor(): void;
55 | getTensor(): Tensor | undefined;
56 | setTensor(value?: Tensor): void;
57 |
58 | hasString(): boolean;
59 | clearString(): void;
60 | getString(): string;
61 | setString(value: string): void;
62 |
63 | hasInt64(): boolean;
64 | clearInt64(): void;
65 | getInt64(): number;
66 | setInt64(value: number): void;
67 |
68 | hasFloat(): boolean;
69 | clearFloat(): void;
70 | getFloat(): number;
71 | setFloat(value: number): void;
72 |
73 | hasBool(): boolean;
74 | clearBool(): void;
75 | getBool(): boolean;
76 | setBool(value: boolean): void;
77 |
78 | getValueCase(): Attribute.ValueCase;
79 | serializeBinary(): Uint8Array;
80 | toObject(includeInstance?: boolean): Attribute.AsObject;
81 | static toObject(includeInstance: boolean, msg: Attribute): Attribute.AsObject;
82 | static extensions: {[key: number]: jspb.ExtensionFieldInfo};
83 | static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo};
84 | static serializeBinaryToWriter(message: Attribute, writer: jspb.BinaryWriter): void;
85 | static deserializeBinary(bytes: Uint8Array): Attribute;
86 | static deserializeBinaryFromReader(message: Attribute, reader: jspb.BinaryReader): Attribute;
87 | }
88 |
89 | export namespace Attribute {
90 | export type AsObject = {
91 | name: string,
92 | module?: Module.AsObject,
93 | tensor?: Tensor.AsObject,
94 | string: string,
95 | int64: number,
96 | pb_float: number,
97 | bool: boolean,
98 | }
99 |
100 | export enum ValueCase {
101 | VALUE_NOT_SET = 0,
102 | MODULE = 3,
103 | TENSOR = 4,
104 | STRING = 5,
105 | INT64 = 6,
106 | FLOAT = 7,
107 | BOOL = 8,
108 | }
109 | }
110 |
111 | export class Module extends jspb.Message {
112 | getName(): string;
113 | setName(value: string): void;
114 |
115 | clearNamesList(): void;
116 | getNamesList(): Array;
117 | setNamesList(value: Array): void;
118 | addNames(value: string, index?: number): string;
119 |
120 | clearAttributesList(): void;
121 | getAttributesList(): Array;
122 | setAttributesList(value: Array): void;
123 | addAttributes(value?: Attribute, index?: number): Attribute;
124 |
125 | serializeBinary(): Uint8Array;
126 | toObject(includeInstance?: boolean): Module.AsObject;
127 | static toObject(includeInstance: boolean, msg: Module): Module.AsObject;
128 | static extensions: {[key: number]: jspb.ExtensionFieldInfo};
129 | static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo};
130 | static serializeBinaryToWriter(message: Module, writer: jspb.BinaryWriter): void;
131 | static deserializeBinary(bytes: Uint8Array): Module;
132 | static deserializeBinaryFromReader(message: Module, reader: jspb.BinaryReader): Module;
133 | }
134 |
135 | export namespace Module {
136 | export type AsObject = {
137 | name: string,
138 | namesList: Array,
139 | attributesList: Array,
140 | }
141 | }
142 |
143 | export interface DtypeMap {
144 | DT_INVALID: 0;
145 | DT_FLOAT32: 1;
146 | DT_FLOAT64: 2;
147 | DT_FLOAT16: 3;
148 | DT_BFLOAT16: 4;
149 | DT_COMPLEX32: 5;
150 | DT_COMPLEX64: 6;
151 | DT_COMPLEX128: 7;
152 | DT_UINT8: 8;
153 | DT_INT8: 9;
154 | DT_INT16: 10;
155 | DT_INT32: 11;
156 | DT_INT64: 12;
157 | DT_BOOL: 13;
158 | DT_QUINT8: 14;
159 | DT_QINT8: 15;
160 | DT_QINT32: 16;
161 | DT_QUINT4_2: 17;
162 | }
163 |
164 | export const Dtype: DtypeMap;
165 |
166 | export interface AttributeTypeMap {
167 | AT_PARAMETER: 0;
168 | AT_BUFFER: 1;
169 | }
170 |
171 | export const AttributeType: AttributeTypeMap;
172 |
173 |
--------------------------------------------------------------------------------
/gooseai/generation/tensors_pb2.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | # Generated by the protocol buffer compiler. DO NOT EDIT!
3 | # source: tensors.proto
4 | """Generated protocol buffer code."""
5 | from google.protobuf.internal import enum_type_wrapper
6 | from google.protobuf import descriptor as _descriptor
7 | from google.protobuf import descriptor_pool as _descriptor_pool
8 | from google.protobuf import message as _message
9 | from google.protobuf import reflection as _reflection
10 | from google.protobuf import symbol_database as _symbol_database
11 | # @@protoc_insertion_point(imports)
12 |
13 | _sym_db = _symbol_database.Default()
14 |
15 |
16 |
17 |
18 | DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\rtensors.proto\x12\x07tensors\"\x82\x01\n\x06Tensor\x12\x1d\n\x05\x64type\x18\x01 \x01(\x0e\x32\x0e.tensors.Dtype\x12\r\n\x05shape\x18\x02 \x03(\x03\x12\x0c\n\x04\x64\x61ta\x18\x03 \x01(\x0c\x12.\n\tattr_type\x18\x04 \x01(\x0e\x32\x16.tensors.AttributeTypeH\x00\x88\x01\x01\x42\x0c\n\n_attr_type\"\xac\x01\n\tAttribute\x12\x0c\n\x04name\x18\x01 \x01(\t\x12!\n\x06module\x18\x03 \x01(\x0b\x32\x0f.tensors.ModuleH\x00\x12!\n\x06tensor\x18\x04 \x01(\x0b\x32\x0f.tensors.TensorH\x00\x12\x10\n\x06string\x18\x05 \x01(\tH\x00\x12\x0f\n\x05int64\x18\x06 \x01(\x03H\x00\x12\x0f\n\x05\x66loat\x18\x07 \x01(\x02H\x00\x12\x0e\n\x04\x62ool\x18\x08 \x01(\x08H\x00\x42\x07\n\x05value\"M\n\x06Module\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\r\n\x05names\x18\x02 \x03(\t\x12&\n\nattributes\x18\x03 \x03(\x0b\x32\x12.tensors.Attribute*\x9e\x02\n\x05\x44type\x12\x0e\n\nDT_INVALID\x10\x00\x12\x0e\n\nDT_FLOAT32\x10\x01\x12\x0e\n\nDT_FLOAT64\x10\x02\x12\x0e\n\nDT_FLOAT16\x10\x03\x12\x0f\n\x0b\x44T_BFLOAT16\x10\x04\x12\x10\n\x0c\x44T_COMPLEX32\x10\x05\x12\x10\n\x0c\x44T_COMPLEX64\x10\x06\x12\x11\n\rDT_COMPLEX128\x10\x07\x12\x0c\n\x08\x44T_UINT8\x10\x08\x12\x0b\n\x07\x44T_INT8\x10\t\x12\x0c\n\x08\x44T_INT16\x10\n\x12\x0c\n\x08\x44T_INT32\x10\x0b\x12\x0c\n\x08\x44T_INT64\x10\x0c\x12\x0b\n\x07\x44T_BOOL\x10\r\x12\r\n\tDT_QUINT8\x10\x0e\x12\x0c\n\x08\x44T_QINT8\x10\x0f\x12\r\n\tDT_QINT32\x10\x10\x12\x0f\n\x0b\x44T_QUINT4_2\x10\x11*0\n\rAttributeType\x12\x10\n\x0c\x41T_PARAMETER\x10\x00\x12\r\n\tAT_BUFFER\x10\x01\x42)Z\'github.com/coreweave/tensorizer/tensorsb\x06proto3')
19 |
20 | _DTYPE = DESCRIPTOR.enum_types_by_name['Dtype']
21 | Dtype = enum_type_wrapper.EnumTypeWrapper(_DTYPE)
22 | _ATTRIBUTETYPE = DESCRIPTOR.enum_types_by_name['AttributeType']
23 | AttributeType = enum_type_wrapper.EnumTypeWrapper(_ATTRIBUTETYPE)
24 | DT_INVALID = 0
25 | DT_FLOAT32 = 1
26 | DT_FLOAT64 = 2
27 | DT_FLOAT16 = 3
28 | DT_BFLOAT16 = 4
29 | DT_COMPLEX32 = 5
30 | DT_COMPLEX64 = 6
31 | DT_COMPLEX128 = 7
32 | DT_UINT8 = 8
33 | DT_INT8 = 9
34 | DT_INT16 = 10
35 | DT_INT32 = 11
36 | DT_INT64 = 12
37 | DT_BOOL = 13
38 | DT_QUINT8 = 14
39 | DT_QINT8 = 15
40 | DT_QINT32 = 16
41 | DT_QUINT4_2 = 17
42 | AT_PARAMETER = 0
43 | AT_BUFFER = 1
44 |
45 |
46 | _TENSOR = DESCRIPTOR.message_types_by_name['Tensor']
47 | _ATTRIBUTE = DESCRIPTOR.message_types_by_name['Attribute']
48 | _MODULE = DESCRIPTOR.message_types_by_name['Module']
49 | Tensor = _reflection.GeneratedProtocolMessageType('Tensor', (_message.Message,), {
50 | 'DESCRIPTOR' : _TENSOR,
51 | '__module__' : 'tensors_pb2'
52 | # @@protoc_insertion_point(class_scope:tensors.Tensor)
53 | })
54 | _sym_db.RegisterMessage(Tensor)
55 |
56 | Attribute = _reflection.GeneratedProtocolMessageType('Attribute', (_message.Message,), {
57 | 'DESCRIPTOR' : _ATTRIBUTE,
58 | '__module__' : 'tensors_pb2'
59 | # @@protoc_insertion_point(class_scope:tensors.Attribute)
60 | })
61 | _sym_db.RegisterMessage(Attribute)
62 |
63 | Module = _reflection.GeneratedProtocolMessageType('Module', (_message.Message,), {
64 | 'DESCRIPTOR' : _MODULE,
65 | '__module__' : 'tensors_pb2'
66 | # @@protoc_insertion_point(class_scope:tensors.Module)
67 | })
68 | _sym_db.RegisterMessage(Module)
69 |
70 | if _descriptor._USE_C_DESCRIPTORS == False:
71 |
72 | DESCRIPTOR._options = None
73 | DESCRIPTOR._serialized_options = b'Z\'github.com/coreweave/tensorizer/tensors'
74 | _DTYPE._serialized_start=414
75 | _DTYPE._serialized_end=700
76 | _ATTRIBUTETYPE._serialized_start=702
77 | _ATTRIBUTETYPE._serialized_end=750
78 | _TENSOR._serialized_start=27
79 | _TENSOR._serialized_end=157
80 | _ATTRIBUTE._serialized_start=160
81 | _ATTRIBUTE._serialized_end=332
82 | _MODULE._serialized_start=334
83 | _MODULE._serialized_end=411
84 | # @@protoc_insertion_point(module_scope)
85 |
--------------------------------------------------------------------------------
/gooseai/go.mod:
--------------------------------------------------------------------------------
1 | module github.com/stability-ai/api-interfaces/gooseai
2 |
3 | go 1.18
4 |
5 | require (
6 | github.com/coreweave/tensorizer/tensors v0.0.0-20250509231441-bea4967c057f
7 | google.golang.org/grpc v1.72.1
8 | google.golang.org/protobuf v1.36.6
9 | )
10 |
11 | require (
12 | golang.org/x/net v0.35.0 // indirect
13 | golang.org/x/sys v0.30.0 // indirect
14 | golang.org/x/text v0.22.0 // indirect
15 | google.golang.org/genproto/googleapis/rpc v0.0.0-20250218202821-56aae31c358a // indirect
16 | )
17 |
--------------------------------------------------------------------------------
/gooseai/go.sum:
--------------------------------------------------------------------------------
1 | github.com/coreweave/tensorizer/tensors v0.0.0-20250509231441-bea4967c057f h1:1ky/Kb7g1OePI3hKgD05KdGJezC+rDdS1tTjCJGD/B4=
2 | github.com/coreweave/tensorizer/tensors v0.0.0-20250509231441-bea4967c057f/go.mod h1:SBsa3erqu4GCZbu2jeiMIE86eZ6Tx9fDmi/0BZpjHcU=
3 | github.com/go-logr/logr v1.4.2 h1:6pFjapn8bFcIbiKo3XT4j/BhANplGihG6tvd+8rYgrY=
4 | github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag=
5 | github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek=
6 | github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
7 | github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
8 | go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA=
9 | go.opentelemetry.io/otel v1.34.0 h1:zRLXxLCgL1WyKsPVrgbSdMN4c0FMkDAskSTQP+0hdUY=
10 | go.opentelemetry.io/otel/metric v1.34.0 h1:+eTR3U0MyfWjRDhmFMxe2SsW64QrZ84AOhvqS7Y+PoQ=
11 | go.opentelemetry.io/otel/sdk v1.34.0 h1:95zS4k/2GOy069d321O8jWgYsW3MzVV+KuSPKp7Wr1A=
12 | go.opentelemetry.io/otel/sdk/metric v1.34.0 h1:5CeK9ujjbFVL5c1PhLuStg1wxA7vQv7ce1EK0Gyvahk=
13 | go.opentelemetry.io/otel/trace v1.34.0 h1:+ouXS2V8Rd4hp4580a8q23bg0azF2nI8cqLYnC8mh/k=
14 | golang.org/x/net v0.35.0 h1:T5GQRQb2y08kTAByq9L4/bz8cipCdA8FbRTXewonqY8=
15 | golang.org/x/net v0.35.0/go.mod h1:EglIi67kWsHKlRzzVMUD93VMSWGFOMSZgxFjparz1Qk=
16 | golang.org/x/sys v0.30.0 h1:QjkSwP/36a20jFYWkSue1YwXzLmsV5Gfq7Eiy72C1uc=
17 | golang.org/x/sys v0.30.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
18 | golang.org/x/text v0.22.0 h1:bofq7m3/HAFvbF51jz3Q9wLg3jkvSPuiZu/pD1XwgtM=
19 | golang.org/x/text v0.22.0/go.mod h1:YRoo4H8PVmsu+E3Ou7cqLVH8oXWIHVoX0jqUWALQhfY=
20 | google.golang.org/genproto/googleapis/rpc v0.0.0-20250218202821-56aae31c358a h1:51aaUVRocpvUOSQKM6Q7VuoaktNIaMCLuhZB6DKksq4=
21 | google.golang.org/genproto/googleapis/rpc v0.0.0-20250218202821-56aae31c358a/go.mod h1:uRxBH1mhmO8PGhU89cMcHaXKZqO+OfakD8QQO0oYwlQ=
22 | google.golang.org/grpc v1.72.1 h1:HR03wO6eyZ7lknl75XlxABNVLLFc2PAb6mHlYh756mA=
23 | google.golang.org/grpc v1.72.1/go.mod h1:wH5Aktxcg25y1I3w7H69nHfXdOG3UiadoBtjh3izSDM=
24 | google.golang.org/protobuf v1.36.6 h1:z1NpPI8ku2WgiWnf+t9wTPsn6eP1L7ksHUlkfLvd9xY=
25 | google.golang.org/protobuf v1.36.6/go.mod h1:jduwjTPXsFjZGTmRluh+L6NjiWu7pchiJ2/5YcXBHnY=
26 |
--------------------------------------------------------------------------------
/gooseai/project/project_grpc_pb.d.ts:
--------------------------------------------------------------------------------
1 | // GENERATED CODE -- DO NOT EDIT!
2 |
3 | // package: gooseai
4 | // file: project.proto
5 |
6 | import * as project_pb from "./project_pb";
7 | import * as grpc from "grpc";
8 |
9 | interface IProjectServiceService extends grpc.ServiceDefinition {
10 | create: grpc.MethodDefinition;
11 | update: grpc.MethodDefinition;
12 | list: grpc.MethodDefinition;
13 | get: grpc.MethodDefinition;
14 | delete: grpc.MethodDefinition;
15 | tagAssets: grpc.MethodDefinition;
16 | untagAssets: grpc.MethodDefinition;
17 | queryAssets: grpc.MethodDefinition;
18 | deleteAssets: grpc.MethodDefinition;
19 | }
20 |
21 | export const ProjectServiceService: IProjectServiceService;
22 |
23 | export interface IProjectServiceServer extends grpc.UntypedServiceImplementation {
24 | create: grpc.handleUnaryCall;
25 | update: grpc.handleUnaryCall;
26 | list: grpc.handleServerStreamingCall;
27 | get: grpc.handleUnaryCall;
28 | delete: grpc.handleUnaryCall;
29 | tagAssets: grpc.handleUnaryCall;
30 | untagAssets: grpc.handleUnaryCall;
31 | queryAssets: grpc.handleUnaryCall;
32 | deleteAssets: grpc.handleUnaryCall;
33 | }
34 |
35 | export class ProjectServiceClient extends grpc.Client {
36 | constructor(address: string, credentials: grpc.ChannelCredentials, options?: object);
37 | create(argument: project_pb.CreateProjectRequest, callback: grpc.requestCallback): grpc.ClientUnaryCall;
38 | create(argument: project_pb.CreateProjectRequest, metadataOrOptions: grpc.Metadata | grpc.CallOptions | null, callback: grpc.requestCallback): grpc.ClientUnaryCall;
39 | create(argument: project_pb.CreateProjectRequest, metadata: grpc.Metadata | null, options: grpc.CallOptions | null, callback: grpc.requestCallback): grpc.ClientUnaryCall;
40 | update(argument: project_pb.UpdateProjectRequest, callback: grpc.requestCallback): grpc.ClientUnaryCall;
41 | update(argument: project_pb.UpdateProjectRequest, metadataOrOptions: grpc.Metadata | grpc.CallOptions | null, callback: grpc.requestCallback): grpc.ClientUnaryCall;
42 | update(argument: project_pb.UpdateProjectRequest, metadata: grpc.Metadata | null, options: grpc.CallOptions | null, callback: grpc.requestCallback): grpc.ClientUnaryCall;
43 | list(argument: project_pb.ListProjectRequest, metadataOrOptions?: grpc.Metadata | grpc.CallOptions | null): grpc.ClientReadableStream;
44 | list(argument: project_pb.ListProjectRequest, metadata?: grpc.Metadata | null, options?: grpc.CallOptions | null): grpc.ClientReadableStream;
45 | get(argument: project_pb.GetProjectRequest, callback: grpc.requestCallback): grpc.ClientUnaryCall;
46 | get(argument: project_pb.GetProjectRequest, metadataOrOptions: grpc.Metadata | grpc.CallOptions | null, callback: grpc.requestCallback): grpc.ClientUnaryCall;
47 | get(argument: project_pb.GetProjectRequest, metadata: grpc.Metadata | null, options: grpc.CallOptions | null, callback: grpc.requestCallback): grpc.ClientUnaryCall;
48 | delete(argument: project_pb.DeleteProjectRequest, callback: grpc.requestCallback): grpc.ClientUnaryCall;
49 | delete(argument: project_pb.DeleteProjectRequest, metadataOrOptions: grpc.Metadata | grpc.CallOptions | null, callback: grpc.requestCallback): grpc.ClientUnaryCall;
50 | delete(argument: project_pb.DeleteProjectRequest, metadata: grpc.Metadata | null, options: grpc.CallOptions | null, callback: grpc.requestCallback): grpc.ClientUnaryCall;
51 | tagAssets(argument: project_pb.TagAssetsRequest, callback: grpc.requestCallback): grpc.ClientUnaryCall;
52 | tagAssets(argument: project_pb.TagAssetsRequest, metadataOrOptions: grpc.Metadata | grpc.CallOptions | null, callback: grpc.requestCallback): grpc.ClientUnaryCall;
53 | tagAssets(argument: project_pb.TagAssetsRequest, metadata: grpc.Metadata | null, options: grpc.CallOptions | null, callback: grpc.requestCallback): grpc.ClientUnaryCall;
54 | untagAssets(argument: project_pb.UntagAssetsRequest, callback: grpc.requestCallback): grpc.ClientUnaryCall;
55 | untagAssets(argument: project_pb.UntagAssetsRequest, metadataOrOptions: grpc.Metadata | grpc.CallOptions | null, callback: grpc.requestCallback): grpc.ClientUnaryCall;
56 | untagAssets(argument: project_pb.UntagAssetsRequest, metadata: grpc.Metadata | null, options: grpc.CallOptions | null, callback: grpc.requestCallback): grpc.ClientUnaryCall;
57 | queryAssets(argument: project_pb.QueryAssetsRequest, callback: grpc.requestCallback): grpc.ClientUnaryCall;
58 | queryAssets(argument: project_pb.QueryAssetsRequest, metadataOrOptions: grpc.Metadata | grpc.CallOptions | null, callback: grpc.requestCallback): grpc.ClientUnaryCall;
59 | queryAssets(argument: project_pb.QueryAssetsRequest, metadata: grpc.Metadata | null, options: grpc.CallOptions | null, callback: grpc.requestCallback): grpc.ClientUnaryCall;
60 | deleteAssets(argument: project_pb.DeleteAssetsRequest, callback: grpc.requestCallback): grpc.ClientUnaryCall;
61 | deleteAssets(argument: project_pb.DeleteAssetsRequest, metadataOrOptions: grpc.Metadata | grpc.CallOptions | null, callback: grpc.requestCallback): grpc.ClientUnaryCall;
62 | deleteAssets(argument: project_pb.DeleteAssetsRequest, metadata: grpc.Metadata | null, options: grpc.CallOptions | null, callback: grpc.requestCallback): grpc.ClientUnaryCall;
63 | }
64 |
--------------------------------------------------------------------------------
/gooseai/project/project_grpc_pb.js:
--------------------------------------------------------------------------------
1 | // GENERATED CODE -- DO NOT EDIT!
2 |
3 | 'use strict';
4 | var grpc = require('grpc');
5 | var project_pb = require('./project_pb.js');
6 | var generation_pb = require('./generation_pb.js');
7 |
8 | function serialize_gooseai_CreateProjectRequest(arg) {
9 | if (!(arg instanceof project_pb.CreateProjectRequest)) {
10 | throw new Error('Expected argument of type gooseai.CreateProjectRequest');
11 | }
12 | return Buffer.from(arg.serializeBinary());
13 | }
14 |
15 | function deserialize_gooseai_CreateProjectRequest(buffer_arg) {
16 | return project_pb.CreateProjectRequest.deserializeBinary(new Uint8Array(buffer_arg));
17 | }
18 |
19 | function serialize_gooseai_DeleteAssetsRequest(arg) {
20 | if (!(arg instanceof project_pb.DeleteAssetsRequest)) {
21 | throw new Error('Expected argument of type gooseai.DeleteAssetsRequest');
22 | }
23 | return Buffer.from(arg.serializeBinary());
24 | }
25 |
26 | function deserialize_gooseai_DeleteAssetsRequest(buffer_arg) {
27 | return project_pb.DeleteAssetsRequest.deserializeBinary(new Uint8Array(buffer_arg));
28 | }
29 |
30 | function serialize_gooseai_DeleteAssetsResponse(arg) {
31 | if (!(arg instanceof project_pb.DeleteAssetsResponse)) {
32 | throw new Error('Expected argument of type gooseai.DeleteAssetsResponse');
33 | }
34 | return Buffer.from(arg.serializeBinary());
35 | }
36 |
37 | function deserialize_gooseai_DeleteAssetsResponse(buffer_arg) {
38 | return project_pb.DeleteAssetsResponse.deserializeBinary(new Uint8Array(buffer_arg));
39 | }
40 |
41 | function serialize_gooseai_DeleteProjectRequest(arg) {
42 | if (!(arg instanceof project_pb.DeleteProjectRequest)) {
43 | throw new Error('Expected argument of type gooseai.DeleteProjectRequest');
44 | }
45 | return Buffer.from(arg.serializeBinary());
46 | }
47 |
48 | function deserialize_gooseai_DeleteProjectRequest(buffer_arg) {
49 | return project_pb.DeleteProjectRequest.deserializeBinary(new Uint8Array(buffer_arg));
50 | }
51 |
52 | function serialize_gooseai_GetProjectRequest(arg) {
53 | if (!(arg instanceof project_pb.GetProjectRequest)) {
54 | throw new Error('Expected argument of type gooseai.GetProjectRequest');
55 | }
56 | return Buffer.from(arg.serializeBinary());
57 | }
58 |
59 | function deserialize_gooseai_GetProjectRequest(buffer_arg) {
60 | return project_pb.GetProjectRequest.deserializeBinary(new Uint8Array(buffer_arg));
61 | }
62 |
63 | function serialize_gooseai_ListProjectRequest(arg) {
64 | if (!(arg instanceof project_pb.ListProjectRequest)) {
65 | throw new Error('Expected argument of type gooseai.ListProjectRequest');
66 | }
67 | return Buffer.from(arg.serializeBinary());
68 | }
69 |
70 | function deserialize_gooseai_ListProjectRequest(buffer_arg) {
71 | return project_pb.ListProjectRequest.deserializeBinary(new Uint8Array(buffer_arg));
72 | }
73 |
74 | function serialize_gooseai_Project(arg) {
75 | if (!(arg instanceof project_pb.Project)) {
76 | throw new Error('Expected argument of type gooseai.Project');
77 | }
78 | return Buffer.from(arg.serializeBinary());
79 | }
80 |
81 | function deserialize_gooseai_Project(buffer_arg) {
82 | return project_pb.Project.deserializeBinary(new Uint8Array(buffer_arg));
83 | }
84 |
85 | function serialize_gooseai_QueryAssetsRequest(arg) {
86 | if (!(arg instanceof project_pb.QueryAssetsRequest)) {
87 | throw new Error('Expected argument of type gooseai.QueryAssetsRequest');
88 | }
89 | return Buffer.from(arg.serializeBinary());
90 | }
91 |
92 | function deserialize_gooseai_QueryAssetsRequest(buffer_arg) {
93 | return project_pb.QueryAssetsRequest.deserializeBinary(new Uint8Array(buffer_arg));
94 | }
95 |
96 | function serialize_gooseai_QueryAssetsResponse(arg) {
97 | if (!(arg instanceof project_pb.QueryAssetsResponse)) {
98 | throw new Error('Expected argument of type gooseai.QueryAssetsResponse');
99 | }
100 | return Buffer.from(arg.serializeBinary());
101 | }
102 |
103 | function deserialize_gooseai_QueryAssetsResponse(buffer_arg) {
104 | return project_pb.QueryAssetsResponse.deserializeBinary(new Uint8Array(buffer_arg));
105 | }
106 |
107 | function serialize_gooseai_TagAssetsRequest(arg) {
108 | if (!(arg instanceof project_pb.TagAssetsRequest)) {
109 | throw new Error('Expected argument of type gooseai.TagAssetsRequest');
110 | }
111 | return Buffer.from(arg.serializeBinary());
112 | }
113 |
114 | function deserialize_gooseai_TagAssetsRequest(buffer_arg) {
115 | return project_pb.TagAssetsRequest.deserializeBinary(new Uint8Array(buffer_arg));
116 | }
117 |
118 | function serialize_gooseai_TagAssetsResponse(arg) {
119 | if (!(arg instanceof project_pb.TagAssetsResponse)) {
120 | throw new Error('Expected argument of type gooseai.TagAssetsResponse');
121 | }
122 | return Buffer.from(arg.serializeBinary());
123 | }
124 |
125 | function deserialize_gooseai_TagAssetsResponse(buffer_arg) {
126 | return project_pb.TagAssetsResponse.deserializeBinary(new Uint8Array(buffer_arg));
127 | }
128 |
129 | function serialize_gooseai_UntagAssetsRequest(arg) {
130 | if (!(arg instanceof project_pb.UntagAssetsRequest)) {
131 | throw new Error('Expected argument of type gooseai.UntagAssetsRequest');
132 | }
133 | return Buffer.from(arg.serializeBinary());
134 | }
135 |
136 | function deserialize_gooseai_UntagAssetsRequest(buffer_arg) {
137 | return project_pb.UntagAssetsRequest.deserializeBinary(new Uint8Array(buffer_arg));
138 | }
139 |
140 | function serialize_gooseai_UntagAssetsResponse(arg) {
141 | if (!(arg instanceof project_pb.UntagAssetsResponse)) {
142 | throw new Error('Expected argument of type gooseai.UntagAssetsResponse');
143 | }
144 | return Buffer.from(arg.serializeBinary());
145 | }
146 |
147 | function deserialize_gooseai_UntagAssetsResponse(buffer_arg) {
148 | return project_pb.UntagAssetsResponse.deserializeBinary(new Uint8Array(buffer_arg));
149 | }
150 |
151 | function serialize_gooseai_UpdateProjectRequest(arg) {
152 | if (!(arg instanceof project_pb.UpdateProjectRequest)) {
153 | throw new Error('Expected argument of type gooseai.UpdateProjectRequest');
154 | }
155 | return Buffer.from(arg.serializeBinary());
156 | }
157 |
158 | function deserialize_gooseai_UpdateProjectRequest(buffer_arg) {
159 | return project_pb.UpdateProjectRequest.deserializeBinary(new Uint8Array(buffer_arg));
160 | }
161 |
162 |
163 | //
164 | // gRPC services
165 | //
166 | var ProjectServiceService = exports.ProjectServiceService = {
167 | // Create a new project if it does not exist
168 | create: {
169 | path: '/gooseai.ProjectService/Create',
170 | requestStream: false,
171 | responseStream: false,
172 | requestType: project_pb.CreateProjectRequest,
173 | responseType: project_pb.Project,
174 | requestSerialize: serialize_gooseai_CreateProjectRequest,
175 | requestDeserialize: deserialize_gooseai_CreateProjectRequest,
176 | responseSerialize: serialize_gooseai_Project,
177 | responseDeserialize: deserialize_gooseai_Project,
178 | },
179 | // Update an existing project
180 | update: {
181 | path: '/gooseai.ProjectService/Update',
182 | requestStream: false,
183 | responseStream: false,
184 | requestType: project_pb.UpdateProjectRequest,
185 | responseType: project_pb.Project,
186 | requestSerialize: serialize_gooseai_UpdateProjectRequest,
187 | requestDeserialize: deserialize_gooseai_UpdateProjectRequest,
188 | responseSerialize: serialize_gooseai_Project,
189 | responseDeserialize: deserialize_gooseai_Project,
190 | },
191 | // List all the projects for an organization
192 | list: {
193 | path: '/gooseai.ProjectService/List',
194 | requestStream: false,
195 | responseStream: true,
196 | requestType: project_pb.ListProjectRequest,
197 | responseType: project_pb.Project,
198 | requestSerialize: serialize_gooseai_ListProjectRequest,
199 | requestDeserialize: deserialize_gooseai_ListProjectRequest,
200 | responseSerialize: serialize_gooseai_Project,
201 | responseDeserialize: deserialize_gooseai_Project,
202 | },
203 | // Get a project
204 | get: {
205 | path: '/gooseai.ProjectService/Get',
206 | requestStream: false,
207 | responseStream: false,
208 | requestType: project_pb.GetProjectRequest,
209 | responseType: project_pb.Project,
210 | requestSerialize: serialize_gooseai_GetProjectRequest,
211 | requestDeserialize: deserialize_gooseai_GetProjectRequest,
212 | responseSerialize: serialize_gooseai_Project,
213 | responseDeserialize: deserialize_gooseai_Project,
214 | },
215 | // Delete a project
216 | delete: {
217 | path: '/gooseai.ProjectService/Delete',
218 | requestStream: false,
219 | responseStream: false,
220 | requestType: project_pb.DeleteProjectRequest,
221 | responseType: project_pb.Project,
222 | requestSerialize: serialize_gooseai_DeleteProjectRequest,
223 | requestDeserialize: deserialize_gooseai_DeleteProjectRequest,
224 | responseSerialize: serialize_gooseai_Project,
225 | responseDeserialize: deserialize_gooseai_Project,
226 | },
227 | // Add or remove tags from an asset
228 | tagAssets: {
229 | path: '/gooseai.ProjectService/TagAssets',
230 | requestStream: false,
231 | responseStream: false,
232 | requestType: project_pb.TagAssetsRequest,
233 | responseType: project_pb.TagAssetsResponse,
234 | requestSerialize: serialize_gooseai_TagAssetsRequest,
235 | requestDeserialize: deserialize_gooseai_TagAssetsRequest,
236 | responseSerialize: serialize_gooseai_TagAssetsResponse,
237 | responseDeserialize: deserialize_gooseai_TagAssetsResponse,
238 | },
239 | untagAssets: {
240 | path: '/gooseai.ProjectService/UntagAssets',
241 | requestStream: false,
242 | responseStream: false,
243 | requestType: project_pb.UntagAssetsRequest,
244 | responseType: project_pb.UntagAssetsResponse,
245 | requestSerialize: serialize_gooseai_UntagAssetsRequest,
246 | requestDeserialize: deserialize_gooseai_UntagAssetsRequest,
247 | responseSerialize: serialize_gooseai_UntagAssetsResponse,
248 | responseDeserialize: deserialize_gooseai_UntagAssetsResponse,
249 | },
250 | // Query the assets of a project, with additional filtering
251 | queryAssets: {
252 | path: '/gooseai.ProjectService/QueryAssets',
253 | requestStream: false,
254 | responseStream: false,
255 | requestType: project_pb.QueryAssetsRequest,
256 | responseType: project_pb.QueryAssetsResponse,
257 | requestSerialize: serialize_gooseai_QueryAssetsRequest,
258 | requestDeserialize: deserialize_gooseai_QueryAssetsRequest,
259 | responseSerialize: serialize_gooseai_QueryAssetsResponse,
260 | responseDeserialize: deserialize_gooseai_QueryAssetsResponse,
261 | },
262 | // Delete one or more assets of a project
263 | deleteAssets: {
264 | path: '/gooseai.ProjectService/DeleteAssets',
265 | requestStream: false,
266 | responseStream: false,
267 | requestType: project_pb.DeleteAssetsRequest,
268 | responseType: project_pb.DeleteAssetsResponse,
269 | requestSerialize: serialize_gooseai_DeleteAssetsRequest,
270 | requestDeserialize: deserialize_gooseai_DeleteAssetsRequest,
271 | responseSerialize: serialize_gooseai_DeleteAssetsResponse,
272 | responseDeserialize: deserialize_gooseai_DeleteAssetsResponse,
273 | },
274 | };
275 |
276 | exports.ProjectServiceClient = grpc.makeGenericClientConstructor(ProjectServiceService);
277 |
--------------------------------------------------------------------------------
/gooseai/project/project_pb_service.d.ts:
--------------------------------------------------------------------------------
1 | // package: gooseai
2 | // file: project.proto
3 |
4 | import * as project_pb from "./project_pb";
5 | import {grpc} from "@improbable-eng/grpc-web";
6 |
7 | type ProjectServiceCreate = {
8 | readonly methodName: string;
9 | readonly service: typeof ProjectService;
10 | readonly requestStream: false;
11 | readonly responseStream: false;
12 | readonly requestType: typeof project_pb.CreateProjectRequest;
13 | readonly responseType: typeof project_pb.Project;
14 | };
15 |
16 | type ProjectServiceUpdate = {
17 | readonly methodName: string;
18 | readonly service: typeof ProjectService;
19 | readonly requestStream: false;
20 | readonly responseStream: false;
21 | readonly requestType: typeof project_pb.UpdateProjectRequest;
22 | readonly responseType: typeof project_pb.Project;
23 | };
24 |
25 | type ProjectServiceList = {
26 | readonly methodName: string;
27 | readonly service: typeof ProjectService;
28 | readonly requestStream: false;
29 | readonly responseStream: true;
30 | readonly requestType: typeof project_pb.ListProjectRequest;
31 | readonly responseType: typeof project_pb.Project;
32 | };
33 |
34 | type ProjectServiceGet = {
35 | readonly methodName: string;
36 | readonly service: typeof ProjectService;
37 | readonly requestStream: false;
38 | readonly responseStream: false;
39 | readonly requestType: typeof project_pb.GetProjectRequest;
40 | readonly responseType: typeof project_pb.Project;
41 | };
42 |
43 | type ProjectServiceDelete = {
44 | readonly methodName: string;
45 | readonly service: typeof ProjectService;
46 | readonly requestStream: false;
47 | readonly responseStream: false;
48 | readonly requestType: typeof project_pb.DeleteProjectRequest;
49 | readonly responseType: typeof project_pb.Project;
50 | };
51 |
52 | type ProjectServiceTagAssets = {
53 | readonly methodName: string;
54 | readonly service: typeof ProjectService;
55 | readonly requestStream: false;
56 | readonly responseStream: false;
57 | readonly requestType: typeof project_pb.TagAssetsRequest;
58 | readonly responseType: typeof project_pb.TagAssetsResponse;
59 | };
60 |
61 | type ProjectServiceUntagAssets = {
62 | readonly methodName: string;
63 | readonly service: typeof ProjectService;
64 | readonly requestStream: false;
65 | readonly responseStream: false;
66 | readonly requestType: typeof project_pb.UntagAssetsRequest;
67 | readonly responseType: typeof project_pb.UntagAssetsResponse;
68 | };
69 |
70 | type ProjectServiceQueryAssets = {
71 | readonly methodName: string;
72 | readonly service: typeof ProjectService;
73 | readonly requestStream: false;
74 | readonly responseStream: false;
75 | readonly requestType: typeof project_pb.QueryAssetsRequest;
76 | readonly responseType: typeof project_pb.QueryAssetsResponse;
77 | };
78 |
79 | type ProjectServiceDeleteAssets = {
80 | readonly methodName: string;
81 | readonly service: typeof ProjectService;
82 | readonly requestStream: false;
83 | readonly responseStream: false;
84 | readonly requestType: typeof project_pb.DeleteAssetsRequest;
85 | readonly responseType: typeof project_pb.DeleteAssetsResponse;
86 | };
87 |
88 | export class ProjectService {
89 | static readonly serviceName: string;
90 | static readonly Create: ProjectServiceCreate;
91 | static readonly Update: ProjectServiceUpdate;
92 | static readonly List: ProjectServiceList;
93 | static readonly Get: ProjectServiceGet;
94 | static readonly Delete: ProjectServiceDelete;
95 | static readonly TagAssets: ProjectServiceTagAssets;
96 | static readonly UntagAssets: ProjectServiceUntagAssets;
97 | static readonly QueryAssets: ProjectServiceQueryAssets;
98 | static readonly DeleteAssets: ProjectServiceDeleteAssets;
99 | }
100 |
101 | export type ServiceError = { message: string, code: number; metadata: grpc.Metadata }
102 | export type Status = { details: string, code: number; metadata: grpc.Metadata }
103 |
104 | interface UnaryResponse {
105 | cancel(): void;
106 | }
107 | interface ResponseStream {
108 | cancel(): void;
109 | on(type: 'data', handler: (message: T) => void): ResponseStream;
110 | on(type: 'end', handler: (status?: Status) => void): ResponseStream;
111 | on(type: 'status', handler: (status: Status) => void): ResponseStream;
112 | }
113 | interface RequestStream {
114 | write(message: T): RequestStream;
115 | end(): void;
116 | cancel(): void;
117 | on(type: 'end', handler: (status?: Status) => void): RequestStream;
118 | on(type: 'status', handler: (status: Status) => void): RequestStream;
119 | }
120 | interface BidirectionalStream {
121 | write(message: ReqT): BidirectionalStream;
122 | end(): void;
123 | cancel(): void;
124 | on(type: 'data', handler: (message: ResT) => void): BidirectionalStream;
125 | on(type: 'end', handler: (status?: Status) => void): BidirectionalStream;
126 | on(type: 'status', handler: (status: Status) => void): BidirectionalStream;
127 | }
128 |
129 | export class ProjectServiceClient {
130 | readonly serviceHost: string;
131 |
132 | constructor(serviceHost: string, options?: grpc.RpcOptions);
133 | create(
134 | requestMessage: project_pb.CreateProjectRequest,
135 | metadata: grpc.Metadata,
136 | callback: (error: ServiceError|null, responseMessage: project_pb.Project|null) => void
137 | ): UnaryResponse;
138 | create(
139 | requestMessage: project_pb.CreateProjectRequest,
140 | callback: (error: ServiceError|null, responseMessage: project_pb.Project|null) => void
141 | ): UnaryResponse;
142 | update(
143 | requestMessage: project_pb.UpdateProjectRequest,
144 | metadata: grpc.Metadata,
145 | callback: (error: ServiceError|null, responseMessage: project_pb.Project|null) => void
146 | ): UnaryResponse;
147 | update(
148 | requestMessage: project_pb.UpdateProjectRequest,
149 | callback: (error: ServiceError|null, responseMessage: project_pb.Project|null) => void
150 | ): UnaryResponse;
151 | list(requestMessage: project_pb.ListProjectRequest, metadata?: grpc.Metadata): ResponseStream;
152 | get(
153 | requestMessage: project_pb.GetProjectRequest,
154 | metadata: grpc.Metadata,
155 | callback: (error: ServiceError|null, responseMessage: project_pb.Project|null) => void
156 | ): UnaryResponse;
157 | get(
158 | requestMessage: project_pb.GetProjectRequest,
159 | callback: (error: ServiceError|null, responseMessage: project_pb.Project|null) => void
160 | ): UnaryResponse;
161 | delete(
162 | requestMessage: project_pb.DeleteProjectRequest,
163 | metadata: grpc.Metadata,
164 | callback: (error: ServiceError|null, responseMessage: project_pb.Project|null) => void
165 | ): UnaryResponse;
166 | delete(
167 | requestMessage: project_pb.DeleteProjectRequest,
168 | callback: (error: ServiceError|null, responseMessage: project_pb.Project|null) => void
169 | ): UnaryResponse;
170 | tagAssets(
171 | requestMessage: project_pb.TagAssetsRequest,
172 | metadata: grpc.Metadata,
173 | callback: (error: ServiceError|null, responseMessage: project_pb.TagAssetsResponse|null) => void
174 | ): UnaryResponse;
175 | tagAssets(
176 | requestMessage: project_pb.TagAssetsRequest,
177 | callback: (error: ServiceError|null, responseMessage: project_pb.TagAssetsResponse|null) => void
178 | ): UnaryResponse;
179 | untagAssets(
180 | requestMessage: project_pb.UntagAssetsRequest,
181 | metadata: grpc.Metadata,
182 | callback: (error: ServiceError|null, responseMessage: project_pb.UntagAssetsResponse|null) => void
183 | ): UnaryResponse;
184 | untagAssets(
185 | requestMessage: project_pb.UntagAssetsRequest,
186 | callback: (error: ServiceError|null, responseMessage: project_pb.UntagAssetsResponse|null) => void
187 | ): UnaryResponse;
188 | queryAssets(
189 | requestMessage: project_pb.QueryAssetsRequest,
190 | metadata: grpc.Metadata,
191 | callback: (error: ServiceError|null, responseMessage: project_pb.QueryAssetsResponse|null) => void
192 | ): UnaryResponse;
193 | queryAssets(
194 | requestMessage: project_pb.QueryAssetsRequest,
195 | callback: (error: ServiceError|null, responseMessage: project_pb.QueryAssetsResponse|null) => void
196 | ): UnaryResponse;
197 | deleteAssets(
198 | requestMessage: project_pb.DeleteAssetsRequest,
199 | metadata: grpc.Metadata,
200 | callback: (error: ServiceError|null, responseMessage: project_pb.DeleteAssetsResponse|null) => void
201 | ): UnaryResponse;
202 | deleteAssets(
203 | requestMessage: project_pb.DeleteAssetsRequest,
204 | callback: (error: ServiceError|null, responseMessage: project_pb.DeleteAssetsResponse|null) => void
205 | ): UnaryResponse;
206 | }
207 |
208 |
--------------------------------------------------------------------------------
/gooseai/project/project_pb_service.js:
--------------------------------------------------------------------------------
1 | // package: gooseai
2 | // file: project.proto
3 |
4 | var project_pb = require("./project_pb");
5 | var grpc = require("@improbable-eng/grpc-web").grpc;
6 |
7 | var ProjectService = (function () {
8 | function ProjectService() {}
9 | ProjectService.serviceName = "gooseai.ProjectService";
10 | return ProjectService;
11 | }());
12 |
13 | ProjectService.Create = {
14 | methodName: "Create",
15 | service: ProjectService,
16 | requestStream: false,
17 | responseStream: false,
18 | requestType: project_pb.CreateProjectRequest,
19 | responseType: project_pb.Project
20 | };
21 |
22 | ProjectService.Update = {
23 | methodName: "Update",
24 | service: ProjectService,
25 | requestStream: false,
26 | responseStream: false,
27 | requestType: project_pb.UpdateProjectRequest,
28 | responseType: project_pb.Project
29 | };
30 |
31 | ProjectService.List = {
32 | methodName: "List",
33 | service: ProjectService,
34 | requestStream: false,
35 | responseStream: true,
36 | requestType: project_pb.ListProjectRequest,
37 | responseType: project_pb.Project
38 | };
39 |
40 | ProjectService.Get = {
41 | methodName: "Get",
42 | service: ProjectService,
43 | requestStream: false,
44 | responseStream: false,
45 | requestType: project_pb.GetProjectRequest,
46 | responseType: project_pb.Project
47 | };
48 |
49 | ProjectService.Delete = {
50 | methodName: "Delete",
51 | service: ProjectService,
52 | requestStream: false,
53 | responseStream: false,
54 | requestType: project_pb.DeleteProjectRequest,
55 | responseType: project_pb.Project
56 | };
57 |
58 | ProjectService.TagAssets = {
59 | methodName: "TagAssets",
60 | service: ProjectService,
61 | requestStream: false,
62 | responseStream: false,
63 | requestType: project_pb.TagAssetsRequest,
64 | responseType: project_pb.TagAssetsResponse
65 | };
66 |
67 | ProjectService.UntagAssets = {
68 | methodName: "UntagAssets",
69 | service: ProjectService,
70 | requestStream: false,
71 | responseStream: false,
72 | requestType: project_pb.UntagAssetsRequest,
73 | responseType: project_pb.UntagAssetsResponse
74 | };
75 |
76 | ProjectService.QueryAssets = {
77 | methodName: "QueryAssets",
78 | service: ProjectService,
79 | requestStream: false,
80 | responseStream: false,
81 | requestType: project_pb.QueryAssetsRequest,
82 | responseType: project_pb.QueryAssetsResponse
83 | };
84 |
85 | ProjectService.DeleteAssets = {
86 | methodName: "DeleteAssets",
87 | service: ProjectService,
88 | requestStream: false,
89 | responseStream: false,
90 | requestType: project_pb.DeleteAssetsRequest,
91 | responseType: project_pb.DeleteAssetsResponse
92 | };
93 |
94 | exports.ProjectService = ProjectService;
95 |
96 | function ProjectServiceClient(serviceHost, options) {
97 | this.serviceHost = serviceHost;
98 | this.options = options || {};
99 | }
100 |
101 | ProjectServiceClient.prototype.create = function create(requestMessage, metadata, callback) {
102 | if (arguments.length === 2) {
103 | callback = arguments[1];
104 | }
105 | var client = grpc.unary(ProjectService.Create, {
106 | request: requestMessage,
107 | host: this.serviceHost,
108 | metadata: metadata,
109 | transport: this.options.transport,
110 | debug: this.options.debug,
111 | onEnd: function (response) {
112 | if (callback) {
113 | if (response.status !== grpc.Code.OK) {
114 | var err = new Error(response.statusMessage);
115 | err.code = response.status;
116 | err.metadata = response.trailers;
117 | callback(err, null);
118 | } else {
119 | callback(null, response.message);
120 | }
121 | }
122 | }
123 | });
124 | return {
125 | cancel: function () {
126 | callback = null;
127 | client.close();
128 | }
129 | };
130 | };
131 |
132 | ProjectServiceClient.prototype.update = function update(requestMessage, metadata, callback) {
133 | if (arguments.length === 2) {
134 | callback = arguments[1];
135 | }
136 | var client = grpc.unary(ProjectService.Update, {
137 | request: requestMessage,
138 | host: this.serviceHost,
139 | metadata: metadata,
140 | transport: this.options.transport,
141 | debug: this.options.debug,
142 | onEnd: function (response) {
143 | if (callback) {
144 | if (response.status !== grpc.Code.OK) {
145 | var err = new Error(response.statusMessage);
146 | err.code = response.status;
147 | err.metadata = response.trailers;
148 | callback(err, null);
149 | } else {
150 | callback(null, response.message);
151 | }
152 | }
153 | }
154 | });
155 | return {
156 | cancel: function () {
157 | callback = null;
158 | client.close();
159 | }
160 | };
161 | };
162 |
163 | ProjectServiceClient.prototype.list = function list(requestMessage, metadata) {
164 | var listeners = {
165 | data: [],
166 | end: [],
167 | status: []
168 | };
169 | var client = grpc.invoke(ProjectService.List, {
170 | request: requestMessage,
171 | host: this.serviceHost,
172 | metadata: metadata,
173 | transport: this.options.transport,
174 | debug: this.options.debug,
175 | onMessage: function (responseMessage) {
176 | listeners.data.forEach(function (handler) {
177 | handler(responseMessage);
178 | });
179 | },
180 | onEnd: function (status, statusMessage, trailers) {
181 | listeners.status.forEach(function (handler) {
182 | handler({ code: status, details: statusMessage, metadata: trailers });
183 | });
184 | listeners.end.forEach(function (handler) {
185 | handler({ code: status, details: statusMessage, metadata: trailers });
186 | });
187 | listeners = null;
188 | }
189 | });
190 | return {
191 | on: function (type, handler) {
192 | listeners[type].push(handler);
193 | return this;
194 | },
195 | cancel: function () {
196 | listeners = null;
197 | client.close();
198 | }
199 | };
200 | };
201 |
202 | ProjectServiceClient.prototype.get = function get(requestMessage, metadata, callback) {
203 | if (arguments.length === 2) {
204 | callback = arguments[1];
205 | }
206 | var client = grpc.unary(ProjectService.Get, {
207 | request: requestMessage,
208 | host: this.serviceHost,
209 | metadata: metadata,
210 | transport: this.options.transport,
211 | debug: this.options.debug,
212 | onEnd: function (response) {
213 | if (callback) {
214 | if (response.status !== grpc.Code.OK) {
215 | var err = new Error(response.statusMessage);
216 | err.code = response.status;
217 | err.metadata = response.trailers;
218 | callback(err, null);
219 | } else {
220 | callback(null, response.message);
221 | }
222 | }
223 | }
224 | });
225 | return {
226 | cancel: function () {
227 | callback = null;
228 | client.close();
229 | }
230 | };
231 | };
232 |
233 | ProjectServiceClient.prototype.delete = function pb_delete(requestMessage, metadata, callback) {
234 | if (arguments.length === 2) {
235 | callback = arguments[1];
236 | }
237 | var client = grpc.unary(ProjectService.Delete, {
238 | request: requestMessage,
239 | host: this.serviceHost,
240 | metadata: metadata,
241 | transport: this.options.transport,
242 | debug: this.options.debug,
243 | onEnd: function (response) {
244 | if (callback) {
245 | if (response.status !== grpc.Code.OK) {
246 | var err = new Error(response.statusMessage);
247 | err.code = response.status;
248 | err.metadata = response.trailers;
249 | callback(err, null);
250 | } else {
251 | callback(null, response.message);
252 | }
253 | }
254 | }
255 | });
256 | return {
257 | cancel: function () {
258 | callback = null;
259 | client.close();
260 | }
261 | };
262 | };
263 |
264 | ProjectServiceClient.prototype.tagAssets = function tagAssets(requestMessage, metadata, callback) {
265 | if (arguments.length === 2) {
266 | callback = arguments[1];
267 | }
268 | var client = grpc.unary(ProjectService.TagAssets, {
269 | request: requestMessage,
270 | host: this.serviceHost,
271 | metadata: metadata,
272 | transport: this.options.transport,
273 | debug: this.options.debug,
274 | onEnd: function (response) {
275 | if (callback) {
276 | if (response.status !== grpc.Code.OK) {
277 | var err = new Error(response.statusMessage);
278 | err.code = response.status;
279 | err.metadata = response.trailers;
280 | callback(err, null);
281 | } else {
282 | callback(null, response.message);
283 | }
284 | }
285 | }
286 | });
287 | return {
288 | cancel: function () {
289 | callback = null;
290 | client.close();
291 | }
292 | };
293 | };
294 |
295 | ProjectServiceClient.prototype.untagAssets = function untagAssets(requestMessage, metadata, callback) {
296 | if (arguments.length === 2) {
297 | callback = arguments[1];
298 | }
299 | var client = grpc.unary(ProjectService.UntagAssets, {
300 | request: requestMessage,
301 | host: this.serviceHost,
302 | metadata: metadata,
303 | transport: this.options.transport,
304 | debug: this.options.debug,
305 | onEnd: function (response) {
306 | if (callback) {
307 | if (response.status !== grpc.Code.OK) {
308 | var err = new Error(response.statusMessage);
309 | err.code = response.status;
310 | err.metadata = response.trailers;
311 | callback(err, null);
312 | } else {
313 | callback(null, response.message);
314 | }
315 | }
316 | }
317 | });
318 | return {
319 | cancel: function () {
320 | callback = null;
321 | client.close();
322 | }
323 | };
324 | };
325 |
326 | ProjectServiceClient.prototype.queryAssets = function queryAssets(requestMessage, metadata, callback) {
327 | if (arguments.length === 2) {
328 | callback = arguments[1];
329 | }
330 | var client = grpc.unary(ProjectService.QueryAssets, {
331 | request: requestMessage,
332 | host: this.serviceHost,
333 | metadata: metadata,
334 | transport: this.options.transport,
335 | debug: this.options.debug,
336 | onEnd: function (response) {
337 | if (callback) {
338 | if (response.status !== grpc.Code.OK) {
339 | var err = new Error(response.statusMessage);
340 | err.code = response.status;
341 | err.metadata = response.trailers;
342 | callback(err, null);
343 | } else {
344 | callback(null, response.message);
345 | }
346 | }
347 | }
348 | });
349 | return {
350 | cancel: function () {
351 | callback = null;
352 | client.close();
353 | }
354 | };
355 | };
356 |
357 | ProjectServiceClient.prototype.deleteAssets = function deleteAssets(requestMessage, metadata, callback) {
358 | if (arguments.length === 2) {
359 | callback = arguments[1];
360 | }
361 | var client = grpc.unary(ProjectService.DeleteAssets, {
362 | request: requestMessage,
363 | host: this.serviceHost,
364 | metadata: metadata,
365 | transport: this.options.transport,
366 | debug: this.options.debug,
367 | onEnd: function (response) {
368 | if (callback) {
369 | if (response.status !== grpc.Code.OK) {
370 | var err = new Error(response.statusMessage);
371 | err.code = response.status;
372 | err.metadata = response.trailers;
373 | callback(err, null);
374 | } else {
375 | callback(null, response.message);
376 | }
377 | }
378 | }
379 | });
380 | return {
381 | cancel: function () {
382 | callback = null;
383 | client.close();
384 | }
385 | };
386 | };
387 |
388 | exports.ProjectServiceClient = ProjectServiceClient;
389 |
390 |
--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
1 | {
2 | "name": "api-interfaces",
3 | "version": "0.1.0",
4 | "description": "",
5 | "main": "index.js",
6 | "scripts": {},
7 | "keywords": [],
8 | "author": "",
9 | "license": "",
10 | "dependencies": {
11 | "grpc-tools": "^1.11.2",
12 | "ts-protoc-gen": "^0.15.0"
13 | }
14 | }
--------------------------------------------------------------------------------
/requirements.txt:
--------------------------------------------------------------------------------
1 | grpcio==1.48.1
2 | grpcio-tools==1.48.1
3 | protobuf==3.19.5
4 |
--------------------------------------------------------------------------------
/samples/witch_noprob.json:
--------------------------------------------------------------------------------
1 | {
2 | "id": "cmpl-48crry2pOUoUtVxd2vJSursYcqhrj",
3 | "object": "text_completion",
4 | "created": 1637961379,
5 | "choices": [
6 | {
7 | "text": "The mercurial and beautiful witch laughed as she waved her wand, creating colorful bubbles that floated around her. \"It's a muggle fair!\" she exclaimed. \"And you're ... oh, you're adorable!\"\n\nHarry frowned as he ducked behind his friend. \"What's a muggle?\"\n\n\"You don't know what a",
8 | "index": 0,
9 | "logprobs": {
10 | "tokens": [
11 | "The",
12 | " merc",
13 | "ur",
14 | "ial",
15 | " and",
16 | " beautiful",
17 | " witch",
18 | " laughed",
19 | " as",
20 | " she",
21 | " waved",
22 | " her",
23 | " wand",
24 | ",",
25 | " creating",
26 | " colorful",
27 | " bubbles",
28 | " that",
29 | " floated",
30 | " around",
31 | " her",
32 | ".",
33 | " \"",
34 | "It",
35 | "'s",
36 | " a",
37 | " m",
38 | "uggle",
39 | " fair",
40 | "!\"",
41 | " she",
42 | " exclaimed",
43 | ".",
44 | " \"",
45 | "And",
46 | " you",
47 | "'re",
48 | " ...",
49 | " oh",
50 | ",",
51 | " you",
52 | "'re",
53 | " adorable",
54 | "!\"",
55 | "\n",
56 | "\n",
57 | "Harry",
58 | " frowned",
59 | " as",
60 | " he",
61 | " d",
62 | "ucked",
63 | " behind",
64 | " his",
65 | " friend",
66 | ".",
67 | " \"",
68 | "What",
69 | "'s",
70 | " a",
71 | " m",
72 | "uggle",
73 | "?\"",
74 | "\n",
75 | "\n",
76 | "\"",
77 | "You",
78 | " don",
79 | "'t",
80 | " know",
81 | " what",
82 | " a"
83 | ],
84 | "token_logprobs": [
85 | null,
86 | -10.987186,
87 | -0.71666235,
88 | -0.05154027,
89 | -4.2106233,
90 | -6.8736644,
91 | -7.8763485,
92 | -8.008118,
93 | -2.907369,
94 | -0.35576633,
95 | -4.8894453,
96 | -0.36318788,
97 | -0.9196957,
98 | -1.5668958,
99 | -3.6836884,
100 | -6.7724147,
101 | -2.6831,
102 | -0.83893436,
103 | -1.2555307,
104 | -1.532455,
105 | -1.3832833,
106 | -0.963496,
107 | -1.3439143,
108 | -3.3855555,
109 | -0.57608956,
110 | -2.1722336,
111 | -6.2369056,
112 | -0.09448118,
113 | -2.8567991,
114 | -5.022727,
115 | -1.104426,
116 | -1.3855448,
117 | -1.0346243,
118 | -0.46600902,
119 | -3.0332527,
120 | -2.375405,
121 | -1.3233099,
122 | -9.890566,
123 | -3.3423312,
124 | -0.88883483,
125 | -1.8411102,
126 | -0.30346137,
127 | -3.6947815,
128 | -1.0291778,
129 | -0.68579245,
130 | -9.7114484e-05,
131 | -2.315282,
132 | -3.3687363,
133 | -2.3542898,
134 | -0.38693583,
135 | -6.16344,
136 | -0.35217825,
137 | -2.122844,
138 | -1.7648246,
139 | -4.341085,
140 | -0.7969093,
141 | -0.41084018,
142 | -1.8209854,
143 | -1.1971861,
144 | -0.23019834,
145 | -0.12387496,
146 | -0.007885975,
147 | -0.23736298,
148 | -0.48618445,
149 | -6.6619094e-07,
150 | -0.7301654,
151 | -2.6885703,
152 | -1.4081082,
153 | -0.00060583797,
154 | -0.08347951,
155 | -1.055868,
156 | -0.10785947
157 | ],
158 | "top_logprobs": null,
159 | "text_offset": [
160 | 0,
161 | 3,
162 | 8,
163 | 10,
164 | 13,
165 | 17,
166 | 27,
167 | 33,
168 | 41,
169 | 44,
170 | 48,
171 | 54,
172 | 58,
173 | 63,
174 | 64,
175 | 73,
176 | 82,
177 | 90,
178 | 95,
179 | 103,
180 | 110,
181 | 114,
182 | 115,
183 | 117,
184 | 119,
185 | 121,
186 | 123,
187 | 125,
188 | 130,
189 | 135,
190 | 137,
191 | 141,
192 | 151,
193 | 152,
194 | 154,
195 | 157,
196 | 161,
197 | 164,
198 | 168,
199 | 171,
200 | 172,
201 | 176,
202 | 179,
203 | 188,
204 | 190,
205 | 191,
206 | 192,
207 | 197,
208 | 205,
209 | 208,
210 | 211,
211 | 213,
212 | 218,
213 | 225,
214 | 229,
215 | 236,
216 | 237,
217 | 239,
218 | 243,
219 | 245,
220 | 247,
221 | 249,
222 | 254,
223 | 256,
224 | 257,
225 | 258,
226 | 259,
227 | 262,
228 | 266,
229 | 268,
230 | 273,
231 | 278
232 | ]
233 | },
234 | "finish_reason": "length"
235 | }
236 | ],
237 | "model": "davinci:2020-05-03"
238 | }
--------------------------------------------------------------------------------
/src/bin/protoc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Stability-AI/api-interfaces/0c30849b5d12274b1858658df796366c06b8c3fa/src/bin/protoc
--------------------------------------------------------------------------------
/src/cmake/FindProtobufWithTargets.cmake:
--------------------------------------------------------------------------------
1 | # ~~~
2 | # Copyright 2019 Google LLC
3 | #
4 | # Licensed under the Apache License, Version 2.0 (the "License");
5 | # you may not use this file except in compliance with the License.
6 | # You may obtain a copy of the License at
7 | #
8 | # https://www.apache.org/licenses/LICENSE-2.0
9 | #
10 | # Unless required by applicable law or agreed to in writing, software
11 | # distributed under the License is distributed on an "AS IS" BASIS,
12 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | # See the License for the specific language governing permissions and
14 | # limitations under the License.
15 | # ~~~
16 |
17 | #[=======================================================================[.rst:
18 | FindProtobufWithTargets
19 | -------------------
20 |
21 | A module to use ``Protobuf`` with less complications.
22 |
23 | Using ``find_package(Protobuf)`` should be simple, but it is not.
24 |
25 | CMake provides a ``FindProtobuf`` module. Unfortunately it does not generate
26 | ``protobuf::*`` targets until CMake-3.9, and ``protobuf::protoc`` does not
27 | appear until CMake-3.10.
28 |
29 | The CMake-config files generated by ``protobuf`` always create these targets,
30 | but on some Linux distributions (e.g. Fedora>=29, and openSUSE-Tumbleweed) there
31 | are system packages for protobuf, but these packages are installed without the
32 | CMake-config files. One must either use the ``FindProtobuf`` module, find the
33 | libraries via ``pkg-config``, or find the libraries manually.
34 |
35 | When the CMake-config files are installed they produce the same targets as
36 | recent versions of ``FindProtobuf``. However, they do not produce the
37 | ``Protobuf_LIBRARY``, ``Protobuf_INCLUDE_DIR``, etc. that are generated by the
38 | module. Furthermore, the ``protobuf::protoc`` library is not usable when loaded
39 | from the CMake-config files: its ``IMPORTED_LOCATION`` variable is not defined.
40 |
41 | This module is designed to provide a single, uniform, ``find_package()``
42 | module that always produces the same outputs:
43 |
44 | - It always generates the ``protobuf::*`` targets.
45 | - It always defines ``ProtobufWithTargets_FOUND`` and
46 | ``ProtobufWithTargets_VERSION``.
47 | - It *prefers* using the CMake config files if they are available.
48 | - It fallsback on the ``FindProtobuf`` module if the config files are not found.
49 | - It populates any missing targets and their properties.
50 |
51 | The following ``IMPORTED`` targets are defined:
52 |
53 | ``protobuf::libprotobuf``
54 | The protobuf library.
55 | ``protobuf::libprotobuf-lite``
56 | The protobuf lite library.
57 | ``protobuf::libprotoc``
58 | The protoc library.
59 | ``protobuf::protoc``
60 | The protoc compiler.
61 |
62 | Example:
63 |
64 | .. code-block:: cmake
65 |
66 | find_package(ProtobufWithTargets REQUIRED)
67 | add_executable(bar bar.cc)
68 | target_link_libraries(bar PRIVATE protobuf::libprotobuf)
69 |
70 | #]=======================================================================]
71 |
72 | if (protobuf_DEBUG)
73 | message(STATUS "[ ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE} ] "
74 | "protobuf_USE_STATIC_LIBS = ${protobuf_USE_STATIC_LIBS}"
75 | " ProtobufWithTargets = ${ProtobufWithTargets_FOUND}")
76 | endif ()
77 |
78 | # Always load thread support, even on Windows.
79 | find_package(Threads REQUIRED)
80 |
81 | # First try to use the ``protobufConfig.cmake`` or ``protobuf-config.cmake``
82 | # file if it was installed. This is common on systems (or package managers)
83 | # where protobuf was compiled and installed with `CMake`. Note that on Linux
84 | # this *must* be all lowercase ``protobuf``, while on Windows it does not
85 | # matter.
86 | find_package(Protobuf CONFIG QUIET)
87 |
88 | if (protobuf_DEBUG)
89 | message(STATUS "[ ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE} ] "
90 | "Protobuf_FOUND = ${Protobuf_FOUND}"
91 | " Protobuf_VERSION = ${Protobuf_VERSION}")
92 | endif ()
93 |
94 | if (NOT Protobuf_FOUND)
95 | find_package(Protobuf QUIET)
96 | endif ()
97 |
98 | if (Protobuf_FOUND)
99 | set(ProtobufWithTargets_FOUND 1)
100 | set(ProtobufWithTargets_VERSION ${Protobuf_VERSION})
101 |
102 | if (NOT TARGET protobuf::libprotobuf)
103 | add_library(protobuf::libprotobuf INTERFACE IMPORTED)
104 | set_property(
105 | TARGET protobuf::libprotobuf PROPERTY INTERFACE_INCLUDE_DIRECTORIES
106 | ${Protobuf_INCLUDE_DIR})
107 | set_property(
108 | TARGET protobuf::libprotobuf
109 | APPEND
110 | PROPERTY INTERFACE_LINK_LIBRARIES ${Protobuf_LIBRARY}
111 | Threads::Threads)
112 | endif ()
113 |
114 | if (NOT TARGET protobuf::libprotobuf-lite)
115 | add_library(protobuf::libprotobuf-lite INTERFACE IMPORTED)
116 | set_property(
117 | TARGET protobuf::libprotobuf-lite
118 | PROPERTY INTERFACE_INCLUDE_DIRECTORIES ${Protobuf_INCLUDE_DIR})
119 | set_property(
120 | TARGET protobuf::libprotobuf-lite
121 | APPEND
122 | PROPERTY INTERFACE_LINK_LIBRARIES ${Protobuf_LITE_LIBRARY}
123 | Threads::Threads)
124 | endif ()
125 |
126 | if (NOT TARGET protobuf::libprotoc)
127 | add_library(protobuf::libprotoc INTERFACE IMPORTED)
128 | set_property(
129 | TARGET protobuf::libprotoc PROPERTY INTERFACE_INCLUDE_DIRECTORIES
130 | ${Protobuf_INCLUDE_DIR})
131 | set_property(
132 | TARGET protobuf::libprotoc
133 | APPEND
134 | PROPERTY INTERFACE_LINK_LIBRARIES ${Protobuf_PROTOC_LIBRARY}
135 | Threads::Threads)
136 | endif ()
137 |
138 | if (NOT TARGET protobuf::protoc)
139 | add_executable(protobuf::protoc IMPORTED)
140 |
141 | # Discover the protoc compiler location.
142 | find_program(
143 | _protobuf_PROTOC_EXECUTABLE
144 | NAMES protoc
145 | DOC "The Google Protocol Buffers Compiler")
146 | if (protobuf_DEBUG)
147 | message(
148 | STATUS
149 | "[ ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE} ] "
150 | "ProtobufWithTargets_FOUND = ${ProtobufWithTargets_FOUND}"
151 | " ProtobufWithTargets_VERSION = ${ProtobufWithTargets_VERSION}"
152 | " EXE = ${_protobuf_PROTOC_EXECUTABLE}")
153 | endif ()
154 | set_property(TARGET protobuf::protoc
155 | PROPERTY IMPORTED_LOCATION ${_protobuf_PROTOC_EXECUTABLE})
156 | set_property(
157 | TARGET protobuf::protoc PROPERTY IMPORTED_LOCATION_DEBUG
158 | ${_protobuf_PROTOC_EXECUTABLE})
159 | set_property(
160 | TARGET protobuf::protoc PROPERTY IMPORTED_LOCATION_RELEASE
161 | ${_protobuf_PROTOC_EXECUTABLE})
162 | unset(_protobuf_PROTOC_EXECUTABLE)
163 |
164 | if (protobuf_DEBUG)
165 | get_target_property(_protobuf_PROTOC_EXECUTABLE protobuf::protoc
166 | IMPORTED_LOCATION)
167 | message(
168 | STATUS
169 | "[ ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE} ] "
170 | "LOCATION=${_protobuf_PROTOC_EXECUTABLE}")
171 | endif ()
172 | endif ()
173 | endif ()
174 |
175 | if (protobuf_DEBUG)
176 | message(
177 | STATUS "[ ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE} ] "
178 | "ProtobufWithTargets_FOUND = ${ProtobufWithTargets_FOUND}"
179 | " ProtobufWithTargets_VERSION = ${ProtobufWithTargets_VERSION}")
180 | endif ()
181 |
182 | if (protobuf_DEBUG)
183 | message(
184 | STATUS "[ ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE} ] "
185 | "ProtobufWithTargets_FOUND = ${ProtobufWithTargets_FOUND}"
186 | " ProtobufWithTargets_VERSION = ${ProtobufWithTargets_VERSION}")
187 | if (ProtobufWithTargets_FOUND)
188 | foreach (_target protobuf::libprotobuf protobuf::libprotobuf-lite
189 | protobuf::libprotoc)
190 | if (NOT TARGET ${_target})
191 | message(
192 | STATUS
193 | "[ ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE} ] "
194 | "target=${_target} is NOT a target")
195 | endif ()
196 | endforeach ()
197 | unset(_target)
198 | endif ()
199 | endif ()
200 |
201 | find_package_handle_standard_args(
202 | ProtobufWithTargets REQUIRED_VARS ProtobufWithTargets_FOUND
203 | ProtobufWithTargets_VERSION)
204 |
--------------------------------------------------------------------------------
/src/proto/dashboard.proto:
--------------------------------------------------------------------------------
1 | syntax = 'proto3';
2 | package gooseai;
3 | option go_package = "github.com/stability-ai/api-interfaces/gooseai/dashboard";
4 |
5 | enum OrganizationRole {
6 | MEMBER = 0;
7 | ACCOUNTANT = 1;
8 | OWNER = 2;
9 | }
10 |
11 | message OrganizationMember {
12 | Organization organization = 1;
13 | optional User user = 2;
14 | OrganizationRole role = 3;
15 | bool is_default = 4;
16 | }
17 |
18 | message OrganizationGrant {
19 | double amount_granted = 1;
20 | double amount_used = 2;
21 | uint64 expires_at = 3;
22 | uint64 granted_at = 4;
23 | }
24 |
25 | message OrganizationPaymentInfo {
26 | double balance = 1;
27 | repeated OrganizationGrant grants = 2;
28 | }
29 |
30 | message OrganizationAutoCharge {
31 | bool enabled = 1;
32 | string id = 2;
33 | uint64 created_at = 3;
34 | }
35 |
36 | message Organization {
37 | string id = 1;
38 | string name = 2;
39 | string description = 3;
40 | repeated OrganizationMember members = 4;
41 | optional OrganizationPaymentInfo payment_info = 5;
42 | optional string stripe_customer_id = 6;
43 | optional OrganizationAutoCharge auto_charge = 7;
44 | }
45 |
46 | message APIKey {
47 | string key = 1;
48 | bool is_secret = 2;
49 | uint64 created_at = 3;
50 | }
51 |
52 | message User {
53 | string id = 1;
54 | optional string auth_id = 2;
55 | string profile_picture = 3;
56 | string email = 4;
57 | repeated OrganizationMember organizations = 5;
58 | repeated APIKey api_keys = 7;
59 | uint64 created_at = 8;
60 | optional bool email_verified = 9;
61 | optional bool accepted_latest_tos_version = 10;
62 | optional bool accepted_latest_privacy_policy_version = 11;
63 | optional bool accepted_any_tos_version = 12;
64 | optional bool accepted_any_privacy_policy_version = 13;
65 | optional bool training_opt_in = 14;
66 | }
67 |
68 | message CostData {
69 | uint32 amount_tokens = 1;
70 | double amount_credits = 2;
71 | }
72 |
73 | message UsageMetric {
74 | string operation = 1;
75 | string engine = 2;
76 | CostData input_cost = 3;
77 | CostData output_cost = 4;
78 | optional string user = 5;
79 | uint64 aggregation_timestamp = 6;
80 | }
81 |
82 | message CostTotal {
83 | uint32 amount_tokens = 1;
84 | double amount_credits = 2;
85 | }
86 |
87 | message TotalMetricsData {
88 | CostTotal input_total = 1;
89 | CostTotal output_total = 2;
90 | }
91 |
92 | message Metrics {
93 | repeated UsageMetric metrics = 1;
94 | TotalMetricsData total = 2;
95 | }
96 |
97 | message EmptyRequest {}
98 |
99 | message GetOrganizationRequest {
100 | string id = 1;
101 | }
102 |
103 | message GetMetricsRequest {
104 | string organization_id = 1;
105 | optional string user_id = 2;
106 | uint64 range_from = 3;
107 | uint64 range_to = 4;
108 | bool include_per_request_metrics = 5;
109 | }
110 |
111 | message APIKeyRequest {
112 | bool is_secret = 1;
113 | }
114 |
115 | message APIKeyFindRequest {
116 | string id = 1;
117 | }
118 |
119 | message AcceptLegalTermsRequest {
120 | optional bool marketing_opt_in = 1;
121 | }
122 |
123 | message AcceptLegalTermsResponse {
124 | // Whether this was successful or not
125 | bool success = 1;
126 | }
127 |
128 | message UpdateDefaultOrganizationRequest {
129 | string organization_id = 1;
130 | }
131 |
132 | message ClientSettings {
133 | bytes settings = 1;
134 | }
135 |
136 | message CreateAutoChargeIntentRequest {
137 | string organization_id = 1;
138 | uint64 monthly_maximum = 2;
139 | uint64 minimum_value = 3;
140 | uint64 amount_credits = 4;
141 | }
142 |
143 | message CreateChargeRequest {
144 | uint64 amount = 1;
145 | string organization_id = 2;
146 | }
147 |
148 | message GetChargesRequest {
149 | string organization_id = 1;
150 | uint64 range_from = 2;
151 | uint64 range_to = 3;
152 | }
153 |
154 | message Charge {
155 | string id = 1;
156 | bool paid = 2;
157 | string receipt_link = 3;
158 | string payment_link = 4;
159 | uint64 created_at = 5;
160 | uint64 amount_credits = 6;
161 | }
162 |
163 | message Charges {
164 | repeated Charge charges = 1;
165 | }
166 |
167 | message GetAutoChargeRequest {
168 | string organization_id = 1;
169 | }
170 |
171 | message AutoChargeIntent {
172 | string id = 1;
173 | string payment_link = 2;
174 | uint64 created_at = 3;
175 | uint64 monthly_maximum = 4;
176 | uint64 minimum_value = 5;
177 | uint64 amount_credits = 6;
178 | }
179 |
180 | message UpdateUserInfoRequest {
181 | optional string email = 1;
182 | }
183 |
184 | message UpdateUserPreferencesRequest {
185 | optional bool training_opt_in = 1;
186 | }
187 |
188 | message UserPasswordChangeTicket {
189 | string ticket = 1;
190 | }
191 |
192 | service DashboardService {
193 | // Get info
194 | rpc GetMe (EmptyRequest) returns (User);
195 | rpc GetOrganization (GetOrganizationRequest) returns (Organization);
196 | rpc GetMetrics (GetMetricsRequest) returns (Metrics);
197 |
198 | // API key management
199 | rpc CreateAPIKey (APIKeyRequest) returns (APIKey);
200 | rpc DeleteAPIKey (APIKeyFindRequest) returns (APIKey);
201 |
202 | // Legal and Marketing functions
203 | rpc AcceptLegalTerms (AcceptLegalTermsRequest) returns (AcceptLegalTermsResponse);
204 |
205 | // User settings
206 | rpc UpdateDefaultOrganization (UpdateDefaultOrganizationRequest) returns (User);
207 | rpc GetClientSettings (EmptyRequest) returns (ClientSettings);
208 | rpc SetClientSettings (ClientSettings) returns (ClientSettings);
209 | rpc UpdateUserInfo (UpdateUserInfoRequest) returns (User);
210 | rpc UpdateUserPreferences (UpdateUserPreferencesRequest) returns (User);
211 | rpc CreatePasswordChangeTicket (EmptyRequest) returns (UserPasswordChangeTicket);
212 | rpc DeleteAccount (EmptyRequest) returns (User);
213 |
214 | // Payment functions
215 | rpc CreateCharge (CreateChargeRequest) returns (Charge);
216 | rpc GetCharges (GetChargesRequest) returns (Charges);
217 | rpc CreateAutoChargeIntent (CreateAutoChargeIntentRequest) returns (AutoChargeIntent);
218 | rpc UpdateAutoChargeIntent (CreateAutoChargeIntentRequest) returns (AutoChargeIntent);
219 | rpc GetAutoChargeIntent (GetAutoChargeRequest) returns (AutoChargeIntent);
220 | }
221 |
--------------------------------------------------------------------------------
/src/proto/engines.proto:
--------------------------------------------------------------------------------
1 | syntax = 'proto3';
2 | package gooseai;
3 | option go_package = "github.com/stability-ai/api-interfaces/gooseai/engines";
4 |
5 | // Possible engine type
6 | enum EngineType {
7 | TEXT = 0;
8 | PICTURE = 1;
9 | AUDIO = 2;
10 | VIDEO = 3;
11 | CLASSIFICATION = 4;
12 | STORAGE = 5;
13 | }
14 |
15 | enum EngineTokenizer {
16 | GPT2 = 0;
17 | PILE = 1;
18 | }
19 |
20 | // Engine info struct
21 | message EngineInfo {
22 | string id = 1;
23 | string owner = 2;
24 | bool ready = 3;
25 | EngineType type = 4;
26 | EngineTokenizer tokenizer = 5;
27 | string name = 6;
28 | string description = 7;
29 | bool can_fine_tune = 8;
30 | bool is_adaptive = 9; // Whether this Engine supports T2I Adapters
31 | }
32 |
33 | message ListEnginesRequest {
34 | // Empty
35 | }
36 |
37 | // Engine info list
38 | message Engines {
39 | repeated EngineInfo engine = 1;
40 | }
41 |
42 | service EnginesService {
43 | rpc ListEngines (ListEnginesRequest) returns (Engines) {};
44 | }
45 |
--------------------------------------------------------------------------------
/src/proto/finetuning.proto:
--------------------------------------------------------------------------------
1 | syntax = "proto3";
2 | package gooseai;
3 |
4 | option go_package = "github.com/stability-ai/api-interfaces/gooseai/finetuning";
5 | import "google/protobuf/struct.proto";
6 |
7 | enum FineTuningMode {
8 | FINE_TUNING_MODE_UNSPECIFIED = 0; // No mode specified
9 | FINE_TUNING_MODE_FACE = 1; // Fine tuning a face model
10 | FINE_TUNING_MODE_STYLE = 2; // Fine tuning a style model
11 | FINE_TUNING_MODE_OBJECT = 3; // Fine tuning an object model
12 | }
13 |
14 | enum FineTuningStatus {
15 | FINE_TUNING_STATUS_NOT_STARTED = 0; // Model not yet started
16 | FINE_TUNING_STATUS_RUNNING = 1; // Model is currently running
17 | FINE_TUNING_STATUS_COMPLETED = 2; // Model has completed successfully
18 | FINE_TUNING_STATUS_FAILED = 3; // Model has failed
19 | FINE_TUNING_STATUS_SUBMITTED = 4; // Model has been submitted
20 | }
21 |
22 | message FineTuningModel {
23 | string id = 1; // ID of the model, UUIDv4
24 | string user_id = 2; // ID of user who created the model
25 | string name = 3; // a readable model name
26 | optional FineTuningMode mode = 4; // the mode of the model
27 | optional string object_prompt = 5; // freeform text description of object, should only be set when mode is OBJECT
28 | string project_id = 6; // project ID with assets to be used for fine tuning
29 | double duration = 7; // duration in seconds for how long the model took to train
30 | FineTuningStatus status = 8; // the current status of the model
31 | string engine_id = 9; // the engineId of a fine-tuneable Stability model
32 | optional string failure_reason = 10; // If a model's training failed, this will contain the reason
33 | }
34 |
35 | message CreateModelRequest {
36 | string name = 1; // a readable model name
37 | optional FineTuningMode mode = 2; // the mode of the model
38 | optional string object_prompt = 3; // freeform text description of object, should only be set when mode is OBJECT
39 | string project_id = 4; // the project_id with assets to be used for fine tuning
40 | string engine_id = 5; // the engineId of an fine-tuneable Stability model
41 | optional google.protobuf.Struct extras = 2047; // for development use
42 | }
43 |
44 | message CreateModelResponse {
45 | FineTuningModel model = 1;
46 | }
47 |
48 | message GetModelRequest {
49 | string id = 1; // ID of the model
50 | }
51 |
52 | message GetModelResponse {
53 | FineTuningModel model = 1;
54 | }
55 |
56 | message UpdateModelRequest{
57 | string id = 1; // the id of the model
58 | optional string name = 2; // a readable model name
59 | optional FineTuningMode mode = 3; // the mode of the model
60 | optional string object_prompt = 4; // freeform text description of object, should only be set when mode is OBJECT
61 | optional string engine_id = 5; // the engineId of an fine-tuneable Stability model
62 | }
63 |
64 | message UpdateModelResponse {
65 | FineTuningModel model = 1;
66 | }
67 |
68 | message DeleteModelRequest {
69 | string id = 1; // ID of the model to delete
70 | }
71 |
72 | message DeleteModelResponse {
73 | FineTuningModel model = 1;
74 | }
75 |
76 | message ResubmitModelRequest {
77 | string id = 1; // ID of the model to resubmit
78 | }
79 |
80 | message ResubmitModelResponse {
81 | FineTuningModel model = 1;
82 | }
83 |
84 | message ListModelsRequest {
85 | oneof id {
86 | string org_id = 1; // the organization's ID
87 | string user_id = 2; // or the user's ID
88 | }
89 | }
90 |
91 | message ListModelsResponse {
92 | repeated FineTuningModel models = 1; // the list of models
93 | }
94 |
95 | service FineTuningService {
96 | // Create a new model and begin the fine tuning process
97 | rpc CreateModel (CreateModelRequest) returns (CreateModelResponse);
98 | // Get a FineTuningModel
99 | rpc GetModel (GetModelRequest) returns (GetModelResponse);
100 | // Update a FineTuningModel by id
101 | rpc UpdateModel (UpdateModelRequest) returns (UpdateModelResponse);
102 | // Delete a fine tuned model
103 | rpc DeleteModel (DeleteModelRequest) returns (DeleteModelResponse);
104 | // Re-run training, does not create a new model
105 | rpc ResubmitModel (ResubmitModelRequest) returns (ResubmitModelResponse);
106 | // List all the fine tuned models for an organization or user
107 | rpc ListModels (ListModelsRequest) returns (ListModelsResponse);
108 | }
--------------------------------------------------------------------------------
/src/proto/project.proto:
--------------------------------------------------------------------------------
1 | syntax = 'proto3';
2 | package gooseai;
3 | option go_package = "github.com/stability-ai/api-interfaces/gooseai/project";
4 | import "generation.proto";
5 |
6 | enum ProjectAccess {
7 | PROJECT_ACCESS_PRIVATE = 0; // Private access, only owner organization can access
8 | PROJECT_ACCESS_PUBLIC = 1; // Public access, anyone can access
9 | }
10 |
11 | enum ProjectStatus {
12 | PROJECT_STATUS_INACTIVE = 0; // Inactive project
13 | PROJECT_STATUS_ACTIVE = 1; // Active project
14 | PROJECT_STATUS_DELETED = 2; // Deleted project, only set by delete endpoint
15 | }
16 |
17 | enum ProjectAssetUse {
18 | PROJECT_ASSET_USE_UNDEFINED = 0; // Asset does not have use defined
19 | PROJECT_ASSET_USE_INPUT = 1; // Asset is used as an input for the project
20 | PROJECT_ASSET_USE_OUTPUT = 2; // Asset is an output from the project
21 | PROJECT_ASSET_USE_INTERMEDIATE = 3; // Asset is an output from an intermediate step of the project
22 | PROJECT_ASSET_USE_PROJECT = 4; // Asset is used as the project file for the project
23 | }
24 |
25 | enum ProjectSortDir {
26 | PROJECT_SORT_DIR_UNSPECIFIED = 0; // Sort direction is not specified, uses default
27 | PROJECT_SORT_DIR_ASC = 1; // Sort in ascending order
28 | PROJECT_SORT_DIR_DESC = 2; // Sort in descending order
29 | }
30 |
31 | // The Type of Project being created
32 | enum ProjectType {
33 | PROJECT_TYPE_UNSPECIFIED = 0; // Zero-value, unspecified
34 | PROJECT_TYPE_TRAINING = 1; // Training project, used for Fine-Tuning models
35 | }
36 |
37 | message ProjectAsset {
38 | string id = 1; // ID of the asset, UUIDv4
39 | string uri = 2; // The URI to the asset
40 | ProjectAssetUse use = 3; // The use of the asset with respect to the project
41 | string name = 4; // The name of the asset
42 | uint64 size = 5; // The asset size in bytes
43 | uint64 created_at = 6; // Time of asset creation (UTC seconds epoch)
44 | uint64 updated_at = 7; // Time of last asset update (UTC seconds epoch)
45 | Request request = 8; // The request object that is associated with the artifact
46 | map tags = 9; // The tags associated with the asset
47 | }
48 |
49 | message Project {
50 | string id = 1; // ID of the project, UUIDv4
51 | string title = 2; // Title of the project
52 | string owner_id = 3; // The ID of the organization owning the project
53 | ProjectAccess access = 4; // The access of the project (such as public vs private)
54 | ProjectStatus status = 5; // The status of the project (such as active vs inactive)
55 | uint64 size = 6; // The size of the project in bytes
56 | ProjectAsset file = 7; // Project file for the project
57 | uint64 created_at = 8; // Time of project creation (UTC seconds epoch)
58 | uint64 updated_at = 9; // Time of last project update (UTC seconds epoch)
59 | repeated ProjectAsset assets = 10; // The listing of all assets associated with the project
60 | ProjectType type = 11; // The type of project
61 | }
62 |
63 | message CreateProjectRequest {
64 | string title = 1; // title of the project
65 | optional string owner_id = 2; // The ID of the organization owning the project, empty for default org for user
66 | ProjectAccess access = 3; // The access of the project (such as public vs private)
67 | ProjectStatus status = 4; // The status of the project (such as active vs inactive)
68 | optional ProjectAsset file = 5; // Project file for the project (if existing, else will create)
69 | ProjectType type = 6; // The type of project
70 | }
71 |
72 | message UpdateProjectRequest {
73 | string id = 1; // ID of the project, UUIDv4
74 | optional string owner_id = 2; // The ID of the organization owning the project, empty for default org for user
75 | optional string title = 3; // Title of the project
76 | optional ProjectAccess access = 4; // The access of the project (such as public vs private)
77 | optional ProjectStatus status = 5; // The status of the project (such as active vs inactive)
78 | optional ProjectAsset file = 6; // Project file for the project
79 | optional ProjectType type = 7; // The type of project
80 | }
81 |
82 | message ListProjectRequest {
83 | optional string owner_id = 1; // The ID of the organization owning the project, empty for default org for user
84 | }
85 |
86 | message GetProjectRequest {
87 | string id = 1; // ID of the project to request, UUIDv4, empty string uses default project
88 | optional string owner_id = 2; // The ID of the organization owning the project, empty for default org for user
89 | }
90 |
91 | message DeleteProjectRequest {
92 | string id = 1; // ID of the project to request, UUIDv4
93 | optional string owner_id = 2; // The ID of the organization owning the project, empty for default org for user
94 | }
95 |
96 | message QueryAssetsRequest {
97 | string id = 1; // ID of the project to request, UUIDv4, empty string uses default project
98 | optional string owner_id = 2; // The ID of the organization owning the assets, unset for default org for user
99 | optional uint64 since = 3; // The time (UTC seconds epoch) to start listing assets from, unset for no restriction
100 | optional uint64 until = 4; // The time (UTC seconds epoch) to stop listing assets at, unset for no restriction
101 | optional uint64 limit = 5; // The maximum number of assets to return, unset for no limit
102 | optional string start_key = 6; // The key to start from, used to paginate results, unset for no offset
103 | repeated ProjectAssetUse use = 7; // The asset usage to filter the assets returned, empty for no filter
104 | ProjectSortDir sort_dir = 8; // The sort direction based on asset creation time, default is descending
105 | map tags = 9; // The tag values used to filter the assets returned, empty for no filter
106 | }
107 |
108 | message QueryAssetsResponse {
109 | repeated ProjectAsset assets = 1; // The assets returned by the query
110 | optional string last_key = 2; // The last asset key returned when the results were limited, unset when not limited
111 | }
112 |
113 | message TagAssetsRequest {
114 | string id = 1; // ID of the project to request, UUIDv4, empty string uses default project
115 | optional string owner_id = 2; // The ID of the organization owning the assets, unset for default org for user
116 | repeated string asset_ids = 3; // The IDs of the assets to tag in the project, UUIDv4, limit 1000
117 | map tags = 4; // The tags to add to the assets
118 | }
119 |
120 | message TagAssetsResponse {
121 | string id = 1; // ID of the project, UUIDv4
122 | string owner_id = 2; // The ID of the organization owning the project
123 | repeated string asset_ids = 3; // The IDs of the assets updated in the project, UUIDv4, limit 1000
124 | }
125 |
126 | message UntagAssetsRequest {
127 | string id = 1; // ID of the project to request, UUIDv4, empty string uses default project
128 | optional string owner_id = 2; // The ID of the organization owning the assets, unset for default org for user
129 | repeated string asset_ids = 3; // The IDs of the assets to tag in the project, UUIDv4, limit 1000
130 | repeated string tag_keys = 4; // The keys of the tags to remove from the assets
131 | }
132 |
133 | message UntagAssetsResponse {
134 | string id = 1; // ID of the project, UUIDv4
135 | string owner_id = 2; // The ID of the organization owning the project
136 | repeated string asset_ids = 3; // The IDs of the assets updated in the project, UUIDv4, limit 1000
137 | }
138 |
139 | message DeleteAssetsRequest {
140 | string id = 1; // ID of the project to request, UUIDv4, empty string uses default project
141 | optional string owner_id = 2; // The ID of the organization owning the project, unset for default org for user
142 | repeated string asset_ids = 3; // The IDs of the assets to delete from the project, UUIDv4, limit 1000
143 | }
144 |
145 | message DeleteAssetsResponse {
146 | string id = 1; // ID of the project, UUIDv4
147 | string owner_id = 2; // The ID of the organization owning the project
148 | repeated string asset_ids = 3; // The IDs of the assets deleted from the project, UUIDv4, limit 1000
149 | }
150 |
151 | //
152 | // gRPC services
153 | //
154 | service ProjectService {
155 | // Create a new project if it does not exist
156 | rpc Create (CreateProjectRequest) returns (Project) {};
157 | // Update an existing project
158 | rpc Update (UpdateProjectRequest) returns (Project) {};
159 | // List all the projects for an organization
160 | rpc List (ListProjectRequest) returns (stream Project) {};
161 | // Get a project
162 | rpc Get (GetProjectRequest) returns (Project) {};
163 | // Delete a project
164 | rpc Delete (DeleteProjectRequest) returns (Project) {};
165 | // Add or remove tags from an asset
166 | rpc TagAssets (TagAssetsRequest) returns (TagAssetsResponse) {};
167 | rpc UntagAssets (UntagAssetsRequest) returns (UntagAssetsResponse) {};
168 | // Query the assets of a project, with additional filtering
169 | rpc QueryAssets (QueryAssetsRequest) returns (QueryAssetsResponse) {};
170 | // Delete one or more assets of a project
171 | rpc DeleteAssets (DeleteAssetsRequest) returns (DeleteAssetsResponse) {};
172 | }
173 |
--------------------------------------------------------------------------------
/update.sh:
--------------------------------------------------------------------------------
1 | # Update the API interfaces generated code files
2 | docker build -t api_interfaces .
3 |
4 | # Start a container based on the "api_interfaces" image
5 | docker run --name api_interfaces -d api_interfaces
6 |
7 | # Copy the files in the "/gooseai" directory out from the container
8 | docker cp api_interfaces:/gooseai .
9 |
10 | # Stop and remove the container
11 | docker stop api_interfaces
12 | docker rm api_interfaces
13 |
--------------------------------------------------------------------------------