From 66f0846d564579e3df9f5c79e6d61e2cb496c96f Mon Sep 17 00:00:00 2001 From: SimFG <1142838399@qq.com> Date: Wed, 3 Apr 2024 17:41:39 +0800 Subject: [PATCH] add the milvus connector and cli lib --- .gitignore | 6 +- README.md | 162 + README_CN.md | 162 + all_proto/README.md | 15 + all_proto/common.proto | 462 +++ all_proto/data_coord.proto | 912 ++++++ all_proto/etcd_meta.proto | 127 + all_proto/feder.proto | 40 + all_proto/index_cgo_msg.proto | 32 + all_proto/index_coord.proto | 345 ++ all_proto/internal.proto | 333 ++ all_proto/milvus.proto | 1835 +++++++++++ all_proto/msg.proto | 108 + all_proto/plan.proto | 211 ++ all_proto/proxy.proto | 80 + all_proto/query_coord.proto | 769 +++++ all_proto/rg.proto | 29 + all_proto/root_coord.proto | 226 ++ all_proto/schema.proto | 196 ++ all_proto/segcore.proto | 45 + app/milvus-cli/.DS_Store | Bin 0 -> 6148 bytes app/milvus-cli/README.md | 0 app/milvus-cli/mucli/__init__.py | 0 app/milvus-cli/mucli/_milvus.py | 1030 ++++++ app/milvus-cli/mucli/_option.py | 175 + app/milvus-cli/mucli/main.py | 11 + app/milvus-cli/mucli/pyinstaller.py | 16 + app/milvus-cli/poetry.lock | 518 +++ app/milvus-cli/pyproject.toml | 23 + app/milvus-cli/tests/__init__.py | 0 app/milvus-http/README.md | 0 app/milvus-http/milvus_http/__init__.py | 0 app/milvus-http/pyproject.toml | 14 + app/milvus-http/tests/__init__.py | 0 milvus_connector/__init__.py | 5 + milvus_connector/_interceptor.py | 91 + milvus_connector/core/__init__.py | 0 milvus_connector/core/_const.py | 15 + milvus_connector/core/_param.py | 42 + milvus_connector/core/_types.py | 140 + milvus_connector/core/milvus.py | 1478 +++++++++ milvus_connector/core/util.py | 419 +++ milvus_connector/protocol/__init__.py | 0 milvus_connector/protocol/common_pb2.py | 104 + milvus_connector/protocol/common_pb2.pyi | 763 +++++ milvus_connector/protocol/common_pb2_grpc.py | 4 + milvus_connector/protocol/data_coord_pb2.py | 259 ++ milvus_connector/protocol/data_coord_pb2.pyi | 1363 ++++++++ .../protocol/data_coord_pb2_grpc.py | 2384 ++++++++++++++ milvus_connector/protocol/etcd_meta_pb2.py | 53 + milvus_connector/protocol/etcd_meta_pb2.pyi | 203 ++ .../protocol/etcd_meta_pb2_grpc.py | 4 + milvus_connector/protocol/feder_pb2.py | 42 + milvus_connector/protocol/feder_pb2.pyi | 70 + milvus_connector/protocol/feder_pb2_grpc.py | 4 + .../protocol/index_cgo_msg_pb2.py | 42 + .../protocol/index_cgo_msg_pb2.pyi | 52 + .../protocol/index_cgo_msg_pb2_grpc.py | 4 + milvus_connector/protocol/index_coord_pb2.py | 107 + milvus_connector/protocol/index_coord_pb2.pyi | 505 +++ .../protocol/index_coord_pb2_grpc.py | 794 +++++ milvus_connector/protocol/internal_pb2.py | 111 + milvus_connector/protocol/internal_pb2.pyi | 550 ++++ .../protocol/internal_pb2_grpc.py | 4 + milvus_connector/protocol/milvus_pb2.py | 535 +++ milvus_connector/protocol/milvus_pb2.pyi | 1894 +++++++++++ milvus_connector/protocol/milvus_pb2_grpc.py | 2875 +++++++++++++++++ milvus_connector/protocol/msg_pb2.py | 47 + milvus_connector/protocol/msg_pb2.pyi | 184 ++ milvus_connector/protocol/msg_pb2_grpc.py | 4 + milvus_connector/protocol/plan_pb2.py | 82 + milvus_connector/protocol/plan_pb2.pyi | 343 ++ milvus_connector/protocol/plan_pb2_grpc.py | 4 + milvus_connector/protocol/proxy_pb2.py | 46 + milvus_connector/protocol/proxy_pb2.pyi | 85 + milvus_connector/protocol/proxy_pb2_grpc.py | 466 +++ milvus_connector/protocol/query_coord_pb2.py | 234 ++ milvus_connector/protocol/query_coord_pb2.pyi | 1112 +++++++ .../protocol/query_coord_pb2_grpc.py | 1784 ++++++++++ milvus_connector/protocol/rg_pb2.py | 31 + milvus_connector/protocol/rg_pb2.pyi | 29 + milvus_connector/protocol/rg_pb2_grpc.py | 4 + milvus_connector/protocol/root_coord_pb2.py | 62 + milvus_connector/protocol/root_coord_pb2.pyi | 139 + .../protocol/root_coord_pb2_grpc.py | 1711 ++++++++++ milvus_connector/protocol/schema_pb2.py | 75 + milvus_connector/protocol/schema_pb2.pyi | 293 ++ milvus_connector/protocol/schema_pb2_grpc.py | 4 + milvus_connector/protocol/segcore_pb2.py | 39 + milvus_connector/protocol/segcore_pb2.pyi | 72 + milvus_connector/protocol/segcore_pb2_grpc.py | 4 + poetry.lock | 472 +++ pyproject.toml | 23 + ruff.toml | 63 + script/generate_proto.sh | 27 + tests/__init__.py | 0 tests/test_milvus.py | 7 + 97 files changed, 30242 insertions(+), 2 deletions(-) create mode 100644 README.md create mode 100644 README_CN.md create mode 100644 all_proto/README.md create mode 100644 all_proto/common.proto create mode 100644 all_proto/data_coord.proto create mode 100644 all_proto/etcd_meta.proto create mode 100644 all_proto/feder.proto create mode 100755 all_proto/index_cgo_msg.proto create mode 100644 all_proto/index_coord.proto create mode 100644 all_proto/internal.proto create mode 100644 all_proto/milvus.proto create mode 100644 all_proto/msg.proto create mode 100644 all_proto/plan.proto create mode 100644 all_proto/proxy.proto create mode 100644 all_proto/query_coord.proto create mode 100644 all_proto/rg.proto create mode 100644 all_proto/root_coord.proto create mode 100644 all_proto/schema.proto create mode 100644 all_proto/segcore.proto create mode 100644 app/milvus-cli/.DS_Store create mode 100644 app/milvus-cli/README.md create mode 100644 app/milvus-cli/mucli/__init__.py create mode 100644 app/milvus-cli/mucli/_milvus.py create mode 100644 app/milvus-cli/mucli/_option.py create mode 100644 app/milvus-cli/mucli/main.py create mode 100644 app/milvus-cli/mucli/pyinstaller.py create mode 100644 app/milvus-cli/poetry.lock create mode 100644 app/milvus-cli/pyproject.toml create mode 100644 app/milvus-cli/tests/__init__.py create mode 100644 app/milvus-http/README.md create mode 100644 app/milvus-http/milvus_http/__init__.py create mode 100644 app/milvus-http/pyproject.toml create mode 100644 app/milvus-http/tests/__init__.py create mode 100644 milvus_connector/__init__.py create mode 100644 milvus_connector/_interceptor.py create mode 100644 milvus_connector/core/__init__.py create mode 100644 milvus_connector/core/_const.py create mode 100644 milvus_connector/core/_param.py create mode 100644 milvus_connector/core/_types.py create mode 100644 milvus_connector/core/milvus.py create mode 100644 milvus_connector/core/util.py create mode 100644 milvus_connector/protocol/__init__.py create mode 100644 milvus_connector/protocol/common_pb2.py create mode 100644 milvus_connector/protocol/common_pb2.pyi create mode 100644 milvus_connector/protocol/common_pb2_grpc.py create mode 100644 milvus_connector/protocol/data_coord_pb2.py create mode 100644 milvus_connector/protocol/data_coord_pb2.pyi create mode 100644 milvus_connector/protocol/data_coord_pb2_grpc.py create mode 100644 milvus_connector/protocol/etcd_meta_pb2.py create mode 100644 milvus_connector/protocol/etcd_meta_pb2.pyi create mode 100644 milvus_connector/protocol/etcd_meta_pb2_grpc.py create mode 100644 milvus_connector/protocol/feder_pb2.py create mode 100644 milvus_connector/protocol/feder_pb2.pyi create mode 100644 milvus_connector/protocol/feder_pb2_grpc.py create mode 100644 milvus_connector/protocol/index_cgo_msg_pb2.py create mode 100644 milvus_connector/protocol/index_cgo_msg_pb2.pyi create mode 100644 milvus_connector/protocol/index_cgo_msg_pb2_grpc.py create mode 100644 milvus_connector/protocol/index_coord_pb2.py create mode 100644 milvus_connector/protocol/index_coord_pb2.pyi create mode 100644 milvus_connector/protocol/index_coord_pb2_grpc.py create mode 100644 milvus_connector/protocol/internal_pb2.py create mode 100644 milvus_connector/protocol/internal_pb2.pyi create mode 100644 milvus_connector/protocol/internal_pb2_grpc.py create mode 100644 milvus_connector/protocol/milvus_pb2.py create mode 100644 milvus_connector/protocol/milvus_pb2.pyi create mode 100644 milvus_connector/protocol/milvus_pb2_grpc.py create mode 100644 milvus_connector/protocol/msg_pb2.py create mode 100644 milvus_connector/protocol/msg_pb2.pyi create mode 100644 milvus_connector/protocol/msg_pb2_grpc.py create mode 100644 milvus_connector/protocol/plan_pb2.py create mode 100644 milvus_connector/protocol/plan_pb2.pyi create mode 100644 milvus_connector/protocol/plan_pb2_grpc.py create mode 100644 milvus_connector/protocol/proxy_pb2.py create mode 100644 milvus_connector/protocol/proxy_pb2.pyi create mode 100644 milvus_connector/protocol/proxy_pb2_grpc.py create mode 100644 milvus_connector/protocol/query_coord_pb2.py create mode 100644 milvus_connector/protocol/query_coord_pb2.pyi create mode 100644 milvus_connector/protocol/query_coord_pb2_grpc.py create mode 100644 milvus_connector/protocol/rg_pb2.py create mode 100644 milvus_connector/protocol/rg_pb2.pyi create mode 100644 milvus_connector/protocol/rg_pb2_grpc.py create mode 100644 milvus_connector/protocol/root_coord_pb2.py create mode 100644 milvus_connector/protocol/root_coord_pb2.pyi create mode 100644 milvus_connector/protocol/root_coord_pb2_grpc.py create mode 100644 milvus_connector/protocol/schema_pb2.py create mode 100644 milvus_connector/protocol/schema_pb2.pyi create mode 100644 milvus_connector/protocol/schema_pb2_grpc.py create mode 100644 milvus_connector/protocol/segcore_pb2.py create mode 100644 milvus_connector/protocol/segcore_pb2.pyi create mode 100644 milvus_connector/protocol/segcore_pb2_grpc.py create mode 100644 poetry.lock create mode 100644 pyproject.toml create mode 100644 ruff.toml create mode 100755 script/generate_proto.sh create mode 100644 tests/__init__.py create mode 100644 tests/test_milvus.py diff --git a/.gitignore b/.gitignore index 5023870..8ecd0a8 100644 --- a/.gitignore +++ b/.gitignore @@ -4,5 +4,7 @@ draft/ dist/ build/ *.spec -.env -.ruff_cache/ \ No newline at end of file +*.env +.ruff_cache/ +.vscode/ +.bw_config/ \ No newline at end of file diff --git a/README.md b/README.md new file mode 100644 index 0000000..0593a2f --- /dev/null +++ b/README.md @@ -0,0 +1,162 @@ +# milvus any operation + +English | [中文](README_CN.md) + +## Why does this project exist? + +As a Milvus developer, I am involved in the development of various features in Milvus as part of my regular work. Additionally, I often need to troubleshoot Milvus issues reported by the community and our collaborative users. + +During this process, I found it somewhat cumbersome every time I made a gRPC call to Milvus. I had to open the pymilvus project, make modifications to some example code, and then run it. Many times, I had to make multiple changes to the code, which was quite tedious. I also attempted to use other tools like the HTTP client tool in GoLand or gRPC calls in Postman, which partially addressed the problem of repeatedly modifying parameters. However, they introduced a new issue of not being able to construct complex parameters. + +The core objective of this project is to enable interaction with Milvus by freely adjusting parameters without the need to open any project code. + +## Who is suitable for using this project? + +1. Milvus developers +2. Milvus administrators responsible for **testing cluster** operations and maintenance + +This project has not yet undergone **sufficient testing**, so please do not use any APIs from this project in a production cluster. Since this project does not perform parameter validation, **users must ensure the legality of the parameters themselves**. Of course, Milvus services also perform a series of parameter validations, but unexpected situations may still occur. If you encounter any issues, please provide feedback in the issue section. + +## Project Highlights + +During the development process, we interacted with Milvus in the following ways: + +- SDK interaction: [pymilvus](https://github.com/milvus-io/pymilvus) +- Milvus UI app interaction: [attu](https://github.com/zilliztech/attu) +- Command-line interaction based on SDK: [milvus_cli](https://github.com/zilliztech/milvus_cli) + +All of these methods are aimed at Milvus users, but they may not be very user-friendly for Milvus developers as they cannot directly access the native gRPC interface in a faster and more convenient way. Additionally, there is another tool, primarily used for viewing Milvus metadata, called [birdwatcher](https://github.com/milvus-io/birdwatcher), which is frequently used in troubleshooting. + +The core purpose of the project is to facilitate developers' interaction with Milvus to the maximum extent. This is reflected in the following aspects: + +1. Directly constructing gRPC requests to interact with Milvus, with minimal parameter validation. +2. The response can be in JSON format. By using the project's CLI tool, it becomes easier to interact with Milvus using jq commands, Linux pipelines, or custom Bash scripts. +3. Lightweight, with minimal dependencies. + +## Installation + +**Usage Tips** + +1. The tool is currently developed based on milvus proto, which means that if you use the tool to connect to other versions of milvus, there may be unexpected behaviors for some interfaces. Please refer to the following table for specific correspondences. +2. Do not use parameters that you do not understand, as many parameters are hidden in the official milvus SDK with the main purpose of reducing understanding and usage costs. +3. Parameters are generally not validated. +4. Some interfaces in the project have not been tested, which means they may not work. If you find any issues, please submit an issue. +5. The return values are native gRPC return values, and some of them have complex structures. +6. When using on macOS, there may be a slow loading time for the first use, approximately 10 seconds. + +### macOS + +Currently, the macOS binary is compiled using x86 machines. It has not been tested on M1 chips, so it is uncertain whether it can be installed successfully. + +``` +brew install simfg/su/mucli +``` + +### Linux + +You can download the binary from the [GitHub Release](https://github.com/SimFG/mua/releases/) and then add it to the PATH environment variable. + +``` +wget https://github.com/SimFG/mua/releases/download/0.0.1/mucli-v0.0.1-linux.tar.gz -O mucli.tar.gz + +tar -zxvf mucli.tar.gz +``` + +After these steps, you will have an executable mucli binary in the mucli folder, and you can start using it. + +Please note that **do not move the executable file from the folder to another location** because it depends on the files in the _internal folder within the current folder. + +## Version List + +It is recommended to use the mucli tool that corresponds to the respective Milvus version to avoid potential compatibility issues due to inconsistent proto files. + +| mucli | milvus | date | +| --------- | ------------ | ------------ | +| v0.0.1 | v2.4.0-rc.1 | 2024.3.13 | + +## mucli Quick Start + +### Connecting to Milvus + +Currently, there are two ways to connect to Milvus: specifying parameters and using the .env file. If both methods are used, the .env file takes precedence. + +1. Specifying parameters + +``` +mucli -u localhost:19530 -t 'root:Milvus' -d default {{command}} +``` + +2. Using the .env file + +By default, the .env file in the current folder will be read. + +``` +// .demo.env file content +MILVUS_URI=https://xxxx:19530 +MILVUS_TOKEN=root:Milvus +MILVUS_DATABASE=default +``` + +``` +mucli -e '.demo.env' {{command}} +``` + +Note: Before using any related commands, make sure to specify the connection parameters. + +### Built-in Query Command Aliases + +- View the collection list: `mucli collections` +- View the partition list: `mucli partitions -n {{collection_name}}` +- View the database list: `mucli databases` +- View the user list: `mucli users` +- View the role list: `mucli roles` + +You can use the jq command to obtain more concise JSON information or view arrays. For example, to check the number of collections: `mucli collections | jq ".collectionNames | length"` + +### help Command + +- View a list of all subcommands: `mucli --help` +- View the usage of a specific subcommand: `mucli {{command}} --help` +- Fuzzy search the list of subcommands, e.g., `mucli collection`, will return a list of commands that contain the word "collection". + +### Built-in Shortcut Commands + +Certain commands require many parameters to be set by default, such as creating a collection, inserting data, etc. + +- Quickly create a collection: `mucli create-collection --name hello_milvus --auto-field true` +- Quickly create a collection with a partition key: `mucli create-collection --name hello_milvus --auto-field true --auto-partition true` +- Insert random data: `mucli insert --name hello_milvus --random-data true` +- Insert 5000 random data points: `mucli insert --name hello_milvus --random-data true --random-num 5000` + +### List of Commonly Used Commands + +If you encounter any errors with the commands, please feel free to raise an issue as some commands have not been tested. + +``` +mucli create-collection --name hello_milvus --auto-field true + +mucli insert --name hello_milvus --random-data true + +mucli flush --name hello_milvus + +mucli create-index --name hello_milvus3 + +mucli load-collection --name hello_milvus + +mucli query --name hello_milvus --expr 'pk in [10, 20]' --field pk --field random + +mucli collections | jq '.collectionNames' + +mucli collections | jq '.collectionNames | length' +``` + +## Follow-up Plan + +This project was developed in my spare time because I need to interact with Milvus frequently in my work. Typically, if there aren't too many issues which are not handled, I will fix them within 2-3 days. Your star will be my greatest source of support! + +1. Develop an HTTP proxy service for Milvus service. +2. Add RPC calls for internal nodes. +3. Query Milvus configurations. +4. Provide more user-friendly error messages when encountering exceptions. +5. Implement dynamic loading of commands. +6. Optimize the usage of search/query and other interfaces. \ No newline at end of file diff --git a/README_CN.md b/README_CN.md new file mode 100644 index 0000000..fb981ce --- /dev/null +++ b/README_CN.md @@ -0,0 +1,162 @@ +# milvus any operation + +[English](README.md) | 中文 + +## 为什么会有这个项目？ + +作为一个Milvus开发者，我的日常工作涉及到许多Milvus功能的开发，同时也需要排查许多社区和合作用户的Milvus异常情况。 + +在这个过程中，我发现每次调用Milvus的gRPC都有些麻烦，需要打开pymilvus项目，然后修改一些示例代码，然后运行。很多时候，我需要反复修改代码，这样比较繁琐。我也尝试过使用其他工具，比如GoLand中的HTTP客户端工具、Postman中的gRPC调用，这些工具在一定程度上解决了反复修改参数的问题，但也带来了一个新的问题，即无法构造复杂参数。 + +这个项目的核心目标是：无需打开任何项目代码，就能够任意调整参数与Milvus进行直接交互。 + +## 谁适合使用该项目 + +1. milvus开发者 +2. 负责**测试集群**运维的milvus管理员 + +该项目目前尚**未经过充分的测试**，请勿在生产集群中使用该项目中的任何API。由于该项目基本上不会对参数进行校验，因此用户需自行确保参数的合法性。当然，milvus服务也对参数进行了一系列校验，但仍可能存在意外情况。如果发现任何问题，请在issue中反馈。 + +## 项目亮点 + +在开发过程中，我们与Milvus的交互方式主要包括以下几种： + +- 使用SDK进行交互：[pymilvus](https://github.com/milvus-io/pymilvus) +- 通过Milvus UI应用进行交互：[attu](https://github.com/zilliztech/attu) +- 基于SDK开发的命令行交互：[milvus_cli](https://github.com/zilliztech/milvus_cli) + +以上方式都是面向Milvus用户的，但对于Milvus开发者来说并不是很友好，无法快速、方便地调用原生的gRPC接口。此外，还有一个其他工具用于查看Milvus的元信息：[birdwatcher](https://github.com/milvus-io/birdwatcher)，在问题排查中使用频率相对较高。 + +该项目的核心目标是尽可能方便开发者与Milvus进行交互，主要体现在以下几个方面： + +1. 可以直接构造gRPC请求与Milvus进行交互，参数基本上没有校验； +2. 请求返回值可以为JSON格式，使用项目中的命令行工具，可以更方便地与jq命令、Linux管道进行交互，也可以自定义更多与Milvus交互的Bash脚本； +3. 轻量化，尽量减少依赖。 + +## 安装 + +**使用提示** + +1. 工具目前依赖于 milvus 的 proto 进行开发。如果使用当前工具连接其他版本的 milvus，部分接口可能会出现不可预期的行为。具体对应关系请参考下表。 +2. 对于不理解的参数，请勿使用，因为很多参数在 milvus 的官方 SDK 中被隐藏了，其主要目的是降低理解和使用成本。 +3. 基本上不会对参数进行校验。 +4. 项目中的某些接口并没有经过测试，可能会存在不工作的情况。如果发现，请提出 issue。 +5. 返回值均为原生的 gRPC 返回值，其中部分返回值的结构较为复杂。 +6. 在 macOS 上使用时，首次加载较慢，大约需要 10 秒左右。 + +### macOS + +目前 macOS 二进制是使用 x86 机器编译的，对于 M1 芯片暂时未进行实验，无法确定是否能成功安装。 + +``` +brew install simfg/su/mucli +``` + +### Linux + +可以从 [GitHub Release](https://github.com/SimFG/mua/releases/) 中下载二进制文件，然后将其设置为 PATH 环境变量。 + +``` +wget https://github.com/SimFG/mua/releases/download/0.0.1/mucli-v0.0.1-linux.tar.gz -O mucli.tar.gz + +tar -zxvf mucli.tar.gz +``` + +这样，在 mucli 的文件夹下就会有一个可执行的 mucli 二进制文件，您就可以开始使用了。 + +请注意**不要将文件夹中的可执行文件单独移动到其他位置**，因为它依赖当前文件夹中的 _internal 文件夹中的文件。 + +## 版本列表 + +建议使用相应的 Milvus 版本的 mucli 工具，以免出现兼容性问题，因为 proto 文件可能不一致。 + +| mucli | milvus | 日期 | +| --------- | ------------ | ------------ | +| v0.0.1 | v2.4.0-rc.1 | 2024.3.13 | + +## mucli快速使用 + +### milvus连接 + +目前提供两种方式来连接Milvus，分别是指定参数和指定.env文件，如果两者都存在，则使用.env文件。 + +1. 指定参数 + +``` +mucli -u localhost:19530 -t 'root:Milvus' -d default {{command}} +``` + +2. 使用.env文件 + +默认情况下，会读取当前文件夹中的`.env`文件。 + +``` +// .demo.env文件内容 +MILVUS_URI=https://xxxx:19530 +MILVUS_TOKEN=root:Milvus +MILVUS_DATABASE=default +``` + +``` +mucli -e '.demo.env' {{command}} +``` + +注：在使用相关命令之前，需要先指定连接参数。 + +### 内置部分查询指令别名 + +- 查看collection列表：`mucli collections` +- 查看partition列表：`mucli partitions -n {{collection_name}}` +- 查看db列表：`mucli databases` +- 查看user列表：`mucli users` +- 查看role列表：`mucli roles` + +可以配合jq命令使用，以获取更简洁的JSON信息或者查看数组。例如，要查看collection数目：`mucli collections | jq ".collectionNames | length"` + +### help命令 + +- 查看所有子命令列表：`mucli --help` +- 查看某个子命令的用法：`mucli {{command}} --help` +- 模糊搜索子命令列表，例如：`mucli collection`，将返回所有带有"collection"字符的子命令列表 + +### 内置快捷指令命令 + +部分指令，默认情况下需要设置许多参数，例如创建collection、插入数据等。 + +- 快速创建collection：`mucli create-collection --name hello_milvus --auto-field true` +- 快速创建带有partition key的collection：`mucli create-collection --name hello_milvus --auto-field true --auto-partition true` +- 随机插入数据：`mucli insert --name hello_milvus --random-data true` +- 随机插入5000条数据：`mucli insert --name hello_milvus --random-data true --random-num 5000` + +### 常用命令列表 + +以下命令均自己尝试过使用，使用其他命令遇到报错，请提issue，因为有些命令尚未经过测试运行。 + +``` +mucli create-collection --name hello_milvus --auto-field true + +mucli insert --name hello_milvus --random-data true + +mucli flush --name hello_milvus + +mucli create-index --name hello_milvus3 + +mucli load-collection --name hello_milvus + +mucli query --name hello_milvus --expr 'pk in [10, 20]' --field pk --field random + +mucli collections | jq '.collectionNames' + +mucli collections | jq '.collectionNames | length' +``` + +## 后续规划 + +这个项目是在业余时间里开发的，因为在工作中需要频繁与Milvus进行交互。通常情况下，如果没有太多的issue反馈堆积，会在2-3天内进行修复并给出修复小版本。你的关注将是我最大的支持动力！ + +1. 开发 Milvus 服务的 HTTP 代理服务。 +2. 添加内部节点的 RPC 调用功能。 +3. 查询 Milvus 配置。 +4. 在遇到异常情况时，提供更友好的错误信息。 +5. 实现动态加载命令功能。 +6. 优化 search/query 等接口的使用体验。 \ No newline at end of file diff --git a/all_proto/README.md b/all_proto/README.md new file mode 100644 index 0000000..1eb4549 --- /dev/null +++ b/all_proto/README.md @@ -0,0 +1,15 @@ +# milvus-proto + +branch: master + +commit id: 2c89f346b00f496287f50ac39239bde0c0f99e8b + +date: 2024.3.13 + +# milvus-inner-proto + +branch: master + +commit id: 1d962391378164e9024519590d6bb7bee60b9a90 + +date: 2024.3.15 \ No newline at end of file diff --git a/all_proto/common.proto b/all_proto/common.proto new file mode 100644 index 0000000..76eb482 --- /dev/null +++ b/all_proto/common.proto @@ -0,0 +1,462 @@ +syntax = "proto3"; +package milvus.proto.common; + +option go_package="github.com/milvus-io/milvus-proto/go-api/v2/commonpb"; + +option java_multiple_files = true; +option java_package = "io.milvus.grpc"; +option java_outer_classname = "CommonProto"; +option java_generate_equals_and_hash = true; + +option csharp_namespace = "Milvus.Client.Grpc"; + +import "google/protobuf/descriptor.proto"; + +// Deprecated +enum ErrorCode { + option deprecated = true; + Success = 0; + UnexpectedError = 1; + ConnectFailed = 2; + PermissionDenied = 3; + CollectionNotExists = 4; + IllegalArgument = 5; + IllegalDimension = 7; + IllegalIndexType = 8; + IllegalCollectionName = 9; + IllegalTOPK = 10; + IllegalRowRecord = 11; + IllegalVectorID = 12; + IllegalSearchResult = 13; + FileNotFound = 14; + MetaFailed = 15; + CacheFailed = 16; + CannotCreateFolder = 17; + CannotCreateFile = 18; + CannotDeleteFolder = 19; + CannotDeleteFile = 20; + BuildIndexError = 21; + IllegalNLIST = 22; + IllegalMetricType = 23; + OutOfMemory = 24; + IndexNotExist = 25; + EmptyCollection = 26; + UpdateImportTaskFailure = 27; + CollectionNameNotFound = 28; + CreateCredentialFailure = 29; + UpdateCredentialFailure = 30; + DeleteCredentialFailure = 31; + GetCredentialFailure = 32; + ListCredUsersFailure = 33; + GetUserFailure = 34; + CreateRoleFailure = 35; + DropRoleFailure = 36; + OperateUserRoleFailure = 37; + SelectRoleFailure = 38; + SelectUserFailure = 39; + SelectResourceFailure = 40; + OperatePrivilegeFailure = 41; + SelectGrantFailure = 42; + RefreshPolicyInfoCacheFailure = 43; + ListPolicyFailure = 44; + NotShardLeader = 45; + NoReplicaAvailable = 46; + SegmentNotFound = 47; + ForceDeny = 48; + RateLimit = 49; + NodeIDNotMatch = 50; + UpsertAutoIDTrue = 51; + InsufficientMemoryToLoad = 52; + MemoryQuotaExhausted = 53; + DiskQuotaExhausted = 54; + TimeTickLongDelay = 55; + NotReadyServe = 56; + // Coord is switching from standby mode to active mode + NotReadyCoordActivating = 57; + + // Service availability. + // NA: Not Available. + DataCoordNA = 100; + + // internal error code. + DDRequestRace = 1000; +} + +enum IndexState { + IndexStateNone = 0; + Unissued = 1; + InProgress = 2; + Finished = 3; + Failed = 4; + Retry = 5; +} + +enum SegmentState { + SegmentStateNone = 0; + NotExist = 1; + Growing = 2; + Sealed = 3; + Flushed = 4; + Flushing = 5; + Dropped = 6; + Importing = 7; +} + +message Status { + ErrorCode error_code = 1 [deprecated=true]; + string reason = 2; + int32 code = 3; + bool retriable = 4; + string detail = 5; + map extra_info = 6; +} + +message KeyValuePair { + string key = 1; + string value = 2; +} + +message KeyDataPair { + string key = 1; + bytes data = 2; +} + +message Blob { + bytes value = 1; +} + +enum PlaceholderType { + None = 0; + BinaryVector = 100; + FloatVector = 101; + Float16Vector = 102; + BFloat16Vector = 103; + SparseFloatVector = 104; + Int64 = 5; + VarChar = 21; +} + +message PlaceholderValue { + string tag = 1; + PlaceholderType type = 2; + // values is a 2d-array of nq rows, every row contains a query vector. + // for dense vector, all rows are of the same length; for sparse vector, + // the length of each row may vary depending on their number of non-zeros. + repeated bytes values = 3; +} + +message PlaceholderGroup { + repeated PlaceholderValue placeholders = 1; +} + + +message Address { + string ip = 1; + int64 port = 2; +} + +enum MsgType { + Undefined = 0; + /* DEFINITION REQUESTS: COLLECTION */ + CreateCollection = 100; + DropCollection = 101; + HasCollection = 102; + DescribeCollection = 103; + ShowCollections = 104; + GetSystemConfigs = 105; + LoadCollection = 106; + ReleaseCollection = 107; + CreateAlias = 108; + DropAlias = 109; + AlterAlias = 110; + AlterCollection = 111; + RenameCollection = 112; + DescribeAlias = 113; + ListAliases = 114; + + /* DEFINITION REQUESTS: PARTITION */ + CreatePartition = 200; + DropPartition = 201; + HasPartition = 202; + DescribePartition = 203; + ShowPartitions = 204; + LoadPartitions = 205; + ReleasePartitions = 206; + + /* DEFINE REQUESTS: SEGMENT */ + ShowSegments = 250; + DescribeSegment = 251; + LoadSegments = 252; + ReleaseSegments = 253; + HandoffSegments = 254; + LoadBalanceSegments = 255; + DescribeSegments = 256; + FederListIndexedSegment = 257; + FederDescribeSegmentIndexData = 258; + + /* DEFINITION REQUESTS: INDEX */ + CreateIndex = 300; + DescribeIndex = 301; + DropIndex = 302; + GetIndexStatistics = 303; + AlterIndex = 304; + + /* MANIPULATION REQUESTS */ + Insert = 400; + Delete = 401; + Flush = 402; + ResendSegmentStats = 403; + Upsert = 404; + + /* QUERY */ + Search = 500; + SearchResult = 501; + GetIndexState = 502; + GetIndexBuildProgress = 503; + GetCollectionStatistics = 504; + GetPartitionStatistics = 505; + Retrieve = 506; + RetrieveResult = 507; + WatchDmChannels = 508; + RemoveDmChannels = 509; + WatchQueryChannels = 510; + RemoveQueryChannels = 511; + SealedSegmentsChangeInfo = 512; + WatchDeltaChannels = 513; + GetShardLeaders = 514; + GetReplicas = 515; + UnsubDmChannel = 516; + GetDistribution = 517; + SyncDistribution = 518; + + /* DATA SERVICE */ + SegmentInfo = 600; + SystemInfo = 601; + GetRecoveryInfo = 602; + GetSegmentState = 603; + + /* SYSTEM CONTROL */ + TimeTick = 1200; + QueryNodeStats = 1201; // GOOSE TODO: Remove kQueryNodeStats + LoadIndex = 1202; + RequestID = 1203; + RequestTSO = 1204; + AllocateSegment = 1205; + SegmentStatistics = 1206; + SegmentFlushDone = 1207; + + DataNodeTt = 1208; + Connect = 1209; + ListClientInfos = 1210; + AllocTimestamp = 1211; + + /* Credential */ + CreateCredential = 1500; + GetCredential = 1501; + DeleteCredential = 1502; + UpdateCredential = 1503; + ListCredUsernames = 1504; + + /* RBAC */ + CreateRole = 1600; + DropRole = 1601; + OperateUserRole = 1602; + SelectRole = 1603; + SelectUser = 1604; + SelectResource = 1605; + OperatePrivilege = 1606; + SelectGrant = 1607; + RefreshPolicyInfoCache = 1608; + ListPolicy = 1609; + + /* Resource group */ + CreateResourceGroup = 1700; + DropResourceGroup = 1701; + ListResourceGroups = 1702; + DescribeResourceGroup = 1703; + TransferNode = 1704; + TransferReplica = 1705; + UpdateResourceGroups = 1706; + + /* Database group */ + CreateDatabase = 1801; + DropDatabase = 1802; + ListDatabases = 1803; +} + +message MsgBase { + MsgType msg_type = 1; + int64 msgID = 2; + uint64 timestamp = 3; + int64 sourceID = 4; + int64 targetID = 5; + map properties = 6; + ReplicateInfo replicateInfo = 7; +} + +message ReplicateInfo { + bool isReplicate = 1; + uint64 msgTimestamp = 2; +} + +enum DslType { + Dsl = 0; + BoolExprV1 = 1; +} + +// Don't Modify This. @czs +message MsgHeader { + common.MsgBase base = 1; +} + +// Don't Modify This. @czs +message DMLMsgHeader { + common.MsgBase base = 1; + string shardName = 2; +} + +enum CompactionState { + UndefiedState = 0; + Executing = 1; + Completed = 2; +} + +enum ConsistencyLevel { + Strong = 0; + Session = 1; // default in PyMilvus + Bounded = 2; + Eventually = 3; + Customized = 4; // Users pass their own `guarantee_timestamp`. +} + +enum ImportState { + ImportPending = 0; // the task in in pending list of rootCoord, waiting to be executed + ImportFailed = 1; // the task failed for some reason, get detail reason from GetImportStateResponse.infos + ImportStarted = 2; // the task has been sent to datanode to execute + ImportPersisted = 5; // all data files have been parsed and all meta data already persisted, ready to be flushed. + ImportFlushed = 8; // all segments are successfully flushed. + ImportCompleted = 6; // all indexes are successfully built and segments are able to be compacted as normal. + ImportFailedAndCleaned = 7; // the task failed and all segments it generated are cleaned up. +} + +enum ObjectType { + Collection = 0; + Global = 1; + User = 2; +} + +enum ObjectPrivilege { + PrivilegeAll = 0; + PrivilegeCreateCollection = 1; + PrivilegeDropCollection = 2; + PrivilegeDescribeCollection = 3; + PrivilegeShowCollections = 4; + PrivilegeLoad = 5; + PrivilegeRelease = 6; + PrivilegeCompaction = 7; + PrivilegeInsert = 8; + PrivilegeDelete = 9; + + PrivilegeGetStatistics = 10; + PrivilegeCreateIndex = 11; + PrivilegeIndexDetail = 12; + PrivilegeDropIndex = 13; + PrivilegeSearch = 14; + PrivilegeFlush = 15; + PrivilegeQuery = 16; + PrivilegeLoadBalance = 17; + PrivilegeImport = 18; + PrivilegeCreateOwnership = 19; + PrivilegeUpdateUser = 20; + PrivilegeDropOwnership = 21; + PrivilegeSelectOwnership = 22; + PrivilegeManageOwnership = 23; + PrivilegeSelectUser = 24; + PrivilegeUpsert = 25; + PrivilegeCreateResourceGroup = 26; + PrivilegeDropResourceGroup = 27; + PrivilegeDescribeResourceGroup = 28; + PrivilegeListResourceGroups = 29; + PrivilegeTransferNode = 30; + PrivilegeTransferReplica = 31; + PrivilegeGetLoadingProgress = 32; + PrivilegeGetLoadState = 33; + + PrivilegeRenameCollection = 34; + PrivilegeCreateDatabase = 35; + PrivilegeDropDatabase = 36; + PrivilegeListDatabases = 37; + PrivilegeFlushAll = 38; + + PrivilegeCreatePartition = 39; + PrivilegeDropPartition = 40; + PrivilegeShowPartitions = 41; + PrivilegeHasPartition = 42; + PrivilegeGetFlushState = 43; + PrivilegeCreateAlias = 44; + PrivilegeDropAlias = 45; + PrivilegeDescribeAlias = 46; + PrivilegeListAliases = 47; + + PrivilegeUpdateResourceGroups = 48; +} + +message PrivilegeExt { + ObjectType object_type = 1; + ObjectPrivilege object_privilege = 2; + int32 object_name_index = 3; + int32 object_name_indexs = 4; +} + +extend google.protobuf.MessageOptions { + PrivilegeExt privilege_ext_obj = 1001; +} + +enum StateCode { + Initializing = 0; + Healthy = 1; + Abnormal = 2; + StandBy = 3; + Stopping = 4; +} + +enum LoadState { + LoadStateNotExist = 0; + LoadStateNotLoad = 1; + LoadStateLoading = 2; + LoadStateLoaded = 3; +} + +message SegmentStats { + int64 SegmentID = 1; + int64 NumRows = 2; +} + +message ClientInfo { + // sdk_type can be `python`, `golang`, `nodejs` and etc. It's not proper to make `sdk_type` an + // enumerate type, since we cannot always update the enum value everytime when newly sdk is supported. + string sdk_type = 1; + string sdk_version = 2; + string local_time = 3; + string user = 4; + string host = 5; + // reserved for newly-added feature if necessary. + map reserved = 6; +} + +message ServerInfo { + string build_tags = 1; + string build_time = 2; + string git_commit = 3; + string go_version = 4; + string deploy_mode = 5; + // reserved for newly-added feature if necessary. + map reserved = 6; +} + +// NodeInfo is used to describe the node information. +message NodeInfo { + int64 nodeID = 1; + string address = 2; + string hostname = 3; +} diff --git a/all_proto/data_coord.proto b/all_proto/data_coord.proto new file mode 100644 index 0000000..ab50d98 --- /dev/null +++ b/all_proto/data_coord.proto @@ -0,0 +1,912 @@ +syntax = "proto3"; + +package milvus.proto.data; + +option go_package = "github.com/milvus-io/milvus/internal/proto/datapb"; + +import "common.proto"; +import "internal.proto"; +import "milvus.proto"; +import "schema.proto"; +import "msg.proto"; +import "index_coord.proto"; + +// TODO: import google/protobuf/empty.proto +message Empty {} + +enum SegmentType { + New = 0; + Normal = 1; + Flushed = 2; + Compacted = 3; +} + +enum SegmentLevel { + Legacy = 0; // zero value for legacy logic + L0 = 1; // L0 segment, contains delta data for current channel + L1 = 2; // L1 segment, normal segment, with no extra compaction attribute + L2 = 3; // L2 segemnt, segment with extra data distribution info +} + +service DataCoord { + rpc GetComponentStates(milvus.GetComponentStatesRequest) returns (milvus.ComponentStates) {} + rpc GetTimeTickChannel(internal.GetTimeTickChannelRequest) returns(milvus.StringResponse) {} + rpc GetStatisticsChannel(internal.GetStatisticsChannelRequest) returns(milvus.StringResponse){} + + rpc Flush(FlushRequest) returns (FlushResponse) {} + + rpc AssignSegmentID(AssignSegmentIDRequest) returns (AssignSegmentIDResponse) {} + + rpc GetSegmentInfo(GetSegmentInfoRequest) returns (GetSegmentInfoResponse) {} + rpc GetSegmentStates(GetSegmentStatesRequest) returns (GetSegmentStatesResponse) {} + rpc GetInsertBinlogPaths(GetInsertBinlogPathsRequest) returns (GetInsertBinlogPathsResponse) {} + + rpc GetCollectionStatistics(GetCollectionStatisticsRequest) returns (GetCollectionStatisticsResponse) {} + rpc GetPartitionStatistics(GetPartitionStatisticsRequest) returns (GetPartitionStatisticsResponse) {} + + rpc GetSegmentInfoChannel(GetSegmentInfoChannelRequest) returns (milvus.StringResponse){} + + rpc SaveBinlogPaths(SaveBinlogPathsRequest) returns (common.Status){} + rpc GetRecoveryInfo(GetRecoveryInfoRequest) returns (GetRecoveryInfoResponse){} + rpc GetRecoveryInfoV2(GetRecoveryInfoRequestV2) returns (GetRecoveryInfoResponseV2){} + rpc GetFlushedSegments(GetFlushedSegmentsRequest) returns(GetFlushedSegmentsResponse){} + rpc GetSegmentsByStates(GetSegmentsByStatesRequest) returns(GetSegmentsByStatesResponse){} + rpc GetFlushAllState(milvus.GetFlushAllStateRequest) returns(milvus.GetFlushAllStateResponse) {} + + rpc ShowConfigurations(internal.ShowConfigurationsRequest) returns (internal.ShowConfigurationsResponse){} + // https://wiki.lfaidata.foundation/display/MIL/MEP+8+--+Add+metrics+for+proxy + rpc GetMetrics(milvus.GetMetricsRequest) returns (milvus.GetMetricsResponse) {} + rpc ManualCompaction(milvus.ManualCompactionRequest) returns (milvus.ManualCompactionResponse) {} + rpc GetCompactionState(milvus.GetCompactionStateRequest) returns (milvus.GetCompactionStateResponse) {} + rpc GetCompactionStateWithPlans(milvus.GetCompactionPlansRequest) returns (milvus.GetCompactionPlansResponse) {} + + rpc WatchChannels(WatchChannelsRequest) returns (WatchChannelsResponse) {} + rpc GetFlushState(GetFlushStateRequest) returns (milvus.GetFlushStateResponse) {} + rpc DropVirtualChannel(DropVirtualChannelRequest) returns (DropVirtualChannelResponse) {} + + rpc SetSegmentState(SetSegmentStateRequest) returns (SetSegmentStateResponse) {} + // https://wiki.lfaidata.foundation/display/MIL/MEP+24+--+Support+bulk+load + rpc Import(ImportTaskRequest) returns (ImportTaskResponse) {} + rpc UpdateSegmentStatistics(UpdateSegmentStatisticsRequest) returns (common.Status) {} + rpc UpdateChannelCheckpoint(UpdateChannelCheckpointRequest) returns (common.Status) {} + + rpc SaveImportSegment(SaveImportSegmentRequest) returns(common.Status) {} + rpc UnsetIsImportingState(UnsetIsImportingStateRequest) returns(common.Status) {} + rpc MarkSegmentsDropped(MarkSegmentsDroppedRequest) returns(common.Status) {} + + rpc BroadcastAlteredCollection(AlterCollectionRequest) returns (common.Status) {} + + rpc CheckHealth(milvus.CheckHealthRequest) returns (milvus.CheckHealthResponse) {} + + rpc CreateIndex(index.CreateIndexRequest) returns (common.Status){} + rpc AlterIndex(index.AlterIndexRequest) returns (common.Status){} + // Deprecated: use DescribeIndex instead + rpc GetIndexState(index.GetIndexStateRequest) returns (index.GetIndexStateResponse) {} + rpc GetSegmentIndexState(index.GetSegmentIndexStateRequest) returns (index.GetSegmentIndexStateResponse) {} + rpc GetIndexInfos(index.GetIndexInfoRequest) returns (index.GetIndexInfoResponse){} + rpc DropIndex(index.DropIndexRequest) returns (common.Status) {} + rpc DescribeIndex(index.DescribeIndexRequest) returns (index.DescribeIndexResponse) {} + rpc GetIndexStatistics(index.GetIndexStatisticsRequest) returns (index.GetIndexStatisticsResponse) {} + // Deprecated: use DescribeIndex instead + rpc GetIndexBuildProgress(index.GetIndexBuildProgressRequest) returns (index.GetIndexBuildProgressResponse) {} + rpc ListIndexes(index.ListIndexesRequest) returns (index.ListIndexesResponse) {} + + rpc GcConfirm(GcConfirmRequest) returns (GcConfirmResponse) {} + + rpc ReportDataNodeTtMsgs(ReportDataNodeTtMsgsRequest) returns (common.Status) {} + + rpc GcControl(GcControlRequest) returns(common.Status){} + + // importV2 + rpc ImportV2(internal.ImportRequestInternal) returns(internal.ImportResponse){} + rpc GetImportProgress(internal.GetImportProgressRequest) returns(internal.GetImportProgressResponse){} + rpc ListImports(internal.ListImportsRequestInternal) returns(internal.ListImportsResponse){} +} + +service DataNode { + rpc GetComponentStates(milvus.GetComponentStatesRequest) returns (milvus.ComponentStates) {} + rpc GetStatisticsChannel(internal.GetStatisticsChannelRequest) returns (milvus.StringResponse) {} + + rpc WatchDmChannels(WatchDmChannelsRequest) returns (common.Status) {} + rpc FlushSegments(FlushSegmentsRequest) returns(common.Status) {} + + rpc ShowConfigurations(internal.ShowConfigurationsRequest) returns (internal.ShowConfigurationsResponse){} + // https://wiki.lfaidata.foundation/display/MIL/MEP+8+--+Add+metrics+for+proxy + rpc GetMetrics(milvus.GetMetricsRequest) returns (milvus.GetMetricsResponse) {} + + rpc Compaction(CompactionPlan) returns (common.Status) {} + rpc GetCompactionState(CompactionStateRequest) returns (CompactionStateResponse) {} + rpc SyncSegments(SyncSegmentsRequest) returns (common.Status) {} + + // https://wiki.lfaidata.foundation/display/MIL/MEP+24+--+Support+bulk+load + rpc Import(ImportTaskRequest) returns(common.Status) {} + + // Deprecated + rpc ResendSegmentStats(ResendSegmentStatsRequest) returns(ResendSegmentStatsResponse) {} + + rpc AddImportSegment(AddImportSegmentRequest) returns(AddImportSegmentResponse) {} + + rpc FlushChannels(FlushChannelsRequest) returns(common.Status) {} + rpc NotifyChannelOperation(ChannelOperationsRequest) returns(common.Status) {} + rpc CheckChannelOperationProgress(ChannelWatchInfo) returns(ChannelOperationProgressResponse) {} + + // import v2 + rpc PreImport(PreImportRequest) returns(common.Status) {} + rpc ImportV2(ImportRequest) returns(common.Status) {} + rpc QueryPreImport(QueryPreImportRequest) returns(QueryPreImportResponse) {} + rpc QueryImport(QueryImportRequest) returns(QueryImportResponse) {} + rpc DropImport(DropImportRequest) returns(common.Status) {} +} + +message FlushRequest { + common.MsgBase base = 1; + int64 dbID = 2; + repeated int64 segmentIDs = 3; + int64 collectionID = 4; + bool isImport = 5; +} + +message FlushResponse { + common.Status status = 1; + int64 dbID = 2; + int64 collectionID = 3; + repeated int64 segmentIDs = 4; // newly sealed segments + repeated int64 flushSegmentIDs = 5; // old flushed segment + int64 timeOfSeal = 6; + uint64 flush_ts = 7; +} + +message FlushChannelsRequest { + common.MsgBase base = 1; + uint64 flush_ts = 2; + repeated string channels = 3; +} + +message SegmentIDRequest { + uint32 count = 1; + string channel_name = 2; + int64 collectionID = 3; + int64 partitionID = 4; + bool isImport = 5; // Indicate whether this request comes from a bulk insert task. + int64 importTaskID = 6; // Needed for segment lock. + SegmentLevel level = 7; +} + +message AssignSegmentIDRequest { + int64 nodeID = 1; + string peer_role = 2; + repeated SegmentIDRequest segmentIDRequests = 3; +} + +message SegmentIDAssignment { + int64 segID = 1; + string channel_name = 2; + uint32 count = 3; + int64 collectionID = 4; + int64 partitionID = 5; + uint64 expire_time = 6; + common.Status status = 7; +} + +message AssignSegmentIDResponse { + repeated SegmentIDAssignment segIDAssignments = 1; + common.Status status = 2; +} + +message GetSegmentStatesRequest { + common.MsgBase base = 1; + repeated int64 segmentIDs = 2; +} + +message SegmentStateInfo { + int64 segmentID = 1; + common.SegmentState state = 2; + msg.MsgPosition start_position = 3; + msg.MsgPosition end_position = 4; + common.Status status = 5; +} + +message GetSegmentStatesResponse { + common.Status status = 1; + repeated SegmentStateInfo states = 2; +} + +message GetSegmentInfoRequest { + common.MsgBase base = 1; + repeated int64 segmentIDs = 2; + bool includeUnHealthy =3; +} + +message GetSegmentInfoResponse { + common.Status status = 1; + repeated SegmentInfo infos = 2; + map channel_checkpoint = 3; +} + +message GetInsertBinlogPathsRequest { + common.MsgBase base = 1; + int64 segmentID = 2; +} + +message GetInsertBinlogPathsResponse { + repeated int64 fieldIDs = 1; + repeated internal.StringList paths = 2; + common.Status status = 3; +} + +message GetCollectionStatisticsRequest { + common.MsgBase base = 1; + int64 dbID = 2; + int64 collectionID = 3; +} + +message GetCollectionStatisticsResponse { + repeated common.KeyValuePair stats = 1; + common.Status status = 2; +} + +message GetPartitionStatisticsRequest{ + common.MsgBase base = 1; + int64 dbID = 2; + int64 collectionID = 3; + repeated int64 partitionIDs = 4; +} + +message GetPartitionStatisticsResponse { + repeated common.KeyValuePair stats = 1; + common.Status status = 2; +} + +message GetSegmentInfoChannelRequest { +} + +message VchannelInfo { + int64 collectionID = 1; + string channelName = 2; + msg.MsgPosition seek_position = 3; + repeated SegmentInfo unflushedSegments = 4; // deprecated, keep it for compatibility + repeated SegmentInfo flushedSegments = 5; // deprecated, keep it for compatibility + repeated SegmentInfo dropped_segments = 6; // deprecated, keep it for compatibility + repeated int64 unflushedSegmentIds = 7; + repeated int64 flushedSegmentIds = 8; + repeated int64 dropped_segmentIds = 9; + repeated int64 indexed_segmentIds = 10; + repeated SegmentInfo indexed_segments = 11; + repeated int64 level_zero_segment_ids = 12; +} + +message WatchDmChannelsRequest { + common.MsgBase base = 1; + repeated VchannelInfo vchannels = 2; +} + +message FlushSegmentsRequest { + common.MsgBase base = 1; + int64 dbID = 2; + int64 collectionID = 3; + repeated int64 segmentIDs = 4; // segments to flush + string channelName = 5; // vchannel name to flush +} + +message SegmentMsg{ + common.MsgBase base = 1; + SegmentInfo segment = 2; +} + +message SegmentInfo { + int64 ID = 1; + int64 collectionID = 2; + int64 partitionID = 3; + string insert_channel = 4; + int64 num_of_rows = 5; + common.SegmentState state = 6; + int64 max_row_num = 7; + uint64 last_expire_time = 8; + msg.MsgPosition start_position = 9; + msg.MsgPosition dml_position = 10; + // binlogs consist of insert binlogs + repeated FieldBinlog binlogs = 11; + repeated FieldBinlog statslogs = 12; + // deltalogs consists of delete binlogs. FieldID is not used yet since delete is always applied on primary key + repeated FieldBinlog deltalogs = 13; + bool createdByCompaction = 14; + repeated int64 compactionFrom = 15; + uint64 dropped_at = 16; // timestamp when segment marked drop + // A flag indicating if: + // (1) this segment is created by bulk insert, and + // (2) the bulk insert task that creates this segment has not yet reached `ImportCompleted` state. + bool is_importing = 17; + bool is_fake = 18; + + // denote if this segment is compacted to other segment. + // For compatibility reasons, this flag of an old compacted segment may still be False. + // As for new fields added in the message, they will be populated with their respective field types' default values. + bool compacted = 19; + + // Segment level, indicating compaction segment level + // Available value: Legacy, L0, L1, L2 + // For legacy level, it represent old segment before segment level introduced + // so segments with Legacy level shall be treated as L1 segment + SegmentLevel level = 20; + int64 storage_version = 21; +} + +message SegmentStartPosition { + msg.MsgPosition start_position = 1; + int64 segmentID = 2; +} + +message SaveBinlogPathsRequest { + common.MsgBase base = 1; + int64 segmentID = 2; + int64 collectionID = 3; + repeated FieldBinlog field2BinlogPaths = 4; + repeated CheckPoint checkPoints = 5; + repeated SegmentStartPosition start_positions = 6; + bool flushed = 7; + repeated FieldBinlog field2StatslogPaths = 8; + repeated FieldBinlog deltalogs = 9; + bool dropped = 10; + bool importing = 11; + string channel = 12; // report channel name for verification + SegmentLevel seg_level =13; + int64 partitionID =14; // report partitionID for create L0 segment + int64 storageVersion = 15; +} + +message CheckPoint { + int64 segmentID = 1; + msg.MsgPosition position = 2; + int64 num_of_rows = 3; +} + +message DeltaLogInfo { + uint64 record_entries = 1; + uint64 timestamp_from = 2; + uint64 timestamp_to = 3; + string delta_log_path = 4; + int64 delta_log_size = 5; +} + +enum ChannelWatchState { + Uncomplete = 0; // deprecated, keep it for compatibility + Complete = 1; // deprecated, keep it for compatibility + ToWatch = 2; + WatchSuccess = 3; + WatchFailure = 4; + ToRelease = 5; + ReleaseSuccess = 6; + ReleaseFailure = 7; +} + +message ChannelStatus { + string name = 1; + ChannelWatchState state=2; + int64 collectionID = 3; +} + +message DataNodeInfo { + string address = 1; + int64 version = 2; + repeated ChannelStatus channels = 3; +} + +message SegmentBinlogs { + int64 segmentID = 1; + repeated FieldBinlog fieldBinlogs = 2; + int64 num_of_rows = 3; + repeated FieldBinlog statslogs = 4; + repeated FieldBinlog deltalogs = 5; + string insert_channel = 6; +} + +message FieldBinlog{ + int64 fieldID = 1; + repeated Binlog binlogs = 2; +} + +message Binlog { + int64 entries_num = 1; + uint64 timestamp_from = 2; + uint64 timestamp_to = 3; + // deprecated + string log_path = 4; + int64 log_size = 5; + int64 logID = 6; +} + +message GetRecoveryInfoResponse { + common.Status status = 1; + repeated VchannelInfo channels = 2; + repeated SegmentBinlogs binlogs = 3; +} + +message GetRecoveryInfoRequest { + common.MsgBase base = 1; + int64 collectionID = 2; + int64 partitionID = 3; +} + +message GetRecoveryInfoResponseV2 { + common.Status status = 1; + repeated VchannelInfo channels = 2; + repeated SegmentInfo segments = 3; +} + +message GetRecoveryInfoRequestV2 { + common.MsgBase base = 1; + int64 collectionID = 2; + repeated int64 partitionIDs = 3; +} + +message GetSegmentsByStatesRequest { + common.MsgBase base = 1; + int64 collectionID = 2; + int64 partitionID = 3; + repeated common.SegmentState states = 4; +} + +message GetSegmentsByStatesResponse { + common.Status status = 1; + repeated int64 segments = 2; +} + +message GetFlushedSegmentsRequest { + common.MsgBase base = 1; + int64 collectionID = 2; + int64 partitionID = 3; + bool includeUnhealthy = 4; +} + +message GetFlushedSegmentsResponse { + common.Status status = 1; + repeated int64 segments = 2; +} + +message SegmentFlushCompletedMsg { + common.MsgBase base = 1; + SegmentInfo segment = 2; +} + +message ChannelWatchInfo { + VchannelInfo vchan= 1; + int64 startTs = 2; + ChannelWatchState state = 3; + // the timeout ts, datanode shall do nothing after it + // NOT USED. + int64 timeoutTs = 4; + // the schema of the collection to watch, to avoid get schema rpc issues. + schema.CollectionSchema schema = 5; + // watch progress, deprecated + int32 progress = 6; + int64 opID = 7; +} + +enum CompactionType { + UndefinedCompaction = 0; + reserved 1; + MergeCompaction = 2; + MixCompaction = 3; + // compactionV2 + SingleCompaction = 4; + MinorCompaction = 5; + MajorCompaction = 6; + Level0DeleteCompaction = 7; +} + +message CompactionStateRequest { + common.MsgBase base = 1; +} + +message SyncSegmentsRequest { + int64 planID = 1; + int64 compacted_to = 2; + int64 num_of_rows = 3; + repeated int64 compacted_from = 4; + repeated FieldBinlog stats_logs = 5; + string channel_name = 6; + int64 partition_id = 7; + int64 collection_id = 8; +} + +message CompactionSegmentBinlogs { + int64 segmentID = 1; + repeated FieldBinlog fieldBinlogs = 2; + repeated FieldBinlog field2StatslogPaths = 3; + repeated FieldBinlog deltalogs = 4; + string insert_channel = 5; + SegmentLevel level = 6; + int64 collectionID = 7; + int64 partitionID = 8; +} + +message CompactionPlan { + int64 planID = 1; + repeated CompactionSegmentBinlogs segmentBinlogs = 2; + uint64 start_time = 3; + int32 timeout_in_seconds = 4; + CompactionType type = 5; + uint64 timetravel = 6; + string channel = 7; + int64 collection_ttl = 8; + int64 total_rows = 9; +} + +message CompactionSegment { + int64 planID = 1; // deprecated after 2.3.4 + int64 segmentID = 2; + int64 num_of_rows = 3; + repeated FieldBinlog insert_logs = 4; + repeated FieldBinlog field2StatslogPaths = 5; + repeated FieldBinlog deltalogs = 6; + string channel = 7; +} + +message CompactionPlanResult { + int64 planID = 1; + common.CompactionState state = 2; + repeated CompactionSegment segments = 3; + string channel = 4; + CompactionType type = 5; +} + +message CompactionStateResponse { + common.Status status = 1; + repeated CompactionPlanResult results = 2; +} + +// Deprecated +message SegmentFieldBinlogMeta { + int64 fieldID = 1; + string binlog_path = 2; +} + +message WatchChannelsRequest { + int64 collectionID = 1; + repeated string channelNames = 2; + repeated common.KeyDataPair start_positions = 3; + schema.CollectionSchema schema = 4; + uint64 create_timestamp = 5; +} + +message WatchChannelsResponse { + common.Status status = 1; +} + +message SetSegmentStateRequest { + common.MsgBase base = 1; + int64 segment_id = 2; + common.SegmentState new_state = 3; +} + +message SetSegmentStateResponse { + common.Status status = 1; +} + +message DropVirtualChannelRequest { + common.MsgBase base = 1; + string channel_name = 2; + repeated DropVirtualChannelSegment segments = 3; +} + +message DropVirtualChannelSegment { + int64 segmentID = 1; + int64 collectionID = 2; + repeated FieldBinlog field2BinlogPaths = 3; + repeated FieldBinlog field2StatslogPaths = 4; + repeated FieldBinlog deltalogs = 5; + msg.MsgPosition startPosition = 6; + msg.MsgPosition checkPoint = 7; + int64 numOfRows = 8; +} + +message DropVirtualChannelResponse { + common.Status status = 1; +} + +message ImportTask { + common.Status status = 1; + int64 collection_id = 2; // target collection ID + int64 partition_id = 3; // target partition ID + repeated string channel_names = 4; // target channel names of the collection. + bool row_based = 5; // the file is row-based or column-based + int64 task_id = 6; // id of the task + repeated string files = 7; // file paths to be imported + repeated common.KeyValuePair infos = 8; // extra information about the task, bucket, etc. + string database_name = 16; // Database name +} + +message ImportTaskState { + common.ImportState stateCode = 1; // Import state code. + repeated int64 segments = 2; // Ids of segments created in import task. + repeated int64 row_ids = 3; // Row IDs for the newly inserted rows. + int64 row_count = 4; // # of rows added in the import task. + string error_message = 5; // Error message for the failed task. +} + +message ImportTaskInfo { + int64 id = 1; // Task ID. + int64 request_id = 2 [deprecated = true]; // Request ID of the import task. + int64 datanode_id = 3; // ID of DataNode that processes the task. + int64 collection_id = 4; // Collection ID for the import task. + int64 partition_id = 5; // Partition ID for the import task. + repeated string channel_names = 6; // Names of channels for the collection. + string bucket = 7; // Bucket for the import task. + bool row_based = 8; // Boolean indicating whether import files are row-based or column-based. + repeated string files = 9; // A list of files to import. + int64 create_ts = 10; // Timestamp when the import task is created. + ImportTaskState state = 11; // State of the import task. + string collection_name = 12; // Collection name for the import task. + string partition_name = 13; // Partition name for the import task. + repeated common.KeyValuePair infos = 14; // extra information about the task, bucket, etc. + int64 start_ts = 15; // Timestamp when the import task is sent to datanode to execute. + string database_name = 16; // Database name +} + +message ImportTaskResponse { + common.Status status = 1; + int64 datanode_id = 2; // which datanode takes this task +} + +message ImportTaskRequest { + common.MsgBase base = 1; + ImportTask import_task = 2; // Target import task. + repeated int64 working_nodes = 3; // DataNodes that are currently working. +} + +message UpdateSegmentStatisticsRequest { + common.MsgBase base = 1; + repeated common.SegmentStats stats = 2; +} + +message UpdateChannelCheckpointRequest { + common.MsgBase base = 1; + string vChannel = 2; // deprecated, keep it for compatibility + msg.MsgPosition position = 3; // deprecated, keep it for compatibility + repeated msg.MsgPosition channel_checkpoints = 4; +} + +message ResendSegmentStatsRequest { + common.MsgBase base = 1; +} + +message ResendSegmentStatsResponse { + common.Status status = 1; + repeated int64 seg_resent = 2; +} + +message AddImportSegmentRequest { + common.MsgBase base = 1; + int64 segment_id = 2; + string channel_name = 3; + int64 collection_id = 4; + int64 partition_id = 5; + int64 row_num = 6; + repeated FieldBinlog stats_log = 7; +} + +message AddImportSegmentResponse { + common.Status status = 1; + bytes channel_pos = 2; // deprecated +} + +message SaveImportSegmentRequest { + common.MsgBase base = 1; + int64 segment_id = 2; + string channel_name = 3; + int64 collection_id = 4; + int64 partition_id = 5; + int64 row_num = 6; + SaveBinlogPathsRequest save_binlog_path_req = 7; + bytes dml_position_id = 8; +} + +message UnsetIsImportingStateRequest { + common.MsgBase base = 1; + repeated int64 segment_ids = 2; // IDs of segments whose `isImport` states need to be unset. +} + +message MarkSegmentsDroppedRequest { + common.MsgBase base = 1; + repeated int64 segment_ids = 2; // IDs of segments that needs to be marked as `dropped`. +} + +message SegmentReferenceLock { + int64 taskID = 1; + int64 nodeID = 2; + repeated int64 segmentIDs = 3; +} + + +message AlterCollectionRequest { + int64 collectionID = 1; + schema.CollectionSchema schema = 2; + repeated int64 partitionIDs = 3; + repeated common.KeyDataPair start_positions = 4; + repeated common.KeyValuePair properties = 5; +} + +message GcConfirmRequest { + int64 collection_id = 1; + int64 partition_id = 2; // -1 means whole collection. +} + +message GcConfirmResponse { + common.Status status = 1; + bool gc_finished = 2; +} + +message ReportDataNodeTtMsgsRequest { + common.MsgBase base = 1; + repeated msg.DataNodeTtMsg msgs = 2; // -1 means whole collection. +} + +message GetFlushStateRequest { + repeated int64 segmentIDs = 1; + uint64 flush_ts = 2; + string db_name = 3; + string collection_name = 4; + int64 collectionID = 5; +} + +message ChannelOperationsRequest { + repeated ChannelWatchInfo infos = 1; +} + +message ChannelOperationProgressResponse { + common.Status status = 1; + int64 opID = 2; + ChannelWatchState state = 3; + int32 progress = 4; +} + +message PreImportRequest { + string clusterID = 1; + int64 jobID = 2; + int64 taskID = 3; + int64 collectionID = 4; + repeated int64 partitionIDs = 5; + repeated string vchannels = 6; + schema.CollectionSchema schema = 7; + repeated internal.ImportFile import_files = 8; + repeated common.KeyValuePair options = 9; +} + +message autoIDRange { + int64 begin = 1; + int64 end = 2; +} + +message ImportRequestSegment { + int64 segmentID = 1; + int64 partitionID = 2; + string vchannel = 3; +} + +message ImportRequest { + string clusterID = 1; + int64 jobID = 2; + int64 taskID = 3; + int64 collectionID = 4; + repeated int64 partitionIDs = 5; + repeated string vchannels = 6; + schema.CollectionSchema schema = 7; + repeated internal.ImportFile files = 8; + repeated common.KeyValuePair options = 9; + uint64 ts = 10; + autoIDRange autoID_range = 11; + repeated ImportRequestSegment request_segments = 12; +} + +message QueryPreImportRequest { + string clusterID = 1; + int64 jobID = 2; + int64 taskID = 3; +} + +message PartitionImportStats { + map partition_rows = 1; // partitionID -> numRows + map partition_data_size = 2; // partitionID -> dataSize +} + +message ImportFileStats { + internal.ImportFile import_file = 1; + int64 file_size = 2; + int64 total_rows = 3; + int64 total_memory_size = 4; + map hashed_stats = 5; // channel -> PartitionImportStats +} + +message QueryPreImportResponse { + common.Status status = 1; + int64 taskID = 2; + ImportTaskStateV2 state = 3; + string reason = 4; + int64 slots = 5; + repeated ImportFileStats file_stats = 6; +} + +message QueryImportRequest { + string clusterID = 1; + int64 jobID = 2; + int64 taskID = 3; + bool querySlot = 4; +} + +message ImportSegmentInfo { + int64 segmentID = 1; + int64 imported_rows = 2; + repeated FieldBinlog binlogs = 3; + repeated FieldBinlog statslogs = 4; +} + +message QueryImportResponse { + common.Status status = 1; + int64 taskID = 2; + ImportTaskStateV2 state = 3; + string reason = 4; + int64 slots = 5; + repeated ImportSegmentInfo import_segments_info = 6; +} + +message DropImportRequest { + string clusterID = 1; + int64 jobID = 2; + int64 taskID = 3; +} + +message ImportJob { + int64 jobID = 1; + int64 dbID = 2; + int64 collectionID = 3; + repeated int64 partitionIDs = 4; + repeated string vchannels = 5; + schema.CollectionSchema schema = 6; + uint64 timeout_ts = 7; + uint64 cleanup_ts = 8; + internal.ImportJobState state = 9; + string reason = 10; + repeated internal.ImportFile files = 11; + repeated common.KeyValuePair options = 12; +} + +enum ImportTaskStateV2 { + None = 0; + Pending = 1; + InProgress = 2; + Failed = 3; + Completed = 4; +} + +message PreImportTask { + int64 jobID = 1; + int64 taskID = 2; + int64 collectionID = 3; + int64 nodeID = 6; + ImportTaskStateV2 state = 7; + string reason = 8; + repeated ImportFileStats file_stats = 10; +} + +message ImportTaskV2 { + int64 jobID = 1; + int64 taskID = 2; + int64 collectionID = 3; + repeated int64 segmentIDs = 4; + int64 nodeID = 5; + ImportTaskStateV2 state = 6; + string reason = 7; + repeated ImportFileStats file_stats = 9; +} + +enum GcCommand { + _ = 0; + Pause = 1; + Resume = 2; +} + +message GcControlRequest { + common.MsgBase base = 1; + GcCommand command = 2; + repeated common.KeyValuePair params = 3; +} diff --git a/all_proto/etcd_meta.proto b/all_proto/etcd_meta.proto new file mode 100644 index 0000000..d84197f --- /dev/null +++ b/all_proto/etcd_meta.proto @@ -0,0 +1,127 @@ +syntax = "proto3"; +package milvus.proto.etcd; +option go_package="github.com/milvus-io/milvus/internal/proto/etcdpb"; + +import "common.proto"; +import "schema.proto"; + +// this proto only used to describe object that will persist into etcd + +message IndexInfo { + string index_name = 1; + int64 indexID = 2; + repeated common.KeyValuePair index_params = 3; + bool deleted = 4; + uint64 create_time = 5; +} + +message FieldIndexInfo{ + int64 filedID = 1; + int64 indexID = 2; +} + +enum DatabaseState { + DatabaseUnknown = 0; + DatabaseCreated = 1; + DatabaseCreating = 2; + DatabaseDropping = 3; + DatabaseDropped = 4; +} + +enum CollectionState { + CollectionCreated = 0; + CollectionCreating = 1; + CollectionDropping = 2; + CollectionDropped = 3; +} + +enum PartitionState { + PartitionCreated = 0; + PartitionCreating = 1; + PartitionDropping = 2; + PartitionDropped = 3; +} + +enum AliasState { + AliasCreated = 0; + AliasCreating = 1; + AliasDropping = 2; + AliasDropped = 3; +} + +message CollectionInfo { + int64 ID = 1; + schema.CollectionSchema schema = 2; + uint64 create_time = 3; + // deprecate + repeated int64 partitionIDs = 4; + // deprecate + repeated string partitionNames = 5; + // deprecate + repeated FieldIndexInfo field_indexes = 6; + repeated string virtual_channel_names = 7; + repeated string physical_channel_names = 8; + // deprecate + repeated uint64 partition_created_timestamps = 9; + int32 shards_num = 10; + repeated common.KeyDataPair start_positions = 11; + common.ConsistencyLevel consistency_level = 12; + CollectionState state = 13; // To keep compatible with older version, default state is `Created`. + repeated common.KeyValuePair properties = 14; + int64 db_id = 15; +} + +message PartitionInfo { + int64 partitionID = 1; + string partitionName = 2; + uint64 partition_created_timestamp = 3; + int64 collection_id = 4; + PartitionState state = 5; // To keep compatible with older version, default state is `Created`. +} + +message AliasInfo { + string alias_name = 1; + int64 collection_id = 2; + uint64 created_time = 3; + AliasState state = 4; // To keep compatible with older version, default state is `Created`. + int64 db_id = 5; +} + +message DatabaseInfo { + string tenant_id = 1; + string name = 2; + int64 id = 3; + DatabaseState state = 4; + uint64 created_time = 5; +} + +message SegmentIndexInfo { + int64 collectionID = 1; + int64 partitionID = 2; + int64 segmentID = 3; + int64 fieldID = 4; + int64 indexID = 5; + int64 buildID = 6; + bool enable_index = 7; + uint64 create_time = 8; +} + +// TODO move to proto files of interprocess communication +message CollectionMeta { + int64 ID=1; + schema.CollectionSchema schema=2; + uint64 create_time=3; + repeated int64 segmentIDs=4; + repeated string partition_tags=5; + repeated int64 partitionIDs=6; +} + +message CredentialInfo { + string username = 1; + // encrypted by bcrypt (for higher security level) + string encrypted_password = 2; + string tenant = 3; + bool is_super = 4; + // encrypted by sha256 (for good performance in cache mapping) + string sha256_password = 5; +} diff --git a/all_proto/feder.proto b/all_proto/feder.proto new file mode 100644 index 0000000..4f59987 --- /dev/null +++ b/all_proto/feder.proto @@ -0,0 +1,40 @@ +syntax = "proto3"; +package milvus.proto.feder; +option go_package = "github.com/milvus-io/milvus-proto/go-api/v2/federpb"; + +import "common.proto"; + +message SegmentIndexData { + int64 segmentID = 1; + string index_data = 2; // data from knownwhere +} + +message FederSegmentSearchResult { + int64 segmentID = 1; + string visit_info = 2; +} + +message ListIndexedSegmentRequest { + common.MsgBase base = 1; + string collection_name = 2; + string index_name = 3; +} + +message ListIndexedSegmentResponse { + common.Status status = 1; + repeated int64 segmentIDs = 2; +} + +message DescribeSegmentIndexDataRequest { + common.MsgBase base = 1; + string collection_name = 2; + string index_name = 3; + repeated int64 segmentsIDs = 4; +} + +message DescribeSegmentIndexDataResponse { + common.Status status = 1; + // segmentID => segmentIndexData + map index_data = 2; + repeated common.KeyValuePair index_params = 3; +} diff --git a/all_proto/index_cgo_msg.proto b/all_proto/index_cgo_msg.proto new file mode 100755 index 0000000..50b1ea5 --- /dev/null +++ b/all_proto/index_cgo_msg.proto @@ -0,0 +1,32 @@ +syntax = "proto3"; + +package milvus.proto.indexcgo; +option go_package="github.com/milvus-io/milvus/internal/proto/indexcgopb"; + +import "common.proto"; + +message TypeParams { + repeated common.KeyValuePair params = 1; +} + +message IndexParams { + repeated common.KeyValuePair params = 1; +} + +// TypeParams & IndexParams will be replaced by MapParams later +message MapParams { + repeated common.KeyValuePair params = 1; +} + +message MapParamsV2 { + map params = 1; +} + +message Binary { + string key = 1; + bytes value = 2; +} + +message BinarySet { + repeated Binary datas = 1; +} diff --git a/all_proto/index_coord.proto b/all_proto/index_coord.proto new file mode 100644 index 0000000..bd07b8c --- /dev/null +++ b/all_proto/index_coord.proto @@ -0,0 +1,345 @@ +syntax = "proto3"; + +package milvus.proto.index; + +option go_package = "github.com/milvus-io/milvus/internal/proto/indexpb"; + +import "common.proto"; +import "internal.proto"; +import "milvus.proto"; +import "schema.proto"; + +service IndexCoord { + rpc GetComponentStates(milvus.GetComponentStatesRequest) returns (milvus.ComponentStates) {} + rpc GetStatisticsChannel(internal.GetStatisticsChannelRequest) returns(milvus.StringResponse){} + rpc CreateIndex(CreateIndexRequest) returns (common.Status){} + rpc AlterIndex(AlterIndexRequest) returns (common.Status){} + // Deprecated: use DescribeIndex instead + rpc GetIndexState(GetIndexStateRequest) returns (GetIndexStateResponse) {} + rpc GetSegmentIndexState(GetSegmentIndexStateRequest) returns (GetSegmentIndexStateResponse) {} + rpc GetIndexInfos(GetIndexInfoRequest) returns (GetIndexInfoResponse){} + rpc DropIndex(DropIndexRequest) returns (common.Status) {} + rpc DescribeIndex(DescribeIndexRequest) returns (DescribeIndexResponse) {} + rpc GetIndexStatistics(GetIndexStatisticsRequest) returns (GetIndexStatisticsResponse) {} + // Deprecated: use DescribeIndex instead + rpc GetIndexBuildProgress(GetIndexBuildProgressRequest) returns (GetIndexBuildProgressResponse) {} + + rpc ShowConfigurations(internal.ShowConfigurationsRequest) + returns (internal.ShowConfigurationsResponse) { + } + // https://wiki.lfaidata.foundation/display/MIL/MEP+8+--+Add+metrics+for+proxy + rpc GetMetrics(milvus.GetMetricsRequest) + returns (milvus.GetMetricsResponse) { + } + + rpc CheckHealth(milvus.CheckHealthRequest) + returns (milvus.CheckHealthResponse) { + } +} + +service IndexNode { + rpc GetComponentStates(milvus.GetComponentStatesRequest) + returns (milvus.ComponentStates) { + } + rpc GetStatisticsChannel(internal.GetStatisticsChannelRequest) + returns (milvus.StringResponse) { + } + rpc CreateJob(CreateJobRequest) returns (common.Status) { + } + rpc QueryJobs(QueryJobsRequest) returns (QueryJobsResponse) { + } + rpc DropJobs(DropJobsRequest) returns (common.Status) { + } + rpc GetJobStats(GetJobStatsRequest) returns (GetJobStatsResponse) { + } + + rpc ShowConfigurations(internal.ShowConfigurationsRequest) + returns (internal.ShowConfigurationsResponse) { + } + // https://wiki.lfaidata.foundation/display/MIL/MEP+8+--+Add+metrics+for+proxy + rpc GetMetrics(milvus.GetMetricsRequest) + returns (milvus.GetMetricsResponse) { + } +} + +message IndexInfo { + int64 collectionID = 1; + int64 fieldID = 2; + string index_name = 3; + int64 indexID = 4; + repeated common.KeyValuePair type_params = 5; + repeated common.KeyValuePair index_params = 6; + // index build progress + // The real-time statistics may not be expected due to the existence of the compaction mechanism. + int64 indexed_rows = 7; + int64 total_rows = 8; + // index state + common.IndexState state = 9; + string index_state_fail_reason = 10; + bool is_auto_index = 11; + repeated common.KeyValuePair user_index_params = 12; + int64 pending_index_rows = 13; +} + +message FieldIndex { + IndexInfo index_info = 1; + bool deleted = 2; + uint64 create_time = 3; +} + +message SegmentIndex { + int64 collectionID = 1; + int64 partitionID = 2; + int64 segmentID = 3; + int64 num_rows = 4; + int64 indexID = 5; + int64 buildID = 6; + int64 nodeID = 7; + int64 index_version = 8; + common.IndexState state = 9; + string fail_reason = 10; + repeated string index_file_keys = 11; + bool deleted = 12; + uint64 create_time = 13; + uint64 serialize_size = 14; + bool write_handoff = 15; + int32 current_index_version = 16; + int64 index_store_version = 17; +} + +message RegisterNodeRequest { + common.MsgBase base = 1; + common.Address address = 2; + int64 nodeID = 3; +} + +message RegisterNodeResponse { + common.Status status = 1; + internal.InitParams init_params = 2; +} + +message GetIndexStateRequest { + int64 collectionID = 1; + string index_name = 2; +} + +message GetIndexStateResponse { + common.Status status = 1; + common.IndexState state = 2; + string fail_reason = 3; +} + +message GetSegmentIndexStateRequest { + int64 collectionID = 1; + string index_name = 2; + repeated int64 segmentIDs = 3; +} + +message SegmentIndexState { + int64 segmentID = 1; + common.IndexState state = 2; + string fail_reason = 3; + string index_name = 4; +} + +message GetSegmentIndexStateResponse { + common.Status status = 1; + repeated SegmentIndexState states = 2; +} + +message CreateIndexRequest { + int64 collectionID = 1; + int64 fieldID = 2; + string index_name = 3; + repeated common.KeyValuePair type_params = 4; + repeated common.KeyValuePair index_params = 5; + uint64 timestamp = 6; + bool is_auto_index = 7; + repeated common.KeyValuePair user_index_params = 8; +} + +message AlterIndexRequest { + int64 collectionID = 1; + string index_name = 2; + repeated common.KeyValuePair params = 3; +} + +message GetIndexInfoRequest { + int64 collectionID = 1; + repeated int64 segmentIDs = 2; + string index_name = 3; +} + +message IndexFilePathInfo { + int64 segmentID = 1; + int64 fieldID = 2; + int64 indexID = 3; + int64 buildID = 4; + string index_name = 5; + repeated common.KeyValuePair index_params = 6; + repeated string index_file_paths = 7; + uint64 serialized_size = 8; + int64 index_version = 9; + int64 num_rows = 10; + int32 current_index_version = 11; +} + +message SegmentInfo { + int64 collectionID = 1; + int64 segmentID = 2; + bool enable_index = 3; + repeated IndexFilePathInfo index_infos = 4; +} + +message GetIndexInfoResponse { + common.Status status = 1; + map segment_info = 2; +} + +message DropIndexRequest { + int64 collectionID = 1; + repeated int64 partitionIDs = 2; + string index_name = 3; + bool drop_all = 4; +} + +message DescribeIndexRequest { + int64 collectionID = 1; + string index_name = 2; + uint64 timestamp = 3; +} + +message DescribeIndexResponse { + common.Status status = 1; + repeated IndexInfo index_infos = 2; +} + +message GetIndexBuildProgressRequest { + int64 collectionID = 1; + string index_name = 2; +} + +message GetIndexBuildProgressResponse { + common.Status status = 1; + int64 indexed_rows = 2; + int64 total_rows = 3; + int64 pending_index_rows = 4; +} + +message StorageConfig { + string address = 1; + string access_keyID = 2; + string secret_access_key = 3; + bool useSSL = 4; + string bucket_name = 5; + string root_path = 6; + bool useIAM = 7; + string IAMEndpoint = 8; + string storage_type = 9; + bool use_virtual_host = 10; + string region = 11; + string cloud_provider = 12; + int64 request_timeout_ms = 13; +} + +message OptionalFieldInfo { + int64 fieldID = 1; + string field_name = 2; + int32 field_type = 3; + repeated string data_paths = 4; + repeated int64 data_ids = 5; +} + +message CreateJobRequest { + string clusterID = 1; + string index_file_prefix = 2; + int64 buildID = 3; + repeated string data_paths = 4; + int64 index_version = 5; + int64 indexID = 6; + string index_name = 7; + StorageConfig storage_config = 8; + repeated common.KeyValuePair index_params = 9; + repeated common.KeyValuePair type_params = 10; + int64 num_rows = 11; + int32 current_index_version = 12; + int64 collectionID = 13; + int64 partitionID = 14; + int64 segmentID = 15; + int64 fieldID = 16; + string field_name = 17; + schema.DataType field_type = 18; + string store_path = 19; + int64 store_version = 20; + string index_store_path = 21; + int64 dim = 22; + repeated int64 data_ids = 23; + repeated OptionalFieldInfo optional_scalar_fields = 24; +} + +message QueryJobsRequest { + string clusterID = 1; + repeated int64 buildIDs = 2; +} + +message IndexTaskInfo { + int64 buildID = 1; + common.IndexState state = 2; + repeated string index_file_keys = 3; + uint64 serialized_size = 4; + string fail_reason = 5; + int32 current_index_version = 6; + int64 index_store_version = 7; +} + +message QueryJobsResponse { + common.Status status = 1; + string clusterID = 2; + repeated IndexTaskInfo index_infos = 3; +} + +message DropJobsRequest { + string clusterID = 1; + repeated int64 buildIDs = 2; +} + +message JobInfo { + int64 num_rows = 1; + int64 dim = 2; + int64 start_time = 3; + int64 end_time = 4; + repeated common.KeyValuePair index_params = 5; + int64 podID = 6; +} + +message GetJobStatsRequest { +} + +message GetJobStatsResponse { + common.Status status = 1; + int64 total_job_num = 2; + int64 in_progress_job_num = 3; + int64 enqueue_job_num = 4; + int64 task_slots = 5; + repeated JobInfo job_infos = 6; + bool enable_disk = 7; +} + +message GetIndexStatisticsRequest { + int64 collectionID = 1; + string index_name = 2; +} + +message GetIndexStatisticsResponse { + common.Status status = 1; + repeated IndexInfo index_infos = 2; +} + +message ListIndexesRequest { + int64 collectionID = 1; +} + +message ListIndexesResponse { + common.Status status = 1; + repeated IndexInfo index_infos = 2; +} diff --git a/all_proto/internal.proto b/all_proto/internal.proto new file mode 100644 index 0000000..572ecc1 --- /dev/null +++ b/all_proto/internal.proto @@ -0,0 +1,333 @@ +syntax = "proto3"; +package milvus.proto.internal; +option go_package = "github.com/milvus-io/milvus/internal/proto/internalpb"; + +import "common.proto"; +import "schema.proto"; + +message GetTimeTickChannelRequest { +} + +message GetStatisticsChannelRequest { +} + +message GetDdChannelRequest { +} + +message NodeInfo { + common.Address address = 1; + string role = 2; +} + +message InitParams { + int64 nodeID = 1; + repeated common.KeyValuePair start_params = 2; +} + +message StringList { + repeated string values = 1; + common.Status status = 2; +} + +message GetStatisticsRequest { + common.MsgBase base = 1; + // Not useful for now + int64 dbID = 2; + // The collection you want get statistics + int64 collectionID = 3; + // The partitions you want get statistics + repeated int64 partitionIDs = 4; + // timestamp of the statistics + uint64 travel_timestamp = 5; + uint64 guarantee_timestamp = 6; + uint64 timeout_timestamp = 7; +} + +message GetStatisticsResponse { + common.MsgBase base = 1; + // Contain error_code and reason + common.Status status = 2; + // Collection statistics data. Contain pairs like {"row_count": "1"} + repeated common.KeyValuePair stats = 3; +} + +message CreateAliasRequest { + common.MsgBase base = 1; + string db_name = 2; + string collection_name = 3; + string alias = 4; +} + +message DropAliasRequest { + common.MsgBase base = 1; + string db_name = 2; + string alias = 3; +} + +message AlterAliasRequest{ + common.MsgBase base = 1; + string db_name = 2; + string collection_name = 3; + string alias = 4; +} + +message CreateIndexRequest { + common.MsgBase base = 1; + string db_name = 2; + string collection_name = 3; + string field_name = 4; + int64 dbID = 5; + int64 collectionID = 6; + int64 fieldID = 7; + repeated common.KeyValuePair extra_params = 8; +} + +message SearchRequest { + common.MsgBase base = 1; + int64 reqID = 2; + int64 dbID = 3; + int64 collectionID = 4; + repeated int64 partitionIDs = 5; + string dsl = 6; + // serialized `PlaceholderGroup` + bytes placeholder_group = 7; + common.DslType dsl_type = 8; + bytes serialized_expr_plan = 9; + repeated int64 output_fields_id = 10; + uint64 mvcc_timestamp = 11; + uint64 guarantee_timestamp = 12; + uint64 timeout_timestamp = 13; + int64 nq = 14; + int64 topk = 15; + string metricType = 16; + bool ignoreGrowing = 17; // Optional + string username = 18; +} + +message HybridSearchRequest { + common.MsgBase base = 1; + int64 reqID = 2; + int64 dbID = 3; + int64 collectionID = 4; + repeated int64 partitionIDs = 5; + repeated SearchRequest reqs = 6; + uint64 mvcc_timestamp = 11; + uint64 guarantee_timestamp = 12; + uint64 timeout_timestamp = 13; +} + +message SearchResults { + common.MsgBase base = 1; + common.Status status = 2; + int64 reqID = 3; + string metric_type = 4; + int64 num_queries = 5; + int64 top_k = 6; + repeated int64 sealed_segmentIDs_searched = 7; + repeated string channelIDs_searched = 8; + repeated int64 global_sealed_segmentIDs = 9; + // schema.SearchResultsData inside + bytes sliced_blob = 10; + int64 sliced_num_count = 11; + int64 sliced_offset = 12; + + // search request cost + CostAggregation costAggregation = 13; + map channels_mvcc = 14; + int64 all_search_count = 15; +} + +message CostAggregation { + int64 responseTime = 1; + int64 serviceTime = 2; + int64 totalNQ = 3; +} + +message RetrieveRequest { + common.MsgBase base = 1; + int64 reqID = 2; + int64 dbID = 3; + int64 collectionID = 4; + repeated int64 partitionIDs = 5; + bytes serialized_expr_plan = 6; + repeated int64 output_fields_id = 7; + uint64 mvcc_timestamp = 8; + uint64 guarantee_timestamp = 9; + uint64 timeout_timestamp = 10; + int64 limit = 11; // Optional + bool ignoreGrowing = 12; + bool is_count = 13; + int64 iteration_extension_reduce_rate = 14; + string username = 15; + bool reduce_stop_for_best = 16; +} + + + +message RetrieveResults { + common.MsgBase base = 1; + common.Status status = 2; + int64 reqID = 3; + schema.IDs ids = 4; + repeated schema.FieldData fields_data = 5; + repeated int64 sealed_segmentIDs_retrieved = 6; + repeated string channelIDs_retrieved = 7; + repeated int64 global_sealed_segmentIDs = 8; + + // query request cost + CostAggregation costAggregation = 13; + int64 all_retrieve_count = 14; +} + +message LoadIndex { + common.MsgBase base = 1; + int64 segmentID = 2; + string fieldName = 3; + int64 fieldID = 4; + repeated string index_paths = 5; + repeated common.KeyValuePair index_params = 6; +} + +message IndexStats { + repeated common.KeyValuePair index_params = 1; + int64 num_related_segments = 2; +} + +message FieldStats { + int64 collectionID = 1; + int64 fieldID = 2; + repeated IndexStats index_stats = 3; +} + +message SegmentStats { + int64 segmentID = 1; + int64 memory_size = 2; + int64 num_rows = 3; + bool recently_modified = 4; +} + +message ChannelTimeTickMsg { + common.MsgBase base = 1; + repeated string channelNames = 2; + repeated uint64 timestamps = 3; + uint64 default_timestamp = 4; +} + +message CredentialInfo { + string username = 1; + // encrypted by bcrypt (for higher security level) + string encrypted_password = 2; + string tenant = 3; + bool is_super = 4; + // encrypted by sha256 (for good performance in cache mapping) + string sha256_password = 5; +} + +message ListPolicyRequest { + // Not useful for now + common.MsgBase base = 1; +} + +message ListPolicyResponse { + // Contain error_code and reason + common.Status status = 1; + repeated string policy_infos = 2; + repeated string user_roles = 3; +} + +message ShowConfigurationsRequest { + common.MsgBase base = 1; + string pattern = 2; +} + +message ShowConfigurationsResponse { + common.Status status = 1; + repeated common.KeyValuePair configuations = 2; +} + +enum RateType { + DDLCollection = 0; + DDLPartition = 1; + DDLIndex = 2; + DDLFlush = 3; + DDLCompaction = 4; + DMLInsert = 5; + DMLDelete = 6; + DMLBulkLoad = 7; + DQLSearch = 8; + DQLQuery = 9; + DMLUpsert = 10; +} + +message Rate { + RateType rt = 1; + double r = 2; +} + +enum ImportJobState { + None = 0; + Pending = 1; + PreImporting = 2; + Importing = 3; + Failed = 4; + Completed = 5; +} + +message ImportFile { + int64 id = 1; + // A singular row-based file or multiple column-based files. + repeated string paths = 2; +} + +message ImportRequestInternal { + int64 dbID = 1; + int64 collectionID = 2; + repeated int64 partitionIDs = 3; + repeated string channel_names = 4; + schema.CollectionSchema schema = 5; + repeated ImportFile files = 6; + repeated common.KeyValuePair options = 7; +} + +message ImportRequest { + string db_name = 1; + string collection_name = 2; + string partition_name = 3; + repeated ImportFile files = 4; + repeated common.KeyValuePair options = 5; +} + +message ImportResponse { + common.Status status = 1; + string jobID = 2; +} + +message GetImportProgressRequest { + string db_name = 1; + string jobID = 2; +} + +message GetImportProgressResponse { + common.Status status = 1; + ImportJobState state = 2; + string reason = 3; + int64 progress = 4; +} + +message ListImportsRequestInternal { + int64 dbID = 1; + int64 collectionID = 2; +} + +message ListImportsRequest { + string db_name = 1; + string collection_name = 2; +} + +message ListImportsResponse { + common.Status status = 1; + repeated string jobIDs = 2; + repeated ImportJobState states = 3; + repeated string reasons = 4; + repeated int64 progresses = 5; +} diff --git a/all_proto/milvus.proto b/all_proto/milvus.proto new file mode 100644 index 0000000..5ed5e45 --- /dev/null +++ b/all_proto/milvus.proto @@ -0,0 +1,1835 @@ +syntax = "proto3"; +package milvus.proto.milvus; + +option go_package = "github.com/milvus-io/milvus-proto/go-api/v2/milvuspb"; + +option java_multiple_files = true; +option java_package = "io.milvus.grpc"; +option java_outer_classname = "MilvusProto"; +option java_generate_equals_and_hash = true; + +option csharp_namespace = "Milvus.Client.Grpc"; + +import "common.proto"; +import "rg.proto"; +import "schema.proto"; +import "feder.proto"; +import "msg.proto"; +import "google/protobuf/descriptor.proto"; + +service MilvusService { + rpc CreateCollection(CreateCollectionRequest) returns (common.Status) {} + rpc DropCollection(DropCollectionRequest) returns (common.Status) {} + rpc HasCollection(HasCollectionRequest) returns (BoolResponse) {} + rpc LoadCollection(LoadCollectionRequest) returns (common.Status) {} + rpc ReleaseCollection(ReleaseCollectionRequest) returns (common.Status) {} + rpc DescribeCollection(DescribeCollectionRequest) returns (DescribeCollectionResponse) {} + rpc GetCollectionStatistics(GetCollectionStatisticsRequest) returns (GetCollectionStatisticsResponse) {} + rpc ShowCollections(ShowCollectionsRequest) returns (ShowCollectionsResponse) {} + rpc AlterCollection(AlterCollectionRequest) returns (common.Status) {} + + rpc CreatePartition(CreatePartitionRequest) returns (common.Status) {} + rpc DropPartition(DropPartitionRequest) returns (common.Status) {} + rpc HasPartition(HasPartitionRequest) returns (BoolResponse) {} + rpc LoadPartitions(LoadPartitionsRequest) returns (common.Status) {} + rpc ReleasePartitions(ReleasePartitionsRequest) returns (common.Status) {} + rpc GetPartitionStatistics(GetPartitionStatisticsRequest) returns (GetPartitionStatisticsResponse) {} + rpc ShowPartitions(ShowPartitionsRequest) returns (ShowPartitionsResponse) {} + + rpc GetLoadingProgress(GetLoadingProgressRequest) returns (GetLoadingProgressResponse) {} + rpc GetLoadState(GetLoadStateRequest) returns (GetLoadStateResponse) {} + + rpc CreateAlias(CreateAliasRequest) returns (common.Status) {} + rpc DropAlias(DropAliasRequest) returns (common.Status) {} + rpc AlterAlias(AlterAliasRequest) returns (common.Status) {} + rpc DescribeAlias(DescribeAliasRequest) returns (DescribeAliasResponse) {} + rpc ListAliases(ListAliasesRequest) returns (ListAliasesResponse) {} + + rpc CreateIndex(CreateIndexRequest) returns (common.Status) {} + rpc AlterIndex(AlterIndexRequest) returns (common.Status) {} + rpc DescribeIndex(DescribeIndexRequest) returns (DescribeIndexResponse) {} + rpc GetIndexStatistics(GetIndexStatisticsRequest) returns (GetIndexStatisticsResponse) {} + // Deprecated: use DescribeIndex instead + rpc GetIndexState(GetIndexStateRequest) returns (GetIndexStateResponse) { + option deprecated = true; + } + // Deprecated: use DescribeIndex instead + rpc GetIndexBuildProgress(GetIndexBuildProgressRequest) returns (GetIndexBuildProgressResponse) { + option deprecated = true; + } + rpc DropIndex(DropIndexRequest) returns (common.Status) {} + + rpc Insert(InsertRequest) returns (MutationResult) {} + rpc Delete(DeleteRequest) returns (MutationResult) {} + rpc Upsert(UpsertRequest) returns (MutationResult) {} + rpc Search(SearchRequest) returns (SearchResults) {} + rpc HybridSearch(HybridSearchRequest) returns (SearchResults) {} + rpc Flush(FlushRequest) returns (FlushResponse) {} + rpc Query(QueryRequest) returns (QueryResults) {} + rpc CalcDistance(CalcDistanceRequest) returns (CalcDistanceResults) {} + rpc FlushAll(FlushAllRequest) returns (FlushAllResponse) {} + + rpc GetFlushState(GetFlushStateRequest) returns (GetFlushStateResponse) {} + rpc GetFlushAllState(GetFlushAllStateRequest) returns (GetFlushAllStateResponse) {} + rpc GetPersistentSegmentInfo(GetPersistentSegmentInfoRequest) returns (GetPersistentSegmentInfoResponse) {} + rpc GetQuerySegmentInfo(GetQuerySegmentInfoRequest) returns (GetQuerySegmentInfoResponse) {} + rpc GetReplicas(GetReplicasRequest) returns (GetReplicasResponse) {} + + rpc Dummy(DummyRequest) returns (DummyResponse) {} + + // TODO: remove + rpc RegisterLink(RegisterLinkRequest) returns (RegisterLinkResponse) {} + + // https://wiki.lfaidata.foundation/display/MIL/MEP+8+--+Add+metrics+for+proxy + rpc GetMetrics(GetMetricsRequest) returns (GetMetricsResponse) {} + rpc GetComponentStates(GetComponentStatesRequest) returns (ComponentStates) {} + + rpc LoadBalance(LoadBalanceRequest) returns (common.Status) {} + rpc GetCompactionState(GetCompactionStateRequest) returns (GetCompactionStateResponse) {} + rpc ManualCompaction(ManualCompactionRequest) returns (ManualCompactionResponse) {} + rpc GetCompactionStateWithPlans(GetCompactionPlansRequest) returns (GetCompactionPlansResponse) {} + + // https://wiki.lfaidata.foundation/display/MIL/MEP+24+--+Support+bulk+load + rpc Import(ImportRequest) returns (ImportResponse) {} + rpc GetImportState(GetImportStateRequest) returns (GetImportStateResponse) {} + rpc ListImportTasks(ListImportTasksRequest) returns (ListImportTasksResponse) {} + + // https://wiki.lfaidata.foundation/display/MIL/MEP+27+--+Support+Basic+Authentication + rpc CreateCredential(CreateCredentialRequest) returns (common.Status) {} + rpc UpdateCredential(UpdateCredentialRequest) returns (common.Status) {} + rpc DeleteCredential(DeleteCredentialRequest) returns (common.Status) {} + rpc ListCredUsers(ListCredUsersRequest) returns (ListCredUsersResponse) {} + + // https://wiki.lfaidata.foundation/display/MIL/MEP+29+--+Support+Role-Based+Access+Control + rpc CreateRole(CreateRoleRequest) returns (common.Status) {} + rpc DropRole(DropRoleRequest) returns (common.Status) {} + rpc OperateUserRole(OperateUserRoleRequest) returns (common.Status) {} + rpc SelectRole(SelectRoleRequest) returns (SelectRoleResponse) {} + rpc SelectUser(SelectUserRequest) returns (SelectUserResponse) {} + rpc OperatePrivilege(OperatePrivilegeRequest) returns (common.Status) {} + rpc SelectGrant(SelectGrantRequest) returns (SelectGrantResponse) {} + + rpc GetVersion(GetVersionRequest) returns (GetVersionResponse) {} + rpc CheckHealth(CheckHealthRequest) returns (CheckHealthResponse) {} + + rpc CreateResourceGroup(CreateResourceGroupRequest) returns (common.Status) {} + rpc DropResourceGroup(DropResourceGroupRequest) returns (common.Status) {} + rpc UpdateResourceGroups(UpdateResourceGroupsRequest) returns (common.Status) {} + rpc TransferNode(TransferNodeRequest) returns (common.Status) {} + rpc TransferReplica(TransferReplicaRequest) returns (common.Status) {} + rpc ListResourceGroups(ListResourceGroupsRequest) returns (ListResourceGroupsResponse) {} + rpc DescribeResourceGroup(DescribeResourceGroupRequest) returns (DescribeResourceGroupResponse) {} + + rpc RenameCollection(RenameCollectionRequest) returns (common.Status) {} + + rpc ListIndexedSegment(feder.ListIndexedSegmentRequest) returns(feder.ListIndexedSegmentResponse) {} + rpc DescribeSegmentIndexData(feder.DescribeSegmentIndexDataRequest) returns(feder.DescribeSegmentIndexDataResponse) {} + + rpc Connect(ConnectRequest) returns (ConnectResponse) {} + + rpc AllocTimestamp(AllocTimestampRequest) returns (AllocTimestampResponse) {} + + rpc CreateDatabase(CreateDatabaseRequest) returns (common.Status) {} + rpc DropDatabase(DropDatabaseRequest) returns (common.Status) {} + rpc ListDatabases(ListDatabasesRequest) returns (ListDatabasesResponse) {} + + rpc ReplicateMessage(ReplicateMessageRequest) returns (ReplicateMessageResponse) {} +} + +message CreateAliasRequest { + option (common.privilege_ext_obj) = { + object_type: Global + object_privilege: PrivilegeCreateAlias + object_name_index: -1 + }; + + common.MsgBase base = 1; + string db_name = 2; + string collection_name = 3; + string alias = 4; +} + +message DropAliasRequest { + option (common.privilege_ext_obj) = { + object_type: Global + object_privilege: PrivilegeDropAlias + object_name_index: -1 + }; + + common.MsgBase base = 1; + string db_name = 2; + string alias = 3; +} + +message AlterAliasRequest{ + common.MsgBase base = 1; + string db_name = 2; + string collection_name = 3; + string alias = 4; +} + +message DescribeAliasRequest{ + option (common.privilege_ext_obj) = { + object_type: Global + object_privilege: PrivilegeDescribeAlias + object_name_index: -1 + }; + + common.MsgBase base = 1; + string db_name = 2; + string alias = 3; +} + +/* +* Describe alias response +*/ +message DescribeAliasResponse { + // Response status + common.Status status = 1; + string db_name = 2; + string alias = 3; + string collection = 4; +} + +message ListAliasesRequest{ + option (common.privilege_ext_obj) = { + object_type: Global + object_privilege: PrivilegeListAliases + object_name_index: -1 + }; + + common.MsgBase base = 1; + string db_name = 2; + string collection_name = 3; +} + +/* +* List aliases response +*/ +message ListAliasesResponse { + // Response status + common.Status status = 1; + string db_name = 2; + string collection_name = 3; + repeated string aliases = 4; +} + +/** +* Create collection in milvus +*/ +message CreateCollectionRequest { + option (common.privilege_ext_obj) = { + object_type: Global + object_privilege: PrivilegeCreateCollection + object_name_index: -1 + }; + // Not useful for now + common.MsgBase base = 1; + string db_name = 2; + // The unique collection name in milvus.(Required) + string collection_name = 3; + // The serialized `schema.CollectionSchema`(Required) + bytes schema = 4; + // Once set, no modification is allowed (Optional) + // https://github.com/milvus-io/milvus/issues/6690 + int32 shards_num = 5; + // The consistency level that the collection used, modification is not supported now. + common.ConsistencyLevel consistency_level = 6; + repeated common.KeyValuePair properties = 7; + int64 num_partitions = 8; // num of default physical partitions, only used in partition key mode and changes are not supported +} + +/** +* Drop collection in milvus, also will drop data in collection. +*/ +message DropCollectionRequest { + option (common.privilege_ext_obj) = { + object_type: Global + object_privilege: PrivilegeDropCollection + object_name_index: -1 + }; + // Not useful for now + common.MsgBase base = 1; + string db_name = 2; + // The unique collection name in milvus.(Required) + string collection_name = 3; +} + +/** +* Alter collection in milvus +*/ +message AlterCollectionRequest { + option (common.privilege_ext_obj) = { + object_type: Global + object_privilege: PrivilegeCreateCollection + object_name_index: -1 + }; + // Not useful for now + common.MsgBase base = 1; + string db_name = 2; + // The unique collection name in milvus.(Required) + string collection_name = 3; + int64 collectionID = 4; + repeated common.KeyValuePair properties = 5; +} + +/** +* Check collection exist in milvus or not. +*/ +message HasCollectionRequest { + // Not useful for now + common.MsgBase base = 1; + string db_name = 2; + // The collection name you want to check. + string collection_name = 3; + // If time_stamp is not zero, will return true when time_stamp >= created collection timestamp, otherwise will return false. + uint64 time_stamp = 4; +} + + +message BoolResponse { + common.Status status = 1; + bool value = 2; +} + +message StringResponse { + common.Status status = 1; + string value = 2; +} + +/** +* Get collection meta datas like: schema, collectionID, shards number ... +*/ +message DescribeCollectionRequest { + option (common.privilege_ext_obj) = { + object_type: Global + object_privilege: PrivilegeDescribeCollection + object_name_index: -1 + }; + // Not useful for now + common.MsgBase base = 1; + string db_name = 2; + // The collection name you want to describe, you can pass collection_name or collectionID + string collection_name = 3; + // The collection ID you want to describe + int64 collectionID = 4; + // If time_stamp is not zero, will describe collection success when time_stamp >= created collection timestamp, otherwise will throw error. + uint64 time_stamp = 5; +} + +/** +* DescribeCollection Response +*/ +message DescribeCollectionResponse { + // Contain error_code and reason + common.Status status = 1; + // The schema param when you created collection. + schema.CollectionSchema schema = 2; + // The collection id + int64 collectionID = 3; + // System design related, users should not perceive + repeated string virtual_channel_names = 4; + // System design related, users should not perceive + repeated string physical_channel_names = 5; + // Hybrid timestamp in milvus + uint64 created_timestamp = 6; + // The utc timestamp calculated by created_timestamp + uint64 created_utc_timestamp = 7; + // The shards number you set. + int32 shards_num = 8; + // The aliases of this collection + repeated string aliases = 9; + // The message ID/posititon when collection is created + repeated common.KeyDataPair start_positions = 10; + // The consistency level that the collection used, modification is not supported now. + common.ConsistencyLevel consistency_level = 11; + // The collection name + string collection_name = 12; + repeated common.KeyValuePair properties = 13; + string db_name = 14; + int64 num_partitions = 15; +} + +/** +* Load collection data into query nodes, then you can do vector search on this collection. +*/ +message LoadCollectionRequest { + option (common.privilege_ext_obj) = { + object_type: Collection + object_privilege: PrivilegeLoad + object_name_index: 3 + }; + // Not useful for now + common.MsgBase base = 1; + string db_name = 2; + // The collection name you want to load + string collection_name = 3; + // The replica number to load, default by 1 + int32 replica_number = 4; + // create replica used resource group + repeated string resource_groups = 5; + // Whether to enable refresh mode. + bool refresh = 6; +} + +/** +* Release collection data from query nodes, then you can't do vector search on this collection. +*/ +message ReleaseCollectionRequest { + option (common.privilege_ext_obj) = { + object_type: Collection + object_privilege: PrivilegeRelease + object_name_index: 3 + }; + // Not useful for now + common.MsgBase base = 1; + string db_name = 2; + // The collection name you want to release + string collection_name = 3; +} + +/** +* Get statistics like row_count. +* WARNING: This API is experimental and not useful for now. +*/ +message GetStatisticsRequest { + option (common.privilege_ext_obj) = { + object_type: Collection + object_privilege: PrivilegeGetStatistics + object_name_index: 3 + }; + // Not useful for now + common.MsgBase base = 1; + string db_name = 2; + // The collection name you want get statistics + string collection_name = 3; + // The partition names you want get statistics, empty for all partitions + repeated string partition_names = 4; + // Not useful for now, reserved for future + uint64 guarantee_timestamp = 5; +} + +/** +* Will return statistics in stats field like [{key:"row_count",value:"1"}] +* WARNING: This API is experimental and not useful for now. +*/ +message GetStatisticsResponse { + // Contain error_code and reason + common.Status status = 1; + // Collection statistics data + repeated common.KeyValuePair stats = 2; +} + +/** +* Get collection statistics like row_count. +*/ +message GetCollectionStatisticsRequest { + option (common.privilege_ext_obj) = { + object_type: Collection + object_privilege: PrivilegeGetStatistics + object_name_index: 3 + }; + // Not useful for now + common.MsgBase base = 1; + string db_name = 2; + // The collection name you want get statistics + string collection_name = 3; +} + +/** +* Will return collection statistics in stats field like [{key:"row_count",value:"1"}] +*/ +message GetCollectionStatisticsResponse { + // Contain error_code and reason + common.Status status = 1; + // Collection statistics data + repeated common.KeyValuePair stats = 2; +} + +/* +* This is for ShowCollectionsRequest type field. +*/ +// Deprecated: use GetLoadingProgress rpc instead +enum ShowType { + option deprecated = true; + // Will return all collections + All = 0; + // Will return loaded collections with their inMemory_percentages + InMemory = 1; +} + +/* +* List collections +*/ +message ShowCollectionsRequest { + option (common.privilege_ext_obj) = { + object_type: Global + object_privilege: PrivilegeShowCollections + object_name_index: -1 + }; + // Not useful for now + common.MsgBase base = 1; + string db_name = 2; + // Not useful for now + uint64 time_stamp = 3; + // Decide return Loaded collections or All collections(Optional) + ShowType type = 4; + // When type is InMemory, will return these collection's inMemory_percentages.(Optional) + // Deprecated: use GetLoadingProgress rpc instead + repeated string collection_names = 5 [deprecated=true]; +} + +/* +* Return basic collection infos. +*/ +message ShowCollectionsResponse { + // Contain error_code and reason + common.Status status = 1; + // Collection name array + repeated string collection_names = 2; + // Collection Id array + repeated int64 collection_ids = 3; + // Hybrid timestamps in milvus + repeated uint64 created_timestamps = 4; + // The utc timestamp calculated by created_timestamp + repeated uint64 created_utc_timestamps = 5; + // Load percentage on querynode when type is InMemory + // Deprecated: use GetLoadingProgress rpc instead + repeated int64 inMemory_percentages = 6 [deprecated=true]; + // Indicate whether query service is available + repeated bool query_service_available = 7; +} + +/* +* Create partition in created collection. +*/ +message CreatePartitionRequest { + option (common.privilege_ext_obj) = { + object_type: Collection + object_privilege: PrivilegeCreatePartition + object_name_index: 3 + }; + // Not useful for now + common.MsgBase base = 1; + string db_name = 2; + // The collection name in milvus + string collection_name = 3; + // The partition name you want to create. + string partition_name = 4; +} + +/* +* Drop partition in created collection. +*/ +message DropPartitionRequest { + option (common.privilege_ext_obj) = { + object_type: Collection + object_privilege: PrivilegeDropPartition + object_name_index: 3 + }; + // Not useful for now + common.MsgBase base = 1; + string db_name = 2; + // The collection name in milvus + string collection_name = 3; + // The partition name you want to drop + string partition_name = 4; +} + +/* +* Check if partition exist in collection or not. +*/ +message HasPartitionRequest { + option (common.privilege_ext_obj) = { + object_type: Collection + object_privilege: PrivilegeHasPartition + object_name_index: 3 + }; + // Not useful for now + common.MsgBase base = 1; + string db_name = 2; + // The collection name in milvus + string collection_name = 3; + // The partition name you want to check + string partition_name = 4; +} + +/* +* Load specific partitions data of one collection into query nodes +* Then you can get these data as result when you do vector search on this collection. +*/ +message LoadPartitionsRequest { + option (common.privilege_ext_obj) = { + object_type: Collection + object_privilege: PrivilegeLoad + object_name_index: 3 + }; + // Not useful for now + common.MsgBase base = 1; + string db_name = 2; + // The collection name in milvus + string collection_name = 3; + // The partition names you want to load + repeated string partition_names = 4; + // The replicas number you would load, 1 by default + int32 replica_number = 5; + // create replica used resource group + repeated string resource_groups = 6; + // Whether to enable refresh mode. + bool refresh = 7; +} + +/* +* Release specific partitions data of one collection from query nodes. +* Then you can not get these data as result when you do vector search on this collection. +*/ +message ReleasePartitionsRequest { + option (common.privilege_ext_obj) = { + object_type: Collection + object_privilege: PrivilegeRelease + object_name_index: 3 + }; + // Not useful for now + common.MsgBase base = 1; + string db_name = 2; + // The collection name in milvus + string collection_name = 3; + // The partition names you want to release + repeated string partition_names = 4; +} + +/* +* Get partition statistics like row_count. +*/ +message GetPartitionStatisticsRequest { + // Not useful for now + common.MsgBase base = 1; + string db_name = 2; + // The collection name in milvus + string collection_name = 3; + // The partition name you want to collect statistics + string partition_name = 4; +} + +message GetPartitionStatisticsResponse { + common.Status status = 1; + repeated common.KeyValuePair stats = 2; +} + +/* +* List all partitions for particular collection +*/ +message ShowPartitionsRequest { + option (common.privilege_ext_obj) = { + object_type: Collection + object_privilege: PrivilegeShowPartitions + object_name_index: 3 + }; + // Not useful for now + common.MsgBase base = 1; + string db_name = 2; + // The collection name you want to describe, you can pass collection_name or collectionID + string collection_name = 3; + // The collection id in milvus + int64 collectionID = 4; + // When type is InMemory, will return these patitions's inMemory_percentages.(Optional) + repeated string partition_names = 5; + // Decide return Loaded partitions or All partitions(Optional) + // Deprecated: use GetLoadingProgress rpc instead + ShowType type = 6 [deprecated=true]; +} + +/* +* List all partitions for particular collection response. +* The returned datas are all rows, we can format to columns by therir index. +*/ +message ShowPartitionsResponse { + // Contain error_code and reason + common.Status status = 1; + // All partition names for this collection + repeated string partition_names = 2; + // All partition ids for this collection + repeated int64 partitionIDs = 3; + // All hybrid timestamps + repeated uint64 created_timestamps = 4; + // All utc timestamps calculated by created_timestamps + repeated uint64 created_utc_timestamps = 5; + // Load percentage on querynode + // Deprecated: use GetLoadingProgress rpc instead + repeated int64 inMemory_percentages = 6 [deprecated=true]; +} + +message DescribeSegmentRequest { + common.MsgBase base = 1; + int64 collectionID = 2; + int64 segmentID = 3; +} + +message DescribeSegmentResponse { + common.Status status = 1; + int64 indexID = 2; + int64 buildID = 3; + bool enable_index = 4; + int64 fieldID = 5; +} + +message ShowSegmentsRequest { + common.MsgBase base = 1; + int64 collectionID = 2; + int64 partitionID = 3; +} + +message ShowSegmentsResponse { + common.Status status = 1; + repeated int64 segmentIDs = 2; +} + +/* +* Create index for vector datas +*/ +message CreateIndexRequest { + option (common.privilege_ext_obj) = { + object_type: Collection + object_privilege: PrivilegeCreateIndex + object_name_index: 3 + }; + // Not useful for now + common.MsgBase base = 1; + string db_name = 2; + // The particular collection name you want to create index. + string collection_name = 3; + // The vector field name in this particular collection + string field_name = 4; + // Support keys: index_type,metric_type, params. Different index_type may has different params. + repeated common.KeyValuePair extra_params = 5; + // Version before 2.0.2 doesn't contain index_name, we use default index name. + string index_name = 6; +} + +/* +* Alter index +*/ +message AlterIndexRequest { + option (common.privilege_ext_obj) = { + object_type: Collection + object_privilege: PrivilegeCreateIndex + object_name_index: 3 + }; + + common.MsgBase base = 1; + string db_name = 2; + string collection_name = 3; + string index_name = 4; + repeated common.KeyValuePair extra_params = 5; +} + +/* +* Get created index information. +* Current release of Milvus only supports showing latest built index. +*/ +message DescribeIndexRequest { + option (common.privilege_ext_obj) = { + object_type: Collection + object_privilege: PrivilegeIndexDetail + object_name_index: 3 + }; + // Not useful for now + common.MsgBase base = 1; + string db_name = 2; + // The particular collection name in Milvus + string collection_name = 3; + // The vector field name in this particular collection + string field_name = 4; + // No need to set up for now @2021.06.30 + string index_name = 5; + uint64 timestamp = 6; +} + +/* +* Index informations +*/ +message IndexDescription { + // Index name + string index_name = 1; + // Index id + int64 indexID = 2; + // Will return index_type, metric_type, params(like nlist). + repeated common.KeyValuePair params = 3; + // The vector field name + string field_name = 4; + // index build progress + int64 indexed_rows = 5; + int64 total_rows = 6; + // index state + common.IndexState state = 7; + string index_state_fail_reason = 8; + int64 pending_index_rows = 9; +} + +/* +* Describe index response +*/ +message DescribeIndexResponse { + // Response status + common.Status status = 1; + // All index informations, for now only return tha latest index you created for the collection. + repeated IndexDescription index_descriptions = 2; +} + +/* +* Get index building progress +*/ +message GetIndexBuildProgressRequest { + option (common.privilege_ext_obj) = { + object_type: Collection + object_privilege: PrivilegeIndexDetail + object_name_index: 3 + }; + // Not useful for now + common.MsgBase base = 1; + string db_name = 2 ; + // The collection name in milvus + string collection_name = 3; + // The vector field name in this collection + string field_name = 4; + // Not useful for now + string index_name = 5; +} + +message GetIndexBuildProgressResponse { + common.Status status = 1; + int64 indexed_rows = 2; + int64 total_rows = 3; +} + +message GetIndexStateRequest { + option (common.privilege_ext_obj) = { + object_type: Collection + object_privilege: PrivilegeIndexDetail + object_name_index: 3 + }; + common.MsgBase base = 1; // must + string db_name = 2 ; + string collection_name = 3; // must + string field_name = 4; + string index_name = 5; // No need to set up for now @2021.06.30 +} + +message GetIndexStateResponse { + common.Status status = 1; + common.IndexState state = 2; + string fail_reason = 3; +} + +message DropIndexRequest { + option (common.privilege_ext_obj) = { + object_type: Collection + object_privilege: PrivilegeDropIndex + object_name_index: 3 + }; + common.MsgBase base = 1; // must + string db_name = 2; + string collection_name = 3; // must + // Deprecated: not be used in the milvus + string field_name = 4; + string index_name = 5; +} + +message InsertRequest { + option (common.privilege_ext_obj) = { + object_type: Collection + object_privilege: PrivilegeInsert + object_name_index: 3 + }; + common.MsgBase base = 1; + string db_name = 2; + string collection_name = 3; + string partition_name = 4; + repeated schema.FieldData fields_data = 5; + repeated uint32 hash_keys = 6; + uint32 num_rows = 7; +} + +message UpsertRequest { + option (common.privilege_ext_obj) = { + object_type: Collection + object_privilege: PrivilegeUpsert + object_name_index: 3 + }; + common.MsgBase base = 1; + string db_name = 2; + string collection_name = 3; + string partition_name = 4; + repeated schema.FieldData fields_data = 5; + repeated uint32 hash_keys = 6; + uint32 num_rows = 7; +} + +message MutationResult { + common.Status status = 1; + schema.IDs IDs = 2; // required for insert, delete, upsert + repeated uint32 succ_index = 3; // error indexes indicate + repeated uint32 err_index = 4; // error indexes indicate + bool acknowledged = 5; + int64 insert_cnt = 6; + int64 delete_cnt = 7; + int64 upsert_cnt = 8; + uint64 timestamp = 9; +} + +message DeleteRequest { + option (common.privilege_ext_obj) = { + object_type: Collection + object_privilege: PrivilegeDelete + object_name_index: 3 + }; + common.MsgBase base = 1; + string db_name = 2; + string collection_name = 3; + string partition_name = 4; + string expr = 5; + repeated uint32 hash_keys = 6; + common.ConsistencyLevel consistency_level = 7; +} + + +message SearchRequest { + option (common.privilege_ext_obj) = { + object_type: Collection + object_privilege: PrivilegeSearch + object_name_index: 3 + }; + common.MsgBase base = 1; // must + string db_name = 2; + string collection_name = 3; // must + repeated string partition_names = 4; // must + string dsl = 5; // must + // serialized `PlaceholderGroup` + bytes placeholder_group = 6; // must + common.DslType dsl_type = 7; // must + repeated string output_fields = 8; + repeated common.KeyValuePair search_params = 9; // must + uint64 travel_timestamp = 10; + uint64 guarantee_timestamp = 11; // guarantee_timestamp + int64 nq = 12; + bool not_return_all_meta = 13; + common.ConsistencyLevel consistency_level = 14; + bool use_default_consistency = 15; + bool search_by_primary_keys = 16; +} + +message Hits { + repeated int64 IDs = 1; + repeated bytes row_data = 2; + repeated float scores = 3; +} + +message SearchResults { + common.Status status = 1; + schema.SearchResultData results = 2; + string collection_name = 3; +} + +message HybridSearchRequest { + option (common.privilege_ext_obj) = { + object_type: Collection + object_privilege: PrivilegeSearch + object_name_index: 3 + }; + common.MsgBase base = 1; // must + string db_name = 2; + string collection_name = 3; // must + repeated string partition_names = 4; // must + repeated SearchRequest requests = 5; + repeated common.KeyValuePair rank_params = 6; // must + uint64 travel_timestamp = 7; + uint64 guarantee_timestamp = 8; // guarantee_timestamp + bool not_return_all_meta = 9; + repeated string output_fields = 10; + common.ConsistencyLevel consistency_level = 11; + bool use_default_consistency = 12; +} + +message FlushRequest { + option (common.privilege_ext_obj) = { + object_type: Collection + object_privilege: PrivilegeFlush + object_name_indexs: 3 + }; + common.MsgBase base = 1; + string db_name = 2; + repeated string collection_names = 3; +} + +message FlushResponse{ + common.Status status = 1; + string db_name = 2; + map coll_segIDs = 3; + map flush_coll_segIDs = 4; + map coll_seal_times = 5; // physical time for backup tool + map coll_flush_ts = 6; // hybrid ts for geting flush tate +} + +message QueryRequest { + option (common.privilege_ext_obj) = { + object_type: Collection + object_privilege: PrivilegeQuery + object_name_index: 3 + }; + common.MsgBase base = 1; + string db_name = 2; + string collection_name = 3; + string expr = 4; + repeated string output_fields = 5; + repeated string partition_names = 6; + uint64 travel_timestamp = 7; + uint64 guarantee_timestamp = 8; // guarantee_timestamp + repeated common.KeyValuePair query_params = 9; // optional + bool not_return_all_meta = 10; + common.ConsistencyLevel consistency_level = 11; + bool use_default_consistency = 12; +} + +message QueryResults { + common.Status status = 1; + repeated schema.FieldData fields_data = 2; + string collection_name = 3; + repeated string output_fields = 4; +} + +message VectorIDs { + string collection_name = 1; + string field_name = 2; + schema.IDs id_array = 3; + repeated string partition_names = 4; +} + +message VectorsArray { + oneof array { + VectorIDs id_array = 1; // vector ids + schema.VectorField data_array = 2; // vectors data + } +} + +message CalcDistanceRequest { + common.MsgBase base = 1; + VectorsArray op_left = 2; // vectors on the left of operator + VectorsArray op_right = 3; // vectors on the right of operator + repeated common.KeyValuePair params = 4; // "metric":"L2"/"IP"/"HAMMIN"/"TANIMOTO" +} + +message CalcDistanceResults { + common.Status status = 1; + // num(op_left)*num(op_right) distance values, "HAMMIN" return integer distance + oneof array { + schema.IntArray int_dist = 2; + schema.FloatArray float_dist = 3; + } +} + +message FlushAllRequest { + option (common.privilege_ext_obj) = { + object_type: Global + object_privilege: PrivilegeFlushAll + object_name_index: -1 + }; + common.MsgBase base = 1; + string db_name = 2; +} + +message FlushAllResponse { + common.Status status = 1; + uint64 flush_all_ts = 2; +} + +message PersistentSegmentInfo { + int64 segmentID = 1; + int64 collectionID = 2; + int64 partitionID = 3; + int64 num_rows = 4; + common.SegmentState state = 5; +} + +message GetPersistentSegmentInfoRequest { + common.MsgBase base = 1; // must + string dbName = 2; + string collectionName = 3; // must +} + +message GetPersistentSegmentInfoResponse { + common.Status status = 1; + repeated PersistentSegmentInfo infos = 2; +} + +message QuerySegmentInfo { + int64 segmentID = 1; + int64 collectionID = 2; + int64 partitionID = 3; + int64 mem_size = 4; + int64 num_rows = 5; + string index_name = 6; + int64 indexID = 7; + // deprecated, check node_ids(NodeIds) field + int64 nodeID = 8 [deprecated=true]; + common.SegmentState state = 9; + repeated int64 nodeIds = 10; +} + +message GetQuerySegmentInfoRequest { + common.MsgBase base = 1; // must + string dbName = 2; + string collectionName = 3; // must +} + +message GetQuerySegmentInfoResponse { + common.Status status = 1; + repeated QuerySegmentInfo infos = 2; +} + +message DummyRequest { + string request_type = 1; +} + +message DummyResponse { + string response = 1; +} + +message RegisterLinkRequest { +} + +message RegisterLinkResponse { + common.Address address = 1; + common.Status status = 2; +} + +message GetMetricsRequest { + common.MsgBase base = 1; + string request = 2; // request is of jsonic format +} + +message GetMetricsResponse { + common.Status status = 1; + string response = 2; // response is of jsonic format + string component_name = 3; // metrics from which component +} + +message ComponentInfo { + int64 nodeID = 1; + string role = 2; + common.StateCode state_code = 3; + repeated common.KeyValuePair extra_info = 4; +} + +message ComponentStates { + ComponentInfo state = 1; + repeated ComponentInfo subcomponent_states = 2; + common.Status status = 3; +} + +message GetComponentStatesRequest { +} + +/* +* Do load balancing operation from src_nodeID to dst_nodeID. +*/ +message LoadBalanceRequest { + option (common.privilege_ext_obj) = { + object_type: Collection + object_privilege: PrivilegeLoadBalance + object_name_index: 5 + }; + common.MsgBase base = 1; + int64 src_nodeID = 2; + repeated int64 dst_nodeIDs = 3; + repeated int64 sealed_segmentIDs = 4; + string collectionName = 5; + string db_name = 6; +} + +message ManualCompactionRequest { + option (common.privilege_ext_obj) = { + object_type: Collection + object_privilege: PrivilegeCompaction + object_name_index: 1 + }; + int64 collectionID = 1; + uint64 timetravel = 2; + bool majorCompaction = 3; +} + +message ManualCompactionResponse { + common.Status status = 1; + int64 compactionID = 2; + int32 compactionPlanCount = 3; +} + +message GetCompactionStateRequest { + int64 compactionID = 1; +} + +message GetCompactionStateResponse { + common.Status status = 1; + common.CompactionState state = 2; + int64 executingPlanNo = 3; + int64 timeoutPlanNo = 4; + int64 completedPlanNo = 5; + int64 failedPlanNo = 6; +} + +message GetCompactionPlansRequest { + int64 compactionID = 1; +} + +message GetCompactionPlansResponse { + common.Status status = 1; + common.CompactionState state = 2; + repeated CompactionMergeInfo mergeInfos = 3; +} + +message CompactionMergeInfo { + repeated int64 sources = 1; + int64 target = 2; +} + +message GetFlushStateRequest { + option (common.privilege_ext_obj) = { + object_type: Collection + object_privilege: PrivilegeGetFlushState + object_name_index: 4 + }; + repeated int64 segmentIDs = 1; + uint64 flush_ts = 2; + string db_name = 3; + string collection_name = 4; +} + +message GetFlushStateResponse { + common.Status status = 1; + bool flushed = 2; +} + +message GetFlushAllStateRequest { + common.MsgBase base = 1; + uint64 flush_all_ts = 2; + string db_name = 3; +} + +message GetFlushAllStateResponse { + common.Status status = 1; + bool flushed = 2; +} + +message ImportRequest { + option (common.privilege_ext_obj) = { + object_type: Collection + object_privilege: PrivilegeImport + object_name_index: 1 + }; + string collection_name = 1; // target collection + string partition_name = 2; // target partition + repeated string channel_names = 3; // channel names for the collection + bool row_based = 4; // the file is row-based or column-based + repeated string files = 5; // file paths to be imported + repeated common.KeyValuePair options = 6; // import options, bucket, etc. + string db_name = 7; // target database + bytes clustering_info = 8; // serialized `schema.ClusteringInfo` +} + +message ImportResponse { + common.Status status = 1; + repeated int64 tasks = 2; // id array of import tasks +} + +message GetImportStateRequest { + int64 task = 1; // id of an import task +} + +message GetImportStateResponse { + common.Status status = 1; + common.ImportState state = 2; // is this import task finished or not + int64 row_count = 3; // if the task is finished, this value is how many rows are imported. if the task is not finished, this value is how many rows are parsed. return 0 if failed. + repeated int64 id_list = 4; // auto generated ids if the primary key is autoid + repeated common.KeyValuePair infos = 5; // more information about the task, progress percent, file path, failed reason, etc. + int64 id = 6; // id of an import task + int64 collection_id = 7; // collection ID of the import task. + repeated int64 segment_ids = 8; // a list of segment IDs created by the import task. + int64 create_ts = 9; // timestamp when the import task is created. +} + +message ListImportTasksRequest { + string collection_name = 1; // target collection, list all tasks if the name is empty + int64 limit = 2; // maximum number of tasks returned, list all tasks if the value is 0 + string db_name = 3; +} + +message ListImportTasksResponse { + common.Status status = 1; + repeated GetImportStateResponse tasks = 2; // list of all import tasks +} + +message GetReplicasRequest { + common.MsgBase base = 1; + int64 collectionID = 2; + bool with_shard_nodes = 3; + string collection_name = 4; + string db_name = 5; +} + +message GetReplicasResponse { + common.Status status = 1; + repeated ReplicaInfo replicas = 2; +} + +message ReplicaInfo { // ReplicaGroup + int64 replicaID = 1; + int64 collectionID = 2; + repeated int64 partition_ids = 3; // empty indicates to load collection + repeated ShardReplica shard_replicas = 4; + repeated int64 node_ids = 5; // include leaders + string resource_group_name = 6; + // outbound access rg -> node num + map num_outbound_node = 7; +} + +message ShardReplica { + int64 leaderID = 1; + string leader_addr = 2; // IP:port + string dm_channel_name = 3; + // optional, DO NOT save it in meta, set it only for GetReplicas() + // if with_shard_nodes is true + repeated int64 node_ids = 4; +} + +service ProxyService { + rpc RegisterLink(RegisterLinkRequest) returns (RegisterLinkResponse) {} +} + +// https://wiki.lfaidata.foundation/display/MIL/MEP+27+--+Support+Basic+Authentication + +message CreateCredentialRequest { + option (common.privilege_ext_obj) = { + object_type: Global + object_privilege: PrivilegeCreateOwnership + object_name_index: -1 + }; + // Not useful for now + common.MsgBase base = 1; + // username + string username = 2; + // ciphertext password + string password = 3; + // create time + uint64 created_utc_timestamps = 4; + // modify time + uint64 modified_utc_timestamps = 5; +} + +message UpdateCredentialRequest { + option (common.privilege_ext_obj) = { + object_type: User + object_privilege: PrivilegeUpdateUser + object_name_index: 2 + }; + // Not useful for now + common.MsgBase base = 1; + // username + string username = 2; + // old password + string oldPassword = 3; + // new password + string newPassword = 4; + // create time + uint64 created_utc_timestamps = 5; + // modify time + uint64 modified_utc_timestamps = 6; +} + +message DeleteCredentialRequest { + option (common.privilege_ext_obj) = { + object_type: Global + object_privilege: PrivilegeDropOwnership + object_name_index: -1 + }; + // Not useful for now + common.MsgBase base = 1; + // Not useful for now + string username = 2; +} + +message ListCredUsersResponse { + // Contain error_code and reason + common.Status status = 1; + // username array + repeated string usernames = 2; +} + +message ListCredUsersRequest { + option (common.privilege_ext_obj) = { + object_type: Global + object_privilege: PrivilegeSelectOwnership + object_name_index: -1 + }; + // Not useful for now + common.MsgBase base = 1; +} + +// https://wiki.lfaidata.foundation/display/MIL/MEP+29+--+Support+Role-Based+Access+Control +message RoleEntity { + string name = 1; +} + +message UserEntity { + string name = 1; +} + +message CreateRoleRequest { + option (common.privilege_ext_obj) = { + object_type: Global + object_privilege: PrivilegeCreateOwnership + object_name_index: -1 + }; + // Not useful for now + common.MsgBase base = 1; + // role + RoleEntity entity = 2; +} + +message DropRoleRequest { + option (common.privilege_ext_obj) = { + object_type: Global + object_privilege: PrivilegeDropOwnership + object_name_index: -1 + }; + // Not useful for now + common.MsgBase base = 1; + // role name + string role_name = 2; +} + +enum OperateUserRoleType { + AddUserToRole = 0; + RemoveUserFromRole = 1; +} + +message OperateUserRoleRequest { + option (common.privilege_ext_obj) = { + object_type: Global + object_privilege: PrivilegeManageOwnership + object_name_index: -1 + }; + // Not useful for now + common.MsgBase base = 1; + // username + string username = 2; + // role name + string role_name = 3; + // operation type + OperateUserRoleType type = 4; +} + +message SelectRoleRequest { + option (common.privilege_ext_obj) = { + object_type: Global + object_privilege: PrivilegeSelectOwnership + object_name_index: -1 + }; + // Not useful for now + common.MsgBase base = 1; + // role + RoleEntity role = 2; + // include user info + bool include_user_info = 3; +} + +message RoleResult { + RoleEntity role = 1; + repeated UserEntity users = 2; +} + +message SelectRoleResponse { + // Not useful for now + common.Status status = 1; + // role result array + repeated RoleResult results = 2; +} + +message SelectUserRequest { + option (common.privilege_ext_obj) = { + object_type: User + object_privilege: PrivilegeSelectUser + object_name_index: 2 + }; + // Not useful for now + common.MsgBase base = 1; + // user + UserEntity user = 2; + // include user info + bool include_role_info = 3; +} + +message UserResult { + UserEntity user = 1; + repeated RoleEntity roles = 2; +} + +message SelectUserResponse { + // Not useful for now + common.Status status = 1; + // user result array + repeated UserResult results = 2; +} + +message ObjectEntity { + string name = 1; +} + +message PrivilegeEntity { + string name = 1; +} + +message GrantorEntity { + UserEntity user = 1; + PrivilegeEntity privilege = 2; +} + +message GrantPrivilegeEntity { + repeated GrantorEntity entities = 1; +} + +message GrantEntity { + // role + RoleEntity role = 1; + // object + ObjectEntity object = 2; + // object name + string object_name = 3; + // privilege + GrantorEntity grantor = 4; + // db name + string db_name = 5; +} + +message SelectGrantRequest { + option (common.privilege_ext_obj) = { + object_type: Global + object_privilege: PrivilegeSelectOwnership + object_name_index: -1 + }; + // Not useful for now + common.MsgBase base = 1; + // grant + GrantEntity entity = 2; +} + +message SelectGrantResponse { + // Not useful for now + common.Status status = 1; + // grant info array + repeated GrantEntity entities = 2; +} + +enum OperatePrivilegeType { + Grant = 0; + Revoke = 1; +} + +message OperatePrivilegeRequest { + option (common.privilege_ext_obj) = { + object_type: Global + object_privilege: PrivilegeManageOwnership + object_name_index: -1 + }; + // Not useful for now + common.MsgBase base = 1; + // grant + GrantEntity entity = 2; + // operation type + OperatePrivilegeType type = 3; +} + +message GetLoadingProgressRequest { + option (common.privilege_ext_obj) = { + object_type: Collection + object_privilege: PrivilegeLoad + object_name_index: 2 + }; + // Not useful for now + common.MsgBase base = 1; + string collection_name = 2; + repeated string partition_names = 3; + string db_name = 4; +} + +message GetLoadingProgressResponse { + common.Status status = 1; + int64 progress = 2; + int64 refresh_progress = 3; +} + +message GetLoadStateRequest { + option (common.privilege_ext_obj) = { + object_type: Collection + object_privilege: PrivilegeLoad + object_name_index: 2 + }; + // Not useful for now + common.MsgBase base = 1; + string collection_name = 2; + repeated string partition_names = 3; + string db_name = 4; +} + +message GetLoadStateResponse { + common.Status status = 1; + common.LoadState state = 2; +} + +message MilvusExt { + string version = 1; +} + +extend google.protobuf.FileOptions { + MilvusExt milvus_ext_obj = 1001; +} + +message GetVersionRequest { +} + +message GetVersionResponse { + common.Status status = 1; + string version =2; +} + +enum QuotaState { + Unknown = 0; + ReadLimited = 2; + WriteLimited = 3; + DenyToRead = 4; + DenyToWrite = 5; +} + +message CheckHealthRequest { +} + +message CheckHealthResponse { + common.Status status = 1; + bool isHealthy = 2; + repeated string reasons = 3; + repeated QuotaState quota_states = 4; +} + +message CreateResourceGroupRequest { + option (common.privilege_ext_obj) = { + object_type: Global + object_privilege: PrivilegeCreateResourceGroup + object_name_index: -1 + }; + common.MsgBase base = 1; + string resource_group = 2; + rg.ResourceGroupConfig config = 3; +} + +message UpdateResourceGroupsRequest { + option (common.privilege_ext_obj) = { + object_type: Global + object_privilege: PrivilegeUpdateResourceGroups + object_name_index: -1 + }; + common.MsgBase base = 1; + map resource_groups = 2; +} + +message DropResourceGroupRequest { + option (common.privilege_ext_obj) = { + object_type: Global + object_privilege: PrivilegeDropResourceGroup + object_name_index: -1 + }; + common.MsgBase base = 1; + string resource_group = 2; +} + +// transfer `nodeNum` nodes from `source_resource_group` to `target_resource_group` +message TransferNodeRequest { + option (common.privilege_ext_obj) = { + object_type: Global + object_privilege: PrivilegeTransferNode + object_name_index: -1 + }; + common.MsgBase base = 1; + string source_resource_group = 2; + string target_resource_group = 3; + int32 num_node = 4; +} + +// transfer `replicaNum` replicas in `collectionID` from `source_resource_group` to `target_resource_group` +message TransferReplicaRequest { + option (common.privilege_ext_obj) = { + object_type: Global + object_privilege: PrivilegeTransferReplica + object_name_index: -1 + }; + common.MsgBase base = 1; + string source_resource_group = 2; + string target_resource_group = 3; + string collection_name = 4; + int64 num_replica = 5; + string db_name = 6; +} + +message ListResourceGroupsRequest { + option (common.privilege_ext_obj) = { + object_type: Global + object_privilege: PrivilegeListResourceGroups + object_name_index: -1 + }; + common.MsgBase base = 1; +} + +message ListResourceGroupsResponse { + common.Status status = 1; + repeated string resource_groups = 2; +} + +message DescribeResourceGroupRequest { + option (common.privilege_ext_obj) = { + object_type: Global + object_privilege: PrivilegeDescribeResourceGroup + object_name_index: -1 + }; + common.MsgBase base = 1; + string resource_group = 2; +} + +message DescribeResourceGroupResponse { + common.Status status = 1; + ResourceGroup resource_group = 2; +} + +message ResourceGroup { + string name = 1; + int32 capacity = 2; + int32 num_available_node = 3; + // collection name -> loaded replica num + map num_loaded_replica = 4; + // collection name -> accessed other rg's node num + map num_outgoing_node = 5; + // collection name -> be accessed node num by other rg + map num_incoming_node = 6; + // resource group configuration. + rg.ResourceGroupConfig config = 7; + // query node belong to this resource group now. + repeated common.NodeInfo nodes = 8; +} + +message RenameCollectionRequest { + option (common.privilege_ext_obj) = { + object_type: Global + object_privilege: PrivilegeRenameCollection + object_name_index: -1 + }; + common.MsgBase base = 1; + string db_name = 2; + string oldName = 3; + string newName = 4; + string newDBName =5; +} + +message GetIndexStatisticsRequest { + option (common.privilege_ext_obj) = { + object_type: Collection + object_privilege: PrivilegeIndexDetail + object_name_index: 3 + }; + // Not useful for now + common.MsgBase base = 1; + // Not useful for now + string db_name = 2; + // The particular collection name in Milvus + string collection_name = 3; + // The index name in this particular collection + string index_name = 4; + uint64 timestamp = 5; +} + +message GetIndexStatisticsResponse { + // Response status + common.Status status = 1; + // All index information. + repeated IndexDescription index_descriptions = 2; +} + +message ConnectRequest { + common.MsgBase base = 1; + common.ClientInfo client_info = 2; +} + +message ConnectResponse { + common.Status status = 1; + common.ServerInfo server_info = 2; + int64 identifier = 3; +} + +message AllocTimestampRequest { + common.MsgBase base = 1; +} + +message AllocTimestampResponse { + common.Status status = 1; + uint64 timestamp = 2; +} + +message CreateDatabaseRequest { + option (common.privilege_ext_obj) = { + object_type: Global + object_privilege: PrivilegeCreateDatabase + object_name_index: -1 + }; + common.MsgBase base = 1; + string db_name = 2; +} + +message DropDatabaseRequest { + option (common.privilege_ext_obj) = { + object_type: Global + object_privilege: PrivilegeDropDatabase + object_name_index: -1 + }; + common.MsgBase base = 1; + string db_name = 2; +} + +message ListDatabasesRequest { + option (common.privilege_ext_obj) = { + object_type: Global + object_privilege: PrivilegeListDatabases + object_name_index: -1 + }; + common.MsgBase base = 1; +} + +message ListDatabasesResponse { + option (common.privilege_ext_obj) = { + object_type: Global + object_privilege: PrivilegeShowCollections + object_name_index: -1 + }; + common.Status status = 1; + repeated string db_names = 2; + repeated uint64 created_timestamp = 3; +} + +message ReplicateMessageRequest { + common.MsgBase base = 1; + string channel_name = 2; + uint64 BeginTs = 3; + uint64 EndTs = 4; + repeated bytes Msgs = 5; + repeated msg.MsgPosition StartPositions = 6; + repeated msg.MsgPosition EndPositions = 7; +} + +message ReplicateMessageResponse { + common.Status status = 1; + string position = 2; +} diff --git a/all_proto/msg.proto b/all_proto/msg.proto new file mode 100644 index 0000000..1561ea4 --- /dev/null +++ b/all_proto/msg.proto @@ -0,0 +1,108 @@ +syntax = "proto3"; +package milvus.proto.msg; +option go_package = "github.com/milvus-io/milvus-proto/go-api/v2/msgpb"; + +import "common.proto"; +import "schema.proto"; + +enum InsertDataVersion { + // 0 must refer to row-based format, since it's the first version in Milvus. + RowBased = 0; + ColumnBased = 1; +} + +message InsertRequest { + common.MsgBase base = 1; + string shardName = 2; + string db_name = 3; + string collection_name = 4; + string partition_name = 5; + int64 dbID = 6; + int64 collectionID = 7; + int64 partitionID = 8; + int64 segmentID = 9; + repeated uint64 timestamps = 10; + repeated int64 rowIDs = 11; + // row_data was reserved for compatibility + repeated common.Blob row_data = 12; + repeated schema.FieldData fields_data = 13; + uint64 num_rows = 14; + InsertDataVersion version = 15; +} + +message DeleteRequest { + common.MsgBase base = 1; + string shardName = 2; + string db_name = 3; + string collection_name = 4; + string partition_name = 5; + int64 dbID = 6; + int64 collectionID = 7; + int64 partitionID = 8; + repeated int64 int64_primary_keys = 9; // deprecated + repeated uint64 timestamps = 10; + int64 num_rows = 11; + schema.IDs primary_keys = 12; +} + +message MsgPosition { + string channel_name = 1; + bytes msgID = 2; + string msgGroup = 3; + uint64 timestamp = 4; +} + +message CreateCollectionRequest { + common.MsgBase base = 1; + string db_name = 2; + string collectionName = 3; + string partitionName = 4; + // `schema` is the serialized `schema.CollectionSchema` + int64 dbID = 5; + int64 collectionID = 6; + int64 partitionID = 7; // deprecated + bytes schema = 8; + repeated string virtualChannelNames = 9; + repeated string physicalChannelNames = 10; + repeated int64 partitionIDs = 11; +} + +message DropCollectionRequest { + common.MsgBase base = 1; + string db_name = 2; + string collectionName = 3; + int64 dbID = 4; + int64 collectionID = 5; +} + +message CreatePartitionRequest { + common.MsgBase base = 1; + string db_name = 2; + string collection_name = 3; + string partition_name = 4; + int64 dbID = 5; + int64 collectionID = 6; + int64 partitionID = 7; +} + +message DropPartitionRequest { + common.MsgBase base = 1; + string db_name = 2; + string collection_name = 3; + string partition_name = 4; + int64 dbID = 5; + int64 collectionID = 6; + int64 partitionID = 7; +} + +message TimeTickMsg { + common.MsgBase base = 1; +} + +message DataNodeTtMsg { + common.MsgBase base =1; + string channel_name = 2; + uint64 timestamp = 3; + repeated common.SegmentStats segments_stats = 4; +} + diff --git a/all_proto/plan.proto b/all_proto/plan.proto new file mode 100644 index 0000000..ca19f76 --- /dev/null +++ b/all_proto/plan.proto @@ -0,0 +1,211 @@ +syntax = "proto3"; +package milvus.proto.plan; + +option go_package = "github.com/milvus-io/milvus/internal/proto/planpb"; +import "schema.proto"; + +enum OpType { + Invalid = 0; + GreaterThan = 1; + GreaterEqual = 2; + LessThan = 3; + LessEqual = 4; + Equal = 5; + NotEqual = 6; + PrefixMatch = 7; // startsWith + PostfixMatch = 8; // endsWith + Match = 9; // like + Range = 10; // for case 1 < a < b + In = 11; // TODO:: used for term expr + NotIn = 12; +}; + +enum ArithOpType { + Unknown = 0; + Add = 1; + Sub = 2; + Mul = 3; + Div = 4; + Mod = 5; + ArrayLength = 6; +}; + +enum VectorType { + BinaryVector = 0; + FloatVector = 1; + Float16Vector = 2; + BFloat16Vector = 3; + SparseFloatVector = 4; +}; + +message GenericValue { + oneof val { + bool bool_val = 1; + int64 int64_val = 2; + double float_val = 3; + string string_val = 4; + Array array_val = 5; + }; +} + +message Array { + repeated GenericValue array = 1; + bool same_type = 2; + schema.DataType element_type = 3; +} + +message QueryInfo { + int64 topk = 1; + string metric_type = 3; + string search_params = 4; + int64 round_decimal = 5; + int64 group_by_field_id = 6; +} + +message ColumnInfo { + int64 field_id = 1; + schema.DataType data_type = 2; + bool is_primary_key = 3; + bool is_autoID = 4; + repeated string nested_path = 5; + bool is_partition_key = 6; + schema.DataType element_type = 7; +} + +message ColumnExpr { + ColumnInfo info = 1; +} + +message ExistsExpr { + ColumnInfo info = 1; +} + +message ValueExpr { + GenericValue value = 1; +} + +message UnaryRangeExpr { + ColumnInfo column_info = 1; + OpType op = 2; + GenericValue value = 3; +} + +message BinaryRangeExpr { + ColumnInfo column_info = 1; + bool lower_inclusive = 2; + bool upper_inclusive = 3; + GenericValue lower_value = 4; + GenericValue upper_value = 5; +} + +message CompareExpr { + ColumnInfo left_column_info = 1; + ColumnInfo right_column_info = 2; + OpType op = 3; +} + +message TermExpr { + ColumnInfo column_info = 1; + repeated GenericValue values = 2; + bool is_in_field = 3; +} + +message JSONContainsExpr { + ColumnInfo column_info = 1; + repeated GenericValue elements = 2; + // 0: invalid + // 1: json_contains | array_contains + // 2: json_contains_all | array_contains_all + // 3: json_contains_any | array_contains_any + enum JSONOp { + Invalid = 0; + Contains = 1; + ContainsAll = 2; + ContainsAny = 3; + } + JSONOp op = 3; + bool elements_same_type = 4; +} + +message UnaryExpr { + enum UnaryOp { + Invalid = 0; + Not = 1; + }; + UnaryOp op = 1; + Expr child = 2; +} + +message BinaryExpr { + enum BinaryOp { + Invalid = 0; + LogicalAnd = 1; + LogicalOr = 2; + } + BinaryOp op = 1; + Expr left = 2; + Expr right = 3; +} + +message BinaryArithOp { + ColumnInfo column_info = 1; + ArithOpType arith_op = 2; + GenericValue right_operand = 3; +} + +message BinaryArithExpr { + Expr left = 1; + Expr right = 2; + ArithOpType op = 3; +} + +message BinaryArithOpEvalRangeExpr { + ColumnInfo column_info = 1; + ArithOpType arith_op = 2; + GenericValue right_operand = 3; + OpType op = 4; + GenericValue value = 5; +} + +message AlwaysTrueExpr {} + +message Expr { + oneof expr { + TermExpr term_expr = 1; + UnaryExpr unary_expr = 2; + BinaryExpr binary_expr = 3; + CompareExpr compare_expr = 4; + UnaryRangeExpr unary_range_expr = 5; + BinaryRangeExpr binary_range_expr = 6; + BinaryArithOpEvalRangeExpr binary_arith_op_eval_range_expr = 7; + BinaryArithExpr binary_arith_expr = 8; + ValueExpr value_expr = 9; + ColumnExpr column_expr = 10; + ExistsExpr exists_expr = 11; + AlwaysTrueExpr always_true_expr = 12; + JSONContainsExpr json_contains_expr = 13; + }; +} + +message VectorANNS { + VectorType vector_type = 1; + int64 field_id = 2; + Expr predicates = 3; + QueryInfo query_info = 4; + string placeholder_tag = 5; // always be "$0" +} + +message QueryPlanNode { + Expr predicates = 1; + bool is_count = 2; + int64 limit = 3; +}; + +message PlanNode { + oneof node { + VectorANNS vector_anns = 1; + Expr predicates = 2; // deprecated, use query instead. + QueryPlanNode query = 4; + } + repeated int64 output_field_ids = 3; +} diff --git a/all_proto/proxy.proto b/all_proto/proxy.proto new file mode 100644 index 0000000..5d02d1b --- /dev/null +++ b/all_proto/proxy.proto @@ -0,0 +1,80 @@ +syntax = "proto3"; +package milvus.proto.proxy; + +option go_package = "github.com/milvus-io/milvus/internal/proto/proxypb"; + +import "common.proto"; +import "internal.proto"; +import "milvus.proto"; + +service Proxy { + rpc GetComponentStates(milvus.GetComponentStatesRequest) returns (milvus.ComponentStates) {} + rpc GetStatisticsChannel(internal.GetStatisticsChannelRequest) returns(milvus.StringResponse){} + + rpc InvalidateCollectionMetaCache(InvalidateCollMetaCacheRequest) returns (common.Status) {} + rpc GetDdChannel(internal.GetDdChannelRequest) returns (milvus.StringResponse) {} + + rpc InvalidateCredentialCache(InvalidateCredCacheRequest) returns (common.Status) {} + rpc UpdateCredentialCache(UpdateCredCacheRequest) returns (common.Status) {} + + rpc RefreshPolicyInfoCache(RefreshPolicyInfoCacheRequest) returns (common.Status) {} + rpc GetProxyMetrics(milvus.GetMetricsRequest) returns (milvus.GetMetricsResponse) {} + rpc SetRates(SetRatesRequest) returns (common.Status) {} + + rpc ListClientInfos(ListClientInfosRequest) returns (ListClientInfosResponse) {} + + // importV2 + rpc ImportV2(internal.ImportRequest) returns(internal.ImportResponse){} + rpc GetImportProgress(internal.GetImportProgressRequest) returns(internal.GetImportProgressResponse){} + rpc ListImports(internal.ListImportsRequest) returns(internal.ListImportsResponse){} +} + +message InvalidateCollMetaCacheRequest { + // MsgType: + // DropCollection -> {meta cache, dml channels} + // Other -> {meta cache} + common.MsgBase base = 1; + string db_name = 2; + string collection_name = 3; + int64 collectionID = 4; + string partition_name = 5; +} + +message InvalidateCredCacheRequest { + common.MsgBase base = 1; + string username = 2; +} + +message UpdateCredCacheRequest { + common.MsgBase base = 1; + string username = 2; + // password stored in cache + string password = 3; +} + +message RefreshPolicyInfoCacheRequest { + common.MsgBase base = 1; + int32 opType = 2; + string opKey = 3; +} + +message CollectionRate { + int64 collection = 1; + repeated internal.Rate rates = 2; + repeated milvus.QuotaState states = 3; + repeated common.ErrorCode codes = 4; +} + +message SetRatesRequest { + common.MsgBase base = 1; + repeated CollectionRate rates = 2; +} + +message ListClientInfosRequest { + common.MsgBase base = 1; +} + +message ListClientInfosResponse { + common.Status status = 1; + repeated common.ClientInfo client_infos = 2; +} diff --git a/all_proto/query_coord.proto b/all_proto/query_coord.proto new file mode 100644 index 0000000..f77ce1c --- /dev/null +++ b/all_proto/query_coord.proto @@ -0,0 +1,769 @@ +syntax = "proto3"; + +package milvus.proto.query; + +option go_package = "github.com/milvus-io/milvus/internal/proto/querypb"; + +import "common.proto"; +import "milvus.proto"; +import "internal.proto"; +import "schema.proto"; +import "msg.proto"; +import "data_coord.proto"; +import "index_coord.proto"; + +service QueryCoord { + rpc GetComponentStates(milvus.GetComponentStatesRequest) + returns (milvus.ComponentStates) { + } + rpc GetTimeTickChannel(internal.GetTimeTickChannelRequest) + returns (milvus.StringResponse) { + } + rpc GetStatisticsChannel(internal.GetStatisticsChannelRequest) + returns (milvus.StringResponse) { + } + + rpc ShowCollections(ShowCollectionsRequest) + returns (ShowCollectionsResponse) { + } + rpc ShowPartitions(ShowPartitionsRequest) returns (ShowPartitionsResponse) { + } + + rpc LoadPartitions(LoadPartitionsRequest) returns (common.Status) { + } + rpc ReleasePartitions(ReleasePartitionsRequest) returns (common.Status) { + } + rpc LoadCollection(LoadCollectionRequest) returns (common.Status) { + } + rpc ReleaseCollection(ReleaseCollectionRequest) returns (common.Status) { + } + rpc SyncNewCreatedPartition(SyncNewCreatedPartitionRequest) + returns (common.Status) { + } + + rpc GetPartitionStates(GetPartitionStatesRequest) + returns (GetPartitionStatesResponse) { + } + rpc GetSegmentInfo(GetSegmentInfoRequest) returns (GetSegmentInfoResponse) { + } + rpc LoadBalance(LoadBalanceRequest) returns (common.Status) { + } + + rpc ShowConfigurations(internal.ShowConfigurationsRequest) + returns (internal.ShowConfigurationsResponse) { + } + // https://wiki.lfaidata.foundation/display/MIL/MEP+8+--+Add+metrics+for+proxy + rpc GetMetrics(milvus.GetMetricsRequest) + returns (milvus.GetMetricsResponse) { + } + + // https://wiki.lfaidata.foundation/display/MIL/MEP+23+--+Multiple+memory+replication+design + rpc GetReplicas(milvus.GetReplicasRequest) + returns (milvus.GetReplicasResponse) { + } + rpc GetShardLeaders(GetShardLeadersRequest) + returns (GetShardLeadersResponse) { + } + + rpc CheckHealth(milvus.CheckHealthRequest) + returns (milvus.CheckHealthResponse) { + } + + rpc CreateResourceGroup(milvus.CreateResourceGroupRequest) + returns (common.Status) { + } + rpc DropResourceGroup(milvus.DropResourceGroupRequest) + returns (common.Status) { + } + rpc TransferNode(milvus.TransferNodeRequest) returns (common.Status) { + } + rpc TransferReplica(TransferReplicaRequest) returns (common.Status) { + } + rpc ListResourceGroups(milvus.ListResourceGroupsRequest) + returns (milvus.ListResourceGroupsResponse) { + } + rpc DescribeResourceGroup(DescribeResourceGroupRequest) + returns (DescribeResourceGroupResponse) { + } + + // ops interfaces + rpc ListCheckers(ListCheckersRequest) returns (ListCheckersResponse) { + } + rpc ActivateChecker(ActivateCheckerRequest) returns (common.Status) { + } + rpc DeactivateChecker(DeactivateCheckerRequest) returns (common.Status) { + } +} + +service QueryNode { + rpc GetComponentStates(milvus.GetComponentStatesRequest) + returns (milvus.ComponentStates) { + } + rpc GetTimeTickChannel(internal.GetTimeTickChannelRequest) + returns (milvus.StringResponse) { + } + rpc GetStatisticsChannel(internal.GetStatisticsChannelRequest) + returns (milvus.StringResponse) { + } + + rpc WatchDmChannels(WatchDmChannelsRequest) returns (common.Status) { + } + rpc UnsubDmChannel(UnsubDmChannelRequest) returns (common.Status) { + } + rpc LoadSegments(LoadSegmentsRequest) returns (common.Status) { + } + rpc ReleaseCollection(ReleaseCollectionRequest) returns (common.Status) { + } + rpc LoadPartitions(LoadPartitionsRequest) returns (common.Status) { + } + rpc ReleasePartitions(ReleasePartitionsRequest) returns (common.Status) { + } + rpc ReleaseSegments(ReleaseSegmentsRequest) returns (common.Status) { + } + rpc GetSegmentInfo(GetSegmentInfoRequest) returns (GetSegmentInfoResponse) { + } + rpc SyncReplicaSegments(SyncReplicaSegmentsRequest) + returns (common.Status) { + } + + rpc GetStatistics(GetStatisticsRequest) + returns (internal.GetStatisticsResponse) { + } + rpc Search(SearchRequest) returns (internal.SearchResults) { + } + rpc HybridSearch(HybridSearchRequest) returns (HybridSearchResult) { + } + rpc SearchSegments(SearchRequest) returns (internal.SearchResults) { + } + rpc Query(QueryRequest) returns (internal.RetrieveResults) { + } + rpc QueryStream(QueryRequest) returns (stream internal.RetrieveResults) { + } + rpc QuerySegments(QueryRequest) returns (internal.RetrieveResults) { + } + rpc QueryStreamSegments(QueryRequest) + returns (stream internal.RetrieveResults) { + } + + rpc ShowConfigurations(internal.ShowConfigurationsRequest) + returns (internal.ShowConfigurationsResponse) { + } + // https://wiki.lfaidata.foundation/display/MIL/MEP+8+--+Add+metrics+for+proxy + rpc GetMetrics(milvus.GetMetricsRequest) + returns (milvus.GetMetricsResponse) { + } + + rpc GetDataDistribution(GetDataDistributionRequest) + returns (GetDataDistributionResponse) { + } + rpc SyncDistribution(SyncDistributionRequest) returns (common.Status) { + } + rpc Delete(DeleteRequest) returns (common.Status) { + } +} + +// --------------------QueryCoord grpc request and response proto------------------ + +message ShowCollectionsRequest { + common.MsgBase base = 1; + // Not useful for now + int64 dbID = 2; + repeated int64 collectionIDs = 3; +} + +message ShowCollectionsResponse { + common.Status status = 1; + repeated int64 collectionIDs = 2; + repeated int64 inMemory_percentages = 3; + repeated bool query_service_available = 4; + repeated int64 refresh_progress = 5; +} + +message ShowPartitionsRequest { + common.MsgBase base = 1; + int64 dbID = 2; + int64 collectionID = 3; + repeated int64 partitionIDs = 4; +} + +message ShowPartitionsResponse { + common.Status status = 1; + repeated int64 partitionIDs = 2; + repeated int64 inMemory_percentages = 3; + repeated int64 refresh_progress = 4; +} + +message LoadCollectionRequest { + common.MsgBase base = 1; + int64 dbID = 2; + int64 collectionID = 3; + schema.CollectionSchema schema = 4; + int32 replica_number = 5; + // fieldID -> indexID + map field_indexID = 6; + bool refresh = 7; + // resource group names + repeated string resource_groups = 8; +} + +message ReleaseCollectionRequest { + common.MsgBase base = 1; + int64 dbID = 2; + int64 collectionID = 3; + int64 nodeID = 4; +} + +message GetStatisticsRequest { + internal.GetStatisticsRequest req = 1; + repeated string dml_channels = 2; + repeated int64 segmentIDs = 3; + bool from_shard_leader = 4; + DataScope scope = 5; // All, Streaming, Historical +} + +message LoadPartitionsRequest { + common.MsgBase base = 1; + int64 dbID = 2; + int64 collectionID = 3; + repeated int64 partitionIDs = 4; + schema.CollectionSchema schema = 5; + int32 replica_number = 6; + // fieldID -> indexID + map field_indexID = 7; + bool refresh = 8; + // resource group names + repeated string resource_groups = 9; + repeated index.IndexInfo index_info_list = 10; +} + +message ReleasePartitionsRequest { + common.MsgBase base = 1; + int64 dbID = 2; + int64 collectionID = 3; + repeated int64 partitionIDs = 4; + int64 nodeID = 5; +} + +message GetPartitionStatesRequest { + common.MsgBase base = 1; + int64 dbID = 2; + int64 collectionID = 3; + repeated int64 partitionIDs = 4; +} + +message GetPartitionStatesResponse { + common.Status status = 1; + repeated PartitionStates partition_descriptions = 2; +} + +message GetSegmentInfoRequest { + common.MsgBase base = 1; + repeated int64 segmentIDs = 2; // deprecated + int64 collectionID = 3; +} + +message GetSegmentInfoResponse { + common.Status status = 1; + repeated SegmentInfo infos = 2; +} + +message GetShardLeadersRequest { + common.MsgBase base = 1; + int64 collectionID = 2; +} + +message GetShardLeadersResponse { + common.Status status = 1; + repeated ShardLeadersList shards = 2; +} + +message ShardLeadersList { // All leaders of all replicas of one shard + string channel_name = 1; + repeated int64 node_ids = 2; + repeated string node_addrs = 3; +} + +message SyncNewCreatedPartitionRequest { + common.MsgBase base = 1; + int64 collectionID = 2; + int64 partitionID = 3; +} + +// -----------------query node grpc request and response proto---------------- + +message LoadMetaInfo { + LoadType load_type = 1; + int64 collectionID = 2; + repeated int64 partitionIDs = 3; + string metric_type = 4 [deprecated = true]; +} + +message WatchDmChannelsRequest { + common.MsgBase base = 1; + int64 nodeID = 2; + int64 collectionID = 3; + repeated int64 partitionIDs = 4; + repeated data.VchannelInfo infos = 5; + schema.CollectionSchema schema = 6; + repeated data.SegmentInfo exclude_infos = 7; + LoadMetaInfo load_meta = 8; + int64 replicaID = 9; + map segment_infos = 10; + // Deprecated + // for node down load balance, need to remove offline node in time after every watchDmChannel finish. + int64 offlineNodeID = 11; + int64 version = 12; + repeated index.IndexInfo index_info_list = 13; +} + +message UnsubDmChannelRequest { + common.MsgBase base = 1; + int64 nodeID = 2; + int64 collectionID = 3; + string channel_name = 4; +} + +message SegmentLoadInfo { + int64 segmentID = 1; + int64 partitionID = 2; + int64 collectionID = 3; + int64 dbID = 4; + int64 flush_time = 5; + repeated data.FieldBinlog binlog_paths = 6; + int64 num_of_rows = 7; + repeated data.FieldBinlog statslogs = 8; + repeated data.FieldBinlog deltalogs = 9; + repeated int64 compactionFrom = 10; // segmentIDs compacted from + repeated FieldIndexInfo index_infos = 11; + int64 segment_size = 12; + string insert_channel = 13; + msg.MsgPosition start_position = 14; + msg.MsgPosition delta_position = 15; + int64 readableVersion = 16; + data.SegmentLevel level = 17; + int64 storageVersion = 18; +} + +message FieldIndexInfo { + int64 fieldID = 1; + // deprecated + bool enable_index = 2; + string index_name = 3; + int64 indexID = 4; + int64 buildID = 5; + repeated common.KeyValuePair index_params = 6; + repeated string index_file_paths = 7; + int64 index_size = 8; + int64 index_version = 9; + int64 num_rows = 10; + int32 current_index_version = 11; + int64 index_store_version = 12; +} + +enum LoadScope { + Full = 0; + Delta = 1; + Index = 2; +} + +message LoadSegmentsRequest { + common.MsgBase base = 1; + int64 dst_nodeID = 2; + repeated SegmentLoadInfo infos = 3; + schema.CollectionSchema schema = 4; + int64 source_nodeID = 5; + int64 collectionID = 6; + LoadMetaInfo load_meta = 7; + int64 replicaID = 8; + repeated msg.MsgPosition delta_positions = + 9; // keep it for compatibility of rolling upgrade from 2.2.x to 2.3 + int64 version = 10; + bool need_transfer = 11; + LoadScope load_scope = 12; + repeated index.IndexInfo index_info_list = 13; + bool lazy_load = 14; +} + +message ReleaseSegmentsRequest { + common.MsgBase base = 1; + int64 nodeID = 2; + // Not useful for now + int64 dbID = 3; + int64 collectionID = 4; + repeated int64 partitionIDs = 5; + repeated int64 segmentIDs = 6; + DataScope scope = 7; // All, Streaming, Historical + string shard = 8; + bool need_transfer = 11; +} + +message SearchRequest { + internal.SearchRequest req = 1; + repeated string dml_channels = 2; + repeated int64 segmentIDs = 3; + bool from_shard_leader = 4; + DataScope scope = 5; // All, Streaming, Historical + int32 total_channel_num = 6; +} + +message HybridSearchRequest { + internal.HybridSearchRequest req = 1; + repeated string dml_channels = 2; + int32 total_channel_num = 3; +} + +message HybridSearchResult { + common.MsgBase base = 1; + common.Status status = 2; + repeated internal.SearchResults results = 3; + internal.CostAggregation costAggregation = 4; + map channels_mvcc = 5; +} + +message QueryRequest { + internal.RetrieveRequest req = 1; + repeated string dml_channels = 2; + repeated int64 segmentIDs = 3; + bool from_shard_leader = 4; + DataScope scope = 5; // All, Streaming, Historical +} + +message SyncReplicaSegmentsRequest { + common.MsgBase base = 1; + string vchannel_name = 2; + repeated ReplicaSegmentsInfo replica_segments = 3; +} + +message ReplicaSegmentsInfo { + int64 node_id = 1; + int64 partition_id = 2; + repeated int64 segment_ids = 3; + repeated int64 versions = 4; +} + +message GetLoadInfoRequest { + common.MsgBase base = 1; + int64 collection_id = 2; +} + +message GetLoadInfoResponse { + common.Status status = 1; + schema.CollectionSchema schema = 2; + LoadType load_type = 3; + repeated int64 partitions = 4; +} + +// ----------------request auto triggered by QueryCoord----------------- + +message HandoffSegmentsRequest { + common.MsgBase base = 1; + repeated SegmentInfo segmentInfos = 2; + repeated int64 released_segments = 3; +} + +message LoadBalanceRequest { + common.MsgBase base = 1; + repeated int64 source_nodeIDs = 2; + TriggerCondition balance_reason = 3; + repeated int64 dst_nodeIDs = 4; + repeated int64 sealed_segmentIDs = 5; + int64 collectionID = 6; +} + +// -------------------- internal meta proto------------------ + +enum DataScope { + UnKnown = 0; + All = 1; + Streaming = 2; + Historical = 3; +} + +enum PartitionState { + NotExist = 0; + NotPresent = 1; + OnDisk = 2; + PartialInMemory = 3; + InMemory = 4; + PartialInGPU = 5; + InGPU = 6; +} + +enum TriggerCondition { + UnKnowCondition = 0; + Handoff = 1; + LoadBalance = 2; + GrpcRequest = 3; + NodeDown = 4; +} + +enum LoadType { + UnKnownType = 0; + LoadPartition = 1; + LoadCollection = 2; +} + +message DmChannelWatchInfo { + int64 collectionID = 1; + string dmChannel = 2; + int64 nodeID_loaded = 3; + int64 replicaID = 4; + repeated int64 node_ids = 5; +} + +message QueryChannelInfo { + int64 collectionID = 1; + string query_channel = 2; + string query_result_channel = 3; + repeated SegmentInfo global_sealed_segments = 4; + msg.MsgPosition seek_position = 5; +} + +message PartitionStates { + int64 partitionID = 1; + PartitionState state = 2; + int64 inMemory_percentage = 3; +} + +message SegmentInfo { + int64 segmentID = 1; + int64 collectionID = 2; + int64 partitionID = 3; + // deprecated, check node_ids(NodeIds) field + int64 nodeID = 4; + int64 mem_size = 5; + int64 num_rows = 6; + string index_name = 7; + int64 indexID = 8; + string dmChannel = 9; + repeated int64 compactionFrom = 10; + bool createdByCompaction = 11; + common.SegmentState segment_state = 12; + repeated FieldIndexInfo index_infos = 13; + repeated int64 replica_ids = 14; + repeated int64 node_ids = 15; + bool enable_index = 16; + bool is_fake = 17; +} + +message CollectionInfo { + int64 collectionID = 1; + repeated int64 partitionIDs = 2; + repeated PartitionStates partition_states = 3; + LoadType load_type = 4; + schema.CollectionSchema schema = 5; + repeated int64 released_partitionIDs = 6; + int64 inMemory_percentage = 7; + repeated int64 replica_ids = 8; + int32 replica_number = 9; +} + +message UnsubscribeChannels { + int64 collectionID = 1; + repeated string channels = 2; +} + +message UnsubscribeChannelInfo { + int64 nodeID = 1; + repeated UnsubscribeChannels collection_channels = 2; +} + +// ---- synchronize messages proto between QueryCoord and QueryNode ----- + +message SegmentChangeInfo { + int64 online_nodeID = 1; + repeated SegmentInfo online_segments = 2; + int64 offline_nodeID = 3; + repeated SegmentInfo offline_segments = 4; +} + +message SealedSegmentsChangeInfo { + common.MsgBase base = 1; + repeated SegmentChangeInfo infos = 2; +} + +message GetDataDistributionRequest { + common.MsgBase base = 1; + map checkpoints = 2; +} + +message GetDataDistributionResponse { + common.Status status = 1; + int64 nodeID = 2; + repeated SegmentVersionInfo segments = 3; + repeated ChannelVersionInfo channels = 4; + repeated LeaderView leader_views = 5; +} + +message LeaderView { + int64 collection = 1; + string channel = 2; + map segment_dist = 3; + repeated int64 growing_segmentIDs = 4; + map growing_segments = 5; + int64 TargetVersion = 6; + int64 num_of_growing_rows = 7; +} + +message SegmentDist { + int64 nodeID = 1; + int64 version = 2; +} + +message SegmentVersionInfo { + int64 ID = 1; + int64 collection = 2; + int64 partition = 3; + string channel = 4; + int64 version = 5; + uint64 last_delta_timestamp = 6; + map index_info = 7; +} + +message ChannelVersionInfo { + string channel = 1; + int64 collection = 2; + int64 version = 3; +} + +enum LoadStatus { + Invalid = 0; + Loading = 1; + Loaded = 2; +} + +message CollectionLoadInfo { + int64 collectionID = 1; + repeated int64 released_partitions = + 2; // Deprecated: No longer used; kept for compatibility. + int32 replica_number = 3; + LoadStatus status = 4; + map field_indexID = 5; + LoadType load_type = 6; + int32 recover_times = 7; +} + +message PartitionLoadInfo { + int64 collectionID = 1; + int64 partitionID = 2; + int32 replica_number = + 3; // Deprecated: No longer used; kept for compatibility. + LoadStatus status = 4; + map field_indexID = + 5; // Deprecated: No longer used; kept for compatibility. + int32 recover_times = 7; +} + +message Replica { + int64 ID = 1; + int64 collectionID = 2; + repeated int64 nodes = 3; + string resource_group = 4; +} + +enum SyncType { + Remove = 0; + Set = 1; + Amend = 2; + UpdateVersion = 3; +} + +message SyncAction { + SyncType type = 1; + int64 partitionID = 2; + int64 segmentID = 3; + int64 nodeID = 4; + int64 version = 5; + SegmentLoadInfo info = 6; + repeated int64 growingInTarget = 7; + repeated int64 sealedInTarget = 8; + int64 TargetVersion = 9; + repeated int64 droppedInTarget = 10; + msg.MsgPosition checkpoint = 11; +} + +message SyncDistributionRequest { + common.MsgBase base = 1; + int64 collectionID = 2; + string channel = 3; + repeated SyncAction actions = 4; + schema.CollectionSchema schema = 5; + LoadMetaInfo load_meta = 6; + int64 replicaID = 7; + int64 version = 8; + repeated index.IndexInfo index_info_list = 9; +} + +message ResourceGroup { + string name = 1; + int32 capacity = 2; + repeated int64 nodes = 3; +} + +// transfer `replicaNum` replicas in `collectionID` from `source_resource_group` to `target_resource_groups` +message TransferReplicaRequest { + common.MsgBase base = 1; + string source_resource_group = 2; + string target_resource_group = 3; + int64 collectionID = 4; + int64 num_replica = 5; +} + +message DescribeResourceGroupRequest { + common.MsgBase base = 1; + string resource_group = 2; +} + +message DescribeResourceGroupResponse { + common.Status status = 1; + ResourceGroupInfo resource_group = 2; +} + +message ResourceGroupInfo { + string name = 1; + int32 capacity = 2; + int32 num_available_node = 3; + // collection id -> loaded replica num + map num_loaded_replica = 4; + // collection id -> accessed other rg's node num + map num_outgoing_node = 5; + // collection id -> be accessed node num by other rg + map num_incoming_node = 6; +} +message DeleteRequest { + common.MsgBase base = 1; + int64 collection_id = 2; + int64 partition_id = 3; + string vchannel_name = 4; + int64 segment_id = 5; + schema.IDs primary_keys = 6; + repeated uint64 timestamps = 7; + DataScope scope = 8; +} + +message ActivateCheckerRequest { + common.MsgBase base = 1; + int32 checkerID = 2; +} + +message DeactivateCheckerRequest { + common.MsgBase base = 1; + int32 checkerID = 2; +} + +message ListCheckersRequest { + common.MsgBase base = 1; + repeated int32 checkerIDs = 2; +} + +message ListCheckersResponse { + common.Status status = 1; + repeated CheckerInfo checkerInfos = 2; +} + +message CheckerInfo { + int32 id = 1; + string desc = 2; + bool activated = 3; + bool found = 4; +} diff --git a/all_proto/rg.proto b/all_proto/rg.proto new file mode 100644 index 0000000..91af861 --- /dev/null +++ b/all_proto/rg.proto @@ -0,0 +1,29 @@ +syntax = "proto3"; +package milvus.proto.rg; + +option go_package = "github.com/milvus-io/milvus-proto/go-api/v2/rgpb"; + +option java_multiple_files = true; +option java_package = "io.milvus.grpc"; +option java_outer_classname = "ResourceGroupProto"; +option java_generate_equals_and_hash = true; + +option csharp_namespace = "Milvus.Client.Grpc"; + +message ResourceGroupLimit { + int32 nodeNum = 1; + // preserve for other limit. +} + +message ResourceGroupTransfer { + string resource_group = 1; // resource groups can be transfered with current resource group. + // preserve for other option, such as weight, priority or affinity setup. +} + +message ResourceGroupConfig { + ResourceGroupLimit requests = 1; // requests node num in resource group, if node num is less than requests.nodeNum, it will be transfer from other resource group. + ResourceGroupLimit limits = 2; // limited node num in resource group, if node num is more than limits.nodeNum, it will be transfer to other resource group. + repeated ResourceGroupTransfer from = 3; // missing node should be transfer from given resource group at high priority in repeated list. + repeated ResourceGroupTransfer to = 4; // redundant node should be transfer to given resource group at high priority in repeated list. +} + diff --git a/all_proto/root_coord.proto b/all_proto/root_coord.proto new file mode 100644 index 0000000..86f5d7b --- /dev/null +++ b/all_proto/root_coord.proto @@ -0,0 +1,226 @@ +syntax = "proto3"; +package milvus.proto.rootcoord; + +option go_package="github.com/milvus-io/milvus/internal/proto/rootcoordpb"; + +import "common.proto"; +import "milvus.proto"; +import "internal.proto"; +import "proxy.proto"; +//import "data_coord.proto"; +import "etcd_meta.proto"; + +service RootCoord { + rpc GetComponentStates(milvus.GetComponentStatesRequest) returns (milvus.ComponentStates) {} + rpc GetTimeTickChannel(internal.GetTimeTickChannelRequest) returns(milvus.StringResponse) {} + rpc GetStatisticsChannel(internal.GetStatisticsChannelRequest) returns(milvus.StringResponse){} + /** + * @brief This method is used to create collection + * + * @param CreateCollectionRequest, use to provide collection information to be created. + * + * @return Status + */ + rpc CreateCollection(milvus.CreateCollectionRequest) returns (common.Status){} + + /** + * @brief This method is used to delete collection. + * + * @param DropCollectionRequest, collection name is going to be deleted. + * + * @return Status + */ + rpc DropCollection(milvus.DropCollectionRequest) returns (common.Status) {} + + /** + * @brief This method is used to test collection existence. + * + * @param HasCollectionRequest, collection name is going to be tested. + * + * @return BoolResponse + */ + rpc HasCollection(milvus.HasCollectionRequest) returns (milvus.BoolResponse) {} + + /** + * @brief This method is used to get collection schema. + * + * @param DescribeCollectionRequest, target collection name. + * + * @return CollectionSchema + */ + rpc DescribeCollection(milvus.DescribeCollectionRequest) returns (milvus.DescribeCollectionResponse) {} + rpc DescribeCollectionInternal(milvus.DescribeCollectionRequest) returns (milvus.DescribeCollectionResponse) {} + + rpc CreateAlias(milvus.CreateAliasRequest) returns (common.Status) {} + rpc DropAlias(milvus.DropAliasRequest) returns (common.Status) {} + rpc AlterAlias(milvus.AlterAliasRequest) returns (common.Status) {} + rpc DescribeAlias(milvus.DescribeAliasRequest) returns (milvus.DescribeAliasResponse) {} + rpc ListAliases(milvus.ListAliasesRequest) returns (milvus.ListAliasesResponse) {} + + /** + * @brief This method is used to list all collections. + * + * @return StringListResponse, collection name list + */ + rpc ShowCollections(milvus.ShowCollectionsRequest) returns (milvus.ShowCollectionsResponse) {} + + rpc AlterCollection(milvus.AlterCollectionRequest) returns (common.Status) {} + + /** + * @brief This method is used to create partition + * + * @return Status + */ + rpc CreatePartition(milvus.CreatePartitionRequest) returns (common.Status) {} + + /** + * @brief This method is used to drop partition + * + * @return Status + */ + rpc DropPartition(milvus.DropPartitionRequest) returns (common.Status) {} + + /** + * @brief This method is used to test partition existence. + * + * @return BoolResponse + */ + rpc HasPartition(milvus.HasPartitionRequest) returns (milvus.BoolResponse) {} + + /** + * @brief This method is used to show partition information + * + * @param ShowPartitionRequest, target collection name. + * + * @return StringListResponse + */ + rpc ShowPartitions(milvus.ShowPartitionsRequest) returns (milvus.ShowPartitionsResponse) {} + rpc ShowPartitionsInternal(milvus.ShowPartitionsRequest) returns (milvus.ShowPartitionsResponse) {} + +// rpc DescribeSegment(milvus.DescribeSegmentRequest) returns (milvus.DescribeSegmentResponse) {} + rpc ShowSegments(milvus.ShowSegmentsRequest) returns (milvus.ShowSegmentsResponse) {} +// rpc DescribeSegments(DescribeSegmentsRequest) returns (DescribeSegmentsResponse) {} + +// rpc CreateIndex(milvus.CreateIndexRequest) returns (common.Status) {} +// rpc DescribeIndex(milvus.DescribeIndexRequest) returns (milvus.DescribeIndexResponse) {} +// rpc DropIndex(milvus.DropIndexRequest) returns (common.Status) {} +// rpc GetIndexState(milvus.GetIndexStateRequest) returns (milvus.GetIndexStateResponse) {} + + rpc AllocTimestamp(AllocTimestampRequest) returns (AllocTimestampResponse) {} + rpc AllocID(AllocIDRequest) returns (AllocIDResponse) {} + rpc UpdateChannelTimeTick(internal.ChannelTimeTickMsg) returns (common.Status) {} + rpc InvalidateCollectionMetaCache(proxy.InvalidateCollMetaCacheRequest) returns (common.Status) {} +// rpc SegmentFlushCompleted(data.SegmentFlushCompletedMsg) returns (common.Status) {} + + rpc ShowConfigurations(internal.ShowConfigurationsRequest) returns (internal.ShowConfigurationsResponse){} + // https://wiki.lfaidata.foundation/display/MIL/MEP+8+--+Add+metrics+for+proxy + rpc GetMetrics(milvus.GetMetricsRequest) returns (milvus.GetMetricsResponse) {} + + // https://wiki.lfaidata.foundation/display/MIL/MEP+24+--+Support+bulk+load + rpc Import(milvus.ImportRequest) returns (milvus.ImportResponse) {} + rpc GetImportState(milvus.GetImportStateRequest) returns (milvus.GetImportStateResponse) {} + rpc ListImportTasks(milvus.ListImportTasksRequest) returns (milvus.ListImportTasksResponse) {} + rpc ReportImport(ImportResult) returns (common.Status) {} + + // https://wiki.lfaidata.foundation/display/MIL/MEP+27+--+Support+Basic+Authentication + rpc CreateCredential(internal.CredentialInfo) returns (common.Status) {} + rpc UpdateCredential(internal.CredentialInfo) returns (common.Status) {} + rpc DeleteCredential(milvus.DeleteCredentialRequest) returns (common.Status) {} + rpc ListCredUsers(milvus.ListCredUsersRequest) returns (milvus.ListCredUsersResponse) {} + // userd by proxy, not exposed to sdk + rpc GetCredential(GetCredentialRequest) returns (GetCredentialResponse) {} + + // https://wiki.lfaidata.foundation/display/MIL/MEP+29+--+Support+Role-Based+Access+Control + rpc CreateRole(milvus.CreateRoleRequest) returns (common.Status) {} + rpc DropRole(milvus.DropRoleRequest) returns (common.Status) {} + rpc OperateUserRole(milvus.OperateUserRoleRequest) returns (common.Status) {} + rpc SelectRole(milvus.SelectRoleRequest) returns (milvus.SelectRoleResponse) {} + rpc SelectUser(milvus.SelectUserRequest) returns (milvus.SelectUserResponse) {} + rpc OperatePrivilege(milvus.OperatePrivilegeRequest) returns (common.Status) {} + rpc SelectGrant(milvus.SelectGrantRequest) returns (milvus.SelectGrantResponse) {} + rpc ListPolicy(internal.ListPolicyRequest) returns (internal.ListPolicyResponse) {} + + rpc CheckHealth(milvus.CheckHealthRequest) returns (milvus.CheckHealthResponse) {} + + rpc RenameCollection(milvus.RenameCollectionRequest) returns (common.Status) {} + + rpc CreateDatabase(milvus.CreateDatabaseRequest) returns (common.Status) {} + rpc DropDatabase(milvus.DropDatabaseRequest) returns (common.Status) {} + rpc ListDatabases(milvus.ListDatabasesRequest) returns (milvus.ListDatabasesResponse) {} +} + +message AllocTimestampRequest { + common.MsgBase base = 1; + uint32 count = 3; +} + +message AllocTimestampResponse { + common.Status status = 1; + uint64 timestamp = 2; + uint32 count = 3; +} + +message AllocIDRequest { + common.MsgBase base = 1; + uint32 count = 2; +} + +message AllocIDResponse { + common.Status status = 1; + int64 ID = 2; + uint32 count = 3; +} + +message ImportResult { + common.Status status = 1; + int64 task_id = 2; // id of the task + int64 datanode_id = 3; // id of the datanode which takes this task + common.ImportState state = 4; // state of the task + repeated int64 segments = 5; // id array of new sealed segments + repeated int64 auto_ids = 6; // auto-generated ids for auto-id primary key + int64 row_count = 7; // how many rows are imported by this task + repeated common.KeyValuePair infos = 8; // more informations about the task, file path, failed reason, etc. +} + +// TODO: find a proper place for these segment-related messages. + +message DescribeSegmentsRequest { + common.MsgBase base = 1; + int64 collectionID = 2; + repeated int64 segmentIDs = 3; +} + +message SegmentBaseInfo { + int64 collectionID = 1; // in which collection. + int64 partitionID = 2; // in which partition. + int64 segmentID = 3; +} + +message SegmentInfos { + SegmentBaseInfo base_info = 1; // base information. + repeated etcd.SegmentIndexInfo index_infos = 2; // multiple index infos. + map extra_index_infos = 3; // index_id -> IndexInfo{index_name, index_id, index_params} +} + +message DescribeSegmentsResponse { + common.Status status = 1; + int64 collectionID = 2; + map segment_infos = 3; // segment_id -> segment infos +} + +message GetCredentialRequest { + // Not useful for now + common.MsgBase base = 1; + // username + string username = 2; +} + +message GetCredentialResponse { + // Contain error_code and reason + common.Status status = 1; + // username + string username = 2; + // password stored in etcd/mysql + string password = 3; +} + diff --git a/all_proto/schema.proto b/all_proto/schema.proto new file mode 100644 index 0000000..ff972b9 --- /dev/null +++ b/all_proto/schema.proto @@ -0,0 +1,196 @@ +syntax = "proto3"; +package milvus.proto.schema; + +option go_package = "github.com/milvus-io/milvus-proto/go-api/v2/schemapb"; + +option java_multiple_files = true; +option java_package = "io.milvus.grpc"; +option java_outer_classname = "SchemaProto"; +option java_generate_equals_and_hash = true; + +option csharp_namespace = "Milvus.Client.Grpc"; + +import "common.proto"; +import "google/protobuf/descriptor.proto"; + +/** + * @brief Field data type + */ +enum DataType { + None = 0; + Bool = 1; + Int8 = 2; + Int16 = 3; + Int32 = 4; + Int64 = 5; + + Float = 10; + Double = 11; + + String = 20; + VarChar = 21; // variable-length strings with a specified maximum length + Array = 22; + JSON = 23; + + BinaryVector = 100; + FloatVector = 101; + Float16Vector = 102; + BFloat16Vector = 103; + SparseFloatVector = 104; +} + +enum FieldState { + FieldCreated = 0; + FieldCreating = 1; + FieldDropping = 2; + FieldDropped = 3; +} + +/** + * @brief Field schema + */ +message FieldSchema { + int64 fieldID = 1; + string name = 2; + bool is_primary_key = 3; + string description = 4; + DataType data_type = 5; + repeated common.KeyValuePair type_params = 6; + repeated common.KeyValuePair index_params = 7; + bool autoID = 8; + FieldState state = 9; // To keep compatible with older version, the default + // state is `Created`. + DataType element_type = 10; // For array type, the element type is stored here + ValueField default_value = 11; // default_value only support scalars except array and json for now + bool is_dynamic = 12; // mark whether this field is the dynamic field + bool is_partition_key = 13; // enable logic partitions + bool is_clustering_key = 14; +} + +/** + * @brief Collection schema + */ +message CollectionSchema { + string name = 1; + string description = 2; + bool autoID = 3 [deprecated=true]; // deprecated later, keep compatible with c++ part now + repeated FieldSchema fields = 4; + bool enable_dynamic_field = 5; // mark whether this table has the dynamic field function enabled. + repeated common.KeyValuePair properties = 6; +} + +message BoolArray { repeated bool data = 1; } + +message IntArray { repeated int32 data = 1; } + +message LongArray { repeated int64 data = 1; } + +message FloatArray { repeated float data = 1; } + +message DoubleArray { repeated double data = 1; } + +// For special fields such as bigdecimal, array... +message BytesArray { repeated bytes data = 1; } + +message StringArray { repeated string data = 1; } + +message ArrayArray { + repeated ScalarField data = 1; + DataType element_type = 2; +} + +message JSONArray { repeated bytes data = 1; } + +message ValueField { + oneof data { + bool bool_data = 1; + int32 int_data = 2; + int64 long_data = 3; + float float_data = 4; + double double_data = 5; + string string_data = 6; + bytes bytes_data = 7; + } +} + +message ScalarField { + oneof data { + BoolArray bool_data = 1; + IntArray int_data = 2; + LongArray long_data = 3; + FloatArray float_data = 4; + DoubleArray double_data = 5; + StringArray string_data = 6; + BytesArray bytes_data = 7; + ArrayArray array_data = 8; + JSONArray json_data = 9; + } +} + +// beta, api may change +message SparseFloatArray { + repeated bytes contents = 1; + // dim is the max dimension of the current batch of vectors + int64 dim = 2; +} + +message VectorField { + // For sparse vector, dim is the max dimension of the current batch of vectors + int64 dim = 1; + oneof data { + FloatArray float_vector = 2; + bytes binary_vector = 3; + bytes float16_vector = 4; + bytes bfloat16_vector = 5; + SparseFloatArray sparse_float_vector = 6; + } +} + +message FieldData { + DataType type = 1; + string field_name = 2; + oneof field { + ScalarField scalars = 3; + VectorField vectors = 4; + } + int64 field_id = 5; + bool is_dynamic = 6; +} + +message IDs { + oneof id_field { + LongArray int_id = 1; + StringArray str_id = 2; + } +} + +message SearchResultData { + int64 num_queries = 1; + int64 top_k = 2; + repeated FieldData fields_data = 3; + repeated float scores = 4; + IDs ids = 5; + repeated int64 topks = 6; + repeated string output_fields = 7; + FieldData group_by_field_value = 8; + int64 all_search_count = 9; +} + +// vector field clustering info +message VectorClusteringInfo { + // for multi vectors + string field = 1; + schema.VectorField centroid = 2; +} + +// Scalar field clustering info +// todo more definitions: min/max, etc +message ScalarClusteringInfo { + string field = 1; +} + +// clustering distribution info of a certain data unit, it can be segment, partition, etc. +message ClusteringInfo { + repeated VectorClusteringInfo vector_clustering_infos = 1; + repeated ScalarClusteringInfo scalar_clustering_infos = 2; +} diff --git a/all_proto/segcore.proto b/all_proto/segcore.proto new file mode 100644 index 0000000..ea7697f --- /dev/null +++ b/all_proto/segcore.proto @@ -0,0 +1,45 @@ +syntax = "proto3"; +package milvus.proto.segcore; + +option go_package = "github.com/milvus-io/milvus/internal/proto/segcorepb"; +import "schema.proto"; +import "common.proto"; + +message RetrieveResults { + schema.IDs ids = 1; + repeated int64 offset = 2; + repeated schema.FieldData fields_data = 3; + int64 all_retrieve_count = 4; +} + +message LoadFieldMeta { + int64 min_timestamp = 1; + int64 max_timestamp = 2; + int64 row_count = 3; +} + +message LoadSegmentMeta { + // TODOs + repeated LoadFieldMeta metas = 1; + int64 total_size = 2; +} + +message InsertRecord { + repeated schema.FieldData fields_data = 1; + int64 num_rows = 2; +} + +message FieldIndexMeta { + int64 fieldID = 1; + int64 collectionID = 2; + string index_name = 3; + repeated common.KeyValuePair type_params = 4; + repeated common.KeyValuePair index_params = 5; + bool is_auto_index = 6; + repeated common.KeyValuePair user_index_params = 7; +} + +message CollectionIndexMeta { + int64 maxIndexRowCount = 1; + repeated FieldIndexMeta index_metas = 2; +} \ No newline at end of file diff --git a/app/milvus-cli/.DS_Store b/app/milvus-cli/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..c88a062b05be4fd1d362b3e4c6a7481e718b69d0 GIT binary patch literal 6148 zcmeH~O$x$5422WzLU7Zi%h`AUZ!n0Spcima5J4*Vx1OW>k_m#k8KJGkN^pg011%5 z4-v3?8#bF)Wh4O-Ab}?V`#vPNX$~z_{nLTqBLK8P*$r!-C7{U)&>UK-q5{*H9yD6j z#}KP~J2b_)99pW@cF`C;crrWIXQgOGwy`I%~QMGk}L;X0y%TE9jyNVZZH|!@{KyzrRiVBQB0*--!1inh( E0rZ6u#{d8T literal 0 HcmV?d00001 diff --git a/app/milvus-cli/README.md b/app/milvus-cli/README.md new file mode 100644 index 0000000..e69de29 diff --git a/app/milvus-cli/mucli/__init__.py b/app/milvus-cli/mucli/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/app/milvus-cli/mucli/_milvus.py b/app/milvus-cli/mucli/_milvus.py new file mode 100644 index 0000000..3d7beb7 --- /dev/null +++ b/app/milvus-cli/mucli/_milvus.py @@ -0,0 +1,1030 @@ +import csv +import os +import random +from typing import List +from click import * +from click.core import Context +from dotenv import load_dotenv + +import milvus_connector +from milvus_connector.core._types import * +from milvus_connector.core.util import CollectionField, construct_data, convert_data, ok, generate_random_data + +from mucli._option import * + + +SUB_COMMAND_GROUP = ["proxy"] + +# alias -> real command +ALIAS_CMD = { + "collections": "show-collections", + "list-collections": "show-collections", + "partitions": "show-partitions", + "list-partitions": "show-partitions", + "databases": "list-databases", + "show-databases": "list-databases", + "users": "select-user", + "roles": "select-role", +} + +class MilvusGroup(Group): + def list_commands(self, ctx: Context) -> List[str]: + cmds = super().list_commands(ctx) + for sub_cmd in SUB_COMMAND_GROUP: + if sub_cmd in cmds: + cmds.remove(sub_cmd) + cmds.extend(SUB_COMMAND_GROUP) + return cmds + + def get_command(self, ctx, cmd_name): + rv = Group.get_command(self, ctx, cmd_name) + if rv is not None: + return rv + if ALIAS_CMD.get(cmd_name): + rv = Group.get_command(self, ctx, ALIAS_CMD.get(cmd_name)) + if rv is not None: + return rv + matches = [x for x in self.list_commands(ctx) + if cmd_name in x] + if not matches: + ctx.fail(f"Not such command: {cmd_name}") + return None + hints = '\n'.join(sorted(matches)) + ctx.fail(f"Maybe you find:\n{hints}") + + def resolve_command(self, ctx, args): + # always return the full command name + _, cmd, args = super().resolve_command(ctx, args) + return cmd.name, cmd, args + + +@group(cls=MilvusGroup, + epilog='Check out our docs at https://milvus.io/docs for more milvus details', + ) +@version_option(version='0.0.1') +@option('-u', '--uri', + default=lambda: os.environ.get("MILVUS_URI", "localhost:19530"), + show_default="localhost:19530", + prompt='Milvus connection uri', + prompt_required=False, + help='Milvus connection uri') +@option('-t', '--token', + default=lambda: os.environ.get("MILVUS_TOKEN", "root:Milvus"), + show_default="root:Milvus", + prompt='Milvus connection token', + prompt_required=False, + help='Milvus connection token') +@option('-d', '--database', + default=lambda: os.environ.get("MILVUS_DATABASE", "default"), + show_default="default", + prompt='Milvus connection database', + prompt_required=False, + help='Milvus connection database') +@option('-e', '--env', + type=Path(), + show_default=".env", + prompt='Milvus connection database', + prompt_required=False, + help='Path to milvus .env file') +@pass_context +def milvus_cli(ctx, uri, token, database, env): + """This is a pure and easy python CLI tool to interact with Milvus.""" + if env: + if os.path.exists(env): + load_dotenv(env) + uri = os.getenv("MILVUS_URI", uri) + token = os.getenv("MILVUS_TOKEN", token) + database = os.getenv("MILVUS_DATABASE", database) + else: + ctx.fail(f"File not found: {env}") + ctx.obj = lambda: milvus_connector.Milvus(uri=uri, token=token, database=database) + + +@milvus_cli.command() +@pass_obj +def show_collections(cli): + client: milvus_connector.Milvus = cli() + with client: + echo(client.json().show_collections()) + + +@compose(milvus_cli.command(short_help='Create collection'), + collection_name(), + option('-sn', '--shard-num', type=IntParamType(), + default=1, show_default=True, + prompt='Shard num', prompt_required=False, help='Shard num'), + option('-cl', '--consistency-level', + default="bounded", show_default=True, + type=Choice(CONSISTENCY_LEVEL_ARRAY, case_sensitive=False), + prompt_required=False, + prompt='Consistency level', help='Consistency level'), + option('-cd', '--collection-description', + default="", show_default=True, + type=str, prompt_required=False, + prompt='Collection description', help='Collection description'), + option('-ai', '--auto-id', type=bool, + default=False, show_default=True, + prompt_required=False, prompt='Auto id', help='Auto id'), + option('-ed', '--enable-dynamic-field', type=bool, + default=False, show_default=True, + prompt_required=False, + prompt='Enable dynamic field', help='Enable dynamic field'), + option('-p', '--property', 'props', multiple=True, help='Collection properties, format: [key]:[value]'), + option('-pk', '--pk-field', prompt="Collection pk field", prompt_required=False, + help="Collection pk field, format: name:[field_name];dtype:[data_type];desc:[field_description];auto_id:false"), + option('-f', '--field', 'fields', multiple=True, + help='Collection field, format: name:[field_name];dtype:[data_type];desc:[field_description];dim:[vector_dim];is_partition_key:false'), + option('--auto-field', type=bool, help='quick fields, include: pk, random, embedding[vector:128]'), + option('--auto-partition', type=bool, help='quick fields should include partition key field or not'), + ) +@pass_obj +def create_collection(cli, name, + shard_num, consistency_level, + collection_description, + auto_id, + enable_dynamic_field, + props, + pk_field, fields, + auto_field, + auto_partition, + ): + """ create collection, param hints: + + the field format:\n + key1:value1;key2:value2... + + the field key options:\n + name,dtype,desc,auto_id,dim,max_length,is_partition_key + + dtype options:\n + \b + "bool", + "int8", "int16", "int32", "int64", + "float", "double", + "string", "varchar", + "array", "json", + "binary_vector", "float_vector", "float16_vector", "bfloat16_vector", "sparse_vector", + """ + client: milvus_connector.Milvus = cli() + with client: + fields_obj = [] + if auto_field: + fields_obj.extend(get_auto_field()) + if auto_partition: + fields_obj.append(get_partition_key_field()) + else: + pk_obj = CollectionField(**format_collection_field(pk_field)) + fields_obj.append(pk_obj) + for f in fields: + field_obj = CollectionField(**format_collection_field(f)) + fields_obj.append(field_obj) + echo(client.json().create_collection( + collection_name=name, + shard_num=shard_num, + consistency_level=consistency_level, + collection_description=collection_description, + auto_id=True if auto_id else False, + enable_dynamic_field=True if enable_dynamic_field else False, + properties=props if props else {}, + fields=fields_obj, + )) + + +@compose( + milvus_cli.command(), + collection_name(prompt_required=False), + collection_id(), + option('-p', '--property', 'props', multiple=True, help='Collection properties, format: [key]:[value]'), +) +@pass_obj +def alter_collection(cli, name, cid, props): + client: milvus_connector.Milvus = cli() + with client: + if name and cid: + echo('Please only provide either collection name or collection id') + return + if not name and not cid: + collection_name = prompt('Collection name') + if len(props) == 0: + echo('Please must provide one or more collection properties, like: -p key1:value1 -p key2:value2') + return + properties = [] + for p in props: + res = p.split(':') + if len(res) != 2: + echo(f'Invalid property format: {p}, should be [key]:[value]') + return + k, v = res + properties.append({k: v}) + if collection_name or cid: + echo(client.json().alter_collection(collection_name=name, collection_id=cid)) + + +@compose(milvus_cli.command(), + collection_name(prompt_required=False), + collection_id(), + ) +@pass_obj +def describe_collection(cli, + name, cid): + client: milvus_connector.Milvus = cli() + with client: + if name and cid: + echo('Please only provide either collection name or collection id') + return + if not name and not cid: + name = prompt('Collection name') + if name or cid: + echo(client.json().describe_collection(collection_name=name, collection_id=cid)) + else: + echo('Please provide valid collection name or collection id') + + +@compose( + milvus_cli.command(), + collection_name(), +) +@pass_obj +def collection_statistics(cli, name): + client: milvus_connector.Milvus = cli() + with client: + echo(client.json().get_collection_statistics(collection_name=name)) + + +@compose( + milvus_cli.command(), + collection_name(), + partition_name(), + option('-df', '--data-file', + type=Path(), + prompt_required=False, help='Vector data csv file'), + option('-rd', '--random-data', type=bool, default=False, help='Random vector search'), + option('-rn', '--random-num', type=int, default=2000, help='Random vector num'), +) +@pass_obj +def insert(cli, name, partition_name, data_file, random_data, random_num): + client: milvus_connector.Milvus = cli() + with client: + insert_data = [] + num_row = 0 + if random_data: + collection_info = client.describe_collection(collection_name=name) + if not ok(collection_info.status): + echo(f'fail to get collection info, status: {collection_info.status}') + return + for field in collection_info.schema.fields: + if field.autoID: + continue + dim = next((int(type_param.value) for type_param in field.type_params if type_param.key == 'dim'), 0) + insert_data.append(generate_random_data(random_num, field.name, field.data_type, dim=dim)) + num_row = random_num + else: + if data_file and not os.path.exists(data_file): + echo(f'File not found: {data_file}') + return + collection_info = client.describe_collection(collection_name=name) + if not ok(collection_info.status): + echo(f'fail to get collection info, status: {collection_info.status}') + return + with open(data_file, 'r', newline='') as file: + reader = csv.reader(file) + header = next(reader) + data = list(reader) + num_row = len(data) + file_data = {} + field_type_map = {} + for field in collection_info.schema.fields: + field_type_map[field.name] = field.data_type + for row in data: + row_data = row.split(',') + for index, column_data in enumerate(row_data): + file_field_name = header[index] + field_type = field_type_map.get(file_field_name, None) + if field_type is None: + echo(f'Field not found: {file_field_name}') + return + if file_field_name not in file_data: + file_data[file_field_name] = [] + file_data[file_field_name].append(convert_data(field_type, column_data)) + for field_name, field_data in file_data.items(): + insert_data.append(construct_data(field_name, field_type_map[field_name], field_data)) + echo( + client.json().insert( + collection_name=name, + partition_name=partition_name, + fields_data=insert_data, + num_rows=num_row, + ) + ) + + +@compose( + milvus_cli.command(), + collection_name(), + partition_name(), + option('-e', '--expr', prompt='Expr', help='Expr'), +) +@pass_obj +def delete(cli, name, partition_name, expr): + client: milvus_connector.Milvus = cli() + with client: + echo(client.json().delete( + collection_name=name, + partition_name=partition_name, + expr=expr, + ) + ) + + +@compose( + milvus_cli.command(), + collection_name(), + partition_names(), + option('-e', '--expr', prompt_required=False, prompt='Expr', help='Expr'), + option('-f', '--field', 'fields', multiple=True, help='Fields'), + option('-vf', '--vector-field-name', prompt='Vector field name', help='Vector field name'), + option('-tk', '--topk', type=int, help='Topk'), + option('-mt', '--metric-type', type=Choice(METRIC_TYPE_ARRAY, case_sensitive=False), default="L2", help='Metric type'), + option('-vd', '--vector-data-file', + type=Path(), + prompt_required=False, + prompt='Vector data file', help='Vector data file'), + option('-ri', '--random-vector', type=bool, default=False, help='Random vector search'), +) +@pass_obj +def search(cli, name, partition_names, + expr, fields, vector_field, + topk, metric_type, + vector_data_file, random_vector, + ): + client: milvus_connector.Milvus = cli() + with client: + if len(fields) == 0: + echo('Please provide one or more fields, like: -f field1 -f field2') + return + if vector_data_file and not os.path.exists(vector_data_file): + echo(f'File not found: {vector_data_file}') + return + if random_vector: + collection_info = client.describe_collection(collection_name=name) + if not ok(collection_info.status): + echo(f'fail to get collection info, status: {collection_info.status}') + return + vector_data = None + real_vector_field = None + for field in collection_info.schema.fields: + if field.name == vector_field: + for type_param in field.type_params: + if type_param.key == 'dim': + # TODO it need to be random diff type according to the data type + vector_data = [random.random() for _ in range(int(type_param.value))] + break + elif vector_data: + break + else: + if any([type_param.key == 'dim' for type_param in field.type_params]): + real_vector_field = field.name + if not vector_data: + echo(f'Vector field not found: {vector_field}, dected vector field: {real_vector_field}') + return + vector_data = [vector_data] + else: + if not vector_data_file: + echo('Please provide vector data file or use the --random-vector option') + return + with open(vector_data_file, 'r') as f: + file_content = f.readlines() + file_content = [line.strip() for line in file_content] + # TODO it need to use the diff convert func according to the data type + vector_data = [list(map(float, line.split(','))) for line in file_content] + echo(client.json().search( + client.construct_search_request( + collection_name=name, + partition_names=partition_names, + expr=expr, + output_fields=fields, + vector_field=vector_field, + topk=topk, + metric_type=metric_type, + search_data=vector_data, + ), + )) + + +@compose( + milvus_cli.command(), + collection_name(), + partition_names(), + option('-e', '--expr', prompt='Expr', help='Expr'), + option('-f', '--field', 'fields', multiple=True, help='Fields'), + option('-l', '--limit', default=-1, type=int, help='Limit'), + consistency_level(), + option('-qp', '--query-param', 'query_params', multiple=True, help='Query params, format: [key]:[value]'), +) +@pass_obj +def query(cli, name, partition_names, expr, fields, + limit, consistency_level, query_params): + client: milvus_connector.Milvus = cli() + with client: + if len(fields) == 0: + echo('Please provide one or more fields, like: -f field1 -f field2') + return + _query_params = {} + if len(query_params) > 0: + for qp in query_params: + res = qp.split(':') + if len(res) != 2: + echo(f'Invalid query param format: {qp}, should be [key]:[value]') + return + k, v = res + _query_params[k] = v + echo(client.json().query( + collection_name=name, + partition_names=partition_names, + expr=expr, + output_fields=fields, + limit=limit, + consistency_level=consistency_level, + query_params=_query_params, + )) + + +@compose( + milvus_cli.command(), + collection_name(), + partition_names(), +) +@pass_obj +def query_star(cli, name, partition_names): + client: milvus_connector.Milvus = cli() + with client: + echo(client.json().query( + collection_name=name, + partition_names=partition_names, + expr='', + output_fields=["count(*)"], + consistency_level='strong' + )) + + +@compose( + milvus_cli.command(), + collection_name(), + index_name(), + field_name(prompt_required=False), + option('-it', '--index-type', + type=Choice(INDEX_TYPE_ARRAY, case_sensitive=False), + default="IVF_FLAT", + prompt_required=False, + prompt='Index type', help='Index type'), + option('-mt', '--metric-type', + type=Choice(METRIC_TYPE_ARRAY, case_sensitive=False), + default="L2", + prompt_required=False, + prompt='Metric type', help='Metric type'), + option('-nl', '--nlist', type=int, + default=128, + prompt_required=False, + prompt='Nlist', help='Nlist'), +) +@pass_obj +def create_index(cli, name, index_name, field_name, + index_type, metric_type, nlist): + client: milvus_connector.Milvus = cli() + with client: + if field_name is None: + collection_info = client.describe_collection(collection_name=name) + if not ok(collection_info.status): + echo(f'fail to get collection info, status: {collection_info.status}') + return + for field in collection_info.schema.fields: + if any([type_param.key == 'dim' for type_param in field.type_params]): + field_name = field.name + echo(client.json().create_index(collection_name=name, + index_name=index_name, + field_name=field_name, + index_type=index_type, + metric_type=metric_type, + nlist=nlist, + )) + + +@compose( + milvus_cli.command(), + collection_name(), +) +@pass_obj +def drop_index(cli, name): + client: milvus_connector.Milvus = cli() + with client: + echo(client.json().drop_index(collection_name=name)) + + +@compose( + milvus_cli.command(), + collection_name(), +) +@pass_obj +def describe_index(cli, name): + client: milvus_connector.Milvus = cli() + with client: + echo(client.json().describe_index(collection_name=name)) + + +@compose( + milvus_cli.command(), + collection_name(), + replica_num(), +) +@pass_obj +def load_collection(cli, name, num): + client: milvus_connector.Milvus = cli() + with client: + echo(client.json().load_collection(collection_name=name, replica_number=num)) + + +@compose( + milvus_cli.command(), + collection_name(), + partition_names() +) +@pass_obj +def load_state(cli, name, partition_names): + client: milvus_connector.Milvus = cli() + with client: + echo(client.json().get_load_state(collection_name=name, partition_names=partition_names)) + + +@compose( + milvus_cli.command(), + collection_name(), + partition_names() +) +@pass_obj +def load_progress(cli, name, partition_names): + client: milvus_connector.Milvus = cli() + with client: + echo(client.json().get_loading_progress(collection_name=name, partition_names=partition_names)) + +@compose( + milvus_cli.command(), + collection_name(), +) +@pass_obj +def release_collection(cli, name): + client: milvus_connector.Milvus = cli() + with client: + echo(client.json().release_collection(collection_name=name)) + + +@compose( + milvus_cli.command(), + collection_name(multiple=True), +) +@pass_obj +def flush(cli, name): + client: milvus_connector.Milvus = cli() + with client: + echo(client.json().flush(collection_names=name)) + + +@compose( + milvus_cli.command(), + collection_name(), +) +@pass_obj +def flush_state(cli, name): + client: milvus_connector.Milvus = cli() + with client: + echo(client.json().get_flush_state(collection_name=name)) + + +@compose( + milvus_cli.command(), +) +@pass_obj +def flush_all(cli): + client: milvus_connector.Milvus = cli() + with client: + echo(client.json().flush_all()) + + +@compose( + milvus_cli.command(), +) +@pass_obj +def flush_all_state(cli): + client: milvus_connector.Milvus = cli() + with client: + echo(client.json().get_flush_all_state()) + + +@compose( + milvus_cli.command(), + collection_name(), + partition_name() +) +@pass_obj +def create_partition(cli, name, partition_name): + client: milvus_connector.Milvus = cli() + with client: + echo(client.json().create_partition(collection_name=name, partition_name=partition_name)) + + +@compose( + milvus_cli.command(), + collection_name(), + partition_name(), + confirmation_option('-f', '--force', prompt='Are you sure you want to drop the collection?'), +) +@pass_obj +def drop_partition(cli, name, partition_name, force): + client: milvus_connector.Milvus = cli() + with client: + drop = True + if not force: + drop = confirm(f'Drop partition <{partition_name}> ?') + if drop: + echo(client.json().drop_partition(collection_name=name, partition_name=partition_name)) + +@compose( + milvus_cli.command(), + collection_name(), + partition_names(), + replica_num(), +) +@pass_obj +def load_partitions(cli, name, partition_names, num): + client: milvus_connector.Milvus = cli() + with client: + echo(client.json().load_partitions(collection_name=name, + partition_names=partition_names, + replica_number=num, + )) + + +@compose( + milvus_cli.command(), + collection_name(), + partition_names(), +) +@pass_obj +def release_partitions(cli, name, partition_names): + client: milvus_connector.Milvus = cli() + with client: + echo(client.json().release_partitions(collection_name=name, + partition_names=partition_names, + )) + +@compose( + milvus_cli.command(), + collection_name(), + collection_id() +) +@pass_obj +def show_partitions(cli, name, cid): + client: milvus_connector.Milvus = cli() + with client: + echo(client.json().show_partitions(collection_name=name, + collection_id=cid, + )) + + +@compose( + milvus_cli.command(), + collection_name(), + partition_name() +) +@pass_obj +def partition_statistics(cli, name, partition_name): + client: milvus_connector.Milvus = cli() + with client: + echo(client.json().get_partition_statistics( + collection_name=name, + partition_name=partition_name, + )) + +@compose( + milvus_cli.command(), + collection_name(), + collection_id(), +) +@pass_obj +def compact(cli, name, cid): + client: milvus_connector.Milvus = cli() + with client: + if cid: + echo(client.json().compaction(collection_id=cid)) + else: + rsp = client.describe_collection(collection_name=name) + if ok(rsp.status): + echo(client.json().compaction(collection_id=rsp.collectionID)) + else: + echo(rsp) + + +@compose( + milvus_cli.command(), + option('-c', '--compaction-id', prompt='Compaction id', help='Compaction id'), +) +@pass_obj +def compact_state(cli, compaction_id): + client: milvus_connector.Milvus = cli() + with client: + echo(client.json().get_compaction_state(compaction_id=compaction_id)) + + +@compose( + milvus_cli.command(), + option('-c', '--compaction-id', prompt='Compaction id', help='Compaction id'), +) +@pass_obj +def compact_state_with_plans(cli, compaction_id): + client: milvus_connector.Milvus = cli() + with client: + echo(client.json().get_compaction_state_with_plans(compaction_id=compaction_id)) + +@compose( + milvus_cli.command(), + confirmation_option('-f', '--force', prompt='Are you sure you want to drop the collection?'), + collection_name(), +) +@pass_obj +def drop_collection(cli, name, force): + client: milvus_connector.Milvus = cli() + with client: + drop = True + if not force: + drop = confirm(f'Drop collections <{name}> ?') + if drop: + echo(client.json().drop_collection(collection_name=name)) + + +@compose( + milvus_cli.command(), + username(), + password_option(), +) +@pass_obj +def create_user(cli, username, password): + client: milvus_connector.Milvus = cli() + with client: + echo(client.json().create_user( + username=username, + password=password, + )) + + +@compose( + milvus_cli.command(), + username(), +) +@pass_obj +def drop_user(cli, username): + client: milvus_connector.Milvus = cli() + with client: + echo(client.json().delete_user(username=username)) + + +@compose( + milvus_cli.command(), + username(), + password_option('-op', '--old-password', prompt='Old password', help='Old password'), + password_option('-np', '--new-password', prompt='New password', help='New password'), +) +@pass_obj +def update_password(cli, username, old_password, new_password): + client: milvus_connector.Milvus = cli() + with client: + echo(client.json().update_user( + username=username, + old_password=old_password, + new_password=new_password, + )) + + +@compose( + milvus_cli.command(), +) +@pass_obj +def list_users(cli): + client: milvus_connector.Milvus = cli() + with client: + echo(client.json().list_users()) + + +@compose( + milvus_cli.command(), + rolename(), +) +@pass_obj +def create_role(cli, rolename): + client: milvus_connector.Milvus = cli() + with client: + echo(client.json().create_role( + role_name=rolename, + )) + + +@compose( + milvus_cli.command(), + rolename(), +) +@pass_obj +def drop_role(cli, rolename): + client: milvus_connector.Milvus = cli() + with client: + echo(client.json().delete_role( + role_name=rolename, + )) + + +@compose( + milvus_cli.command(), + username(), + rolename(), + option('--add/--no-add', ' /--remove', default=True, help='Add or remove user to role'), +) +@pass_obj +def operate_user_role(cli, username, rolename, add): + client: milvus_connector.Milvus = cli() + with client: + echo(client.json().operate_user_role( + username=username, + role_name=rolename, + action='add_user_to_role' if add else 'remove_user_from_role', + )) + + +@compose( + milvus_cli.command(), + username(prompt_required=False), + option('--include/--no-include', default=False, help='Include the role information or not'), +) +@pass_obj +def select_user(cli, username, include): + client: milvus_connector.Milvus = cli() + with client: + echo(client.json().select_user( + username=username, + include_role_info=include, + )) + + +@compose( + milvus_cli.command(), + rolename(prompt_required=False), + option('--include/--no-include', default=False, help='Include the user information or not'), +) +@pass_obj +def select_role(cli, rolename, include): + client: milvus_connector.Milvus = cli() + with client: + echo(client.json().select_role( + role_name=rolename, + include_user_info=include, + )) + + +@compose( + milvus_cli.command(), + database_name(), + rolename(), + option('-on', '--object-name', prompt='Object name', help='Object name'), + option('-ot', '--object-type', + type=Choice([ + "collection", + "global", + "user", + ], case_sensitive=False), + prompt='Object type', help='Object type'), + option('--grant/--no-grant', ' /--revoke', default=True, help='Grant or revoke the privilege'), + option('-p', '--privilege', prompt='Privilege', help='Privilege'), +) +@pass_obj +def operate_privilege(cli, database, rolename, object_name, object_type, grant, privilege): + client: milvus_connector.Milvus = cli() + with client: + echo(client.json().operate_privilege( + db_name=database, + role_name=rolename, + object_name=object_name, + object_type=object_type, + action='grant' if grant else 'revoke', + privilege=privilege, + )) + + +@compose( + milvus_cli.command(), + database_name(), + rolename(), + option('-on', '--object-name', + prompt_required=False, + prompt='Object name', help='Object name'), + option('-ot', '--object-type', + prompt_required=False, + type=Choice([ + "collection", + "global", + "user", + ], case_sensitive=False), + prompt='Object type', help='Object type'), + option('-p', '--privilege', + prompt_required=False, + prompt='Privilege', help='Privilege'), +) +@pass_obj +def select_grant(cli, database, rolename, object_name, object_type, privilege): + client: milvus_connector.Milvus = cli() + with client: + echo(client.json().select_grant( + db_name=database, + role_name=rolename, + object_name=object_name, + object_type=object_type, + privilege=privilege, + )) + + +@compose( + milvus_cli.command(), + database_name(), +) +@pass_obj +def create_database(cli, database): + client: milvus_connector.Milvus = cli() + with client: + echo(client.json().create_database(db_name=database)) + + +@compose( + milvus_cli.command(), + database_name(), +) +@pass_obj +def drop_database(cli, database): + client: milvus_connector.Milvus = cli() + with client: + echo(client.json().drop_database(db_name=database)) + + +@compose( + milvus_cli.command(), +) +@pass_obj +def list_databases(cli): + client: milvus_connector.Milvus = cli() + with client: + echo(client.json().list_databases()) + + +@compose( + milvus_cli.command(), + option('-c', '--channel-name', prompt='Channel name', help='Channel name'), +) +@pass_obj +def replicate_message(cli, channel_name): + client: milvus_connector.Milvus = cli() + with client: + echo(client.json().replicate_message(channel_name=channel_name)) + + +@compose( + milvus_cli.command(), +) +@pass_obj +def get_version(cli): + client: milvus_connector.Milvus = cli() + with client: + echo(client.json().get_version()) + + +@compose( + milvus_cli.command(), +) +@pass_obj +def check_health(cli): + client: milvus_connector.Milvus = cli() + with client: + echo(client.json().check_health()) + + +@compose( + milvus_cli.command(), +) +@pass_obj +def connect(cli): + client: milvus_connector.Milvus = cli() + with client: + echo(client.json().connect()) + +@milvus_cli.group() +def proxy(): + """[inner] proxy command""" + pass + + +# @proxy.command() +# def get_metric(): +# echo('Metric') \ No newline at end of file diff --git a/app/milvus-cli/mucli/_option.py b/app/milvus-cli/mucli/_option.py new file mode 100644 index 0000000..eb5224c --- /dev/null +++ b/app/milvus-cli/mucli/_option.py @@ -0,0 +1,175 @@ +import json +from typing import Any, Dict, List +from click import Choice, option +from click.types import IntParamType + +from milvus_connector.core.util import CollectionField +from milvus_connector.core._types import * + + +def database_name(*args, **kwargs): + if not args: + args = ('-d', '--database') + kwargs.setdefault('prompt_required', False) + kwargs.setdefault('prompt', 'Database name') + kwargs.setdefault('help', 'Database name') + return option(*args, **kwargs) + + +def collection_name(*args, **kwargs): + if not args: + args = ('-n', '--name') + kwargs.setdefault('prompt', 'Collection name') + kwargs.setdefault('help', 'Collection name') + return option(*args, **kwargs) + + +def collection_id(*args, **kwargs): + if not args: + args = ('-i', '--cid') + kwargs.setdefault('prompt_required', False) + kwargs.setdefault('prompt', 'Collection id') + kwargs.setdefault('help', 'Collection id') + return option(*args, **kwargs) + + +def partition_name(*args, **kwargs): + if not args: + args = ('-p', '--partition-name') + kwargs.setdefault('default', '') + kwargs.setdefault('prompt_required', False) + kwargs.setdefault('prompt', 'Partition name') + kwargs.setdefault('help', 'Partition name') + return option(*args, **kwargs) + + +def partition_names(*args, **kwargs): + if not args: + args = ('-p', '--partition-names') + kwargs.setdefault('prompt_required', False) + kwargs.setdefault('multiple', True) + kwargs.setdefault('help', 'Partition names') + return option(*args, **kwargs) + + +def index_name(*args, **kwargs): + if not args: + args = ('-in', '--index-name') + kwargs.setdefault('prompt_required', False) + kwargs.setdefault('prompt', 'Index name') + kwargs.setdefault('help', 'Index name') + return option(*args, **kwargs) + + +def field_name(*args, **kwargs): + if not args: + args = ('-fn', '--field-name') + kwargs.setdefault('prompt', 'Field name') + kwargs.setdefault('help', 'Field name') + return option(*args, **kwargs) + + +def consistency_level(*args, **kwargs): + if not args: + args = ('-cl', '--consistency-level') + kwargs.setdefault('type', Choice(CONSISTENCY_LEVEL_ARRAY, case_sensitive=False)) + kwargs.setdefault('default', 'bounded') + kwargs.setdefault('show_default', True) + kwargs.setdefault('prompt_required', False) + kwargs.setdefault('prompt', 'Consistency level') + kwargs.setdefault('help', 'Consistency level') + return option(*args, **kwargs) + + +def replica_num(*args, **kwargs): + if not args: + args = ('-r', '--replica-num', 'num') + kwargs.setdefault('prompt_required', False) + kwargs.setdefault('prompt', 'Replica num') + kwargs.setdefault('type', IntParamType()) + kwargs.setdefault('default', 1) + kwargs.setdefault('help', 'Replica num') + return option(*args, **kwargs) + + +def username(*args, **kwargs): + if not args: + args = ('-u', '--username') + kwargs.setdefault('prompt', 'Username') + kwargs.setdefault('help', 'Username') + return option(*args, **kwargs) + + +def rolename(*args, **kwargs): + if not args: + args = ('-r', '--rolename') + kwargs.setdefault('prompt', 'Role name') + kwargs.setdefault('help', 'Role name') + return option(*args, **kwargs) + + +# format_collection_field, v format: +# name:pk; +# is_primary_key:true; +# auto_id:true; +# is_dynamic:false; +# is_partition_key:false; +# dtype:int32; +# dim:16; +# params:{"nbits": 32} +def format_collection_field(v: str) -> Dict[str, Any]: + atts = v.split(';') + field_att = {} + for att in atts: + if len(att.split(':')) != 2: + raise ValueError(f"Invalid field format: {v}") + k, v = att.split(':') + if k in ('is_primary_key', 'auto_id', 'is_dynamic', + 'is_partition_key', 'is_cluster_key'): + v = True if v else False + elif k == 'params': + v = json.loads(v) + elif k in ('dim', 'max_length'): + v = int(v) + elif k == 'desc': + v = v.strip('"').strip('\'') + field_att[k] = v + return field_att + +def get_auto_field() -> List[CollectionField]: + return [ + CollectionField( + name="pk", + is_primary_key=True, + dtype="int64", + desc="it's the pk field", + ), + CollectionField( + name="random", + dtype="varchar", + desc="it's random string field", + max_length=32, + ), + CollectionField( + name="embedding", + dtype="float_vector", + desc="it's vector float field", + dim=32, + ), + ] + +def get_partition_key_field() -> CollectionField: + return CollectionField( + name="partition_key", + dtype="int64", + desc="it's partition key int64 field", + is_partition_key=True, + ) + + +def compose(*decorators): + def wrapper(func, *args, **kwargs): + for decorator in decorators: + func = decorator(func, *args, **kwargs) + return func + return wrapper \ No newline at end of file diff --git a/app/milvus-cli/mucli/main.py b/app/milvus-cli/mucli/main.py new file mode 100644 index 0000000..fd817f1 --- /dev/null +++ b/app/milvus-cli/mucli/main.py @@ -0,0 +1,11 @@ +from click import * +from dotenv import load_dotenv + +from mucli._milvus import milvus_cli + +def main(): + load_dotenv() + milvus_cli() + +if __name__ == '__main__': + main() \ No newline at end of file diff --git a/app/milvus-cli/mucli/pyinstaller.py b/app/milvus-cli/mucli/pyinstaller.py new file mode 100644 index 0000000..bf09596 --- /dev/null +++ b/app/milvus-cli/mucli/pyinstaller.py @@ -0,0 +1,16 @@ +import PyInstaller.__main__ +from pathlib import Path + +HERE = Path(__file__).parent.absolute() +path_to_main = str(HERE / "main.py") + +def install(): + PyInstaller.__main__.run([ + path_to_main, + # '--onefile', + '-D', + '--windowed', + '--noupx', + '-nmucli', # output name + # other pyinstaller options... + ]) \ No newline at end of file diff --git a/app/milvus-cli/poetry.lock b/app/milvus-cli/poetry.lock new file mode 100644 index 0000000..bb35822 --- /dev/null +++ b/app/milvus-cli/poetry.lock @@ -0,0 +1,518 @@ +# This file is automatically @generated by Poetry 1.7.1 and should not be changed by hand. + +[[package]] +name = "altgraph" +version = "0.17.4" +description = "Python graph (network) package" +optional = false +python-versions = "*" +files = [ + {file = "altgraph-0.17.4-py2.py3-none-any.whl", hash = "sha256:642743b4750de17e655e6711601b077bc6598dbfa3ba5fa2b2a35ce12b508dff"}, + {file = "altgraph-0.17.4.tar.gz", hash = "sha256:1b5afbb98f6c4dcadb2e2ae6ab9fa994bbb8c1d75f4fa96d340f9437ae454406"}, +] + +[[package]] +name = "annotated-types" +version = "0.6.0" +description = "Reusable constraint types to use with typing.Annotated" +optional = false +python-versions = ">=3.8" +files = [ + {file = "annotated_types-0.6.0-py3-none-any.whl", hash = "sha256:0641064de18ba7a25dee8f96403ebc39113d0cb953a01429249d5c7564666a43"}, + {file = "annotated_types-0.6.0.tar.gz", hash = "sha256:563339e807e53ffd9c267e99fc6d9ea23eb8443c08f112651963e24e22f84a5d"}, +] + +[[package]] +name = "click" +version = "8.1.7" +description = "Composable command line interface toolkit" +optional = false +python-versions = ">=3.7" +files = [ + {file = "click-8.1.7-py3-none-any.whl", hash = "sha256:ae74fb96c20a0277a1d615f1e4d73c8414f5a98db8b799a7931d1582f3390c28"}, + {file = "click-8.1.7.tar.gz", hash = "sha256:ca9853ad459e787e2192211578cc907e7594e294c7ccc834310722b41b9ca6de"}, +] + +[package.dependencies] +colorama = {version = "*", markers = "platform_system == \"Windows\""} + +[[package]] +name = "colorama" +version = "0.4.6" +description = "Cross-platform colored terminal text." +optional = false +python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,!=3.6.*,>=2.7" +files = [ + {file = "colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6"}, + {file = "colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44"}, +] + +[[package]] +name = "furl" +version = "2.1.3" +description = "URL manipulation made simple." +optional = false +python-versions = "*" +files = [ + {file = "furl-2.1.3-py2.py3-none-any.whl", hash = "sha256:9ab425062c4217f9802508e45feb4a83e54324273ac4b202f1850363309666c0"}, + {file = "furl-2.1.3.tar.gz", hash = "sha256:5a6188fe2666c484a12159c18be97a1977a71d632ef5bb867ef15f54af39cc4e"}, +] + +[package.dependencies] +orderedmultidict = ">=1.0.1" +six = ">=1.8.0" + +[[package]] +name = "grpcio" +version = "1.62.1" +description = "HTTP/2-based RPC framework" +optional = false +python-versions = ">=3.7" +files = [ + {file = "grpcio-1.62.1-cp310-cp310-linux_armv7l.whl", hash = "sha256:179bee6f5ed7b5f618844f760b6acf7e910988de77a4f75b95bbfaa8106f3c1e"}, + {file = "grpcio-1.62.1-cp310-cp310-macosx_12_0_universal2.whl", hash = "sha256:48611e4fa010e823ba2de8fd3f77c1322dd60cb0d180dc6630a7e157b205f7ea"}, + {file = "grpcio-1.62.1-cp310-cp310-manylinux_2_17_aarch64.whl", hash = "sha256:b2a0e71b0a2158aa4bce48be9f8f9eb45cbd17c78c7443616d00abbe2a509f6d"}, + {file = "grpcio-1.62.1-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:fbe80577c7880911d3ad65e5ecc997416c98f354efeba2f8d0f9112a67ed65a5"}, + {file = "grpcio-1.62.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:58f6c693d446964e3292425e1d16e21a97a48ba9172f2d0df9d7b640acb99243"}, + {file = "grpcio-1.62.1-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:77c339403db5a20ef4fed02e4d1a9a3d9866bf9c0afc77a42234677313ea22f3"}, + {file = "grpcio-1.62.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:b5a4ea906db7dec694098435d84bf2854fe158eb3cd51e1107e571246d4d1d70"}, + {file = "grpcio-1.62.1-cp310-cp310-win32.whl", hash = "sha256:4187201a53f8561c015bc745b81a1b2d278967b8de35f3399b84b0695e281d5f"}, + {file = "grpcio-1.62.1-cp310-cp310-win_amd64.whl", hash = "sha256:844d1f3fb11bd1ed362d3fdc495d0770cfab75761836193af166fee113421d66"}, + {file = "grpcio-1.62.1-cp311-cp311-linux_armv7l.whl", hash = "sha256:833379943d1728a005e44103f17ecd73d058d37d95783eb8f0b28ddc1f54d7b2"}, + {file = "grpcio-1.62.1-cp311-cp311-macosx_10_10_universal2.whl", hash = "sha256:c7fcc6a32e7b7b58f5a7d27530669337a5d587d4066060bcb9dee7a8c833dfb7"}, + {file = "grpcio-1.62.1-cp311-cp311-manylinux_2_17_aarch64.whl", hash = "sha256:fa7d28eb4d50b7cbe75bb8b45ed0da9a1dc5b219a0af59449676a29c2eed9698"}, + {file = "grpcio-1.62.1-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:48f7135c3de2f298b833be8b4ae20cafe37091634e91f61f5a7eb3d61ec6f660"}, + {file = "grpcio-1.62.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:71f11fd63365ade276c9d4a7b7df5c136f9030e3457107e1791b3737a9b9ed6a"}, + {file = "grpcio-1.62.1-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:4b49fd8fe9f9ac23b78437da94c54aa7e9996fbb220bac024a67469ce5d0825f"}, + {file = "grpcio-1.62.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:482ae2ae78679ba9ed5752099b32e5fe580443b4f798e1b71df412abf43375db"}, + {file = "grpcio-1.62.1-cp311-cp311-win32.whl", hash = "sha256:1faa02530b6c7426404372515fe5ddf66e199c2ee613f88f025c6f3bd816450c"}, + {file = "grpcio-1.62.1-cp311-cp311-win_amd64.whl", hash = "sha256:5bd90b8c395f39bc82a5fb32a0173e220e3f401ff697840f4003e15b96d1befc"}, + {file = "grpcio-1.62.1-cp312-cp312-linux_armv7l.whl", hash = "sha256:b134d5d71b4e0837fff574c00e49176051a1c532d26c052a1e43231f252d813b"}, + {file = "grpcio-1.62.1-cp312-cp312-macosx_10_10_universal2.whl", hash = "sha256:d1f6c96573dc09d50dbcbd91dbf71d5cf97640c9427c32584010fbbd4c0e0037"}, + {file = "grpcio-1.62.1-cp312-cp312-manylinux_2_17_aarch64.whl", hash = "sha256:359f821d4578f80f41909b9ee9b76fb249a21035a061a327f91c953493782c31"}, + {file = "grpcio-1.62.1-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a485f0c2010c696be269184bdb5ae72781344cb4e60db976c59d84dd6354fac9"}, + {file = "grpcio-1.62.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b50b09b4dc01767163d67e1532f948264167cd27f49e9377e3556c3cba1268e1"}, + {file = "grpcio-1.62.1-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:3227c667dccbe38f2c4d943238b887bac588d97c104815aecc62d2fd976e014b"}, + {file = "grpcio-1.62.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:3952b581eb121324853ce2b191dae08badb75cd493cb4e0243368aa9e61cfd41"}, + {file = "grpcio-1.62.1-cp312-cp312-win32.whl", hash = "sha256:83a17b303425104d6329c10eb34bba186ffa67161e63fa6cdae7776ff76df73f"}, + {file = "grpcio-1.62.1-cp312-cp312-win_amd64.whl", hash = "sha256:6696ffe440333a19d8d128e88d440f91fb92c75a80ce4b44d55800e656a3ef1d"}, + {file = "grpcio-1.62.1-cp37-cp37m-linux_armv7l.whl", hash = "sha256:e3393b0823f938253370ebef033c9fd23d27f3eae8eb9a8f6264900c7ea3fb5a"}, + {file = "grpcio-1.62.1-cp37-cp37m-macosx_10_10_universal2.whl", hash = "sha256:83e7ccb85a74beaeae2634f10eb858a0ed1a63081172649ff4261f929bacfd22"}, + {file = "grpcio-1.62.1-cp37-cp37m-manylinux_2_17_aarch64.whl", hash = "sha256:882020c87999d54667a284c7ddf065b359bd00251fcd70279ac486776dbf84ec"}, + {file = "grpcio-1.62.1-cp37-cp37m-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a10383035e864f386fe096fed5c47d27a2bf7173c56a6e26cffaaa5a361addb1"}, + {file = "grpcio-1.62.1-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:960edebedc6b9ada1ef58e1c71156f28689978188cd8cff3b646b57288a927d9"}, + {file = "grpcio-1.62.1-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:23e2e04b83f347d0aadde0c9b616f4726c3d76db04b438fd3904b289a725267f"}, + {file = "grpcio-1.62.1-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:978121758711916d34fe57c1f75b79cdfc73952f1481bb9583399331682d36f7"}, + {file = "grpcio-1.62.1-cp37-cp37m-win_amd64.whl", hash = "sha256:9084086190cc6d628f282e5615f987288b95457292e969b9205e45b442276407"}, + {file = "grpcio-1.62.1-cp38-cp38-linux_armv7l.whl", hash = "sha256:22bccdd7b23c420a27fd28540fb5dcbc97dc6be105f7698cb0e7d7a420d0e362"}, + {file = "grpcio-1.62.1-cp38-cp38-macosx_10_10_universal2.whl", hash = "sha256:8999bf1b57172dbc7c3e4bb3c732658e918f5c333b2942243f10d0d653953ba9"}, + {file = "grpcio-1.62.1-cp38-cp38-manylinux_2_17_aarch64.whl", hash = "sha256:d9e52558b8b8c2f4ac05ac86344a7417ccdd2b460a59616de49eb6933b07a0bd"}, + {file = "grpcio-1.62.1-cp38-cp38-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1714e7bc935780bc3de1b3fcbc7674209adf5208ff825799d579ffd6cd0bd505"}, + {file = "grpcio-1.62.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c8842ccbd8c0e253c1f189088228f9b433f7a93b7196b9e5b6f87dba393f5d5d"}, + {file = "grpcio-1.62.1-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:1f1e7b36bdff50103af95a80923bf1853f6823dd62f2d2a2524b66ed74103e49"}, + {file = "grpcio-1.62.1-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:bba97b8e8883a8038606480d6b6772289f4c907f6ba780fa1f7b7da7dfd76f06"}, + {file = "grpcio-1.62.1-cp38-cp38-win32.whl", hash = "sha256:a7f615270fe534548112a74e790cd9d4f5509d744dd718cd442bf016626c22e4"}, + {file = "grpcio-1.62.1-cp38-cp38-win_amd64.whl", hash = "sha256:e6c8c8693df718c5ecbc7babb12c69a4e3677fd11de8886f05ab22d4e6b1c43b"}, + {file = "grpcio-1.62.1-cp39-cp39-linux_armv7l.whl", hash = "sha256:73db2dc1b201d20ab7083e7041946910bb991e7e9761a0394bbc3c2632326483"}, + {file = "grpcio-1.62.1-cp39-cp39-macosx_10_10_universal2.whl", hash = "sha256:407b26b7f7bbd4f4751dbc9767a1f0716f9fe72d3d7e96bb3ccfc4aace07c8de"}, + {file = "grpcio-1.62.1-cp39-cp39-manylinux_2_17_aarch64.whl", hash = "sha256:f8de7c8cef9261a2d0a62edf2ccea3d741a523c6b8a6477a340a1f2e417658de"}, + {file = "grpcio-1.62.1-cp39-cp39-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:9bd5c8a1af40ec305d001c60236308a67e25419003e9bb3ebfab5695a8d0b369"}, + {file = "grpcio-1.62.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:be0477cb31da67846a33b1a75c611f88bfbcd427fe17701b6317aefceee1b96f"}, + {file = "grpcio-1.62.1-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:60dcd824df166ba266ee0cfaf35a31406cd16ef602b49f5d4dfb21f014b0dedd"}, + {file = "grpcio-1.62.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:973c49086cabab773525f6077f95e5a993bfc03ba8fc32e32f2c279497780585"}, + {file = "grpcio-1.62.1-cp39-cp39-win32.whl", hash = "sha256:12859468e8918d3bd243d213cd6fd6ab07208195dc140763c00dfe901ce1e1b4"}, + {file = "grpcio-1.62.1-cp39-cp39-win_amd64.whl", hash = "sha256:b7209117bbeebdfa5d898205cc55153a51285757902dd73c47de498ad4d11332"}, + {file = "grpcio-1.62.1.tar.gz", hash = "sha256:6c455e008fa86d9e9a9d85bb76da4277c0d7d9668a3bfa70dbe86e9f3c759947"}, +] + +[package.extras] +protobuf = ["grpcio-tools (>=1.62.1)"] + +[[package]] +name = "grpcio-tools" +version = "1.62.1" +description = "Protobuf code generator for gRPC" +optional = false +python-versions = ">=3.7" +files = [ + {file = "grpcio-tools-1.62.1.tar.gz", hash = "sha256:a4991e5ee8a97ab791296d3bf7e8700b1445635cc1828cc98df945ca1802d7f2"}, + {file = "grpcio_tools-1.62.1-cp310-cp310-linux_armv7l.whl", hash = "sha256:f2b404bcae7e2ef9b0b9803b2a95119eb7507e6dc80ea4a64a78be052c30cebc"}, + {file = "grpcio_tools-1.62.1-cp310-cp310-macosx_12_0_universal2.whl", hash = "sha256:fdd987a580b4474769adfd40144486f54bcc73838d5ec5d3647a17883ea78e76"}, + {file = "grpcio_tools-1.62.1-cp310-cp310-manylinux_2_17_aarch64.whl", hash = "sha256:07af1a6442e2313cff22af93c2c4dd37ae32b5239b38e0d99e2cbf93de65429f"}, + {file = "grpcio_tools-1.62.1-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:41384c9ee18e61ef20cad2774ef71bd8854b63efce263b5177aa06fccb84df1f"}, + {file = "grpcio_tools-1.62.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5c38006f7702d2ff52122e4c77a47348709374050c76216e84b30a9f06e45afa"}, + {file = "grpcio_tools-1.62.1-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:08fecc3c5b4e6dd3278f2b9d12837e423c7dcff551ca1e587018b4a0fc5f8019"}, + {file = "grpcio_tools-1.62.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:a01e8dcd0f041f6fa6d815c54a2017d032950e310c41d514a8bc041e872c4d12"}, + {file = "grpcio_tools-1.62.1-cp310-cp310-win32.whl", hash = "sha256:dd933b8e0b3c13fe3543d58f849a6a5e0d7987688cb6801834278378c724f695"}, + {file = "grpcio_tools-1.62.1-cp310-cp310-win_amd64.whl", hash = "sha256:2b04844a9382f1bde4b4174e476e654ab3976168d2469cb4b29e352f4f35a5aa"}, + {file = "grpcio_tools-1.62.1-cp311-cp311-linux_armv7l.whl", hash = "sha256:024380536ba71a96cdf736f0954f6ad03f5da609c09edbcc2ca02fdd639e0eed"}, + {file = "grpcio_tools-1.62.1-cp311-cp311-macosx_10_10_universal2.whl", hash = "sha256:21f14b99e0cd38ad56754cc0b62b2bf3cf75f9f7fc40647da54669e0da0726fe"}, + {file = "grpcio_tools-1.62.1-cp311-cp311-manylinux_2_17_aarch64.whl", hash = "sha256:975ac5fb482c23f3608c16e06a43c8bab4d79c2e2564cdbc25cf753c6e998775"}, + {file = "grpcio_tools-1.62.1-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:50739aaab0c8076ad5957204e71f2e0c9876e11fd8338f7f09de12c2d75163c5"}, + {file = "grpcio_tools-1.62.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:598c54318f0326cf5020aa43fc95a15e933aba4a71943d3bff2677d2d21ddfa1"}, + {file = "grpcio_tools-1.62.1-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:f309bdb33a61f8e049480d41498ee2e525cfb5e959958b326abfdf552bf9b9cb"}, + {file = "grpcio_tools-1.62.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:f358effd3c11d66c150e0227f983d54a5cd30e14038566dadcf25f9f6844e6e8"}, + {file = "grpcio_tools-1.62.1-cp311-cp311-win32.whl", hash = "sha256:b76aead9b73f1650a091870fe4e9ed15ac4d8ed136f962042367255199c23594"}, + {file = "grpcio_tools-1.62.1-cp311-cp311-win_amd64.whl", hash = "sha256:d66a5d47eaa427039752fa0a83a425ff2a487b6a0ac30556fd3be2f3a27a0130"}, + {file = "grpcio_tools-1.62.1-cp312-cp312-linux_armv7l.whl", hash = "sha256:575535d039b97d63e6a9abee626d6c7cd47bd8cb73dd00a5c84a98254a2164a4"}, + {file = "grpcio_tools-1.62.1-cp312-cp312-macosx_10_10_universal2.whl", hash = "sha256:22644c90e43d1a888477899af917979e17364fdd6e9bbb92679cd6a54c4d36c3"}, + {file = "grpcio_tools-1.62.1-cp312-cp312-manylinux_2_17_aarch64.whl", hash = "sha256:156d3e1b227c16e903003a56881dbe60e40f2b4bd66f0bc3b27c53e466e6384d"}, + {file = "grpcio_tools-1.62.1-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:5ad7c5691625a85327e5b683443baf73ae790fd5afc938252041ed5cd665e377"}, + {file = "grpcio_tools-1.62.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0e140bbc08eea8abf51c0274f45fb1e8350220e64758998d7f3c7f985a0b2496"}, + {file = "grpcio_tools-1.62.1-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:7444fcab861911525470d398e5638b70d5cbea3b4674a3de92b5c58c5c515d4d"}, + {file = "grpcio_tools-1.62.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:e643cd14a5d1e59865cba68a5a6f0175d987f36c5f4cb0db80dee9ed60b4c174"}, + {file = "grpcio_tools-1.62.1-cp312-cp312-win32.whl", hash = "sha256:1344a773d2caa9bb7fbea7e879b84f33740c808c34a5bd2a2768e526117a6b44"}, + {file = "grpcio_tools-1.62.1-cp312-cp312-win_amd64.whl", hash = "sha256:2eea1db3748b2f37b4dce84d8e0c15d9bc811094807cabafe7b0ea47f424dfd5"}, + {file = "grpcio_tools-1.62.1-cp37-cp37m-linux_armv7l.whl", hash = "sha256:45d2e6cf04d27286b6f73e6e20ba3f0a1f6d8f5535e5dcb1356200419bb457f4"}, + {file = "grpcio_tools-1.62.1-cp37-cp37m-macosx_10_10_universal2.whl", hash = "sha256:46ae58e6926773e7315e9005f0f17aacedbc0895a8752bec087d24efa2f1fb21"}, + {file = "grpcio_tools-1.62.1-cp37-cp37m-manylinux_2_17_aarch64.whl", hash = "sha256:4c28086df31478023a36f45e50767872ab3aed2419afff09814cb61c88b77db4"}, + {file = "grpcio_tools-1.62.1-cp37-cp37m-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a4fba5b339f4797548591036c9481e6895bf920fab7d3dc664d2697f8fb7c0bf"}, + {file = "grpcio_tools-1.62.1-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:23eb3d47f78f509fcd201749b1f1e44b76f447913f7fbb3b8bae20f109086295"}, + {file = "grpcio_tools-1.62.1-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:fd5d47707bd6bc2b707ece765c362d2a1d2e8f6cd92b04c99fab49a929f3610c"}, + {file = "grpcio_tools-1.62.1-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:d1924a6a943df7c73b9ef0048302327c75962b567451479710da729ead241228"}, + {file = "grpcio_tools-1.62.1-cp37-cp37m-win_amd64.whl", hash = "sha256:fe71ca30aabe42591e84ecb9694c0297dc699cc20c5b24d2cb267fb0fc01f947"}, + {file = "grpcio_tools-1.62.1-cp38-cp38-linux_armv7l.whl", hash = "sha256:1819fd055c1ae672d1d725ec75eefd1f700c18acba0ed9332202be31d69c401d"}, + {file = "grpcio_tools-1.62.1-cp38-cp38-macosx_10_10_universal2.whl", hash = "sha256:5dbe1f7481dd14b6d477b4bace96d275090bc7636b9883975a08b802c94e7b78"}, + {file = "grpcio_tools-1.62.1-cp38-cp38-manylinux_2_17_aarch64.whl", hash = "sha256:771c051c5ece27ad03e4f2e33624a925f0ad636c01757ab7dbb04a37964af4ba"}, + {file = "grpcio_tools-1.62.1-cp38-cp38-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:98209c438b38b6f1276dbc27b1c04e346a75bfaafe72a25a548f2dc5ce71d226"}, + {file = "grpcio_tools-1.62.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2152308e5321cb90fb45aaa84d03d6dedb19735a8779aaf36c624f97b831842d"}, + {file = "grpcio_tools-1.62.1-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:ed1f27dc2b2262c8b8d9036276619c1bb18791311c16ccbf1f31b660f2aad7cf"}, + {file = "grpcio_tools-1.62.1-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:2744947b6c5e907af21133431809ccca535a037356864e32c122efed8cb9de1f"}, + {file = "grpcio_tools-1.62.1-cp38-cp38-win32.whl", hash = "sha256:13b20e269d14ad629ff9a2c9a2450f3dbb119d5948de63b27ffe624fa7aea85a"}, + {file = "grpcio_tools-1.62.1-cp38-cp38-win_amd64.whl", hash = "sha256:999823758e9eacd0095863d06cd6d388be769f80c9abb65cdb11c4f2cfce3fea"}, + {file = "grpcio_tools-1.62.1-cp39-cp39-linux_armv7l.whl", hash = "sha256:941f8a5c31986053e75fa466bcfa743c2bf1b513b7978cf1f4ab4e96a8219d27"}, + {file = "grpcio_tools-1.62.1-cp39-cp39-macosx_10_10_universal2.whl", hash = "sha256:b9c02c88c77ef6057c6cbeea8922d7c2424aabf46bfc40ddf42a32765ba91061"}, + {file = "grpcio_tools-1.62.1-cp39-cp39-manylinux_2_17_aarch64.whl", hash = "sha256:6abd4eb3ccb444383a40156139acc3aaa73745d395139cb6bc8e2a3429e1e627"}, + {file = "grpcio_tools-1.62.1-cp39-cp39-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:449503213d142f8470b331a1c2f346f8457f16c7fe20f531bc2500e271f7c14c"}, + {file = "grpcio_tools-1.62.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9a11bcf609d00cfc9baed77ab308223cabc1f0b22a05774a26dd4c94c0c80f1f"}, + {file = "grpcio_tools-1.62.1-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:5d7bdea33354b55acf40bb4dd3ba7324d6f1ef6b4a1a4da0807591f8c7e87b9a"}, + {file = "grpcio_tools-1.62.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:d03b645852d605f43003020e78fe6d573cae6ee6b944193e36b8b317e7549a20"}, + {file = "grpcio_tools-1.62.1-cp39-cp39-win32.whl", hash = "sha256:52b185dfc3bf32e70929310367dbc66185afba60492a6a75a9b1141d407e160c"}, + {file = "grpcio_tools-1.62.1-cp39-cp39-win_amd64.whl", hash = "sha256:63a273b70896d3640b7a883eb4a080c3c263d91662d870a2e9c84b7bbd978e7b"}, +] + +[package.dependencies] +grpcio = ">=1.62.1" +protobuf = ">=4.21.6,<5.0dev" +setuptools = "*" + +[[package]] +name = "macholib" +version = "1.16.3" +description = "Mach-O header analysis and editing" +optional = false +python-versions = "*" +files = [ + {file = "macholib-1.16.3-py2.py3-none-any.whl", hash = "sha256:0e315d7583d38b8c77e815b1ecbdbf504a8258d8b3e17b61165c6feb60d18f2c"}, + {file = "macholib-1.16.3.tar.gz", hash = "sha256:07ae9e15e8e4cd9a788013d81f5908b3609aa76f9b1421bae9c4d7606ec86a30"}, +] + +[package.dependencies] +altgraph = ">=0.17" + +[[package]] +name = "milvus-connector" +version = "0.1.0" +description = "" +optional = false +python-versions = "^3.8" +files = [] +develop = true + +[package.dependencies] +furl = "^2.1.3" +grpcio = "^1.62.0" +grpcio-tools = "^1.62.0" +pydantic = "^2.6.3" +typing-extensions = "^4.10.0" + +[package.source] +type = "directory" +url = "../.." + +[[package]] +name = "orderedmultidict" +version = "1.0.1" +description = "Ordered Multivalue Dictionary" +optional = false +python-versions = "*" +files = [] +develop = false + +[package.dependencies] +six = ">=1.8.0" + +[package.source] +type = "git" +url = "https://github.com/gruns/orderedmultidict.git" +reference = "d3912b8" +resolved_reference = "d3912b85cd6dbb18c3e7bde4d18443931b6608c3" + +[[package]] +name = "packaging" +version = "24.0" +description = "Core utilities for Python packages" +optional = false +python-versions = ">=3.7" +files = [ + {file = "packaging-24.0-py3-none-any.whl", hash = "sha256:2ddfb553fdf02fb784c234c7ba6ccc288296ceabec964ad2eae3777778130bc5"}, + {file = "packaging-24.0.tar.gz", hash = "sha256:eb82c5e3e56209074766e6885bb04b8c38a0c015d0a30036ebe7ece34c9989e9"}, +] + +[[package]] +name = "pefile" +version = "2023.2.7" +description = "Python PE parsing module" +optional = false +python-versions = ">=3.6.0" +files = [ + {file = "pefile-2023.2.7-py3-none-any.whl", hash = "sha256:da185cd2af68c08a6cd4481f7325ed600a88f6a813bad9dea07ab3ef73d8d8d6"}, + {file = "pefile-2023.2.7.tar.gz", hash = "sha256:82e6114004b3d6911c77c3953e3838654b04511b8b66e8583db70c65998017dc"}, +] + +[[package]] +name = "protobuf" +version = "4.25.3" +description = "" +optional = false +python-versions = ">=3.8" +files = [ + {file = "protobuf-4.25.3-cp310-abi3-win32.whl", hash = "sha256:d4198877797a83cbfe9bffa3803602bbe1625dc30d8a097365dbc762e5790faa"}, + {file = "protobuf-4.25.3-cp310-abi3-win_amd64.whl", hash = "sha256:209ba4cc916bab46f64e56b85b090607a676f66b473e6b762e6f1d9d591eb2e8"}, + {file = "protobuf-4.25.3-cp37-abi3-macosx_10_9_universal2.whl", hash = "sha256:f1279ab38ecbfae7e456a108c5c0681e4956d5b1090027c1de0f934dfdb4b35c"}, + {file = "protobuf-4.25.3-cp37-abi3-manylinux2014_aarch64.whl", hash = "sha256:e7cb0ae90dd83727f0c0718634ed56837bfeeee29a5f82a7514c03ee1364c019"}, + {file = "protobuf-4.25.3-cp37-abi3-manylinux2014_x86_64.whl", hash = "sha256:7c8daa26095f82482307bc717364e7c13f4f1c99659be82890dcfc215194554d"}, + {file = "protobuf-4.25.3-cp38-cp38-win32.whl", hash = "sha256:f4f118245c4a087776e0a8408be33cf09f6c547442c00395fbfb116fac2f8ac2"}, + {file = "protobuf-4.25.3-cp38-cp38-win_amd64.whl", hash = "sha256:c053062984e61144385022e53678fbded7aea14ebb3e0305ae3592fb219ccfa4"}, + {file = "protobuf-4.25.3-cp39-cp39-win32.whl", hash = "sha256:19b270aeaa0099f16d3ca02628546b8baefe2955bbe23224aaf856134eccf1e4"}, + {file = "protobuf-4.25.3-cp39-cp39-win_amd64.whl", hash = "sha256:e3c97a1555fd6388f857770ff8b9703083de6bf1f9274a002a332d65fbb56c8c"}, + {file = "protobuf-4.25.3-py3-none-any.whl", hash = "sha256:f0700d54bcf45424477e46a9f0944155b46fb0639d69728739c0e47bab83f2b9"}, + {file = "protobuf-4.25.3.tar.gz", hash = "sha256:25b5d0b42fd000320bd7830b349e3b696435f3b329810427a6bcce6a5492cc5c"}, +] + +[[package]] +name = "pydantic" +version = "2.6.3" +description = "Data validation using Python type hints" +optional = false +python-versions = ">=3.8" +files = [ + {file = "pydantic-2.6.3-py3-none-any.whl", hash = "sha256:72c6034df47f46ccdf81869fddb81aade68056003900a8724a4f160700016a2a"}, + {file = "pydantic-2.6.3.tar.gz", hash = "sha256:e07805c4c7f5c6826e33a1d4c9d47950d7eaf34868e2690f8594d2e30241f11f"}, +] + +[package.dependencies] +annotated-types = ">=0.4.0" +pydantic-core = "2.16.3" +typing-extensions = ">=4.6.1" + +[package.extras] +email = ["email-validator (>=2.0.0)"] + +[[package]] +name = "pydantic-core" +version = "2.16.3" +description = "" +optional = false +python-versions = ">=3.8" +files = [ + {file = "pydantic_core-2.16.3-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:75b81e678d1c1ede0785c7f46690621e4c6e63ccd9192af1f0bd9d504bbb6bf4"}, + {file = "pydantic_core-2.16.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:9c865a7ee6f93783bd5d781af5a4c43dadc37053a5b42f7d18dc019f8c9d2bd1"}, + {file = "pydantic_core-2.16.3-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:162e498303d2b1c036b957a1278fa0899d02b2842f1ff901b6395104c5554a45"}, + {file = "pydantic_core-2.16.3-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:2f583bd01bbfbff4eaee0868e6fc607efdfcc2b03c1c766b06a707abbc856187"}, + {file = "pydantic_core-2.16.3-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b926dd38db1519ed3043a4de50214e0d600d404099c3392f098a7f9d75029ff8"}, + {file = "pydantic_core-2.16.3-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:716b542728d4c742353448765aa7cdaa519a7b82f9564130e2b3f6766018c9ec"}, + {file = "pydantic_core-2.16.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fc4ad7f7ee1a13d9cb49d8198cd7d7e3aa93e425f371a68235f784e99741561f"}, + {file = "pydantic_core-2.16.3-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:bd87f48924f360e5d1c5f770d6155ce0e7d83f7b4e10c2f9ec001c73cf475c99"}, + {file = "pydantic_core-2.16.3-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:0df446663464884297c793874573549229f9eca73b59360878f382a0fc085979"}, + {file = "pydantic_core-2.16.3-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:4df8a199d9f6afc5ae9a65f8f95ee52cae389a8c6b20163762bde0426275b7db"}, + {file = "pydantic_core-2.16.3-cp310-none-win32.whl", hash = "sha256:456855f57b413f077dff513a5a28ed838dbbb15082ba00f80750377eed23d132"}, + {file = "pydantic_core-2.16.3-cp310-none-win_amd64.whl", hash = "sha256:732da3243e1b8d3eab8c6ae23ae6a58548849d2e4a4e03a1924c8ddf71a387cb"}, + {file = "pydantic_core-2.16.3-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:519ae0312616026bf4cedc0fe459e982734f3ca82ee8c7246c19b650b60a5ee4"}, + {file = "pydantic_core-2.16.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:b3992a322a5617ded0a9f23fd06dbc1e4bd7cf39bc4ccf344b10f80af58beacd"}, + {file = "pydantic_core-2.16.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8d62da299c6ecb04df729e4b5c52dc0d53f4f8430b4492b93aa8de1f541c4aac"}, + {file = "pydantic_core-2.16.3-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:2acca2be4bb2f2147ada8cac612f8a98fc09f41c89f87add7256ad27332c2fda"}, + {file = "pydantic_core-2.16.3-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1b662180108c55dfbf1280d865b2d116633d436cfc0bba82323554873967b340"}, + {file = "pydantic_core-2.16.3-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e7c6ed0dc9d8e65f24f5824291550139fe6f37fac03788d4580da0d33bc00c97"}, + {file = "pydantic_core-2.16.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a6b1bb0827f56654b4437955555dc3aeeebeddc47c2d7ed575477f082622c49e"}, + {file = "pydantic_core-2.16.3-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:e56f8186d6210ac7ece503193ec84104da7ceb98f68ce18c07282fcc2452e76f"}, + {file = "pydantic_core-2.16.3-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:936e5db01dd49476fa8f4383c259b8b1303d5dd5fb34c97de194560698cc2c5e"}, + {file = "pydantic_core-2.16.3-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:33809aebac276089b78db106ee692bdc9044710e26f24a9a2eaa35a0f9fa70ba"}, + {file = "pydantic_core-2.16.3-cp311-none-win32.whl", hash = "sha256:ded1c35f15c9dea16ead9bffcde9bb5c7c031bff076355dc58dcb1cb436c4721"}, + {file = "pydantic_core-2.16.3-cp311-none-win_amd64.whl", hash = "sha256:d89ca19cdd0dd5f31606a9329e309d4fcbb3df860960acec32630297d61820df"}, + {file = "pydantic_core-2.16.3-cp311-none-win_arm64.whl", hash = "sha256:6162f8d2dc27ba21027f261e4fa26f8bcb3cf9784b7f9499466a311ac284b5b9"}, + {file = "pydantic_core-2.16.3-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:0f56ae86b60ea987ae8bcd6654a887238fd53d1384f9b222ac457070b7ac4cff"}, + {file = "pydantic_core-2.16.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:c9bd22a2a639e26171068f8ebb5400ce2c1bc7d17959f60a3b753ae13c632975"}, + {file = "pydantic_core-2.16.3-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4204e773b4b408062960e65468d5346bdfe139247ee5f1ca2a378983e11388a2"}, + {file = "pydantic_core-2.16.3-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f651dd19363c632f4abe3480a7c87a9773be27cfe1341aef06e8759599454120"}, + {file = "pydantic_core-2.16.3-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:aaf09e615a0bf98d406657e0008e4a8701b11481840be7d31755dc9f97c44053"}, + {file = "pydantic_core-2.16.3-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8e47755d8152c1ab5b55928ab422a76e2e7b22b5ed8e90a7d584268dd49e9c6b"}, + {file = "pydantic_core-2.16.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:500960cb3a0543a724a81ba859da816e8cf01b0e6aaeedf2c3775d12ee49cade"}, + {file = "pydantic_core-2.16.3-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:cf6204fe865da605285c34cf1172879d0314ff267b1c35ff59de7154f35fdc2e"}, + {file = "pydantic_core-2.16.3-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:d33dd21f572545649f90c38c227cc8631268ba25c460b5569abebdd0ec5974ca"}, + {file = "pydantic_core-2.16.3-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:49d5d58abd4b83fb8ce763be7794d09b2f50f10aa65c0f0c1696c677edeb7cbf"}, + {file = "pydantic_core-2.16.3-cp312-none-win32.whl", hash = "sha256:f53aace168a2a10582e570b7736cc5bef12cae9cf21775e3eafac597e8551fbe"}, + {file = "pydantic_core-2.16.3-cp312-none-win_amd64.whl", hash = "sha256:0d32576b1de5a30d9a97f300cc6a3f4694c428d956adbc7e6e2f9cad279e45ed"}, + {file = "pydantic_core-2.16.3-cp312-none-win_arm64.whl", hash = "sha256:ec08be75bb268473677edb83ba71e7e74b43c008e4a7b1907c6d57e940bf34b6"}, + {file = "pydantic_core-2.16.3-cp38-cp38-macosx_10_12_x86_64.whl", hash = "sha256:b1f6f5938d63c6139860f044e2538baeee6f0b251a1816e7adb6cbce106a1f01"}, + {file = "pydantic_core-2.16.3-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:2a1ef6a36fdbf71538142ed604ad19b82f67b05749512e47f247a6ddd06afdc7"}, + {file = "pydantic_core-2.16.3-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:704d35ecc7e9c31d48926150afada60401c55efa3b46cd1ded5a01bdffaf1d48"}, + {file = "pydantic_core-2.16.3-cp38-cp38-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:d937653a696465677ed583124b94a4b2d79f5e30b2c46115a68e482c6a591c8a"}, + {file = "pydantic_core-2.16.3-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c9803edf8e29bd825f43481f19c37f50d2b01899448273b3a7758441b512acf8"}, + {file = "pydantic_core-2.16.3-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:72282ad4892a9fb2da25defeac8c2e84352c108705c972db82ab121d15f14e6d"}, + {file = "pydantic_core-2.16.3-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7f752826b5b8361193df55afcdf8ca6a57d0232653494ba473630a83ba50d8c9"}, + {file = "pydantic_core-2.16.3-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:4384a8f68ddb31a0b0c3deae88765f5868a1b9148939c3f4121233314ad5532c"}, + {file = "pydantic_core-2.16.3-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:a4b2bf78342c40b3dc830880106f54328928ff03e357935ad26c7128bbd66ce8"}, + {file = "pydantic_core-2.16.3-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:13dcc4802961b5f843a9385fc821a0b0135e8c07fc3d9949fd49627c1a5e6ae5"}, + {file = "pydantic_core-2.16.3-cp38-none-win32.whl", hash = "sha256:e3e70c94a0c3841e6aa831edab1619ad5c511199be94d0c11ba75fe06efe107a"}, + {file = "pydantic_core-2.16.3-cp38-none-win_amd64.whl", hash = "sha256:ecdf6bf5f578615f2e985a5e1f6572e23aa632c4bd1dc67f8f406d445ac115ed"}, + {file = "pydantic_core-2.16.3-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:bda1ee3e08252b8d41fa5537413ffdddd58fa73107171a126d3b9ff001b9b820"}, + {file = "pydantic_core-2.16.3-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:21b888c973e4f26b7a96491c0965a8a312e13be108022ee510248fe379a5fa23"}, + {file = "pydantic_core-2.16.3-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:be0ec334369316fa73448cc8c982c01e5d2a81c95969d58b8f6e272884df0074"}, + {file = "pydantic_core-2.16.3-cp39-cp39-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b5b6079cc452a7c53dd378c6f881ac528246b3ac9aae0f8eef98498a75657805"}, + {file = "pydantic_core-2.16.3-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:7ee8d5f878dccb6d499ba4d30d757111847b6849ae07acdd1205fffa1fc1253c"}, + {file = "pydantic_core-2.16.3-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7233d65d9d651242a68801159763d09e9ec96e8a158dbf118dc090cd77a104c9"}, + {file = "pydantic_core-2.16.3-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c6119dc90483a5cb50a1306adb8d52c66e447da88ea44f323e0ae1a5fcb14256"}, + {file = "pydantic_core-2.16.3-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:578114bc803a4c1ff9946d977c221e4376620a46cf78da267d946397dc9514a8"}, + {file = "pydantic_core-2.16.3-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:d8f99b147ff3fcf6b3cc60cb0c39ea443884d5559a30b1481e92495f2310ff2b"}, + {file = "pydantic_core-2.16.3-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:4ac6b4ce1e7283d715c4b729d8f9dab9627586dafce81d9eaa009dd7f25dd972"}, + {file = "pydantic_core-2.16.3-cp39-none-win32.whl", hash = "sha256:e7774b570e61cb998490c5235740d475413a1f6de823169b4cf94e2fe9e9f6b2"}, + {file = "pydantic_core-2.16.3-cp39-none-win_amd64.whl", hash = "sha256:9091632a25b8b87b9a605ec0e61f241c456e9248bfdcf7abdf344fdb169c81cf"}, + {file = "pydantic_core-2.16.3-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:36fa178aacbc277bc6b62a2c3da95226520da4f4e9e206fdf076484363895d2c"}, + {file = "pydantic_core-2.16.3-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:dcca5d2bf65c6fb591fff92da03f94cd4f315972f97c21975398bd4bd046854a"}, + {file = "pydantic_core-2.16.3-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2a72fb9963cba4cd5793854fd12f4cfee731e86df140f59ff52a49b3552db241"}, + {file = "pydantic_core-2.16.3-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b60cc1a081f80a2105a59385b92d82278b15d80ebb3adb200542ae165cd7d183"}, + {file = "pydantic_core-2.16.3-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:cbcc558401de90a746d02ef330c528f2e668c83350f045833543cd57ecead1ad"}, + {file = "pydantic_core-2.16.3-pp310-pypy310_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:fee427241c2d9fb7192b658190f9f5fd6dfe41e02f3c1489d2ec1e6a5ab1e04a"}, + {file = "pydantic_core-2.16.3-pp310-pypy310_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:f4cb85f693044e0f71f394ff76c98ddc1bc0953e48c061725e540396d5c8a2e1"}, + {file = "pydantic_core-2.16.3-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:b29eeb887aa931c2fcef5aa515d9d176d25006794610c264ddc114c053bf96fe"}, + {file = "pydantic_core-2.16.3-pp39-pypy39_pp73-macosx_10_12_x86_64.whl", hash = "sha256:a425479ee40ff021f8216c9d07a6a3b54b31c8267c6e17aa88b70d7ebd0e5e5b"}, + {file = "pydantic_core-2.16.3-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:5c5cbc703168d1b7a838668998308018a2718c2130595e8e190220238addc96f"}, + {file = "pydantic_core-2.16.3-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:99b6add4c0b39a513d323d3b93bc173dac663c27b99860dd5bf491b240d26137"}, + {file = "pydantic_core-2.16.3-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:75f76ee558751746d6a38f89d60b6228fa174e5172d143886af0f85aa306fd89"}, + {file = "pydantic_core-2.16.3-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:00ee1c97b5364b84cb0bd82e9bbf645d5e2871fb8c58059d158412fee2d33d8a"}, + {file = "pydantic_core-2.16.3-pp39-pypy39_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:287073c66748f624be4cef893ef9174e3eb88fe0b8a78dc22e88eca4bc357ca6"}, + {file = "pydantic_core-2.16.3-pp39-pypy39_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:ed25e1835c00a332cb10c683cd39da96a719ab1dfc08427d476bce41b92531fc"}, + {file = "pydantic_core-2.16.3-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:86b3d0033580bd6bbe07590152007275bd7af95f98eaa5bd36f3da219dcd93da"}, + {file = "pydantic_core-2.16.3.tar.gz", hash = "sha256:1cac689f80a3abab2d3c0048b29eea5751114054f032a941a32de4c852c59cad"}, +] + +[package.dependencies] +typing-extensions = ">=4.6.0,<4.7.0 || >4.7.0" + +[[package]] +name = "pyinstaller" +version = "6.5.0" +description = "PyInstaller bundles a Python application and all its dependencies into a single package." +optional = false +python-versions = "<3.13,>=3.8" +files = [ + {file = "pyinstaller-6.5.0-py3-none-macosx_10_13_universal2.whl", hash = "sha256:81ec15c0deb8c7a0f95bea85b49eecc2df1bdeaf5fe487a41d97de6b0ad29dff"}, + {file = "pyinstaller-6.5.0-py3-none-manylinux2014_aarch64.whl", hash = "sha256:5f432f3fdef053989e0a44134e483131c533dab7637e6afd80c3f7c26e6dbcc9"}, + {file = "pyinstaller-6.5.0-py3-none-manylinux2014_i686.whl", hash = "sha256:6ffd76a0194dac4df5e66dcfccc7b597f3eaa40ef9a3f63548f260aa2c187512"}, + {file = "pyinstaller-6.5.0-py3-none-manylinux2014_ppc64le.whl", hash = "sha256:a54968df2228f0128607b1dced41bbff94149d459987fb5cd1a41893e9bb85df"}, + {file = "pyinstaller-6.5.0-py3-none-manylinux2014_s390x.whl", hash = "sha256:0dae0edbe6d667b6b0ccd8c97a148f86474a82da7ce582296f9025f4c7242ec6"}, + {file = "pyinstaller-6.5.0-py3-none-manylinux2014_x86_64.whl", hash = "sha256:7c76bfcb624803c311fa8fb137e4780d0ec86d11b7d90a8f43f185e2554afdcc"}, + {file = "pyinstaller-6.5.0-py3-none-musllinux_1_1_aarch64.whl", hash = "sha256:6cfee8a74ea2d3a1dc8e99e732a87b314739dc14363778143caac31f8aee9039"}, + {file = "pyinstaller-6.5.0-py3-none-musllinux_1_1_x86_64.whl", hash = "sha256:9d828213aea5401bb33a36ca396f8dc76a59a25bce1d76a13c9ad94ba29fbe42"}, + {file = "pyinstaller-6.5.0-py3-none-win32.whl", hash = "sha256:61865eee5e0d8f8252722f6d001baec497b7cee79ebe62c33a6ba86ba0c7010d"}, + {file = "pyinstaller-6.5.0-py3-none-win_amd64.whl", hash = "sha256:e1266498893ce1d6cc7337e8d2acbf7905a10ed2b7c8377270117d6b7b922fc4"}, + {file = "pyinstaller-6.5.0-py3-none-win_arm64.whl", hash = "sha256:1b3b7d6d3b18d76a833fd5a4d7f4544c5e2c2a4db4a728ea191e62f69d5cc33c"}, + {file = "pyinstaller-6.5.0.tar.gz", hash = "sha256:b1e55113c5a40cb7041c908a57f212f3ebd3e444dbb245ca2f91d86a76dabec5"}, +] + +[package.dependencies] +altgraph = "*" +macholib = {version = ">=1.8", markers = "sys_platform == \"darwin\""} +packaging = ">=22.0" +pefile = {version = ">=2022.5.30", markers = "sys_platform == \"win32\""} +pyinstaller-hooks-contrib = ">=2024.3" +pywin32-ctypes = {version = ">=0.2.1", markers = "sys_platform == \"win32\""} +setuptools = ">=42.0.0" + +[package.extras] +completion = ["argcomplete"] +hook-testing = ["execnet (>=1.5.0)", "psutil", "pytest (>=2.7.3)"] + +[[package]] +name = "pyinstaller-hooks-contrib" +version = "2024.3" +description = "Community maintained hooks for PyInstaller" +optional = false +python-versions = ">=3.7" +files = [ + {file = "pyinstaller-hooks-contrib-2024.3.tar.gz", hash = "sha256:d18657c29267c63563a96b8fc78db6ba9ae40af6702acb2f8c871df12c75b60b"}, + {file = "pyinstaller_hooks_contrib-2024.3-py2.py3-none-any.whl", hash = "sha256:6701752d525e1f4eda1eaec2c2affc206171e15c7a4e188a152fcf3ed3308024"}, +] + +[package.dependencies] +packaging = ">=22.0" +setuptools = ">=42.0.0" + +[[package]] +name = "python-dotenv" +version = "1.0.1" +description = "Read key-value pairs from a .env file and set them as environment variables" +optional = false +python-versions = ">=3.8" +files = [ + {file = "python-dotenv-1.0.1.tar.gz", hash = "sha256:e324ee90a023d808f1959c46bcbc04446a10ced277783dc6ee09987c37ec10ca"}, + {file = "python_dotenv-1.0.1-py3-none-any.whl", hash = "sha256:f7b63ef50f1b690dddf550d03497b66d609393b40b564ed0d674909a68ebf16a"}, +] + +[package.extras] +cli = ["click (>=5.0)"] + +[[package]] +name = "pywin32-ctypes" +version = "0.2.2" +description = "A (partial) reimplementation of pywin32 using ctypes/cffi" +optional = false +python-versions = ">=3.6" +files = [ + {file = "pywin32-ctypes-0.2.2.tar.gz", hash = "sha256:3426e063bdd5fd4df74a14fa3cf80a0b42845a87e1d1e81f6549f9daec593a60"}, + {file = "pywin32_ctypes-0.2.2-py3-none-any.whl", hash = "sha256:bf490a1a709baf35d688fe0ecf980ed4de11d2b3e37b51e5442587a75d9957e7"}, +] + +[[package]] +name = "setuptools" +version = "69.1.1" +description = "Easily download, build, install, upgrade, and uninstall Python packages" +optional = false +python-versions = ">=3.8" +files = [ + {file = "setuptools-69.1.1-py3-none-any.whl", hash = "sha256:02fa291a0471b3a18b2b2481ed902af520c69e8ae0919c13da936542754b4c56"}, + {file = "setuptools-69.1.1.tar.gz", hash = "sha256:5c0806c7d9af348e6dd3777b4f4dbb42c7ad85b190104837488eab9a7c945cf8"}, +] + +[package.extras] +docs = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "pygments-github-lexers (==0.0.5)", "rst.linker (>=1.9)", "sphinx (<7.2.5)", "sphinx (>=3.5)", "sphinx-favicon", "sphinx-inline-tabs", "sphinx-lint", "sphinx-notfound-page (>=1,<2)", "sphinx-reredirects", "sphinxcontrib-towncrier"] +testing = ["build[virtualenv]", "filelock (>=3.4.0)", "flake8-2020", "ini2toml[lite] (>=0.9)", "jaraco.develop (>=7.21)", "jaraco.envs (>=2.2)", "jaraco.path (>=3.2.0)", "packaging (>=23.2)", "pip (>=19.1)", "pytest (>=6)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=2.2)", "pytest-home (>=0.5)", "pytest-mypy (>=0.9.1)", "pytest-perf", "pytest-ruff (>=0.2.1)", "pytest-timeout", "pytest-xdist", "tomli-w (>=1.0.0)", "virtualenv (>=13.0.0)", "wheel"] +testing-integration = ["build[virtualenv] (>=1.0.3)", "filelock (>=3.4.0)", "jaraco.envs (>=2.2)", "jaraco.path (>=3.2.0)", "packaging (>=23.2)", "pytest", "pytest-enabler", "pytest-xdist", "tomli", "virtualenv (>=13.0.0)", "wheel"] + +[[package]] +name = "six" +version = "1.16.0" +description = "Python 2 and 3 compatibility utilities" +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*" +files = [ + {file = "six-1.16.0-py2.py3-none-any.whl", hash = "sha256:8abb2f1d86890a2dfb989f9a77cfcfd3e47c2a354b01111771326f8aa26e0254"}, + {file = "six-1.16.0.tar.gz", hash = "sha256:1e61c37477a1626458e36f7b1d82aa5c9b094fa4802892072e49de9c60c4c926"}, +] + +[[package]] +name = "typing-extensions" +version = "4.10.0" +description = "Backported and Experimental Type Hints for Python 3.8+" +optional = false +python-versions = ">=3.8" +files = [ + {file = "typing_extensions-4.10.0-py3-none-any.whl", hash = "sha256:69b1a937c3a517342112fb4c6df7e72fc39a38e7891a5730ed4985b5214b5475"}, + {file = "typing_extensions-4.10.0.tar.gz", hash = "sha256:b0abd7c89e8fb96f98db18d86106ff1d90ab692004eb746cf6eda2682f91b3cb"}, +] + +[metadata] +lock-version = "2.0" +python-versions = ">=3.10,<3.13" +content-hash = "5a9d0ae50f4e58443cb54e8bc0ada715fa2e4fcfb738af23618cb61d6a199277" diff --git a/app/milvus-cli/pyproject.toml b/app/milvus-cli/pyproject.toml new file mode 100644 index 0000000..1c6301f --- /dev/null +++ b/app/milvus-cli/pyproject.toml @@ -0,0 +1,23 @@ +[tool.poetry] +name = "mucli" +version = "0.1.0" +description = "Light client directly to milvus service " +authors = ["SimFG <1142838399@qq.com>"] +readme = "README.md" + +[tool.poetry.scripts] +build-mucli = "mucli.pyinstaller:install" +mucli = "mucli.main:main" + +[tool.poetry.dependencies] +python = ">=3.10,<3.13" +click = "^8.1.7" +milvus_connector = { path = "../..", develop = true } +pyinstaller = "^6.5.0" +python-dotenv = "^1.0.1" +orderedmultidict = { git = "https://github.com/gruns/orderedmultidict.git", rev = "d3912b8" } + + +[build-system] +requires = ["poetry-core"] +build-backend = "poetry.core.masonry.api" diff --git a/app/milvus-cli/tests/__init__.py b/app/milvus-cli/tests/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/app/milvus-http/README.md b/app/milvus-http/README.md new file mode 100644 index 0000000..e69de29 diff --git a/app/milvus-http/milvus_http/__init__.py b/app/milvus-http/milvus_http/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/app/milvus-http/pyproject.toml b/app/milvus-http/pyproject.toml new file mode 100644 index 0000000..ccfb6f4 --- /dev/null +++ b/app/milvus-http/pyproject.toml @@ -0,0 +1,14 @@ +[tool.poetry] +name = "milvus-http" +version = "0.1.0" +description = "" +authors = ["SimFG <1142838399@qq.com>"] +readme = "README.md" + +[tool.poetry.dependencies] +python = "^3.10" + + +[build-system] +requires = ["poetry-core"] +build-backend = "poetry.core.masonry.api" diff --git a/app/milvus-http/tests/__init__.py b/app/milvus-http/tests/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/milvus_connector/__init__.py b/milvus_connector/__init__.py new file mode 100644 index 0000000..4005232 --- /dev/null +++ b/milvus_connector/__init__.py @@ -0,0 +1,5 @@ +from milvus_connector.core.milvus import Milvus + +__all__ = [ + "Milvus", +] \ No newline at end of file diff --git a/milvus_connector/_interceptor.py b/milvus_connector/_interceptor.py new file mode 100644 index 0000000..0db4098 --- /dev/null +++ b/milvus_connector/_interceptor.py @@ -0,0 +1,91 @@ +"""Copy from the pymilvus.""" + +from typing import Any, Callable, List, NamedTuple + +import grpc + + +class _GenericClientInterceptor( + grpc.UnaryUnaryClientInterceptor, + grpc.UnaryStreamClientInterceptor, + grpc.StreamUnaryClientInterceptor, + grpc.StreamStreamClientInterceptor, +): + def __init__(self, interceptor_function: Callable) -> None: + super().__init__() + self._fn = interceptor_function + + def intercept_unary_unary(self, continuation: Callable, client_call_details: Any, request: Any): + new_details, new_request_iterator, postprocess = self._fn( + client_call_details, iter((request,)) + ) + response = continuation(new_details, next(new_request_iterator)) + return postprocess(response) if postprocess else response + + def intercept_unary_stream( + self, + continuation: Callable, + client_call_details: Any, + request: Any, + ): + new_details, new_request_iterator, postprocess = self._fn( + client_call_details, iter((request,)) + ) + response_it = continuation(new_details, next(new_request_iterator)) + return postprocess(response_it) if postprocess else response_it + + def intercept_stream_unary( + self, + continuation: Callable, + client_call_details: Any, + request_iterator: Any, + ): + new_details, new_request_iterator, postprocess = self._fn( + client_call_details, request_iterator + ) + response = continuation(new_details, new_request_iterator) + return postprocess(response) if postprocess else response + + def intercept_stream_stream( + self, + continuation: Callable, + client_call_details: Any, + request_iterator: Any, + ): + new_details, new_request_iterator, postprocess = self._fn( + client_call_details, request_iterator + ) + response_it = continuation(new_details, new_request_iterator) + return postprocess(response_it) if postprocess else response_it + + +class ClientCallDetailsTuple(NamedTuple): + method: Any + timeout: Any + metadata: Any + credentials: Any + + +class _ClientCallDetails(ClientCallDetailsTuple, grpc.ClientCallDetails): + pass + + +def header_adder_interceptor(headers: List, values: List): + def intercept_call( + client_call_details: Any, + request_iterator: Any, + ): + metadata = [] + if client_call_details.metadata is not None: + metadata = list(client_call_details.metadata) + for item in zip(headers, values): + metadata.append(item) + client_call_details = _ClientCallDetails( + client_call_details.method, + client_call_details.timeout, + metadata, + client_call_details.credentials, + ) + return client_call_details, request_iterator, None + + return _GenericClientInterceptor(intercept_call) diff --git a/milvus_connector/core/__init__.py b/milvus_connector/core/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/milvus_connector/core/_const.py b/milvus_connector/core/_const.py new file mode 100644 index 0000000..dc6a20a --- /dev/null +++ b/milvus_connector/core/_const.py @@ -0,0 +1,15 @@ +from typing_extensions import Annotated +from pydantic import Field + +DB_NAME = "db_name" +COLLECTION_NAME = "collection_name" +PARTITION_NAME = "partition_name" +PARTITION_NAMES = "partition_names" +USER_NAME = "user_name" +USER_NAME2 = "username" +ROLE_NAME = "role_name" + +VERSION = "0.0.1" + +# validator +NOT_EMPTY_STR = Annotated[str, Field(min_length=1)] \ No newline at end of file diff --git a/milvus_connector/core/_param.py b/milvus_connector/core/_param.py new file mode 100644 index 0000000..2920eab --- /dev/null +++ b/milvus_connector/core/_param.py @@ -0,0 +1,42 @@ +from typing import Any, Dict, List + +from ._const import * + + +class RPCParam: + params: Dict[str, Any] = {} + + def add_param(self, key: str, value: Any) -> None: + self.params[key] = value + + def extend_params(self, params: Dict[str, Any]) -> None: + self.params.update(params) + + def clear_param(self) -> None: + self.params.clear() + + def get_params(self) -> Dict[str, Any]: + # some key should be converted + return self.params + + def _db_name(self) -> str: + return self.params.get(DB_NAME, "") + + def _collection_name(self) -> str: + return self.params.get(COLLECTION_NAME, "") + + def _partition_name(self) -> str: + return self.params.get(PARTITION_NAME, "") + + def _partition_names(self) -> List[str]: + _partition = self.params.get(PARTITION_NAME, "") + return [_partition] if _partition else [] + + def _partition_names(self) -> str: + return self.params.get(PARTITION_NAMES, "") + + def _user_name(self) -> str: + return self.params.get(USER_NAME, self.params.get(USER_NAME2, "")) + + def _role_name(self) -> str: + return self.params.get(ROLE_NAME, "") \ No newline at end of file diff --git a/milvus_connector/core/_types.py b/milvus_connector/core/_types.py new file mode 100644 index 0000000..ddff13b --- /dev/null +++ b/milvus_connector/core/_types.py @@ -0,0 +1,140 @@ +from typing import Literal, Union +from ..protocol.common_pb2 import * +from ..protocol.schema_pb2 import * + +# not stable type +CONSISTENCY_LEVEL = Union[str, Literal[ + "strong", + "session", + "bounded", + "eventually", + "customized", + ]] + +CONSISTENCY_LEVEL_ARRAY = [ + "strong", + "session", + "bounded", + "eventually", + "customized", + ] + +DTYPE = Union[str, Literal[ + "bool", + "int8", "int16", "int32", "int64", + "float", "double", + "string", "varchar", + "array", "json", + "binary_vector", "float_vector", "float16_vector", "bfloat16_vector", "sparse_vector", + ]] + +DTYPE_ARRAY = [ + "bool", + "int8", "int16", "int32", "int64", + "float", "double", + "string", "varchar", + "array", "json", + "binary_vector", "float_vector", "float16_vector", "bfloat16_vector", "sparse_vector", +] + + +INDEX_TYPE = Union[str, Literal[ + "FLAT", "IVF_FLAT", "IVF_SQ8", "IVF_PQ", "SCANN", + "DISKANN", "HNSW", + "BIN_FLAT", "BIN_IVF_FLAT", + "GPU_BRUTE_FORCE", "GPU_IVF_FLAT", "GPU_IVF_PQ", "GPU_CAGRA", "GPU_BRUTE_FORCE", + ]] + +INDEX_TYPE_ARRAY = [ + "FLAT", "IVF_FLAT", "IVF_SQ8", "IVF_PQ", "SCANN", + "DISKANN", "HNSW", + "BIN_FLAT", "BIN_IVF_FLAT", + "GPU_BRUTE_FORCE", "GPU_IVF_FLAT", "GPU_IVF_PQ", "GPU_CAGRA", "GPU_BRUTE_FORCE", + ] + + +METRIC_TYPE = Union[str, Literal[ + "L2", "IP", "COSINE", "HAMMING", "JACCARD", "SUBSTRUCTURE", "SUPERSTRUCTURE", + ]] + +METRIC_TYPE_ARRAY = [ + "L2", "IP", "COSINE", "HAMMING", "JACCARD", "SUBSTRUCTURE", "SUPERSTRUCTURE", + ] + +# more details: see https://milvus.io/docs/users_and_roles.md#Users-and-Roles +COLLECTION_PRIVILEGE = Union[str, Literal[ + "CreateIndex", "DropIndex", "IndexDetail", + "Load", "GetLoadingProgress", "GetLoadState", + "Release", "Insert", "Delete", "Upsert", "Search", "Flush", "GetFlushState", + "Query", "GetStatistics", "Compaction", "Import", "LoadBalance", + "CreatePartition", "ShowPartitions", "DropPartition", "HasPartition", + ]] + +GLOBAL_PRIVILEGE = Union[str, Literal[ + "All", "CreateCollection", "DropCollection", "DescribeCollection", "ShowCollections", + "RenameCollection", "FlushAll", + "CreateOwnership", "DropOwnership", "SelectOwnership", "ManageOwnership", + "CreateResourceGroup", "DropResourceGroup", "DescribeResourceGroup", "ListResourceGroups", + "TransferNode", "TransferReplica", + "CreateDatabase", "DropDatabase", "ListDatabases", + "CreateAlias", "DropAlias", "ShowAliases", "DescribeAlias", + ]] + +USER_PRIVILEGE = Union[str, Literal[ + "UpdateUser", "SelectUser", + ]] + + +def get_consistency_level(level: str) -> ConsistencyLevel: + level = level.lower() + match level: + case "strong": + return ConsistencyLevel.Strong + case "session": + return ConsistencyLevel.Session + case "bounded": + return ConsistencyLevel.Bounded + case "eventual": + return ConsistencyLevel.Eventually + case "customized": + return ConsistencyLevel.Customized + case (_): + raise ValueError(f"Invalid consistency level: {level}") + +def get_data_type(dtype: str) -> DataType: + d = dtype.lower() + match d: + case "bool": + return DataType.Bool + case "int8": + return DataType.Int8 + case "int16": + return DataType.Int16 + case "int32": + return DataType.Int32 + case "int64": + return DataType.Int64 + case "float": + return DataType.Float + case "double": + return DataType.Double + case "string": + return DataType.String + case "varchar": + return DataType.VarChar + case "array": + return DataType.Array + case "json": + return DataType.JSON + case "binary_vector" | "binaryvector": + return DataType.BinaryVector + case "float_vector" | "floatvector": + return DataType.FloatVector + case "float16_vector" | "float16vector": + return DataType.Float16Vector + case "bfloat16_vector" | "bfloat16vector": + return DataType.BFloat16Vector + case "sparse_vector" | "sparsevector": + return DataType.SparseFloatVector + case (_): + raise ValueError(f"Invalid data type: {dtype}") diff --git a/milvus_connector/core/milvus.py b/milvus_connector/core/milvus.py new file mode 100644 index 0000000..0e0d852 --- /dev/null +++ b/milvus_connector/core/milvus.py @@ -0,0 +1,1478 @@ +import base64 +import copy +import datetime +import json +import struct +from typing import Any, Dict, List, Optional, Union, Literal +from typing_extensions import Self, deprecated + +import grpc +from google.protobuf import json_format +from furl import furl +from pydantic import validate_call + +from ..protocol.milvus_pb2_grpc import MilvusServiceStub +from ..protocol.milvus_pb2 import * +from ..protocol.common_pb2 import * +from ..protocol.schema_pb2 import * +from ..protocol.feder_pb2 import * +from ._param import RPCParam +from ._const import * +from ._types import * +from .util import CollectionField, Data +from .._interceptor import header_adder_interceptor + + +class Milvus(RPCParam): + stub: MilvusServiceStub + channel: Optional[grpc.Channel] = None + style: str + + def __init__(self, *, + uri: str = "localhost:19530", + token: str = "root:Milvus", + database: str = "default", + response_style: Union[str, Literal[ + "json", + "object", + ]] = "object", + milvus: Optional[Self] = None, + ) -> None: + if milvus: + self.stub = milvus.stub + self.style = milvus.style + self.params = copy.deepcopy(milvus.params) + return + self.style = response_style.lower() + if not uri.startswith("http"): + uri = "http://" + uri + _secure = uri.startswith("https://") + _header_key = list() + _header_value = list() + if token: + _header_key.append("authorization") + _header_value.append(base64.b64encode(f"{token}".encode())) + if database: + _header_key.append("dbname") + _header_value.append(database) + + _netloc = furl(uri).netloc + if _secure: + creds = grpc.ssl_channel_credentials() + _channel = grpc.secure_channel(_netloc, creds) + else: + _channel = grpc.insecure_channel(_netloc) + + if _header_key: + interceptor = header_adder_interceptor(_header_key, _header_value) + _channel = grpc.intercept_channel(_channel, interceptor) + self.stub = MilvusServiceStub(_channel) + self.channel = _channel + + def __enter__(self): + return self + + def __exit__(self, exc_type, exc_val, exc_tb): + if self.channel: + self.channel.close() + + def _is_json(self) -> bool: + return self.style == "json" + + def _intercept_resp(self, resp: Any)->None: + pass + + def json(self) -> Self: + m = Milvus(milvus=self) + m.style = "json" + return m + + def with_params(self, *, params: Dict[str, Any] = dict()) -> Self: + m = Milvus(milvus=self) + m.extend_params(params) + return m + + @validate_call + def with_db(self, *, name: NOT_EMPTY_STR) -> Self: + m = Milvus(milvus=self) + m.add_param(DB_NAME, name) + return m + + @validate_call + def with_collection(self, *, name: NOT_EMPTY_STR) -> Self: + m = Milvus(milvus=self) + m.add_param(COLLECTION_NAME, name) + return m + + @validate_call + def with_partition(self, *, name: NOT_EMPTY_STR) -> Self: + m = Milvus(milvus=self) + m.add_param(PARTITION_NAME, name) + return m + + def create_collection(self, *, + db_name: str = "", + collection_name: str = "", + shard_num: int = 1, + consistency_level: CONSISTENCY_LEVEL = "bounded", + properties: Optional[Dict[str, str]] = None, + num_partitions: int = 0, + collection_description: str = "", + auto_id: bool = False, + enable_dynamic_field: bool = False, + schema_properties: Optional[Dict[str, str]] = None, + fields: List[CollectionField] = [], + ) -> Union[Status, str]: + if len(fields) == 0: + raise ValueError("Fields should not be empty") + pk_cnt = 0 + for field in fields: + if field.obj.is_primary_key: + pk_cnt += 1 + if pk_cnt > 1: + raise ValueError("There should be only one primary key") + if pk_cnt == 0: + raise ValueError("There should be at least one primary key") + + _db_name = db_name or self._db_name() + _collection_name = collection_name or self._collection_name() + schema = CollectionSchema( + name=_collection_name, + description=collection_description, + autoID=auto_id, + fields=[field.obj for field in fields], + enable_dynamic_field=enable_dynamic_field, + properties=[KeyValuePair(key=k, value=v) for k, v in (schema_properties or {}).items()], + ) + resp = self.stub.CreateCollection( + CreateCollectionRequest( + db_name=_db_name, + collection_name=_collection_name, + schema=bytes(schema.SerializeToString()), + shards_num=shard_num, + consistency_level=get_consistency_level(consistency_level), + properties=[KeyValuePair(key=k, value=v) for k, v in (properties or {}).items()], + num_partitions=num_partitions, + ) + ) + self._intercept_resp(resp) + if self._is_json(): + return json_format.MessageToJson(resp) + return resp + + def drop_collection(self, *, + db_name: str = "", + collection_name: str = "", + ) -> Union[Status, str]: + _db_name = db_name or self._db_name() + _collection_name = collection_name or self._collection_name() + resp = self.stub.DropCollection(DropCollectionRequest(db_name=_db_name, collection_name=_collection_name)) + self._intercept_resp(resp) + if self._is_json(): + return json_format.MessageToJson(resp) + return resp + + def alter_collection(self, *, + db_name: str = "", + collection_name: str = "", + collection_id: int = 0, + properties: Dict[str, str] = None, + ) -> Union[Status, str]: + _db_name = db_name or self._db_name() + _collection_name = collection_name or self._collection_name() + resp = self.stub.AlterCollection(AlterCollectionRequest( + db_name=_db_name, + collection_name=_collection_name, + collectionID=collection_id, + properties=[KeyValuePair(key=k, value=v) for k, v in (properties or {}).items()], + )) + self._intercept_resp(resp) + if self._is_json(): + return json_format.MessageToJson(resp) + return resp + + @deprecated("Use describe_collection instead") + def has_collection(self, *, + db_name: str = "", + collection_name: str = "", + time_stamp: int = 0, + ) -> Union[BoolResponse, str]: + _db_name = db_name or self._db_name() + _collection_name = collection_name or self._collection_name() + resp = self.stub.HasCollection(HasCollectionRequest( + db_name=_db_name, + collection_name=_collection_name, + time_stamp=time_stamp, + )) + self._intercept_resp(resp) + if self._is_json(): + return json_format.MessageToJson(resp) + return resp + + def describe_collection(self, *, + db_name: str = "", + collection_name: str = "", + collection_id: int = 0, + time_stamp: int = 0, + ) -> Union[DescribeCollectionResponse, str]: + _db_name = db_name or self._db_name() + _collection_name = collection_name or self._collection_name() + resp = self.stub.DescribeCollection(DescribeCollectionRequest( + db_name=_db_name, + collection_name=_collection_name, + collectionID=collection_id, + time_stamp=time_stamp, + )) + self._intercept_resp(resp) + if self._is_json(): + return json_format.MessageToJson(resp) + return resp + + def load_collection(self, *, + db_name: str = "", + collection_name: str = "", + replica_number: int = 1, + resource_groups: Optional[List[str]] = None, + refresh: bool = False, + ) -> Union[Status, str]: + _db_name = db_name or self._db_name() + _collection_name = collection_name or self._collection_name() + resp = self.stub.LoadCollection(LoadCollectionRequest( + db_name=_db_name, + collection_name=_collection_name, + replica_number=replica_number, + resource_groups=resource_groups or [], + refresh=refresh, + )) + self._intercept_resp(resp) + if self._is_json(): + return json_format.MessageToJson(resp) + return resp + + def release_collection(self, *, + db_name: str = "", + collection_name: str = "", + ) -> Union[Status, str]: + _db_name = db_name or self._db_name() + _collection_name = collection_name or self._collection_name() + resp = self.stub.ReleaseCollection(ReleaseCollectionRequest(db_name=_db_name, collection_name=_collection_name)) + self._intercept_resp(resp) + if self._is_json(): + return json_format.MessageToJson(resp) + return resp + + def get_collection_statistics(self, *, + db_name: str = "", + collection_name: str = "", + ) -> Union[GetCollectionStatisticsResponse, str]: + _db_name = db_name or self._db_name() + _collection_name = collection_name or self._collection_name() + resp = self.stub.GetCollectionStatistics(GetCollectionStatisticsRequest(db_name=_db_name, collection_name=_collection_name)) + self._intercept_resp(resp) + if self._is_json(): + return json_format.MessageToJson(resp) + return resp + + def show_collections(self, *, + db_name: str = "", + ) -> Union[ShowCollectionsResponse, str]: + _db_name = db_name or self._db_name() + resp = self.stub.ShowCollections(ShowCollectionsRequest(db_name=_db_name)) + self._intercept_resp(resp) + if self._is_json(): + return json_format.MessageToJson(resp) + return resp + + def insert(self, *, + db_name: str = "", + collection_name: str = "", + partition_name: str = "", + fields_data: List[Data] = None, + num_rows: int = 0, + ) -> Union[MutationResult, str]: + _db_name = db_name or self._db_name() + _collection_name = collection_name or self._collection_name() + _partition_name = partition_name or self._partition_name() + req = InsertRequest( + db_name=_db_name, + collection_name=_collection_name, + partition_name=_partition_name, + fields_data=[d.construct_data() for d in fields_data], + num_rows=num_rows, + ) + resp = self.stub.Insert(req) + self._intercept_resp(resp) + if self._is_json(): + return json_format.MessageToJson(resp) + return resp + + def delete(self, *, + db_name: str = "", + collection_name: str = "", + partition_name: str = "", + expr: str = "", + consistency_level: CONSISTENCY_LEVEL = "strong", + ) -> Union[MutationResult, str]: + _db_name = db_name or self._db_name() + _collection_name = collection_name or self._collection_name() + _partition_name = partition_name or self._partition_name() + req = DeleteRequest( + db_name=_db_name, + collection_name=_collection_name, + partition_name=_partition_name, + expr=expr, + consistency_level=get_consistency_level(consistency_level), + ) + resp = self.stub.Delete(req) + self._intercept_resp(resp) + if self._is_json(): + return json_format.MessageToJson(resp) + return resp + + def upsert(self, *, + db_name: str = "", + collection_name: str = "", + partition_name: str = "", + fields_data: List[Data] = None, + num_rows: int = 0, + ) -> Union[MutationResult, str]: + _db_name = db_name or self._db_name() + _collection_name = collection_name or self._collection_name() + _partition_name = partition_name or self._partition_name() + req = UpsertRequest( + db_name=_db_name, + collection_name=_collection_name, + partition_name=_partition_name, + fields_data=[d.construct_data() for d in fields_data], + num_rows=num_rows, + ) + resp = self.stub.Upsert(req) + self._intercept_resp(resp) + if self._is_json(): + return json_format.MessageToJson(resp) + return resp + + def construct_search_request(self, *, + # common params + db_name: str = "", + collection_name: str = "", + partition_names: List[str] = [], + expr: str = "", + output_fields: List[str] = None, + vector_field: str = None, + top_k: int = 10, + metric_type: str = "L2", + search_data: List[Union[List[float], bytes]] = None, + # more params + search_params: Dict[str, Any] = None, + round_decimal: int = -1, + ignore_growing: bool = False, + offset: int = 0, + extra_params: Optional[Dict[str, Any]] = None, + iterator: str = "", + group_by_field: str = "", + guarantee_timestamp: int = 0, + not_return_all_meta: bool = False, + consistency_level: CONSISTENCY_LEVEL = "bounded", + use_default_consistency: bool = False, + search_by_primary_keys: bool = False, + ) -> SearchRequest: + _db_name = db_name or self._db_name() + _collection_name = collection_name or self._collection_name() + search_params = search_params or {} + search_params["round_decimal"] = round_decimal + search_params["ignore_growing"] = ignore_growing + search_params["topk"] = top_k + search_params["params"] = extra_params or {} + search_params["anns_field"] = vector_field + if offset > 0: + search_params["offset"] = offset + if iterator: + search_params["iterator"] = iterator + if group_by_field: + search_params["group_by_field"] = group_by_field + if metric_type: + search_params["metric_type"] = metric_type + is_binary, pl_type = (True, PlaceholderType.BinaryVector) if isinstance(search_data[0], bytes) else (False, PlaceholderType.FloatVector) + nq, tag = len(search_data), "$0" + plg = PlaceholderGroup( + placeholders=[PlaceholderValue( + tag=tag, + type=pl_type, + values=[bytes(d) if is_binary else struct.pack(f"{len(d)}f", *d) for d in search_data], + )], + ) + + return SearchRequest( + db_name=_db_name, + collection_name=_collection_name, + partition_names=partition_names, + dsl=expr, + dsl_type=DslType.BoolExprV1, + placeholder_group=PlaceholderGroup.SerializeToString(plg), + output_fields=output_fields, + search_params=[KeyValuePair(key=k, value=json.dumps(v) if isinstance(v, dict) else str(v)) for k, v in search_params.items()], + travel_timestamp=0, + guarantee_timestamp=guarantee_timestamp, + nq=nq, + not_return_all_meta=not_return_all_meta, + consistency_level=consistency_level, + use_default_consistency=use_default_consistency, + search_by_primary_keys=search_by_primary_keys, + ) + + def search(self, *, req: SearchRequest) -> Union[SearchResults, str]: + resp = self.stub.Search(req) + self._intercept_resp(resp) + if self._is_json(): + return json_format.MessageToJson(resp) + return resp + + def hybrid_search(self, *, + db_name: str = "", + collection_name: str = "", + partition_names: List[str] = [], + reqs: List[SearchRequest] = None, + rank_params: Dict[str, str] = None, + guarantee_timestamp: int = 0, + not_return_all_meta: bool = False, + output_fields: List[str] = None, + consistency_level: CONSISTENCY_LEVEL = "bounded", + use_default_consistency: bool = False, + ) -> Union[SearchResults, str]: + _db_name = db_name or self._db_name() + _collection_name = collection_name or self._collection_name() + resp = self.stub.HybridSearch(HybridSearchRequest( + db_name=_db_name, + collection_name=_collection_name, + partition_names=partition_names, + requests=reqs, + rank_params=[KeyValuePair(key=k, value=v) for k, v in (rank_params or {}).items()], + guarantee_timestamp=guarantee_timestamp, + not_return_all_meta=not_return_all_meta, + output_fields=output_fields, + consistency_level=get_consistency_level(consistency_level), + use_default_consistency=use_default_consistency, + )) + self._intercept_resp(resp) + if self._is_json(): + return json_format.MessageToJson(resp) + return resp + + def flush(self, *, + db_name: str = "", + collection_names: List[str] = [], + ) -> Union[Status, str]: + _db_name = db_name or self._db_name() + _collection_names = [self._collection_name()] if len(collection_names) == 0 else collection_names + resp = self.stub.Flush(FlushRequest(db_name=_db_name, collection_names=_collection_names)) + self._intercept_resp(resp) + if self._is_json(): + return json_format.MessageToJson(resp) + return resp + + def get_flush_state(self, *, + db_name: str = "", + collection_name: str = "", + segmentIDs: List[int] = [], + flush_ts: int = 0, + ) -> Union[GetFlushStateResponse, str]: + _db_name = db_name or self._db_name() + _collection_name = collection_name or self._collection_name() + resp = self.stub.GetFlushState(GetFlushStateRequest( + db_name=_db_name, + collection_name=_collection_name, + segmentIDs=segmentIDs, + flush_ts=flush_ts, + )) + self._intercept_resp(resp) + if self._is_json(): + return json_format.MessageToJson(resp) + return resp + + def query(self, *, + db_name: str = "", + collection_name: str = "", + partition_names: List[str] = [], + expr: str = "", + output_fields: List[str] = None, + limit: int = -1, + ignore_growing: bool = False, + reduce_stop_for_best: bool = False, + offset: int = 0, + query_params: Dict[str, Any] = None, + guarantee_timestamp: int = 0, + not_return_all_meta: bool = False, + consistency_level: CONSISTENCY_LEVEL = "bounded", + use_default_consistency: bool = False, + ) -> Union[SearchResults, str]: + _db_name = db_name or self._db_name() + _collection_name = collection_name or self._collection_name() + _query_params = query_params or {} + _query_params["reduce_stop_for_best"] = reduce_stop_for_best + _query_params["ignore_growing"] = ignore_growing + if offset > 0: + _query_params["offset"] = offset + if limit > 0: + _query_params["limit"] = limit + resp = self.stub.Query(QueryRequest( + db_name=_db_name, + collection_name=_collection_name, + partition_names=partition_names, + expr=expr, + output_fields=output_fields, + query_params=[KeyValuePair(key=k, value=str(v) if isinstance(v, dict) else str(v)) for k, v in _query_params.items()], + guarantee_timestamp=guarantee_timestamp, + not_return_all_meta=not_return_all_meta, + consistency_level=get_consistency_level(consistency_level), + use_default_consistency=use_default_consistency, + )) + self._intercept_resp(resp) + if self._is_json(): + return json_format.MessageToJson(resp) + return resp + + def flush_all(self, *, + db_name: str = "", + ) -> Union[Status, str]: + _db_name = db_name or self._db_name() + resp = self.stub.Flush(FlushRequest(db_name=_db_name)) + self._intercept_resp(resp) + if self._is_json(): + return json_format.MessageToJson(resp) + return resp + + def get_flush_all_state(self, *, + db_name: str = "", + flush_all_ts: int = 0, + ) -> Union[GetFlushAllStateResponse, str]: + _db_name = db_name or self._db_name() + resp = self.stub.GetFlushAllState(GetFlushAllStateRequest( + db_name=_db_name, + flush_all_ts=flush_all_ts, + )) + self._intercept_resp(resp) + if self._is_json(): + return json_format.MessageToJson(resp) + return resp + + def create_partition(self, *, + db_name: str = "", + collection_name: str = "", + partition_name: str = "", + ) -> Union[Status, str]: + _db_name = db_name or self._db_name() + _collection_name = collection_name or self._collection_name() + _partition_name = partition_name or self._partition_name() + resp = self.stub.CreatePartition(CreatePartitionRequest( + db_name=_db_name, + collection_name=_collection_name, + partition_name=_partition_name, + )) + self._intercept_resp(resp) + if self._is_json(): + return json_format.MessageToJson(resp) + return resp + + def drop_partition(self, *, + db_name: str = "", + collection_name: str = "", + partition_name: str = "", + ) -> Union[Status, str]: + _db_name = db_name or self._db_name() + _collection_name = collection_name or self._collection_name() + _partition_name = partition_name or self._partition_name() + resp = self.stub.DropPartition(DropPartitionRequest( + db_name=_db_name, + collection_name=_collection_name, + partition_name=_partition_name, + )) + self._intercept_resp(resp) + if self._is_json(): + return json_format.MessageToJson(resp) + return resp + + @deprecated("Use show_partitions instead") + def has_partition(self, *, + db_name: str = "", + collection_name: str = "", + partition_name: str = "", + time_stamp: int = 0, + ) -> Union[BoolResponse, str]: + _db_name = db_name or self._db_name() + _collection_name = collection_name or self._collection_name() + _partition_name = partition_name or self._partition_name() + resp = self.stub.HasPartition(HasPartitionRequest( + db_name=_db_name, + collection_name=_collection_name, + partition_name=_partition_name, + time_stamp=time_stamp, + )) + self._intercept_resp(resp) + if self._is_json(): + return json_format.MessageToJson(resp) + return resp + + def load_partitions(self, *, + db_name: str = "", + collection_name: str = "", + partition_names: List[str] = None, + replica_number: int = 1, + resource_groups: Optional[List[str]] = None, + refresh: bool = False, + ) -> Union[Status, str]: + _db_name = db_name or self._db_name() + _collection_name = collection_name or self._collection_name() + _partition_names = [self._partition_name()] if len(partition_names) == 0 else partition_names + resp = self.stub.LoadPartitions(LoadPartitionsRequest( + db_name=_db_name, + collection_name=_collection_name, + partition_names=_partition_names, + replica_number=replica_number, + resource_groups=resource_groups or [], + refresh=refresh, + )) + self._intercept_resp(resp) + if self._is_json(): + return json_format.MessageToJson(resp) + return resp + + def release_partitions(self, *, + db_name: str = "", + collection_name: str = "", + partition_names: List[str] = None, + ) -> Union[Status, str]: + _db_name = db_name or self._db_name() + _collection_name = collection_name or self._collection_name() + _partition_names = [self._partition_name()] if len(partition_names) == 0 else partition_names + resp = self.stub.ReleasePartitions(ReleasePartitionsRequest( + db_name=_db_name, + collection_name=_collection_name, + partition_names=_partition_names, + )) + self._intercept_resp(resp) + if self._is_json(): + return json_format.MessageToJson(resp) + return resp + + def get_partition_statistics(self, *, + db_name: str = "", + collection_name: str = "", + partition_name: str = "", + ) -> Union[GetPartitionStatisticsResponse, str]: + _db_name = db_name or self._db_name() + _collection_name = collection_name or self._collection_name() + _partition_name = partition_name or self._partition_name() + resp = self.stub.GetPartitionStatistics(GetPartitionStatisticsRequest( + db_name=_db_name, + collection_name=_collection_name, + partition_name=_partition_name, + )) + self._intercept_resp(resp) + if self._is_json(): + return json_format.MessageToJson(resp) + return resp + + def show_partitions(self, *, + db_name: str = "", + collection_name: str = "", + collection_id: int = 0, + ) -> Union[ShowPartitionsResponse, str]: + _db_name = db_name or self._db_name() + _collection_name = collection_name or self._collection_name() + resp = self.stub.ShowPartitions(ShowPartitionsRequest( + db_name=_db_name, + collection_name=_collection_name, + collectionID=collection_id, + )) + self._intercept_resp(resp) + if self._is_json(): + return json_format.MessageToJson(resp) + return resp + + def get_loading_progress(self, *, + db_name: str = "", + collection_name: str = "", + partition_names: Optional[List[str]] = None, + ) -> Union[GetLoadingProgressResponse, str]: + _db_name = db_name or self._db_name() + _collection_name = collection_name or self._collection_name() + _partition_names = self._partition_names() if not partition_names else partition_names + resp = self.stub.GetLoadingProgress(GetLoadingProgressRequest( + db_name=_db_name, + collection_name=_collection_name, + partition_names=_partition_names, + )) + self._intercept_resp(resp) + if self._is_json(): + return json_format.MessageToJson(resp) + return resp + + def get_load_state(self, *, + db_name: str = "", + collection_name: str = "", + partition_names: Optional[List[str]] = None, + ) -> Union[GetLoadStateResponse, str]: + _db_name = db_name or self._db_name() + _collection_name = collection_name or self._collection_name() + _partition_names = self._partition_names() if not partition_names else partition_names + resp = self.stub.GetLoadState(GetLoadStateRequest( + db_name=_db_name, + collection_name=_collection_name, + partition_names=_partition_names, + )) + self._intercept_resp(resp) + if self._is_json(): + return json_format.MessageToJson(resp) + return resp + + def create_alias(self, *, + db_name: str = "", + collection_name: str = "", + alias_name: str = "", + ) -> Union[Status, str]: + _db_name = db_name or self._db_name() + _collection_name = collection_name or self._collection_name() + resp = self.stub.CreateAlias(CreateAliasRequest( + db_name=_db_name, + collection_name=_collection_name, + alias=alias_name, + )) + self._intercept_resp(resp) + if self._is_json(): + return json_format.MessageToJson(resp) + return resp + + def drop_alias(self, *, + db_name: str = "", + alias_name: str = "", + ) -> Union[Status, str]: + _db_name = db_name or self._db_name() + resp = self.stub.DropAlias(DropAliasRequest( + db_name=_db_name, + alias=alias_name, + )) + self._intercept_resp(resp) + if self._is_json(): + return json_format.MessageToJson(resp) + return resp + + def alter_alias(self, *, + db_name: str = "", + collection_name: str = "", + alias_name: str = "", + ) -> Union[Status, str]: + _db_name = db_name or self._db_name() + _collection_name = collection_name or self._collection_name() + resp = self.stub.AlterAlias(AlterAliasRequest( + db_name=_db_name, + collection_name=_collection_name, + alias=alias_name, + )) + self._intercept_resp(resp) + if self._is_json(): + return json_format.MessageToJson(resp) + return resp + + def describe_alias(self, *, + db_name: str = "", + alias_name: str = "", + ) -> Union[DescribeAliasResponse, str]: + _db_name = db_name or self._db_name() + resp = self.stub.DescribeAlias(DescribeAliasRequest( + db_name=_db_name, + alias=alias_name, + )) + self._intercept_resp(resp) + if self._is_json(): + return json_format.MessageToJson(resp) + return resp + + def list_aliases(self, *, + db_name: str = "", + collection_name: str = "", + ) -> Union[ListAliasesResponse, str]: + _db_name = db_name or self._db_name() + _collection_name = collection_name or self._collection_name() + resp = self.stub.ListAliases(ListAliasesRequest( + db_name=_db_name, + collection_name=_collection_name, + )) + self._intercept_resp(resp) + if self._is_json(): + return json_format.MessageToJson(resp) + return resp + + def create_index(self, *, + db_name: str = "", + collection_name: str = "", + field_name: str = "", + index_name: str = "", + index_type: INDEX_TYPE = "IVF_FLAT", + metric_type: METRIC_TYPE = "L2", + params: Optional[Dict[str, str]] = None, + nlist: int = 128, + ) -> Union[Status, str]: + _db_name = db_name or self._db_name() + _collection_name = collection_name or self._collection_name() + params = params or {} + params["nlist"] = nlist + extra_params = { + "index_type": index_type, + "metric_type": metric_type, + "params": json.dumps(params), + } + resp = self.stub.CreateIndex(CreateIndexRequest( + db_name=_db_name, + collection_name=_collection_name, + field_name=field_name, + index_name=index_name, + extra_params=[KeyValuePair(key=k, value=str(v)) for k, v in (extra_params or {}).items()], + )) + self._intercept_resp(resp) + if self._is_json(): + return json_format.MessageToJson(resp) + return resp + + def alter_index(self, *, + db_name: str = "", + collection_name: str = "", + index_name: str = "", + params: Dict[str, str] = None, + ) -> Union[Status, str]: + _db_name = db_name or self._db_name() + _collection_name = collection_name or self._collection_name() + resp = self.stub.AlterIndex(AlterIndexRequest( + db_name=_db_name, + collection_name=_collection_name, + index_name=index_name, + extra_params=[KeyValuePair(key=k, value=str(v)) for k, v in (params or {}).items()], + )) + self._intercept_resp(resp) + if self._is_json(): + return json_format.MessageToJson(resp) + return resp + + def describe_index(self, *, + db_name: str = "", + collection_name: str = "", + field_name: str = "", + index_name: str = "", + timestamp: int = 0, + ) -> Union[DescribeIndexResponse, str]: + _db_name = db_name or self._db_name() + _collection_name = collection_name or self._collection_name() + resp = self.stub.DescribeIndex(DescribeIndexRequest( + db_name=_db_name, + collection_name=_collection_name, + index_name=index_name, + field_name=field_name, + timestamp=timestamp, + )) + self._intercept_resp(resp) + if self._is_json(): + return json_format.MessageToJson(resp) + return resp + + def get_index_statistics(self, *, + db_name: str = "", + collection_name: str = "", + index_name: str = "", + timestamp: int = 0, + ) -> Union[GetIndexStatisticsResponse, str]: + _db_name = db_name or self._db_name() + _collection_name = collection_name or self._collection_name() + resp = self.stub.GetIndexStatistics(GetIndexStatisticsRequest( + db_name=_db_name, + collection_name=_collection_name, + index_name=index_name, + timestamp=timestamp, + )) + self._intercept_resp(resp) + if self._is_json(): + return json_format.MessageToJson(resp) + return resp + + def drop_index(self, *, + db_name: str = "", + collection_name: str = "", + index_name: str = "", + ) -> Union[Status, str]: + _db_name = db_name or self._db_name() + _collection_name = collection_name or self._collection_name() + resp = self.stub.DropIndex(DropIndexRequest( + db_name=_db_name, + collection_name=_collection_name, + index_name=index_name, + )) + self._intercept_resp(resp) + if self._is_json(): + return json_format.MessageToJson(resp) + return resp + + def get_persistent_segment_info(self, *, + db_name: str = "", + collection_name: str = "", + ) -> Union[GetPersistentSegmentInfoResponse, str]: + _db_name = db_name or self._db_name() + _collection_name = collection_name or self._collection_name() + resp = self.stub.GetPersistentSegmentInfo(GetPersistentSegmentInfoRequest( + dbName=_db_name, + collectionName=_collection_name, + )) + self._intercept_resp(resp) + if self._is_json(): + return json_format.MessageToJson(resp) + return resp + + def get_query_segment_info(self, *, + db_name: str = "", + collection_name: str = "", + ) -> Union[GetQuerySegmentInfoResponse, str]: + _db_name = db_name or self._db_name() + _collection_name = collection_name or self._collection_name() + resp = self.stub.GetQuerySegmentInfo(GetQuerySegmentInfoRequest( + dbName=_db_name, + collectionName=_collection_name, + )) + self._intercept_resp(resp) + if self._is_json(): + return json_format.MessageToJson(resp) + return resp + + def get_replicas(self, *, + db_name: str = "", + collection_name: str = "", + collection_id: int = 0, + with_shard_nodes: bool = False, + ) -> Union[GetReplicasResponse, str]: + _db_name = db_name or self._db_name() + _collection_name = collection_name or self._collection_name() + resp = self.stub.GetReplica(GetReplicasRequest( + db_name=_db_name, + collection_name=_collection_name, + collectionID=collection_id, + with_shard_nodes=with_shard_nodes, + )) + self._intercept_resp(resp) + if self._is_json(): + return json_format.MessageToJson(resp) + return resp + + def get_metric(self) -> Union[GetMetricsResponse, str]: + resp = self.stub.GetMetrics(GetMetricsRequest( + request="system_info", + )) + self._intercept_resp(resp) + if self._is_json(): + return json_format.MessageToJson(resp) + return resp + + def get_component_states(self) -> Union[ComponentStates, str]: + resp = self.stub.GetComponentStates(GetComponentStatesRequest()) + self._intercept_resp(resp) + if self._is_json(): + return json_format.MessageToJson(resp) + return resp + + def load_banlance(self, *, + db_name: str = "", + collection_name: str = "", + src_node_id: int = 0, + dst_node_ids: List[int] = [], + segment_ids: List[int] = [], + ) -> Union[Status, str]: + _db_name = db_name or self._db_name() + _collection_name = collection_name or self._collection_name() + resp = self.stub.LoadBalance(LoadBalanceRequest( + db_name=_db_name, + collection_name=_collection_name, + src_nodeID=src_node_id, + dst_nodeIDs=dst_node_ids, + sealed_segmentIDs=segment_ids, + )) + self._intercept_resp(resp) + if self._is_json(): + return json_format.MessageToJson(resp) + return resp + + def compaction(self, *, + collection_id: int = 0, + time_travel: int = 0, + ) -> Union[Status, str]: + resp = self.stub.ManualCompaction(ManualCompactionRequest( + collectionID=collection_id, + timeTravel=time_travel, + )) + self._intercept_resp(resp) + if self._is_json(): + return json_format.MessageToJson(resp) + return resp + + def get_compaction_state(self, *, + compaction_id: int = 0, + ) -> Union[GetCompactionStateResponse, str]: + resp = self.stub.GetCompactionState(GetCompactionStateRequest( + compactionID=compaction_id, + )) + self._intercept_resp(resp) + if self._is_json(): + return json_format.MessageToJson(resp) + return resp + + def get_compaction_state_with_plans(self, *, + compaction_id: int = 0, + ) -> Union[GetCompactionPlansResponse, str]: + resp = self.stub.GetCompactionStateWithPlans(GetCompactionPlansRequest( + compactionID=compaction_id, + )) + self._intercept_resp(resp) + if self._is_json(): + return json_format.MessageToJson(resp) + return resp + + def bulk_insert(self, *, + db_name: str = "", + collection_name: str = "", + partition_name: str = "", + channel_names: List[str] = [], + row_base: bool = False, + files: List[str] = [], + options: Dict[str, str] = None, + scalar_fields: List[str] = [], + vector_fields: Dict[str, int] = {}, + ) -> Union[MutationResult, str]: + _db_name = db_name or self._db_name() + _collection_name = collection_name or self._collection_name() + _partition_name = partition_name or self._partition_name() + c = ClusteringInfo( + scalar_clustering_infos=[ScalarClusteringInfo(field=f) for f in scalar_fields], + vector_clustering_infos=[VectorClusteringInfo(field=f, centroid=VectorField(dim=d)) for f, d in vector_fields.items()], + ) + resp = self.stub.Import(ImportRequest( + db_name=_db_name, + collection_name=_collection_name, + partition_name=_partition_name, + channel_names=channel_names, + row_base=row_base, + files=files, + options=[KeyValuePair(key=k, value=v) for k, v in (options or {}).items()], + clustering_info=ClusteringInfo.SerializeToString(c), + )) + self._intercept_resp(resp) + if self._is_json(): + return json_format.MessageToJson(resp) + return resp + + def get_bulk_insert_state(self, *, + task_id: str = "", + ) -> Union[GetImportStateResponse, str]: + resp = self.stub.GetImportState(GetImportStateRequest( + task=task_id, + )) + self._intercept_resp(resp) + if self._is_json(): + return json_format.MessageToJson(resp) + return resp + + def list_bulk_insert_tasks(self, *, + db_name: str = "", + collection_name: str = "", + limit: int = 0, + ) -> Union[ListImportTasksResponse, str]: + _db_name = db_name or self._db_name() + _collection_name = collection_name or self._collection_name() + resp = self.stub.ListImportTasks(ListImportTasksRequest( + db_name=_db_name, + collection_name=_collection_name, + limit=limit, + )) + self._intercept_resp(resp) + if self._is_json(): + return json_format.MessageToJson(resp) + return resp + + def create_user(self, *, + username: str = "", + password: str = "", + ) -> Union[Status, str]: + resp = self.stub.CreateCredential(CreateCredentialRequest( + username=username, + password=base64.b64encode(password.encode("utf-8")), + )) + self._intercept_resp(resp) + if self._is_json(): + return json_format.MessageToJson(resp) + return resp + + def update_user(self, *, + username: str = "", + old_password: str = "", + new_password: str = "", + ) -> Union[Status, str]: + resp = self.stub.UpdateCredential(UpdateCredentialRequest( + username=username, + oldPassword=base64.b64encode(old_password.encode("utf-8")), + newPassword=base64.b64encode(new_password.encode("utf-8")), + )) + self._intercept_resp(resp) + if self._is_json(): + return json_format.MessageToJson(resp) + return resp + + def delete_user(self, *, + username: str = "", + ) -> Union[Status, str]: + resp = self.stub.DeleteCredential(DeleteCredentialRequest( + username=username, + )) + self._intercept_resp(resp) + if self._is_json(): + return json_format.MessageToJson(resp) + return resp + + def list_users(self) -> Union[ListCredUsersResponse, str]: + resp = self.stub.ListCredentials(ListCredUsersRequest()) + self._intercept_resp(resp) + if self._is_json(): + return json_format.MessageToJson(resp) + return resp + + def create_role(self, *, + role_name: str = "", + ) -> Union[Status, str]: + resp = self.stub.CreateRole(CreateRoleRequest( + entity=RoleEntity(name=role_name), + )) + self._intercept_resp(resp) + if self._is_json(): + return json_format.MessageToJson(resp) + return resp + + def drop_role(self, *, + role_name: str = "", + ) -> Union[Status, str]: + resp = self.stub.DropRole(DropRoleRequest( + role_name=role_name, + )) + self._intercept_resp(resp) + if self._is_json(): + return json_format.MessageToJson(resp) + return resp + + def operate_user_role(self, *, + username: str = "", + role_name: str = "", + action: Union[str, Literal[ + "add_user_to_role", + "remove_user_from_role", + ]] = "add_user_to_role", + ) -> Union[Status, str]: + if action not in ["add_user_to_role", "remove_user_from_role"]: + raise ValueError(f"Invalid action: {action}") + resp = self.stub.OperateUserRole(OperateUserRoleRequest( + username=username, + role_name=role_name, + type=OperateUserRoleType.AddUserToRole if action == "add_user_to_role" else OperateUserRoleType.RemoveUserFromRole, + )) + self._intercept_resp(resp) + if self._is_json(): + return json_format.MessageToJson(resp) + return resp + + def select_user(self, *, + username: str = "", + include_role_info: bool = False, + ) -> Union[SelectUserResponse, str]: + resp = self.stub.SelectUser(SelectUserRequest( + user=UserEntity(name=username) if username else None, + include_role_info=include_role_info, + )) + self._intercept_resp(resp) + if self._is_json(): + return json_format.MessageToJson(resp) + return resp + + def select_role(self, *, + role_name: str = "", + include_user_info: bool = False, + ) -> Union[SelectRoleResponse, str]: + resp = self.stub.SelectRole(SelectRoleRequest( + role=RoleEntity(name=role_name) if role_name else None, + include_user_info=include_user_info, + )) + self._intercept_resp(resp) + if self._is_json(): + return json_format.MessageToJson(resp) + return resp + + def operate_privilege(self, *, + db_name: str = "", + role_name: str = "", + object_type: Union[str, Literal[ + "collection", + "global", + "user", + ]] = "collection", + object_name: str = "", + privilege: Union[COLLECTION_PRIVILEGE, + GLOBAL_PRIVILEGE, + USER_PRIVILEGE] = "DescribeCollection", + action: Union[str, Literal[ + "grant", + "revoke", + ]] = "grant", + ) -> Union[Status, str]: + if action not in ["grant", "revoke"]: + raise ValueError(f"Invalid action: {action}") + if not privilege: + raise ValueError("Privilege is required, more details: https://milvus.io/docs/users_and_roles.md#Users-and-Roles") + _db_name = db_name or self._db_name() + resp = self.stub.OperatePrivilege(OperatePrivilegeRequest( + entity=GrantEntity( + db_name=_db_name, + role=RoleEntity(name=role_name), + object=ObjectEntity(name=object_type.capitalize()), + object_name=object_name, + grantor=GrantorEntity( + privilege=PrivilegeEntity(name=privilege), + ), + ), + type=OperatePrivilegeType.Grant if action == "grant" else OperatePrivilegeType.Revoke, + )) + self._intercept_resp(resp) + if self._is_json(): + return json_format.MessageToJson(resp) + return resp + + def select_grant(self, *, + db_name: str = "", + role_name: str = "", + object_type: Union[str, Literal[ + "collection", + "global", + "user", + ]] = "collection", + object_name: str = "", + privilege: Union[COLLECTION_PRIVILEGE, + GLOBAL_PRIVILEGE, + USER_PRIVILEGE] = "", + ) -> Union[SelectGrantResponse, str]: + _db_name = db_name or self._db_name() + resp = self.stub.SelectGrant(SelectGrantRequest( + entity=GrantEntity( + db_name=_db_name, + role=RoleEntity(name=role_name) if role_name else None, + object=ObjectEntity(name=object_type) if object_type else None, + object_name=object_name if object_name else None, + grantor=GrantorEntity( + privilege=PrivilegeEntity(name=privilege), + ) if privilege else None, + ), + )) + self._intercept_resp(resp) + if self._is_json(): + return json_format.MessageToJson(resp) + return resp + + def get_version(self) -> Union[GetVersionResponse, str]: + resp = self.stub.GetVersion(GetVersionRequest()) + self._intercept_resp(resp) + if self._is_json(): + return json_format.MessageToJson(resp) + return resp + + def check_health(self) -> Union[CheckHealthResponse, str]: + resp = self.stub.CheckHealth(CheckHealthRequest()) + self._intercept_resp(resp) + if self._is_json(): + return json_format.MessageToJson(resp) + return resp + + def create_resource_group(self, *, + name: str = "", + ) -> Union[Status, str]: + resp = self.stub.CreateResourceGroup(CreateResourceGroupRequest( + resource_group=name, + )) + self._intercept_resp(resp) + if self._is_json(): + return json_format.MessageToJson(resp) + return resp + + def drop_resource_group(self, *, + name: str = "", + ) -> Union[Status, str]: + resp = self.stub.DropResourceGroup(DropResourceGroupRequest( + resource_group=name, + )) + self._intercept_resp(resp) + if self._is_json(): + return json_format.MessageToJson(resp) + return resp + + def transfer_node(self, *, + source_resource_group: str = "", + dst_resource_group: str = "", + num_node: int = 0, + ) -> Union[Status, str]: + resp = self.stub.TransferNode(TransferNodeRequest( + source_resource_group=source_resource_group, + dst_resource_group=dst_resource_group, + num_node=num_node, + )) + self._intercept_resp(resp) + if self._is_json(): + return json_format.MessageToJson(resp) + return resp + + def transfer_replica(self, *, + db_name: str = "", + collection_name: str = "", + source_resource_group: str = "", + dst_resource_group: str = "", + num_replica: int = 0, + ) -> Union[Status, str]: + _db_name = db_name or self._db_name() + _collection_name = collection_name or self._collection_name() + resp = self.stub.TransferReplica(TransferReplicaRequest( + source_resource_group=source_resource_group, + dst_resource_group=dst_resource_group, + num_replica=num_replica, + db_name=_db_name, + collection_name=_collection_name, + )) + self._intercept_resp(resp) + if self._is_json(): + return json_format.MessageToJson(resp) + return resp + + def list_resource_groups(self) -> Union[ListResourceGroupsResponse, str]: + resp = self.stub.ListResourceGroups(ListResourceGroupsRequest()) + self._intercept_resp(resp) + if self._is_json(): + return json_format.MessageToJson(resp) + return resp + + def describe_resource_group(self, *, + resource_group: str = "", + ) -> Union[DescribeResourceGroupResponse, str]: + resp = self.stub.DescribeResourceGroup(DescribeResourceGroupRequest( + resource_group=resource_group, + )) + self._intercept_resp(resp) + if self._is_json(): + return json_format.MessageToJson(resp) + return resp + + def rename_collection(self, *, + db_name: str = "", + new_db_name: str = "", + old_collection_name: str = "", + new_collection_name: str = "", + ) -> Union[Status, str]: + _db_name = db_name or self._db_name() + resp = self.stub.RenameCollection(RenameCollectionRequest( + db_name=_db_name, + newDBName=new_db_name, + oldName=old_collection_name, + newName=new_collection_name, + )) + self._intercept_resp(resp) + if self._is_json(): + return json_format.MessageToJson(resp) + return resp + + def list_indexed_segment(self, *, + collection_name: str = "", + index_name: str = "", + ) -> Union[ListIndexedSegmentResponse, str]: + _collection_name = collection_name or self._collection_name() + resp = self.stub.ListIndexedSegment(ListIndexedSegmentRequest( + collection_name=_collection_name, + index_name=index_name, + )) + self._intercept_resp(resp) + if self._is_json(): + return json_format.MessageToJson(resp) + return resp + + def describe_segment_index_data(self, *, + collection_name: str = "", + index_name: str = "", + segment_ids: List[int] = [], + ) -> Union[DescribeSegmentIndexDataResponse, str]: + _collection_name = collection_name or self._collection_name() + resp = self.stub.DescribeSegmentIndexData(DescribeSegmentIndexDataRequest( + collection_name=_collection_name, + index_name=index_name, + segmentsIDs=segment_ids, + )) + self._intercept_resp(resp) + if self._is_json(): + return json_format.MessageToJson(resp) + return resp + + # TODO it need to more information + def connect(self) -> Union[ConnectResponse, str]: + now = datetime.datetime.now() + resp = self.stub.Connect(ConnectRequest( + client_info=ClientInfo( + sdk_type="python", + sdk_version=f"connector-{VERSION}", + local_time=str(now), + ), + )) + self._intercept_resp(resp) + if self._is_json(): + return json_format.MessageToJson(resp) + return resp + + def alloc_timestamp(self) -> Union[AllocTimestampResponse, str]: + resp = self.stub.AllocTimestamp(AllocTimestampRequest()) + self._intercept_resp(resp) + if self._is_json(): + return json_format.MessageToJson(resp) + return resp + + def create_database(self, *, + db_name: str = "", + ) -> Union[Status, str]: + _db_name = db_name or self._db_name() + resp = self.stub.CreateDatabase(CreateDatabaseRequest( + db_name=_db_name, + )) + self._intercept_resp(resp) + if self._is_json(): + return json_format.MessageToJson(resp) + return resp + + def drop_database(self, *, + db_name: str = "", + ) -> Union[Status, str]: + _db_name = db_name or self._db_name() + resp = self.stub.DropDatabase(DropDatabaseRequest( + db_name=_db_name, + )) + self._intercept_resp(resp) + if self._is_json(): + return json_format.MessageToJson(resp) + return resp + + def list_databases(self) -> Union[ListDatabasesResponse, str]: + resp = self.stub.ListDatabases(ListDatabasesRequest()) + self._intercept_resp(resp) + if self._is_json(): + return json_format.MessageToJson(resp) + return resp + + def replicate_message(self, *, + channel_name: str = "", + ) -> Union[ReplicateMessageResponse, str]: + resp = self.stub.ReplicateMessage(ReplicateMessageRequest( + channel_name=channel_name, + )) + self._intercept_resp(resp) + if self._is_json(): + return json_format.MessageToJson(resp) + return resp \ No newline at end of file diff --git a/milvus_connector/core/util.py b/milvus_connector/core/util.py new file mode 100644 index 0000000..f00ce23 --- /dev/null +++ b/milvus_connector/core/util.py @@ -0,0 +1,419 @@ +import random +from typing import Any, Dict, List, Union +from abc import ABCMeta, abstractmethod + +from ._types import * +from ..protocol.schema_pb2 import * +from ..protocol.common_pb2 import * + +class CollectionField: + obj: FieldSchema + + def __init__(self, *, + name: str, + is_primary_key: bool = False, + dtype: DTYPE = "int64", + desc: str = "", + dim: int = 0, + max_length: int = 0, + type_params: Union[None, Dict[str, str]] = None, + auto_id: bool = False, + is_dynamic: bool = False, + is_partition_key: bool = False, + is_cluster_key: bool = False, + ): + if dtype in ("binary_vector", "float_vector", "float16_vector", "bfloat16_vector", "sparse_vector") and dim == 0: + raise ValueError(f"Dimension should be specified for {dtype} field") + if dtype in ("string", "varchar") and max_length == 0: + raise ValueError(f"Max length should be specified for {dtype} field") + type_params = type_params or {} + if dim > 0: + type_params["dim"] = str(dim) + if max_length > 0: + type_params["max_length"] = str(max_length) + self.obj = FieldSchema( + name=name, + is_primary_key=is_primary_key, + data_type=get_data_type(dtype), + description=desc, + type_params=[KeyValuePair(key=k, value=v) for k, v in (type_params or {}).items()], + autoID=auto_id, + is_dynamic=is_dynamic, + is_partition_key=is_partition_key, + is_clustering_key=is_cluster_key, + ) + +class Data(metaclass=ABCMeta): + dtype: DataType + field_name: str + is_dynamic: bool + + def __init__(self, field_name: str, dtype: DTYPE, is_dynamic: bool = False): + self.field_name = field_name + self.is_dynamic = is_dynamic + self.dtype = get_data_type(dtype) + + @abstractmethod + def construct_data(self)-> FieldData: + pass + +class VectorData(Data): + pass + +class FloatVectorData(VectorData): + data: List[List[float]] + + def __init__(self, *, + field_name: str, + dtype: str, + data: List[List[float]], + is_dynamic: bool = False): + if dtype not in ("float_vector", "floatvector"): + raise ValueError(f"the expect: float_vector, current: {dtype}") + super().__init__(field_name, dtype, is_dynamic) + self.data = data + + def construct_data(self) -> FieldData: + dim = len(self.data[0]) + b :List[float] = [] + for d in self.data: + b.extend(d) + return FieldData( + type=self.dtype, + field_name=self.field_name, + vectors=VectorField( + dim=dim, + float_vector=FloatArray(data=b), + ), + is_dynamic=self.is_dynamic, + ) + +class ByteVectorData(VectorData): + data: List[bytes] + def __init__(self, *, + field_name: str, + dtype: str, + data: List[bytes], + is_dynamic: bool = False): + if dtype not in ("binary_vector", "float16_vector", "bfloat16_vector"): + raise ValueError(f"the expect: binary_vector, float16_vector, bfloat16_vector, current: {dtype}") + super().__init__(field_name, dtype, is_dynamic) + self.data = data + + def construct_data(self) -> FieldData: + b :bytes = [] + for d in self.data: + b.extend(d) + + match self.dtype: + case "binary_vector": + return FieldData( + type=self.dtype, + field_name=self.field_name, + vectors=VectorField( + dim=len(self.data[0]) * 8, + binary_vector=b, + ), + is_dynamic=self.is_dynamic, + ) + case "float16_vector": + return FieldData( + type=self.dtype, + field_name=self.field_name, + vectors=VectorField( + dim=len(self.data[0]) // 2, + float16_vector=b, + ), + is_dynamic=self.is_dynamic, + ) + case "bfloat16_vector": + return FieldData( + type=self.dtype, + field_name=self.field_name, + vectors=VectorField( + dim=len(self.data[0]) // 2, + bfloat16_vector=b, + ), + is_dynamic=self.is_dynamic, + ) + case (_): + raise ValueError(f"Invalid data type: {self.dtype}") + +class ScalarData(Data): + pass + +class BoolData(ScalarData): + data: List[bool] + + def __init__(self, *, + field_name: str, + dtype: str, + data: List[bool], + is_dynamic: bool = False): + if dtype not in ("bool"): + raise ValueError(f"the expect: bool, current: {dtype}") + super().__init__(field_name, dtype, is_dynamic) + self.data = data + + def construct_data(self) -> FieldData: + return FieldData( + type=self.dtype, + field_name=self.field_name, + scalars=ScalarField( + bool_data=BoolArray(data=self.data), + ), + is_dynamic=self.is_dynamic, + ) + +class IntData(ScalarData): + data: List[int] + + def __init__(self, *, + field_name: str, + dtype: str, + data: List[int], + is_dynamic: bool = False): + if dtype not in ("int8", "int16", "int32"): + raise ValueError(f"the expect: int8, int16, int32, current: {dtype}") + super().__init__(field_name, dtype, is_dynamic) + self.data = data + + def construct_data(self) -> FieldData: + return FieldData( + type=self.dtype, + field_name=self.field_name, + scalars=ScalarField( + int_data=IntArray(data=self.data), + ), + is_dynamic=self.is_dynamic, + ) + +class LongData(ScalarData): + data: List[int] + + def __init__(self, *, + field_name: str, + dtype: str, + data: List[int], + is_dynamic: bool = False): + if dtype not in ("int64"): + raise ValueError(f"the expect: int64, current: {dtype}") + super().__init__(field_name, dtype, is_dynamic) + self.data = data + + def construct_data(self) -> FieldData: + return FieldData( + type=self.dtype, + field_name=self.field_name, + scalars=ScalarField( + long_data=LongArray(data=self.data), + ), + is_dynamic=self.is_dynamic, + ) + +class FloatData(ScalarData): + data: List[float] + + def __init__(self, *, + field_name: str, + dtype: str, + data: List[float], + is_dynamic: bool = False): + if dtype not in ("float"): + raise ValueError(f"the expect: float, current: {dtype}") + super().__init__(field_name, dtype, is_dynamic) + self.data = data + + def construct_data(self) -> FieldData: + return FieldData( + type=self.dtype, + field_name=self.field_name, + scalars=ScalarField( + float_data=FloatArray(data=self.data), + ), + is_dynamic=self.is_dynamic, + ) + +class DoubleData(ScalarData): + data: List[float] + + def __init__(self, *, + field_name: str, + dtype: str, + data: List[float], + is_dynamic: bool = False): + if dtype not in ("double"): + raise ValueError(f"the expect: double, current: {dtype}") + super().__init__(field_name, dtype, is_dynamic) + self.data = data + + def construct_data(self) -> FieldData: + return FieldData( + type=self.dtype, + field_name=self.field_name, + scalars=ScalarField( + double_data=DoubleArray(data=self.data), + ), + is_dynamic=self.is_dynamic, + ) + +class StringData(ScalarData): + data: List[str] + + def __init__(self, *, + field_name: str, + dtype: str, + data: List[str], + is_dynamic: bool = False): + if dtype not in ("string", "varchar"): + raise ValueError(f"the expect: string, varchar, current: {dtype}") + super().__init__(field_name, dtype, is_dynamic) + self.data = data + + def construct_data(self) -> FieldData: + return FieldData( + type=self.dtype, + field_name=self.field_name, + scalars=ScalarField( + string_data=StringArray(data=self.data), + ), + is_dynamic=self.is_dynamic, + ) + +class JSONData(ScalarData): + data: List[str] + + def __init__(self, *, + field_name: str, + dtype: str, + data: List[str], + is_dynamic: bool = False): + if dtype not in ("json"): + raise ValueError(f"the expect: json, current: {dtype}") + super().__init__(field_name, dtype, is_dynamic) + self.data = data + + def construct_data(self) -> FieldData: + return FieldData( + type=self.dtype, + field_name=self.field_name, + scalars=ScalarField( + json_data=JSONArray(data=[bytes(d, "utf-8") for d in self.data]), + ), + is_dynamic=self.is_dynamic, + ) + +class ArrayData(ScalarData): + data: List[ScalarData] + + def __init__(self, *, + field_name: str, + dtype: str, + element_type: str, + data: List[ScalarData], + is_dynamic: bool = False): + if dtype not in ("array"): + raise ValueError(f"the expect: array, current: {dtype}") + super().__init__(field_name, dtype, is_dynamic) + self.data = data + + def construct_data(self) -> FieldData: + return FieldData( + type=self.dtype, + field_name=self.field_name, + scalars=ScalarField( + array_data=ArrayArray( + element_type=get_data_type(self.element_type), + data=self.data, + ), + ), + is_dynamic=self.is_dynamic, + ) + +def ok(s: Status) -> bool: + return s.code == 0 and s.error_code == Success + +def construct_data(field_name: str, data_type: DataType, data: List) -> Data: + dtype_str = DataType.Name(data_type).lower() + match data_type: + case DataType.Bool: + return BoolData(field_name=field_name, + dtype=dtype_str, + data=data) + case DataType.Int8 | DataType.Int16 | DataType.Int32: + return IntData(field_name=field_name, + dtype=dtype_str, + data=data) + case DataType.Int64: + return LongData(field_name=field_name, + dtype=dtype_str, + data=data) + case DataType.Float: + return FloatData(field_name=field_name, + dtype=dtype_str, + data=data) + case DataType.Double: + return DoubleData(field_name=field_name, + dtype=dtype_str, + data=data) + case DataType.String | DataType.VarChar: + return StringData(field_name=field_name, + dtype=dtype_str, + data=data) + case DataType.FloatVector: + return FloatVectorData(field_name=field_name, + dtype=dtype_str, + data=data) + case (_): + raise ValueError(f"Invalid data type: {data_type}") + +def generate_random_data(row_num: int, field_name: str, data_type: DataType, dim: int = 0) -> Data: + dtype_str = DataType.Name(data_type).lower() + match data_type: + case DataType.Bool: + return BoolData(field_name=field_name, + dtype=dtype_str, + data=[random.choice([True, False]) for _ in range(row_num)]) + case DataType.Int8 | DataType.Int16 | DataType.Int32: + return IntData(field_name=field_name, + dtype=dtype_str, + data=[random.randint(-128, 127) for _ in range(row_num)]) + case DataType.Int64: + return LongData(field_name=field_name, + dtype=dtype_str, + data=[random.randint(-128, 127) for _ in range(row_num)]) + case DataType.Float: + return FloatData(field_name=field_name, + dtype=dtype_str, + data=[random.random() for _ in range(row_num)]) + case DataType.Double: + return DoubleData(field_name=field_name, + dtype=dtype_str, + data=[random.random() for _ in range(row_num)]) + case DataType.String | DataType.VarChar: + return StringData(field_name=field_name, + dtype=dtype_str, + data=[str(random.randint(0, 1000)) for _ in range(row_num)]) + case DataType.FloatVector: + if dim <= 0: + raise ValueError("Dimension should be specified for float_vector field") + return FloatVectorData(field_name=field_name, + dtype=dtype_str, + data=[[random.random() for _ in range(dim)] for _ in range(row_num)]) + case (_): + raise ValueError(f"Random generation, not support data type: {dtype_str}") + +def convert_data(data_type: DataType, data_str: str) -> Any: + match data_type: + case DataType.Bool: + return bool(data_str) + case DataType.Int8 | DataType.Int16 | DataType.Int32 | DataType.Int64: + return int(data_str) + case DataType.Float | DataType.Double: + return float(data_str) + case DataType.String | DataType.VarChar: + return data_str + case DataType.FloatVector: + return [[float(d) for d in data_str.split(",")]] + case (_): + raise ValueError(f"Invalid data type: {data_type}") \ No newline at end of file diff --git a/milvus_connector/protocol/__init__.py b/milvus_connector/protocol/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/milvus_connector/protocol/common_pb2.py b/milvus_connector/protocol/common_pb2.py new file mode 100644 index 0000000..596eff3 --- /dev/null +++ b/milvus_connector/protocol/common_pb2.py @@ -0,0 +1,104 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: common.proto +# Protobuf Python Version: 4.25.1 +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from google.protobuf import descriptor_pb2 as google_dot_protobuf_dot_descriptor__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x0c\x63ommon.proto\x12\x13milvus.proto.common\x1a google/protobuf/descriptor.proto\"\xf3\x01\n\x06Status\x12\x36\n\nerror_code\x18\x01 \x01(\x0e\x32\x1e.milvus.proto.common.ErrorCodeB\x02\x18\x01\x12\x0e\n\x06reason\x18\x02 \x01(\t\x12\x0c\n\x04\x63ode\x18\x03 \x01(\x05\x12\x11\n\tretriable\x18\x04 \x01(\x08\x12\x0e\n\x06\x64\x65tail\x18\x05 \x01(\t\x12>\n\nextra_info\x18\x06 \x03(\x0b\x32*.milvus.proto.common.Status.ExtraInfoEntry\x1a\x30\n\x0e\x45xtraInfoEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01\"*\n\x0cKeyValuePair\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t\"(\n\x0bKeyDataPair\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\x0c\n\x04\x64\x61ta\x18\x02 \x01(\x0c\"\x15\n\x04\x42lob\x12\r\n\x05value\x18\x01 \x01(\x0c\"c\n\x10PlaceholderValue\x12\x0b\n\x03tag\x18\x01 \x01(\t\x12\x32\n\x04type\x18\x02 \x01(\x0e\x32$.milvus.proto.common.PlaceholderType\x12\x0e\n\x06values\x18\x03 \x03(\x0c\"O\n\x10PlaceholderGroup\x12;\n\x0cplaceholders\x18\x01 \x03(\x0b\x32%.milvus.proto.common.PlaceholderValue\"#\n\x07\x41\x64\x64ress\x12\n\n\x02ip\x18\x01 \x01(\t\x12\x0c\n\x04port\x18\x02 \x01(\x03\"\xaf\x02\n\x07MsgBase\x12.\n\x08msg_type\x18\x01 \x01(\x0e\x32\x1c.milvus.proto.common.MsgType\x12\r\n\x05msgID\x18\x02 \x01(\x03\x12\x11\n\ttimestamp\x18\x03 \x01(\x04\x12\x10\n\x08sourceID\x18\x04 \x01(\x03\x12\x10\n\x08targetID\x18\x05 \x01(\x03\x12@\n\nproperties\x18\x06 \x03(\x0b\x32,.milvus.proto.common.MsgBase.PropertiesEntry\x12\x39\n\rreplicateInfo\x18\x07 \x01(\x0b\x32\".milvus.proto.common.ReplicateInfo\x1a\x31\n\x0fPropertiesEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01\":\n\rReplicateInfo\x12\x13\n\x0bisReplicate\x18\x01 \x01(\x08\x12\x14\n\x0cmsgTimestamp\x18\x02 \x01(\x04\"7\n\tMsgHeader\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\"M\n\x0c\x44MLMsgHeader\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x11\n\tshardName\x18\x02 \x01(\t\"\xbb\x01\n\x0cPrivilegeExt\x12\x34\n\x0bobject_type\x18\x01 \x01(\x0e\x32\x1f.milvus.proto.common.ObjectType\x12>\n\x10object_privilege\x18\x02 \x01(\x0e\x32$.milvus.proto.common.ObjectPrivilege\x12\x19\n\x11object_name_index\x18\x03 \x01(\x05\x12\x1a\n\x12object_name_indexs\x18\x04 \x01(\x05\"2\n\x0cSegmentStats\x12\x11\n\tSegmentID\x18\x01 \x01(\x03\x12\x0f\n\x07NumRows\x18\x02 \x01(\x03\"\xd5\x01\n\nClientInfo\x12\x10\n\x08sdk_type\x18\x01 \x01(\t\x12\x13\n\x0bsdk_version\x18\x02 \x01(\t\x12\x12\n\nlocal_time\x18\x03 \x01(\t\x12\x0c\n\x04user\x18\x04 \x01(\t\x12\x0c\n\x04host\x18\x05 \x01(\t\x12?\n\x08reserved\x18\x06 \x03(\x0b\x32-.milvus.proto.common.ClientInfo.ReservedEntry\x1a/\n\rReservedEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01\"\xe3\x01\n\nServerInfo\x12\x12\n\nbuild_tags\x18\x01 \x01(\t\x12\x12\n\nbuild_time\x18\x02 \x01(\t\x12\x12\n\ngit_commit\x18\x03 \x01(\t\x12\x12\n\ngo_version\x18\x04 \x01(\t\x12\x13\n\x0b\x64\x65ploy_mode\x18\x05 \x01(\t\x12?\n\x08reserved\x18\x06 \x03(\x0b\x32-.milvus.proto.common.ServerInfo.ReservedEntry\x1a/\n\rReservedEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01\"=\n\x08NodeInfo\x12\x0e\n\x06nodeID\x18\x01 \x01(\x03\x12\x0f\n\x07\x61\x64\x64ress\x18\x02 \x01(\t\x12\x10\n\x08hostname\x18\x03 \x01(\t*\xc7\n\n\tErrorCode\x12\x0b\n\x07Success\x10\x00\x12\x13\n\x0fUnexpectedError\x10\x01\x12\x11\n\rConnectFailed\x10\x02\x12\x14\n\x10PermissionDenied\x10\x03\x12\x17\n\x13\x43ollectionNotExists\x10\x04\x12\x13\n\x0fIllegalArgument\x10\x05\x12\x14\n\x10IllegalDimension\x10\x07\x12\x14\n\x10IllegalIndexType\x10\x08\x12\x19\n\x15IllegalCollectionName\x10\t\x12\x0f\n\x0bIllegalTOPK\x10\n\x12\x14\n\x10IllegalRowRecord\x10\x0b\x12\x13\n\x0fIllegalVectorID\x10\x0c\x12\x17\n\x13IllegalSearchResult\x10\r\x12\x10\n\x0c\x46ileNotFound\x10\x0e\x12\x0e\n\nMetaFailed\x10\x0f\x12\x0f\n\x0b\x43\x61\x63heFailed\x10\x10\x12\x16\n\x12\x43\x61nnotCreateFolder\x10\x11\x12\x14\n\x10\x43\x61nnotCreateFile\x10\x12\x12\x16\n\x12\x43\x61nnotDeleteFolder\x10\x13\x12\x14\n\x10\x43\x61nnotDeleteFile\x10\x14\x12\x13\n\x0f\x42uildIndexError\x10\x15\x12\x10\n\x0cIllegalNLIST\x10\x16\x12\x15\n\x11IllegalMetricType\x10\x17\x12\x0f\n\x0bOutOfMemory\x10\x18\x12\x11\n\rIndexNotExist\x10\x19\x12\x13\n\x0f\x45mptyCollection\x10\x1a\x12\x1b\n\x17UpdateImportTaskFailure\x10\x1b\x12\x1a\n\x16\x43ollectionNameNotFound\x10\x1c\x12\x1b\n\x17\x43reateCredentialFailure\x10\x1d\x12\x1b\n\x17UpdateCredentialFailure\x10\x1e\x12\x1b\n\x17\x44\x65leteCredentialFailure\x10\x1f\x12\x18\n\x14GetCredentialFailure\x10 \x12\x18\n\x14ListCredUsersFailure\x10!\x12\x12\n\x0eGetUserFailure\x10\"\x12\x15\n\x11\x43reateRoleFailure\x10#\x12\x13\n\x0f\x44ropRoleFailure\x10$\x12\x1a\n\x16OperateUserRoleFailure\x10%\x12\x15\n\x11SelectRoleFailure\x10&\x12\x15\n\x11SelectUserFailure\x10\'\x12\x19\n\x15SelectResourceFailure\x10(\x12\x1b\n\x17OperatePrivilegeFailure\x10)\x12\x16\n\x12SelectGrantFailure\x10*\x12!\n\x1dRefreshPolicyInfoCacheFailure\x10+\x12\x15\n\x11ListPolicyFailure\x10,\x12\x12\n\x0eNotShardLeader\x10-\x12\x16\n\x12NoReplicaAvailable\x10.\x12\x13\n\x0fSegmentNotFound\x10/\x12\r\n\tForceDeny\x10\x30\x12\r\n\tRateLimit\x10\x31\x12\x12\n\x0eNodeIDNotMatch\x10\x32\x12\x14\n\x10UpsertAutoIDTrue\x10\x33\x12\x1c\n\x18InsufficientMemoryToLoad\x10\x34\x12\x18\n\x14MemoryQuotaExhausted\x10\x35\x12\x16\n\x12\x44iskQuotaExhausted\x10\x36\x12\x15\n\x11TimeTickLongDelay\x10\x37\x12\x11\n\rNotReadyServe\x10\x38\x12\x1b\n\x17NotReadyCoordActivating\x10\x39\x12\x0f\n\x0b\x44\x61taCoordNA\x10\x64\x12\x12\n\rDDRequestRace\x10\xe8\x07\x1a\x02\x18\x01*c\n\nIndexState\x12\x12\n\x0eIndexStateNone\x10\x00\x12\x0c\n\x08Unissued\x10\x01\x12\x0e\n\nInProgress\x10\x02\x12\x0c\n\x08\x46inished\x10\x03\x12\n\n\x06\x46\x61iled\x10\x04\x12\t\n\x05Retry\x10\x05*\x82\x01\n\x0cSegmentState\x12\x14\n\x10SegmentStateNone\x10\x00\x12\x0c\n\x08NotExist\x10\x01\x12\x0b\n\x07Growing\x10\x02\x12\n\n\x06Sealed\x10\x03\x12\x0b\n\x07\x46lushed\x10\x04\x12\x0c\n\x08\x46lushing\x10\x05\x12\x0b\n\x07\x44ropped\x10\x06\x12\r\n\tImporting\x10\x07*\x94\x01\n\x0fPlaceholderType\x12\x08\n\x04None\x10\x00\x12\x10\n\x0c\x42inaryVector\x10\x64\x12\x0f\n\x0b\x46loatVector\x10\x65\x12\x11\n\rFloat16Vector\x10\x66\x12\x12\n\x0e\x42\x46loat16Vector\x10g\x12\x15\n\x11SparseFloatVector\x10h\x12\t\n\x05Int64\x10\x05\x12\x0b\n\x07VarChar\x10\x15*\xe0\x10\n\x07MsgType\x12\r\n\tUndefined\x10\x00\x12\x14\n\x10\x43reateCollection\x10\x64\x12\x12\n\x0e\x44ropCollection\x10\x65\x12\x11\n\rHasCollection\x10\x66\x12\x16\n\x12\x44\x65scribeCollection\x10g\x12\x13\n\x0fShowCollections\x10h\x12\x14\n\x10GetSystemConfigs\x10i\x12\x12\n\x0eLoadCollection\x10j\x12\x15\n\x11ReleaseCollection\x10k\x12\x0f\n\x0b\x43reateAlias\x10l\x12\r\n\tDropAlias\x10m\x12\x0e\n\nAlterAlias\x10n\x12\x13\n\x0f\x41lterCollection\x10o\x12\x14\n\x10RenameCollection\x10p\x12\x11\n\rDescribeAlias\x10q\x12\x0f\n\x0bListAliases\x10r\x12\x14\n\x0f\x43reatePartition\x10\xc8\x01\x12\x12\n\rDropPartition\x10\xc9\x01\x12\x11\n\x0cHasPartition\x10\xca\x01\x12\x16\n\x11\x44\x65scribePartition\x10\xcb\x01\x12\x13\n\x0eShowPartitions\x10\xcc\x01\x12\x13\n\x0eLoadPartitions\x10\xcd\x01\x12\x16\n\x11ReleasePartitions\x10\xce\x01\x12\x11\n\x0cShowSegments\x10\xfa\x01\x12\x14\n\x0f\x44\x65scribeSegment\x10\xfb\x01\x12\x11\n\x0cLoadSegments\x10\xfc\x01\x12\x14\n\x0fReleaseSegments\x10\xfd\x01\x12\x14\n\x0fHandoffSegments\x10\xfe\x01\x12\x18\n\x13LoadBalanceSegments\x10\xff\x01\x12\x15\n\x10\x44\x65scribeSegments\x10\x80\x02\x12\x1c\n\x17\x46\x65\x64\x65rListIndexedSegment\x10\x81\x02\x12\"\n\x1d\x46\x65\x64\x65rDescribeSegmentIndexData\x10\x82\x02\x12\x10\n\x0b\x43reateIndex\x10\xac\x02\x12\x12\n\rDescribeIndex\x10\xad\x02\x12\x0e\n\tDropIndex\x10\xae\x02\x12\x17\n\x12GetIndexStatistics\x10\xaf\x02\x12\x0f\n\nAlterIndex\x10\xb0\x02\x12\x0b\n\x06Insert\x10\x90\x03\x12\x0b\n\x06\x44\x65lete\x10\x91\x03\x12\n\n\x05\x46lush\x10\x92\x03\x12\x17\n\x12ResendSegmentStats\x10\x93\x03\x12\x0b\n\x06Upsert\x10\x94\x03\x12\x0b\n\x06Search\x10\xf4\x03\x12\x11\n\x0cSearchResult\x10\xf5\x03\x12\x12\n\rGetIndexState\x10\xf6\x03\x12\x1a\n\x15GetIndexBuildProgress\x10\xf7\x03\x12\x1c\n\x17GetCollectionStatistics\x10\xf8\x03\x12\x1b\n\x16GetPartitionStatistics\x10\xf9\x03\x12\r\n\x08Retrieve\x10\xfa\x03\x12\x13\n\x0eRetrieveResult\x10\xfb\x03\x12\x14\n\x0fWatchDmChannels\x10\xfc\x03\x12\x15\n\x10RemoveDmChannels\x10\xfd\x03\x12\x17\n\x12WatchQueryChannels\x10\xfe\x03\x12\x18\n\x13RemoveQueryChannels\x10\xff\x03\x12\x1d\n\x18SealedSegmentsChangeInfo\x10\x80\x04\x12\x17\n\x12WatchDeltaChannels\x10\x81\x04\x12\x14\n\x0fGetShardLeaders\x10\x82\x04\x12\x10\n\x0bGetReplicas\x10\x83\x04\x12\x13\n\x0eUnsubDmChannel\x10\x84\x04\x12\x14\n\x0fGetDistribution\x10\x85\x04\x12\x15\n\x10SyncDistribution\x10\x86\x04\x12\x10\n\x0bSegmentInfo\x10\xd8\x04\x12\x0f\n\nSystemInfo\x10\xd9\x04\x12\x14\n\x0fGetRecoveryInfo\x10\xda\x04\x12\x14\n\x0fGetSegmentState\x10\xdb\x04\x12\r\n\x08TimeTick\x10\xb0\t\x12\x13\n\x0eQueryNodeStats\x10\xb1\t\x12\x0e\n\tLoadIndex\x10\xb2\t\x12\x0e\n\tRequestID\x10\xb3\t\x12\x0f\n\nRequestTSO\x10\xb4\t\x12\x14\n\x0f\x41llocateSegment\x10\xb5\t\x12\x16\n\x11SegmentStatistics\x10\xb6\t\x12\x15\n\x10SegmentFlushDone\x10\xb7\t\x12\x0f\n\nDataNodeTt\x10\xb8\t\x12\x0c\n\x07\x43onnect\x10\xb9\t\x12\x14\n\x0fListClientInfos\x10\xba\t\x12\x13\n\x0e\x41llocTimestamp\x10\xbb\t\x12\x15\n\x10\x43reateCredential\x10\xdc\x0b\x12\x12\n\rGetCredential\x10\xdd\x0b\x12\x15\n\x10\x44\x65leteCredential\x10\xde\x0b\x12\x15\n\x10UpdateCredential\x10\xdf\x0b\x12\x16\n\x11ListCredUsernames\x10\xe0\x0b\x12\x0f\n\nCreateRole\x10\xc0\x0c\x12\r\n\x08\x44ropRole\x10\xc1\x0c\x12\x14\n\x0fOperateUserRole\x10\xc2\x0c\x12\x0f\n\nSelectRole\x10\xc3\x0c\x12\x0f\n\nSelectUser\x10\xc4\x0c\x12\x13\n\x0eSelectResource\x10\xc5\x0c\x12\x15\n\x10OperatePrivilege\x10\xc6\x0c\x12\x10\n\x0bSelectGrant\x10\xc7\x0c\x12\x1b\n\x16RefreshPolicyInfoCache\x10\xc8\x0c\x12\x0f\n\nListPolicy\x10\xc9\x0c\x12\x18\n\x13\x43reateResourceGroup\x10\xa4\r\x12\x16\n\x11\x44ropResourceGroup\x10\xa5\r\x12\x17\n\x12ListResourceGroups\x10\xa6\r\x12\x1a\n\x15\x44\x65scribeResourceGroup\x10\xa7\r\x12\x11\n\x0cTransferNode\x10\xa8\r\x12\x14\n\x0fTransferReplica\x10\xa9\r\x12\x19\n\x14UpdateResourceGroups\x10\xaa\r\x12\x13\n\x0e\x43reateDatabase\x10\x89\x0e\x12\x11\n\x0c\x44ropDatabase\x10\x8a\x0e\x12\x12\n\rListDatabases\x10\x8b\x0e*\"\n\x07\x44slType\x12\x07\n\x03\x44sl\x10\x00\x12\x0e\n\nBoolExprV1\x10\x01*B\n\x0f\x43ompactionState\x12\x11\n\rUndefiedState\x10\x00\x12\r\n\tExecuting\x10\x01\x12\r\n\tCompleted\x10\x02*X\n\x10\x43onsistencyLevel\x12\n\n\x06Strong\x10\x00\x12\x0b\n\x07Session\x10\x01\x12\x0b\n\x07\x42ounded\x10\x02\x12\x0e\n\nEventually\x10\x03\x12\x0e\n\nCustomized\x10\x04*\x9e\x01\n\x0bImportState\x12\x11\n\rImportPending\x10\x00\x12\x10\n\x0cImportFailed\x10\x01\x12\x11\n\rImportStarted\x10\x02\x12\x13\n\x0fImportPersisted\x10\x05\x12\x11\n\rImportFlushed\x10\x08\x12\x13\n\x0fImportCompleted\x10\x06\x12\x1a\n\x16ImportFailedAndCleaned\x10\x07*2\n\nObjectType\x12\x0e\n\nCollection\x10\x00\x12\n\n\x06Global\x10\x01\x12\x08\n\x04User\x10\x02*\xba\n\n\x0fObjectPrivilege\x12\x10\n\x0cPrivilegeAll\x10\x00\x12\x1d\n\x19PrivilegeCreateCollection\x10\x01\x12\x1b\n\x17PrivilegeDropCollection\x10\x02\x12\x1f\n\x1bPrivilegeDescribeCollection\x10\x03\x12\x1c\n\x18PrivilegeShowCollections\x10\x04\x12\x11\n\rPrivilegeLoad\x10\x05\x12\x14\n\x10PrivilegeRelease\x10\x06\x12\x17\n\x13PrivilegeCompaction\x10\x07\x12\x13\n\x0fPrivilegeInsert\x10\x08\x12\x13\n\x0fPrivilegeDelete\x10\t\x12\x1a\n\x16PrivilegeGetStatistics\x10\n\x12\x18\n\x14PrivilegeCreateIndex\x10\x0b\x12\x18\n\x14PrivilegeIndexDetail\x10\x0c\x12\x16\n\x12PrivilegeDropIndex\x10\r\x12\x13\n\x0fPrivilegeSearch\x10\x0e\x12\x12\n\x0ePrivilegeFlush\x10\x0f\x12\x12\n\x0ePrivilegeQuery\x10\x10\x12\x18\n\x14PrivilegeLoadBalance\x10\x11\x12\x13\n\x0fPrivilegeImport\x10\x12\x12\x1c\n\x18PrivilegeCreateOwnership\x10\x13\x12\x17\n\x13PrivilegeUpdateUser\x10\x14\x12\x1a\n\x16PrivilegeDropOwnership\x10\x15\x12\x1c\n\x18PrivilegeSelectOwnership\x10\x16\x12\x1c\n\x18PrivilegeManageOwnership\x10\x17\x12\x17\n\x13PrivilegeSelectUser\x10\x18\x12\x13\n\x0fPrivilegeUpsert\x10\x19\x12 \n\x1cPrivilegeCreateResourceGroup\x10\x1a\x12\x1e\n\x1aPrivilegeDropResourceGroup\x10\x1b\x12\"\n\x1ePrivilegeDescribeResourceGroup\x10\x1c\x12\x1f\n\x1bPrivilegeListResourceGroups\x10\x1d\x12\x19\n\x15PrivilegeTransferNode\x10\x1e\x12\x1c\n\x18PrivilegeTransferReplica\x10\x1f\x12\x1f\n\x1bPrivilegeGetLoadingProgress\x10 \x12\x19\n\x15PrivilegeGetLoadState\x10!\x12\x1d\n\x19PrivilegeRenameCollection\x10\"\x12\x1b\n\x17PrivilegeCreateDatabase\x10#\x12\x19\n\x15PrivilegeDropDatabase\x10$\x12\x1a\n\x16PrivilegeListDatabases\x10%\x12\x15\n\x11PrivilegeFlushAll\x10&\x12\x1c\n\x18PrivilegeCreatePartition\x10\'\x12\x1a\n\x16PrivilegeDropPartition\x10(\x12\x1b\n\x17PrivilegeShowPartitions\x10)\x12\x19\n\x15PrivilegeHasPartition\x10*\x12\x1a\n\x16PrivilegeGetFlushState\x10+\x12\x18\n\x14PrivilegeCreateAlias\x10,\x12\x16\n\x12PrivilegeDropAlias\x10-\x12\x1a\n\x16PrivilegeDescribeAlias\x10.\x12\x18\n\x14PrivilegeListAliases\x10/\x12!\n\x1dPrivilegeUpdateResourceGroups\x10\x30*S\n\tStateCode\x12\x10\n\x0cInitializing\x10\x00\x12\x0b\n\x07Healthy\x10\x01\x12\x0c\n\x08\x41\x62normal\x10\x02\x12\x0b\n\x07StandBy\x10\x03\x12\x0c\n\x08Stopping\x10\x04*c\n\tLoadState\x12\x15\n\x11LoadStateNotExist\x10\x00\x12\x14\n\x10LoadStateNotLoad\x10\x01\x12\x14\n\x10LoadStateLoading\x10\x02\x12\x13\n\x0fLoadStateLoaded\x10\x03:^\n\x11privilege_ext_obj\x12\x1f.google.protobuf.MessageOptions\x18\xe9\x07 \x01(\x0b\x32!.milvus.proto.common.PrivilegeExtBm\n\x0eio.milvus.grpcB\x0b\x43ommonProtoP\x01Z4github.com/milvus-io/milvus-proto/go-api/v2/commonpb\xa0\x01\x01\xaa\x02\x12Milvus.Client.Grpcb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'common_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + _globals['DESCRIPTOR']._options = None + _globals['DESCRIPTOR']._serialized_options = b'\n\016io.milvus.grpcB\013CommonProtoP\001Z4github.com/milvus-io/milvus-proto/go-api/v2/commonpb\240\001\001\252\002\022Milvus.Client.Grpc' + _globals['_ERRORCODE']._options = None + _globals['_ERRORCODE']._serialized_options = b'\030\001' + _globals['_STATUS_EXTRAINFOENTRY']._options = None + _globals['_STATUS_EXTRAINFOENTRY']._serialized_options = b'8\001' + _globals['_STATUS'].fields_by_name['error_code']._options = None + _globals['_STATUS'].fields_by_name['error_code']._serialized_options = b'\030\001' + _globals['_MSGBASE_PROPERTIESENTRY']._options = None + _globals['_MSGBASE_PROPERTIESENTRY']._serialized_options = b'8\001' + _globals['_CLIENTINFO_RESERVEDENTRY']._options = None + _globals['_CLIENTINFO_RESERVEDENTRY']._serialized_options = b'8\001' + _globals['_SERVERINFO_RESERVEDENTRY']._options = None + _globals['_SERVERINFO_RESERVEDENTRY']._serialized_options = b'8\001' + _globals['_ERRORCODE']._serialized_start=1899 + _globals['_ERRORCODE']._serialized_end=3250 + _globals['_INDEXSTATE']._serialized_start=3252 + _globals['_INDEXSTATE']._serialized_end=3351 + _globals['_SEGMENTSTATE']._serialized_start=3354 + _globals['_SEGMENTSTATE']._serialized_end=3484 + _globals['_PLACEHOLDERTYPE']._serialized_start=3487 + _globals['_PLACEHOLDERTYPE']._serialized_end=3635 + _globals['_MSGTYPE']._serialized_start=3638 + _globals['_MSGTYPE']._serialized_end=5782 + _globals['_DSLTYPE']._serialized_start=5784 + _globals['_DSLTYPE']._serialized_end=5818 + _globals['_COMPACTIONSTATE']._serialized_start=5820 + _globals['_COMPACTIONSTATE']._serialized_end=5886 + _globals['_CONSISTENCYLEVEL']._serialized_start=5888 + _globals['_CONSISTENCYLEVEL']._serialized_end=5976 + _globals['_IMPORTSTATE']._serialized_start=5979 + _globals['_IMPORTSTATE']._serialized_end=6137 + _globals['_OBJECTTYPE']._serialized_start=6139 + _globals['_OBJECTTYPE']._serialized_end=6189 + _globals['_OBJECTPRIVILEGE']._serialized_start=6192 + _globals['_OBJECTPRIVILEGE']._serialized_end=7530 + _globals['_STATECODE']._serialized_start=7532 + _globals['_STATECODE']._serialized_end=7615 + _globals['_LOADSTATE']._serialized_start=7617 + _globals['_LOADSTATE']._serialized_end=7716 + _globals['_STATUS']._serialized_start=72 + _globals['_STATUS']._serialized_end=315 + _globals['_STATUS_EXTRAINFOENTRY']._serialized_start=267 + _globals['_STATUS_EXTRAINFOENTRY']._serialized_end=315 + _globals['_KEYVALUEPAIR']._serialized_start=317 + _globals['_KEYVALUEPAIR']._serialized_end=359 + _globals['_KEYDATAPAIR']._serialized_start=361 + _globals['_KEYDATAPAIR']._serialized_end=401 + _globals['_BLOB']._serialized_start=403 + _globals['_BLOB']._serialized_end=424 + _globals['_PLACEHOLDERVALUE']._serialized_start=426 + _globals['_PLACEHOLDERVALUE']._serialized_end=525 + _globals['_PLACEHOLDERGROUP']._serialized_start=527 + _globals['_PLACEHOLDERGROUP']._serialized_end=606 + _globals['_ADDRESS']._serialized_start=608 + _globals['_ADDRESS']._serialized_end=643 + _globals['_MSGBASE']._serialized_start=646 + _globals['_MSGBASE']._serialized_end=949 + _globals['_MSGBASE_PROPERTIESENTRY']._serialized_start=900 + _globals['_MSGBASE_PROPERTIESENTRY']._serialized_end=949 + _globals['_REPLICATEINFO']._serialized_start=951 + _globals['_REPLICATEINFO']._serialized_end=1009 + _globals['_MSGHEADER']._serialized_start=1011 + _globals['_MSGHEADER']._serialized_end=1066 + _globals['_DMLMSGHEADER']._serialized_start=1068 + _globals['_DMLMSGHEADER']._serialized_end=1145 + _globals['_PRIVILEGEEXT']._serialized_start=1148 + _globals['_PRIVILEGEEXT']._serialized_end=1335 + _globals['_SEGMENTSTATS']._serialized_start=1337 + _globals['_SEGMENTSTATS']._serialized_end=1387 + _globals['_CLIENTINFO']._serialized_start=1390 + _globals['_CLIENTINFO']._serialized_end=1603 + _globals['_CLIENTINFO_RESERVEDENTRY']._serialized_start=1556 + _globals['_CLIENTINFO_RESERVEDENTRY']._serialized_end=1603 + _globals['_SERVERINFO']._serialized_start=1606 + _globals['_SERVERINFO']._serialized_end=1833 + _globals['_SERVERINFO_RESERVEDENTRY']._serialized_start=1556 + _globals['_SERVERINFO_RESERVEDENTRY']._serialized_end=1603 + _globals['_NODEINFO']._serialized_start=1835 + _globals['_NODEINFO']._serialized_end=1896 +# @@protoc_insertion_point(module_scope) diff --git a/milvus_connector/protocol/common_pb2.pyi b/milvus_connector/protocol/common_pb2.pyi new file mode 100644 index 0000000..1fa1c69 --- /dev/null +++ b/milvus_connector/protocol/common_pb2.pyi @@ -0,0 +1,763 @@ +from google.protobuf import descriptor_pb2 as _descriptor_pb2 +from google.protobuf.internal import containers as _containers +from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Iterable as _Iterable, Mapping as _Mapping, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class ErrorCode(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = () + Success: _ClassVar[ErrorCode] + UnexpectedError: _ClassVar[ErrorCode] + ConnectFailed: _ClassVar[ErrorCode] + PermissionDenied: _ClassVar[ErrorCode] + CollectionNotExists: _ClassVar[ErrorCode] + IllegalArgument: _ClassVar[ErrorCode] + IllegalDimension: _ClassVar[ErrorCode] + IllegalIndexType: _ClassVar[ErrorCode] + IllegalCollectionName: _ClassVar[ErrorCode] + IllegalTOPK: _ClassVar[ErrorCode] + IllegalRowRecord: _ClassVar[ErrorCode] + IllegalVectorID: _ClassVar[ErrorCode] + IllegalSearchResult: _ClassVar[ErrorCode] + FileNotFound: _ClassVar[ErrorCode] + MetaFailed: _ClassVar[ErrorCode] + CacheFailed: _ClassVar[ErrorCode] + CannotCreateFolder: _ClassVar[ErrorCode] + CannotCreateFile: _ClassVar[ErrorCode] + CannotDeleteFolder: _ClassVar[ErrorCode] + CannotDeleteFile: _ClassVar[ErrorCode] + BuildIndexError: _ClassVar[ErrorCode] + IllegalNLIST: _ClassVar[ErrorCode] + IllegalMetricType: _ClassVar[ErrorCode] + OutOfMemory: _ClassVar[ErrorCode] + IndexNotExist: _ClassVar[ErrorCode] + EmptyCollection: _ClassVar[ErrorCode] + UpdateImportTaskFailure: _ClassVar[ErrorCode] + CollectionNameNotFound: _ClassVar[ErrorCode] + CreateCredentialFailure: _ClassVar[ErrorCode] + UpdateCredentialFailure: _ClassVar[ErrorCode] + DeleteCredentialFailure: _ClassVar[ErrorCode] + GetCredentialFailure: _ClassVar[ErrorCode] + ListCredUsersFailure: _ClassVar[ErrorCode] + GetUserFailure: _ClassVar[ErrorCode] + CreateRoleFailure: _ClassVar[ErrorCode] + DropRoleFailure: _ClassVar[ErrorCode] + OperateUserRoleFailure: _ClassVar[ErrorCode] + SelectRoleFailure: _ClassVar[ErrorCode] + SelectUserFailure: _ClassVar[ErrorCode] + SelectResourceFailure: _ClassVar[ErrorCode] + OperatePrivilegeFailure: _ClassVar[ErrorCode] + SelectGrantFailure: _ClassVar[ErrorCode] + RefreshPolicyInfoCacheFailure: _ClassVar[ErrorCode] + ListPolicyFailure: _ClassVar[ErrorCode] + NotShardLeader: _ClassVar[ErrorCode] + NoReplicaAvailable: _ClassVar[ErrorCode] + SegmentNotFound: _ClassVar[ErrorCode] + ForceDeny: _ClassVar[ErrorCode] + RateLimit: _ClassVar[ErrorCode] + NodeIDNotMatch: _ClassVar[ErrorCode] + UpsertAutoIDTrue: _ClassVar[ErrorCode] + InsufficientMemoryToLoad: _ClassVar[ErrorCode] + MemoryQuotaExhausted: _ClassVar[ErrorCode] + DiskQuotaExhausted: _ClassVar[ErrorCode] + TimeTickLongDelay: _ClassVar[ErrorCode] + NotReadyServe: _ClassVar[ErrorCode] + NotReadyCoordActivating: _ClassVar[ErrorCode] + DataCoordNA: _ClassVar[ErrorCode] + DDRequestRace: _ClassVar[ErrorCode] + +class IndexState(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = () + IndexStateNone: _ClassVar[IndexState] + Unissued: _ClassVar[IndexState] + InProgress: _ClassVar[IndexState] + Finished: _ClassVar[IndexState] + Failed: _ClassVar[IndexState] + Retry: _ClassVar[IndexState] + +class SegmentState(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = () + SegmentStateNone: _ClassVar[SegmentState] + NotExist: _ClassVar[SegmentState] + Growing: _ClassVar[SegmentState] + Sealed: _ClassVar[SegmentState] + Flushed: _ClassVar[SegmentState] + Flushing: _ClassVar[SegmentState] + Dropped: _ClassVar[SegmentState] + Importing: _ClassVar[SegmentState] + +class PlaceholderType(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = () + None: _ClassVar[PlaceholderType] + BinaryVector: _ClassVar[PlaceholderType] + FloatVector: _ClassVar[PlaceholderType] + Float16Vector: _ClassVar[PlaceholderType] + BFloat16Vector: _ClassVar[PlaceholderType] + SparseFloatVector: _ClassVar[PlaceholderType] + Int64: _ClassVar[PlaceholderType] + VarChar: _ClassVar[PlaceholderType] + +class MsgType(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = () + Undefined: _ClassVar[MsgType] + CreateCollection: _ClassVar[MsgType] + DropCollection: _ClassVar[MsgType] + HasCollection: _ClassVar[MsgType] + DescribeCollection: _ClassVar[MsgType] + ShowCollections: _ClassVar[MsgType] + GetSystemConfigs: _ClassVar[MsgType] + LoadCollection: _ClassVar[MsgType] + ReleaseCollection: _ClassVar[MsgType] + CreateAlias: _ClassVar[MsgType] + DropAlias: _ClassVar[MsgType] + AlterAlias: _ClassVar[MsgType] + AlterCollection: _ClassVar[MsgType] + RenameCollection: _ClassVar[MsgType] + DescribeAlias: _ClassVar[MsgType] + ListAliases: _ClassVar[MsgType] + CreatePartition: _ClassVar[MsgType] + DropPartition: _ClassVar[MsgType] + HasPartition: _ClassVar[MsgType] + DescribePartition: _ClassVar[MsgType] + ShowPartitions: _ClassVar[MsgType] + LoadPartitions: _ClassVar[MsgType] + ReleasePartitions: _ClassVar[MsgType] + ShowSegments: _ClassVar[MsgType] + DescribeSegment: _ClassVar[MsgType] + LoadSegments: _ClassVar[MsgType] + ReleaseSegments: _ClassVar[MsgType] + HandoffSegments: _ClassVar[MsgType] + LoadBalanceSegments: _ClassVar[MsgType] + DescribeSegments: _ClassVar[MsgType] + FederListIndexedSegment: _ClassVar[MsgType] + FederDescribeSegmentIndexData: _ClassVar[MsgType] + CreateIndex: _ClassVar[MsgType] + DescribeIndex: _ClassVar[MsgType] + DropIndex: _ClassVar[MsgType] + GetIndexStatistics: _ClassVar[MsgType] + AlterIndex: _ClassVar[MsgType] + Insert: _ClassVar[MsgType] + Delete: _ClassVar[MsgType] + Flush: _ClassVar[MsgType] + ResendSegmentStats: _ClassVar[MsgType] + Upsert: _ClassVar[MsgType] + Search: _ClassVar[MsgType] + SearchResult: _ClassVar[MsgType] + GetIndexState: _ClassVar[MsgType] + GetIndexBuildProgress: _ClassVar[MsgType] + GetCollectionStatistics: _ClassVar[MsgType] + GetPartitionStatistics: _ClassVar[MsgType] + Retrieve: _ClassVar[MsgType] + RetrieveResult: _ClassVar[MsgType] + WatchDmChannels: _ClassVar[MsgType] + RemoveDmChannels: _ClassVar[MsgType] + WatchQueryChannels: _ClassVar[MsgType] + RemoveQueryChannels: _ClassVar[MsgType] + SealedSegmentsChangeInfo: _ClassVar[MsgType] + WatchDeltaChannels: _ClassVar[MsgType] + GetShardLeaders: _ClassVar[MsgType] + GetReplicas: _ClassVar[MsgType] + UnsubDmChannel: _ClassVar[MsgType] + GetDistribution: _ClassVar[MsgType] + SyncDistribution: _ClassVar[MsgType] + SegmentInfo: _ClassVar[MsgType] + SystemInfo: _ClassVar[MsgType] + GetRecoveryInfo: _ClassVar[MsgType] + GetSegmentState: _ClassVar[MsgType] + TimeTick: _ClassVar[MsgType] + QueryNodeStats: _ClassVar[MsgType] + LoadIndex: _ClassVar[MsgType] + RequestID: _ClassVar[MsgType] + RequestTSO: _ClassVar[MsgType] + AllocateSegment: _ClassVar[MsgType] + SegmentStatistics: _ClassVar[MsgType] + SegmentFlushDone: _ClassVar[MsgType] + DataNodeTt: _ClassVar[MsgType] + Connect: _ClassVar[MsgType] + ListClientInfos: _ClassVar[MsgType] + AllocTimestamp: _ClassVar[MsgType] + CreateCredential: _ClassVar[MsgType] + GetCredential: _ClassVar[MsgType] + DeleteCredential: _ClassVar[MsgType] + UpdateCredential: _ClassVar[MsgType] + ListCredUsernames: _ClassVar[MsgType] + CreateRole: _ClassVar[MsgType] + DropRole: _ClassVar[MsgType] + OperateUserRole: _ClassVar[MsgType] + SelectRole: _ClassVar[MsgType] + SelectUser: _ClassVar[MsgType] + SelectResource: _ClassVar[MsgType] + OperatePrivilege: _ClassVar[MsgType] + SelectGrant: _ClassVar[MsgType] + RefreshPolicyInfoCache: _ClassVar[MsgType] + ListPolicy: _ClassVar[MsgType] + CreateResourceGroup: _ClassVar[MsgType] + DropResourceGroup: _ClassVar[MsgType] + ListResourceGroups: _ClassVar[MsgType] + DescribeResourceGroup: _ClassVar[MsgType] + TransferNode: _ClassVar[MsgType] + TransferReplica: _ClassVar[MsgType] + UpdateResourceGroups: _ClassVar[MsgType] + CreateDatabase: _ClassVar[MsgType] + DropDatabase: _ClassVar[MsgType] + ListDatabases: _ClassVar[MsgType] + +class DslType(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = () + Dsl: _ClassVar[DslType] + BoolExprV1: _ClassVar[DslType] + +class CompactionState(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = () + UndefiedState: _ClassVar[CompactionState] + Executing: _ClassVar[CompactionState] + Completed: _ClassVar[CompactionState] + +class ConsistencyLevel(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = () + Strong: _ClassVar[ConsistencyLevel] + Session: _ClassVar[ConsistencyLevel] + Bounded: _ClassVar[ConsistencyLevel] + Eventually: _ClassVar[ConsistencyLevel] + Customized: _ClassVar[ConsistencyLevel] + +class ImportState(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = () + ImportPending: _ClassVar[ImportState] + ImportFailed: _ClassVar[ImportState] + ImportStarted: _ClassVar[ImportState] + ImportPersisted: _ClassVar[ImportState] + ImportFlushed: _ClassVar[ImportState] + ImportCompleted: _ClassVar[ImportState] + ImportFailedAndCleaned: _ClassVar[ImportState] + +class ObjectType(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = () + Collection: _ClassVar[ObjectType] + Global: _ClassVar[ObjectType] + User: _ClassVar[ObjectType] + +class ObjectPrivilege(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = () + PrivilegeAll: _ClassVar[ObjectPrivilege] + PrivilegeCreateCollection: _ClassVar[ObjectPrivilege] + PrivilegeDropCollection: _ClassVar[ObjectPrivilege] + PrivilegeDescribeCollection: _ClassVar[ObjectPrivilege] + PrivilegeShowCollections: _ClassVar[ObjectPrivilege] + PrivilegeLoad: _ClassVar[ObjectPrivilege] + PrivilegeRelease: _ClassVar[ObjectPrivilege] + PrivilegeCompaction: _ClassVar[ObjectPrivilege] + PrivilegeInsert: _ClassVar[ObjectPrivilege] + PrivilegeDelete: _ClassVar[ObjectPrivilege] + PrivilegeGetStatistics: _ClassVar[ObjectPrivilege] + PrivilegeCreateIndex: _ClassVar[ObjectPrivilege] + PrivilegeIndexDetail: _ClassVar[ObjectPrivilege] + PrivilegeDropIndex: _ClassVar[ObjectPrivilege] + PrivilegeSearch: _ClassVar[ObjectPrivilege] + PrivilegeFlush: _ClassVar[ObjectPrivilege] + PrivilegeQuery: _ClassVar[ObjectPrivilege] + PrivilegeLoadBalance: _ClassVar[ObjectPrivilege] + PrivilegeImport: _ClassVar[ObjectPrivilege] + PrivilegeCreateOwnership: _ClassVar[ObjectPrivilege] + PrivilegeUpdateUser: _ClassVar[ObjectPrivilege] + PrivilegeDropOwnership: _ClassVar[ObjectPrivilege] + PrivilegeSelectOwnership: _ClassVar[ObjectPrivilege] + PrivilegeManageOwnership: _ClassVar[ObjectPrivilege] + PrivilegeSelectUser: _ClassVar[ObjectPrivilege] + PrivilegeUpsert: _ClassVar[ObjectPrivilege] + PrivilegeCreateResourceGroup: _ClassVar[ObjectPrivilege] + PrivilegeDropResourceGroup: _ClassVar[ObjectPrivilege] + PrivilegeDescribeResourceGroup: _ClassVar[ObjectPrivilege] + PrivilegeListResourceGroups: _ClassVar[ObjectPrivilege] + PrivilegeTransferNode: _ClassVar[ObjectPrivilege] + PrivilegeTransferReplica: _ClassVar[ObjectPrivilege] + PrivilegeGetLoadingProgress: _ClassVar[ObjectPrivilege] + PrivilegeGetLoadState: _ClassVar[ObjectPrivilege] + PrivilegeRenameCollection: _ClassVar[ObjectPrivilege] + PrivilegeCreateDatabase: _ClassVar[ObjectPrivilege] + PrivilegeDropDatabase: _ClassVar[ObjectPrivilege] + PrivilegeListDatabases: _ClassVar[ObjectPrivilege] + PrivilegeFlushAll: _ClassVar[ObjectPrivilege] + PrivilegeCreatePartition: _ClassVar[ObjectPrivilege] + PrivilegeDropPartition: _ClassVar[ObjectPrivilege] + PrivilegeShowPartitions: _ClassVar[ObjectPrivilege] + PrivilegeHasPartition: _ClassVar[ObjectPrivilege] + PrivilegeGetFlushState: _ClassVar[ObjectPrivilege] + PrivilegeCreateAlias: _ClassVar[ObjectPrivilege] + PrivilegeDropAlias: _ClassVar[ObjectPrivilege] + PrivilegeDescribeAlias: _ClassVar[ObjectPrivilege] + PrivilegeListAliases: _ClassVar[ObjectPrivilege] + PrivilegeUpdateResourceGroups: _ClassVar[ObjectPrivilege] + +class StateCode(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = () + Initializing: _ClassVar[StateCode] + Healthy: _ClassVar[StateCode] + Abnormal: _ClassVar[StateCode] + StandBy: _ClassVar[StateCode] + Stopping: _ClassVar[StateCode] + +class LoadState(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = () + LoadStateNotExist: _ClassVar[LoadState] + LoadStateNotLoad: _ClassVar[LoadState] + LoadStateLoading: _ClassVar[LoadState] + LoadStateLoaded: _ClassVar[LoadState] +Success: ErrorCode +UnexpectedError: ErrorCode +ConnectFailed: ErrorCode +PermissionDenied: ErrorCode +CollectionNotExists: ErrorCode +IllegalArgument: ErrorCode +IllegalDimension: ErrorCode +IllegalIndexType: ErrorCode +IllegalCollectionName: ErrorCode +IllegalTOPK: ErrorCode +IllegalRowRecord: ErrorCode +IllegalVectorID: ErrorCode +IllegalSearchResult: ErrorCode +FileNotFound: ErrorCode +MetaFailed: ErrorCode +CacheFailed: ErrorCode +CannotCreateFolder: ErrorCode +CannotCreateFile: ErrorCode +CannotDeleteFolder: ErrorCode +CannotDeleteFile: ErrorCode +BuildIndexError: ErrorCode +IllegalNLIST: ErrorCode +IllegalMetricType: ErrorCode +OutOfMemory: ErrorCode +IndexNotExist: ErrorCode +EmptyCollection: ErrorCode +UpdateImportTaskFailure: ErrorCode +CollectionNameNotFound: ErrorCode +CreateCredentialFailure: ErrorCode +UpdateCredentialFailure: ErrorCode +DeleteCredentialFailure: ErrorCode +GetCredentialFailure: ErrorCode +ListCredUsersFailure: ErrorCode +GetUserFailure: ErrorCode +CreateRoleFailure: ErrorCode +DropRoleFailure: ErrorCode +OperateUserRoleFailure: ErrorCode +SelectRoleFailure: ErrorCode +SelectUserFailure: ErrorCode +SelectResourceFailure: ErrorCode +OperatePrivilegeFailure: ErrorCode +SelectGrantFailure: ErrorCode +RefreshPolicyInfoCacheFailure: ErrorCode +ListPolicyFailure: ErrorCode +NotShardLeader: ErrorCode +NoReplicaAvailable: ErrorCode +SegmentNotFound: ErrorCode +ForceDeny: ErrorCode +RateLimit: ErrorCode +NodeIDNotMatch: ErrorCode +UpsertAutoIDTrue: ErrorCode +InsufficientMemoryToLoad: ErrorCode +MemoryQuotaExhausted: ErrorCode +DiskQuotaExhausted: ErrorCode +TimeTickLongDelay: ErrorCode +NotReadyServe: ErrorCode +NotReadyCoordActivating: ErrorCode +DataCoordNA: ErrorCode +DDRequestRace: ErrorCode +IndexStateNone: IndexState +Unissued: IndexState +InProgress: IndexState +Finished: IndexState +Failed: IndexState +Retry: IndexState +SegmentStateNone: SegmentState +NotExist: SegmentState +Growing: SegmentState +Sealed: SegmentState +Flushed: SegmentState +Flushing: SegmentState +Dropped: SegmentState +Importing: SegmentState +None: PlaceholderType +BinaryVector: PlaceholderType +FloatVector: PlaceholderType +Float16Vector: PlaceholderType +BFloat16Vector: PlaceholderType +SparseFloatVector: PlaceholderType +Int64: PlaceholderType +VarChar: PlaceholderType +Undefined: MsgType +CreateCollection: MsgType +DropCollection: MsgType +HasCollection: MsgType +DescribeCollection: MsgType +ShowCollections: MsgType +GetSystemConfigs: MsgType +LoadCollection: MsgType +ReleaseCollection: MsgType +CreateAlias: MsgType +DropAlias: MsgType +AlterAlias: MsgType +AlterCollection: MsgType +RenameCollection: MsgType +DescribeAlias: MsgType +ListAliases: MsgType +CreatePartition: MsgType +DropPartition: MsgType +HasPartition: MsgType +DescribePartition: MsgType +ShowPartitions: MsgType +LoadPartitions: MsgType +ReleasePartitions: MsgType +ShowSegments: MsgType +DescribeSegment: MsgType +LoadSegments: MsgType +ReleaseSegments: MsgType +HandoffSegments: MsgType +LoadBalanceSegments: MsgType +DescribeSegments: MsgType +FederListIndexedSegment: MsgType +FederDescribeSegmentIndexData: MsgType +CreateIndex: MsgType +DescribeIndex: MsgType +DropIndex: MsgType +GetIndexStatistics: MsgType +AlterIndex: MsgType +Insert: MsgType +Delete: MsgType +Flush: MsgType +ResendSegmentStats: MsgType +Upsert: MsgType +Search: MsgType +SearchResult: MsgType +GetIndexState: MsgType +GetIndexBuildProgress: MsgType +GetCollectionStatistics: MsgType +GetPartitionStatistics: MsgType +Retrieve: MsgType +RetrieveResult: MsgType +WatchDmChannels: MsgType +RemoveDmChannels: MsgType +WatchQueryChannels: MsgType +RemoveQueryChannels: MsgType +SealedSegmentsChangeInfo: MsgType +WatchDeltaChannels: MsgType +GetShardLeaders: MsgType +GetReplicas: MsgType +UnsubDmChannel: MsgType +GetDistribution: MsgType +SyncDistribution: MsgType +SegmentInfo: MsgType +SystemInfo: MsgType +GetRecoveryInfo: MsgType +GetSegmentState: MsgType +TimeTick: MsgType +QueryNodeStats: MsgType +LoadIndex: MsgType +RequestID: MsgType +RequestTSO: MsgType +AllocateSegment: MsgType +SegmentStatistics: MsgType +SegmentFlushDone: MsgType +DataNodeTt: MsgType +Connect: MsgType +ListClientInfos: MsgType +AllocTimestamp: MsgType +CreateCredential: MsgType +GetCredential: MsgType +DeleteCredential: MsgType +UpdateCredential: MsgType +ListCredUsernames: MsgType +CreateRole: MsgType +DropRole: MsgType +OperateUserRole: MsgType +SelectRole: MsgType +SelectUser: MsgType +SelectResource: MsgType +OperatePrivilege: MsgType +SelectGrant: MsgType +RefreshPolicyInfoCache: MsgType +ListPolicy: MsgType +CreateResourceGroup: MsgType +DropResourceGroup: MsgType +ListResourceGroups: MsgType +DescribeResourceGroup: MsgType +TransferNode: MsgType +TransferReplica: MsgType +UpdateResourceGroups: MsgType +CreateDatabase: MsgType +DropDatabase: MsgType +ListDatabases: MsgType +Dsl: DslType +BoolExprV1: DslType +UndefiedState: CompactionState +Executing: CompactionState +Completed: CompactionState +Strong: ConsistencyLevel +Session: ConsistencyLevel +Bounded: ConsistencyLevel +Eventually: ConsistencyLevel +Customized: ConsistencyLevel +ImportPending: ImportState +ImportFailed: ImportState +ImportStarted: ImportState +ImportPersisted: ImportState +ImportFlushed: ImportState +ImportCompleted: ImportState +ImportFailedAndCleaned: ImportState +Collection: ObjectType +Global: ObjectType +User: ObjectType +PrivilegeAll: ObjectPrivilege +PrivilegeCreateCollection: ObjectPrivilege +PrivilegeDropCollection: ObjectPrivilege +PrivilegeDescribeCollection: ObjectPrivilege +PrivilegeShowCollections: ObjectPrivilege +PrivilegeLoad: ObjectPrivilege +PrivilegeRelease: ObjectPrivilege +PrivilegeCompaction: ObjectPrivilege +PrivilegeInsert: ObjectPrivilege +PrivilegeDelete: ObjectPrivilege +PrivilegeGetStatistics: ObjectPrivilege +PrivilegeCreateIndex: ObjectPrivilege +PrivilegeIndexDetail: ObjectPrivilege +PrivilegeDropIndex: ObjectPrivilege +PrivilegeSearch: ObjectPrivilege +PrivilegeFlush: ObjectPrivilege +PrivilegeQuery: ObjectPrivilege +PrivilegeLoadBalance: ObjectPrivilege +PrivilegeImport: ObjectPrivilege +PrivilegeCreateOwnership: ObjectPrivilege +PrivilegeUpdateUser: ObjectPrivilege +PrivilegeDropOwnership: ObjectPrivilege +PrivilegeSelectOwnership: ObjectPrivilege +PrivilegeManageOwnership: ObjectPrivilege +PrivilegeSelectUser: ObjectPrivilege +PrivilegeUpsert: ObjectPrivilege +PrivilegeCreateResourceGroup: ObjectPrivilege +PrivilegeDropResourceGroup: ObjectPrivilege +PrivilegeDescribeResourceGroup: ObjectPrivilege +PrivilegeListResourceGroups: ObjectPrivilege +PrivilegeTransferNode: ObjectPrivilege +PrivilegeTransferReplica: ObjectPrivilege +PrivilegeGetLoadingProgress: ObjectPrivilege +PrivilegeGetLoadState: ObjectPrivilege +PrivilegeRenameCollection: ObjectPrivilege +PrivilegeCreateDatabase: ObjectPrivilege +PrivilegeDropDatabase: ObjectPrivilege +PrivilegeListDatabases: ObjectPrivilege +PrivilegeFlushAll: ObjectPrivilege +PrivilegeCreatePartition: ObjectPrivilege +PrivilegeDropPartition: ObjectPrivilege +PrivilegeShowPartitions: ObjectPrivilege +PrivilegeHasPartition: ObjectPrivilege +PrivilegeGetFlushState: ObjectPrivilege +PrivilegeCreateAlias: ObjectPrivilege +PrivilegeDropAlias: ObjectPrivilege +PrivilegeDescribeAlias: ObjectPrivilege +PrivilegeListAliases: ObjectPrivilege +PrivilegeUpdateResourceGroups: ObjectPrivilege +Initializing: StateCode +Healthy: StateCode +Abnormal: StateCode +StandBy: StateCode +Stopping: StateCode +LoadStateNotExist: LoadState +LoadStateNotLoad: LoadState +LoadStateLoading: LoadState +LoadStateLoaded: LoadState +PRIVILEGE_EXT_OBJ_FIELD_NUMBER: _ClassVar[int] +privilege_ext_obj: _descriptor.FieldDescriptor + +class Status(_message.Message): + __slots__ = ("error_code", "reason", "code", "retriable", "detail", "extra_info") + class ExtraInfoEntry(_message.Message): + __slots__ = ("key", "value") + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: str + value: str + def __init__(self, key: _Optional[str] = ..., value: _Optional[str] = ...) -> None: ... + ERROR_CODE_FIELD_NUMBER: _ClassVar[int] + REASON_FIELD_NUMBER: _ClassVar[int] + CODE_FIELD_NUMBER: _ClassVar[int] + RETRIABLE_FIELD_NUMBER: _ClassVar[int] + DETAIL_FIELD_NUMBER: _ClassVar[int] + EXTRA_INFO_FIELD_NUMBER: _ClassVar[int] + error_code: ErrorCode + reason: str + code: int + retriable: bool + detail: str + extra_info: _containers.ScalarMap[str, str] + def __init__(self, error_code: _Optional[_Union[ErrorCode, str]] = ..., reason: _Optional[str] = ..., code: _Optional[int] = ..., retriable: bool = ..., detail: _Optional[str] = ..., extra_info: _Optional[_Mapping[str, str]] = ...) -> None: ... + +class KeyValuePair(_message.Message): + __slots__ = ("key", "value") + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: str + value: str + def __init__(self, key: _Optional[str] = ..., value: _Optional[str] = ...) -> None: ... + +class KeyDataPair(_message.Message): + __slots__ = ("key", "data") + KEY_FIELD_NUMBER: _ClassVar[int] + DATA_FIELD_NUMBER: _ClassVar[int] + key: str + data: bytes + def __init__(self, key: _Optional[str] = ..., data: _Optional[bytes] = ...) -> None: ... + +class Blob(_message.Message): + __slots__ = ("value",) + VALUE_FIELD_NUMBER: _ClassVar[int] + value: bytes + def __init__(self, value: _Optional[bytes] = ...) -> None: ... + +class PlaceholderValue(_message.Message): + __slots__ = ("tag", "type", "values") + TAG_FIELD_NUMBER: _ClassVar[int] + TYPE_FIELD_NUMBER: _ClassVar[int] + VALUES_FIELD_NUMBER: _ClassVar[int] + tag: str + type: PlaceholderType + values: _containers.RepeatedScalarFieldContainer[bytes] + def __init__(self, tag: _Optional[str] = ..., type: _Optional[_Union[PlaceholderType, str]] = ..., values: _Optional[_Iterable[bytes]] = ...) -> None: ... + +class PlaceholderGroup(_message.Message): + __slots__ = ("placeholders",) + PLACEHOLDERS_FIELD_NUMBER: _ClassVar[int] + placeholders: _containers.RepeatedCompositeFieldContainer[PlaceholderValue] + def __init__(self, placeholders: _Optional[_Iterable[_Union[PlaceholderValue, _Mapping]]] = ...) -> None: ... + +class Address(_message.Message): + __slots__ = ("ip", "port") + IP_FIELD_NUMBER: _ClassVar[int] + PORT_FIELD_NUMBER: _ClassVar[int] + ip: str + port: int + def __init__(self, ip: _Optional[str] = ..., port: _Optional[int] = ...) -> None: ... + +class MsgBase(_message.Message): + __slots__ = ("msg_type", "msgID", "timestamp", "sourceID", "targetID", "properties", "replicateInfo") + class PropertiesEntry(_message.Message): + __slots__ = ("key", "value") + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: str + value: str + def __init__(self, key: _Optional[str] = ..., value: _Optional[str] = ...) -> None: ... + MSG_TYPE_FIELD_NUMBER: _ClassVar[int] + MSGID_FIELD_NUMBER: _ClassVar[int] + TIMESTAMP_FIELD_NUMBER: _ClassVar[int] + SOURCEID_FIELD_NUMBER: _ClassVar[int] + TARGETID_FIELD_NUMBER: _ClassVar[int] + PROPERTIES_FIELD_NUMBER: _ClassVar[int] + REPLICATEINFO_FIELD_NUMBER: _ClassVar[int] + msg_type: MsgType + msgID: int + timestamp: int + sourceID: int + targetID: int + properties: _containers.ScalarMap[str, str] + replicateInfo: ReplicateInfo + def __init__(self, msg_type: _Optional[_Union[MsgType, str]] = ..., msgID: _Optional[int] = ..., timestamp: _Optional[int] = ..., sourceID: _Optional[int] = ..., targetID: _Optional[int] = ..., properties: _Optional[_Mapping[str, str]] = ..., replicateInfo: _Optional[_Union[ReplicateInfo, _Mapping]] = ...) -> None: ... + +class ReplicateInfo(_message.Message): + __slots__ = ("isReplicate", "msgTimestamp") + ISREPLICATE_FIELD_NUMBER: _ClassVar[int] + MSGTIMESTAMP_FIELD_NUMBER: _ClassVar[int] + isReplicate: bool + msgTimestamp: int + def __init__(self, isReplicate: bool = ..., msgTimestamp: _Optional[int] = ...) -> None: ... + +class MsgHeader(_message.Message): + __slots__ = ("base",) + BASE_FIELD_NUMBER: _ClassVar[int] + base: MsgBase + def __init__(self, base: _Optional[_Union[MsgBase, _Mapping]] = ...) -> None: ... + +class DMLMsgHeader(_message.Message): + __slots__ = ("base", "shardName") + BASE_FIELD_NUMBER: _ClassVar[int] + SHARDNAME_FIELD_NUMBER: _ClassVar[int] + base: MsgBase + shardName: str + def __init__(self, base: _Optional[_Union[MsgBase, _Mapping]] = ..., shardName: _Optional[str] = ...) -> None: ... + +class PrivilegeExt(_message.Message): + __slots__ = ("object_type", "object_privilege", "object_name_index", "object_name_indexs") + OBJECT_TYPE_FIELD_NUMBER: _ClassVar[int] + OBJECT_PRIVILEGE_FIELD_NUMBER: _ClassVar[int] + OBJECT_NAME_INDEX_FIELD_NUMBER: _ClassVar[int] + OBJECT_NAME_INDEXS_FIELD_NUMBER: _ClassVar[int] + object_type: ObjectType + object_privilege: ObjectPrivilege + object_name_index: int + object_name_indexs: int + def __init__(self, object_type: _Optional[_Union[ObjectType, str]] = ..., object_privilege: _Optional[_Union[ObjectPrivilege, str]] = ..., object_name_index: _Optional[int] = ..., object_name_indexs: _Optional[int] = ...) -> None: ... + +class SegmentStats(_message.Message): + __slots__ = ("SegmentID", "NumRows") + SEGMENTID_FIELD_NUMBER: _ClassVar[int] + NUMROWS_FIELD_NUMBER: _ClassVar[int] + SegmentID: int + NumRows: int + def __init__(self, SegmentID: _Optional[int] = ..., NumRows: _Optional[int] = ...) -> None: ... + +class ClientInfo(_message.Message): + __slots__ = ("sdk_type", "sdk_version", "local_time", "user", "host", "reserved") + class ReservedEntry(_message.Message): + __slots__ = ("key", "value") + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: str + value: str + def __init__(self, key: _Optional[str] = ..., value: _Optional[str] = ...) -> None: ... + SDK_TYPE_FIELD_NUMBER: _ClassVar[int] + SDK_VERSION_FIELD_NUMBER: _ClassVar[int] + LOCAL_TIME_FIELD_NUMBER: _ClassVar[int] + USER_FIELD_NUMBER: _ClassVar[int] + HOST_FIELD_NUMBER: _ClassVar[int] + RESERVED_FIELD_NUMBER: _ClassVar[int] + sdk_type: str + sdk_version: str + local_time: str + user: str + host: str + reserved: _containers.ScalarMap[str, str] + def __init__(self, sdk_type: _Optional[str] = ..., sdk_version: _Optional[str] = ..., local_time: _Optional[str] = ..., user: _Optional[str] = ..., host: _Optional[str] = ..., reserved: _Optional[_Mapping[str, str]] = ...) -> None: ... + +class ServerInfo(_message.Message): + __slots__ = ("build_tags", "build_time", "git_commit", "go_version", "deploy_mode", "reserved") + class ReservedEntry(_message.Message): + __slots__ = ("key", "value") + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: str + value: str + def __init__(self, key: _Optional[str] = ..., value: _Optional[str] = ...) -> None: ... + BUILD_TAGS_FIELD_NUMBER: _ClassVar[int] + BUILD_TIME_FIELD_NUMBER: _ClassVar[int] + GIT_COMMIT_FIELD_NUMBER: _ClassVar[int] + GO_VERSION_FIELD_NUMBER: _ClassVar[int] + DEPLOY_MODE_FIELD_NUMBER: _ClassVar[int] + RESERVED_FIELD_NUMBER: _ClassVar[int] + build_tags: str + build_time: str + git_commit: str + go_version: str + deploy_mode: str + reserved: _containers.ScalarMap[str, str] + def __init__(self, build_tags: _Optional[str] = ..., build_time: _Optional[str] = ..., git_commit: _Optional[str] = ..., go_version: _Optional[str] = ..., deploy_mode: _Optional[str] = ..., reserved: _Optional[_Mapping[str, str]] = ...) -> None: ... + +class NodeInfo(_message.Message): + __slots__ = ("nodeID", "address", "hostname") + NODEID_FIELD_NUMBER: _ClassVar[int] + ADDRESS_FIELD_NUMBER: _ClassVar[int] + HOSTNAME_FIELD_NUMBER: _ClassVar[int] + nodeID: int + address: str + hostname: str + def __init__(self, nodeID: _Optional[int] = ..., address: _Optional[str] = ..., hostname: _Optional[str] = ...) -> None: ... diff --git a/milvus_connector/protocol/common_pb2_grpc.py b/milvus_connector/protocol/common_pb2_grpc.py new file mode 100644 index 0000000..2daafff --- /dev/null +++ b/milvus_connector/protocol/common_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/milvus_connector/protocol/data_coord_pb2.py b/milvus_connector/protocol/data_coord_pb2.py new file mode 100644 index 0000000..bc11778 --- /dev/null +++ b/milvus_connector/protocol/data_coord_pb2.py @@ -0,0 +1,259 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: data_coord.proto +# Protobuf Python Version: 4.25.1 +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from . import common_pb2 as common__pb2 +from . import internal_pb2 as internal__pb2 +from . import milvus_pb2 as milvus__pb2 +from . import schema_pb2 as schema__pb2 +from . import msg_pb2 as msg__pb2 +from . import index_coord_pb2 as index__coord__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x10\x64\x61ta_coord.proto\x12\x11milvus.proto.data\x1a\x0c\x63ommon.proto\x1a\x0einternal.proto\x1a\x0cmilvus.proto\x1a\x0cschema.proto\x1a\tmsg.proto\x1a\x11index_coord.proto\"\x07\n\x05\x45mpty\"\x84\x01\n\x0c\x46lushRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x0c\n\x04\x64\x62ID\x18\x02 \x01(\x03\x12\x12\n\nsegmentIDs\x18\x03 \x03(\x03\x12\x14\n\x0c\x63ollectionID\x18\x04 \x01(\x03\x12\x10\n\x08isImport\x18\x05 \x01(\x08\"\xb3\x01\n\rFlushResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\x0c\n\x04\x64\x62ID\x18\x02 \x01(\x03\x12\x14\n\x0c\x63ollectionID\x18\x03 \x01(\x03\x12\x12\n\nsegmentIDs\x18\x04 \x03(\x03\x12\x17\n\x0f\x66lushSegmentIDs\x18\x05 \x03(\x03\x12\x12\n\ntimeOfSeal\x18\x06 \x01(\x03\x12\x10\n\x08\x66lush_ts\x18\x07 \x01(\x04\"f\n\x14\x46lushChannelsRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x10\n\x08\x66lush_ts\x18\x02 \x01(\x04\x12\x10\n\x08\x63hannels\x18\x03 \x03(\t\"\xba\x01\n\x10SegmentIDRequest\x12\r\n\x05\x63ount\x18\x01 \x01(\r\x12\x14\n\x0c\x63hannel_name\x18\x02 \x01(\t\x12\x14\n\x0c\x63ollectionID\x18\x03 \x01(\x03\x12\x13\n\x0bpartitionID\x18\x04 \x01(\x03\x12\x10\n\x08isImport\x18\x05 \x01(\x08\x12\x14\n\x0cimportTaskID\x18\x06 \x01(\x03\x12.\n\x05level\x18\x07 \x01(\x0e\x32\x1f.milvus.proto.data.SegmentLevel\"{\n\x16\x41ssignSegmentIDRequest\x12\x0e\n\x06nodeID\x18\x01 \x01(\x03\x12\x11\n\tpeer_role\x18\x02 \x01(\t\x12>\n\x11segmentIDRequests\x18\x03 \x03(\x0b\x32#.milvus.proto.data.SegmentIDRequest\"\xb6\x01\n\x13SegmentIDAssignment\x12\r\n\x05segID\x18\x01 \x01(\x03\x12\x14\n\x0c\x63hannel_name\x18\x02 \x01(\t\x12\r\n\x05\x63ount\x18\x03 \x01(\r\x12\x14\n\x0c\x63ollectionID\x18\x04 \x01(\x03\x12\x13\n\x0bpartitionID\x18\x05 \x01(\x03\x12\x13\n\x0b\x65xpire_time\x18\x06 \x01(\x04\x12+\n\x06status\x18\x07 \x01(\x0b\x32\x1b.milvus.proto.common.Status\"\x88\x01\n\x17\x41ssignSegmentIDResponse\x12@\n\x10segIDAssignments\x18\x01 \x03(\x0b\x32&.milvus.proto.data.SegmentIDAssignment\x12+\n\x06status\x18\x02 \x01(\x0b\x32\x1b.milvus.proto.common.Status\"Y\n\x17GetSegmentStatesRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x12\n\nsegmentIDs\x18\x02 \x03(\x03\"\xf0\x01\n\x10SegmentStateInfo\x12\x11\n\tsegmentID\x18\x01 \x01(\x03\x12\x30\n\x05state\x18\x02 \x01(\x0e\x32!.milvus.proto.common.SegmentState\x12\x35\n\x0estart_position\x18\x03 \x01(\x0b\x32\x1d.milvus.proto.msg.MsgPosition\x12\x33\n\x0c\x65nd_position\x18\x04 \x01(\x0b\x32\x1d.milvus.proto.msg.MsgPosition\x12+\n\x06status\x18\x05 \x01(\x0b\x32\x1b.milvus.proto.common.Status\"|\n\x18GetSegmentStatesResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\x33\n\x06states\x18\x02 \x03(\x0b\x32#.milvus.proto.data.SegmentStateInfo\"q\n\x15GetSegmentInfoRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x12\n\nsegmentIDs\x18\x02 \x03(\x03\x12\x18\n\x10includeUnHealthy\x18\x03 \x01(\x08\"\xab\x02\n\x16GetSegmentInfoResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12-\n\x05infos\x18\x02 \x03(\x0b\x32\x1e.milvus.proto.data.SegmentInfo\x12\\\n\x12\x63hannel_checkpoint\x18\x03 \x03(\x0b\x32@.milvus.proto.data.GetSegmentInfoResponse.ChannelCheckpointEntry\x1aW\n\x16\x43hannelCheckpointEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12,\n\x05value\x18\x02 \x01(\x0b\x32\x1d.milvus.proto.msg.MsgPosition:\x02\x38\x01\"\\\n\x1bGetInsertBinlogPathsRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x11\n\tsegmentID\x18\x02 \x01(\x03\"\x8f\x01\n\x1cGetInsertBinlogPathsResponse\x12\x10\n\x08\x66ieldIDs\x18\x01 \x03(\x03\x12\x30\n\x05paths\x18\x02 \x03(\x0b\x32!.milvus.proto.internal.StringList\x12+\n\x06status\x18\x03 \x01(\x0b\x32\x1b.milvus.proto.common.Status\"p\n\x1eGetCollectionStatisticsRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x0c\n\x04\x64\x62ID\x18\x02 \x01(\x03\x12\x14\n\x0c\x63ollectionID\x18\x03 \x01(\x03\"\x80\x01\n\x1fGetCollectionStatisticsResponse\x12\x30\n\x05stats\x18\x01 \x03(\x0b\x32!.milvus.proto.common.KeyValuePair\x12+\n\x06status\x18\x02 \x01(\x0b\x32\x1b.milvus.proto.common.Status\"\x85\x01\n\x1dGetPartitionStatisticsRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x0c\n\x04\x64\x62ID\x18\x02 \x01(\x03\x12\x14\n\x0c\x63ollectionID\x18\x03 \x01(\x03\x12\x14\n\x0cpartitionIDs\x18\x04 \x03(\x03\"\x7f\n\x1eGetPartitionStatisticsResponse\x12\x30\n\x05stats\x18\x01 \x03(\x0b\x32!.milvus.proto.common.KeyValuePair\x12+\n\x06status\x18\x02 \x01(\x0b\x32\x1b.milvus.proto.common.Status\"\x1e\n\x1cGetSegmentInfoChannelRequest\"\xe7\x03\n\x0cVchannelInfo\x12\x14\n\x0c\x63ollectionID\x18\x01 \x01(\x03\x12\x13\n\x0b\x63hannelName\x18\x02 \x01(\t\x12\x34\n\rseek_position\x18\x03 \x01(\x0b\x32\x1d.milvus.proto.msg.MsgPosition\x12\x39\n\x11unflushedSegments\x18\x04 \x03(\x0b\x32\x1e.milvus.proto.data.SegmentInfo\x12\x37\n\x0f\x66lushedSegments\x18\x05 \x03(\x0b\x32\x1e.milvus.proto.data.SegmentInfo\x12\x38\n\x10\x64ropped_segments\x18\x06 \x03(\x0b\x32\x1e.milvus.proto.data.SegmentInfo\x12\x1b\n\x13unflushedSegmentIds\x18\x07 \x03(\x03\x12\x19\n\x11\x66lushedSegmentIds\x18\x08 \x03(\x03\x12\x1a\n\x12\x64ropped_segmentIds\x18\t \x03(\x03\x12\x1a\n\x12indexed_segmentIds\x18\n \x03(\x03\x12\x38\n\x10indexed_segments\x18\x0b \x03(\x0b\x32\x1e.milvus.proto.data.SegmentInfo\x12\x1e\n\x16level_zero_segment_ids\x18\x0c \x03(\x03\"x\n\x16WatchDmChannelsRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x32\n\tvchannels\x18\x02 \x03(\x0b\x32\x1f.milvus.proto.data.VchannelInfo\"\x8f\x01\n\x14\x46lushSegmentsRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x0c\n\x04\x64\x62ID\x18\x02 \x01(\x03\x12\x14\n\x0c\x63ollectionID\x18\x03 \x01(\x03\x12\x12\n\nsegmentIDs\x18\x04 \x03(\x03\x12\x13\n\x0b\x63hannelName\x18\x05 \x01(\t\"i\n\nSegmentMsg\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12/\n\x07segment\x18\x02 \x01(\x0b\x32\x1e.milvus.proto.data.SegmentInfo\"\xa1\x05\n\x0bSegmentInfo\x12\n\n\x02ID\x18\x01 \x01(\x03\x12\x14\n\x0c\x63ollectionID\x18\x02 \x01(\x03\x12\x13\n\x0bpartitionID\x18\x03 \x01(\x03\x12\x16\n\x0einsert_channel\x18\x04 \x01(\t\x12\x13\n\x0bnum_of_rows\x18\x05 \x01(\x03\x12\x30\n\x05state\x18\x06 \x01(\x0e\x32!.milvus.proto.common.SegmentState\x12\x13\n\x0bmax_row_num\x18\x07 \x01(\x03\x12\x18\n\x10last_expire_time\x18\x08 \x01(\x04\x12\x35\n\x0estart_position\x18\t \x01(\x0b\x32\x1d.milvus.proto.msg.MsgPosition\x12\x33\n\x0c\x64ml_position\x18\n \x01(\x0b\x32\x1d.milvus.proto.msg.MsgPosition\x12/\n\x07\x62inlogs\x18\x0b \x03(\x0b\x32\x1e.milvus.proto.data.FieldBinlog\x12\x31\n\tstatslogs\x18\x0c \x03(\x0b\x32\x1e.milvus.proto.data.FieldBinlog\x12\x31\n\tdeltalogs\x18\r \x03(\x0b\x32\x1e.milvus.proto.data.FieldBinlog\x12\x1b\n\x13\x63reatedByCompaction\x18\x0e \x01(\x08\x12\x16\n\x0e\x63ompactionFrom\x18\x0f \x03(\x03\x12\x12\n\ndropped_at\x18\x10 \x01(\x04\x12\x14\n\x0cis_importing\x18\x11 \x01(\x08\x12\x0f\n\x07is_fake\x18\x12 \x01(\x08\x12\x11\n\tcompacted\x18\x13 \x01(\x08\x12.\n\x05level\x18\x14 \x01(\x0e\x32\x1f.milvus.proto.data.SegmentLevel\x12\x17\n\x0fstorage_version\x18\x15 \x01(\x03\"`\n\x14SegmentStartPosition\x12\x35\n\x0estart_position\x18\x01 \x01(\x0b\x32\x1d.milvus.proto.msg.MsgPosition\x12\x11\n\tsegmentID\x18\x02 \x01(\x03\"\xb5\x04\n\x16SaveBinlogPathsRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x11\n\tsegmentID\x18\x02 \x01(\x03\x12\x14\n\x0c\x63ollectionID\x18\x03 \x01(\x03\x12\x39\n\x11\x66ield2BinlogPaths\x18\x04 \x03(\x0b\x32\x1e.milvus.proto.data.FieldBinlog\x12\x32\n\x0b\x63heckPoints\x18\x05 \x03(\x0b\x32\x1d.milvus.proto.data.CheckPoint\x12@\n\x0fstart_positions\x18\x06 \x03(\x0b\x32\'.milvus.proto.data.SegmentStartPosition\x12\x0f\n\x07\x66lushed\x18\x07 \x01(\x08\x12;\n\x13\x66ield2StatslogPaths\x18\x08 \x03(\x0b\x32\x1e.milvus.proto.data.FieldBinlog\x12\x31\n\tdeltalogs\x18\t \x03(\x0b\x32\x1e.milvus.proto.data.FieldBinlog\x12\x0f\n\x07\x64ropped\x18\n \x01(\x08\x12\x11\n\timporting\x18\x0b \x01(\x08\x12\x0f\n\x07\x63hannel\x18\x0c \x01(\t\x12\x32\n\tseg_level\x18\r \x01(\x0e\x32\x1f.milvus.proto.data.SegmentLevel\x12\x13\n\x0bpartitionID\x18\x0e \x01(\x03\x12\x16\n\x0estorageVersion\x18\x0f \x01(\x03\"e\n\nCheckPoint\x12\x11\n\tsegmentID\x18\x01 \x01(\x03\x12/\n\x08position\x18\x02 \x01(\x0b\x32\x1d.milvus.proto.msg.MsgPosition\x12\x13\n\x0bnum_of_rows\x18\x03 \x01(\x03\"\x84\x01\n\x0c\x44\x65ltaLogInfo\x12\x16\n\x0erecord_entries\x18\x01 \x01(\x04\x12\x16\n\x0etimestamp_from\x18\x02 \x01(\x04\x12\x14\n\x0ctimestamp_to\x18\x03 \x01(\x04\x12\x16\n\x0e\x64\x65lta_log_path\x18\x04 \x01(\t\x12\x16\n\x0e\x64\x65lta_log_size\x18\x05 \x01(\x03\"h\n\rChannelStatus\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x33\n\x05state\x18\x02 \x01(\x0e\x32$.milvus.proto.data.ChannelWatchState\x12\x14\n\x0c\x63ollectionID\x18\x03 \x01(\x03\"d\n\x0c\x44\x61taNodeInfo\x12\x0f\n\x07\x61\x64\x64ress\x18\x01 \x01(\t\x12\x0f\n\x07version\x18\x02 \x01(\x03\x12\x32\n\x08\x63hannels\x18\x03 \x03(\x0b\x32 .milvus.proto.data.ChannelStatus\"\xec\x01\n\x0eSegmentBinlogs\x12\x11\n\tsegmentID\x18\x01 \x01(\x03\x12\x34\n\x0c\x66ieldBinlogs\x18\x02 \x03(\x0b\x32\x1e.milvus.proto.data.FieldBinlog\x12\x13\n\x0bnum_of_rows\x18\x03 \x01(\x03\x12\x31\n\tstatslogs\x18\x04 \x03(\x0b\x32\x1e.milvus.proto.data.FieldBinlog\x12\x31\n\tdeltalogs\x18\x05 \x03(\x0b\x32\x1e.milvus.proto.data.FieldBinlog\x12\x16\n\x0einsert_channel\x18\x06 \x01(\t\"J\n\x0b\x46ieldBinlog\x12\x0f\n\x07\x66ieldID\x18\x01 \x01(\x03\x12*\n\x07\x62inlogs\x18\x02 \x03(\x0b\x32\x19.milvus.proto.data.Binlog\"~\n\x06\x42inlog\x12\x13\n\x0b\x65ntries_num\x18\x01 \x01(\x03\x12\x16\n\x0etimestamp_from\x18\x02 \x01(\x04\x12\x14\n\x0ctimestamp_to\x18\x03 \x01(\x04\x12\x10\n\x08log_path\x18\x04 \x01(\t\x12\x10\n\x08log_size\x18\x05 \x01(\x03\x12\r\n\x05logID\x18\x06 \x01(\x03\"\xad\x01\n\x17GetRecoveryInfoResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\x31\n\x08\x63hannels\x18\x02 \x03(\x0b\x32\x1f.milvus.proto.data.VchannelInfo\x12\x32\n\x07\x62inlogs\x18\x03 \x03(\x0b\x32!.milvus.proto.data.SegmentBinlogs\"o\n\x16GetRecoveryInfoRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x14\n\x0c\x63ollectionID\x18\x02 \x01(\x03\x12\x13\n\x0bpartitionID\x18\x03 \x01(\x03\"\xad\x01\n\x19GetRecoveryInfoResponseV2\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\x31\n\x08\x63hannels\x18\x02 \x03(\x0b\x32\x1f.milvus.proto.data.VchannelInfo\x12\x30\n\x08segments\x18\x03 \x03(\x0b\x32\x1e.milvus.proto.data.SegmentInfo\"r\n\x18GetRecoveryInfoRequestV2\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x14\n\x0c\x63ollectionID\x18\x02 \x01(\x03\x12\x14\n\x0cpartitionIDs\x18\x03 \x03(\x03\"\xa6\x01\n\x1aGetSegmentsByStatesRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x14\n\x0c\x63ollectionID\x18\x02 \x01(\x03\x12\x13\n\x0bpartitionID\x18\x03 \x01(\x03\x12\x31\n\x06states\x18\x04 \x03(\x0e\x32!.milvus.proto.common.SegmentState\"\\\n\x1bGetSegmentsByStatesResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\x10\n\x08segments\x18\x02 \x03(\x03\"\x8c\x01\n\x19GetFlushedSegmentsRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x14\n\x0c\x63ollectionID\x18\x02 \x01(\x03\x12\x13\n\x0bpartitionID\x18\x03 \x01(\x03\x12\x18\n\x10includeUnhealthy\x18\x04 \x01(\x08\"[\n\x1aGetFlushedSegmentsResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\x10\n\x08segments\x18\x02 \x03(\x03\"w\n\x18SegmentFlushCompletedMsg\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12/\n\x07segment\x18\x02 \x01(\x0b\x32\x1e.milvus.proto.data.SegmentInfo\"\xf2\x01\n\x10\x43hannelWatchInfo\x12.\n\x05vchan\x18\x01 \x01(\x0b\x32\x1f.milvus.proto.data.VchannelInfo\x12\x0f\n\x07startTs\x18\x02 \x01(\x03\x12\x33\n\x05state\x18\x03 \x01(\x0e\x32$.milvus.proto.data.ChannelWatchState\x12\x11\n\ttimeoutTs\x18\x04 \x01(\x03\x12\x35\n\x06schema\x18\x05 \x01(\x0b\x32%.milvus.proto.schema.CollectionSchema\x12\x10\n\x08progress\x18\x06 \x01(\x05\x12\x0c\n\x04opID\x18\x07 \x01(\x03\"D\n\x16\x43ompactionStateRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\"\xdf\x01\n\x13SyncSegmentsRequest\x12\x0e\n\x06planID\x18\x01 \x01(\x03\x12\x14\n\x0c\x63ompacted_to\x18\x02 \x01(\x03\x12\x13\n\x0bnum_of_rows\x18\x03 \x01(\x03\x12\x16\n\x0e\x63ompacted_from\x18\x04 \x03(\x03\x12\x32\n\nstats_logs\x18\x05 \x03(\x0b\x32\x1e.milvus.proto.data.FieldBinlog\x12\x14\n\x0c\x63hannel_name\x18\x06 \x01(\t\x12\x14\n\x0cpartition_id\x18\x07 \x01(\x03\x12\x15\n\rcollection_id\x18\x08 \x01(\x03\"\xc6\x02\n\x18\x43ompactionSegmentBinlogs\x12\x11\n\tsegmentID\x18\x01 \x01(\x03\x12\x34\n\x0c\x66ieldBinlogs\x18\x02 \x03(\x0b\x32\x1e.milvus.proto.data.FieldBinlog\x12;\n\x13\x66ield2StatslogPaths\x18\x03 \x03(\x0b\x32\x1e.milvus.proto.data.FieldBinlog\x12\x31\n\tdeltalogs\x18\x04 \x03(\x0b\x32\x1e.milvus.proto.data.FieldBinlog\x12\x16\n\x0einsert_channel\x18\x05 \x01(\t\x12.\n\x05level\x18\x06 \x01(\x0e\x32\x1f.milvus.proto.data.SegmentLevel\x12\x14\n\x0c\x63ollectionID\x18\x07 \x01(\x03\x12\x13\n\x0bpartitionID\x18\x08 \x01(\x03\"\x97\x02\n\x0e\x43ompactionPlan\x12\x0e\n\x06planID\x18\x01 \x01(\x03\x12\x43\n\x0esegmentBinlogs\x18\x02 \x03(\x0b\x32+.milvus.proto.data.CompactionSegmentBinlogs\x12\x12\n\nstart_time\x18\x03 \x01(\x04\x12\x1a\n\x12timeout_in_seconds\x18\x04 \x01(\x05\x12/\n\x04type\x18\x05 \x01(\x0e\x32!.milvus.proto.data.CompactionType\x12\x12\n\ntimetravel\x18\x06 \x01(\x04\x12\x0f\n\x07\x63hannel\x18\x07 \x01(\t\x12\x16\n\x0e\x63ollection_ttl\x18\x08 \x01(\x03\x12\x12\n\ntotal_rows\x18\t \x01(\x03\"\x81\x02\n\x11\x43ompactionSegment\x12\x0e\n\x06planID\x18\x01 \x01(\x03\x12\x11\n\tsegmentID\x18\x02 \x01(\x03\x12\x13\n\x0bnum_of_rows\x18\x03 \x01(\x03\x12\x33\n\x0binsert_logs\x18\x04 \x03(\x0b\x32\x1e.milvus.proto.data.FieldBinlog\x12;\n\x13\x66ield2StatslogPaths\x18\x05 \x03(\x0b\x32\x1e.milvus.proto.data.FieldBinlog\x12\x31\n\tdeltalogs\x18\x06 \x03(\x0b\x32\x1e.milvus.proto.data.FieldBinlog\x12\x0f\n\x07\x63hannel\x18\x07 \x01(\t\"\xd5\x01\n\x14\x43ompactionPlanResult\x12\x0e\n\x06planID\x18\x01 \x01(\x03\x12\x33\n\x05state\x18\x02 \x01(\x0e\x32$.milvus.proto.common.CompactionState\x12\x36\n\x08segments\x18\x03 \x03(\x0b\x32$.milvus.proto.data.CompactionSegment\x12\x0f\n\x07\x63hannel\x18\x04 \x01(\t\x12/\n\x04type\x18\x05 \x01(\x0e\x32!.milvus.proto.data.CompactionType\"\x80\x01\n\x17\x43ompactionStateResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\x38\n\x07results\x18\x02 \x03(\x0b\x32\'.milvus.proto.data.CompactionPlanResult\">\n\x16SegmentFieldBinlogMeta\x12\x0f\n\x07\x66ieldID\x18\x01 \x01(\x03\x12\x13\n\x0b\x62inlog_path\x18\x02 \x01(\t\"\xce\x01\n\x14WatchChannelsRequest\x12\x14\n\x0c\x63ollectionID\x18\x01 \x01(\x03\x12\x14\n\x0c\x63hannelNames\x18\x02 \x03(\t\x12\x39\n\x0fstart_positions\x18\x03 \x03(\x0b\x32 .milvus.proto.common.KeyDataPair\x12\x35\n\x06schema\x18\x04 \x01(\x0b\x32%.milvus.proto.schema.CollectionSchema\x12\x18\n\x10\x63reate_timestamp\x18\x05 \x01(\x04\"D\n\x15WatchChannelsResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\"\x8e\x01\n\x16SetSegmentStateRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x12\n\nsegment_id\x18\x02 \x01(\x03\x12\x34\n\tnew_state\x18\x03 \x01(\x0e\x32!.milvus.proto.common.SegmentState\"F\n\x17SetSegmentStateResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\"\x9d\x01\n\x19\x44ropVirtualChannelRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x14\n\x0c\x63hannel_name\x18\x02 \x01(\t\x12>\n\x08segments\x18\x03 \x03(\x0b\x32,.milvus.proto.data.DropVirtualChannelSegment\"\xeb\x02\n\x19\x44ropVirtualChannelSegment\x12\x11\n\tsegmentID\x18\x01 \x01(\x03\x12\x14\n\x0c\x63ollectionID\x18\x02 \x01(\x03\x12\x39\n\x11\x66ield2BinlogPaths\x18\x03 \x03(\x0b\x32\x1e.milvus.proto.data.FieldBinlog\x12;\n\x13\x66ield2StatslogPaths\x18\x04 \x03(\x0b\x32\x1e.milvus.proto.data.FieldBinlog\x12\x31\n\tdeltalogs\x18\x05 \x03(\x0b\x32\x1e.milvus.proto.data.FieldBinlog\x12\x34\n\rstartPosition\x18\x06 \x01(\x0b\x32\x1d.milvus.proto.msg.MsgPosition\x12\x31\n\ncheckPoint\x18\x07 \x01(\x0b\x32\x1d.milvus.proto.msg.MsgPosition\x12\x11\n\tnumOfRows\x18\x08 \x01(\x03\"I\n\x1a\x44ropVirtualChannelResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\"\xf9\x01\n\nImportTask\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\x15\n\rcollection_id\x18\x02 \x01(\x03\x12\x14\n\x0cpartition_id\x18\x03 \x01(\x03\x12\x15\n\rchannel_names\x18\x04 \x03(\t\x12\x11\n\trow_based\x18\x05 \x01(\x08\x12\x0f\n\x07task_id\x18\x06 \x01(\x03\x12\r\n\x05\x66iles\x18\x07 \x03(\t\x12\x30\n\x05infos\x18\x08 \x03(\x0b\x32!.milvus.proto.common.KeyValuePair\x12\x15\n\rdatabase_name\x18\x10 \x01(\t\"\x93\x01\n\x0fImportTaskState\x12\x33\n\tstateCode\x18\x01 \x01(\x0e\x32 .milvus.proto.common.ImportState\x12\x10\n\x08segments\x18\x02 \x03(\x03\x12\x0f\n\x07row_ids\x18\x03 \x03(\x03\x12\x11\n\trow_count\x18\x04 \x01(\x03\x12\x15\n\rerror_message\x18\x05 \x01(\t\"\x91\x03\n\x0eImportTaskInfo\x12\n\n\x02id\x18\x01 \x01(\x03\x12\x16\n\nrequest_id\x18\x02 \x01(\x03\x42\x02\x18\x01\x12\x13\n\x0b\x64\x61tanode_id\x18\x03 \x01(\x03\x12\x15\n\rcollection_id\x18\x04 \x01(\x03\x12\x14\n\x0cpartition_id\x18\x05 \x01(\x03\x12\x15\n\rchannel_names\x18\x06 \x03(\t\x12\x0e\n\x06\x62ucket\x18\x07 \x01(\t\x12\x11\n\trow_based\x18\x08 \x01(\x08\x12\r\n\x05\x66iles\x18\t \x03(\t\x12\x11\n\tcreate_ts\x18\n \x01(\x03\x12\x31\n\x05state\x18\x0b \x01(\x0b\x32\".milvus.proto.data.ImportTaskState\x12\x17\n\x0f\x63ollection_name\x18\x0c \x01(\t\x12\x16\n\x0epartition_name\x18\r \x01(\t\x12\x30\n\x05infos\x18\x0e \x03(\x0b\x32!.milvus.proto.common.KeyValuePair\x12\x10\n\x08start_ts\x18\x0f \x01(\x03\x12\x15\n\rdatabase_name\x18\x10 \x01(\t\"V\n\x12ImportTaskResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\x13\n\x0b\x64\x61tanode_id\x18\x02 \x01(\x03\"\x8a\x01\n\x11ImportTaskRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x32\n\x0bimport_task\x18\x02 \x01(\x0b\x32\x1d.milvus.proto.data.ImportTask\x12\x15\n\rworking_nodes\x18\x03 \x03(\x03\"~\n\x1eUpdateSegmentStatisticsRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x30\n\x05stats\x18\x02 \x03(\x0b\x32!.milvus.proto.common.SegmentStats\"\xcb\x01\n\x1eUpdateChannelCheckpointRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x10\n\x08vChannel\x18\x02 \x01(\t\x12/\n\x08position\x18\x03 \x01(\x0b\x32\x1d.milvus.proto.msg.MsgPosition\x12:\n\x13\x63hannel_checkpoints\x18\x04 \x03(\x0b\x32\x1d.milvus.proto.msg.MsgPosition\"G\n\x19ResendSegmentStatsRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\"]\n\x1aResendSegmentStatsResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\x12\n\nseg_resent\x18\x02 \x03(\x03\"\xe0\x01\n\x17\x41\x64\x64ImportSegmentRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x12\n\nsegment_id\x18\x02 \x01(\x03\x12\x14\n\x0c\x63hannel_name\x18\x03 \x01(\t\x12\x15\n\rcollection_id\x18\x04 \x01(\x03\x12\x14\n\x0cpartition_id\x18\x05 \x01(\x03\x12\x0f\n\x07row_num\x18\x06 \x01(\x03\x12\x31\n\tstats_log\x18\x07 \x03(\x0b\x32\x1e.milvus.proto.data.FieldBinlog\"\\\n\x18\x41\x64\x64ImportSegmentResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\x13\n\x0b\x63hannel_pos\x18\x02 \x01(\x0c\"\x90\x02\n\x18SaveImportSegmentRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x12\n\nsegment_id\x18\x02 \x01(\x03\x12\x14\n\x0c\x63hannel_name\x18\x03 \x01(\t\x12\x15\n\rcollection_id\x18\x04 \x01(\x03\x12\x14\n\x0cpartition_id\x18\x05 \x01(\x03\x12\x0f\n\x07row_num\x18\x06 \x01(\x03\x12G\n\x14save_binlog_path_req\x18\x07 \x01(\x0b\x32).milvus.proto.data.SaveBinlogPathsRequest\x12\x17\n\x0f\x64ml_position_id\x18\x08 \x01(\x0c\"_\n\x1cUnsetIsImportingStateRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x13\n\x0bsegment_ids\x18\x02 \x03(\x03\"]\n\x1aMarkSegmentsDroppedRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x13\n\x0bsegment_ids\x18\x02 \x03(\x03\"J\n\x14SegmentReferenceLock\x12\x0e\n\x06taskID\x18\x01 \x01(\x03\x12\x0e\n\x06nodeID\x18\x02 \x01(\x03\x12\x12\n\nsegmentIDs\x18\x03 \x03(\x03\"\xed\x01\n\x16\x41lterCollectionRequest\x12\x14\n\x0c\x63ollectionID\x18\x01 \x01(\x03\x12\x35\n\x06schema\x18\x02 \x01(\x0b\x32%.milvus.proto.schema.CollectionSchema\x12\x14\n\x0cpartitionIDs\x18\x03 \x03(\x03\x12\x39\n\x0fstart_positions\x18\x04 \x03(\x0b\x32 .milvus.proto.common.KeyDataPair\x12\x35\n\nproperties\x18\x05 \x03(\x0b\x32!.milvus.proto.common.KeyValuePair\"?\n\x10GcConfirmRequest\x12\x15\n\rcollection_id\x18\x01 \x01(\x03\x12\x14\n\x0cpartition_id\x18\x02 \x01(\x03\"U\n\x11GcConfirmResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\x13\n\x0bgc_finished\x18\x02 \x01(\x08\"x\n\x1bReportDataNodeTtMsgsRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12-\n\x04msgs\x18\x02 \x03(\x0b\x32\x1f.milvus.proto.msg.DataNodeTtMsg\"|\n\x14GetFlushStateRequest\x12\x12\n\nsegmentIDs\x18\x01 \x03(\x03\x12\x10\n\x08\x66lush_ts\x18\x02 \x01(\x04\x12\x0f\n\x07\x64\x62_name\x18\x03 \x01(\t\x12\x17\n\x0f\x63ollection_name\x18\x04 \x01(\t\x12\x14\n\x0c\x63ollectionID\x18\x05 \x01(\x03\"N\n\x18\x43hannelOperationsRequest\x12\x32\n\x05infos\x18\x01 \x03(\x0b\x32#.milvus.proto.data.ChannelWatchInfo\"\xa4\x01\n ChannelOperationProgressResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\x0c\n\x04opID\x18\x02 \x01(\x03\x12\x33\n\x05state\x18\x03 \x01(\x0e\x32$.milvus.proto.data.ChannelWatchState\x12\x10\n\x08progress\x18\x04 \x01(\x05\"\xa7\x02\n\x10PreImportRequest\x12\x11\n\tclusterID\x18\x01 \x01(\t\x12\r\n\x05jobID\x18\x02 \x01(\x03\x12\x0e\n\x06taskID\x18\x03 \x01(\x03\x12\x14\n\x0c\x63ollectionID\x18\x04 \x01(\x03\x12\x14\n\x0cpartitionIDs\x18\x05 \x03(\x03\x12\x11\n\tvchannels\x18\x06 \x03(\t\x12\x35\n\x06schema\x18\x07 \x01(\x0b\x32%.milvus.proto.schema.CollectionSchema\x12\x37\n\x0cimport_files\x18\x08 \x03(\x0b\x32!.milvus.proto.internal.ImportFile\x12\x32\n\x07options\x18\t \x03(\x0b\x32!.milvus.proto.common.KeyValuePair\")\n\x0b\x61utoIDRange\x12\r\n\x05\x62\x65gin\x18\x01 \x01(\x03\x12\x0b\n\x03\x65nd\x18\x02 \x01(\x03\"P\n\x14ImportRequestSegment\x12\x11\n\tsegmentID\x18\x01 \x01(\x03\x12\x13\n\x0bpartitionID\x18\x02 \x01(\x03\x12\x10\n\x08vchannel\x18\x03 \x01(\t\"\xa2\x03\n\rImportRequest\x12\x11\n\tclusterID\x18\x01 \x01(\t\x12\r\n\x05jobID\x18\x02 \x01(\x03\x12\x0e\n\x06taskID\x18\x03 \x01(\x03\x12\x14\n\x0c\x63ollectionID\x18\x04 \x01(\x03\x12\x14\n\x0cpartitionIDs\x18\x05 \x03(\x03\x12\x11\n\tvchannels\x18\x06 \x03(\t\x12\x35\n\x06schema\x18\x07 \x01(\x0b\x32%.milvus.proto.schema.CollectionSchema\x12\x30\n\x05\x66iles\x18\x08 \x03(\x0b\x32!.milvus.proto.internal.ImportFile\x12\x32\n\x07options\x18\t \x03(\x0b\x32!.milvus.proto.common.KeyValuePair\x12\n\n\x02ts\x18\n \x01(\x04\x12\x34\n\x0c\x61utoID_range\x18\x0b \x01(\x0b\x32\x1e.milvus.proto.data.autoIDRange\x12\x41\n\x10request_segments\x18\x0c \x03(\x0b\x32\'.milvus.proto.data.ImportRequestSegment\"I\n\x15QueryPreImportRequest\x12\x11\n\tclusterID\x18\x01 \x01(\t\x12\r\n\x05jobID\x18\x02 \x01(\x03\x12\x0e\n\x06taskID\x18\x03 \x01(\x03\"\xb7\x02\n\x14PartitionImportStats\x12R\n\x0epartition_rows\x18\x01 \x03(\x0b\x32:.milvus.proto.data.PartitionImportStats.PartitionRowsEntry\x12[\n\x13partition_data_size\x18\x02 \x03(\x0b\x32>.milvus.proto.data.PartitionImportStats.PartitionDataSizeEntry\x1a\x34\n\x12PartitionRowsEntry\x12\x0b\n\x03key\x18\x01 \x01(\x03\x12\r\n\x05value\x18\x02 \x01(\x03:\x02\x38\x01\x1a\x38\n\x16PartitionDataSizeEntry\x12\x0b\n\x03key\x18\x01 \x01(\x03\x12\r\n\x05value\x18\x02 \x01(\x03:\x02\x38\x01\"\xb3\x02\n\x0fImportFileStats\x12\x36\n\x0bimport_file\x18\x01 \x01(\x0b\x32!.milvus.proto.internal.ImportFile\x12\x11\n\tfile_size\x18\x02 \x01(\x03\x12\x12\n\ntotal_rows\x18\x03 \x01(\x03\x12\x19\n\x11total_memory_size\x18\x04 \x01(\x03\x12I\n\x0chashed_stats\x18\x05 \x03(\x0b\x32\x33.milvus.proto.data.ImportFileStats.HashedStatsEntry\x1a[\n\x10HashedStatsEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\x36\n\x05value\x18\x02 \x01(\x0b\x32\'.milvus.proto.data.PartitionImportStats:\x02\x38\x01\"\xe1\x01\n\x16QueryPreImportResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\x0e\n\x06taskID\x18\x02 \x01(\x03\x12\x33\n\x05state\x18\x03 \x01(\x0e\x32$.milvus.proto.data.ImportTaskStateV2\x12\x0e\n\x06reason\x18\x04 \x01(\t\x12\r\n\x05slots\x18\x05 \x01(\x03\x12\x36\n\nfile_stats\x18\x06 \x03(\x0b\x32\".milvus.proto.data.ImportFileStats\"Y\n\x12QueryImportRequest\x12\x11\n\tclusterID\x18\x01 \x01(\t\x12\r\n\x05jobID\x18\x02 \x01(\x03\x12\x0e\n\x06taskID\x18\x03 \x01(\x03\x12\x11\n\tquerySlot\x18\x04 \x01(\x08\"\xa1\x01\n\x11ImportSegmentInfo\x12\x11\n\tsegmentID\x18\x01 \x01(\x03\x12\x15\n\rimported_rows\x18\x02 \x01(\x03\x12/\n\x07\x62inlogs\x18\x03 \x03(\x0b\x32\x1e.milvus.proto.data.FieldBinlog\x12\x31\n\tstatslogs\x18\x04 \x03(\x0b\x32\x1e.milvus.proto.data.FieldBinlog\"\xea\x01\n\x13QueryImportResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\x0e\n\x06taskID\x18\x02 \x01(\x03\x12\x33\n\x05state\x18\x03 \x01(\x0e\x32$.milvus.proto.data.ImportTaskStateV2\x12\x0e\n\x06reason\x18\x04 \x01(\t\x12\r\n\x05slots\x18\x05 \x01(\x03\x12\x42\n\x14import_segments_info\x18\x06 \x03(\x0b\x32$.milvus.proto.data.ImportSegmentInfo\"E\n\x11\x44ropImportRequest\x12\x11\n\tclusterID\x18\x01 \x01(\t\x12\r\n\x05jobID\x18\x02 \x01(\x03\x12\x0e\n\x06taskID\x18\x03 \x01(\x03\"\xf2\x02\n\tImportJob\x12\r\n\x05jobID\x18\x01 \x01(\x03\x12\x0c\n\x04\x64\x62ID\x18\x02 \x01(\x03\x12\x14\n\x0c\x63ollectionID\x18\x03 \x01(\x03\x12\x14\n\x0cpartitionIDs\x18\x04 \x03(\x03\x12\x11\n\tvchannels\x18\x05 \x03(\t\x12\x35\n\x06schema\x18\x06 \x01(\x0b\x32%.milvus.proto.schema.CollectionSchema\x12\x12\n\ntimeout_ts\x18\x07 \x01(\x04\x12\x12\n\ncleanup_ts\x18\x08 \x01(\x04\x12\x34\n\x05state\x18\t \x01(\x0e\x32%.milvus.proto.internal.ImportJobState\x12\x0e\n\x06reason\x18\n \x01(\t\x12\x30\n\x05\x66iles\x18\x0b \x03(\x0b\x32!.milvus.proto.internal.ImportFile\x12\x32\n\x07options\x18\x0c \x03(\x0b\x32!.milvus.proto.common.KeyValuePair\"\xd1\x01\n\rPreImportTask\x12\r\n\x05jobID\x18\x01 \x01(\x03\x12\x0e\n\x06taskID\x18\x02 \x01(\x03\x12\x14\n\x0c\x63ollectionID\x18\x03 \x01(\x03\x12\x0e\n\x06nodeID\x18\x06 \x01(\x03\x12\x33\n\x05state\x18\x07 \x01(\x0e\x32$.milvus.proto.data.ImportTaskStateV2\x12\x0e\n\x06reason\x18\x08 \x01(\t\x12\x36\n\nfile_stats\x18\n \x03(\x0b\x32\".milvus.proto.data.ImportFileStats\"\xe4\x01\n\x0cImportTaskV2\x12\r\n\x05jobID\x18\x01 \x01(\x03\x12\x0e\n\x06taskID\x18\x02 \x01(\x03\x12\x14\n\x0c\x63ollectionID\x18\x03 \x01(\x03\x12\x12\n\nsegmentIDs\x18\x04 \x03(\x03\x12\x0e\n\x06nodeID\x18\x05 \x01(\x03\x12\x33\n\x05state\x18\x06 \x01(\x0e\x32$.milvus.proto.data.ImportTaskStateV2\x12\x0e\n\x06reason\x18\x07 \x01(\t\x12\x36\n\nfile_stats\x18\t \x03(\x0b\x32\".milvus.proto.data.ImportFileStats\"\xa0\x01\n\x10GcControlRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12-\n\x07\x63ommand\x18\x02 \x01(\x0e\x32\x1c.milvus.proto.data.GcCommand\x12\x31\n\x06params\x18\x03 \x03(\x0b\x32!.milvus.proto.common.KeyValuePair*>\n\x0bSegmentType\x12\x07\n\x03New\x10\x00\x12\n\n\x06Normal\x10\x01\x12\x0b\n\x07\x46lushed\x10\x02\x12\r\n\tCompacted\x10\x03*2\n\x0cSegmentLevel\x12\n\n\x06Legacy\x10\x00\x12\x06\n\x02L0\x10\x01\x12\x06\n\x02L1\x10\x02\x12\x06\n\x02L2\x10\x03*\x99\x01\n\x11\x43hannelWatchState\x12\x0e\n\nUncomplete\x10\x00\x12\x0c\n\x08\x43omplete\x10\x01\x12\x0b\n\x07ToWatch\x10\x02\x12\x10\n\x0cWatchSuccess\x10\x03\x12\x10\n\x0cWatchFailure\x10\x04\x12\r\n\tToRelease\x10\x05\x12\x12\n\x0eReleaseSuccess\x10\x06\x12\x12\n\x0eReleaseFailure\x10\x07*\xb3\x01\n\x0e\x43ompactionType\x12\x17\n\x13UndefinedCompaction\x10\x00\x12\x13\n\x0fMergeCompaction\x10\x02\x12\x11\n\rMixCompaction\x10\x03\x12\x14\n\x10SingleCompaction\x10\x04\x12\x13\n\x0fMinorCompaction\x10\x05\x12\x13\n\x0fMajorCompaction\x10\x06\x12\x1a\n\x16Level0DeleteCompaction\x10\x07\"\x04\x08\x01\x10\x01*U\n\x11ImportTaskStateV2\x12\x08\n\x04None\x10\x00\x12\x0b\n\x07Pending\x10\x01\x12\x0e\n\nInProgress\x10\x02\x12\n\n\x06\x46\x61iled\x10\x03\x12\r\n\tCompleted\x10\x04*)\n\tGcCommand\x12\x05\n\x01_\x10\x00\x12\t\n\x05Pause\x10\x01\x12\n\n\x06Resume\x10\x02\x32\x8b*\n\tDataCoord\x12l\n\x12GetComponentStates\x12..milvus.proto.milvus.GetComponentStatesRequest\x1a$.milvus.proto.milvus.ComponentStates\"\x00\x12m\n\x12GetTimeTickChannel\x12\x30.milvus.proto.internal.GetTimeTickChannelRequest\x1a#.milvus.proto.milvus.StringResponse\"\x00\x12q\n\x14GetStatisticsChannel\x12\x32.milvus.proto.internal.GetStatisticsChannelRequest\x1a#.milvus.proto.milvus.StringResponse\"\x00\x12L\n\x05\x46lush\x12\x1f.milvus.proto.data.FlushRequest\x1a .milvus.proto.data.FlushResponse\"\x00\x12j\n\x0f\x41ssignSegmentID\x12).milvus.proto.data.AssignSegmentIDRequest\x1a*.milvus.proto.data.AssignSegmentIDResponse\"\x00\x12g\n\x0eGetSegmentInfo\x12(.milvus.proto.data.GetSegmentInfoRequest\x1a).milvus.proto.data.GetSegmentInfoResponse\"\x00\x12m\n\x10GetSegmentStates\x12*.milvus.proto.data.GetSegmentStatesRequest\x1a+.milvus.proto.data.GetSegmentStatesResponse\"\x00\x12y\n\x14GetInsertBinlogPaths\x12..milvus.proto.data.GetInsertBinlogPathsRequest\x1a/.milvus.proto.data.GetInsertBinlogPathsResponse\"\x00\x12\x82\x01\n\x17GetCollectionStatistics\x12\x31.milvus.proto.data.GetCollectionStatisticsRequest\x1a\x32.milvus.proto.data.GetCollectionStatisticsResponse\"\x00\x12\x7f\n\x16GetPartitionStatistics\x12\x30.milvus.proto.data.GetPartitionStatisticsRequest\x1a\x31.milvus.proto.data.GetPartitionStatisticsResponse\"\x00\x12o\n\x15GetSegmentInfoChannel\x12/.milvus.proto.data.GetSegmentInfoChannelRequest\x1a#.milvus.proto.milvus.StringResponse\"\x00\x12[\n\x0fSaveBinlogPaths\x12).milvus.proto.data.SaveBinlogPathsRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12j\n\x0fGetRecoveryInfo\x12).milvus.proto.data.GetRecoveryInfoRequest\x1a*.milvus.proto.data.GetRecoveryInfoResponse\"\x00\x12p\n\x11GetRecoveryInfoV2\x12+.milvus.proto.data.GetRecoveryInfoRequestV2\x1a,.milvus.proto.data.GetRecoveryInfoResponseV2\"\x00\x12s\n\x12GetFlushedSegments\x12,.milvus.proto.data.GetFlushedSegmentsRequest\x1a-.milvus.proto.data.GetFlushedSegmentsResponse\"\x00\x12v\n\x13GetSegmentsByStates\x12-.milvus.proto.data.GetSegmentsByStatesRequest\x1a..milvus.proto.data.GetSegmentsByStatesResponse\"\x00\x12q\n\x10GetFlushAllState\x12,.milvus.proto.milvus.GetFlushAllStateRequest\x1a-.milvus.proto.milvus.GetFlushAllStateResponse\"\x00\x12{\n\x12ShowConfigurations\x12\x30.milvus.proto.internal.ShowConfigurationsRequest\x1a\x31.milvus.proto.internal.ShowConfigurationsResponse\"\x00\x12_\n\nGetMetrics\x12&.milvus.proto.milvus.GetMetricsRequest\x1a\'.milvus.proto.milvus.GetMetricsResponse\"\x00\x12q\n\x10ManualCompaction\x12,.milvus.proto.milvus.ManualCompactionRequest\x1a-.milvus.proto.milvus.ManualCompactionResponse\"\x00\x12w\n\x12GetCompactionState\x12..milvus.proto.milvus.GetCompactionStateRequest\x1a/.milvus.proto.milvus.GetCompactionStateResponse\"\x00\x12\x80\x01\n\x1bGetCompactionStateWithPlans\x12..milvus.proto.milvus.GetCompactionPlansRequest\x1a/.milvus.proto.milvus.GetCompactionPlansResponse\"\x00\x12\x64\n\rWatchChannels\x12\'.milvus.proto.data.WatchChannelsRequest\x1a(.milvus.proto.data.WatchChannelsResponse\"\x00\x12\x66\n\rGetFlushState\x12\'.milvus.proto.data.GetFlushStateRequest\x1a*.milvus.proto.milvus.GetFlushStateResponse\"\x00\x12s\n\x12\x44ropVirtualChannel\x12,.milvus.proto.data.DropVirtualChannelRequest\x1a-.milvus.proto.data.DropVirtualChannelResponse\"\x00\x12j\n\x0fSetSegmentState\x12).milvus.proto.data.SetSegmentStateRequest\x1a*.milvus.proto.data.SetSegmentStateResponse\"\x00\x12W\n\x06Import\x12$.milvus.proto.data.ImportTaskRequest\x1a%.milvus.proto.data.ImportTaskResponse\"\x00\x12k\n\x17UpdateSegmentStatistics\x12\x31.milvus.proto.data.UpdateSegmentStatisticsRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12k\n\x17UpdateChannelCheckpoint\x12\x31.milvus.proto.data.UpdateChannelCheckpointRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12_\n\x11SaveImportSegment\x12+.milvus.proto.data.SaveImportSegmentRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12g\n\x15UnsetIsImportingState\x12/.milvus.proto.data.UnsetIsImportingStateRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12\x63\n\x13MarkSegmentsDropped\x12-.milvus.proto.data.MarkSegmentsDroppedRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12\x66\n\x1a\x42roadcastAlteredCollection\x12).milvus.proto.data.AlterCollectionRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12\x62\n\x0b\x43heckHealth\x12\'.milvus.proto.milvus.CheckHealthRequest\x1a(.milvus.proto.milvus.CheckHealthResponse\"\x00\x12T\n\x0b\x43reateIndex\x12&.milvus.proto.index.CreateIndexRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12R\n\nAlterIndex\x12%.milvus.proto.index.AlterIndexRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12\x66\n\rGetIndexState\x12(.milvus.proto.index.GetIndexStateRequest\x1a).milvus.proto.index.GetIndexStateResponse\"\x00\x12{\n\x14GetSegmentIndexState\x12/.milvus.proto.index.GetSegmentIndexStateRequest\x1a\x30.milvus.proto.index.GetSegmentIndexStateResponse\"\x00\x12\x64\n\rGetIndexInfos\x12\'.milvus.proto.index.GetIndexInfoRequest\x1a(.milvus.proto.index.GetIndexInfoResponse\"\x00\x12P\n\tDropIndex\x12$.milvus.proto.index.DropIndexRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12\x66\n\rDescribeIndex\x12(.milvus.proto.index.DescribeIndexRequest\x1a).milvus.proto.index.DescribeIndexResponse\"\x00\x12u\n\x12GetIndexStatistics\x12-.milvus.proto.index.GetIndexStatisticsRequest\x1a..milvus.proto.index.GetIndexStatisticsResponse\"\x00\x12~\n\x15GetIndexBuildProgress\x12\x30.milvus.proto.index.GetIndexBuildProgressRequest\x1a\x31.milvus.proto.index.GetIndexBuildProgressResponse\"\x00\x12`\n\x0bListIndexes\x12&.milvus.proto.index.ListIndexesRequest\x1a\'.milvus.proto.index.ListIndexesResponse\"\x00\x12X\n\tGcConfirm\x12#.milvus.proto.data.GcConfirmRequest\x1a$.milvus.proto.data.GcConfirmResponse\"\x00\x12\x65\n\x14ReportDataNodeTtMsgs\x12..milvus.proto.data.ReportDataNodeTtMsgsRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12O\n\tGcControl\x12#.milvus.proto.data.GcControlRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12\x61\n\x08ImportV2\x12,.milvus.proto.internal.ImportRequestInternal\x1a%.milvus.proto.internal.ImportResponse\"\x00\x12x\n\x11GetImportProgress\x12/.milvus.proto.internal.GetImportProgressRequest\x1a\x30.milvus.proto.internal.GetImportProgressResponse\"\x00\x12n\n\x0bListImports\x12\x31.milvus.proto.internal.ListImportsRequestInternal\x1a*.milvus.proto.internal.ListImportsResponse\"\x00\x32\xbe\x0f\n\x08\x44\x61taNode\x12l\n\x12GetComponentStates\x12..milvus.proto.milvus.GetComponentStatesRequest\x1a$.milvus.proto.milvus.ComponentStates\"\x00\x12q\n\x14GetStatisticsChannel\x12\x32.milvus.proto.internal.GetStatisticsChannelRequest\x1a#.milvus.proto.milvus.StringResponse\"\x00\x12[\n\x0fWatchDmChannels\x12).milvus.proto.data.WatchDmChannelsRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12W\n\rFlushSegments\x12\'.milvus.proto.data.FlushSegmentsRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12{\n\x12ShowConfigurations\x12\x30.milvus.proto.internal.ShowConfigurationsRequest\x1a\x31.milvus.proto.internal.ShowConfigurationsResponse\"\x00\x12_\n\nGetMetrics\x12&.milvus.proto.milvus.GetMetricsRequest\x1a\'.milvus.proto.milvus.GetMetricsResponse\"\x00\x12N\n\nCompaction\x12!.milvus.proto.data.CompactionPlan\x1a\x1b.milvus.proto.common.Status\"\x00\x12m\n\x12GetCompactionState\x12).milvus.proto.data.CompactionStateRequest\x1a*.milvus.proto.data.CompactionStateResponse\"\x00\x12U\n\x0cSyncSegments\x12&.milvus.proto.data.SyncSegmentsRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12M\n\x06Import\x12$.milvus.proto.data.ImportTaskRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12s\n\x12ResendSegmentStats\x12,.milvus.proto.data.ResendSegmentStatsRequest\x1a-.milvus.proto.data.ResendSegmentStatsResponse\"\x00\x12m\n\x10\x41\x64\x64ImportSegment\x12*.milvus.proto.data.AddImportSegmentRequest\x1a+.milvus.proto.data.AddImportSegmentResponse\"\x00\x12W\n\rFlushChannels\x12\'.milvus.proto.data.FlushChannelsRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12\x64\n\x16NotifyChannelOperation\x12+.milvus.proto.data.ChannelOperationsRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12{\n\x1d\x43heckChannelOperationProgress\x12#.milvus.proto.data.ChannelWatchInfo\x1a\x33.milvus.proto.data.ChannelOperationProgressResponse\"\x00\x12O\n\tPreImport\x12#.milvus.proto.data.PreImportRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12K\n\x08ImportV2\x12 .milvus.proto.data.ImportRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12g\n\x0eQueryPreImport\x12(.milvus.proto.data.QueryPreImportRequest\x1a).milvus.proto.data.QueryPreImportResponse\"\x00\x12^\n\x0bQueryImport\x12%.milvus.proto.data.QueryImportRequest\x1a&.milvus.proto.data.QueryImportResponse\"\x00\x12Q\n\nDropImport\x12$.milvus.proto.data.DropImportRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x42\x33Z1github.com/milvus-io/milvus/internal/proto/datapbb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'data_coord_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + _globals['DESCRIPTOR']._options = None + _globals['DESCRIPTOR']._serialized_options = b'Z1github.com/milvus-io/milvus/internal/proto/datapb' + _globals['_GETSEGMENTINFORESPONSE_CHANNELCHECKPOINTENTRY']._options = None + _globals['_GETSEGMENTINFORESPONSE_CHANNELCHECKPOINTENTRY']._serialized_options = b'8\001' + _globals['_IMPORTTASKINFO'].fields_by_name['request_id']._options = None + _globals['_IMPORTTASKINFO'].fields_by_name['request_id']._serialized_options = b'\030\001' + _globals['_PARTITIONIMPORTSTATS_PARTITIONROWSENTRY']._options = None + _globals['_PARTITIONIMPORTSTATS_PARTITIONROWSENTRY']._serialized_options = b'8\001' + _globals['_PARTITIONIMPORTSTATS_PARTITIONDATASIZEENTRY']._options = None + _globals['_PARTITIONIMPORTSTATS_PARTITIONDATASIZEENTRY']._serialized_options = b'8\001' + _globals['_IMPORTFILESTATS_HASHEDSTATSENTRY']._options = None + _globals['_IMPORTFILESTATS_HASHEDSTATSENTRY']._serialized_options = b'8\001' + _globals['_SEGMENTTYPE']._serialized_start=16672 + _globals['_SEGMENTTYPE']._serialized_end=16734 + _globals['_SEGMENTLEVEL']._serialized_start=16736 + _globals['_SEGMENTLEVEL']._serialized_end=16786 + _globals['_CHANNELWATCHSTATE']._serialized_start=16789 + _globals['_CHANNELWATCHSTATE']._serialized_end=16942 + _globals['_COMPACTIONTYPE']._serialized_start=16945 + _globals['_COMPACTIONTYPE']._serialized_end=17124 + _globals['_IMPORTTASKSTATEV2']._serialized_start=17126 + _globals['_IMPORTTASKSTATEV2']._serialized_end=17211 + _globals['_GCCOMMAND']._serialized_start=17213 + _globals['_GCCOMMAND']._serialized_end=17254 + _globals['_EMPTY']._serialized_start=127 + _globals['_EMPTY']._serialized_end=134 + _globals['_FLUSHREQUEST']._serialized_start=137 + _globals['_FLUSHREQUEST']._serialized_end=269 + _globals['_FLUSHRESPONSE']._serialized_start=272 + _globals['_FLUSHRESPONSE']._serialized_end=451 + _globals['_FLUSHCHANNELSREQUEST']._serialized_start=453 + _globals['_FLUSHCHANNELSREQUEST']._serialized_end=555 + _globals['_SEGMENTIDREQUEST']._serialized_start=558 + _globals['_SEGMENTIDREQUEST']._serialized_end=744 + _globals['_ASSIGNSEGMENTIDREQUEST']._serialized_start=746 + _globals['_ASSIGNSEGMENTIDREQUEST']._serialized_end=869 + _globals['_SEGMENTIDASSIGNMENT']._serialized_start=872 + _globals['_SEGMENTIDASSIGNMENT']._serialized_end=1054 + _globals['_ASSIGNSEGMENTIDRESPONSE']._serialized_start=1057 + _globals['_ASSIGNSEGMENTIDRESPONSE']._serialized_end=1193 + _globals['_GETSEGMENTSTATESREQUEST']._serialized_start=1195 + _globals['_GETSEGMENTSTATESREQUEST']._serialized_end=1284 + _globals['_SEGMENTSTATEINFO']._serialized_start=1287 + _globals['_SEGMENTSTATEINFO']._serialized_end=1527 + _globals['_GETSEGMENTSTATESRESPONSE']._serialized_start=1529 + _globals['_GETSEGMENTSTATESRESPONSE']._serialized_end=1653 + _globals['_GETSEGMENTINFOREQUEST']._serialized_start=1655 + _globals['_GETSEGMENTINFOREQUEST']._serialized_end=1768 + _globals['_GETSEGMENTINFORESPONSE']._serialized_start=1771 + _globals['_GETSEGMENTINFORESPONSE']._serialized_end=2070 + _globals['_GETSEGMENTINFORESPONSE_CHANNELCHECKPOINTENTRY']._serialized_start=1983 + _globals['_GETSEGMENTINFORESPONSE_CHANNELCHECKPOINTENTRY']._serialized_end=2070 + _globals['_GETINSERTBINLOGPATHSREQUEST']._serialized_start=2072 + _globals['_GETINSERTBINLOGPATHSREQUEST']._serialized_end=2164 + _globals['_GETINSERTBINLOGPATHSRESPONSE']._serialized_start=2167 + _globals['_GETINSERTBINLOGPATHSRESPONSE']._serialized_end=2310 + _globals['_GETCOLLECTIONSTATISTICSREQUEST']._serialized_start=2312 + _globals['_GETCOLLECTIONSTATISTICSREQUEST']._serialized_end=2424 + _globals['_GETCOLLECTIONSTATISTICSRESPONSE']._serialized_start=2427 + _globals['_GETCOLLECTIONSTATISTICSRESPONSE']._serialized_end=2555 + _globals['_GETPARTITIONSTATISTICSREQUEST']._serialized_start=2558 + _globals['_GETPARTITIONSTATISTICSREQUEST']._serialized_end=2691 + _globals['_GETPARTITIONSTATISTICSRESPONSE']._serialized_start=2693 + _globals['_GETPARTITIONSTATISTICSRESPONSE']._serialized_end=2820 + _globals['_GETSEGMENTINFOCHANNELREQUEST']._serialized_start=2822 + _globals['_GETSEGMENTINFOCHANNELREQUEST']._serialized_end=2852 + _globals['_VCHANNELINFO']._serialized_start=2855 + _globals['_VCHANNELINFO']._serialized_end=3342 + _globals['_WATCHDMCHANNELSREQUEST']._serialized_start=3344 + _globals['_WATCHDMCHANNELSREQUEST']._serialized_end=3464 + _globals['_FLUSHSEGMENTSREQUEST']._serialized_start=3467 + _globals['_FLUSHSEGMENTSREQUEST']._serialized_end=3610 + _globals['_SEGMENTMSG']._serialized_start=3612 + _globals['_SEGMENTMSG']._serialized_end=3717 + _globals['_SEGMENTINFO']._serialized_start=3720 + _globals['_SEGMENTINFO']._serialized_end=4393 + _globals['_SEGMENTSTARTPOSITION']._serialized_start=4395 + _globals['_SEGMENTSTARTPOSITION']._serialized_end=4491 + _globals['_SAVEBINLOGPATHSREQUEST']._serialized_start=4494 + _globals['_SAVEBINLOGPATHSREQUEST']._serialized_end=5059 + _globals['_CHECKPOINT']._serialized_start=5061 + _globals['_CHECKPOINT']._serialized_end=5162 + _globals['_DELTALOGINFO']._serialized_start=5165 + _globals['_DELTALOGINFO']._serialized_end=5297 + _globals['_CHANNELSTATUS']._serialized_start=5299 + _globals['_CHANNELSTATUS']._serialized_end=5403 + _globals['_DATANODEINFO']._serialized_start=5405 + _globals['_DATANODEINFO']._serialized_end=5505 + _globals['_SEGMENTBINLOGS']._serialized_start=5508 + _globals['_SEGMENTBINLOGS']._serialized_end=5744 + _globals['_FIELDBINLOG']._serialized_start=5746 + _globals['_FIELDBINLOG']._serialized_end=5820 + _globals['_BINLOG']._serialized_start=5822 + _globals['_BINLOG']._serialized_end=5948 + _globals['_GETRECOVERYINFORESPONSE']._serialized_start=5951 + _globals['_GETRECOVERYINFORESPONSE']._serialized_end=6124 + _globals['_GETRECOVERYINFOREQUEST']._serialized_start=6126 + _globals['_GETRECOVERYINFOREQUEST']._serialized_end=6237 + _globals['_GETRECOVERYINFORESPONSEV2']._serialized_start=6240 + _globals['_GETRECOVERYINFORESPONSEV2']._serialized_end=6413 + _globals['_GETRECOVERYINFOREQUESTV2']._serialized_start=6415 + _globals['_GETRECOVERYINFOREQUESTV2']._serialized_end=6529 + _globals['_GETSEGMENTSBYSTATESREQUEST']._serialized_start=6532 + _globals['_GETSEGMENTSBYSTATESREQUEST']._serialized_end=6698 + _globals['_GETSEGMENTSBYSTATESRESPONSE']._serialized_start=6700 + _globals['_GETSEGMENTSBYSTATESRESPONSE']._serialized_end=6792 + _globals['_GETFLUSHEDSEGMENTSREQUEST']._serialized_start=6795 + _globals['_GETFLUSHEDSEGMENTSREQUEST']._serialized_end=6935 + _globals['_GETFLUSHEDSEGMENTSRESPONSE']._serialized_start=6937 + _globals['_GETFLUSHEDSEGMENTSRESPONSE']._serialized_end=7028 + _globals['_SEGMENTFLUSHCOMPLETEDMSG']._serialized_start=7030 + _globals['_SEGMENTFLUSHCOMPLETEDMSG']._serialized_end=7149 + _globals['_CHANNELWATCHINFO']._serialized_start=7152 + _globals['_CHANNELWATCHINFO']._serialized_end=7394 + _globals['_COMPACTIONSTATEREQUEST']._serialized_start=7396 + _globals['_COMPACTIONSTATEREQUEST']._serialized_end=7464 + _globals['_SYNCSEGMENTSREQUEST']._serialized_start=7467 + _globals['_SYNCSEGMENTSREQUEST']._serialized_end=7690 + _globals['_COMPACTIONSEGMENTBINLOGS']._serialized_start=7693 + _globals['_COMPACTIONSEGMENTBINLOGS']._serialized_end=8019 + _globals['_COMPACTIONPLAN']._serialized_start=8022 + _globals['_COMPACTIONPLAN']._serialized_end=8301 + _globals['_COMPACTIONSEGMENT']._serialized_start=8304 + _globals['_COMPACTIONSEGMENT']._serialized_end=8561 + _globals['_COMPACTIONPLANRESULT']._serialized_start=8564 + _globals['_COMPACTIONPLANRESULT']._serialized_end=8777 + _globals['_COMPACTIONSTATERESPONSE']._serialized_start=8780 + _globals['_COMPACTIONSTATERESPONSE']._serialized_end=8908 + _globals['_SEGMENTFIELDBINLOGMETA']._serialized_start=8910 + _globals['_SEGMENTFIELDBINLOGMETA']._serialized_end=8972 + _globals['_WATCHCHANNELSREQUEST']._serialized_start=8975 + _globals['_WATCHCHANNELSREQUEST']._serialized_end=9181 + _globals['_WATCHCHANNELSRESPONSE']._serialized_start=9183 + _globals['_WATCHCHANNELSRESPONSE']._serialized_end=9251 + _globals['_SETSEGMENTSTATEREQUEST']._serialized_start=9254 + _globals['_SETSEGMENTSTATEREQUEST']._serialized_end=9396 + _globals['_SETSEGMENTSTATERESPONSE']._serialized_start=9398 + _globals['_SETSEGMENTSTATERESPONSE']._serialized_end=9468 + _globals['_DROPVIRTUALCHANNELREQUEST']._serialized_start=9471 + _globals['_DROPVIRTUALCHANNELREQUEST']._serialized_end=9628 + _globals['_DROPVIRTUALCHANNELSEGMENT']._serialized_start=9631 + _globals['_DROPVIRTUALCHANNELSEGMENT']._serialized_end=9994 + _globals['_DROPVIRTUALCHANNELRESPONSE']._serialized_start=9996 + _globals['_DROPVIRTUALCHANNELRESPONSE']._serialized_end=10069 + _globals['_IMPORTTASK']._serialized_start=10072 + _globals['_IMPORTTASK']._serialized_end=10321 + _globals['_IMPORTTASKSTATE']._serialized_start=10324 + _globals['_IMPORTTASKSTATE']._serialized_end=10471 + _globals['_IMPORTTASKINFO']._serialized_start=10474 + _globals['_IMPORTTASKINFO']._serialized_end=10875 + _globals['_IMPORTTASKRESPONSE']._serialized_start=10877 + _globals['_IMPORTTASKRESPONSE']._serialized_end=10963 + _globals['_IMPORTTASKREQUEST']._serialized_start=10966 + _globals['_IMPORTTASKREQUEST']._serialized_end=11104 + _globals['_UPDATESEGMENTSTATISTICSREQUEST']._serialized_start=11106 + _globals['_UPDATESEGMENTSTATISTICSREQUEST']._serialized_end=11232 + _globals['_UPDATECHANNELCHECKPOINTREQUEST']._serialized_start=11235 + _globals['_UPDATECHANNELCHECKPOINTREQUEST']._serialized_end=11438 + _globals['_RESENDSEGMENTSTATSREQUEST']._serialized_start=11440 + _globals['_RESENDSEGMENTSTATSREQUEST']._serialized_end=11511 + _globals['_RESENDSEGMENTSTATSRESPONSE']._serialized_start=11513 + _globals['_RESENDSEGMENTSTATSRESPONSE']._serialized_end=11606 + _globals['_ADDIMPORTSEGMENTREQUEST']._serialized_start=11609 + _globals['_ADDIMPORTSEGMENTREQUEST']._serialized_end=11833 + _globals['_ADDIMPORTSEGMENTRESPONSE']._serialized_start=11835 + _globals['_ADDIMPORTSEGMENTRESPONSE']._serialized_end=11927 + _globals['_SAVEIMPORTSEGMENTREQUEST']._serialized_start=11930 + _globals['_SAVEIMPORTSEGMENTREQUEST']._serialized_end=12202 + _globals['_UNSETISIMPORTINGSTATEREQUEST']._serialized_start=12204 + _globals['_UNSETISIMPORTINGSTATEREQUEST']._serialized_end=12299 + _globals['_MARKSEGMENTSDROPPEDREQUEST']._serialized_start=12301 + _globals['_MARKSEGMENTSDROPPEDREQUEST']._serialized_end=12394 + _globals['_SEGMENTREFERENCELOCK']._serialized_start=12396 + _globals['_SEGMENTREFERENCELOCK']._serialized_end=12470 + _globals['_ALTERCOLLECTIONREQUEST']._serialized_start=12473 + _globals['_ALTERCOLLECTIONREQUEST']._serialized_end=12710 + _globals['_GCCONFIRMREQUEST']._serialized_start=12712 + _globals['_GCCONFIRMREQUEST']._serialized_end=12775 + _globals['_GCCONFIRMRESPONSE']._serialized_start=12777 + _globals['_GCCONFIRMRESPONSE']._serialized_end=12862 + _globals['_REPORTDATANODETTMSGSREQUEST']._serialized_start=12864 + _globals['_REPORTDATANODETTMSGSREQUEST']._serialized_end=12984 + _globals['_GETFLUSHSTATEREQUEST']._serialized_start=12986 + _globals['_GETFLUSHSTATEREQUEST']._serialized_end=13110 + _globals['_CHANNELOPERATIONSREQUEST']._serialized_start=13112 + _globals['_CHANNELOPERATIONSREQUEST']._serialized_end=13190 + _globals['_CHANNELOPERATIONPROGRESSRESPONSE']._serialized_start=13193 + _globals['_CHANNELOPERATIONPROGRESSRESPONSE']._serialized_end=13357 + _globals['_PREIMPORTREQUEST']._serialized_start=13360 + _globals['_PREIMPORTREQUEST']._serialized_end=13655 + _globals['_AUTOIDRANGE']._serialized_start=13657 + _globals['_AUTOIDRANGE']._serialized_end=13698 + _globals['_IMPORTREQUESTSEGMENT']._serialized_start=13700 + _globals['_IMPORTREQUESTSEGMENT']._serialized_end=13780 + _globals['_IMPORTREQUEST']._serialized_start=13783 + _globals['_IMPORTREQUEST']._serialized_end=14201 + _globals['_QUERYPREIMPORTREQUEST']._serialized_start=14203 + _globals['_QUERYPREIMPORTREQUEST']._serialized_end=14276 + _globals['_PARTITIONIMPORTSTATS']._serialized_start=14279 + _globals['_PARTITIONIMPORTSTATS']._serialized_end=14590 + _globals['_PARTITIONIMPORTSTATS_PARTITIONROWSENTRY']._serialized_start=14480 + _globals['_PARTITIONIMPORTSTATS_PARTITIONROWSENTRY']._serialized_end=14532 + _globals['_PARTITIONIMPORTSTATS_PARTITIONDATASIZEENTRY']._serialized_start=14534 + _globals['_PARTITIONIMPORTSTATS_PARTITIONDATASIZEENTRY']._serialized_end=14590 + _globals['_IMPORTFILESTATS']._serialized_start=14593 + _globals['_IMPORTFILESTATS']._serialized_end=14900 + _globals['_IMPORTFILESTATS_HASHEDSTATSENTRY']._serialized_start=14809 + _globals['_IMPORTFILESTATS_HASHEDSTATSENTRY']._serialized_end=14900 + _globals['_QUERYPREIMPORTRESPONSE']._serialized_start=14903 + _globals['_QUERYPREIMPORTRESPONSE']._serialized_end=15128 + _globals['_QUERYIMPORTREQUEST']._serialized_start=15130 + _globals['_QUERYIMPORTREQUEST']._serialized_end=15219 + _globals['_IMPORTSEGMENTINFO']._serialized_start=15222 + _globals['_IMPORTSEGMENTINFO']._serialized_end=15383 + _globals['_QUERYIMPORTRESPONSE']._serialized_start=15386 + _globals['_QUERYIMPORTRESPONSE']._serialized_end=15620 + _globals['_DROPIMPORTREQUEST']._serialized_start=15622 + _globals['_DROPIMPORTREQUEST']._serialized_end=15691 + _globals['_IMPORTJOB']._serialized_start=15694 + _globals['_IMPORTJOB']._serialized_end=16064 + _globals['_PREIMPORTTASK']._serialized_start=16067 + _globals['_PREIMPORTTASK']._serialized_end=16276 + _globals['_IMPORTTASKV2']._serialized_start=16279 + _globals['_IMPORTTASKV2']._serialized_end=16507 + _globals['_GCCONTROLREQUEST']._serialized_start=16510 + _globals['_GCCONTROLREQUEST']._serialized_end=16670 + _globals['_DATACOORD']._serialized_start=17257 + _globals['_DATACOORD']._serialized_end=22644 + _globals['_DATANODE']._serialized_start=22647 + _globals['_DATANODE']._serialized_end=24629 +# @@protoc_insertion_point(module_scope) diff --git a/milvus_connector/protocol/data_coord_pb2.pyi b/milvus_connector/protocol/data_coord_pb2.pyi new file mode 100644 index 0000000..ff5f96e --- /dev/null +++ b/milvus_connector/protocol/data_coord_pb2.pyi @@ -0,0 +1,1363 @@ +from . import common_pb2 as _common_pb2 +from . import internal_pb2 as _internal_pb2 +from . import milvus_pb2 as _milvus_pb2 +from . import schema_pb2 as _schema_pb2 +from . import msg_pb2 as _msg_pb2 +from . import index_coord_pb2 as _index_coord_pb2 +from google.protobuf.internal import containers as _containers +from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Iterable as _Iterable, Mapping as _Mapping, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class SegmentType(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = () + New: _ClassVar[SegmentType] + Normal: _ClassVar[SegmentType] + Flushed: _ClassVar[SegmentType] + Compacted: _ClassVar[SegmentType] + +class SegmentLevel(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = () + Legacy: _ClassVar[SegmentLevel] + L0: _ClassVar[SegmentLevel] + L1: _ClassVar[SegmentLevel] + L2: _ClassVar[SegmentLevel] + +class ChannelWatchState(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = () + Uncomplete: _ClassVar[ChannelWatchState] + Complete: _ClassVar[ChannelWatchState] + ToWatch: _ClassVar[ChannelWatchState] + WatchSuccess: _ClassVar[ChannelWatchState] + WatchFailure: _ClassVar[ChannelWatchState] + ToRelease: _ClassVar[ChannelWatchState] + ReleaseSuccess: _ClassVar[ChannelWatchState] + ReleaseFailure: _ClassVar[ChannelWatchState] + +class CompactionType(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = () + UndefinedCompaction: _ClassVar[CompactionType] + MergeCompaction: _ClassVar[CompactionType] + MixCompaction: _ClassVar[CompactionType] + SingleCompaction: _ClassVar[CompactionType] + MinorCompaction: _ClassVar[CompactionType] + MajorCompaction: _ClassVar[CompactionType] + Level0DeleteCompaction: _ClassVar[CompactionType] + +class ImportTaskStateV2(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = () + None: _ClassVar[ImportTaskStateV2] + Pending: _ClassVar[ImportTaskStateV2] + InProgress: _ClassVar[ImportTaskStateV2] + Failed: _ClassVar[ImportTaskStateV2] + Completed: _ClassVar[ImportTaskStateV2] + +class GcCommand(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = () + _: _ClassVar[GcCommand] + Pause: _ClassVar[GcCommand] + Resume: _ClassVar[GcCommand] +New: SegmentType +Normal: SegmentType +Flushed: SegmentType +Compacted: SegmentType +Legacy: SegmentLevel +L0: SegmentLevel +L1: SegmentLevel +L2: SegmentLevel +Uncomplete: ChannelWatchState +Complete: ChannelWatchState +ToWatch: ChannelWatchState +WatchSuccess: ChannelWatchState +WatchFailure: ChannelWatchState +ToRelease: ChannelWatchState +ReleaseSuccess: ChannelWatchState +ReleaseFailure: ChannelWatchState +UndefinedCompaction: CompactionType +MergeCompaction: CompactionType +MixCompaction: CompactionType +SingleCompaction: CompactionType +MinorCompaction: CompactionType +MajorCompaction: CompactionType +Level0DeleteCompaction: CompactionType +None: ImportTaskStateV2 +Pending: ImportTaskStateV2 +InProgress: ImportTaskStateV2 +Failed: ImportTaskStateV2 +Completed: ImportTaskStateV2 +_: GcCommand +Pause: GcCommand +Resume: GcCommand + +class Empty(_message.Message): + __slots__ = () + def __init__(self) -> None: ... + +class FlushRequest(_message.Message): + __slots__ = ("base", "dbID", "segmentIDs", "collectionID", "isImport") + BASE_FIELD_NUMBER: _ClassVar[int] + DBID_FIELD_NUMBER: _ClassVar[int] + SEGMENTIDS_FIELD_NUMBER: _ClassVar[int] + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + ISIMPORT_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + dbID: int + segmentIDs: _containers.RepeatedScalarFieldContainer[int] + collectionID: int + isImport: bool + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., dbID: _Optional[int] = ..., segmentIDs: _Optional[_Iterable[int]] = ..., collectionID: _Optional[int] = ..., isImport: bool = ...) -> None: ... + +class FlushResponse(_message.Message): + __slots__ = ("status", "dbID", "collectionID", "segmentIDs", "flushSegmentIDs", "timeOfSeal", "flush_ts") + STATUS_FIELD_NUMBER: _ClassVar[int] + DBID_FIELD_NUMBER: _ClassVar[int] + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + SEGMENTIDS_FIELD_NUMBER: _ClassVar[int] + FLUSHSEGMENTIDS_FIELD_NUMBER: _ClassVar[int] + TIMEOFSEAL_FIELD_NUMBER: _ClassVar[int] + FLUSH_TS_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + dbID: int + collectionID: int + segmentIDs: _containers.RepeatedScalarFieldContainer[int] + flushSegmentIDs: _containers.RepeatedScalarFieldContainer[int] + timeOfSeal: int + flush_ts: int + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., dbID: _Optional[int] = ..., collectionID: _Optional[int] = ..., segmentIDs: _Optional[_Iterable[int]] = ..., flushSegmentIDs: _Optional[_Iterable[int]] = ..., timeOfSeal: _Optional[int] = ..., flush_ts: _Optional[int] = ...) -> None: ... + +class FlushChannelsRequest(_message.Message): + __slots__ = ("base", "flush_ts", "channels") + BASE_FIELD_NUMBER: _ClassVar[int] + FLUSH_TS_FIELD_NUMBER: _ClassVar[int] + CHANNELS_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + flush_ts: int + channels: _containers.RepeatedScalarFieldContainer[str] + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., flush_ts: _Optional[int] = ..., channels: _Optional[_Iterable[str]] = ...) -> None: ... + +class SegmentIDRequest(_message.Message): + __slots__ = ("count", "channel_name", "collectionID", "partitionID", "isImport", "importTaskID", "level") + COUNT_FIELD_NUMBER: _ClassVar[int] + CHANNEL_NAME_FIELD_NUMBER: _ClassVar[int] + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + PARTITIONID_FIELD_NUMBER: _ClassVar[int] + ISIMPORT_FIELD_NUMBER: _ClassVar[int] + IMPORTTASKID_FIELD_NUMBER: _ClassVar[int] + LEVEL_FIELD_NUMBER: _ClassVar[int] + count: int + channel_name: str + collectionID: int + partitionID: int + isImport: bool + importTaskID: int + level: SegmentLevel + def __init__(self, count: _Optional[int] = ..., channel_name: _Optional[str] = ..., collectionID: _Optional[int] = ..., partitionID: _Optional[int] = ..., isImport: bool = ..., importTaskID: _Optional[int] = ..., level: _Optional[_Union[SegmentLevel, str]] = ...) -> None: ... + +class AssignSegmentIDRequest(_message.Message): + __slots__ = ("nodeID", "peer_role", "segmentIDRequests") + NODEID_FIELD_NUMBER: _ClassVar[int] + PEER_ROLE_FIELD_NUMBER: _ClassVar[int] + SEGMENTIDREQUESTS_FIELD_NUMBER: _ClassVar[int] + nodeID: int + peer_role: str + segmentIDRequests: _containers.RepeatedCompositeFieldContainer[SegmentIDRequest] + def __init__(self, nodeID: _Optional[int] = ..., peer_role: _Optional[str] = ..., segmentIDRequests: _Optional[_Iterable[_Union[SegmentIDRequest, _Mapping]]] = ...) -> None: ... + +class SegmentIDAssignment(_message.Message): + __slots__ = ("segID", "channel_name", "count", "collectionID", "partitionID", "expire_time", "status") + SEGID_FIELD_NUMBER: _ClassVar[int] + CHANNEL_NAME_FIELD_NUMBER: _ClassVar[int] + COUNT_FIELD_NUMBER: _ClassVar[int] + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + PARTITIONID_FIELD_NUMBER: _ClassVar[int] + EXPIRE_TIME_FIELD_NUMBER: _ClassVar[int] + STATUS_FIELD_NUMBER: _ClassVar[int] + segID: int + channel_name: str + count: int + collectionID: int + partitionID: int + expire_time: int + status: _common_pb2.Status + def __init__(self, segID: _Optional[int] = ..., channel_name: _Optional[str] = ..., count: _Optional[int] = ..., collectionID: _Optional[int] = ..., partitionID: _Optional[int] = ..., expire_time: _Optional[int] = ..., status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ...) -> None: ... + +class AssignSegmentIDResponse(_message.Message): + __slots__ = ("segIDAssignments", "status") + SEGIDASSIGNMENTS_FIELD_NUMBER: _ClassVar[int] + STATUS_FIELD_NUMBER: _ClassVar[int] + segIDAssignments: _containers.RepeatedCompositeFieldContainer[SegmentIDAssignment] + status: _common_pb2.Status + def __init__(self, segIDAssignments: _Optional[_Iterable[_Union[SegmentIDAssignment, _Mapping]]] = ..., status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ...) -> None: ... + +class GetSegmentStatesRequest(_message.Message): + __slots__ = ("base", "segmentIDs") + BASE_FIELD_NUMBER: _ClassVar[int] + SEGMENTIDS_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + segmentIDs: _containers.RepeatedScalarFieldContainer[int] + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., segmentIDs: _Optional[_Iterable[int]] = ...) -> None: ... + +class SegmentStateInfo(_message.Message): + __slots__ = ("segmentID", "state", "start_position", "end_position", "status") + SEGMENTID_FIELD_NUMBER: _ClassVar[int] + STATE_FIELD_NUMBER: _ClassVar[int] + START_POSITION_FIELD_NUMBER: _ClassVar[int] + END_POSITION_FIELD_NUMBER: _ClassVar[int] + STATUS_FIELD_NUMBER: _ClassVar[int] + segmentID: int + state: _common_pb2.SegmentState + start_position: _msg_pb2.MsgPosition + end_position: _msg_pb2.MsgPosition + status: _common_pb2.Status + def __init__(self, segmentID: _Optional[int] = ..., state: _Optional[_Union[_common_pb2.SegmentState, str]] = ..., start_position: _Optional[_Union[_msg_pb2.MsgPosition, _Mapping]] = ..., end_position: _Optional[_Union[_msg_pb2.MsgPosition, _Mapping]] = ..., status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ...) -> None: ... + +class GetSegmentStatesResponse(_message.Message): + __slots__ = ("status", "states") + STATUS_FIELD_NUMBER: _ClassVar[int] + STATES_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + states: _containers.RepeatedCompositeFieldContainer[SegmentStateInfo] + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., states: _Optional[_Iterable[_Union[SegmentStateInfo, _Mapping]]] = ...) -> None: ... + +class GetSegmentInfoRequest(_message.Message): + __slots__ = ("base", "segmentIDs", "includeUnHealthy") + BASE_FIELD_NUMBER: _ClassVar[int] + SEGMENTIDS_FIELD_NUMBER: _ClassVar[int] + INCLUDEUNHEALTHY_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + segmentIDs: _containers.RepeatedScalarFieldContainer[int] + includeUnHealthy: bool + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., segmentIDs: _Optional[_Iterable[int]] = ..., includeUnHealthy: bool = ...) -> None: ... + +class GetSegmentInfoResponse(_message.Message): + __slots__ = ("status", "infos", "channel_checkpoint") + class ChannelCheckpointEntry(_message.Message): + __slots__ = ("key", "value") + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: str + value: _msg_pb2.MsgPosition + def __init__(self, key: _Optional[str] = ..., value: _Optional[_Union[_msg_pb2.MsgPosition, _Mapping]] = ...) -> None: ... + STATUS_FIELD_NUMBER: _ClassVar[int] + INFOS_FIELD_NUMBER: _ClassVar[int] + CHANNEL_CHECKPOINT_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + infos: _containers.RepeatedCompositeFieldContainer[SegmentInfo] + channel_checkpoint: _containers.MessageMap[str, _msg_pb2.MsgPosition] + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., infos: _Optional[_Iterable[_Union[SegmentInfo, _Mapping]]] = ..., channel_checkpoint: _Optional[_Mapping[str, _msg_pb2.MsgPosition]] = ...) -> None: ... + +class GetInsertBinlogPathsRequest(_message.Message): + __slots__ = ("base", "segmentID") + BASE_FIELD_NUMBER: _ClassVar[int] + SEGMENTID_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + segmentID: int + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., segmentID: _Optional[int] = ...) -> None: ... + +class GetInsertBinlogPathsResponse(_message.Message): + __slots__ = ("fieldIDs", "paths", "status") + FIELDIDS_FIELD_NUMBER: _ClassVar[int] + PATHS_FIELD_NUMBER: _ClassVar[int] + STATUS_FIELD_NUMBER: _ClassVar[int] + fieldIDs: _containers.RepeatedScalarFieldContainer[int] + paths: _containers.RepeatedCompositeFieldContainer[_internal_pb2.StringList] + status: _common_pb2.Status + def __init__(self, fieldIDs: _Optional[_Iterable[int]] = ..., paths: _Optional[_Iterable[_Union[_internal_pb2.StringList, _Mapping]]] = ..., status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ...) -> None: ... + +class GetCollectionStatisticsRequest(_message.Message): + __slots__ = ("base", "dbID", "collectionID") + BASE_FIELD_NUMBER: _ClassVar[int] + DBID_FIELD_NUMBER: _ClassVar[int] + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + dbID: int + collectionID: int + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., dbID: _Optional[int] = ..., collectionID: _Optional[int] = ...) -> None: ... + +class GetCollectionStatisticsResponse(_message.Message): + __slots__ = ("stats", "status") + STATS_FIELD_NUMBER: _ClassVar[int] + STATUS_FIELD_NUMBER: _ClassVar[int] + stats: _containers.RepeatedCompositeFieldContainer[_common_pb2.KeyValuePair] + status: _common_pb2.Status + def __init__(self, stats: _Optional[_Iterable[_Union[_common_pb2.KeyValuePair, _Mapping]]] = ..., status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ...) -> None: ... + +class GetPartitionStatisticsRequest(_message.Message): + __slots__ = ("base", "dbID", "collectionID", "partitionIDs") + BASE_FIELD_NUMBER: _ClassVar[int] + DBID_FIELD_NUMBER: _ClassVar[int] + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + PARTITIONIDS_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + dbID: int + collectionID: int + partitionIDs: _containers.RepeatedScalarFieldContainer[int] + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., dbID: _Optional[int] = ..., collectionID: _Optional[int] = ..., partitionIDs: _Optional[_Iterable[int]] = ...) -> None: ... + +class GetPartitionStatisticsResponse(_message.Message): + __slots__ = ("stats", "status") + STATS_FIELD_NUMBER: _ClassVar[int] + STATUS_FIELD_NUMBER: _ClassVar[int] + stats: _containers.RepeatedCompositeFieldContainer[_common_pb2.KeyValuePair] + status: _common_pb2.Status + def __init__(self, stats: _Optional[_Iterable[_Union[_common_pb2.KeyValuePair, _Mapping]]] = ..., status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ...) -> None: ... + +class GetSegmentInfoChannelRequest(_message.Message): + __slots__ = () + def __init__(self) -> None: ... + +class VchannelInfo(_message.Message): + __slots__ = ("collectionID", "channelName", "seek_position", "unflushedSegments", "flushedSegments", "dropped_segments", "unflushedSegmentIds", "flushedSegmentIds", "dropped_segmentIds", "indexed_segmentIds", "indexed_segments", "level_zero_segment_ids") + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + CHANNELNAME_FIELD_NUMBER: _ClassVar[int] + SEEK_POSITION_FIELD_NUMBER: _ClassVar[int] + UNFLUSHEDSEGMENTS_FIELD_NUMBER: _ClassVar[int] + FLUSHEDSEGMENTS_FIELD_NUMBER: _ClassVar[int] + DROPPED_SEGMENTS_FIELD_NUMBER: _ClassVar[int] + UNFLUSHEDSEGMENTIDS_FIELD_NUMBER: _ClassVar[int] + FLUSHEDSEGMENTIDS_FIELD_NUMBER: _ClassVar[int] + DROPPED_SEGMENTIDS_FIELD_NUMBER: _ClassVar[int] + INDEXED_SEGMENTIDS_FIELD_NUMBER: _ClassVar[int] + INDEXED_SEGMENTS_FIELD_NUMBER: _ClassVar[int] + LEVEL_ZERO_SEGMENT_IDS_FIELD_NUMBER: _ClassVar[int] + collectionID: int + channelName: str + seek_position: _msg_pb2.MsgPosition + unflushedSegments: _containers.RepeatedCompositeFieldContainer[SegmentInfo] + flushedSegments: _containers.RepeatedCompositeFieldContainer[SegmentInfo] + dropped_segments: _containers.RepeatedCompositeFieldContainer[SegmentInfo] + unflushedSegmentIds: _containers.RepeatedScalarFieldContainer[int] + flushedSegmentIds: _containers.RepeatedScalarFieldContainer[int] + dropped_segmentIds: _containers.RepeatedScalarFieldContainer[int] + indexed_segmentIds: _containers.RepeatedScalarFieldContainer[int] + indexed_segments: _containers.RepeatedCompositeFieldContainer[SegmentInfo] + level_zero_segment_ids: _containers.RepeatedScalarFieldContainer[int] + def __init__(self, collectionID: _Optional[int] = ..., channelName: _Optional[str] = ..., seek_position: _Optional[_Union[_msg_pb2.MsgPosition, _Mapping]] = ..., unflushedSegments: _Optional[_Iterable[_Union[SegmentInfo, _Mapping]]] = ..., flushedSegments: _Optional[_Iterable[_Union[SegmentInfo, _Mapping]]] = ..., dropped_segments: _Optional[_Iterable[_Union[SegmentInfo, _Mapping]]] = ..., unflushedSegmentIds: _Optional[_Iterable[int]] = ..., flushedSegmentIds: _Optional[_Iterable[int]] = ..., dropped_segmentIds: _Optional[_Iterable[int]] = ..., indexed_segmentIds: _Optional[_Iterable[int]] = ..., indexed_segments: _Optional[_Iterable[_Union[SegmentInfo, _Mapping]]] = ..., level_zero_segment_ids: _Optional[_Iterable[int]] = ...) -> None: ... + +class WatchDmChannelsRequest(_message.Message): + __slots__ = ("base", "vchannels") + BASE_FIELD_NUMBER: _ClassVar[int] + VCHANNELS_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + vchannels: _containers.RepeatedCompositeFieldContainer[VchannelInfo] + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., vchannels: _Optional[_Iterable[_Union[VchannelInfo, _Mapping]]] = ...) -> None: ... + +class FlushSegmentsRequest(_message.Message): + __slots__ = ("base", "dbID", "collectionID", "segmentIDs", "channelName") + BASE_FIELD_NUMBER: _ClassVar[int] + DBID_FIELD_NUMBER: _ClassVar[int] + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + SEGMENTIDS_FIELD_NUMBER: _ClassVar[int] + CHANNELNAME_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + dbID: int + collectionID: int + segmentIDs: _containers.RepeatedScalarFieldContainer[int] + channelName: str + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., dbID: _Optional[int] = ..., collectionID: _Optional[int] = ..., segmentIDs: _Optional[_Iterable[int]] = ..., channelName: _Optional[str] = ...) -> None: ... + +class SegmentMsg(_message.Message): + __slots__ = ("base", "segment") + BASE_FIELD_NUMBER: _ClassVar[int] + SEGMENT_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + segment: SegmentInfo + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., segment: _Optional[_Union[SegmentInfo, _Mapping]] = ...) -> None: ... + +class SegmentInfo(_message.Message): + __slots__ = ("ID", "collectionID", "partitionID", "insert_channel", "num_of_rows", "state", "max_row_num", "last_expire_time", "start_position", "dml_position", "binlogs", "statslogs", "deltalogs", "createdByCompaction", "compactionFrom", "dropped_at", "is_importing", "is_fake", "compacted", "level", "storage_version") + ID_FIELD_NUMBER: _ClassVar[int] + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + PARTITIONID_FIELD_NUMBER: _ClassVar[int] + INSERT_CHANNEL_FIELD_NUMBER: _ClassVar[int] + NUM_OF_ROWS_FIELD_NUMBER: _ClassVar[int] + STATE_FIELD_NUMBER: _ClassVar[int] + MAX_ROW_NUM_FIELD_NUMBER: _ClassVar[int] + LAST_EXPIRE_TIME_FIELD_NUMBER: _ClassVar[int] + START_POSITION_FIELD_NUMBER: _ClassVar[int] + DML_POSITION_FIELD_NUMBER: _ClassVar[int] + BINLOGS_FIELD_NUMBER: _ClassVar[int] + STATSLOGS_FIELD_NUMBER: _ClassVar[int] + DELTALOGS_FIELD_NUMBER: _ClassVar[int] + CREATEDBYCOMPACTION_FIELD_NUMBER: _ClassVar[int] + COMPACTIONFROM_FIELD_NUMBER: _ClassVar[int] + DROPPED_AT_FIELD_NUMBER: _ClassVar[int] + IS_IMPORTING_FIELD_NUMBER: _ClassVar[int] + IS_FAKE_FIELD_NUMBER: _ClassVar[int] + COMPACTED_FIELD_NUMBER: _ClassVar[int] + LEVEL_FIELD_NUMBER: _ClassVar[int] + STORAGE_VERSION_FIELD_NUMBER: _ClassVar[int] + ID: int + collectionID: int + partitionID: int + insert_channel: str + num_of_rows: int + state: _common_pb2.SegmentState + max_row_num: int + last_expire_time: int + start_position: _msg_pb2.MsgPosition + dml_position: _msg_pb2.MsgPosition + binlogs: _containers.RepeatedCompositeFieldContainer[FieldBinlog] + statslogs: _containers.RepeatedCompositeFieldContainer[FieldBinlog] + deltalogs: _containers.RepeatedCompositeFieldContainer[FieldBinlog] + createdByCompaction: bool + compactionFrom: _containers.RepeatedScalarFieldContainer[int] + dropped_at: int + is_importing: bool + is_fake: bool + compacted: bool + level: SegmentLevel + storage_version: int + def __init__(self, ID: _Optional[int] = ..., collectionID: _Optional[int] = ..., partitionID: _Optional[int] = ..., insert_channel: _Optional[str] = ..., num_of_rows: _Optional[int] = ..., state: _Optional[_Union[_common_pb2.SegmentState, str]] = ..., max_row_num: _Optional[int] = ..., last_expire_time: _Optional[int] = ..., start_position: _Optional[_Union[_msg_pb2.MsgPosition, _Mapping]] = ..., dml_position: _Optional[_Union[_msg_pb2.MsgPosition, _Mapping]] = ..., binlogs: _Optional[_Iterable[_Union[FieldBinlog, _Mapping]]] = ..., statslogs: _Optional[_Iterable[_Union[FieldBinlog, _Mapping]]] = ..., deltalogs: _Optional[_Iterable[_Union[FieldBinlog, _Mapping]]] = ..., createdByCompaction: bool = ..., compactionFrom: _Optional[_Iterable[int]] = ..., dropped_at: _Optional[int] = ..., is_importing: bool = ..., is_fake: bool = ..., compacted: bool = ..., level: _Optional[_Union[SegmentLevel, str]] = ..., storage_version: _Optional[int] = ...) -> None: ... + +class SegmentStartPosition(_message.Message): + __slots__ = ("start_position", "segmentID") + START_POSITION_FIELD_NUMBER: _ClassVar[int] + SEGMENTID_FIELD_NUMBER: _ClassVar[int] + start_position: _msg_pb2.MsgPosition + segmentID: int + def __init__(self, start_position: _Optional[_Union[_msg_pb2.MsgPosition, _Mapping]] = ..., segmentID: _Optional[int] = ...) -> None: ... + +class SaveBinlogPathsRequest(_message.Message): + __slots__ = ("base", "segmentID", "collectionID", "field2BinlogPaths", "checkPoints", "start_positions", "flushed", "field2StatslogPaths", "deltalogs", "dropped", "importing", "channel", "seg_level", "partitionID", "storageVersion") + BASE_FIELD_NUMBER: _ClassVar[int] + SEGMENTID_FIELD_NUMBER: _ClassVar[int] + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + FIELD2BINLOGPATHS_FIELD_NUMBER: _ClassVar[int] + CHECKPOINTS_FIELD_NUMBER: _ClassVar[int] + START_POSITIONS_FIELD_NUMBER: _ClassVar[int] + FLUSHED_FIELD_NUMBER: _ClassVar[int] + FIELD2STATSLOGPATHS_FIELD_NUMBER: _ClassVar[int] + DELTALOGS_FIELD_NUMBER: _ClassVar[int] + DROPPED_FIELD_NUMBER: _ClassVar[int] + IMPORTING_FIELD_NUMBER: _ClassVar[int] + CHANNEL_FIELD_NUMBER: _ClassVar[int] + SEG_LEVEL_FIELD_NUMBER: _ClassVar[int] + PARTITIONID_FIELD_NUMBER: _ClassVar[int] + STORAGEVERSION_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + segmentID: int + collectionID: int + field2BinlogPaths: _containers.RepeatedCompositeFieldContainer[FieldBinlog] + checkPoints: _containers.RepeatedCompositeFieldContainer[CheckPoint] + start_positions: _containers.RepeatedCompositeFieldContainer[SegmentStartPosition] + flushed: bool + field2StatslogPaths: _containers.RepeatedCompositeFieldContainer[FieldBinlog] + deltalogs: _containers.RepeatedCompositeFieldContainer[FieldBinlog] + dropped: bool + importing: bool + channel: str + seg_level: SegmentLevel + partitionID: int + storageVersion: int + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., segmentID: _Optional[int] = ..., collectionID: _Optional[int] = ..., field2BinlogPaths: _Optional[_Iterable[_Union[FieldBinlog, _Mapping]]] = ..., checkPoints: _Optional[_Iterable[_Union[CheckPoint, _Mapping]]] = ..., start_positions: _Optional[_Iterable[_Union[SegmentStartPosition, _Mapping]]] = ..., flushed: bool = ..., field2StatslogPaths: _Optional[_Iterable[_Union[FieldBinlog, _Mapping]]] = ..., deltalogs: _Optional[_Iterable[_Union[FieldBinlog, _Mapping]]] = ..., dropped: bool = ..., importing: bool = ..., channel: _Optional[str] = ..., seg_level: _Optional[_Union[SegmentLevel, str]] = ..., partitionID: _Optional[int] = ..., storageVersion: _Optional[int] = ...) -> None: ... + +class CheckPoint(_message.Message): + __slots__ = ("segmentID", "position", "num_of_rows") + SEGMENTID_FIELD_NUMBER: _ClassVar[int] + POSITION_FIELD_NUMBER: _ClassVar[int] + NUM_OF_ROWS_FIELD_NUMBER: _ClassVar[int] + segmentID: int + position: _msg_pb2.MsgPosition + num_of_rows: int + def __init__(self, segmentID: _Optional[int] = ..., position: _Optional[_Union[_msg_pb2.MsgPosition, _Mapping]] = ..., num_of_rows: _Optional[int] = ...) -> None: ... + +class DeltaLogInfo(_message.Message): + __slots__ = ("record_entries", "timestamp_from", "timestamp_to", "delta_log_path", "delta_log_size") + RECORD_ENTRIES_FIELD_NUMBER: _ClassVar[int] + TIMESTAMP_FROM_FIELD_NUMBER: _ClassVar[int] + TIMESTAMP_TO_FIELD_NUMBER: _ClassVar[int] + DELTA_LOG_PATH_FIELD_NUMBER: _ClassVar[int] + DELTA_LOG_SIZE_FIELD_NUMBER: _ClassVar[int] + record_entries: int + timestamp_from: int + timestamp_to: int + delta_log_path: str + delta_log_size: int + def __init__(self, record_entries: _Optional[int] = ..., timestamp_from: _Optional[int] = ..., timestamp_to: _Optional[int] = ..., delta_log_path: _Optional[str] = ..., delta_log_size: _Optional[int] = ...) -> None: ... + +class ChannelStatus(_message.Message): + __slots__ = ("name", "state", "collectionID") + NAME_FIELD_NUMBER: _ClassVar[int] + STATE_FIELD_NUMBER: _ClassVar[int] + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + name: str + state: ChannelWatchState + collectionID: int + def __init__(self, name: _Optional[str] = ..., state: _Optional[_Union[ChannelWatchState, str]] = ..., collectionID: _Optional[int] = ...) -> None: ... + +class DataNodeInfo(_message.Message): + __slots__ = ("address", "version", "channels") + ADDRESS_FIELD_NUMBER: _ClassVar[int] + VERSION_FIELD_NUMBER: _ClassVar[int] + CHANNELS_FIELD_NUMBER: _ClassVar[int] + address: str + version: int + channels: _containers.RepeatedCompositeFieldContainer[ChannelStatus] + def __init__(self, address: _Optional[str] = ..., version: _Optional[int] = ..., channels: _Optional[_Iterable[_Union[ChannelStatus, _Mapping]]] = ...) -> None: ... + +class SegmentBinlogs(_message.Message): + __slots__ = ("segmentID", "fieldBinlogs", "num_of_rows", "statslogs", "deltalogs", "insert_channel") + SEGMENTID_FIELD_NUMBER: _ClassVar[int] + FIELDBINLOGS_FIELD_NUMBER: _ClassVar[int] + NUM_OF_ROWS_FIELD_NUMBER: _ClassVar[int] + STATSLOGS_FIELD_NUMBER: _ClassVar[int] + DELTALOGS_FIELD_NUMBER: _ClassVar[int] + INSERT_CHANNEL_FIELD_NUMBER: _ClassVar[int] + segmentID: int + fieldBinlogs: _containers.RepeatedCompositeFieldContainer[FieldBinlog] + num_of_rows: int + statslogs: _containers.RepeatedCompositeFieldContainer[FieldBinlog] + deltalogs: _containers.RepeatedCompositeFieldContainer[FieldBinlog] + insert_channel: str + def __init__(self, segmentID: _Optional[int] = ..., fieldBinlogs: _Optional[_Iterable[_Union[FieldBinlog, _Mapping]]] = ..., num_of_rows: _Optional[int] = ..., statslogs: _Optional[_Iterable[_Union[FieldBinlog, _Mapping]]] = ..., deltalogs: _Optional[_Iterable[_Union[FieldBinlog, _Mapping]]] = ..., insert_channel: _Optional[str] = ...) -> None: ... + +class FieldBinlog(_message.Message): + __slots__ = ("fieldID", "binlogs") + FIELDID_FIELD_NUMBER: _ClassVar[int] + BINLOGS_FIELD_NUMBER: _ClassVar[int] + fieldID: int + binlogs: _containers.RepeatedCompositeFieldContainer[Binlog] + def __init__(self, fieldID: _Optional[int] = ..., binlogs: _Optional[_Iterable[_Union[Binlog, _Mapping]]] = ...) -> None: ... + +class Binlog(_message.Message): + __slots__ = ("entries_num", "timestamp_from", "timestamp_to", "log_path", "log_size", "logID") + ENTRIES_NUM_FIELD_NUMBER: _ClassVar[int] + TIMESTAMP_FROM_FIELD_NUMBER: _ClassVar[int] + TIMESTAMP_TO_FIELD_NUMBER: _ClassVar[int] + LOG_PATH_FIELD_NUMBER: _ClassVar[int] + LOG_SIZE_FIELD_NUMBER: _ClassVar[int] + LOGID_FIELD_NUMBER: _ClassVar[int] + entries_num: int + timestamp_from: int + timestamp_to: int + log_path: str + log_size: int + logID: int + def __init__(self, entries_num: _Optional[int] = ..., timestamp_from: _Optional[int] = ..., timestamp_to: _Optional[int] = ..., log_path: _Optional[str] = ..., log_size: _Optional[int] = ..., logID: _Optional[int] = ...) -> None: ... + +class GetRecoveryInfoResponse(_message.Message): + __slots__ = ("status", "channels", "binlogs") + STATUS_FIELD_NUMBER: _ClassVar[int] + CHANNELS_FIELD_NUMBER: _ClassVar[int] + BINLOGS_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + channels: _containers.RepeatedCompositeFieldContainer[VchannelInfo] + binlogs: _containers.RepeatedCompositeFieldContainer[SegmentBinlogs] + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., channels: _Optional[_Iterable[_Union[VchannelInfo, _Mapping]]] = ..., binlogs: _Optional[_Iterable[_Union[SegmentBinlogs, _Mapping]]] = ...) -> None: ... + +class GetRecoveryInfoRequest(_message.Message): + __slots__ = ("base", "collectionID", "partitionID") + BASE_FIELD_NUMBER: _ClassVar[int] + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + PARTITIONID_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + collectionID: int + partitionID: int + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., collectionID: _Optional[int] = ..., partitionID: _Optional[int] = ...) -> None: ... + +class GetRecoveryInfoResponseV2(_message.Message): + __slots__ = ("status", "channels", "segments") + STATUS_FIELD_NUMBER: _ClassVar[int] + CHANNELS_FIELD_NUMBER: _ClassVar[int] + SEGMENTS_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + channels: _containers.RepeatedCompositeFieldContainer[VchannelInfo] + segments: _containers.RepeatedCompositeFieldContainer[SegmentInfo] + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., channels: _Optional[_Iterable[_Union[VchannelInfo, _Mapping]]] = ..., segments: _Optional[_Iterable[_Union[SegmentInfo, _Mapping]]] = ...) -> None: ... + +class GetRecoveryInfoRequestV2(_message.Message): + __slots__ = ("base", "collectionID", "partitionIDs") + BASE_FIELD_NUMBER: _ClassVar[int] + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + PARTITIONIDS_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + collectionID: int + partitionIDs: _containers.RepeatedScalarFieldContainer[int] + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., collectionID: _Optional[int] = ..., partitionIDs: _Optional[_Iterable[int]] = ...) -> None: ... + +class GetSegmentsByStatesRequest(_message.Message): + __slots__ = ("base", "collectionID", "partitionID", "states") + BASE_FIELD_NUMBER: _ClassVar[int] + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + PARTITIONID_FIELD_NUMBER: _ClassVar[int] + STATES_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + collectionID: int + partitionID: int + states: _containers.RepeatedScalarFieldContainer[_common_pb2.SegmentState] + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., collectionID: _Optional[int] = ..., partitionID: _Optional[int] = ..., states: _Optional[_Iterable[_Union[_common_pb2.SegmentState, str]]] = ...) -> None: ... + +class GetSegmentsByStatesResponse(_message.Message): + __slots__ = ("status", "segments") + STATUS_FIELD_NUMBER: _ClassVar[int] + SEGMENTS_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + segments: _containers.RepeatedScalarFieldContainer[int] + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., segments: _Optional[_Iterable[int]] = ...) -> None: ... + +class GetFlushedSegmentsRequest(_message.Message): + __slots__ = ("base", "collectionID", "partitionID", "includeUnhealthy") + BASE_FIELD_NUMBER: _ClassVar[int] + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + PARTITIONID_FIELD_NUMBER: _ClassVar[int] + INCLUDEUNHEALTHY_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + collectionID: int + partitionID: int + includeUnhealthy: bool + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., collectionID: _Optional[int] = ..., partitionID: _Optional[int] = ..., includeUnhealthy: bool = ...) -> None: ... + +class GetFlushedSegmentsResponse(_message.Message): + __slots__ = ("status", "segments") + STATUS_FIELD_NUMBER: _ClassVar[int] + SEGMENTS_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + segments: _containers.RepeatedScalarFieldContainer[int] + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., segments: _Optional[_Iterable[int]] = ...) -> None: ... + +class SegmentFlushCompletedMsg(_message.Message): + __slots__ = ("base", "segment") + BASE_FIELD_NUMBER: _ClassVar[int] + SEGMENT_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + segment: SegmentInfo + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., segment: _Optional[_Union[SegmentInfo, _Mapping]] = ...) -> None: ... + +class ChannelWatchInfo(_message.Message): + __slots__ = ("vchan", "startTs", "state", "timeoutTs", "schema", "progress", "opID") + VCHAN_FIELD_NUMBER: _ClassVar[int] + STARTTS_FIELD_NUMBER: _ClassVar[int] + STATE_FIELD_NUMBER: _ClassVar[int] + TIMEOUTTS_FIELD_NUMBER: _ClassVar[int] + SCHEMA_FIELD_NUMBER: _ClassVar[int] + PROGRESS_FIELD_NUMBER: _ClassVar[int] + OPID_FIELD_NUMBER: _ClassVar[int] + vchan: VchannelInfo + startTs: int + state: ChannelWatchState + timeoutTs: int + schema: _schema_pb2.CollectionSchema + progress: int + opID: int + def __init__(self, vchan: _Optional[_Union[VchannelInfo, _Mapping]] = ..., startTs: _Optional[int] = ..., state: _Optional[_Union[ChannelWatchState, str]] = ..., timeoutTs: _Optional[int] = ..., schema: _Optional[_Union[_schema_pb2.CollectionSchema, _Mapping]] = ..., progress: _Optional[int] = ..., opID: _Optional[int] = ...) -> None: ... + +class CompactionStateRequest(_message.Message): + __slots__ = ("base",) + BASE_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ...) -> None: ... + +class SyncSegmentsRequest(_message.Message): + __slots__ = ("planID", "compacted_to", "num_of_rows", "compacted_from", "stats_logs", "channel_name", "partition_id", "collection_id") + PLANID_FIELD_NUMBER: _ClassVar[int] + COMPACTED_TO_FIELD_NUMBER: _ClassVar[int] + NUM_OF_ROWS_FIELD_NUMBER: _ClassVar[int] + COMPACTED_FROM_FIELD_NUMBER: _ClassVar[int] + STATS_LOGS_FIELD_NUMBER: _ClassVar[int] + CHANNEL_NAME_FIELD_NUMBER: _ClassVar[int] + PARTITION_ID_FIELD_NUMBER: _ClassVar[int] + COLLECTION_ID_FIELD_NUMBER: _ClassVar[int] + planID: int + compacted_to: int + num_of_rows: int + compacted_from: _containers.RepeatedScalarFieldContainer[int] + stats_logs: _containers.RepeatedCompositeFieldContainer[FieldBinlog] + channel_name: str + partition_id: int + collection_id: int + def __init__(self, planID: _Optional[int] = ..., compacted_to: _Optional[int] = ..., num_of_rows: _Optional[int] = ..., compacted_from: _Optional[_Iterable[int]] = ..., stats_logs: _Optional[_Iterable[_Union[FieldBinlog, _Mapping]]] = ..., channel_name: _Optional[str] = ..., partition_id: _Optional[int] = ..., collection_id: _Optional[int] = ...) -> None: ... + +class CompactionSegmentBinlogs(_message.Message): + __slots__ = ("segmentID", "fieldBinlogs", "field2StatslogPaths", "deltalogs", "insert_channel", "level", "collectionID", "partitionID") + SEGMENTID_FIELD_NUMBER: _ClassVar[int] + FIELDBINLOGS_FIELD_NUMBER: _ClassVar[int] + FIELD2STATSLOGPATHS_FIELD_NUMBER: _ClassVar[int] + DELTALOGS_FIELD_NUMBER: _ClassVar[int] + INSERT_CHANNEL_FIELD_NUMBER: _ClassVar[int] + LEVEL_FIELD_NUMBER: _ClassVar[int] + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + PARTITIONID_FIELD_NUMBER: _ClassVar[int] + segmentID: int + fieldBinlogs: _containers.RepeatedCompositeFieldContainer[FieldBinlog] + field2StatslogPaths: _containers.RepeatedCompositeFieldContainer[FieldBinlog] + deltalogs: _containers.RepeatedCompositeFieldContainer[FieldBinlog] + insert_channel: str + level: SegmentLevel + collectionID: int + partitionID: int + def __init__(self, segmentID: _Optional[int] = ..., fieldBinlogs: _Optional[_Iterable[_Union[FieldBinlog, _Mapping]]] = ..., field2StatslogPaths: _Optional[_Iterable[_Union[FieldBinlog, _Mapping]]] = ..., deltalogs: _Optional[_Iterable[_Union[FieldBinlog, _Mapping]]] = ..., insert_channel: _Optional[str] = ..., level: _Optional[_Union[SegmentLevel, str]] = ..., collectionID: _Optional[int] = ..., partitionID: _Optional[int] = ...) -> None: ... + +class CompactionPlan(_message.Message): + __slots__ = ("planID", "segmentBinlogs", "start_time", "timeout_in_seconds", "type", "timetravel", "channel", "collection_ttl", "total_rows") + PLANID_FIELD_NUMBER: _ClassVar[int] + SEGMENTBINLOGS_FIELD_NUMBER: _ClassVar[int] + START_TIME_FIELD_NUMBER: _ClassVar[int] + TIMEOUT_IN_SECONDS_FIELD_NUMBER: _ClassVar[int] + TYPE_FIELD_NUMBER: _ClassVar[int] + TIMETRAVEL_FIELD_NUMBER: _ClassVar[int] + CHANNEL_FIELD_NUMBER: _ClassVar[int] + COLLECTION_TTL_FIELD_NUMBER: _ClassVar[int] + TOTAL_ROWS_FIELD_NUMBER: _ClassVar[int] + planID: int + segmentBinlogs: _containers.RepeatedCompositeFieldContainer[CompactionSegmentBinlogs] + start_time: int + timeout_in_seconds: int + type: CompactionType + timetravel: int + channel: str + collection_ttl: int + total_rows: int + def __init__(self, planID: _Optional[int] = ..., segmentBinlogs: _Optional[_Iterable[_Union[CompactionSegmentBinlogs, _Mapping]]] = ..., start_time: _Optional[int] = ..., timeout_in_seconds: _Optional[int] = ..., type: _Optional[_Union[CompactionType, str]] = ..., timetravel: _Optional[int] = ..., channel: _Optional[str] = ..., collection_ttl: _Optional[int] = ..., total_rows: _Optional[int] = ...) -> None: ... + +class CompactionSegment(_message.Message): + __slots__ = ("planID", "segmentID", "num_of_rows", "insert_logs", "field2StatslogPaths", "deltalogs", "channel") + PLANID_FIELD_NUMBER: _ClassVar[int] + SEGMENTID_FIELD_NUMBER: _ClassVar[int] + NUM_OF_ROWS_FIELD_NUMBER: _ClassVar[int] + INSERT_LOGS_FIELD_NUMBER: _ClassVar[int] + FIELD2STATSLOGPATHS_FIELD_NUMBER: _ClassVar[int] + DELTALOGS_FIELD_NUMBER: _ClassVar[int] + CHANNEL_FIELD_NUMBER: _ClassVar[int] + planID: int + segmentID: int + num_of_rows: int + insert_logs: _containers.RepeatedCompositeFieldContainer[FieldBinlog] + field2StatslogPaths: _containers.RepeatedCompositeFieldContainer[FieldBinlog] + deltalogs: _containers.RepeatedCompositeFieldContainer[FieldBinlog] + channel: str + def __init__(self, planID: _Optional[int] = ..., segmentID: _Optional[int] = ..., num_of_rows: _Optional[int] = ..., insert_logs: _Optional[_Iterable[_Union[FieldBinlog, _Mapping]]] = ..., field2StatslogPaths: _Optional[_Iterable[_Union[FieldBinlog, _Mapping]]] = ..., deltalogs: _Optional[_Iterable[_Union[FieldBinlog, _Mapping]]] = ..., channel: _Optional[str] = ...) -> None: ... + +class CompactionPlanResult(_message.Message): + __slots__ = ("planID", "state", "segments", "channel", "type") + PLANID_FIELD_NUMBER: _ClassVar[int] + STATE_FIELD_NUMBER: _ClassVar[int] + SEGMENTS_FIELD_NUMBER: _ClassVar[int] + CHANNEL_FIELD_NUMBER: _ClassVar[int] + TYPE_FIELD_NUMBER: _ClassVar[int] + planID: int + state: _common_pb2.CompactionState + segments: _containers.RepeatedCompositeFieldContainer[CompactionSegment] + channel: str + type: CompactionType + def __init__(self, planID: _Optional[int] = ..., state: _Optional[_Union[_common_pb2.CompactionState, str]] = ..., segments: _Optional[_Iterable[_Union[CompactionSegment, _Mapping]]] = ..., channel: _Optional[str] = ..., type: _Optional[_Union[CompactionType, str]] = ...) -> None: ... + +class CompactionStateResponse(_message.Message): + __slots__ = ("status", "results") + STATUS_FIELD_NUMBER: _ClassVar[int] + RESULTS_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + results: _containers.RepeatedCompositeFieldContainer[CompactionPlanResult] + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., results: _Optional[_Iterable[_Union[CompactionPlanResult, _Mapping]]] = ...) -> None: ... + +class SegmentFieldBinlogMeta(_message.Message): + __slots__ = ("fieldID", "binlog_path") + FIELDID_FIELD_NUMBER: _ClassVar[int] + BINLOG_PATH_FIELD_NUMBER: _ClassVar[int] + fieldID: int + binlog_path: str + def __init__(self, fieldID: _Optional[int] = ..., binlog_path: _Optional[str] = ...) -> None: ... + +class WatchChannelsRequest(_message.Message): + __slots__ = ("collectionID", "channelNames", "start_positions", "schema", "create_timestamp") + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + CHANNELNAMES_FIELD_NUMBER: _ClassVar[int] + START_POSITIONS_FIELD_NUMBER: _ClassVar[int] + SCHEMA_FIELD_NUMBER: _ClassVar[int] + CREATE_TIMESTAMP_FIELD_NUMBER: _ClassVar[int] + collectionID: int + channelNames: _containers.RepeatedScalarFieldContainer[str] + start_positions: _containers.RepeatedCompositeFieldContainer[_common_pb2.KeyDataPair] + schema: _schema_pb2.CollectionSchema + create_timestamp: int + def __init__(self, collectionID: _Optional[int] = ..., channelNames: _Optional[_Iterable[str]] = ..., start_positions: _Optional[_Iterable[_Union[_common_pb2.KeyDataPair, _Mapping]]] = ..., schema: _Optional[_Union[_schema_pb2.CollectionSchema, _Mapping]] = ..., create_timestamp: _Optional[int] = ...) -> None: ... + +class WatchChannelsResponse(_message.Message): + __slots__ = ("status",) + STATUS_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ...) -> None: ... + +class SetSegmentStateRequest(_message.Message): + __slots__ = ("base", "segment_id", "new_state") + BASE_FIELD_NUMBER: _ClassVar[int] + SEGMENT_ID_FIELD_NUMBER: _ClassVar[int] + NEW_STATE_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + segment_id: int + new_state: _common_pb2.SegmentState + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., segment_id: _Optional[int] = ..., new_state: _Optional[_Union[_common_pb2.SegmentState, str]] = ...) -> None: ... + +class SetSegmentStateResponse(_message.Message): + __slots__ = ("status",) + STATUS_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ...) -> None: ... + +class DropVirtualChannelRequest(_message.Message): + __slots__ = ("base", "channel_name", "segments") + BASE_FIELD_NUMBER: _ClassVar[int] + CHANNEL_NAME_FIELD_NUMBER: _ClassVar[int] + SEGMENTS_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + channel_name: str + segments: _containers.RepeatedCompositeFieldContainer[DropVirtualChannelSegment] + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., channel_name: _Optional[str] = ..., segments: _Optional[_Iterable[_Union[DropVirtualChannelSegment, _Mapping]]] = ...) -> None: ... + +class DropVirtualChannelSegment(_message.Message): + __slots__ = ("segmentID", "collectionID", "field2BinlogPaths", "field2StatslogPaths", "deltalogs", "startPosition", "checkPoint", "numOfRows") + SEGMENTID_FIELD_NUMBER: _ClassVar[int] + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + FIELD2BINLOGPATHS_FIELD_NUMBER: _ClassVar[int] + FIELD2STATSLOGPATHS_FIELD_NUMBER: _ClassVar[int] + DELTALOGS_FIELD_NUMBER: _ClassVar[int] + STARTPOSITION_FIELD_NUMBER: _ClassVar[int] + CHECKPOINT_FIELD_NUMBER: _ClassVar[int] + NUMOFROWS_FIELD_NUMBER: _ClassVar[int] + segmentID: int + collectionID: int + field2BinlogPaths: _containers.RepeatedCompositeFieldContainer[FieldBinlog] + field2StatslogPaths: _containers.RepeatedCompositeFieldContainer[FieldBinlog] + deltalogs: _containers.RepeatedCompositeFieldContainer[FieldBinlog] + startPosition: _msg_pb2.MsgPosition + checkPoint: _msg_pb2.MsgPosition + numOfRows: int + def __init__(self, segmentID: _Optional[int] = ..., collectionID: _Optional[int] = ..., field2BinlogPaths: _Optional[_Iterable[_Union[FieldBinlog, _Mapping]]] = ..., field2StatslogPaths: _Optional[_Iterable[_Union[FieldBinlog, _Mapping]]] = ..., deltalogs: _Optional[_Iterable[_Union[FieldBinlog, _Mapping]]] = ..., startPosition: _Optional[_Union[_msg_pb2.MsgPosition, _Mapping]] = ..., checkPoint: _Optional[_Union[_msg_pb2.MsgPosition, _Mapping]] = ..., numOfRows: _Optional[int] = ...) -> None: ... + +class DropVirtualChannelResponse(_message.Message): + __slots__ = ("status",) + STATUS_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ...) -> None: ... + +class ImportTask(_message.Message): + __slots__ = ("status", "collection_id", "partition_id", "channel_names", "row_based", "task_id", "files", "infos", "database_name") + STATUS_FIELD_NUMBER: _ClassVar[int] + COLLECTION_ID_FIELD_NUMBER: _ClassVar[int] + PARTITION_ID_FIELD_NUMBER: _ClassVar[int] + CHANNEL_NAMES_FIELD_NUMBER: _ClassVar[int] + ROW_BASED_FIELD_NUMBER: _ClassVar[int] + TASK_ID_FIELD_NUMBER: _ClassVar[int] + FILES_FIELD_NUMBER: _ClassVar[int] + INFOS_FIELD_NUMBER: _ClassVar[int] + DATABASE_NAME_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + collection_id: int + partition_id: int + channel_names: _containers.RepeatedScalarFieldContainer[str] + row_based: bool + task_id: int + files: _containers.RepeatedScalarFieldContainer[str] + infos: _containers.RepeatedCompositeFieldContainer[_common_pb2.KeyValuePair] + database_name: str + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., collection_id: _Optional[int] = ..., partition_id: _Optional[int] = ..., channel_names: _Optional[_Iterable[str]] = ..., row_based: bool = ..., task_id: _Optional[int] = ..., files: _Optional[_Iterable[str]] = ..., infos: _Optional[_Iterable[_Union[_common_pb2.KeyValuePair, _Mapping]]] = ..., database_name: _Optional[str] = ...) -> None: ... + +class ImportTaskState(_message.Message): + __slots__ = ("stateCode", "segments", "row_ids", "row_count", "error_message") + STATECODE_FIELD_NUMBER: _ClassVar[int] + SEGMENTS_FIELD_NUMBER: _ClassVar[int] + ROW_IDS_FIELD_NUMBER: _ClassVar[int] + ROW_COUNT_FIELD_NUMBER: _ClassVar[int] + ERROR_MESSAGE_FIELD_NUMBER: _ClassVar[int] + stateCode: _common_pb2.ImportState + segments: _containers.RepeatedScalarFieldContainer[int] + row_ids: _containers.RepeatedScalarFieldContainer[int] + row_count: int + error_message: str + def __init__(self, stateCode: _Optional[_Union[_common_pb2.ImportState, str]] = ..., segments: _Optional[_Iterable[int]] = ..., row_ids: _Optional[_Iterable[int]] = ..., row_count: _Optional[int] = ..., error_message: _Optional[str] = ...) -> None: ... + +class ImportTaskInfo(_message.Message): + __slots__ = ("id", "request_id", "datanode_id", "collection_id", "partition_id", "channel_names", "bucket", "row_based", "files", "create_ts", "state", "collection_name", "partition_name", "infos", "start_ts", "database_name") + ID_FIELD_NUMBER: _ClassVar[int] + REQUEST_ID_FIELD_NUMBER: _ClassVar[int] + DATANODE_ID_FIELD_NUMBER: _ClassVar[int] + COLLECTION_ID_FIELD_NUMBER: _ClassVar[int] + PARTITION_ID_FIELD_NUMBER: _ClassVar[int] + CHANNEL_NAMES_FIELD_NUMBER: _ClassVar[int] + BUCKET_FIELD_NUMBER: _ClassVar[int] + ROW_BASED_FIELD_NUMBER: _ClassVar[int] + FILES_FIELD_NUMBER: _ClassVar[int] + CREATE_TS_FIELD_NUMBER: _ClassVar[int] + STATE_FIELD_NUMBER: _ClassVar[int] + COLLECTION_NAME_FIELD_NUMBER: _ClassVar[int] + PARTITION_NAME_FIELD_NUMBER: _ClassVar[int] + INFOS_FIELD_NUMBER: _ClassVar[int] + START_TS_FIELD_NUMBER: _ClassVar[int] + DATABASE_NAME_FIELD_NUMBER: _ClassVar[int] + id: int + request_id: int + datanode_id: int + collection_id: int + partition_id: int + channel_names: _containers.RepeatedScalarFieldContainer[str] + bucket: str + row_based: bool + files: _containers.RepeatedScalarFieldContainer[str] + create_ts: int + state: ImportTaskState + collection_name: str + partition_name: str + infos: _containers.RepeatedCompositeFieldContainer[_common_pb2.KeyValuePair] + start_ts: int + database_name: str + def __init__(self, id: _Optional[int] = ..., request_id: _Optional[int] = ..., datanode_id: _Optional[int] = ..., collection_id: _Optional[int] = ..., partition_id: _Optional[int] = ..., channel_names: _Optional[_Iterable[str]] = ..., bucket: _Optional[str] = ..., row_based: bool = ..., files: _Optional[_Iterable[str]] = ..., create_ts: _Optional[int] = ..., state: _Optional[_Union[ImportTaskState, _Mapping]] = ..., collection_name: _Optional[str] = ..., partition_name: _Optional[str] = ..., infos: _Optional[_Iterable[_Union[_common_pb2.KeyValuePair, _Mapping]]] = ..., start_ts: _Optional[int] = ..., database_name: _Optional[str] = ...) -> None: ... + +class ImportTaskResponse(_message.Message): + __slots__ = ("status", "datanode_id") + STATUS_FIELD_NUMBER: _ClassVar[int] + DATANODE_ID_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + datanode_id: int + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., datanode_id: _Optional[int] = ...) -> None: ... + +class ImportTaskRequest(_message.Message): + __slots__ = ("base", "import_task", "working_nodes") + BASE_FIELD_NUMBER: _ClassVar[int] + IMPORT_TASK_FIELD_NUMBER: _ClassVar[int] + WORKING_NODES_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + import_task: ImportTask + working_nodes: _containers.RepeatedScalarFieldContainer[int] + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., import_task: _Optional[_Union[ImportTask, _Mapping]] = ..., working_nodes: _Optional[_Iterable[int]] = ...) -> None: ... + +class UpdateSegmentStatisticsRequest(_message.Message): + __slots__ = ("base", "stats") + BASE_FIELD_NUMBER: _ClassVar[int] + STATS_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + stats: _containers.RepeatedCompositeFieldContainer[_common_pb2.SegmentStats] + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., stats: _Optional[_Iterable[_Union[_common_pb2.SegmentStats, _Mapping]]] = ...) -> None: ... + +class UpdateChannelCheckpointRequest(_message.Message): + __slots__ = ("base", "vChannel", "position", "channel_checkpoints") + BASE_FIELD_NUMBER: _ClassVar[int] + VCHANNEL_FIELD_NUMBER: _ClassVar[int] + POSITION_FIELD_NUMBER: _ClassVar[int] + CHANNEL_CHECKPOINTS_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + vChannel: str + position: _msg_pb2.MsgPosition + channel_checkpoints: _containers.RepeatedCompositeFieldContainer[_msg_pb2.MsgPosition] + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., vChannel: _Optional[str] = ..., position: _Optional[_Union[_msg_pb2.MsgPosition, _Mapping]] = ..., channel_checkpoints: _Optional[_Iterable[_Union[_msg_pb2.MsgPosition, _Mapping]]] = ...) -> None: ... + +class ResendSegmentStatsRequest(_message.Message): + __slots__ = ("base",) + BASE_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ...) -> None: ... + +class ResendSegmentStatsResponse(_message.Message): + __slots__ = ("status", "seg_resent") + STATUS_FIELD_NUMBER: _ClassVar[int] + SEG_RESENT_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + seg_resent: _containers.RepeatedScalarFieldContainer[int] + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., seg_resent: _Optional[_Iterable[int]] = ...) -> None: ... + +class AddImportSegmentRequest(_message.Message): + __slots__ = ("base", "segment_id", "channel_name", "collection_id", "partition_id", "row_num", "stats_log") + BASE_FIELD_NUMBER: _ClassVar[int] + SEGMENT_ID_FIELD_NUMBER: _ClassVar[int] + CHANNEL_NAME_FIELD_NUMBER: _ClassVar[int] + COLLECTION_ID_FIELD_NUMBER: _ClassVar[int] + PARTITION_ID_FIELD_NUMBER: _ClassVar[int] + ROW_NUM_FIELD_NUMBER: _ClassVar[int] + STATS_LOG_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + segment_id: int + channel_name: str + collection_id: int + partition_id: int + row_num: int + stats_log: _containers.RepeatedCompositeFieldContainer[FieldBinlog] + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., segment_id: _Optional[int] = ..., channel_name: _Optional[str] = ..., collection_id: _Optional[int] = ..., partition_id: _Optional[int] = ..., row_num: _Optional[int] = ..., stats_log: _Optional[_Iterable[_Union[FieldBinlog, _Mapping]]] = ...) -> None: ... + +class AddImportSegmentResponse(_message.Message): + __slots__ = ("status", "channel_pos") + STATUS_FIELD_NUMBER: _ClassVar[int] + CHANNEL_POS_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + channel_pos: bytes + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., channel_pos: _Optional[bytes] = ...) -> None: ... + +class SaveImportSegmentRequest(_message.Message): + __slots__ = ("base", "segment_id", "channel_name", "collection_id", "partition_id", "row_num", "save_binlog_path_req", "dml_position_id") + BASE_FIELD_NUMBER: _ClassVar[int] + SEGMENT_ID_FIELD_NUMBER: _ClassVar[int] + CHANNEL_NAME_FIELD_NUMBER: _ClassVar[int] + COLLECTION_ID_FIELD_NUMBER: _ClassVar[int] + PARTITION_ID_FIELD_NUMBER: _ClassVar[int] + ROW_NUM_FIELD_NUMBER: _ClassVar[int] + SAVE_BINLOG_PATH_REQ_FIELD_NUMBER: _ClassVar[int] + DML_POSITION_ID_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + segment_id: int + channel_name: str + collection_id: int + partition_id: int + row_num: int + save_binlog_path_req: SaveBinlogPathsRequest + dml_position_id: bytes + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., segment_id: _Optional[int] = ..., channel_name: _Optional[str] = ..., collection_id: _Optional[int] = ..., partition_id: _Optional[int] = ..., row_num: _Optional[int] = ..., save_binlog_path_req: _Optional[_Union[SaveBinlogPathsRequest, _Mapping]] = ..., dml_position_id: _Optional[bytes] = ...) -> None: ... + +class UnsetIsImportingStateRequest(_message.Message): + __slots__ = ("base", "segment_ids") + BASE_FIELD_NUMBER: _ClassVar[int] + SEGMENT_IDS_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + segment_ids: _containers.RepeatedScalarFieldContainer[int] + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., segment_ids: _Optional[_Iterable[int]] = ...) -> None: ... + +class MarkSegmentsDroppedRequest(_message.Message): + __slots__ = ("base", "segment_ids") + BASE_FIELD_NUMBER: _ClassVar[int] + SEGMENT_IDS_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + segment_ids: _containers.RepeatedScalarFieldContainer[int] + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., segment_ids: _Optional[_Iterable[int]] = ...) -> None: ... + +class SegmentReferenceLock(_message.Message): + __slots__ = ("taskID", "nodeID", "segmentIDs") + TASKID_FIELD_NUMBER: _ClassVar[int] + NODEID_FIELD_NUMBER: _ClassVar[int] + SEGMENTIDS_FIELD_NUMBER: _ClassVar[int] + taskID: int + nodeID: int + segmentIDs: _containers.RepeatedScalarFieldContainer[int] + def __init__(self, taskID: _Optional[int] = ..., nodeID: _Optional[int] = ..., segmentIDs: _Optional[_Iterable[int]] = ...) -> None: ... + +class AlterCollectionRequest(_message.Message): + __slots__ = ("collectionID", "schema", "partitionIDs", "start_positions", "properties") + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + SCHEMA_FIELD_NUMBER: _ClassVar[int] + PARTITIONIDS_FIELD_NUMBER: _ClassVar[int] + START_POSITIONS_FIELD_NUMBER: _ClassVar[int] + PROPERTIES_FIELD_NUMBER: _ClassVar[int] + collectionID: int + schema: _schema_pb2.CollectionSchema + partitionIDs: _containers.RepeatedScalarFieldContainer[int] + start_positions: _containers.RepeatedCompositeFieldContainer[_common_pb2.KeyDataPair] + properties: _containers.RepeatedCompositeFieldContainer[_common_pb2.KeyValuePair] + def __init__(self, collectionID: _Optional[int] = ..., schema: _Optional[_Union[_schema_pb2.CollectionSchema, _Mapping]] = ..., partitionIDs: _Optional[_Iterable[int]] = ..., start_positions: _Optional[_Iterable[_Union[_common_pb2.KeyDataPair, _Mapping]]] = ..., properties: _Optional[_Iterable[_Union[_common_pb2.KeyValuePair, _Mapping]]] = ...) -> None: ... + +class GcConfirmRequest(_message.Message): + __slots__ = ("collection_id", "partition_id") + COLLECTION_ID_FIELD_NUMBER: _ClassVar[int] + PARTITION_ID_FIELD_NUMBER: _ClassVar[int] + collection_id: int + partition_id: int + def __init__(self, collection_id: _Optional[int] = ..., partition_id: _Optional[int] = ...) -> None: ... + +class GcConfirmResponse(_message.Message): + __slots__ = ("status", "gc_finished") + STATUS_FIELD_NUMBER: _ClassVar[int] + GC_FINISHED_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + gc_finished: bool + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., gc_finished: bool = ...) -> None: ... + +class ReportDataNodeTtMsgsRequest(_message.Message): + __slots__ = ("base", "msgs") + BASE_FIELD_NUMBER: _ClassVar[int] + MSGS_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + msgs: _containers.RepeatedCompositeFieldContainer[_msg_pb2.DataNodeTtMsg] + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., msgs: _Optional[_Iterable[_Union[_msg_pb2.DataNodeTtMsg, _Mapping]]] = ...) -> None: ... + +class GetFlushStateRequest(_message.Message): + __slots__ = ("segmentIDs", "flush_ts", "db_name", "collection_name", "collectionID") + SEGMENTIDS_FIELD_NUMBER: _ClassVar[int] + FLUSH_TS_FIELD_NUMBER: _ClassVar[int] + DB_NAME_FIELD_NUMBER: _ClassVar[int] + COLLECTION_NAME_FIELD_NUMBER: _ClassVar[int] + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + segmentIDs: _containers.RepeatedScalarFieldContainer[int] + flush_ts: int + db_name: str + collection_name: str + collectionID: int + def __init__(self, segmentIDs: _Optional[_Iterable[int]] = ..., flush_ts: _Optional[int] = ..., db_name: _Optional[str] = ..., collection_name: _Optional[str] = ..., collectionID: _Optional[int] = ...) -> None: ... + +class ChannelOperationsRequest(_message.Message): + __slots__ = ("infos",) + INFOS_FIELD_NUMBER: _ClassVar[int] + infos: _containers.RepeatedCompositeFieldContainer[ChannelWatchInfo] + def __init__(self, infos: _Optional[_Iterable[_Union[ChannelWatchInfo, _Mapping]]] = ...) -> None: ... + +class ChannelOperationProgressResponse(_message.Message): + __slots__ = ("status", "opID", "state", "progress") + STATUS_FIELD_NUMBER: _ClassVar[int] + OPID_FIELD_NUMBER: _ClassVar[int] + STATE_FIELD_NUMBER: _ClassVar[int] + PROGRESS_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + opID: int + state: ChannelWatchState + progress: int + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., opID: _Optional[int] = ..., state: _Optional[_Union[ChannelWatchState, str]] = ..., progress: _Optional[int] = ...) -> None: ... + +class PreImportRequest(_message.Message): + __slots__ = ("clusterID", "jobID", "taskID", "collectionID", "partitionIDs", "vchannels", "schema", "import_files", "options") + CLUSTERID_FIELD_NUMBER: _ClassVar[int] + JOBID_FIELD_NUMBER: _ClassVar[int] + TASKID_FIELD_NUMBER: _ClassVar[int] + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + PARTITIONIDS_FIELD_NUMBER: _ClassVar[int] + VCHANNELS_FIELD_NUMBER: _ClassVar[int] + SCHEMA_FIELD_NUMBER: _ClassVar[int] + IMPORT_FILES_FIELD_NUMBER: _ClassVar[int] + OPTIONS_FIELD_NUMBER: _ClassVar[int] + clusterID: str + jobID: int + taskID: int + collectionID: int + partitionIDs: _containers.RepeatedScalarFieldContainer[int] + vchannels: _containers.RepeatedScalarFieldContainer[str] + schema: _schema_pb2.CollectionSchema + import_files: _containers.RepeatedCompositeFieldContainer[_internal_pb2.ImportFile] + options: _containers.RepeatedCompositeFieldContainer[_common_pb2.KeyValuePair] + def __init__(self, clusterID: _Optional[str] = ..., jobID: _Optional[int] = ..., taskID: _Optional[int] = ..., collectionID: _Optional[int] = ..., partitionIDs: _Optional[_Iterable[int]] = ..., vchannels: _Optional[_Iterable[str]] = ..., schema: _Optional[_Union[_schema_pb2.CollectionSchema, _Mapping]] = ..., import_files: _Optional[_Iterable[_Union[_internal_pb2.ImportFile, _Mapping]]] = ..., options: _Optional[_Iterable[_Union[_common_pb2.KeyValuePair, _Mapping]]] = ...) -> None: ... + +class autoIDRange(_message.Message): + __slots__ = ("begin", "end") + BEGIN_FIELD_NUMBER: _ClassVar[int] + END_FIELD_NUMBER: _ClassVar[int] + begin: int + end: int + def __init__(self, begin: _Optional[int] = ..., end: _Optional[int] = ...) -> None: ... + +class ImportRequestSegment(_message.Message): + __slots__ = ("segmentID", "partitionID", "vchannel") + SEGMENTID_FIELD_NUMBER: _ClassVar[int] + PARTITIONID_FIELD_NUMBER: _ClassVar[int] + VCHANNEL_FIELD_NUMBER: _ClassVar[int] + segmentID: int + partitionID: int + vchannel: str + def __init__(self, segmentID: _Optional[int] = ..., partitionID: _Optional[int] = ..., vchannel: _Optional[str] = ...) -> None: ... + +class ImportRequest(_message.Message): + __slots__ = ("clusterID", "jobID", "taskID", "collectionID", "partitionIDs", "vchannels", "schema", "files", "options", "ts", "autoID_range", "request_segments") + CLUSTERID_FIELD_NUMBER: _ClassVar[int] + JOBID_FIELD_NUMBER: _ClassVar[int] + TASKID_FIELD_NUMBER: _ClassVar[int] + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + PARTITIONIDS_FIELD_NUMBER: _ClassVar[int] + VCHANNELS_FIELD_NUMBER: _ClassVar[int] + SCHEMA_FIELD_NUMBER: _ClassVar[int] + FILES_FIELD_NUMBER: _ClassVar[int] + OPTIONS_FIELD_NUMBER: _ClassVar[int] + TS_FIELD_NUMBER: _ClassVar[int] + AUTOID_RANGE_FIELD_NUMBER: _ClassVar[int] + REQUEST_SEGMENTS_FIELD_NUMBER: _ClassVar[int] + clusterID: str + jobID: int + taskID: int + collectionID: int + partitionIDs: _containers.RepeatedScalarFieldContainer[int] + vchannels: _containers.RepeatedScalarFieldContainer[str] + schema: _schema_pb2.CollectionSchema + files: _containers.RepeatedCompositeFieldContainer[_internal_pb2.ImportFile] + options: _containers.RepeatedCompositeFieldContainer[_common_pb2.KeyValuePair] + ts: int + autoID_range: autoIDRange + request_segments: _containers.RepeatedCompositeFieldContainer[ImportRequestSegment] + def __init__(self, clusterID: _Optional[str] = ..., jobID: _Optional[int] = ..., taskID: _Optional[int] = ..., collectionID: _Optional[int] = ..., partitionIDs: _Optional[_Iterable[int]] = ..., vchannels: _Optional[_Iterable[str]] = ..., schema: _Optional[_Union[_schema_pb2.CollectionSchema, _Mapping]] = ..., files: _Optional[_Iterable[_Union[_internal_pb2.ImportFile, _Mapping]]] = ..., options: _Optional[_Iterable[_Union[_common_pb2.KeyValuePair, _Mapping]]] = ..., ts: _Optional[int] = ..., autoID_range: _Optional[_Union[autoIDRange, _Mapping]] = ..., request_segments: _Optional[_Iterable[_Union[ImportRequestSegment, _Mapping]]] = ...) -> None: ... + +class QueryPreImportRequest(_message.Message): + __slots__ = ("clusterID", "jobID", "taskID") + CLUSTERID_FIELD_NUMBER: _ClassVar[int] + JOBID_FIELD_NUMBER: _ClassVar[int] + TASKID_FIELD_NUMBER: _ClassVar[int] + clusterID: str + jobID: int + taskID: int + def __init__(self, clusterID: _Optional[str] = ..., jobID: _Optional[int] = ..., taskID: _Optional[int] = ...) -> None: ... + +class PartitionImportStats(_message.Message): + __slots__ = ("partition_rows", "partition_data_size") + class PartitionRowsEntry(_message.Message): + __slots__ = ("key", "value") + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: int + value: int + def __init__(self, key: _Optional[int] = ..., value: _Optional[int] = ...) -> None: ... + class PartitionDataSizeEntry(_message.Message): + __slots__ = ("key", "value") + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: int + value: int + def __init__(self, key: _Optional[int] = ..., value: _Optional[int] = ...) -> None: ... + PARTITION_ROWS_FIELD_NUMBER: _ClassVar[int] + PARTITION_DATA_SIZE_FIELD_NUMBER: _ClassVar[int] + partition_rows: _containers.ScalarMap[int, int] + partition_data_size: _containers.ScalarMap[int, int] + def __init__(self, partition_rows: _Optional[_Mapping[int, int]] = ..., partition_data_size: _Optional[_Mapping[int, int]] = ...) -> None: ... + +class ImportFileStats(_message.Message): + __slots__ = ("import_file", "file_size", "total_rows", "total_memory_size", "hashed_stats") + class HashedStatsEntry(_message.Message): + __slots__ = ("key", "value") + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: str + value: PartitionImportStats + def __init__(self, key: _Optional[str] = ..., value: _Optional[_Union[PartitionImportStats, _Mapping]] = ...) -> None: ... + IMPORT_FILE_FIELD_NUMBER: _ClassVar[int] + FILE_SIZE_FIELD_NUMBER: _ClassVar[int] + TOTAL_ROWS_FIELD_NUMBER: _ClassVar[int] + TOTAL_MEMORY_SIZE_FIELD_NUMBER: _ClassVar[int] + HASHED_STATS_FIELD_NUMBER: _ClassVar[int] + import_file: _internal_pb2.ImportFile + file_size: int + total_rows: int + total_memory_size: int + hashed_stats: _containers.MessageMap[str, PartitionImportStats] + def __init__(self, import_file: _Optional[_Union[_internal_pb2.ImportFile, _Mapping]] = ..., file_size: _Optional[int] = ..., total_rows: _Optional[int] = ..., total_memory_size: _Optional[int] = ..., hashed_stats: _Optional[_Mapping[str, PartitionImportStats]] = ...) -> None: ... + +class QueryPreImportResponse(_message.Message): + __slots__ = ("status", "taskID", "state", "reason", "slots", "file_stats") + STATUS_FIELD_NUMBER: _ClassVar[int] + TASKID_FIELD_NUMBER: _ClassVar[int] + STATE_FIELD_NUMBER: _ClassVar[int] + REASON_FIELD_NUMBER: _ClassVar[int] + SLOTS_FIELD_NUMBER: _ClassVar[int] + FILE_STATS_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + taskID: int + state: ImportTaskStateV2 + reason: str + slots: int + file_stats: _containers.RepeatedCompositeFieldContainer[ImportFileStats] + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., taskID: _Optional[int] = ..., state: _Optional[_Union[ImportTaskStateV2, str]] = ..., reason: _Optional[str] = ..., slots: _Optional[int] = ..., file_stats: _Optional[_Iterable[_Union[ImportFileStats, _Mapping]]] = ...) -> None: ... + +class QueryImportRequest(_message.Message): + __slots__ = ("clusterID", "jobID", "taskID", "querySlot") + CLUSTERID_FIELD_NUMBER: _ClassVar[int] + JOBID_FIELD_NUMBER: _ClassVar[int] + TASKID_FIELD_NUMBER: _ClassVar[int] + QUERYSLOT_FIELD_NUMBER: _ClassVar[int] + clusterID: str + jobID: int + taskID: int + querySlot: bool + def __init__(self, clusterID: _Optional[str] = ..., jobID: _Optional[int] = ..., taskID: _Optional[int] = ..., querySlot: bool = ...) -> None: ... + +class ImportSegmentInfo(_message.Message): + __slots__ = ("segmentID", "imported_rows", "binlogs", "statslogs") + SEGMENTID_FIELD_NUMBER: _ClassVar[int] + IMPORTED_ROWS_FIELD_NUMBER: _ClassVar[int] + BINLOGS_FIELD_NUMBER: _ClassVar[int] + STATSLOGS_FIELD_NUMBER: _ClassVar[int] + segmentID: int + imported_rows: int + binlogs: _containers.RepeatedCompositeFieldContainer[FieldBinlog] + statslogs: _containers.RepeatedCompositeFieldContainer[FieldBinlog] + def __init__(self, segmentID: _Optional[int] = ..., imported_rows: _Optional[int] = ..., binlogs: _Optional[_Iterable[_Union[FieldBinlog, _Mapping]]] = ..., statslogs: _Optional[_Iterable[_Union[FieldBinlog, _Mapping]]] = ...) -> None: ... + +class QueryImportResponse(_message.Message): + __slots__ = ("status", "taskID", "state", "reason", "slots", "import_segments_info") + STATUS_FIELD_NUMBER: _ClassVar[int] + TASKID_FIELD_NUMBER: _ClassVar[int] + STATE_FIELD_NUMBER: _ClassVar[int] + REASON_FIELD_NUMBER: _ClassVar[int] + SLOTS_FIELD_NUMBER: _ClassVar[int] + IMPORT_SEGMENTS_INFO_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + taskID: int + state: ImportTaskStateV2 + reason: str + slots: int + import_segments_info: _containers.RepeatedCompositeFieldContainer[ImportSegmentInfo] + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., taskID: _Optional[int] = ..., state: _Optional[_Union[ImportTaskStateV2, str]] = ..., reason: _Optional[str] = ..., slots: _Optional[int] = ..., import_segments_info: _Optional[_Iterable[_Union[ImportSegmentInfo, _Mapping]]] = ...) -> None: ... + +class DropImportRequest(_message.Message): + __slots__ = ("clusterID", "jobID", "taskID") + CLUSTERID_FIELD_NUMBER: _ClassVar[int] + JOBID_FIELD_NUMBER: _ClassVar[int] + TASKID_FIELD_NUMBER: _ClassVar[int] + clusterID: str + jobID: int + taskID: int + def __init__(self, clusterID: _Optional[str] = ..., jobID: _Optional[int] = ..., taskID: _Optional[int] = ...) -> None: ... + +class ImportJob(_message.Message): + __slots__ = ("jobID", "dbID", "collectionID", "partitionIDs", "vchannels", "schema", "timeout_ts", "cleanup_ts", "state", "reason", "files", "options") + JOBID_FIELD_NUMBER: _ClassVar[int] + DBID_FIELD_NUMBER: _ClassVar[int] + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + PARTITIONIDS_FIELD_NUMBER: _ClassVar[int] + VCHANNELS_FIELD_NUMBER: _ClassVar[int] + SCHEMA_FIELD_NUMBER: _ClassVar[int] + TIMEOUT_TS_FIELD_NUMBER: _ClassVar[int] + CLEANUP_TS_FIELD_NUMBER: _ClassVar[int] + STATE_FIELD_NUMBER: _ClassVar[int] + REASON_FIELD_NUMBER: _ClassVar[int] + FILES_FIELD_NUMBER: _ClassVar[int] + OPTIONS_FIELD_NUMBER: _ClassVar[int] + jobID: int + dbID: int + collectionID: int + partitionIDs: _containers.RepeatedScalarFieldContainer[int] + vchannels: _containers.RepeatedScalarFieldContainer[str] + schema: _schema_pb2.CollectionSchema + timeout_ts: int + cleanup_ts: int + state: _internal_pb2.ImportJobState + reason: str + files: _containers.RepeatedCompositeFieldContainer[_internal_pb2.ImportFile] + options: _containers.RepeatedCompositeFieldContainer[_common_pb2.KeyValuePair] + def __init__(self, jobID: _Optional[int] = ..., dbID: _Optional[int] = ..., collectionID: _Optional[int] = ..., partitionIDs: _Optional[_Iterable[int]] = ..., vchannels: _Optional[_Iterable[str]] = ..., schema: _Optional[_Union[_schema_pb2.CollectionSchema, _Mapping]] = ..., timeout_ts: _Optional[int] = ..., cleanup_ts: _Optional[int] = ..., state: _Optional[_Union[_internal_pb2.ImportJobState, str]] = ..., reason: _Optional[str] = ..., files: _Optional[_Iterable[_Union[_internal_pb2.ImportFile, _Mapping]]] = ..., options: _Optional[_Iterable[_Union[_common_pb2.KeyValuePair, _Mapping]]] = ...) -> None: ... + +class PreImportTask(_message.Message): + __slots__ = ("jobID", "taskID", "collectionID", "nodeID", "state", "reason", "file_stats") + JOBID_FIELD_NUMBER: _ClassVar[int] + TASKID_FIELD_NUMBER: _ClassVar[int] + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + NODEID_FIELD_NUMBER: _ClassVar[int] + STATE_FIELD_NUMBER: _ClassVar[int] + REASON_FIELD_NUMBER: _ClassVar[int] + FILE_STATS_FIELD_NUMBER: _ClassVar[int] + jobID: int + taskID: int + collectionID: int + nodeID: int + state: ImportTaskStateV2 + reason: str + file_stats: _containers.RepeatedCompositeFieldContainer[ImportFileStats] + def __init__(self, jobID: _Optional[int] = ..., taskID: _Optional[int] = ..., collectionID: _Optional[int] = ..., nodeID: _Optional[int] = ..., state: _Optional[_Union[ImportTaskStateV2, str]] = ..., reason: _Optional[str] = ..., file_stats: _Optional[_Iterable[_Union[ImportFileStats, _Mapping]]] = ...) -> None: ... + +class ImportTaskV2(_message.Message): + __slots__ = ("jobID", "taskID", "collectionID", "segmentIDs", "nodeID", "state", "reason", "file_stats") + JOBID_FIELD_NUMBER: _ClassVar[int] + TASKID_FIELD_NUMBER: _ClassVar[int] + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + SEGMENTIDS_FIELD_NUMBER: _ClassVar[int] + NODEID_FIELD_NUMBER: _ClassVar[int] + STATE_FIELD_NUMBER: _ClassVar[int] + REASON_FIELD_NUMBER: _ClassVar[int] + FILE_STATS_FIELD_NUMBER: _ClassVar[int] + jobID: int + taskID: int + collectionID: int + segmentIDs: _containers.RepeatedScalarFieldContainer[int] + nodeID: int + state: ImportTaskStateV2 + reason: str + file_stats: _containers.RepeatedCompositeFieldContainer[ImportFileStats] + def __init__(self, jobID: _Optional[int] = ..., taskID: _Optional[int] = ..., collectionID: _Optional[int] = ..., segmentIDs: _Optional[_Iterable[int]] = ..., nodeID: _Optional[int] = ..., state: _Optional[_Union[ImportTaskStateV2, str]] = ..., reason: _Optional[str] = ..., file_stats: _Optional[_Iterable[_Union[ImportFileStats, _Mapping]]] = ...) -> None: ... + +class GcControlRequest(_message.Message): + __slots__ = ("base", "command", "params") + BASE_FIELD_NUMBER: _ClassVar[int] + COMMAND_FIELD_NUMBER: _ClassVar[int] + PARAMS_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + command: GcCommand + params: _containers.RepeatedCompositeFieldContainer[_common_pb2.KeyValuePair] + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., command: _Optional[_Union[GcCommand, str]] = ..., params: _Optional[_Iterable[_Union[_common_pb2.KeyValuePair, _Mapping]]] = ...) -> None: ... diff --git a/milvus_connector/protocol/data_coord_pb2_grpc.py b/milvus_connector/protocol/data_coord_pb2_grpc.py new file mode 100644 index 0000000..2da7ef2 --- /dev/null +++ b/milvus_connector/protocol/data_coord_pb2_grpc.py @@ -0,0 +1,2384 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + +from . import common_pb2 as common__pb2 +from . import data_coord_pb2 as data__coord__pb2 +from . import index_coord_pb2 as index__coord__pb2 +from . import internal_pb2 as internal__pb2 +from . import milvus_pb2 as milvus__pb2 + + +class DataCoordStub(object): + """Missing associated documentation comment in .proto file.""" + + def __init__(self, channel): + """Constructor. + + Args: + channel: A grpc.Channel. + """ + self.GetComponentStates = channel.unary_unary( + '/milvus.proto.data.DataCoord/GetComponentStates', + request_serializer=milvus__pb2.GetComponentStatesRequest.SerializeToString, + response_deserializer=milvus__pb2.ComponentStates.FromString, + ) + self.GetTimeTickChannel = channel.unary_unary( + '/milvus.proto.data.DataCoord/GetTimeTickChannel', + request_serializer=internal__pb2.GetTimeTickChannelRequest.SerializeToString, + response_deserializer=milvus__pb2.StringResponse.FromString, + ) + self.GetStatisticsChannel = channel.unary_unary( + '/milvus.proto.data.DataCoord/GetStatisticsChannel', + request_serializer=internal__pb2.GetStatisticsChannelRequest.SerializeToString, + response_deserializer=milvus__pb2.StringResponse.FromString, + ) + self.Flush = channel.unary_unary( + '/milvus.proto.data.DataCoord/Flush', + request_serializer=data__coord__pb2.FlushRequest.SerializeToString, + response_deserializer=data__coord__pb2.FlushResponse.FromString, + ) + self.AssignSegmentID = channel.unary_unary( + '/milvus.proto.data.DataCoord/AssignSegmentID', + request_serializer=data__coord__pb2.AssignSegmentIDRequest.SerializeToString, + response_deserializer=data__coord__pb2.AssignSegmentIDResponse.FromString, + ) + self.GetSegmentInfo = channel.unary_unary( + '/milvus.proto.data.DataCoord/GetSegmentInfo', + request_serializer=data__coord__pb2.GetSegmentInfoRequest.SerializeToString, + response_deserializer=data__coord__pb2.GetSegmentInfoResponse.FromString, + ) + self.GetSegmentStates = channel.unary_unary( + '/milvus.proto.data.DataCoord/GetSegmentStates', + request_serializer=data__coord__pb2.GetSegmentStatesRequest.SerializeToString, + response_deserializer=data__coord__pb2.GetSegmentStatesResponse.FromString, + ) + self.GetInsertBinlogPaths = channel.unary_unary( + '/milvus.proto.data.DataCoord/GetInsertBinlogPaths', + request_serializer=data__coord__pb2.GetInsertBinlogPathsRequest.SerializeToString, + response_deserializer=data__coord__pb2.GetInsertBinlogPathsResponse.FromString, + ) + self.GetCollectionStatistics = channel.unary_unary( + '/milvus.proto.data.DataCoord/GetCollectionStatistics', + request_serializer=data__coord__pb2.GetCollectionStatisticsRequest.SerializeToString, + response_deserializer=data__coord__pb2.GetCollectionStatisticsResponse.FromString, + ) + self.GetPartitionStatistics = channel.unary_unary( + '/milvus.proto.data.DataCoord/GetPartitionStatistics', + request_serializer=data__coord__pb2.GetPartitionStatisticsRequest.SerializeToString, + response_deserializer=data__coord__pb2.GetPartitionStatisticsResponse.FromString, + ) + self.GetSegmentInfoChannel = channel.unary_unary( + '/milvus.proto.data.DataCoord/GetSegmentInfoChannel', + request_serializer=data__coord__pb2.GetSegmentInfoChannelRequest.SerializeToString, + response_deserializer=milvus__pb2.StringResponse.FromString, + ) + self.SaveBinlogPaths = channel.unary_unary( + '/milvus.proto.data.DataCoord/SaveBinlogPaths', + request_serializer=data__coord__pb2.SaveBinlogPathsRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.GetRecoveryInfo = channel.unary_unary( + '/milvus.proto.data.DataCoord/GetRecoveryInfo', + request_serializer=data__coord__pb2.GetRecoveryInfoRequest.SerializeToString, + response_deserializer=data__coord__pb2.GetRecoveryInfoResponse.FromString, + ) + self.GetRecoveryInfoV2 = channel.unary_unary( + '/milvus.proto.data.DataCoord/GetRecoveryInfoV2', + request_serializer=data__coord__pb2.GetRecoveryInfoRequestV2.SerializeToString, + response_deserializer=data__coord__pb2.GetRecoveryInfoResponseV2.FromString, + ) + self.GetFlushedSegments = channel.unary_unary( + '/milvus.proto.data.DataCoord/GetFlushedSegments', + request_serializer=data__coord__pb2.GetFlushedSegmentsRequest.SerializeToString, + response_deserializer=data__coord__pb2.GetFlushedSegmentsResponse.FromString, + ) + self.GetSegmentsByStates = channel.unary_unary( + '/milvus.proto.data.DataCoord/GetSegmentsByStates', + request_serializer=data__coord__pb2.GetSegmentsByStatesRequest.SerializeToString, + response_deserializer=data__coord__pb2.GetSegmentsByStatesResponse.FromString, + ) + self.GetFlushAllState = channel.unary_unary( + '/milvus.proto.data.DataCoord/GetFlushAllState', + request_serializer=milvus__pb2.GetFlushAllStateRequest.SerializeToString, + response_deserializer=milvus__pb2.GetFlushAllStateResponse.FromString, + ) + self.ShowConfigurations = channel.unary_unary( + '/milvus.proto.data.DataCoord/ShowConfigurations', + request_serializer=internal__pb2.ShowConfigurationsRequest.SerializeToString, + response_deserializer=internal__pb2.ShowConfigurationsResponse.FromString, + ) + self.GetMetrics = channel.unary_unary( + '/milvus.proto.data.DataCoord/GetMetrics', + request_serializer=milvus__pb2.GetMetricsRequest.SerializeToString, + response_deserializer=milvus__pb2.GetMetricsResponse.FromString, + ) + self.ManualCompaction = channel.unary_unary( + '/milvus.proto.data.DataCoord/ManualCompaction', + request_serializer=milvus__pb2.ManualCompactionRequest.SerializeToString, + response_deserializer=milvus__pb2.ManualCompactionResponse.FromString, + ) + self.GetCompactionState = channel.unary_unary( + '/milvus.proto.data.DataCoord/GetCompactionState', + request_serializer=milvus__pb2.GetCompactionStateRequest.SerializeToString, + response_deserializer=milvus__pb2.GetCompactionStateResponse.FromString, + ) + self.GetCompactionStateWithPlans = channel.unary_unary( + '/milvus.proto.data.DataCoord/GetCompactionStateWithPlans', + request_serializer=milvus__pb2.GetCompactionPlansRequest.SerializeToString, + response_deserializer=milvus__pb2.GetCompactionPlansResponse.FromString, + ) + self.WatchChannels = channel.unary_unary( + '/milvus.proto.data.DataCoord/WatchChannels', + request_serializer=data__coord__pb2.WatchChannelsRequest.SerializeToString, + response_deserializer=data__coord__pb2.WatchChannelsResponse.FromString, + ) + self.GetFlushState = channel.unary_unary( + '/milvus.proto.data.DataCoord/GetFlushState', + request_serializer=data__coord__pb2.GetFlushStateRequest.SerializeToString, + response_deserializer=milvus__pb2.GetFlushStateResponse.FromString, + ) + self.DropVirtualChannel = channel.unary_unary( + '/milvus.proto.data.DataCoord/DropVirtualChannel', + request_serializer=data__coord__pb2.DropVirtualChannelRequest.SerializeToString, + response_deserializer=data__coord__pb2.DropVirtualChannelResponse.FromString, + ) + self.SetSegmentState = channel.unary_unary( + '/milvus.proto.data.DataCoord/SetSegmentState', + request_serializer=data__coord__pb2.SetSegmentStateRequest.SerializeToString, + response_deserializer=data__coord__pb2.SetSegmentStateResponse.FromString, + ) + self.Import = channel.unary_unary( + '/milvus.proto.data.DataCoord/Import', + request_serializer=data__coord__pb2.ImportTaskRequest.SerializeToString, + response_deserializer=data__coord__pb2.ImportTaskResponse.FromString, + ) + self.UpdateSegmentStatistics = channel.unary_unary( + '/milvus.proto.data.DataCoord/UpdateSegmentStatistics', + request_serializer=data__coord__pb2.UpdateSegmentStatisticsRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.UpdateChannelCheckpoint = channel.unary_unary( + '/milvus.proto.data.DataCoord/UpdateChannelCheckpoint', + request_serializer=data__coord__pb2.UpdateChannelCheckpointRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.SaveImportSegment = channel.unary_unary( + '/milvus.proto.data.DataCoord/SaveImportSegment', + request_serializer=data__coord__pb2.SaveImportSegmentRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.UnsetIsImportingState = channel.unary_unary( + '/milvus.proto.data.DataCoord/UnsetIsImportingState', + request_serializer=data__coord__pb2.UnsetIsImportingStateRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.MarkSegmentsDropped = channel.unary_unary( + '/milvus.proto.data.DataCoord/MarkSegmentsDropped', + request_serializer=data__coord__pb2.MarkSegmentsDroppedRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.BroadcastAlteredCollection = channel.unary_unary( + '/milvus.proto.data.DataCoord/BroadcastAlteredCollection', + request_serializer=data__coord__pb2.AlterCollectionRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.CheckHealth = channel.unary_unary( + '/milvus.proto.data.DataCoord/CheckHealth', + request_serializer=milvus__pb2.CheckHealthRequest.SerializeToString, + response_deserializer=milvus__pb2.CheckHealthResponse.FromString, + ) + self.CreateIndex = channel.unary_unary( + '/milvus.proto.data.DataCoord/CreateIndex', + request_serializer=index__coord__pb2.CreateIndexRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.AlterIndex = channel.unary_unary( + '/milvus.proto.data.DataCoord/AlterIndex', + request_serializer=index__coord__pb2.AlterIndexRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.GetIndexState = channel.unary_unary( + '/milvus.proto.data.DataCoord/GetIndexState', + request_serializer=index__coord__pb2.GetIndexStateRequest.SerializeToString, + response_deserializer=index__coord__pb2.GetIndexStateResponse.FromString, + ) + self.GetSegmentIndexState = channel.unary_unary( + '/milvus.proto.data.DataCoord/GetSegmentIndexState', + request_serializer=index__coord__pb2.GetSegmentIndexStateRequest.SerializeToString, + response_deserializer=index__coord__pb2.GetSegmentIndexStateResponse.FromString, + ) + self.GetIndexInfos = channel.unary_unary( + '/milvus.proto.data.DataCoord/GetIndexInfos', + request_serializer=index__coord__pb2.GetIndexInfoRequest.SerializeToString, + response_deserializer=index__coord__pb2.GetIndexInfoResponse.FromString, + ) + self.DropIndex = channel.unary_unary( + '/milvus.proto.data.DataCoord/DropIndex', + request_serializer=index__coord__pb2.DropIndexRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.DescribeIndex = channel.unary_unary( + '/milvus.proto.data.DataCoord/DescribeIndex', + request_serializer=index__coord__pb2.DescribeIndexRequest.SerializeToString, + response_deserializer=index__coord__pb2.DescribeIndexResponse.FromString, + ) + self.GetIndexStatistics = channel.unary_unary( + '/milvus.proto.data.DataCoord/GetIndexStatistics', + request_serializer=index__coord__pb2.GetIndexStatisticsRequest.SerializeToString, + response_deserializer=index__coord__pb2.GetIndexStatisticsResponse.FromString, + ) + self.GetIndexBuildProgress = channel.unary_unary( + '/milvus.proto.data.DataCoord/GetIndexBuildProgress', + request_serializer=index__coord__pb2.GetIndexBuildProgressRequest.SerializeToString, + response_deserializer=index__coord__pb2.GetIndexBuildProgressResponse.FromString, + ) + self.ListIndexes = channel.unary_unary( + '/milvus.proto.data.DataCoord/ListIndexes', + request_serializer=index__coord__pb2.ListIndexesRequest.SerializeToString, + response_deserializer=index__coord__pb2.ListIndexesResponse.FromString, + ) + self.GcConfirm = channel.unary_unary( + '/milvus.proto.data.DataCoord/GcConfirm', + request_serializer=data__coord__pb2.GcConfirmRequest.SerializeToString, + response_deserializer=data__coord__pb2.GcConfirmResponse.FromString, + ) + self.ReportDataNodeTtMsgs = channel.unary_unary( + '/milvus.proto.data.DataCoord/ReportDataNodeTtMsgs', + request_serializer=data__coord__pb2.ReportDataNodeTtMsgsRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.GcControl = channel.unary_unary( + '/milvus.proto.data.DataCoord/GcControl', + request_serializer=data__coord__pb2.GcControlRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.ImportV2 = channel.unary_unary( + '/milvus.proto.data.DataCoord/ImportV2', + request_serializer=internal__pb2.ImportRequestInternal.SerializeToString, + response_deserializer=internal__pb2.ImportResponse.FromString, + ) + self.GetImportProgress = channel.unary_unary( + '/milvus.proto.data.DataCoord/GetImportProgress', + request_serializer=internal__pb2.GetImportProgressRequest.SerializeToString, + response_deserializer=internal__pb2.GetImportProgressResponse.FromString, + ) + self.ListImports = channel.unary_unary( + '/milvus.proto.data.DataCoord/ListImports', + request_serializer=internal__pb2.ListImportsRequestInternal.SerializeToString, + response_deserializer=internal__pb2.ListImportsResponse.FromString, + ) + + +class DataCoordServicer(object): + """Missing associated documentation comment in .proto file.""" + + def GetComponentStates(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetTimeTickChannel(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetStatisticsChannel(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def Flush(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def AssignSegmentID(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetSegmentInfo(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetSegmentStates(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetInsertBinlogPaths(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetCollectionStatistics(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetPartitionStatistics(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetSegmentInfoChannel(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def SaveBinlogPaths(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetRecoveryInfo(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetRecoveryInfoV2(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetFlushedSegments(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetSegmentsByStates(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetFlushAllState(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ShowConfigurations(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetMetrics(self, request, context): + """https://wiki.lfaidata.foundation/display/MIL/MEP+8+--+Add+metrics+for+proxy + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ManualCompaction(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetCompactionState(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetCompactionStateWithPlans(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def WatchChannels(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetFlushState(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def DropVirtualChannel(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def SetSegmentState(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def Import(self, request, context): + """https://wiki.lfaidata.foundation/display/MIL/MEP+24+--+Support+bulk+load + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def UpdateSegmentStatistics(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def UpdateChannelCheckpoint(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def SaveImportSegment(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def UnsetIsImportingState(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def MarkSegmentsDropped(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def BroadcastAlteredCollection(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def CheckHealth(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def CreateIndex(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def AlterIndex(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetIndexState(self, request, context): + """Deprecated: use DescribeIndex instead + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetSegmentIndexState(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetIndexInfos(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def DropIndex(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def DescribeIndex(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetIndexStatistics(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetIndexBuildProgress(self, request, context): + """Deprecated: use DescribeIndex instead + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ListIndexes(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GcConfirm(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ReportDataNodeTtMsgs(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GcControl(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ImportV2(self, request, context): + """importV2 + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetImportProgress(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ListImports(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + +def add_DataCoordServicer_to_server(servicer, server): + rpc_method_handlers = { + 'GetComponentStates': grpc.unary_unary_rpc_method_handler( + servicer.GetComponentStates, + request_deserializer=milvus__pb2.GetComponentStatesRequest.FromString, + response_serializer=milvus__pb2.ComponentStates.SerializeToString, + ), + 'GetTimeTickChannel': grpc.unary_unary_rpc_method_handler( + servicer.GetTimeTickChannel, + request_deserializer=internal__pb2.GetTimeTickChannelRequest.FromString, + response_serializer=milvus__pb2.StringResponse.SerializeToString, + ), + 'GetStatisticsChannel': grpc.unary_unary_rpc_method_handler( + servicer.GetStatisticsChannel, + request_deserializer=internal__pb2.GetStatisticsChannelRequest.FromString, + response_serializer=milvus__pb2.StringResponse.SerializeToString, + ), + 'Flush': grpc.unary_unary_rpc_method_handler( + servicer.Flush, + request_deserializer=data__coord__pb2.FlushRequest.FromString, + response_serializer=data__coord__pb2.FlushResponse.SerializeToString, + ), + 'AssignSegmentID': grpc.unary_unary_rpc_method_handler( + servicer.AssignSegmentID, + request_deserializer=data__coord__pb2.AssignSegmentIDRequest.FromString, + response_serializer=data__coord__pb2.AssignSegmentIDResponse.SerializeToString, + ), + 'GetSegmentInfo': grpc.unary_unary_rpc_method_handler( + servicer.GetSegmentInfo, + request_deserializer=data__coord__pb2.GetSegmentInfoRequest.FromString, + response_serializer=data__coord__pb2.GetSegmentInfoResponse.SerializeToString, + ), + 'GetSegmentStates': grpc.unary_unary_rpc_method_handler( + servicer.GetSegmentStates, + request_deserializer=data__coord__pb2.GetSegmentStatesRequest.FromString, + response_serializer=data__coord__pb2.GetSegmentStatesResponse.SerializeToString, + ), + 'GetInsertBinlogPaths': grpc.unary_unary_rpc_method_handler( + servicer.GetInsertBinlogPaths, + request_deserializer=data__coord__pb2.GetInsertBinlogPathsRequest.FromString, + response_serializer=data__coord__pb2.GetInsertBinlogPathsResponse.SerializeToString, + ), + 'GetCollectionStatistics': grpc.unary_unary_rpc_method_handler( + servicer.GetCollectionStatistics, + request_deserializer=data__coord__pb2.GetCollectionStatisticsRequest.FromString, + response_serializer=data__coord__pb2.GetCollectionStatisticsResponse.SerializeToString, + ), + 'GetPartitionStatistics': grpc.unary_unary_rpc_method_handler( + servicer.GetPartitionStatistics, + request_deserializer=data__coord__pb2.GetPartitionStatisticsRequest.FromString, + response_serializer=data__coord__pb2.GetPartitionStatisticsResponse.SerializeToString, + ), + 'GetSegmentInfoChannel': grpc.unary_unary_rpc_method_handler( + servicer.GetSegmentInfoChannel, + request_deserializer=data__coord__pb2.GetSegmentInfoChannelRequest.FromString, + response_serializer=milvus__pb2.StringResponse.SerializeToString, + ), + 'SaveBinlogPaths': grpc.unary_unary_rpc_method_handler( + servicer.SaveBinlogPaths, + request_deserializer=data__coord__pb2.SaveBinlogPathsRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'GetRecoveryInfo': grpc.unary_unary_rpc_method_handler( + servicer.GetRecoveryInfo, + request_deserializer=data__coord__pb2.GetRecoveryInfoRequest.FromString, + response_serializer=data__coord__pb2.GetRecoveryInfoResponse.SerializeToString, + ), + 'GetRecoveryInfoV2': grpc.unary_unary_rpc_method_handler( + servicer.GetRecoveryInfoV2, + request_deserializer=data__coord__pb2.GetRecoveryInfoRequestV2.FromString, + response_serializer=data__coord__pb2.GetRecoveryInfoResponseV2.SerializeToString, + ), + 'GetFlushedSegments': grpc.unary_unary_rpc_method_handler( + servicer.GetFlushedSegments, + request_deserializer=data__coord__pb2.GetFlushedSegmentsRequest.FromString, + response_serializer=data__coord__pb2.GetFlushedSegmentsResponse.SerializeToString, + ), + 'GetSegmentsByStates': grpc.unary_unary_rpc_method_handler( + servicer.GetSegmentsByStates, + request_deserializer=data__coord__pb2.GetSegmentsByStatesRequest.FromString, + response_serializer=data__coord__pb2.GetSegmentsByStatesResponse.SerializeToString, + ), + 'GetFlushAllState': grpc.unary_unary_rpc_method_handler( + servicer.GetFlushAllState, + request_deserializer=milvus__pb2.GetFlushAllStateRequest.FromString, + response_serializer=milvus__pb2.GetFlushAllStateResponse.SerializeToString, + ), + 'ShowConfigurations': grpc.unary_unary_rpc_method_handler( + servicer.ShowConfigurations, + request_deserializer=internal__pb2.ShowConfigurationsRequest.FromString, + response_serializer=internal__pb2.ShowConfigurationsResponse.SerializeToString, + ), + 'GetMetrics': grpc.unary_unary_rpc_method_handler( + servicer.GetMetrics, + request_deserializer=milvus__pb2.GetMetricsRequest.FromString, + response_serializer=milvus__pb2.GetMetricsResponse.SerializeToString, + ), + 'ManualCompaction': grpc.unary_unary_rpc_method_handler( + servicer.ManualCompaction, + request_deserializer=milvus__pb2.ManualCompactionRequest.FromString, + response_serializer=milvus__pb2.ManualCompactionResponse.SerializeToString, + ), + 'GetCompactionState': grpc.unary_unary_rpc_method_handler( + servicer.GetCompactionState, + request_deserializer=milvus__pb2.GetCompactionStateRequest.FromString, + response_serializer=milvus__pb2.GetCompactionStateResponse.SerializeToString, + ), + 'GetCompactionStateWithPlans': grpc.unary_unary_rpc_method_handler( + servicer.GetCompactionStateWithPlans, + request_deserializer=milvus__pb2.GetCompactionPlansRequest.FromString, + response_serializer=milvus__pb2.GetCompactionPlansResponse.SerializeToString, + ), + 'WatchChannels': grpc.unary_unary_rpc_method_handler( + servicer.WatchChannels, + request_deserializer=data__coord__pb2.WatchChannelsRequest.FromString, + response_serializer=data__coord__pb2.WatchChannelsResponse.SerializeToString, + ), + 'GetFlushState': grpc.unary_unary_rpc_method_handler( + servicer.GetFlushState, + request_deserializer=data__coord__pb2.GetFlushStateRequest.FromString, + response_serializer=milvus__pb2.GetFlushStateResponse.SerializeToString, + ), + 'DropVirtualChannel': grpc.unary_unary_rpc_method_handler( + servicer.DropVirtualChannel, + request_deserializer=data__coord__pb2.DropVirtualChannelRequest.FromString, + response_serializer=data__coord__pb2.DropVirtualChannelResponse.SerializeToString, + ), + 'SetSegmentState': grpc.unary_unary_rpc_method_handler( + servicer.SetSegmentState, + request_deserializer=data__coord__pb2.SetSegmentStateRequest.FromString, + response_serializer=data__coord__pb2.SetSegmentStateResponse.SerializeToString, + ), + 'Import': grpc.unary_unary_rpc_method_handler( + servicer.Import, + request_deserializer=data__coord__pb2.ImportTaskRequest.FromString, + response_serializer=data__coord__pb2.ImportTaskResponse.SerializeToString, + ), + 'UpdateSegmentStatistics': grpc.unary_unary_rpc_method_handler( + servicer.UpdateSegmentStatistics, + request_deserializer=data__coord__pb2.UpdateSegmentStatisticsRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'UpdateChannelCheckpoint': grpc.unary_unary_rpc_method_handler( + servicer.UpdateChannelCheckpoint, + request_deserializer=data__coord__pb2.UpdateChannelCheckpointRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'SaveImportSegment': grpc.unary_unary_rpc_method_handler( + servicer.SaveImportSegment, + request_deserializer=data__coord__pb2.SaveImportSegmentRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'UnsetIsImportingState': grpc.unary_unary_rpc_method_handler( + servicer.UnsetIsImportingState, + request_deserializer=data__coord__pb2.UnsetIsImportingStateRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'MarkSegmentsDropped': grpc.unary_unary_rpc_method_handler( + servicer.MarkSegmentsDropped, + request_deserializer=data__coord__pb2.MarkSegmentsDroppedRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'BroadcastAlteredCollection': grpc.unary_unary_rpc_method_handler( + servicer.BroadcastAlteredCollection, + request_deserializer=data__coord__pb2.AlterCollectionRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'CheckHealth': grpc.unary_unary_rpc_method_handler( + servicer.CheckHealth, + request_deserializer=milvus__pb2.CheckHealthRequest.FromString, + response_serializer=milvus__pb2.CheckHealthResponse.SerializeToString, + ), + 'CreateIndex': grpc.unary_unary_rpc_method_handler( + servicer.CreateIndex, + request_deserializer=index__coord__pb2.CreateIndexRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'AlterIndex': grpc.unary_unary_rpc_method_handler( + servicer.AlterIndex, + request_deserializer=index__coord__pb2.AlterIndexRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'GetIndexState': grpc.unary_unary_rpc_method_handler( + servicer.GetIndexState, + request_deserializer=index__coord__pb2.GetIndexStateRequest.FromString, + response_serializer=index__coord__pb2.GetIndexStateResponse.SerializeToString, + ), + 'GetSegmentIndexState': grpc.unary_unary_rpc_method_handler( + servicer.GetSegmentIndexState, + request_deserializer=index__coord__pb2.GetSegmentIndexStateRequest.FromString, + response_serializer=index__coord__pb2.GetSegmentIndexStateResponse.SerializeToString, + ), + 'GetIndexInfos': grpc.unary_unary_rpc_method_handler( + servicer.GetIndexInfos, + request_deserializer=index__coord__pb2.GetIndexInfoRequest.FromString, + response_serializer=index__coord__pb2.GetIndexInfoResponse.SerializeToString, + ), + 'DropIndex': grpc.unary_unary_rpc_method_handler( + servicer.DropIndex, + request_deserializer=index__coord__pb2.DropIndexRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'DescribeIndex': grpc.unary_unary_rpc_method_handler( + servicer.DescribeIndex, + request_deserializer=index__coord__pb2.DescribeIndexRequest.FromString, + response_serializer=index__coord__pb2.DescribeIndexResponse.SerializeToString, + ), + 'GetIndexStatistics': grpc.unary_unary_rpc_method_handler( + servicer.GetIndexStatistics, + request_deserializer=index__coord__pb2.GetIndexStatisticsRequest.FromString, + response_serializer=index__coord__pb2.GetIndexStatisticsResponse.SerializeToString, + ), + 'GetIndexBuildProgress': grpc.unary_unary_rpc_method_handler( + servicer.GetIndexBuildProgress, + request_deserializer=index__coord__pb2.GetIndexBuildProgressRequest.FromString, + response_serializer=index__coord__pb2.GetIndexBuildProgressResponse.SerializeToString, + ), + 'ListIndexes': grpc.unary_unary_rpc_method_handler( + servicer.ListIndexes, + request_deserializer=index__coord__pb2.ListIndexesRequest.FromString, + response_serializer=index__coord__pb2.ListIndexesResponse.SerializeToString, + ), + 'GcConfirm': grpc.unary_unary_rpc_method_handler( + servicer.GcConfirm, + request_deserializer=data__coord__pb2.GcConfirmRequest.FromString, + response_serializer=data__coord__pb2.GcConfirmResponse.SerializeToString, + ), + 'ReportDataNodeTtMsgs': grpc.unary_unary_rpc_method_handler( + servicer.ReportDataNodeTtMsgs, + request_deserializer=data__coord__pb2.ReportDataNodeTtMsgsRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'GcControl': grpc.unary_unary_rpc_method_handler( + servicer.GcControl, + request_deserializer=data__coord__pb2.GcControlRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'ImportV2': grpc.unary_unary_rpc_method_handler( + servicer.ImportV2, + request_deserializer=internal__pb2.ImportRequestInternal.FromString, + response_serializer=internal__pb2.ImportResponse.SerializeToString, + ), + 'GetImportProgress': grpc.unary_unary_rpc_method_handler( + servicer.GetImportProgress, + request_deserializer=internal__pb2.GetImportProgressRequest.FromString, + response_serializer=internal__pb2.GetImportProgressResponse.SerializeToString, + ), + 'ListImports': grpc.unary_unary_rpc_method_handler( + servicer.ListImports, + request_deserializer=internal__pb2.ListImportsRequestInternal.FromString, + response_serializer=internal__pb2.ListImportsResponse.SerializeToString, + ), + } + generic_handler = grpc.method_handlers_generic_handler( + 'milvus.proto.data.DataCoord', rpc_method_handlers) + server.add_generic_rpc_handlers((generic_handler,)) + + + # This class is part of an EXPERIMENTAL API. +class DataCoord(object): + """Missing associated documentation comment in .proto file.""" + + @staticmethod + def GetComponentStates(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.data.DataCoord/GetComponentStates', + milvus__pb2.GetComponentStatesRequest.SerializeToString, + milvus__pb2.ComponentStates.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetTimeTickChannel(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.data.DataCoord/GetTimeTickChannel', + internal__pb2.GetTimeTickChannelRequest.SerializeToString, + milvus__pb2.StringResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetStatisticsChannel(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.data.DataCoord/GetStatisticsChannel', + internal__pb2.GetStatisticsChannelRequest.SerializeToString, + milvus__pb2.StringResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def Flush(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.data.DataCoord/Flush', + data__coord__pb2.FlushRequest.SerializeToString, + data__coord__pb2.FlushResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def AssignSegmentID(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.data.DataCoord/AssignSegmentID', + data__coord__pb2.AssignSegmentIDRequest.SerializeToString, + data__coord__pb2.AssignSegmentIDResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetSegmentInfo(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.data.DataCoord/GetSegmentInfo', + data__coord__pb2.GetSegmentInfoRequest.SerializeToString, + data__coord__pb2.GetSegmentInfoResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetSegmentStates(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.data.DataCoord/GetSegmentStates', + data__coord__pb2.GetSegmentStatesRequest.SerializeToString, + data__coord__pb2.GetSegmentStatesResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetInsertBinlogPaths(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.data.DataCoord/GetInsertBinlogPaths', + data__coord__pb2.GetInsertBinlogPathsRequest.SerializeToString, + data__coord__pb2.GetInsertBinlogPathsResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetCollectionStatistics(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.data.DataCoord/GetCollectionStatistics', + data__coord__pb2.GetCollectionStatisticsRequest.SerializeToString, + data__coord__pb2.GetCollectionStatisticsResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetPartitionStatistics(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.data.DataCoord/GetPartitionStatistics', + data__coord__pb2.GetPartitionStatisticsRequest.SerializeToString, + data__coord__pb2.GetPartitionStatisticsResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetSegmentInfoChannel(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.data.DataCoord/GetSegmentInfoChannel', + data__coord__pb2.GetSegmentInfoChannelRequest.SerializeToString, + milvus__pb2.StringResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def SaveBinlogPaths(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.data.DataCoord/SaveBinlogPaths', + data__coord__pb2.SaveBinlogPathsRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetRecoveryInfo(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.data.DataCoord/GetRecoveryInfo', + data__coord__pb2.GetRecoveryInfoRequest.SerializeToString, + data__coord__pb2.GetRecoveryInfoResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetRecoveryInfoV2(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.data.DataCoord/GetRecoveryInfoV2', + data__coord__pb2.GetRecoveryInfoRequestV2.SerializeToString, + data__coord__pb2.GetRecoveryInfoResponseV2.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetFlushedSegments(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.data.DataCoord/GetFlushedSegments', + data__coord__pb2.GetFlushedSegmentsRequest.SerializeToString, + data__coord__pb2.GetFlushedSegmentsResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetSegmentsByStates(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.data.DataCoord/GetSegmentsByStates', + data__coord__pb2.GetSegmentsByStatesRequest.SerializeToString, + data__coord__pb2.GetSegmentsByStatesResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetFlushAllState(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.data.DataCoord/GetFlushAllState', + milvus__pb2.GetFlushAllStateRequest.SerializeToString, + milvus__pb2.GetFlushAllStateResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def ShowConfigurations(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.data.DataCoord/ShowConfigurations', + internal__pb2.ShowConfigurationsRequest.SerializeToString, + internal__pb2.ShowConfigurationsResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetMetrics(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.data.DataCoord/GetMetrics', + milvus__pb2.GetMetricsRequest.SerializeToString, + milvus__pb2.GetMetricsResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def ManualCompaction(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.data.DataCoord/ManualCompaction', + milvus__pb2.ManualCompactionRequest.SerializeToString, + milvus__pb2.ManualCompactionResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetCompactionState(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.data.DataCoord/GetCompactionState', + milvus__pb2.GetCompactionStateRequest.SerializeToString, + milvus__pb2.GetCompactionStateResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetCompactionStateWithPlans(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.data.DataCoord/GetCompactionStateWithPlans', + milvus__pb2.GetCompactionPlansRequest.SerializeToString, + milvus__pb2.GetCompactionPlansResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def WatchChannels(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.data.DataCoord/WatchChannels', + data__coord__pb2.WatchChannelsRequest.SerializeToString, + data__coord__pb2.WatchChannelsResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetFlushState(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.data.DataCoord/GetFlushState', + data__coord__pb2.GetFlushStateRequest.SerializeToString, + milvus__pb2.GetFlushStateResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def DropVirtualChannel(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.data.DataCoord/DropVirtualChannel', + data__coord__pb2.DropVirtualChannelRequest.SerializeToString, + data__coord__pb2.DropVirtualChannelResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def SetSegmentState(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.data.DataCoord/SetSegmentState', + data__coord__pb2.SetSegmentStateRequest.SerializeToString, + data__coord__pb2.SetSegmentStateResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def Import(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.data.DataCoord/Import', + data__coord__pb2.ImportTaskRequest.SerializeToString, + data__coord__pb2.ImportTaskResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def UpdateSegmentStatistics(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.data.DataCoord/UpdateSegmentStatistics', + data__coord__pb2.UpdateSegmentStatisticsRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def UpdateChannelCheckpoint(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.data.DataCoord/UpdateChannelCheckpoint', + data__coord__pb2.UpdateChannelCheckpointRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def SaveImportSegment(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.data.DataCoord/SaveImportSegment', + data__coord__pb2.SaveImportSegmentRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def UnsetIsImportingState(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.data.DataCoord/UnsetIsImportingState', + data__coord__pb2.UnsetIsImportingStateRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def MarkSegmentsDropped(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.data.DataCoord/MarkSegmentsDropped', + data__coord__pb2.MarkSegmentsDroppedRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def BroadcastAlteredCollection(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.data.DataCoord/BroadcastAlteredCollection', + data__coord__pb2.AlterCollectionRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def CheckHealth(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.data.DataCoord/CheckHealth', + milvus__pb2.CheckHealthRequest.SerializeToString, + milvus__pb2.CheckHealthResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def CreateIndex(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.data.DataCoord/CreateIndex', + index__coord__pb2.CreateIndexRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def AlterIndex(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.data.DataCoord/AlterIndex', + index__coord__pb2.AlterIndexRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetIndexState(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.data.DataCoord/GetIndexState', + index__coord__pb2.GetIndexStateRequest.SerializeToString, + index__coord__pb2.GetIndexStateResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetSegmentIndexState(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.data.DataCoord/GetSegmentIndexState', + index__coord__pb2.GetSegmentIndexStateRequest.SerializeToString, + index__coord__pb2.GetSegmentIndexStateResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetIndexInfos(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.data.DataCoord/GetIndexInfos', + index__coord__pb2.GetIndexInfoRequest.SerializeToString, + index__coord__pb2.GetIndexInfoResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def DropIndex(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.data.DataCoord/DropIndex', + index__coord__pb2.DropIndexRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def DescribeIndex(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.data.DataCoord/DescribeIndex', + index__coord__pb2.DescribeIndexRequest.SerializeToString, + index__coord__pb2.DescribeIndexResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetIndexStatistics(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.data.DataCoord/GetIndexStatistics', + index__coord__pb2.GetIndexStatisticsRequest.SerializeToString, + index__coord__pb2.GetIndexStatisticsResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetIndexBuildProgress(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.data.DataCoord/GetIndexBuildProgress', + index__coord__pb2.GetIndexBuildProgressRequest.SerializeToString, + index__coord__pb2.GetIndexBuildProgressResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def ListIndexes(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.data.DataCoord/ListIndexes', + index__coord__pb2.ListIndexesRequest.SerializeToString, + index__coord__pb2.ListIndexesResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GcConfirm(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.data.DataCoord/GcConfirm', + data__coord__pb2.GcConfirmRequest.SerializeToString, + data__coord__pb2.GcConfirmResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def ReportDataNodeTtMsgs(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.data.DataCoord/ReportDataNodeTtMsgs', + data__coord__pb2.ReportDataNodeTtMsgsRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GcControl(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.data.DataCoord/GcControl', + data__coord__pb2.GcControlRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def ImportV2(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.data.DataCoord/ImportV2', + internal__pb2.ImportRequestInternal.SerializeToString, + internal__pb2.ImportResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetImportProgress(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.data.DataCoord/GetImportProgress', + internal__pb2.GetImportProgressRequest.SerializeToString, + internal__pb2.GetImportProgressResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def ListImports(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.data.DataCoord/ListImports', + internal__pb2.ListImportsRequestInternal.SerializeToString, + internal__pb2.ListImportsResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + +class DataNodeStub(object): + """Missing associated documentation comment in .proto file.""" + + def __init__(self, channel): + """Constructor. + + Args: + channel: A grpc.Channel. + """ + self.GetComponentStates = channel.unary_unary( + '/milvus.proto.data.DataNode/GetComponentStates', + request_serializer=milvus__pb2.GetComponentStatesRequest.SerializeToString, + response_deserializer=milvus__pb2.ComponentStates.FromString, + ) + self.GetStatisticsChannel = channel.unary_unary( + '/milvus.proto.data.DataNode/GetStatisticsChannel', + request_serializer=internal__pb2.GetStatisticsChannelRequest.SerializeToString, + response_deserializer=milvus__pb2.StringResponse.FromString, + ) + self.WatchDmChannels = channel.unary_unary( + '/milvus.proto.data.DataNode/WatchDmChannels', + request_serializer=data__coord__pb2.WatchDmChannelsRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.FlushSegments = channel.unary_unary( + '/milvus.proto.data.DataNode/FlushSegments', + request_serializer=data__coord__pb2.FlushSegmentsRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.ShowConfigurations = channel.unary_unary( + '/milvus.proto.data.DataNode/ShowConfigurations', + request_serializer=internal__pb2.ShowConfigurationsRequest.SerializeToString, + response_deserializer=internal__pb2.ShowConfigurationsResponse.FromString, + ) + self.GetMetrics = channel.unary_unary( + '/milvus.proto.data.DataNode/GetMetrics', + request_serializer=milvus__pb2.GetMetricsRequest.SerializeToString, + response_deserializer=milvus__pb2.GetMetricsResponse.FromString, + ) + self.Compaction = channel.unary_unary( + '/milvus.proto.data.DataNode/Compaction', + request_serializer=data__coord__pb2.CompactionPlan.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.GetCompactionState = channel.unary_unary( + '/milvus.proto.data.DataNode/GetCompactionState', + request_serializer=data__coord__pb2.CompactionStateRequest.SerializeToString, + response_deserializer=data__coord__pb2.CompactionStateResponse.FromString, + ) + self.SyncSegments = channel.unary_unary( + '/milvus.proto.data.DataNode/SyncSegments', + request_serializer=data__coord__pb2.SyncSegmentsRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.Import = channel.unary_unary( + '/milvus.proto.data.DataNode/Import', + request_serializer=data__coord__pb2.ImportTaskRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.ResendSegmentStats = channel.unary_unary( + '/milvus.proto.data.DataNode/ResendSegmentStats', + request_serializer=data__coord__pb2.ResendSegmentStatsRequest.SerializeToString, + response_deserializer=data__coord__pb2.ResendSegmentStatsResponse.FromString, + ) + self.AddImportSegment = channel.unary_unary( + '/milvus.proto.data.DataNode/AddImportSegment', + request_serializer=data__coord__pb2.AddImportSegmentRequest.SerializeToString, + response_deserializer=data__coord__pb2.AddImportSegmentResponse.FromString, + ) + self.FlushChannels = channel.unary_unary( + '/milvus.proto.data.DataNode/FlushChannels', + request_serializer=data__coord__pb2.FlushChannelsRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.NotifyChannelOperation = channel.unary_unary( + '/milvus.proto.data.DataNode/NotifyChannelOperation', + request_serializer=data__coord__pb2.ChannelOperationsRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.CheckChannelOperationProgress = channel.unary_unary( + '/milvus.proto.data.DataNode/CheckChannelOperationProgress', + request_serializer=data__coord__pb2.ChannelWatchInfo.SerializeToString, + response_deserializer=data__coord__pb2.ChannelOperationProgressResponse.FromString, + ) + self.PreImport = channel.unary_unary( + '/milvus.proto.data.DataNode/PreImport', + request_serializer=data__coord__pb2.PreImportRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.ImportV2 = channel.unary_unary( + '/milvus.proto.data.DataNode/ImportV2', + request_serializer=data__coord__pb2.ImportRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.QueryPreImport = channel.unary_unary( + '/milvus.proto.data.DataNode/QueryPreImport', + request_serializer=data__coord__pb2.QueryPreImportRequest.SerializeToString, + response_deserializer=data__coord__pb2.QueryPreImportResponse.FromString, + ) + self.QueryImport = channel.unary_unary( + '/milvus.proto.data.DataNode/QueryImport', + request_serializer=data__coord__pb2.QueryImportRequest.SerializeToString, + response_deserializer=data__coord__pb2.QueryImportResponse.FromString, + ) + self.DropImport = channel.unary_unary( + '/milvus.proto.data.DataNode/DropImport', + request_serializer=data__coord__pb2.DropImportRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + + +class DataNodeServicer(object): + """Missing associated documentation comment in .proto file.""" + + def GetComponentStates(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetStatisticsChannel(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def WatchDmChannels(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def FlushSegments(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ShowConfigurations(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetMetrics(self, request, context): + """https://wiki.lfaidata.foundation/display/MIL/MEP+8+--+Add+metrics+for+proxy + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def Compaction(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetCompactionState(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def SyncSegments(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def Import(self, request, context): + """https://wiki.lfaidata.foundation/display/MIL/MEP+24+--+Support+bulk+load + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ResendSegmentStats(self, request, context): + """Deprecated + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def AddImportSegment(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def FlushChannels(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def NotifyChannelOperation(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def CheckChannelOperationProgress(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def PreImport(self, request, context): + """import v2 + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ImportV2(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def QueryPreImport(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def QueryImport(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def DropImport(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + +def add_DataNodeServicer_to_server(servicer, server): + rpc_method_handlers = { + 'GetComponentStates': grpc.unary_unary_rpc_method_handler( + servicer.GetComponentStates, + request_deserializer=milvus__pb2.GetComponentStatesRequest.FromString, + response_serializer=milvus__pb2.ComponentStates.SerializeToString, + ), + 'GetStatisticsChannel': grpc.unary_unary_rpc_method_handler( + servicer.GetStatisticsChannel, + request_deserializer=internal__pb2.GetStatisticsChannelRequest.FromString, + response_serializer=milvus__pb2.StringResponse.SerializeToString, + ), + 'WatchDmChannels': grpc.unary_unary_rpc_method_handler( + servicer.WatchDmChannels, + request_deserializer=data__coord__pb2.WatchDmChannelsRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'FlushSegments': grpc.unary_unary_rpc_method_handler( + servicer.FlushSegments, + request_deserializer=data__coord__pb2.FlushSegmentsRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'ShowConfigurations': grpc.unary_unary_rpc_method_handler( + servicer.ShowConfigurations, + request_deserializer=internal__pb2.ShowConfigurationsRequest.FromString, + response_serializer=internal__pb2.ShowConfigurationsResponse.SerializeToString, + ), + 'GetMetrics': grpc.unary_unary_rpc_method_handler( + servicer.GetMetrics, + request_deserializer=milvus__pb2.GetMetricsRequest.FromString, + response_serializer=milvus__pb2.GetMetricsResponse.SerializeToString, + ), + 'Compaction': grpc.unary_unary_rpc_method_handler( + servicer.Compaction, + request_deserializer=data__coord__pb2.CompactionPlan.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'GetCompactionState': grpc.unary_unary_rpc_method_handler( + servicer.GetCompactionState, + request_deserializer=data__coord__pb2.CompactionStateRequest.FromString, + response_serializer=data__coord__pb2.CompactionStateResponse.SerializeToString, + ), + 'SyncSegments': grpc.unary_unary_rpc_method_handler( + servicer.SyncSegments, + request_deserializer=data__coord__pb2.SyncSegmentsRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'Import': grpc.unary_unary_rpc_method_handler( + servicer.Import, + request_deserializer=data__coord__pb2.ImportTaskRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'ResendSegmentStats': grpc.unary_unary_rpc_method_handler( + servicer.ResendSegmentStats, + request_deserializer=data__coord__pb2.ResendSegmentStatsRequest.FromString, + response_serializer=data__coord__pb2.ResendSegmentStatsResponse.SerializeToString, + ), + 'AddImportSegment': grpc.unary_unary_rpc_method_handler( + servicer.AddImportSegment, + request_deserializer=data__coord__pb2.AddImportSegmentRequest.FromString, + response_serializer=data__coord__pb2.AddImportSegmentResponse.SerializeToString, + ), + 'FlushChannels': grpc.unary_unary_rpc_method_handler( + servicer.FlushChannels, + request_deserializer=data__coord__pb2.FlushChannelsRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'NotifyChannelOperation': grpc.unary_unary_rpc_method_handler( + servicer.NotifyChannelOperation, + request_deserializer=data__coord__pb2.ChannelOperationsRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'CheckChannelOperationProgress': grpc.unary_unary_rpc_method_handler( + servicer.CheckChannelOperationProgress, + request_deserializer=data__coord__pb2.ChannelWatchInfo.FromString, + response_serializer=data__coord__pb2.ChannelOperationProgressResponse.SerializeToString, + ), + 'PreImport': grpc.unary_unary_rpc_method_handler( + servicer.PreImport, + request_deserializer=data__coord__pb2.PreImportRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'ImportV2': grpc.unary_unary_rpc_method_handler( + servicer.ImportV2, + request_deserializer=data__coord__pb2.ImportRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'QueryPreImport': grpc.unary_unary_rpc_method_handler( + servicer.QueryPreImport, + request_deserializer=data__coord__pb2.QueryPreImportRequest.FromString, + response_serializer=data__coord__pb2.QueryPreImportResponse.SerializeToString, + ), + 'QueryImport': grpc.unary_unary_rpc_method_handler( + servicer.QueryImport, + request_deserializer=data__coord__pb2.QueryImportRequest.FromString, + response_serializer=data__coord__pb2.QueryImportResponse.SerializeToString, + ), + 'DropImport': grpc.unary_unary_rpc_method_handler( + servicer.DropImport, + request_deserializer=data__coord__pb2.DropImportRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + } + generic_handler = grpc.method_handlers_generic_handler( + 'milvus.proto.data.DataNode', rpc_method_handlers) + server.add_generic_rpc_handlers((generic_handler,)) + + + # This class is part of an EXPERIMENTAL API. +class DataNode(object): + """Missing associated documentation comment in .proto file.""" + + @staticmethod + def GetComponentStates(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.data.DataNode/GetComponentStates', + milvus__pb2.GetComponentStatesRequest.SerializeToString, + milvus__pb2.ComponentStates.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetStatisticsChannel(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.data.DataNode/GetStatisticsChannel', + internal__pb2.GetStatisticsChannelRequest.SerializeToString, + milvus__pb2.StringResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def WatchDmChannels(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.data.DataNode/WatchDmChannels', + data__coord__pb2.WatchDmChannelsRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def FlushSegments(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.data.DataNode/FlushSegments', + data__coord__pb2.FlushSegmentsRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def ShowConfigurations(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.data.DataNode/ShowConfigurations', + internal__pb2.ShowConfigurationsRequest.SerializeToString, + internal__pb2.ShowConfigurationsResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetMetrics(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.data.DataNode/GetMetrics', + milvus__pb2.GetMetricsRequest.SerializeToString, + milvus__pb2.GetMetricsResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def Compaction(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.data.DataNode/Compaction', + data__coord__pb2.CompactionPlan.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetCompactionState(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.data.DataNode/GetCompactionState', + data__coord__pb2.CompactionStateRequest.SerializeToString, + data__coord__pb2.CompactionStateResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def SyncSegments(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.data.DataNode/SyncSegments', + data__coord__pb2.SyncSegmentsRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def Import(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.data.DataNode/Import', + data__coord__pb2.ImportTaskRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def ResendSegmentStats(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.data.DataNode/ResendSegmentStats', + data__coord__pb2.ResendSegmentStatsRequest.SerializeToString, + data__coord__pb2.ResendSegmentStatsResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def AddImportSegment(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.data.DataNode/AddImportSegment', + data__coord__pb2.AddImportSegmentRequest.SerializeToString, + data__coord__pb2.AddImportSegmentResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def FlushChannels(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.data.DataNode/FlushChannels', + data__coord__pb2.FlushChannelsRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def NotifyChannelOperation(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.data.DataNode/NotifyChannelOperation', + data__coord__pb2.ChannelOperationsRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def CheckChannelOperationProgress(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.data.DataNode/CheckChannelOperationProgress', + data__coord__pb2.ChannelWatchInfo.SerializeToString, + data__coord__pb2.ChannelOperationProgressResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def PreImport(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.data.DataNode/PreImport', + data__coord__pb2.PreImportRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def ImportV2(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.data.DataNode/ImportV2', + data__coord__pb2.ImportRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def QueryPreImport(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.data.DataNode/QueryPreImport', + data__coord__pb2.QueryPreImportRequest.SerializeToString, + data__coord__pb2.QueryPreImportResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def QueryImport(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.data.DataNode/QueryImport', + data__coord__pb2.QueryImportRequest.SerializeToString, + data__coord__pb2.QueryImportResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def DropImport(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.data.DataNode/DropImport', + data__coord__pb2.DropImportRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) diff --git a/milvus_connector/protocol/etcd_meta_pb2.py b/milvus_connector/protocol/etcd_meta_pb2.py new file mode 100644 index 0000000..c16d651 --- /dev/null +++ b/milvus_connector/protocol/etcd_meta_pb2.py @@ -0,0 +1,53 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: etcd_meta.proto +# Protobuf Python Version: 4.25.1 +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from . import common_pb2 as common__pb2 +from . import schema_pb2 as schema__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x0f\x65tcd_meta.proto\x12\x11milvus.proto.etcd\x1a\x0c\x63ommon.proto\x1a\x0cschema.proto\"\x8f\x01\n\tIndexInfo\x12\x12\n\nindex_name\x18\x01 \x01(\t\x12\x0f\n\x07indexID\x18\x02 \x01(\x03\x12\x37\n\x0cindex_params\x18\x03 \x03(\x0b\x32!.milvus.proto.common.KeyValuePair\x12\x0f\n\x07\x64\x65leted\x18\x04 \x01(\x08\x12\x13\n\x0b\x63reate_time\x18\x05 \x01(\x04\"2\n\x0e\x46ieldIndexInfo\x12\x0f\n\x07\x66iledID\x18\x01 \x01(\x03\x12\x0f\n\x07indexID\x18\x02 \x01(\x03\"\xbf\x04\n\x0e\x43ollectionInfo\x12\n\n\x02ID\x18\x01 \x01(\x03\x12\x35\n\x06schema\x18\x02 \x01(\x0b\x32%.milvus.proto.schema.CollectionSchema\x12\x13\n\x0b\x63reate_time\x18\x03 \x01(\x04\x12\x14\n\x0cpartitionIDs\x18\x04 \x03(\x03\x12\x16\n\x0epartitionNames\x18\x05 \x03(\t\x12\x38\n\rfield_indexes\x18\x06 \x03(\x0b\x32!.milvus.proto.etcd.FieldIndexInfo\x12\x1d\n\x15virtual_channel_names\x18\x07 \x03(\t\x12\x1e\n\x16physical_channel_names\x18\x08 \x03(\t\x12$\n\x1cpartition_created_timestamps\x18\t \x03(\x04\x12\x12\n\nshards_num\x18\n \x01(\x05\x12\x39\n\x0fstart_positions\x18\x0b \x03(\x0b\x32 .milvus.proto.common.KeyDataPair\x12@\n\x11\x63onsistency_level\x18\x0c \x01(\x0e\x32%.milvus.proto.common.ConsistencyLevel\x12\x31\n\x05state\x18\r \x01(\x0e\x32\".milvus.proto.etcd.CollectionState\x12\x35\n\nproperties\x18\x0e \x03(\x0b\x32!.milvus.proto.common.KeyValuePair\x12\r\n\x05\x64\x62_id\x18\x0f \x01(\x03\"\xa9\x01\n\rPartitionInfo\x12\x13\n\x0bpartitionID\x18\x01 \x01(\x03\x12\x15\n\rpartitionName\x18\x02 \x01(\t\x12#\n\x1bpartition_created_timestamp\x18\x03 \x01(\x04\x12\x15\n\rcollection_id\x18\x04 \x01(\x03\x12\x30\n\x05state\x18\x05 \x01(\x0e\x32!.milvus.proto.etcd.PartitionState\"\x89\x01\n\tAliasInfo\x12\x12\n\nalias_name\x18\x01 \x01(\t\x12\x15\n\rcollection_id\x18\x02 \x01(\x03\x12\x14\n\x0c\x63reated_time\x18\x03 \x01(\x04\x12,\n\x05state\x18\x04 \x01(\x0e\x32\x1d.milvus.proto.etcd.AliasState\x12\r\n\x05\x64\x62_id\x18\x05 \x01(\x03\"\x82\x01\n\x0c\x44\x61tabaseInfo\x12\x11\n\ttenant_id\x18\x01 \x01(\t\x12\x0c\n\x04name\x18\x02 \x01(\t\x12\n\n\x02id\x18\x03 \x01(\x03\x12/\n\x05state\x18\x04 \x01(\x0e\x32 .milvus.proto.etcd.DatabaseState\x12\x14\n\x0c\x63reated_time\x18\x05 \x01(\x04\"\xae\x01\n\x10SegmentIndexInfo\x12\x14\n\x0c\x63ollectionID\x18\x01 \x01(\x03\x12\x13\n\x0bpartitionID\x18\x02 \x01(\x03\x12\x11\n\tsegmentID\x18\x03 \x01(\x03\x12\x0f\n\x07\x66ieldID\x18\x04 \x01(\x03\x12\x0f\n\x07indexID\x18\x05 \x01(\x03\x12\x0f\n\x07\x62uildID\x18\x06 \x01(\x03\x12\x14\n\x0c\x65nable_index\x18\x07 \x01(\x08\x12\x13\n\x0b\x63reate_time\x18\x08 \x01(\x04\"\xaa\x01\n\x0e\x43ollectionMeta\x12\n\n\x02ID\x18\x01 \x01(\x03\x12\x35\n\x06schema\x18\x02 \x01(\x0b\x32%.milvus.proto.schema.CollectionSchema\x12\x13\n\x0b\x63reate_time\x18\x03 \x01(\x04\x12\x12\n\nsegmentIDs\x18\x04 \x03(\x03\x12\x16\n\x0epartition_tags\x18\x05 \x03(\t\x12\x14\n\x0cpartitionIDs\x18\x06 \x03(\x03\"y\n\x0e\x43redentialInfo\x12\x10\n\x08username\x18\x01 \x01(\t\x12\x1a\n\x12\x65ncrypted_password\x18\x02 \x01(\t\x12\x0e\n\x06tenant\x18\x03 \x01(\t\x12\x10\n\x08is_super\x18\x04 \x01(\x08\x12\x17\n\x0fsha256_password\x18\x05 \x01(\t*z\n\rDatabaseState\x12\x13\n\x0f\x44\x61tabaseUnknown\x10\x00\x12\x13\n\x0f\x44\x61tabaseCreated\x10\x01\x12\x14\n\x10\x44\x61tabaseCreating\x10\x02\x12\x14\n\x10\x44\x61tabaseDropping\x10\x03\x12\x13\n\x0f\x44\x61tabaseDropped\x10\x04*o\n\x0f\x43ollectionState\x12\x15\n\x11\x43ollectionCreated\x10\x00\x12\x16\n\x12\x43ollectionCreating\x10\x01\x12\x16\n\x12\x43ollectionDropping\x10\x02\x12\x15\n\x11\x43ollectionDropped\x10\x03*j\n\x0ePartitionState\x12\x14\n\x10PartitionCreated\x10\x00\x12\x15\n\x11PartitionCreating\x10\x01\x12\x15\n\x11PartitionDropping\x10\x02\x12\x14\n\x10PartitionDropped\x10\x03*V\n\nAliasState\x12\x10\n\x0c\x41liasCreated\x10\x00\x12\x11\n\rAliasCreating\x10\x01\x12\x11\n\rAliasDropping\x10\x02\x12\x10\n\x0c\x41liasDropped\x10\x03\x42\x33Z1github.com/milvus-io/milvus/internal/proto/etcdpbb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'etcd_meta_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + _globals['DESCRIPTOR']._options = None + _globals['DESCRIPTOR']._serialized_options = b'Z1github.com/milvus-io/milvus/internal/proto/etcdpb' + _globals['_DATABASESTATE']._serialized_start=1760 + _globals['_DATABASESTATE']._serialized_end=1882 + _globals['_COLLECTIONSTATE']._serialized_start=1884 + _globals['_COLLECTIONSTATE']._serialized_end=1995 + _globals['_PARTITIONSTATE']._serialized_start=1997 + _globals['_PARTITIONSTATE']._serialized_end=2103 + _globals['_ALIASSTATE']._serialized_start=2105 + _globals['_ALIASSTATE']._serialized_end=2191 + _globals['_INDEXINFO']._serialized_start=67 + _globals['_INDEXINFO']._serialized_end=210 + _globals['_FIELDINDEXINFO']._serialized_start=212 + _globals['_FIELDINDEXINFO']._serialized_end=262 + _globals['_COLLECTIONINFO']._serialized_start=265 + _globals['_COLLECTIONINFO']._serialized_end=840 + _globals['_PARTITIONINFO']._serialized_start=843 + _globals['_PARTITIONINFO']._serialized_end=1012 + _globals['_ALIASINFO']._serialized_start=1015 + _globals['_ALIASINFO']._serialized_end=1152 + _globals['_DATABASEINFO']._serialized_start=1155 + _globals['_DATABASEINFO']._serialized_end=1285 + _globals['_SEGMENTINDEXINFO']._serialized_start=1288 + _globals['_SEGMENTINDEXINFO']._serialized_end=1462 + _globals['_COLLECTIONMETA']._serialized_start=1465 + _globals['_COLLECTIONMETA']._serialized_end=1635 + _globals['_CREDENTIALINFO']._serialized_start=1637 + _globals['_CREDENTIALINFO']._serialized_end=1758 +# @@protoc_insertion_point(module_scope) diff --git a/milvus_connector/protocol/etcd_meta_pb2.pyi b/milvus_connector/protocol/etcd_meta_pb2.pyi new file mode 100644 index 0000000..7f6c6bd --- /dev/null +++ b/milvus_connector/protocol/etcd_meta_pb2.pyi @@ -0,0 +1,203 @@ +from . import common_pb2 as _common_pb2 +from . import schema_pb2 as _schema_pb2 +from google.protobuf.internal import containers as _containers +from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Iterable as _Iterable, Mapping as _Mapping, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class DatabaseState(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = () + DatabaseUnknown: _ClassVar[DatabaseState] + DatabaseCreated: _ClassVar[DatabaseState] + DatabaseCreating: _ClassVar[DatabaseState] + DatabaseDropping: _ClassVar[DatabaseState] + DatabaseDropped: _ClassVar[DatabaseState] + +class CollectionState(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = () + CollectionCreated: _ClassVar[CollectionState] + CollectionCreating: _ClassVar[CollectionState] + CollectionDropping: _ClassVar[CollectionState] + CollectionDropped: _ClassVar[CollectionState] + +class PartitionState(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = () + PartitionCreated: _ClassVar[PartitionState] + PartitionCreating: _ClassVar[PartitionState] + PartitionDropping: _ClassVar[PartitionState] + PartitionDropped: _ClassVar[PartitionState] + +class AliasState(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = () + AliasCreated: _ClassVar[AliasState] + AliasCreating: _ClassVar[AliasState] + AliasDropping: _ClassVar[AliasState] + AliasDropped: _ClassVar[AliasState] +DatabaseUnknown: DatabaseState +DatabaseCreated: DatabaseState +DatabaseCreating: DatabaseState +DatabaseDropping: DatabaseState +DatabaseDropped: DatabaseState +CollectionCreated: CollectionState +CollectionCreating: CollectionState +CollectionDropping: CollectionState +CollectionDropped: CollectionState +PartitionCreated: PartitionState +PartitionCreating: PartitionState +PartitionDropping: PartitionState +PartitionDropped: PartitionState +AliasCreated: AliasState +AliasCreating: AliasState +AliasDropping: AliasState +AliasDropped: AliasState + +class IndexInfo(_message.Message): + __slots__ = ("index_name", "indexID", "index_params", "deleted", "create_time") + INDEX_NAME_FIELD_NUMBER: _ClassVar[int] + INDEXID_FIELD_NUMBER: _ClassVar[int] + INDEX_PARAMS_FIELD_NUMBER: _ClassVar[int] + DELETED_FIELD_NUMBER: _ClassVar[int] + CREATE_TIME_FIELD_NUMBER: _ClassVar[int] + index_name: str + indexID: int + index_params: _containers.RepeatedCompositeFieldContainer[_common_pb2.KeyValuePair] + deleted: bool + create_time: int + def __init__(self, index_name: _Optional[str] = ..., indexID: _Optional[int] = ..., index_params: _Optional[_Iterable[_Union[_common_pb2.KeyValuePair, _Mapping]]] = ..., deleted: bool = ..., create_time: _Optional[int] = ...) -> None: ... + +class FieldIndexInfo(_message.Message): + __slots__ = ("filedID", "indexID") + FILEDID_FIELD_NUMBER: _ClassVar[int] + INDEXID_FIELD_NUMBER: _ClassVar[int] + filedID: int + indexID: int + def __init__(self, filedID: _Optional[int] = ..., indexID: _Optional[int] = ...) -> None: ... + +class CollectionInfo(_message.Message): + __slots__ = ("ID", "schema", "create_time", "partitionIDs", "partitionNames", "field_indexes", "virtual_channel_names", "physical_channel_names", "partition_created_timestamps", "shards_num", "start_positions", "consistency_level", "state", "properties", "db_id") + ID_FIELD_NUMBER: _ClassVar[int] + SCHEMA_FIELD_NUMBER: _ClassVar[int] + CREATE_TIME_FIELD_NUMBER: _ClassVar[int] + PARTITIONIDS_FIELD_NUMBER: _ClassVar[int] + PARTITIONNAMES_FIELD_NUMBER: _ClassVar[int] + FIELD_INDEXES_FIELD_NUMBER: _ClassVar[int] + VIRTUAL_CHANNEL_NAMES_FIELD_NUMBER: _ClassVar[int] + PHYSICAL_CHANNEL_NAMES_FIELD_NUMBER: _ClassVar[int] + PARTITION_CREATED_TIMESTAMPS_FIELD_NUMBER: _ClassVar[int] + SHARDS_NUM_FIELD_NUMBER: _ClassVar[int] + START_POSITIONS_FIELD_NUMBER: _ClassVar[int] + CONSISTENCY_LEVEL_FIELD_NUMBER: _ClassVar[int] + STATE_FIELD_NUMBER: _ClassVar[int] + PROPERTIES_FIELD_NUMBER: _ClassVar[int] + DB_ID_FIELD_NUMBER: _ClassVar[int] + ID: int + schema: _schema_pb2.CollectionSchema + create_time: int + partitionIDs: _containers.RepeatedScalarFieldContainer[int] + partitionNames: _containers.RepeatedScalarFieldContainer[str] + field_indexes: _containers.RepeatedCompositeFieldContainer[FieldIndexInfo] + virtual_channel_names: _containers.RepeatedScalarFieldContainer[str] + physical_channel_names: _containers.RepeatedScalarFieldContainer[str] + partition_created_timestamps: _containers.RepeatedScalarFieldContainer[int] + shards_num: int + start_positions: _containers.RepeatedCompositeFieldContainer[_common_pb2.KeyDataPair] + consistency_level: _common_pb2.ConsistencyLevel + state: CollectionState + properties: _containers.RepeatedCompositeFieldContainer[_common_pb2.KeyValuePair] + db_id: int + def __init__(self, ID: _Optional[int] = ..., schema: _Optional[_Union[_schema_pb2.CollectionSchema, _Mapping]] = ..., create_time: _Optional[int] = ..., partitionIDs: _Optional[_Iterable[int]] = ..., partitionNames: _Optional[_Iterable[str]] = ..., field_indexes: _Optional[_Iterable[_Union[FieldIndexInfo, _Mapping]]] = ..., virtual_channel_names: _Optional[_Iterable[str]] = ..., physical_channel_names: _Optional[_Iterable[str]] = ..., partition_created_timestamps: _Optional[_Iterable[int]] = ..., shards_num: _Optional[int] = ..., start_positions: _Optional[_Iterable[_Union[_common_pb2.KeyDataPair, _Mapping]]] = ..., consistency_level: _Optional[_Union[_common_pb2.ConsistencyLevel, str]] = ..., state: _Optional[_Union[CollectionState, str]] = ..., properties: _Optional[_Iterable[_Union[_common_pb2.KeyValuePair, _Mapping]]] = ..., db_id: _Optional[int] = ...) -> None: ... + +class PartitionInfo(_message.Message): + __slots__ = ("partitionID", "partitionName", "partition_created_timestamp", "collection_id", "state") + PARTITIONID_FIELD_NUMBER: _ClassVar[int] + PARTITIONNAME_FIELD_NUMBER: _ClassVar[int] + PARTITION_CREATED_TIMESTAMP_FIELD_NUMBER: _ClassVar[int] + COLLECTION_ID_FIELD_NUMBER: _ClassVar[int] + STATE_FIELD_NUMBER: _ClassVar[int] + partitionID: int + partitionName: str + partition_created_timestamp: int + collection_id: int + state: PartitionState + def __init__(self, partitionID: _Optional[int] = ..., partitionName: _Optional[str] = ..., partition_created_timestamp: _Optional[int] = ..., collection_id: _Optional[int] = ..., state: _Optional[_Union[PartitionState, str]] = ...) -> None: ... + +class AliasInfo(_message.Message): + __slots__ = ("alias_name", "collection_id", "created_time", "state", "db_id") + ALIAS_NAME_FIELD_NUMBER: _ClassVar[int] + COLLECTION_ID_FIELD_NUMBER: _ClassVar[int] + CREATED_TIME_FIELD_NUMBER: _ClassVar[int] + STATE_FIELD_NUMBER: _ClassVar[int] + DB_ID_FIELD_NUMBER: _ClassVar[int] + alias_name: str + collection_id: int + created_time: int + state: AliasState + db_id: int + def __init__(self, alias_name: _Optional[str] = ..., collection_id: _Optional[int] = ..., created_time: _Optional[int] = ..., state: _Optional[_Union[AliasState, str]] = ..., db_id: _Optional[int] = ...) -> None: ... + +class DatabaseInfo(_message.Message): + __slots__ = ("tenant_id", "name", "id", "state", "created_time") + TENANT_ID_FIELD_NUMBER: _ClassVar[int] + NAME_FIELD_NUMBER: _ClassVar[int] + ID_FIELD_NUMBER: _ClassVar[int] + STATE_FIELD_NUMBER: _ClassVar[int] + CREATED_TIME_FIELD_NUMBER: _ClassVar[int] + tenant_id: str + name: str + id: int + state: DatabaseState + created_time: int + def __init__(self, tenant_id: _Optional[str] = ..., name: _Optional[str] = ..., id: _Optional[int] = ..., state: _Optional[_Union[DatabaseState, str]] = ..., created_time: _Optional[int] = ...) -> None: ... + +class SegmentIndexInfo(_message.Message): + __slots__ = ("collectionID", "partitionID", "segmentID", "fieldID", "indexID", "buildID", "enable_index", "create_time") + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + PARTITIONID_FIELD_NUMBER: _ClassVar[int] + SEGMENTID_FIELD_NUMBER: _ClassVar[int] + FIELDID_FIELD_NUMBER: _ClassVar[int] + INDEXID_FIELD_NUMBER: _ClassVar[int] + BUILDID_FIELD_NUMBER: _ClassVar[int] + ENABLE_INDEX_FIELD_NUMBER: _ClassVar[int] + CREATE_TIME_FIELD_NUMBER: _ClassVar[int] + collectionID: int + partitionID: int + segmentID: int + fieldID: int + indexID: int + buildID: int + enable_index: bool + create_time: int + def __init__(self, collectionID: _Optional[int] = ..., partitionID: _Optional[int] = ..., segmentID: _Optional[int] = ..., fieldID: _Optional[int] = ..., indexID: _Optional[int] = ..., buildID: _Optional[int] = ..., enable_index: bool = ..., create_time: _Optional[int] = ...) -> None: ... + +class CollectionMeta(_message.Message): + __slots__ = ("ID", "schema", "create_time", "segmentIDs", "partition_tags", "partitionIDs") + ID_FIELD_NUMBER: _ClassVar[int] + SCHEMA_FIELD_NUMBER: _ClassVar[int] + CREATE_TIME_FIELD_NUMBER: _ClassVar[int] + SEGMENTIDS_FIELD_NUMBER: _ClassVar[int] + PARTITION_TAGS_FIELD_NUMBER: _ClassVar[int] + PARTITIONIDS_FIELD_NUMBER: _ClassVar[int] + ID: int + schema: _schema_pb2.CollectionSchema + create_time: int + segmentIDs: _containers.RepeatedScalarFieldContainer[int] + partition_tags: _containers.RepeatedScalarFieldContainer[str] + partitionIDs: _containers.RepeatedScalarFieldContainer[int] + def __init__(self, ID: _Optional[int] = ..., schema: _Optional[_Union[_schema_pb2.CollectionSchema, _Mapping]] = ..., create_time: _Optional[int] = ..., segmentIDs: _Optional[_Iterable[int]] = ..., partition_tags: _Optional[_Iterable[str]] = ..., partitionIDs: _Optional[_Iterable[int]] = ...) -> None: ... + +class CredentialInfo(_message.Message): + __slots__ = ("username", "encrypted_password", "tenant", "is_super", "sha256_password") + USERNAME_FIELD_NUMBER: _ClassVar[int] + ENCRYPTED_PASSWORD_FIELD_NUMBER: _ClassVar[int] + TENANT_FIELD_NUMBER: _ClassVar[int] + IS_SUPER_FIELD_NUMBER: _ClassVar[int] + SHA256_PASSWORD_FIELD_NUMBER: _ClassVar[int] + username: str + encrypted_password: str + tenant: str + is_super: bool + sha256_password: str + def __init__(self, username: _Optional[str] = ..., encrypted_password: _Optional[str] = ..., tenant: _Optional[str] = ..., is_super: bool = ..., sha256_password: _Optional[str] = ...) -> None: ... diff --git a/milvus_connector/protocol/etcd_meta_pb2_grpc.py b/milvus_connector/protocol/etcd_meta_pb2_grpc.py new file mode 100644 index 0000000..2daafff --- /dev/null +++ b/milvus_connector/protocol/etcd_meta_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/milvus_connector/protocol/feder_pb2.py b/milvus_connector/protocol/feder_pb2.py new file mode 100644 index 0000000..2d24371 --- /dev/null +++ b/milvus_connector/protocol/feder_pb2.py @@ -0,0 +1,42 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: feder.proto +# Protobuf Python Version: 4.25.1 +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from . import common_pb2 as common__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x0b\x66\x65\x64\x65r.proto\x12\x12milvus.proto.feder\x1a\x0c\x63ommon.proto\"9\n\x10SegmentIndexData\x12\x11\n\tsegmentID\x18\x01 \x01(\x03\x12\x12\n\nindex_data\x18\x02 \x01(\t\"A\n\x18\x46\x65\x64\x65rSegmentSearchResult\x12\x11\n\tsegmentID\x18\x01 \x01(\x03\x12\x12\n\nvisit_info\x18\x02 \x01(\t\"t\n\x19ListIndexedSegmentRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x17\n\x0f\x63ollection_name\x18\x02 \x01(\t\x12\x12\n\nindex_name\x18\x03 \x01(\t\"]\n\x1aListIndexedSegmentResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\x12\n\nsegmentIDs\x18\x02 \x03(\x03\"\x8f\x01\n\x1f\x44\x65scribeSegmentIndexDataRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x17\n\x0f\x63ollection_name\x18\x02 \x01(\t\x12\x12\n\nindex_name\x18\x03 \x01(\t\x12\x13\n\x0bsegmentsIDs\x18\x04 \x03(\x03\"\xb9\x02\n DescribeSegmentIndexDataResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12W\n\nindex_data\x18\x02 \x03(\x0b\x32\x43.milvus.proto.feder.DescribeSegmentIndexDataResponse.IndexDataEntry\x12\x37\n\x0cindex_params\x18\x03 \x03(\x0b\x32!.milvus.proto.common.KeyValuePair\x1aV\n\x0eIndexDataEntry\x12\x0b\n\x03key\x18\x01 \x01(\x03\x12\x33\n\x05value\x18\x02 \x01(\x0b\x32$.milvus.proto.feder.SegmentIndexData:\x02\x38\x01\x42\x35Z3github.com/milvus-io/milvus-proto/go-api/v2/federpbb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'feder_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + _globals['DESCRIPTOR']._options = None + _globals['DESCRIPTOR']._serialized_options = b'Z3github.com/milvus-io/milvus-proto/go-api/v2/federpb' + _globals['_DESCRIBESEGMENTINDEXDATARESPONSE_INDEXDATAENTRY']._options = None + _globals['_DESCRIBESEGMENTINDEXDATARESPONSE_INDEXDATAENTRY']._serialized_options = b'8\001' + _globals['_SEGMENTINDEXDATA']._serialized_start=49 + _globals['_SEGMENTINDEXDATA']._serialized_end=106 + _globals['_FEDERSEGMENTSEARCHRESULT']._serialized_start=108 + _globals['_FEDERSEGMENTSEARCHRESULT']._serialized_end=173 + _globals['_LISTINDEXEDSEGMENTREQUEST']._serialized_start=175 + _globals['_LISTINDEXEDSEGMENTREQUEST']._serialized_end=291 + _globals['_LISTINDEXEDSEGMENTRESPONSE']._serialized_start=293 + _globals['_LISTINDEXEDSEGMENTRESPONSE']._serialized_end=386 + _globals['_DESCRIBESEGMENTINDEXDATAREQUEST']._serialized_start=389 + _globals['_DESCRIBESEGMENTINDEXDATAREQUEST']._serialized_end=532 + _globals['_DESCRIBESEGMENTINDEXDATARESPONSE']._serialized_start=535 + _globals['_DESCRIBESEGMENTINDEXDATARESPONSE']._serialized_end=848 + _globals['_DESCRIBESEGMENTINDEXDATARESPONSE_INDEXDATAENTRY']._serialized_start=762 + _globals['_DESCRIBESEGMENTINDEXDATARESPONSE_INDEXDATAENTRY']._serialized_end=848 +# @@protoc_insertion_point(module_scope) diff --git a/milvus_connector/protocol/feder_pb2.pyi b/milvus_connector/protocol/feder_pb2.pyi new file mode 100644 index 0000000..517e5fe --- /dev/null +++ b/milvus_connector/protocol/feder_pb2.pyi @@ -0,0 +1,70 @@ +from . import common_pb2 as _common_pb2 +from google.protobuf.internal import containers as _containers +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Iterable as _Iterable, Mapping as _Mapping, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class SegmentIndexData(_message.Message): + __slots__ = ("segmentID", "index_data") + SEGMENTID_FIELD_NUMBER: _ClassVar[int] + INDEX_DATA_FIELD_NUMBER: _ClassVar[int] + segmentID: int + index_data: str + def __init__(self, segmentID: _Optional[int] = ..., index_data: _Optional[str] = ...) -> None: ... + +class FederSegmentSearchResult(_message.Message): + __slots__ = ("segmentID", "visit_info") + SEGMENTID_FIELD_NUMBER: _ClassVar[int] + VISIT_INFO_FIELD_NUMBER: _ClassVar[int] + segmentID: int + visit_info: str + def __init__(self, segmentID: _Optional[int] = ..., visit_info: _Optional[str] = ...) -> None: ... + +class ListIndexedSegmentRequest(_message.Message): + __slots__ = ("base", "collection_name", "index_name") + BASE_FIELD_NUMBER: _ClassVar[int] + COLLECTION_NAME_FIELD_NUMBER: _ClassVar[int] + INDEX_NAME_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + collection_name: str + index_name: str + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., collection_name: _Optional[str] = ..., index_name: _Optional[str] = ...) -> None: ... + +class ListIndexedSegmentResponse(_message.Message): + __slots__ = ("status", "segmentIDs") + STATUS_FIELD_NUMBER: _ClassVar[int] + SEGMENTIDS_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + segmentIDs: _containers.RepeatedScalarFieldContainer[int] + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., segmentIDs: _Optional[_Iterable[int]] = ...) -> None: ... + +class DescribeSegmentIndexDataRequest(_message.Message): + __slots__ = ("base", "collection_name", "index_name", "segmentsIDs") + BASE_FIELD_NUMBER: _ClassVar[int] + COLLECTION_NAME_FIELD_NUMBER: _ClassVar[int] + INDEX_NAME_FIELD_NUMBER: _ClassVar[int] + SEGMENTSIDS_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + collection_name: str + index_name: str + segmentsIDs: _containers.RepeatedScalarFieldContainer[int] + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., collection_name: _Optional[str] = ..., index_name: _Optional[str] = ..., segmentsIDs: _Optional[_Iterable[int]] = ...) -> None: ... + +class DescribeSegmentIndexDataResponse(_message.Message): + __slots__ = ("status", "index_data", "index_params") + class IndexDataEntry(_message.Message): + __slots__ = ("key", "value") + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: int + value: SegmentIndexData + def __init__(self, key: _Optional[int] = ..., value: _Optional[_Union[SegmentIndexData, _Mapping]] = ...) -> None: ... + STATUS_FIELD_NUMBER: _ClassVar[int] + INDEX_DATA_FIELD_NUMBER: _ClassVar[int] + INDEX_PARAMS_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + index_data: _containers.MessageMap[int, SegmentIndexData] + index_params: _containers.RepeatedCompositeFieldContainer[_common_pb2.KeyValuePair] + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., index_data: _Optional[_Mapping[int, SegmentIndexData]] = ..., index_params: _Optional[_Iterable[_Union[_common_pb2.KeyValuePair, _Mapping]]] = ...) -> None: ... diff --git a/milvus_connector/protocol/feder_pb2_grpc.py b/milvus_connector/protocol/feder_pb2_grpc.py new file mode 100644 index 0000000..2daafff --- /dev/null +++ b/milvus_connector/protocol/feder_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/milvus_connector/protocol/index_cgo_msg_pb2.py b/milvus_connector/protocol/index_cgo_msg_pb2.py new file mode 100644 index 0000000..c5883ad --- /dev/null +++ b/milvus_connector/protocol/index_cgo_msg_pb2.py @@ -0,0 +1,42 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: index_cgo_msg.proto +# Protobuf Python Version: 4.25.1 +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from . import common_pb2 as common__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x13index_cgo_msg.proto\x12\x15milvus.proto.indexcgo\x1a\x0c\x63ommon.proto\"?\n\nTypeParams\x12\x31\n\x06params\x18\x01 \x03(\x0b\x32!.milvus.proto.common.KeyValuePair\"@\n\x0bIndexParams\x12\x31\n\x06params\x18\x01 \x03(\x0b\x32!.milvus.proto.common.KeyValuePair\">\n\tMapParams\x12\x31\n\x06params\x18\x01 \x03(\x0b\x32!.milvus.proto.common.KeyValuePair\"|\n\x0bMapParamsV2\x12>\n\x06params\x18\x01 \x03(\x0b\x32..milvus.proto.indexcgo.MapParamsV2.ParamsEntry\x1a-\n\x0bParamsEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01\"$\n\x06\x42inary\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\x0c\"9\n\tBinarySet\x12,\n\x05\x64\x61tas\x18\x01 \x03(\x0b\x32\x1d.milvus.proto.indexcgo.BinaryB7Z5github.com/milvus-io/milvus/internal/proto/indexcgopbb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'index_cgo_msg_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + _globals['DESCRIPTOR']._options = None + _globals['DESCRIPTOR']._serialized_options = b'Z5github.com/milvus-io/milvus/internal/proto/indexcgopb' + _globals['_MAPPARAMSV2_PARAMSENTRY']._options = None + _globals['_MAPPARAMSV2_PARAMSENTRY']._serialized_options = b'8\001' + _globals['_TYPEPARAMS']._serialized_start=60 + _globals['_TYPEPARAMS']._serialized_end=123 + _globals['_INDEXPARAMS']._serialized_start=125 + _globals['_INDEXPARAMS']._serialized_end=189 + _globals['_MAPPARAMS']._serialized_start=191 + _globals['_MAPPARAMS']._serialized_end=253 + _globals['_MAPPARAMSV2']._serialized_start=255 + _globals['_MAPPARAMSV2']._serialized_end=379 + _globals['_MAPPARAMSV2_PARAMSENTRY']._serialized_start=334 + _globals['_MAPPARAMSV2_PARAMSENTRY']._serialized_end=379 + _globals['_BINARY']._serialized_start=381 + _globals['_BINARY']._serialized_end=417 + _globals['_BINARYSET']._serialized_start=419 + _globals['_BINARYSET']._serialized_end=476 +# @@protoc_insertion_point(module_scope) diff --git a/milvus_connector/protocol/index_cgo_msg_pb2.pyi b/milvus_connector/protocol/index_cgo_msg_pb2.pyi new file mode 100644 index 0000000..77b4e71 --- /dev/null +++ b/milvus_connector/protocol/index_cgo_msg_pb2.pyi @@ -0,0 +1,52 @@ +from . import common_pb2 as _common_pb2 +from google.protobuf.internal import containers as _containers +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Iterable as _Iterable, Mapping as _Mapping, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class TypeParams(_message.Message): + __slots__ = ("params",) + PARAMS_FIELD_NUMBER: _ClassVar[int] + params: _containers.RepeatedCompositeFieldContainer[_common_pb2.KeyValuePair] + def __init__(self, params: _Optional[_Iterable[_Union[_common_pb2.KeyValuePair, _Mapping]]] = ...) -> None: ... + +class IndexParams(_message.Message): + __slots__ = ("params",) + PARAMS_FIELD_NUMBER: _ClassVar[int] + params: _containers.RepeatedCompositeFieldContainer[_common_pb2.KeyValuePair] + def __init__(self, params: _Optional[_Iterable[_Union[_common_pb2.KeyValuePair, _Mapping]]] = ...) -> None: ... + +class MapParams(_message.Message): + __slots__ = ("params",) + PARAMS_FIELD_NUMBER: _ClassVar[int] + params: _containers.RepeatedCompositeFieldContainer[_common_pb2.KeyValuePair] + def __init__(self, params: _Optional[_Iterable[_Union[_common_pb2.KeyValuePair, _Mapping]]] = ...) -> None: ... + +class MapParamsV2(_message.Message): + __slots__ = ("params",) + class ParamsEntry(_message.Message): + __slots__ = ("key", "value") + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: str + value: str + def __init__(self, key: _Optional[str] = ..., value: _Optional[str] = ...) -> None: ... + PARAMS_FIELD_NUMBER: _ClassVar[int] + params: _containers.ScalarMap[str, str] + def __init__(self, params: _Optional[_Mapping[str, str]] = ...) -> None: ... + +class Binary(_message.Message): + __slots__ = ("key", "value") + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: str + value: bytes + def __init__(self, key: _Optional[str] = ..., value: _Optional[bytes] = ...) -> None: ... + +class BinarySet(_message.Message): + __slots__ = ("datas",) + DATAS_FIELD_NUMBER: _ClassVar[int] + datas: _containers.RepeatedCompositeFieldContainer[Binary] + def __init__(self, datas: _Optional[_Iterable[_Union[Binary, _Mapping]]] = ...) -> None: ... diff --git a/milvus_connector/protocol/index_cgo_msg_pb2_grpc.py b/milvus_connector/protocol/index_cgo_msg_pb2_grpc.py new file mode 100644 index 0000000..2daafff --- /dev/null +++ b/milvus_connector/protocol/index_cgo_msg_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/milvus_connector/protocol/index_coord_pb2.py b/milvus_connector/protocol/index_coord_pb2.py new file mode 100644 index 0000000..0ca2ac4 --- /dev/null +++ b/milvus_connector/protocol/index_coord_pb2.py @@ -0,0 +1,107 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: index_coord.proto +# Protobuf Python Version: 4.25.1 +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from . import common_pb2 as common__pb2 +from . import internal_pb2 as internal__pb2 +from . import milvus_pb2 as milvus__pb2 +from . import schema_pb2 as schema__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x11index_coord.proto\x12\x12milvus.proto.index\x1a\x0c\x63ommon.proto\x1a\x0einternal.proto\x1a\x0cmilvus.proto\x1a\x0cschema.proto\"\xb4\x03\n\tIndexInfo\x12\x14\n\x0c\x63ollectionID\x18\x01 \x01(\x03\x12\x0f\n\x07\x66ieldID\x18\x02 \x01(\x03\x12\x12\n\nindex_name\x18\x03 \x01(\t\x12\x0f\n\x07indexID\x18\x04 \x01(\x03\x12\x36\n\x0btype_params\x18\x05 \x03(\x0b\x32!.milvus.proto.common.KeyValuePair\x12\x37\n\x0cindex_params\x18\x06 \x03(\x0b\x32!.milvus.proto.common.KeyValuePair\x12\x14\n\x0cindexed_rows\x18\x07 \x01(\x03\x12\x12\n\ntotal_rows\x18\x08 \x01(\x03\x12.\n\x05state\x18\t \x01(\x0e\x32\x1f.milvus.proto.common.IndexState\x12\x1f\n\x17index_state_fail_reason\x18\n \x01(\t\x12\x15\n\ris_auto_index\x18\x0b \x01(\x08\x12<\n\x11user_index_params\x18\x0c \x03(\x0b\x32!.milvus.proto.common.KeyValuePair\x12\x1a\n\x12pending_index_rows\x18\r \x01(\x03\"e\n\nFieldIndex\x12\x31\n\nindex_info\x18\x01 \x01(\x0b\x32\x1d.milvus.proto.index.IndexInfo\x12\x0f\n\x07\x64\x65leted\x18\x02 \x01(\x08\x12\x13\n\x0b\x63reate_time\x18\x03 \x01(\x04\"\x96\x03\n\x0cSegmentIndex\x12\x14\n\x0c\x63ollectionID\x18\x01 \x01(\x03\x12\x13\n\x0bpartitionID\x18\x02 \x01(\x03\x12\x11\n\tsegmentID\x18\x03 \x01(\x03\x12\x10\n\x08num_rows\x18\x04 \x01(\x03\x12\x0f\n\x07indexID\x18\x05 \x01(\x03\x12\x0f\n\x07\x62uildID\x18\x06 \x01(\x03\x12\x0e\n\x06nodeID\x18\x07 \x01(\x03\x12\x15\n\rindex_version\x18\x08 \x01(\x03\x12.\n\x05state\x18\t \x01(\x0e\x32\x1f.milvus.proto.common.IndexState\x12\x13\n\x0b\x66\x61il_reason\x18\n \x01(\t\x12\x17\n\x0findex_file_keys\x18\x0b \x03(\t\x12\x0f\n\x07\x64\x65leted\x18\x0c \x01(\x08\x12\x13\n\x0b\x63reate_time\x18\r \x01(\x04\x12\x16\n\x0eserialize_size\x18\x0e \x01(\x04\x12\x15\n\rwrite_handoff\x18\x0f \x01(\x08\x12\x1d\n\x15\x63urrent_index_version\x18\x10 \x01(\x05\x12\x1b\n\x13index_store_version\x18\x11 \x01(\x03\"\x80\x01\n\x13RegisterNodeRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12-\n\x07\x61\x64\x64ress\x18\x02 \x01(\x0b\x32\x1c.milvus.proto.common.Address\x12\x0e\n\x06nodeID\x18\x03 \x01(\x03\"{\n\x14RegisterNodeResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\x36\n\x0binit_params\x18\x02 \x01(\x0b\x32!.milvus.proto.internal.InitParams\"@\n\x14GetIndexStateRequest\x12\x14\n\x0c\x63ollectionID\x18\x01 \x01(\x03\x12\x12\n\nindex_name\x18\x02 \x01(\t\"\x89\x01\n\x15GetIndexStateResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12.\n\x05state\x18\x02 \x01(\x0e\x32\x1f.milvus.proto.common.IndexState\x12\x13\n\x0b\x66\x61il_reason\x18\x03 \x01(\t\"[\n\x1bGetSegmentIndexStateRequest\x12\x14\n\x0c\x63ollectionID\x18\x01 \x01(\x03\x12\x12\n\nindex_name\x18\x02 \x01(\t\x12\x12\n\nsegmentIDs\x18\x03 \x03(\x03\"\x7f\n\x11SegmentIndexState\x12\x11\n\tsegmentID\x18\x01 \x01(\x03\x12.\n\x05state\x18\x02 \x01(\x0e\x32\x1f.milvus.proto.common.IndexState\x12\x13\n\x0b\x66\x61il_reason\x18\x03 \x01(\t\x12\x12\n\nindex_name\x18\x04 \x01(\t\"\x82\x01\n\x1cGetSegmentIndexStateResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\x35\n\x06states\x18\x02 \x03(\x0b\x32%.milvus.proto.index.SegmentIndexState\"\xa8\x02\n\x12\x43reateIndexRequest\x12\x14\n\x0c\x63ollectionID\x18\x01 \x01(\x03\x12\x0f\n\x07\x66ieldID\x18\x02 \x01(\x03\x12\x12\n\nindex_name\x18\x03 \x01(\t\x12\x36\n\x0btype_params\x18\x04 \x03(\x0b\x32!.milvus.proto.common.KeyValuePair\x12\x37\n\x0cindex_params\x18\x05 \x03(\x0b\x32!.milvus.proto.common.KeyValuePair\x12\x11\n\ttimestamp\x18\x06 \x01(\x04\x12\x15\n\ris_auto_index\x18\x07 \x01(\x08\x12<\n\x11user_index_params\x18\x08 \x03(\x0b\x32!.milvus.proto.common.KeyValuePair\"p\n\x11\x41lterIndexRequest\x12\x14\n\x0c\x63ollectionID\x18\x01 \x01(\x03\x12\x12\n\nindex_name\x18\x02 \x01(\t\x12\x31\n\x06params\x18\x03 \x03(\x0b\x32!.milvus.proto.common.KeyValuePair\"S\n\x13GetIndexInfoRequest\x12\x14\n\x0c\x63ollectionID\x18\x01 \x01(\x03\x12\x12\n\nsegmentIDs\x18\x02 \x03(\x03\x12\x12\n\nindex_name\x18\x03 \x01(\t\"\xa1\x02\n\x11IndexFilePathInfo\x12\x11\n\tsegmentID\x18\x01 \x01(\x03\x12\x0f\n\x07\x66ieldID\x18\x02 \x01(\x03\x12\x0f\n\x07indexID\x18\x03 \x01(\x03\x12\x0f\n\x07\x62uildID\x18\x04 \x01(\x03\x12\x12\n\nindex_name\x18\x05 \x01(\t\x12\x37\n\x0cindex_params\x18\x06 \x03(\x0b\x32!.milvus.proto.common.KeyValuePair\x12\x18\n\x10index_file_paths\x18\x07 \x03(\t\x12\x17\n\x0fserialized_size\x18\x08 \x01(\x04\x12\x15\n\rindex_version\x18\t \x01(\x03\x12\x10\n\x08num_rows\x18\n \x01(\x03\x12\x1d\n\x15\x63urrent_index_version\x18\x0b \x01(\x05\"\x88\x01\n\x0bSegmentInfo\x12\x14\n\x0c\x63ollectionID\x18\x01 \x01(\x03\x12\x11\n\tsegmentID\x18\x02 \x01(\x03\x12\x14\n\x0c\x65nable_index\x18\x03 \x01(\x08\x12:\n\x0bindex_infos\x18\x04 \x03(\x0b\x32%.milvus.proto.index.IndexFilePathInfo\"\xe9\x01\n\x14GetIndexInfoResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12O\n\x0csegment_info\x18\x02 \x03(\x0b\x32\x39.milvus.proto.index.GetIndexInfoResponse.SegmentInfoEntry\x1aS\n\x10SegmentInfoEntry\x12\x0b\n\x03key\x18\x01 \x01(\x03\x12.\n\x05value\x18\x02 \x01(\x0b\x32\x1f.milvus.proto.index.SegmentInfo:\x02\x38\x01\"d\n\x10\x44ropIndexRequest\x12\x14\n\x0c\x63ollectionID\x18\x01 \x01(\x03\x12\x14\n\x0cpartitionIDs\x18\x02 \x03(\x03\x12\x12\n\nindex_name\x18\x03 \x01(\t\x12\x10\n\x08\x64rop_all\x18\x04 \x01(\x08\"S\n\x14\x44\x65scribeIndexRequest\x12\x14\n\x0c\x63ollectionID\x18\x01 \x01(\x03\x12\x12\n\nindex_name\x18\x02 \x01(\t\x12\x11\n\ttimestamp\x18\x03 \x01(\x04\"x\n\x15\x44\x65scribeIndexResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\x32\n\x0bindex_infos\x18\x02 \x03(\x0b\x32\x1d.milvus.proto.index.IndexInfo\"H\n\x1cGetIndexBuildProgressRequest\x12\x14\n\x0c\x63ollectionID\x18\x01 \x01(\x03\x12\x12\n\nindex_name\x18\x02 \x01(\t\"\x92\x01\n\x1dGetIndexBuildProgressResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\x14\n\x0cindexed_rows\x18\x02 \x01(\x03\x12\x12\n\ntotal_rows\x18\x03 \x01(\x03\x12\x1a\n\x12pending_index_rows\x18\x04 \x01(\x03\"\xa2\x02\n\rStorageConfig\x12\x0f\n\x07\x61\x64\x64ress\x18\x01 \x01(\t\x12\x14\n\x0c\x61\x63\x63\x65ss_keyID\x18\x02 \x01(\t\x12\x19\n\x11secret_access_key\x18\x03 \x01(\t\x12\x0e\n\x06useSSL\x18\x04 \x01(\x08\x12\x13\n\x0b\x62ucket_name\x18\x05 \x01(\t\x12\x11\n\troot_path\x18\x06 \x01(\t\x12\x0e\n\x06useIAM\x18\x07 \x01(\x08\x12\x13\n\x0bIAMEndpoint\x18\x08 \x01(\t\x12\x14\n\x0cstorage_type\x18\t \x01(\t\x12\x18\n\x10use_virtual_host\x18\n \x01(\x08\x12\x0e\n\x06region\x18\x0b \x01(\t\x12\x16\n\x0e\x63loud_provider\x18\x0c \x01(\t\x12\x1a\n\x12request_timeout_ms\x18\r \x01(\x03\"r\n\x11OptionalFieldInfo\x12\x0f\n\x07\x66ieldID\x18\x01 \x01(\x03\x12\x12\n\nfield_name\x18\x02 \x01(\t\x12\x12\n\nfield_type\x18\x03 \x01(\x05\x12\x12\n\ndata_paths\x18\x04 \x03(\t\x12\x10\n\x08\x64\x61ta_ids\x18\x05 \x03(\x03\"\xbf\x05\n\x10\x43reateJobRequest\x12\x11\n\tclusterID\x18\x01 \x01(\t\x12\x19\n\x11index_file_prefix\x18\x02 \x01(\t\x12\x0f\n\x07\x62uildID\x18\x03 \x01(\x03\x12\x12\n\ndata_paths\x18\x04 \x03(\t\x12\x15\n\rindex_version\x18\x05 \x01(\x03\x12\x0f\n\x07indexID\x18\x06 \x01(\x03\x12\x12\n\nindex_name\x18\x07 \x01(\t\x12\x39\n\x0estorage_config\x18\x08 \x01(\x0b\x32!.milvus.proto.index.StorageConfig\x12\x37\n\x0cindex_params\x18\t \x03(\x0b\x32!.milvus.proto.common.KeyValuePair\x12\x36\n\x0btype_params\x18\n \x03(\x0b\x32!.milvus.proto.common.KeyValuePair\x12\x10\n\x08num_rows\x18\x0b \x01(\x03\x12\x1d\n\x15\x63urrent_index_version\x18\x0c \x01(\x05\x12\x14\n\x0c\x63ollectionID\x18\r \x01(\x03\x12\x13\n\x0bpartitionID\x18\x0e \x01(\x03\x12\x11\n\tsegmentID\x18\x0f \x01(\x03\x12\x0f\n\x07\x66ieldID\x18\x10 \x01(\x03\x12\x12\n\nfield_name\x18\x11 \x01(\t\x12\x31\n\nfield_type\x18\x12 \x01(\x0e\x32\x1d.milvus.proto.schema.DataType\x12\x12\n\nstore_path\x18\x13 \x01(\t\x12\x15\n\rstore_version\x18\x14 \x01(\x03\x12\x18\n\x10index_store_path\x18\x15 \x01(\t\x12\x0b\n\x03\x64im\x18\x16 \x01(\x03\x12\x10\n\x08\x64\x61ta_ids\x18\x17 \x03(\x03\x12\x45\n\x16optional_scalar_fields\x18\x18 \x03(\x0b\x32%.milvus.proto.index.OptionalFieldInfo\"7\n\x10QueryJobsRequest\x12\x11\n\tclusterID\x18\x01 \x01(\t\x12\x10\n\x08\x62uildIDs\x18\x02 \x03(\x03\"\xd3\x01\n\rIndexTaskInfo\x12\x0f\n\x07\x62uildID\x18\x01 \x01(\x03\x12.\n\x05state\x18\x02 \x01(\x0e\x32\x1f.milvus.proto.common.IndexState\x12\x17\n\x0findex_file_keys\x18\x03 \x03(\t\x12\x17\n\x0fserialized_size\x18\x04 \x01(\x04\x12\x13\n\x0b\x66\x61il_reason\x18\x05 \x01(\t\x12\x1d\n\x15\x63urrent_index_version\x18\x06 \x01(\x05\x12\x1b\n\x13index_store_version\x18\x07 \x01(\x03\"\x8b\x01\n\x11QueryJobsResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\x11\n\tclusterID\x18\x02 \x01(\t\x12\x36\n\x0bindex_infos\x18\x03 \x03(\x0b\x32!.milvus.proto.index.IndexTaskInfo\"6\n\x0f\x44ropJobsRequest\x12\x11\n\tclusterID\x18\x01 \x01(\t\x12\x10\n\x08\x62uildIDs\x18\x02 \x03(\x03\"\x96\x01\n\x07JobInfo\x12\x10\n\x08num_rows\x18\x01 \x01(\x03\x12\x0b\n\x03\x64im\x18\x02 \x01(\x03\x12\x12\n\nstart_time\x18\x03 \x01(\x03\x12\x10\n\x08\x65nd_time\x18\x04 \x01(\x03\x12\x37\n\x0cindex_params\x18\x05 \x03(\x0b\x32!.milvus.proto.common.KeyValuePair\x12\r\n\x05podID\x18\x06 \x01(\x03\"\x14\n\x12GetJobStatsRequest\"\xe8\x01\n\x13GetJobStatsResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\x15\n\rtotal_job_num\x18\x02 \x01(\x03\x12\x1b\n\x13in_progress_job_num\x18\x03 \x01(\x03\x12\x17\n\x0f\x65nqueue_job_num\x18\x04 \x01(\x03\x12\x12\n\ntask_slots\x18\x05 \x01(\x03\x12.\n\tjob_infos\x18\x06 \x03(\x0b\x32\x1b.milvus.proto.index.JobInfo\x12\x13\n\x0b\x65nable_disk\x18\x07 \x01(\x08\"E\n\x19GetIndexStatisticsRequest\x12\x14\n\x0c\x63ollectionID\x18\x01 \x01(\x03\x12\x12\n\nindex_name\x18\x02 \x01(\t\"}\n\x1aGetIndexStatisticsResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\x32\n\x0bindex_infos\x18\x02 \x03(\x0b\x32\x1d.milvus.proto.index.IndexInfo\"*\n\x12ListIndexesRequest\x12\x14\n\x0c\x63ollectionID\x18\x01 \x01(\x03\"v\n\x13ListIndexesResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\x32\n\x0bindex_infos\x18\x02 \x03(\x0b\x32\x1d.milvus.proto.index.IndexInfo2\xd5\x0b\n\nIndexCoord\x12l\n\x12GetComponentStates\x12..milvus.proto.milvus.GetComponentStatesRequest\x1a$.milvus.proto.milvus.ComponentStates\"\x00\x12q\n\x14GetStatisticsChannel\x12\x32.milvus.proto.internal.GetStatisticsChannelRequest\x1a#.milvus.proto.milvus.StringResponse\"\x00\x12T\n\x0b\x43reateIndex\x12&.milvus.proto.index.CreateIndexRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12R\n\nAlterIndex\x12%.milvus.proto.index.AlterIndexRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12\x66\n\rGetIndexState\x12(.milvus.proto.index.GetIndexStateRequest\x1a).milvus.proto.index.GetIndexStateResponse\"\x00\x12{\n\x14GetSegmentIndexState\x12/.milvus.proto.index.GetSegmentIndexStateRequest\x1a\x30.milvus.proto.index.GetSegmentIndexStateResponse\"\x00\x12\x64\n\rGetIndexInfos\x12\'.milvus.proto.index.GetIndexInfoRequest\x1a(.milvus.proto.index.GetIndexInfoResponse\"\x00\x12P\n\tDropIndex\x12$.milvus.proto.index.DropIndexRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12\x66\n\rDescribeIndex\x12(.milvus.proto.index.DescribeIndexRequest\x1a).milvus.proto.index.DescribeIndexResponse\"\x00\x12u\n\x12GetIndexStatistics\x12-.milvus.proto.index.GetIndexStatisticsRequest\x1a..milvus.proto.index.GetIndexStatisticsResponse\"\x00\x12~\n\x15GetIndexBuildProgress\x12\x30.milvus.proto.index.GetIndexBuildProgressRequest\x1a\x31.milvus.proto.index.GetIndexBuildProgressResponse\"\x00\x12{\n\x12ShowConfigurations\x12\x30.milvus.proto.internal.ShowConfigurationsRequest\x1a\x31.milvus.proto.internal.ShowConfigurationsResponse\"\x00\x12_\n\nGetMetrics\x12&.milvus.proto.milvus.GetMetricsRequest\x1a\'.milvus.proto.milvus.GetMetricsResponse\"\x00\x12\x62\n\x0b\x43heckHealth\x12\'.milvus.proto.milvus.CheckHealthRequest\x1a(.milvus.proto.milvus.CheckHealthResponse\"\x00\x32\xaa\x06\n\tIndexNode\x12l\n\x12GetComponentStates\x12..milvus.proto.milvus.GetComponentStatesRequest\x1a$.milvus.proto.milvus.ComponentStates\"\x00\x12q\n\x14GetStatisticsChannel\x12\x32.milvus.proto.internal.GetStatisticsChannelRequest\x1a#.milvus.proto.milvus.StringResponse\"\x00\x12P\n\tCreateJob\x12$.milvus.proto.index.CreateJobRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12Z\n\tQueryJobs\x12$.milvus.proto.index.QueryJobsRequest\x1a%.milvus.proto.index.QueryJobsResponse\"\x00\x12N\n\x08\x44ropJobs\x12#.milvus.proto.index.DropJobsRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12`\n\x0bGetJobStats\x12&.milvus.proto.index.GetJobStatsRequest\x1a\'.milvus.proto.index.GetJobStatsResponse\"\x00\x12{\n\x12ShowConfigurations\x12\x30.milvus.proto.internal.ShowConfigurationsRequest\x1a\x31.milvus.proto.internal.ShowConfigurationsResponse\"\x00\x12_\n\nGetMetrics\x12&.milvus.proto.milvus.GetMetricsRequest\x1a\'.milvus.proto.milvus.GetMetricsResponse\"\x00\x42\x34Z2github.com/milvus-io/milvus/internal/proto/indexpbb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'index_coord_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + _globals['DESCRIPTOR']._options = None + _globals['DESCRIPTOR']._serialized_options = b'Z2github.com/milvus-io/milvus/internal/proto/indexpb' + _globals['_GETINDEXINFORESPONSE_SEGMENTINFOENTRY']._options = None + _globals['_GETINDEXINFORESPONSE_SEGMENTINFOENTRY']._serialized_options = b'8\001' + _globals['_INDEXINFO']._serialized_start=100 + _globals['_INDEXINFO']._serialized_end=536 + _globals['_FIELDINDEX']._serialized_start=538 + _globals['_FIELDINDEX']._serialized_end=639 + _globals['_SEGMENTINDEX']._serialized_start=642 + _globals['_SEGMENTINDEX']._serialized_end=1048 + _globals['_REGISTERNODEREQUEST']._serialized_start=1051 + _globals['_REGISTERNODEREQUEST']._serialized_end=1179 + _globals['_REGISTERNODERESPONSE']._serialized_start=1181 + _globals['_REGISTERNODERESPONSE']._serialized_end=1304 + _globals['_GETINDEXSTATEREQUEST']._serialized_start=1306 + _globals['_GETINDEXSTATEREQUEST']._serialized_end=1370 + _globals['_GETINDEXSTATERESPONSE']._serialized_start=1373 + _globals['_GETINDEXSTATERESPONSE']._serialized_end=1510 + _globals['_GETSEGMENTINDEXSTATEREQUEST']._serialized_start=1512 + _globals['_GETSEGMENTINDEXSTATEREQUEST']._serialized_end=1603 + _globals['_SEGMENTINDEXSTATE']._serialized_start=1605 + _globals['_SEGMENTINDEXSTATE']._serialized_end=1732 + _globals['_GETSEGMENTINDEXSTATERESPONSE']._serialized_start=1735 + _globals['_GETSEGMENTINDEXSTATERESPONSE']._serialized_end=1865 + _globals['_CREATEINDEXREQUEST']._serialized_start=1868 + _globals['_CREATEINDEXREQUEST']._serialized_end=2164 + _globals['_ALTERINDEXREQUEST']._serialized_start=2166 + _globals['_ALTERINDEXREQUEST']._serialized_end=2278 + _globals['_GETINDEXINFOREQUEST']._serialized_start=2280 + _globals['_GETINDEXINFOREQUEST']._serialized_end=2363 + _globals['_INDEXFILEPATHINFO']._serialized_start=2366 + _globals['_INDEXFILEPATHINFO']._serialized_end=2655 + _globals['_SEGMENTINFO']._serialized_start=2658 + _globals['_SEGMENTINFO']._serialized_end=2794 + _globals['_GETINDEXINFORESPONSE']._serialized_start=2797 + _globals['_GETINDEXINFORESPONSE']._serialized_end=3030 + _globals['_GETINDEXINFORESPONSE_SEGMENTINFOENTRY']._serialized_start=2947 + _globals['_GETINDEXINFORESPONSE_SEGMENTINFOENTRY']._serialized_end=3030 + _globals['_DROPINDEXREQUEST']._serialized_start=3032 + _globals['_DROPINDEXREQUEST']._serialized_end=3132 + _globals['_DESCRIBEINDEXREQUEST']._serialized_start=3134 + _globals['_DESCRIBEINDEXREQUEST']._serialized_end=3217 + _globals['_DESCRIBEINDEXRESPONSE']._serialized_start=3219 + _globals['_DESCRIBEINDEXRESPONSE']._serialized_end=3339 + _globals['_GETINDEXBUILDPROGRESSREQUEST']._serialized_start=3341 + _globals['_GETINDEXBUILDPROGRESSREQUEST']._serialized_end=3413 + _globals['_GETINDEXBUILDPROGRESSRESPONSE']._serialized_start=3416 + _globals['_GETINDEXBUILDPROGRESSRESPONSE']._serialized_end=3562 + _globals['_STORAGECONFIG']._serialized_start=3565 + _globals['_STORAGECONFIG']._serialized_end=3855 + _globals['_OPTIONALFIELDINFO']._serialized_start=3857 + _globals['_OPTIONALFIELDINFO']._serialized_end=3971 + _globals['_CREATEJOBREQUEST']._serialized_start=3974 + _globals['_CREATEJOBREQUEST']._serialized_end=4677 + _globals['_QUERYJOBSREQUEST']._serialized_start=4679 + _globals['_QUERYJOBSREQUEST']._serialized_end=4734 + _globals['_INDEXTASKINFO']._serialized_start=4737 + _globals['_INDEXTASKINFO']._serialized_end=4948 + _globals['_QUERYJOBSRESPONSE']._serialized_start=4951 + _globals['_QUERYJOBSRESPONSE']._serialized_end=5090 + _globals['_DROPJOBSREQUEST']._serialized_start=5092 + _globals['_DROPJOBSREQUEST']._serialized_end=5146 + _globals['_JOBINFO']._serialized_start=5149 + _globals['_JOBINFO']._serialized_end=5299 + _globals['_GETJOBSTATSREQUEST']._serialized_start=5301 + _globals['_GETJOBSTATSREQUEST']._serialized_end=5321 + _globals['_GETJOBSTATSRESPONSE']._serialized_start=5324 + _globals['_GETJOBSTATSRESPONSE']._serialized_end=5556 + _globals['_GETINDEXSTATISTICSREQUEST']._serialized_start=5558 + _globals['_GETINDEXSTATISTICSREQUEST']._serialized_end=5627 + _globals['_GETINDEXSTATISTICSRESPONSE']._serialized_start=5629 + _globals['_GETINDEXSTATISTICSRESPONSE']._serialized_end=5754 + _globals['_LISTINDEXESREQUEST']._serialized_start=5756 + _globals['_LISTINDEXESREQUEST']._serialized_end=5798 + _globals['_LISTINDEXESRESPONSE']._serialized_start=5800 + _globals['_LISTINDEXESRESPONSE']._serialized_end=5918 + _globals['_INDEXCOORD']._serialized_start=5921 + _globals['_INDEXCOORD']._serialized_end=7414 + _globals['_INDEXNODE']._serialized_start=7417 + _globals['_INDEXNODE']._serialized_end=8227 +# @@protoc_insertion_point(module_scope) diff --git a/milvus_connector/protocol/index_coord_pb2.pyi b/milvus_connector/protocol/index_coord_pb2.pyi new file mode 100644 index 0000000..2fa47fd --- /dev/null +++ b/milvus_connector/protocol/index_coord_pb2.pyi @@ -0,0 +1,505 @@ +from . import common_pb2 as _common_pb2 +from . import internal_pb2 as _internal_pb2 +from . import milvus_pb2 as _milvus_pb2 +from . import schema_pb2 as _schema_pb2 +from google.protobuf.internal import containers as _containers +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Iterable as _Iterable, Mapping as _Mapping, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class IndexInfo(_message.Message): + __slots__ = ("collectionID", "fieldID", "index_name", "indexID", "type_params", "index_params", "indexed_rows", "total_rows", "state", "index_state_fail_reason", "is_auto_index", "user_index_params", "pending_index_rows") + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + FIELDID_FIELD_NUMBER: _ClassVar[int] + INDEX_NAME_FIELD_NUMBER: _ClassVar[int] + INDEXID_FIELD_NUMBER: _ClassVar[int] + TYPE_PARAMS_FIELD_NUMBER: _ClassVar[int] + INDEX_PARAMS_FIELD_NUMBER: _ClassVar[int] + INDEXED_ROWS_FIELD_NUMBER: _ClassVar[int] + TOTAL_ROWS_FIELD_NUMBER: _ClassVar[int] + STATE_FIELD_NUMBER: _ClassVar[int] + INDEX_STATE_FAIL_REASON_FIELD_NUMBER: _ClassVar[int] + IS_AUTO_INDEX_FIELD_NUMBER: _ClassVar[int] + USER_INDEX_PARAMS_FIELD_NUMBER: _ClassVar[int] + PENDING_INDEX_ROWS_FIELD_NUMBER: _ClassVar[int] + collectionID: int + fieldID: int + index_name: str + indexID: int + type_params: _containers.RepeatedCompositeFieldContainer[_common_pb2.KeyValuePair] + index_params: _containers.RepeatedCompositeFieldContainer[_common_pb2.KeyValuePair] + indexed_rows: int + total_rows: int + state: _common_pb2.IndexState + index_state_fail_reason: str + is_auto_index: bool + user_index_params: _containers.RepeatedCompositeFieldContainer[_common_pb2.KeyValuePair] + pending_index_rows: int + def __init__(self, collectionID: _Optional[int] = ..., fieldID: _Optional[int] = ..., index_name: _Optional[str] = ..., indexID: _Optional[int] = ..., type_params: _Optional[_Iterable[_Union[_common_pb2.KeyValuePair, _Mapping]]] = ..., index_params: _Optional[_Iterable[_Union[_common_pb2.KeyValuePair, _Mapping]]] = ..., indexed_rows: _Optional[int] = ..., total_rows: _Optional[int] = ..., state: _Optional[_Union[_common_pb2.IndexState, str]] = ..., index_state_fail_reason: _Optional[str] = ..., is_auto_index: bool = ..., user_index_params: _Optional[_Iterable[_Union[_common_pb2.KeyValuePair, _Mapping]]] = ..., pending_index_rows: _Optional[int] = ...) -> None: ... + +class FieldIndex(_message.Message): + __slots__ = ("index_info", "deleted", "create_time") + INDEX_INFO_FIELD_NUMBER: _ClassVar[int] + DELETED_FIELD_NUMBER: _ClassVar[int] + CREATE_TIME_FIELD_NUMBER: _ClassVar[int] + index_info: IndexInfo + deleted: bool + create_time: int + def __init__(self, index_info: _Optional[_Union[IndexInfo, _Mapping]] = ..., deleted: bool = ..., create_time: _Optional[int] = ...) -> None: ... + +class SegmentIndex(_message.Message): + __slots__ = ("collectionID", "partitionID", "segmentID", "num_rows", "indexID", "buildID", "nodeID", "index_version", "state", "fail_reason", "index_file_keys", "deleted", "create_time", "serialize_size", "write_handoff", "current_index_version", "index_store_version") + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + PARTITIONID_FIELD_NUMBER: _ClassVar[int] + SEGMENTID_FIELD_NUMBER: _ClassVar[int] + NUM_ROWS_FIELD_NUMBER: _ClassVar[int] + INDEXID_FIELD_NUMBER: _ClassVar[int] + BUILDID_FIELD_NUMBER: _ClassVar[int] + NODEID_FIELD_NUMBER: _ClassVar[int] + INDEX_VERSION_FIELD_NUMBER: _ClassVar[int] + STATE_FIELD_NUMBER: _ClassVar[int] + FAIL_REASON_FIELD_NUMBER: _ClassVar[int] + INDEX_FILE_KEYS_FIELD_NUMBER: _ClassVar[int] + DELETED_FIELD_NUMBER: _ClassVar[int] + CREATE_TIME_FIELD_NUMBER: _ClassVar[int] + SERIALIZE_SIZE_FIELD_NUMBER: _ClassVar[int] + WRITE_HANDOFF_FIELD_NUMBER: _ClassVar[int] + CURRENT_INDEX_VERSION_FIELD_NUMBER: _ClassVar[int] + INDEX_STORE_VERSION_FIELD_NUMBER: _ClassVar[int] + collectionID: int + partitionID: int + segmentID: int + num_rows: int + indexID: int + buildID: int + nodeID: int + index_version: int + state: _common_pb2.IndexState + fail_reason: str + index_file_keys: _containers.RepeatedScalarFieldContainer[str] + deleted: bool + create_time: int + serialize_size: int + write_handoff: bool + current_index_version: int + index_store_version: int + def __init__(self, collectionID: _Optional[int] = ..., partitionID: _Optional[int] = ..., segmentID: _Optional[int] = ..., num_rows: _Optional[int] = ..., indexID: _Optional[int] = ..., buildID: _Optional[int] = ..., nodeID: _Optional[int] = ..., index_version: _Optional[int] = ..., state: _Optional[_Union[_common_pb2.IndexState, str]] = ..., fail_reason: _Optional[str] = ..., index_file_keys: _Optional[_Iterable[str]] = ..., deleted: bool = ..., create_time: _Optional[int] = ..., serialize_size: _Optional[int] = ..., write_handoff: bool = ..., current_index_version: _Optional[int] = ..., index_store_version: _Optional[int] = ...) -> None: ... + +class RegisterNodeRequest(_message.Message): + __slots__ = ("base", "address", "nodeID") + BASE_FIELD_NUMBER: _ClassVar[int] + ADDRESS_FIELD_NUMBER: _ClassVar[int] + NODEID_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + address: _common_pb2.Address + nodeID: int + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., address: _Optional[_Union[_common_pb2.Address, _Mapping]] = ..., nodeID: _Optional[int] = ...) -> None: ... + +class RegisterNodeResponse(_message.Message): + __slots__ = ("status", "init_params") + STATUS_FIELD_NUMBER: _ClassVar[int] + INIT_PARAMS_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + init_params: _internal_pb2.InitParams + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., init_params: _Optional[_Union[_internal_pb2.InitParams, _Mapping]] = ...) -> None: ... + +class GetIndexStateRequest(_message.Message): + __slots__ = ("collectionID", "index_name") + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + INDEX_NAME_FIELD_NUMBER: _ClassVar[int] + collectionID: int + index_name: str + def __init__(self, collectionID: _Optional[int] = ..., index_name: _Optional[str] = ...) -> None: ... + +class GetIndexStateResponse(_message.Message): + __slots__ = ("status", "state", "fail_reason") + STATUS_FIELD_NUMBER: _ClassVar[int] + STATE_FIELD_NUMBER: _ClassVar[int] + FAIL_REASON_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + state: _common_pb2.IndexState + fail_reason: str + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., state: _Optional[_Union[_common_pb2.IndexState, str]] = ..., fail_reason: _Optional[str] = ...) -> None: ... + +class GetSegmentIndexStateRequest(_message.Message): + __slots__ = ("collectionID", "index_name", "segmentIDs") + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + INDEX_NAME_FIELD_NUMBER: _ClassVar[int] + SEGMENTIDS_FIELD_NUMBER: _ClassVar[int] + collectionID: int + index_name: str + segmentIDs: _containers.RepeatedScalarFieldContainer[int] + def __init__(self, collectionID: _Optional[int] = ..., index_name: _Optional[str] = ..., segmentIDs: _Optional[_Iterable[int]] = ...) -> None: ... + +class SegmentIndexState(_message.Message): + __slots__ = ("segmentID", "state", "fail_reason", "index_name") + SEGMENTID_FIELD_NUMBER: _ClassVar[int] + STATE_FIELD_NUMBER: _ClassVar[int] + FAIL_REASON_FIELD_NUMBER: _ClassVar[int] + INDEX_NAME_FIELD_NUMBER: _ClassVar[int] + segmentID: int + state: _common_pb2.IndexState + fail_reason: str + index_name: str + def __init__(self, segmentID: _Optional[int] = ..., state: _Optional[_Union[_common_pb2.IndexState, str]] = ..., fail_reason: _Optional[str] = ..., index_name: _Optional[str] = ...) -> None: ... + +class GetSegmentIndexStateResponse(_message.Message): + __slots__ = ("status", "states") + STATUS_FIELD_NUMBER: _ClassVar[int] + STATES_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + states: _containers.RepeatedCompositeFieldContainer[SegmentIndexState] + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., states: _Optional[_Iterable[_Union[SegmentIndexState, _Mapping]]] = ...) -> None: ... + +class CreateIndexRequest(_message.Message): + __slots__ = ("collectionID", "fieldID", "index_name", "type_params", "index_params", "timestamp", "is_auto_index", "user_index_params") + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + FIELDID_FIELD_NUMBER: _ClassVar[int] + INDEX_NAME_FIELD_NUMBER: _ClassVar[int] + TYPE_PARAMS_FIELD_NUMBER: _ClassVar[int] + INDEX_PARAMS_FIELD_NUMBER: _ClassVar[int] + TIMESTAMP_FIELD_NUMBER: _ClassVar[int] + IS_AUTO_INDEX_FIELD_NUMBER: _ClassVar[int] + USER_INDEX_PARAMS_FIELD_NUMBER: _ClassVar[int] + collectionID: int + fieldID: int + index_name: str + type_params: _containers.RepeatedCompositeFieldContainer[_common_pb2.KeyValuePair] + index_params: _containers.RepeatedCompositeFieldContainer[_common_pb2.KeyValuePair] + timestamp: int + is_auto_index: bool + user_index_params: _containers.RepeatedCompositeFieldContainer[_common_pb2.KeyValuePair] + def __init__(self, collectionID: _Optional[int] = ..., fieldID: _Optional[int] = ..., index_name: _Optional[str] = ..., type_params: _Optional[_Iterable[_Union[_common_pb2.KeyValuePair, _Mapping]]] = ..., index_params: _Optional[_Iterable[_Union[_common_pb2.KeyValuePair, _Mapping]]] = ..., timestamp: _Optional[int] = ..., is_auto_index: bool = ..., user_index_params: _Optional[_Iterable[_Union[_common_pb2.KeyValuePair, _Mapping]]] = ...) -> None: ... + +class AlterIndexRequest(_message.Message): + __slots__ = ("collectionID", "index_name", "params") + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + INDEX_NAME_FIELD_NUMBER: _ClassVar[int] + PARAMS_FIELD_NUMBER: _ClassVar[int] + collectionID: int + index_name: str + params: _containers.RepeatedCompositeFieldContainer[_common_pb2.KeyValuePair] + def __init__(self, collectionID: _Optional[int] = ..., index_name: _Optional[str] = ..., params: _Optional[_Iterable[_Union[_common_pb2.KeyValuePair, _Mapping]]] = ...) -> None: ... + +class GetIndexInfoRequest(_message.Message): + __slots__ = ("collectionID", "segmentIDs", "index_name") + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + SEGMENTIDS_FIELD_NUMBER: _ClassVar[int] + INDEX_NAME_FIELD_NUMBER: _ClassVar[int] + collectionID: int + segmentIDs: _containers.RepeatedScalarFieldContainer[int] + index_name: str + def __init__(self, collectionID: _Optional[int] = ..., segmentIDs: _Optional[_Iterable[int]] = ..., index_name: _Optional[str] = ...) -> None: ... + +class IndexFilePathInfo(_message.Message): + __slots__ = ("segmentID", "fieldID", "indexID", "buildID", "index_name", "index_params", "index_file_paths", "serialized_size", "index_version", "num_rows", "current_index_version") + SEGMENTID_FIELD_NUMBER: _ClassVar[int] + FIELDID_FIELD_NUMBER: _ClassVar[int] + INDEXID_FIELD_NUMBER: _ClassVar[int] + BUILDID_FIELD_NUMBER: _ClassVar[int] + INDEX_NAME_FIELD_NUMBER: _ClassVar[int] + INDEX_PARAMS_FIELD_NUMBER: _ClassVar[int] + INDEX_FILE_PATHS_FIELD_NUMBER: _ClassVar[int] + SERIALIZED_SIZE_FIELD_NUMBER: _ClassVar[int] + INDEX_VERSION_FIELD_NUMBER: _ClassVar[int] + NUM_ROWS_FIELD_NUMBER: _ClassVar[int] + CURRENT_INDEX_VERSION_FIELD_NUMBER: _ClassVar[int] + segmentID: int + fieldID: int + indexID: int + buildID: int + index_name: str + index_params: _containers.RepeatedCompositeFieldContainer[_common_pb2.KeyValuePair] + index_file_paths: _containers.RepeatedScalarFieldContainer[str] + serialized_size: int + index_version: int + num_rows: int + current_index_version: int + def __init__(self, segmentID: _Optional[int] = ..., fieldID: _Optional[int] = ..., indexID: _Optional[int] = ..., buildID: _Optional[int] = ..., index_name: _Optional[str] = ..., index_params: _Optional[_Iterable[_Union[_common_pb2.KeyValuePair, _Mapping]]] = ..., index_file_paths: _Optional[_Iterable[str]] = ..., serialized_size: _Optional[int] = ..., index_version: _Optional[int] = ..., num_rows: _Optional[int] = ..., current_index_version: _Optional[int] = ...) -> None: ... + +class SegmentInfo(_message.Message): + __slots__ = ("collectionID", "segmentID", "enable_index", "index_infos") + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + SEGMENTID_FIELD_NUMBER: _ClassVar[int] + ENABLE_INDEX_FIELD_NUMBER: _ClassVar[int] + INDEX_INFOS_FIELD_NUMBER: _ClassVar[int] + collectionID: int + segmentID: int + enable_index: bool + index_infos: _containers.RepeatedCompositeFieldContainer[IndexFilePathInfo] + def __init__(self, collectionID: _Optional[int] = ..., segmentID: _Optional[int] = ..., enable_index: bool = ..., index_infos: _Optional[_Iterable[_Union[IndexFilePathInfo, _Mapping]]] = ...) -> None: ... + +class GetIndexInfoResponse(_message.Message): + __slots__ = ("status", "segment_info") + class SegmentInfoEntry(_message.Message): + __slots__ = ("key", "value") + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: int + value: SegmentInfo + def __init__(self, key: _Optional[int] = ..., value: _Optional[_Union[SegmentInfo, _Mapping]] = ...) -> None: ... + STATUS_FIELD_NUMBER: _ClassVar[int] + SEGMENT_INFO_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + segment_info: _containers.MessageMap[int, SegmentInfo] + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., segment_info: _Optional[_Mapping[int, SegmentInfo]] = ...) -> None: ... + +class DropIndexRequest(_message.Message): + __slots__ = ("collectionID", "partitionIDs", "index_name", "drop_all") + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + PARTITIONIDS_FIELD_NUMBER: _ClassVar[int] + INDEX_NAME_FIELD_NUMBER: _ClassVar[int] + DROP_ALL_FIELD_NUMBER: _ClassVar[int] + collectionID: int + partitionIDs: _containers.RepeatedScalarFieldContainer[int] + index_name: str + drop_all: bool + def __init__(self, collectionID: _Optional[int] = ..., partitionIDs: _Optional[_Iterable[int]] = ..., index_name: _Optional[str] = ..., drop_all: bool = ...) -> None: ... + +class DescribeIndexRequest(_message.Message): + __slots__ = ("collectionID", "index_name", "timestamp") + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + INDEX_NAME_FIELD_NUMBER: _ClassVar[int] + TIMESTAMP_FIELD_NUMBER: _ClassVar[int] + collectionID: int + index_name: str + timestamp: int + def __init__(self, collectionID: _Optional[int] = ..., index_name: _Optional[str] = ..., timestamp: _Optional[int] = ...) -> None: ... + +class DescribeIndexResponse(_message.Message): + __slots__ = ("status", "index_infos") + STATUS_FIELD_NUMBER: _ClassVar[int] + INDEX_INFOS_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + index_infos: _containers.RepeatedCompositeFieldContainer[IndexInfo] + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., index_infos: _Optional[_Iterable[_Union[IndexInfo, _Mapping]]] = ...) -> None: ... + +class GetIndexBuildProgressRequest(_message.Message): + __slots__ = ("collectionID", "index_name") + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + INDEX_NAME_FIELD_NUMBER: _ClassVar[int] + collectionID: int + index_name: str + def __init__(self, collectionID: _Optional[int] = ..., index_name: _Optional[str] = ...) -> None: ... + +class GetIndexBuildProgressResponse(_message.Message): + __slots__ = ("status", "indexed_rows", "total_rows", "pending_index_rows") + STATUS_FIELD_NUMBER: _ClassVar[int] + INDEXED_ROWS_FIELD_NUMBER: _ClassVar[int] + TOTAL_ROWS_FIELD_NUMBER: _ClassVar[int] + PENDING_INDEX_ROWS_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + indexed_rows: int + total_rows: int + pending_index_rows: int + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., indexed_rows: _Optional[int] = ..., total_rows: _Optional[int] = ..., pending_index_rows: _Optional[int] = ...) -> None: ... + +class StorageConfig(_message.Message): + __slots__ = ("address", "access_keyID", "secret_access_key", "useSSL", "bucket_name", "root_path", "useIAM", "IAMEndpoint", "storage_type", "use_virtual_host", "region", "cloud_provider", "request_timeout_ms") + ADDRESS_FIELD_NUMBER: _ClassVar[int] + ACCESS_KEYID_FIELD_NUMBER: _ClassVar[int] + SECRET_ACCESS_KEY_FIELD_NUMBER: _ClassVar[int] + USESSL_FIELD_NUMBER: _ClassVar[int] + BUCKET_NAME_FIELD_NUMBER: _ClassVar[int] + ROOT_PATH_FIELD_NUMBER: _ClassVar[int] + USEIAM_FIELD_NUMBER: _ClassVar[int] + IAMENDPOINT_FIELD_NUMBER: _ClassVar[int] + STORAGE_TYPE_FIELD_NUMBER: _ClassVar[int] + USE_VIRTUAL_HOST_FIELD_NUMBER: _ClassVar[int] + REGION_FIELD_NUMBER: _ClassVar[int] + CLOUD_PROVIDER_FIELD_NUMBER: _ClassVar[int] + REQUEST_TIMEOUT_MS_FIELD_NUMBER: _ClassVar[int] + address: str + access_keyID: str + secret_access_key: str + useSSL: bool + bucket_name: str + root_path: str + useIAM: bool + IAMEndpoint: str + storage_type: str + use_virtual_host: bool + region: str + cloud_provider: str + request_timeout_ms: int + def __init__(self, address: _Optional[str] = ..., access_keyID: _Optional[str] = ..., secret_access_key: _Optional[str] = ..., useSSL: bool = ..., bucket_name: _Optional[str] = ..., root_path: _Optional[str] = ..., useIAM: bool = ..., IAMEndpoint: _Optional[str] = ..., storage_type: _Optional[str] = ..., use_virtual_host: bool = ..., region: _Optional[str] = ..., cloud_provider: _Optional[str] = ..., request_timeout_ms: _Optional[int] = ...) -> None: ... + +class OptionalFieldInfo(_message.Message): + __slots__ = ("fieldID", "field_name", "field_type", "data_paths", "data_ids") + FIELDID_FIELD_NUMBER: _ClassVar[int] + FIELD_NAME_FIELD_NUMBER: _ClassVar[int] + FIELD_TYPE_FIELD_NUMBER: _ClassVar[int] + DATA_PATHS_FIELD_NUMBER: _ClassVar[int] + DATA_IDS_FIELD_NUMBER: _ClassVar[int] + fieldID: int + field_name: str + field_type: int + data_paths: _containers.RepeatedScalarFieldContainer[str] + data_ids: _containers.RepeatedScalarFieldContainer[int] + def __init__(self, fieldID: _Optional[int] = ..., field_name: _Optional[str] = ..., field_type: _Optional[int] = ..., data_paths: _Optional[_Iterable[str]] = ..., data_ids: _Optional[_Iterable[int]] = ...) -> None: ... + +class CreateJobRequest(_message.Message): + __slots__ = ("clusterID", "index_file_prefix", "buildID", "data_paths", "index_version", "indexID", "index_name", "storage_config", "index_params", "type_params", "num_rows", "current_index_version", "collectionID", "partitionID", "segmentID", "fieldID", "field_name", "field_type", "store_path", "store_version", "index_store_path", "dim", "data_ids", "optional_scalar_fields") + CLUSTERID_FIELD_NUMBER: _ClassVar[int] + INDEX_FILE_PREFIX_FIELD_NUMBER: _ClassVar[int] + BUILDID_FIELD_NUMBER: _ClassVar[int] + DATA_PATHS_FIELD_NUMBER: _ClassVar[int] + INDEX_VERSION_FIELD_NUMBER: _ClassVar[int] + INDEXID_FIELD_NUMBER: _ClassVar[int] + INDEX_NAME_FIELD_NUMBER: _ClassVar[int] + STORAGE_CONFIG_FIELD_NUMBER: _ClassVar[int] + INDEX_PARAMS_FIELD_NUMBER: _ClassVar[int] + TYPE_PARAMS_FIELD_NUMBER: _ClassVar[int] + NUM_ROWS_FIELD_NUMBER: _ClassVar[int] + CURRENT_INDEX_VERSION_FIELD_NUMBER: _ClassVar[int] + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + PARTITIONID_FIELD_NUMBER: _ClassVar[int] + SEGMENTID_FIELD_NUMBER: _ClassVar[int] + FIELDID_FIELD_NUMBER: _ClassVar[int] + FIELD_NAME_FIELD_NUMBER: _ClassVar[int] + FIELD_TYPE_FIELD_NUMBER: _ClassVar[int] + STORE_PATH_FIELD_NUMBER: _ClassVar[int] + STORE_VERSION_FIELD_NUMBER: _ClassVar[int] + INDEX_STORE_PATH_FIELD_NUMBER: _ClassVar[int] + DIM_FIELD_NUMBER: _ClassVar[int] + DATA_IDS_FIELD_NUMBER: _ClassVar[int] + OPTIONAL_SCALAR_FIELDS_FIELD_NUMBER: _ClassVar[int] + clusterID: str + index_file_prefix: str + buildID: int + data_paths: _containers.RepeatedScalarFieldContainer[str] + index_version: int + indexID: int + index_name: str + storage_config: StorageConfig + index_params: _containers.RepeatedCompositeFieldContainer[_common_pb2.KeyValuePair] + type_params: _containers.RepeatedCompositeFieldContainer[_common_pb2.KeyValuePair] + num_rows: int + current_index_version: int + collectionID: int + partitionID: int + segmentID: int + fieldID: int + field_name: str + field_type: _schema_pb2.DataType + store_path: str + store_version: int + index_store_path: str + dim: int + data_ids: _containers.RepeatedScalarFieldContainer[int] + optional_scalar_fields: _containers.RepeatedCompositeFieldContainer[OptionalFieldInfo] + def __init__(self, clusterID: _Optional[str] = ..., index_file_prefix: _Optional[str] = ..., buildID: _Optional[int] = ..., data_paths: _Optional[_Iterable[str]] = ..., index_version: _Optional[int] = ..., indexID: _Optional[int] = ..., index_name: _Optional[str] = ..., storage_config: _Optional[_Union[StorageConfig, _Mapping]] = ..., index_params: _Optional[_Iterable[_Union[_common_pb2.KeyValuePair, _Mapping]]] = ..., type_params: _Optional[_Iterable[_Union[_common_pb2.KeyValuePair, _Mapping]]] = ..., num_rows: _Optional[int] = ..., current_index_version: _Optional[int] = ..., collectionID: _Optional[int] = ..., partitionID: _Optional[int] = ..., segmentID: _Optional[int] = ..., fieldID: _Optional[int] = ..., field_name: _Optional[str] = ..., field_type: _Optional[_Union[_schema_pb2.DataType, str]] = ..., store_path: _Optional[str] = ..., store_version: _Optional[int] = ..., index_store_path: _Optional[str] = ..., dim: _Optional[int] = ..., data_ids: _Optional[_Iterable[int]] = ..., optional_scalar_fields: _Optional[_Iterable[_Union[OptionalFieldInfo, _Mapping]]] = ...) -> None: ... + +class QueryJobsRequest(_message.Message): + __slots__ = ("clusterID", "buildIDs") + CLUSTERID_FIELD_NUMBER: _ClassVar[int] + BUILDIDS_FIELD_NUMBER: _ClassVar[int] + clusterID: str + buildIDs: _containers.RepeatedScalarFieldContainer[int] + def __init__(self, clusterID: _Optional[str] = ..., buildIDs: _Optional[_Iterable[int]] = ...) -> None: ... + +class IndexTaskInfo(_message.Message): + __slots__ = ("buildID", "state", "index_file_keys", "serialized_size", "fail_reason", "current_index_version", "index_store_version") + BUILDID_FIELD_NUMBER: _ClassVar[int] + STATE_FIELD_NUMBER: _ClassVar[int] + INDEX_FILE_KEYS_FIELD_NUMBER: _ClassVar[int] + SERIALIZED_SIZE_FIELD_NUMBER: _ClassVar[int] + FAIL_REASON_FIELD_NUMBER: _ClassVar[int] + CURRENT_INDEX_VERSION_FIELD_NUMBER: _ClassVar[int] + INDEX_STORE_VERSION_FIELD_NUMBER: _ClassVar[int] + buildID: int + state: _common_pb2.IndexState + index_file_keys: _containers.RepeatedScalarFieldContainer[str] + serialized_size: int + fail_reason: str + current_index_version: int + index_store_version: int + def __init__(self, buildID: _Optional[int] = ..., state: _Optional[_Union[_common_pb2.IndexState, str]] = ..., index_file_keys: _Optional[_Iterable[str]] = ..., serialized_size: _Optional[int] = ..., fail_reason: _Optional[str] = ..., current_index_version: _Optional[int] = ..., index_store_version: _Optional[int] = ...) -> None: ... + +class QueryJobsResponse(_message.Message): + __slots__ = ("status", "clusterID", "index_infos") + STATUS_FIELD_NUMBER: _ClassVar[int] + CLUSTERID_FIELD_NUMBER: _ClassVar[int] + INDEX_INFOS_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + clusterID: str + index_infos: _containers.RepeatedCompositeFieldContainer[IndexTaskInfo] + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., clusterID: _Optional[str] = ..., index_infos: _Optional[_Iterable[_Union[IndexTaskInfo, _Mapping]]] = ...) -> None: ... + +class DropJobsRequest(_message.Message): + __slots__ = ("clusterID", "buildIDs") + CLUSTERID_FIELD_NUMBER: _ClassVar[int] + BUILDIDS_FIELD_NUMBER: _ClassVar[int] + clusterID: str + buildIDs: _containers.RepeatedScalarFieldContainer[int] + def __init__(self, clusterID: _Optional[str] = ..., buildIDs: _Optional[_Iterable[int]] = ...) -> None: ... + +class JobInfo(_message.Message): + __slots__ = ("num_rows", "dim", "start_time", "end_time", "index_params", "podID") + NUM_ROWS_FIELD_NUMBER: _ClassVar[int] + DIM_FIELD_NUMBER: _ClassVar[int] + START_TIME_FIELD_NUMBER: _ClassVar[int] + END_TIME_FIELD_NUMBER: _ClassVar[int] + INDEX_PARAMS_FIELD_NUMBER: _ClassVar[int] + PODID_FIELD_NUMBER: _ClassVar[int] + num_rows: int + dim: int + start_time: int + end_time: int + index_params: _containers.RepeatedCompositeFieldContainer[_common_pb2.KeyValuePair] + podID: int + def __init__(self, num_rows: _Optional[int] = ..., dim: _Optional[int] = ..., start_time: _Optional[int] = ..., end_time: _Optional[int] = ..., index_params: _Optional[_Iterable[_Union[_common_pb2.KeyValuePair, _Mapping]]] = ..., podID: _Optional[int] = ...) -> None: ... + +class GetJobStatsRequest(_message.Message): + __slots__ = () + def __init__(self) -> None: ... + +class GetJobStatsResponse(_message.Message): + __slots__ = ("status", "total_job_num", "in_progress_job_num", "enqueue_job_num", "task_slots", "job_infos", "enable_disk") + STATUS_FIELD_NUMBER: _ClassVar[int] + TOTAL_JOB_NUM_FIELD_NUMBER: _ClassVar[int] + IN_PROGRESS_JOB_NUM_FIELD_NUMBER: _ClassVar[int] + ENQUEUE_JOB_NUM_FIELD_NUMBER: _ClassVar[int] + TASK_SLOTS_FIELD_NUMBER: _ClassVar[int] + JOB_INFOS_FIELD_NUMBER: _ClassVar[int] + ENABLE_DISK_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + total_job_num: int + in_progress_job_num: int + enqueue_job_num: int + task_slots: int + job_infos: _containers.RepeatedCompositeFieldContainer[JobInfo] + enable_disk: bool + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., total_job_num: _Optional[int] = ..., in_progress_job_num: _Optional[int] = ..., enqueue_job_num: _Optional[int] = ..., task_slots: _Optional[int] = ..., job_infos: _Optional[_Iterable[_Union[JobInfo, _Mapping]]] = ..., enable_disk: bool = ...) -> None: ... + +class GetIndexStatisticsRequest(_message.Message): + __slots__ = ("collectionID", "index_name") + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + INDEX_NAME_FIELD_NUMBER: _ClassVar[int] + collectionID: int + index_name: str + def __init__(self, collectionID: _Optional[int] = ..., index_name: _Optional[str] = ...) -> None: ... + +class GetIndexStatisticsResponse(_message.Message): + __slots__ = ("status", "index_infos") + STATUS_FIELD_NUMBER: _ClassVar[int] + INDEX_INFOS_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + index_infos: _containers.RepeatedCompositeFieldContainer[IndexInfo] + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., index_infos: _Optional[_Iterable[_Union[IndexInfo, _Mapping]]] = ...) -> None: ... + +class ListIndexesRequest(_message.Message): + __slots__ = ("collectionID",) + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + collectionID: int + def __init__(self, collectionID: _Optional[int] = ...) -> None: ... + +class ListIndexesResponse(_message.Message): + __slots__ = ("status", "index_infos") + STATUS_FIELD_NUMBER: _ClassVar[int] + INDEX_INFOS_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + index_infos: _containers.RepeatedCompositeFieldContainer[IndexInfo] + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., index_infos: _Optional[_Iterable[_Union[IndexInfo, _Mapping]]] = ...) -> None: ... diff --git a/milvus_connector/protocol/index_coord_pb2_grpc.py b/milvus_connector/protocol/index_coord_pb2_grpc.py new file mode 100644 index 0000000..8750486 --- /dev/null +++ b/milvus_connector/protocol/index_coord_pb2_grpc.py @@ -0,0 +1,794 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + +from . import common_pb2 as common__pb2 +from . import index_coord_pb2 as index__coord__pb2 +from . import internal_pb2 as internal__pb2 +from . import milvus_pb2 as milvus__pb2 + + +class IndexCoordStub(object): + """Missing associated documentation comment in .proto file.""" + + def __init__(self, channel): + """Constructor. + + Args: + channel: A grpc.Channel. + """ + self.GetComponentStates = channel.unary_unary( + '/milvus.proto.index.IndexCoord/GetComponentStates', + request_serializer=milvus__pb2.GetComponentStatesRequest.SerializeToString, + response_deserializer=milvus__pb2.ComponentStates.FromString, + ) + self.GetStatisticsChannel = channel.unary_unary( + '/milvus.proto.index.IndexCoord/GetStatisticsChannel', + request_serializer=internal__pb2.GetStatisticsChannelRequest.SerializeToString, + response_deserializer=milvus__pb2.StringResponse.FromString, + ) + self.CreateIndex = channel.unary_unary( + '/milvus.proto.index.IndexCoord/CreateIndex', + request_serializer=index__coord__pb2.CreateIndexRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.AlterIndex = channel.unary_unary( + '/milvus.proto.index.IndexCoord/AlterIndex', + request_serializer=index__coord__pb2.AlterIndexRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.GetIndexState = channel.unary_unary( + '/milvus.proto.index.IndexCoord/GetIndexState', + request_serializer=index__coord__pb2.GetIndexStateRequest.SerializeToString, + response_deserializer=index__coord__pb2.GetIndexStateResponse.FromString, + ) + self.GetSegmentIndexState = channel.unary_unary( + '/milvus.proto.index.IndexCoord/GetSegmentIndexState', + request_serializer=index__coord__pb2.GetSegmentIndexStateRequest.SerializeToString, + response_deserializer=index__coord__pb2.GetSegmentIndexStateResponse.FromString, + ) + self.GetIndexInfos = channel.unary_unary( + '/milvus.proto.index.IndexCoord/GetIndexInfos', + request_serializer=index__coord__pb2.GetIndexInfoRequest.SerializeToString, + response_deserializer=index__coord__pb2.GetIndexInfoResponse.FromString, + ) + self.DropIndex = channel.unary_unary( + '/milvus.proto.index.IndexCoord/DropIndex', + request_serializer=index__coord__pb2.DropIndexRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.DescribeIndex = channel.unary_unary( + '/milvus.proto.index.IndexCoord/DescribeIndex', + request_serializer=index__coord__pb2.DescribeIndexRequest.SerializeToString, + response_deserializer=index__coord__pb2.DescribeIndexResponse.FromString, + ) + self.GetIndexStatistics = channel.unary_unary( + '/milvus.proto.index.IndexCoord/GetIndexStatistics', + request_serializer=index__coord__pb2.GetIndexStatisticsRequest.SerializeToString, + response_deserializer=index__coord__pb2.GetIndexStatisticsResponse.FromString, + ) + self.GetIndexBuildProgress = channel.unary_unary( + '/milvus.proto.index.IndexCoord/GetIndexBuildProgress', + request_serializer=index__coord__pb2.GetIndexBuildProgressRequest.SerializeToString, + response_deserializer=index__coord__pb2.GetIndexBuildProgressResponse.FromString, + ) + self.ShowConfigurations = channel.unary_unary( + '/milvus.proto.index.IndexCoord/ShowConfigurations', + request_serializer=internal__pb2.ShowConfigurationsRequest.SerializeToString, + response_deserializer=internal__pb2.ShowConfigurationsResponse.FromString, + ) + self.GetMetrics = channel.unary_unary( + '/milvus.proto.index.IndexCoord/GetMetrics', + request_serializer=milvus__pb2.GetMetricsRequest.SerializeToString, + response_deserializer=milvus__pb2.GetMetricsResponse.FromString, + ) + self.CheckHealth = channel.unary_unary( + '/milvus.proto.index.IndexCoord/CheckHealth', + request_serializer=milvus__pb2.CheckHealthRequest.SerializeToString, + response_deserializer=milvus__pb2.CheckHealthResponse.FromString, + ) + + +class IndexCoordServicer(object): + """Missing associated documentation comment in .proto file.""" + + def GetComponentStates(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetStatisticsChannel(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def CreateIndex(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def AlterIndex(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetIndexState(self, request, context): + """Deprecated: use DescribeIndex instead + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetSegmentIndexState(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetIndexInfos(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def DropIndex(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def DescribeIndex(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetIndexStatistics(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetIndexBuildProgress(self, request, context): + """Deprecated: use DescribeIndex instead + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ShowConfigurations(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetMetrics(self, request, context): + """https://wiki.lfaidata.foundation/display/MIL/MEP+8+--+Add+metrics+for+proxy + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def CheckHealth(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + +def add_IndexCoordServicer_to_server(servicer, server): + rpc_method_handlers = { + 'GetComponentStates': grpc.unary_unary_rpc_method_handler( + servicer.GetComponentStates, + request_deserializer=milvus__pb2.GetComponentStatesRequest.FromString, + response_serializer=milvus__pb2.ComponentStates.SerializeToString, + ), + 'GetStatisticsChannel': grpc.unary_unary_rpc_method_handler( + servicer.GetStatisticsChannel, + request_deserializer=internal__pb2.GetStatisticsChannelRequest.FromString, + response_serializer=milvus__pb2.StringResponse.SerializeToString, + ), + 'CreateIndex': grpc.unary_unary_rpc_method_handler( + servicer.CreateIndex, + request_deserializer=index__coord__pb2.CreateIndexRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'AlterIndex': grpc.unary_unary_rpc_method_handler( + servicer.AlterIndex, + request_deserializer=index__coord__pb2.AlterIndexRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'GetIndexState': grpc.unary_unary_rpc_method_handler( + servicer.GetIndexState, + request_deserializer=index__coord__pb2.GetIndexStateRequest.FromString, + response_serializer=index__coord__pb2.GetIndexStateResponse.SerializeToString, + ), + 'GetSegmentIndexState': grpc.unary_unary_rpc_method_handler( + servicer.GetSegmentIndexState, + request_deserializer=index__coord__pb2.GetSegmentIndexStateRequest.FromString, + response_serializer=index__coord__pb2.GetSegmentIndexStateResponse.SerializeToString, + ), + 'GetIndexInfos': grpc.unary_unary_rpc_method_handler( + servicer.GetIndexInfos, + request_deserializer=index__coord__pb2.GetIndexInfoRequest.FromString, + response_serializer=index__coord__pb2.GetIndexInfoResponse.SerializeToString, + ), + 'DropIndex': grpc.unary_unary_rpc_method_handler( + servicer.DropIndex, + request_deserializer=index__coord__pb2.DropIndexRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'DescribeIndex': grpc.unary_unary_rpc_method_handler( + servicer.DescribeIndex, + request_deserializer=index__coord__pb2.DescribeIndexRequest.FromString, + response_serializer=index__coord__pb2.DescribeIndexResponse.SerializeToString, + ), + 'GetIndexStatistics': grpc.unary_unary_rpc_method_handler( + servicer.GetIndexStatistics, + request_deserializer=index__coord__pb2.GetIndexStatisticsRequest.FromString, + response_serializer=index__coord__pb2.GetIndexStatisticsResponse.SerializeToString, + ), + 'GetIndexBuildProgress': grpc.unary_unary_rpc_method_handler( + servicer.GetIndexBuildProgress, + request_deserializer=index__coord__pb2.GetIndexBuildProgressRequest.FromString, + response_serializer=index__coord__pb2.GetIndexBuildProgressResponse.SerializeToString, + ), + 'ShowConfigurations': grpc.unary_unary_rpc_method_handler( + servicer.ShowConfigurations, + request_deserializer=internal__pb2.ShowConfigurationsRequest.FromString, + response_serializer=internal__pb2.ShowConfigurationsResponse.SerializeToString, + ), + 'GetMetrics': grpc.unary_unary_rpc_method_handler( + servicer.GetMetrics, + request_deserializer=milvus__pb2.GetMetricsRequest.FromString, + response_serializer=milvus__pb2.GetMetricsResponse.SerializeToString, + ), + 'CheckHealth': grpc.unary_unary_rpc_method_handler( + servicer.CheckHealth, + request_deserializer=milvus__pb2.CheckHealthRequest.FromString, + response_serializer=milvus__pb2.CheckHealthResponse.SerializeToString, + ), + } + generic_handler = grpc.method_handlers_generic_handler( + 'milvus.proto.index.IndexCoord', rpc_method_handlers) + server.add_generic_rpc_handlers((generic_handler,)) + + + # This class is part of an EXPERIMENTAL API. +class IndexCoord(object): + """Missing associated documentation comment in .proto file.""" + + @staticmethod + def GetComponentStates(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.index.IndexCoord/GetComponentStates', + milvus__pb2.GetComponentStatesRequest.SerializeToString, + milvus__pb2.ComponentStates.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetStatisticsChannel(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.index.IndexCoord/GetStatisticsChannel', + internal__pb2.GetStatisticsChannelRequest.SerializeToString, + milvus__pb2.StringResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def CreateIndex(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.index.IndexCoord/CreateIndex', + index__coord__pb2.CreateIndexRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def AlterIndex(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.index.IndexCoord/AlterIndex', + index__coord__pb2.AlterIndexRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetIndexState(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.index.IndexCoord/GetIndexState', + index__coord__pb2.GetIndexStateRequest.SerializeToString, + index__coord__pb2.GetIndexStateResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetSegmentIndexState(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.index.IndexCoord/GetSegmentIndexState', + index__coord__pb2.GetSegmentIndexStateRequest.SerializeToString, + index__coord__pb2.GetSegmentIndexStateResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetIndexInfos(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.index.IndexCoord/GetIndexInfos', + index__coord__pb2.GetIndexInfoRequest.SerializeToString, + index__coord__pb2.GetIndexInfoResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def DropIndex(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.index.IndexCoord/DropIndex', + index__coord__pb2.DropIndexRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def DescribeIndex(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.index.IndexCoord/DescribeIndex', + index__coord__pb2.DescribeIndexRequest.SerializeToString, + index__coord__pb2.DescribeIndexResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetIndexStatistics(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.index.IndexCoord/GetIndexStatistics', + index__coord__pb2.GetIndexStatisticsRequest.SerializeToString, + index__coord__pb2.GetIndexStatisticsResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetIndexBuildProgress(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.index.IndexCoord/GetIndexBuildProgress', + index__coord__pb2.GetIndexBuildProgressRequest.SerializeToString, + index__coord__pb2.GetIndexBuildProgressResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def ShowConfigurations(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.index.IndexCoord/ShowConfigurations', + internal__pb2.ShowConfigurationsRequest.SerializeToString, + internal__pb2.ShowConfigurationsResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetMetrics(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.index.IndexCoord/GetMetrics', + milvus__pb2.GetMetricsRequest.SerializeToString, + milvus__pb2.GetMetricsResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def CheckHealth(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.index.IndexCoord/CheckHealth', + milvus__pb2.CheckHealthRequest.SerializeToString, + milvus__pb2.CheckHealthResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + +class IndexNodeStub(object): + """Missing associated documentation comment in .proto file.""" + + def __init__(self, channel): + """Constructor. + + Args: + channel: A grpc.Channel. + """ + self.GetComponentStates = channel.unary_unary( + '/milvus.proto.index.IndexNode/GetComponentStates', + request_serializer=milvus__pb2.GetComponentStatesRequest.SerializeToString, + response_deserializer=milvus__pb2.ComponentStates.FromString, + ) + self.GetStatisticsChannel = channel.unary_unary( + '/milvus.proto.index.IndexNode/GetStatisticsChannel', + request_serializer=internal__pb2.GetStatisticsChannelRequest.SerializeToString, + response_deserializer=milvus__pb2.StringResponse.FromString, + ) + self.CreateJob = channel.unary_unary( + '/milvus.proto.index.IndexNode/CreateJob', + request_serializer=index__coord__pb2.CreateJobRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.QueryJobs = channel.unary_unary( + '/milvus.proto.index.IndexNode/QueryJobs', + request_serializer=index__coord__pb2.QueryJobsRequest.SerializeToString, + response_deserializer=index__coord__pb2.QueryJobsResponse.FromString, + ) + self.DropJobs = channel.unary_unary( + '/milvus.proto.index.IndexNode/DropJobs', + request_serializer=index__coord__pb2.DropJobsRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.GetJobStats = channel.unary_unary( + '/milvus.proto.index.IndexNode/GetJobStats', + request_serializer=index__coord__pb2.GetJobStatsRequest.SerializeToString, + response_deserializer=index__coord__pb2.GetJobStatsResponse.FromString, + ) + self.ShowConfigurations = channel.unary_unary( + '/milvus.proto.index.IndexNode/ShowConfigurations', + request_serializer=internal__pb2.ShowConfigurationsRequest.SerializeToString, + response_deserializer=internal__pb2.ShowConfigurationsResponse.FromString, + ) + self.GetMetrics = channel.unary_unary( + '/milvus.proto.index.IndexNode/GetMetrics', + request_serializer=milvus__pb2.GetMetricsRequest.SerializeToString, + response_deserializer=milvus__pb2.GetMetricsResponse.FromString, + ) + + +class IndexNodeServicer(object): + """Missing associated documentation comment in .proto file.""" + + def GetComponentStates(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetStatisticsChannel(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def CreateJob(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def QueryJobs(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def DropJobs(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetJobStats(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ShowConfigurations(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetMetrics(self, request, context): + """https://wiki.lfaidata.foundation/display/MIL/MEP+8+--+Add+metrics+for+proxy + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + +def add_IndexNodeServicer_to_server(servicer, server): + rpc_method_handlers = { + 'GetComponentStates': grpc.unary_unary_rpc_method_handler( + servicer.GetComponentStates, + request_deserializer=milvus__pb2.GetComponentStatesRequest.FromString, + response_serializer=milvus__pb2.ComponentStates.SerializeToString, + ), + 'GetStatisticsChannel': grpc.unary_unary_rpc_method_handler( + servicer.GetStatisticsChannel, + request_deserializer=internal__pb2.GetStatisticsChannelRequest.FromString, + response_serializer=milvus__pb2.StringResponse.SerializeToString, + ), + 'CreateJob': grpc.unary_unary_rpc_method_handler( + servicer.CreateJob, + request_deserializer=index__coord__pb2.CreateJobRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'QueryJobs': grpc.unary_unary_rpc_method_handler( + servicer.QueryJobs, + request_deserializer=index__coord__pb2.QueryJobsRequest.FromString, + response_serializer=index__coord__pb2.QueryJobsResponse.SerializeToString, + ), + 'DropJobs': grpc.unary_unary_rpc_method_handler( + servicer.DropJobs, + request_deserializer=index__coord__pb2.DropJobsRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'GetJobStats': grpc.unary_unary_rpc_method_handler( + servicer.GetJobStats, + request_deserializer=index__coord__pb2.GetJobStatsRequest.FromString, + response_serializer=index__coord__pb2.GetJobStatsResponse.SerializeToString, + ), + 'ShowConfigurations': grpc.unary_unary_rpc_method_handler( + servicer.ShowConfigurations, + request_deserializer=internal__pb2.ShowConfigurationsRequest.FromString, + response_serializer=internal__pb2.ShowConfigurationsResponse.SerializeToString, + ), + 'GetMetrics': grpc.unary_unary_rpc_method_handler( + servicer.GetMetrics, + request_deserializer=milvus__pb2.GetMetricsRequest.FromString, + response_serializer=milvus__pb2.GetMetricsResponse.SerializeToString, + ), + } + generic_handler = grpc.method_handlers_generic_handler( + 'milvus.proto.index.IndexNode', rpc_method_handlers) + server.add_generic_rpc_handlers((generic_handler,)) + + + # This class is part of an EXPERIMENTAL API. +class IndexNode(object): + """Missing associated documentation comment in .proto file.""" + + @staticmethod + def GetComponentStates(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.index.IndexNode/GetComponentStates', + milvus__pb2.GetComponentStatesRequest.SerializeToString, + milvus__pb2.ComponentStates.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetStatisticsChannel(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.index.IndexNode/GetStatisticsChannel', + internal__pb2.GetStatisticsChannelRequest.SerializeToString, + milvus__pb2.StringResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def CreateJob(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.index.IndexNode/CreateJob', + index__coord__pb2.CreateJobRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def QueryJobs(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.index.IndexNode/QueryJobs', + index__coord__pb2.QueryJobsRequest.SerializeToString, + index__coord__pb2.QueryJobsResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def DropJobs(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.index.IndexNode/DropJobs', + index__coord__pb2.DropJobsRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetJobStats(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.index.IndexNode/GetJobStats', + index__coord__pb2.GetJobStatsRequest.SerializeToString, + index__coord__pb2.GetJobStatsResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def ShowConfigurations(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.index.IndexNode/ShowConfigurations', + internal__pb2.ShowConfigurationsRequest.SerializeToString, + internal__pb2.ShowConfigurationsResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetMetrics(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.index.IndexNode/GetMetrics', + milvus__pb2.GetMetricsRequest.SerializeToString, + milvus__pb2.GetMetricsResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) diff --git a/milvus_connector/protocol/internal_pb2.py b/milvus_connector/protocol/internal_pb2.py new file mode 100644 index 0000000..4e752b1 --- /dev/null +++ b/milvus_connector/protocol/internal_pb2.py @@ -0,0 +1,111 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: internal.proto +# Protobuf Python Version: 4.25.1 +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from . import common_pb2 as common__pb2 +from . import schema_pb2 as schema__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x0einternal.proto\x12\x15milvus.proto.internal\x1a\x0c\x63ommon.proto\x1a\x0cschema.proto\"\x1b\n\x19GetTimeTickChannelRequest\"\x1d\n\x1bGetStatisticsChannelRequest\"\x15\n\x13GetDdChannelRequest\"G\n\x08NodeInfo\x12-\n\x07\x61\x64\x64ress\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.Address\x12\x0c\n\x04role\x18\x02 \x01(\t\"U\n\nInitParams\x12\x0e\n\x06nodeID\x18\x01 \x01(\x03\x12\x37\n\x0cstart_params\x18\x02 \x03(\x0b\x32!.milvus.proto.common.KeyValuePair\"I\n\nStringList\x12\x0e\n\x06values\x18\x01 \x03(\t\x12+\n\x06status\x18\x02 \x01(\x0b\x32\x1b.milvus.proto.common.Status\"\xce\x01\n\x14GetStatisticsRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x0c\n\x04\x64\x62ID\x18\x02 \x01(\x03\x12\x14\n\x0c\x63ollectionID\x18\x03 \x01(\x03\x12\x14\n\x0cpartitionIDs\x18\x04 \x03(\x03\x12\x18\n\x10travel_timestamp\x18\x05 \x01(\x04\x12\x1b\n\x13guarantee_timestamp\x18\x06 \x01(\x04\x12\x19\n\x11timeout_timestamp\x18\x07 \x01(\x04\"\xa2\x01\n\x15GetStatisticsResponse\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12+\n\x06status\x18\x02 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\x30\n\x05stats\x18\x03 \x03(\x0b\x32!.milvus.proto.common.KeyValuePair\"y\n\x12\x43reateAliasRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x0f\n\x07\x64\x62_name\x18\x02 \x01(\t\x12\x17\n\x0f\x63ollection_name\x18\x03 \x01(\t\x12\r\n\x05\x61lias\x18\x04 \x01(\t\"^\n\x10\x44ropAliasRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x0f\n\x07\x64\x62_name\x18\x02 \x01(\t\x12\r\n\x05\x61lias\x18\x03 \x01(\t\"x\n\x11\x41lterAliasRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x0f\n\x07\x64\x62_name\x18\x02 \x01(\t\x12\x17\n\x0f\x63ollection_name\x18\x03 \x01(\t\x12\r\n\x05\x61lias\x18\x04 \x01(\t\"\xec\x01\n\x12\x43reateIndexRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x0f\n\x07\x64\x62_name\x18\x02 \x01(\t\x12\x17\n\x0f\x63ollection_name\x18\x03 \x01(\t\x12\x12\n\nfield_name\x18\x04 \x01(\t\x12\x0c\n\x04\x64\x62ID\x18\x05 \x01(\x03\x12\x14\n\x0c\x63ollectionID\x18\x06 \x01(\x03\x12\x0f\n\x07\x66ieldID\x18\x07 \x01(\x03\x12\x37\n\x0c\x65xtra_params\x18\x08 \x03(\x0b\x32!.milvus.proto.common.KeyValuePair\"\xbb\x03\n\rSearchRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\r\n\x05reqID\x18\x02 \x01(\x03\x12\x0c\n\x04\x64\x62ID\x18\x03 \x01(\x03\x12\x14\n\x0c\x63ollectionID\x18\x04 \x01(\x03\x12\x14\n\x0cpartitionIDs\x18\x05 \x03(\x03\x12\x0b\n\x03\x64sl\x18\x06 \x01(\t\x12\x19\n\x11placeholder_group\x18\x07 \x01(\x0c\x12.\n\x08\x64sl_type\x18\x08 \x01(\x0e\x32\x1c.milvus.proto.common.DslType\x12\x1c\n\x14serialized_expr_plan\x18\t \x01(\x0c\x12\x18\n\x10output_fields_id\x18\n \x03(\x03\x12\x16\n\x0emvcc_timestamp\x18\x0b \x01(\x04\x12\x1b\n\x13guarantee_timestamp\x18\x0c \x01(\x04\x12\x19\n\x11timeout_timestamp\x18\r \x01(\x04\x12\n\n\x02nq\x18\x0e \x01(\x03\x12\x0c\n\x04topk\x18\x0f \x01(\x03\x12\x12\n\nmetricType\x18\x10 \x01(\t\x12\x15\n\rignoreGrowing\x18\x11 \x01(\x08\x12\x10\n\x08username\x18\x12 \x01(\t\"\x8e\x02\n\x13HybridSearchRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\r\n\x05reqID\x18\x02 \x01(\x03\x12\x0c\n\x04\x64\x62ID\x18\x03 \x01(\x03\x12\x14\n\x0c\x63ollectionID\x18\x04 \x01(\x03\x12\x14\n\x0cpartitionIDs\x18\x05 \x03(\x03\x12\x32\n\x04reqs\x18\x06 \x03(\x0b\x32$.milvus.proto.internal.SearchRequest\x12\x16\n\x0emvcc_timestamp\x18\x0b \x01(\x04\x12\x1b\n\x13guarantee_timestamp\x18\x0c \x01(\x04\x12\x19\n\x11timeout_timestamp\x18\r \x01(\x04\"\xb8\x04\n\rSearchResults\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12+\n\x06status\x18\x02 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\r\n\x05reqID\x18\x03 \x01(\x03\x12\x13\n\x0bmetric_type\x18\x04 \x01(\t\x12\x13\n\x0bnum_queries\x18\x05 \x01(\x03\x12\r\n\x05top_k\x18\x06 \x01(\x03\x12\"\n\x1asealed_segmentIDs_searched\x18\x07 \x03(\x03\x12\x1b\n\x13\x63hannelIDs_searched\x18\x08 \x03(\t\x12 \n\x18global_sealed_segmentIDs\x18\t \x03(\x03\x12\x13\n\x0bsliced_blob\x18\n \x01(\x0c\x12\x18\n\x10sliced_num_count\x18\x0b \x01(\x03\x12\x15\n\rsliced_offset\x18\x0c \x01(\x03\x12?\n\x0f\x63ostAggregation\x18\r \x01(\x0b\x32&.milvus.proto.internal.CostAggregation\x12M\n\rchannels_mvcc\x18\x0e \x03(\x0b\x32\x36.milvus.proto.internal.SearchResults.ChannelsMvccEntry\x12\x18\n\x10\x61ll_search_count\x18\x0f \x01(\x03\x1a\x33\n\x11\x43hannelsMvccEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\x04:\x02\x38\x01\"M\n\x0f\x43ostAggregation\x12\x14\n\x0cresponseTime\x18\x01 \x01(\x03\x12\x13\n\x0bserviceTime\x18\x02 \x01(\x03\x12\x0f\n\x07totalNQ\x18\x03 \x01(\x03\"\x9f\x03\n\x0fRetrieveRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\r\n\x05reqID\x18\x02 \x01(\x03\x12\x0c\n\x04\x64\x62ID\x18\x03 \x01(\x03\x12\x14\n\x0c\x63ollectionID\x18\x04 \x01(\x03\x12\x14\n\x0cpartitionIDs\x18\x05 \x03(\x03\x12\x1c\n\x14serialized_expr_plan\x18\x06 \x01(\x0c\x12\x18\n\x10output_fields_id\x18\x07 \x03(\x03\x12\x16\n\x0emvcc_timestamp\x18\x08 \x01(\x04\x12\x1b\n\x13guarantee_timestamp\x18\t \x01(\x04\x12\x19\n\x11timeout_timestamp\x18\n \x01(\x04\x12\r\n\x05limit\x18\x0b \x01(\x03\x12\x15\n\rignoreGrowing\x18\x0c \x01(\x08\x12\x10\n\x08is_count\x18\r \x01(\x08\x12\'\n\x1fiteration_extension_reduce_rate\x18\x0e \x01(\x03\x12\x10\n\x08username\x18\x0f \x01(\t\x12\x1c\n\x14reduce_stop_for_best\x18\x10 \x01(\x08\"\x97\x03\n\x0fRetrieveResults\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12+\n\x06status\x18\x02 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\r\n\x05reqID\x18\x03 \x01(\x03\x12%\n\x03ids\x18\x04 \x01(\x0b\x32\x18.milvus.proto.schema.IDs\x12\x33\n\x0b\x66ields_data\x18\x05 \x03(\x0b\x32\x1e.milvus.proto.schema.FieldData\x12#\n\x1bsealed_segmentIDs_retrieved\x18\x06 \x03(\x03\x12\x1c\n\x14\x63hannelIDs_retrieved\x18\x07 \x03(\t\x12 \n\x18global_sealed_segmentIDs\x18\x08 \x03(\x03\x12?\n\x0f\x63ostAggregation\x18\r \x01(\x0b\x32&.milvus.proto.internal.CostAggregation\x12\x1a\n\x12\x61ll_retrieve_count\x18\x0e \x01(\x03\"\xbc\x01\n\tLoadIndex\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x11\n\tsegmentID\x18\x02 \x01(\x03\x12\x11\n\tfieldName\x18\x03 \x01(\t\x12\x0f\n\x07\x66ieldID\x18\x04 \x01(\x03\x12\x13\n\x0bindex_paths\x18\x05 \x03(\t\x12\x37\n\x0cindex_params\x18\x06 \x03(\x0b\x32!.milvus.proto.common.KeyValuePair\"c\n\nIndexStats\x12\x37\n\x0cindex_params\x18\x01 \x03(\x0b\x32!.milvus.proto.common.KeyValuePair\x12\x1c\n\x14num_related_segments\x18\x02 \x01(\x03\"k\n\nFieldStats\x12\x14\n\x0c\x63ollectionID\x18\x01 \x01(\x03\x12\x0f\n\x07\x66ieldID\x18\x02 \x01(\x03\x12\x36\n\x0bindex_stats\x18\x03 \x03(\x0b\x32!.milvus.proto.internal.IndexStats\"c\n\x0cSegmentStats\x12\x11\n\tsegmentID\x18\x01 \x01(\x03\x12\x13\n\x0bmemory_size\x18\x02 \x01(\x03\x12\x10\n\x08num_rows\x18\x03 \x01(\x03\x12\x19\n\x11recently_modified\x18\x04 \x01(\x08\"\x85\x01\n\x12\x43hannelTimeTickMsg\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x14\n\x0c\x63hannelNames\x18\x02 \x03(\t\x12\x12\n\ntimestamps\x18\x03 \x03(\x04\x12\x19\n\x11\x64\x65\x66\x61ult_timestamp\x18\x04 \x01(\x04\"y\n\x0e\x43redentialInfo\x12\x10\n\x08username\x18\x01 \x01(\t\x12\x1a\n\x12\x65ncrypted_password\x18\x02 \x01(\t\x12\x0e\n\x06tenant\x18\x03 \x01(\t\x12\x10\n\x08is_super\x18\x04 \x01(\x08\x12\x17\n\x0fsha256_password\x18\x05 \x01(\t\"?\n\x11ListPolicyRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\"k\n\x12ListPolicyResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\x14\n\x0cpolicy_infos\x18\x02 \x03(\t\x12\x12\n\nuser_roles\x18\x03 \x03(\t\"X\n\x19ShowConfigurationsRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x0f\n\x07pattern\x18\x02 \x01(\t\"\x83\x01\n\x1aShowConfigurationsResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\x38\n\rconfiguations\x18\x02 \x03(\x0b\x32!.milvus.proto.common.KeyValuePair\">\n\x04Rate\x12+\n\x02rt\x18\x01 \x01(\x0e\x32\x1f.milvus.proto.internal.RateType\x12\t\n\x01r\x18\x02 \x01(\x01\"\'\n\nImportFile\x12\n\n\x02id\x18\x01 \x01(\x03\x12\r\n\x05paths\x18\x02 \x03(\t\"\x85\x02\n\x15ImportRequestInternal\x12\x0c\n\x04\x64\x62ID\x18\x01 \x01(\x03\x12\x14\n\x0c\x63ollectionID\x18\x02 \x01(\x03\x12\x14\n\x0cpartitionIDs\x18\x03 \x03(\x03\x12\x15\n\rchannel_names\x18\x04 \x03(\t\x12\x35\n\x06schema\x18\x05 \x01(\x0b\x32%.milvus.proto.schema.CollectionSchema\x12\x30\n\x05\x66iles\x18\x06 \x03(\x0b\x32!.milvus.proto.internal.ImportFile\x12\x32\n\x07options\x18\x07 \x03(\x0b\x32!.milvus.proto.common.KeyValuePair\"\xb7\x01\n\rImportRequest\x12\x0f\n\x07\x64\x62_name\x18\x01 \x01(\t\x12\x17\n\x0f\x63ollection_name\x18\x02 \x01(\t\x12\x16\n\x0epartition_name\x18\x03 \x01(\t\x12\x30\n\x05\x66iles\x18\x04 \x03(\x0b\x32!.milvus.proto.internal.ImportFile\x12\x32\n\x07options\x18\x05 \x03(\x0b\x32!.milvus.proto.common.KeyValuePair\"L\n\x0eImportResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\r\n\x05jobID\x18\x02 \x01(\t\":\n\x18GetImportProgressRequest\x12\x0f\n\x07\x64\x62_name\x18\x01 \x01(\t\x12\r\n\x05jobID\x18\x02 \x01(\t\"\xa0\x01\n\x19GetImportProgressResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\x34\n\x05state\x18\x02 \x01(\x0e\x32%.milvus.proto.internal.ImportJobState\x12\x0e\n\x06reason\x18\x03 \x01(\t\x12\x10\n\x08progress\x18\x04 \x01(\x03\"@\n\x1aListImportsRequestInternal\x12\x0c\n\x04\x64\x62ID\x18\x01 \x01(\x03\x12\x14\n\x0c\x63ollectionID\x18\x02 \x01(\x03\">\n\x12ListImportsRequest\x12\x0f\n\x07\x64\x62_name\x18\x01 \x01(\t\x12\x17\n\x0f\x63ollection_name\x18\x02 \x01(\t\"\xae\x01\n\x13ListImportsResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\x0e\n\x06jobIDs\x18\x02 \x03(\t\x12\x35\n\x06states\x18\x03 \x03(\x0e\x32%.milvus.proto.internal.ImportJobState\x12\x0f\n\x07reasons\x18\x04 \x03(\t\x12\x12\n\nprogresses\x18\x05 \x03(\x03*\xb9\x01\n\x08RateType\x12\x11\n\rDDLCollection\x10\x00\x12\x10\n\x0c\x44\x44LPartition\x10\x01\x12\x0c\n\x08\x44\x44LIndex\x10\x02\x12\x0c\n\x08\x44\x44LFlush\x10\x03\x12\x11\n\rDDLCompaction\x10\x04\x12\r\n\tDMLInsert\x10\x05\x12\r\n\tDMLDelete\x10\x06\x12\x0f\n\x0b\x44MLBulkLoad\x10\x07\x12\r\n\tDQLSearch\x10\x08\x12\x0c\n\x08\x44QLQuery\x10\t\x12\r\n\tDMLUpsert\x10\n*c\n\x0eImportJobState\x12\x08\n\x04None\x10\x00\x12\x0b\n\x07Pending\x10\x01\x12\x10\n\x0cPreImporting\x10\x02\x12\r\n\tImporting\x10\x03\x12\n\n\x06\x46\x61iled\x10\x04\x12\r\n\tCompleted\x10\x05\x42\x37Z5github.com/milvus-io/milvus/internal/proto/internalpbb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'internal_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + _globals['DESCRIPTOR']._options = None + _globals['DESCRIPTOR']._serialized_options = b'Z5github.com/milvus-io/milvus/internal/proto/internalpb' + _globals['_SEARCHRESULTS_CHANNELSMVCCENTRY']._options = None + _globals['_SEARCHRESULTS_CHANNELSMVCCENTRY']._serialized_options = b'8\001' + _globals['_RATETYPE']._serialized_start=5861 + _globals['_RATETYPE']._serialized_end=6046 + _globals['_IMPORTJOBSTATE']._serialized_start=6048 + _globals['_IMPORTJOBSTATE']._serialized_end=6147 + _globals['_GETTIMETICKCHANNELREQUEST']._serialized_start=69 + _globals['_GETTIMETICKCHANNELREQUEST']._serialized_end=96 + _globals['_GETSTATISTICSCHANNELREQUEST']._serialized_start=98 + _globals['_GETSTATISTICSCHANNELREQUEST']._serialized_end=127 + _globals['_GETDDCHANNELREQUEST']._serialized_start=129 + _globals['_GETDDCHANNELREQUEST']._serialized_end=150 + _globals['_NODEINFO']._serialized_start=152 + _globals['_NODEINFO']._serialized_end=223 + _globals['_INITPARAMS']._serialized_start=225 + _globals['_INITPARAMS']._serialized_end=310 + _globals['_STRINGLIST']._serialized_start=312 + _globals['_STRINGLIST']._serialized_end=385 + _globals['_GETSTATISTICSREQUEST']._serialized_start=388 + _globals['_GETSTATISTICSREQUEST']._serialized_end=594 + _globals['_GETSTATISTICSRESPONSE']._serialized_start=597 + _globals['_GETSTATISTICSRESPONSE']._serialized_end=759 + _globals['_CREATEALIASREQUEST']._serialized_start=761 + _globals['_CREATEALIASREQUEST']._serialized_end=882 + _globals['_DROPALIASREQUEST']._serialized_start=884 + _globals['_DROPALIASREQUEST']._serialized_end=978 + _globals['_ALTERALIASREQUEST']._serialized_start=980 + _globals['_ALTERALIASREQUEST']._serialized_end=1100 + _globals['_CREATEINDEXREQUEST']._serialized_start=1103 + _globals['_CREATEINDEXREQUEST']._serialized_end=1339 + _globals['_SEARCHREQUEST']._serialized_start=1342 + _globals['_SEARCHREQUEST']._serialized_end=1785 + _globals['_HYBRIDSEARCHREQUEST']._serialized_start=1788 + _globals['_HYBRIDSEARCHREQUEST']._serialized_end=2058 + _globals['_SEARCHRESULTS']._serialized_start=2061 + _globals['_SEARCHRESULTS']._serialized_end=2629 + _globals['_SEARCHRESULTS_CHANNELSMVCCENTRY']._serialized_start=2578 + _globals['_SEARCHRESULTS_CHANNELSMVCCENTRY']._serialized_end=2629 + _globals['_COSTAGGREGATION']._serialized_start=2631 + _globals['_COSTAGGREGATION']._serialized_end=2708 + _globals['_RETRIEVEREQUEST']._serialized_start=2711 + _globals['_RETRIEVEREQUEST']._serialized_end=3126 + _globals['_RETRIEVERESULTS']._serialized_start=3129 + _globals['_RETRIEVERESULTS']._serialized_end=3536 + _globals['_LOADINDEX']._serialized_start=3539 + _globals['_LOADINDEX']._serialized_end=3727 + _globals['_INDEXSTATS']._serialized_start=3729 + _globals['_INDEXSTATS']._serialized_end=3828 + _globals['_FIELDSTATS']._serialized_start=3830 + _globals['_FIELDSTATS']._serialized_end=3937 + _globals['_SEGMENTSTATS']._serialized_start=3939 + _globals['_SEGMENTSTATS']._serialized_end=4038 + _globals['_CHANNELTIMETICKMSG']._serialized_start=4041 + _globals['_CHANNELTIMETICKMSG']._serialized_end=4174 + _globals['_CREDENTIALINFO']._serialized_start=4176 + _globals['_CREDENTIALINFO']._serialized_end=4297 + _globals['_LISTPOLICYREQUEST']._serialized_start=4299 + _globals['_LISTPOLICYREQUEST']._serialized_end=4362 + _globals['_LISTPOLICYRESPONSE']._serialized_start=4364 + _globals['_LISTPOLICYRESPONSE']._serialized_end=4471 + _globals['_SHOWCONFIGURATIONSREQUEST']._serialized_start=4473 + _globals['_SHOWCONFIGURATIONSREQUEST']._serialized_end=4561 + _globals['_SHOWCONFIGURATIONSRESPONSE']._serialized_start=4564 + _globals['_SHOWCONFIGURATIONSRESPONSE']._serialized_end=4695 + _globals['_RATE']._serialized_start=4697 + _globals['_RATE']._serialized_end=4759 + _globals['_IMPORTFILE']._serialized_start=4761 + _globals['_IMPORTFILE']._serialized_end=4800 + _globals['_IMPORTREQUESTINTERNAL']._serialized_start=4803 + _globals['_IMPORTREQUESTINTERNAL']._serialized_end=5064 + _globals['_IMPORTREQUEST']._serialized_start=5067 + _globals['_IMPORTREQUEST']._serialized_end=5250 + _globals['_IMPORTRESPONSE']._serialized_start=5252 + _globals['_IMPORTRESPONSE']._serialized_end=5328 + _globals['_GETIMPORTPROGRESSREQUEST']._serialized_start=5330 + _globals['_GETIMPORTPROGRESSREQUEST']._serialized_end=5388 + _globals['_GETIMPORTPROGRESSRESPONSE']._serialized_start=5391 + _globals['_GETIMPORTPROGRESSRESPONSE']._serialized_end=5551 + _globals['_LISTIMPORTSREQUESTINTERNAL']._serialized_start=5553 + _globals['_LISTIMPORTSREQUESTINTERNAL']._serialized_end=5617 + _globals['_LISTIMPORTSREQUEST']._serialized_start=5619 + _globals['_LISTIMPORTSREQUEST']._serialized_end=5681 + _globals['_LISTIMPORTSRESPONSE']._serialized_start=5684 + _globals['_LISTIMPORTSRESPONSE']._serialized_end=5858 +# @@protoc_insertion_point(module_scope) diff --git a/milvus_connector/protocol/internal_pb2.pyi b/milvus_connector/protocol/internal_pb2.pyi new file mode 100644 index 0000000..0d7c1df --- /dev/null +++ b/milvus_connector/protocol/internal_pb2.pyi @@ -0,0 +1,550 @@ +from . import common_pb2 as _common_pb2 +from . import schema_pb2 as _schema_pb2 +from google.protobuf.internal import containers as _containers +from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Iterable as _Iterable, Mapping as _Mapping, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class RateType(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = () + DDLCollection: _ClassVar[RateType] + DDLPartition: _ClassVar[RateType] + DDLIndex: _ClassVar[RateType] + DDLFlush: _ClassVar[RateType] + DDLCompaction: _ClassVar[RateType] + DMLInsert: _ClassVar[RateType] + DMLDelete: _ClassVar[RateType] + DMLBulkLoad: _ClassVar[RateType] + DQLSearch: _ClassVar[RateType] + DQLQuery: _ClassVar[RateType] + DMLUpsert: _ClassVar[RateType] + +class ImportJobState(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = () + None: _ClassVar[ImportJobState] + Pending: _ClassVar[ImportJobState] + PreImporting: _ClassVar[ImportJobState] + Importing: _ClassVar[ImportJobState] + Failed: _ClassVar[ImportJobState] + Completed: _ClassVar[ImportJobState] +DDLCollection: RateType +DDLPartition: RateType +DDLIndex: RateType +DDLFlush: RateType +DDLCompaction: RateType +DMLInsert: RateType +DMLDelete: RateType +DMLBulkLoad: RateType +DQLSearch: RateType +DQLQuery: RateType +DMLUpsert: RateType +None: ImportJobState +Pending: ImportJobState +PreImporting: ImportJobState +Importing: ImportJobState +Failed: ImportJobState +Completed: ImportJobState + +class GetTimeTickChannelRequest(_message.Message): + __slots__ = () + def __init__(self) -> None: ... + +class GetStatisticsChannelRequest(_message.Message): + __slots__ = () + def __init__(self) -> None: ... + +class GetDdChannelRequest(_message.Message): + __slots__ = () + def __init__(self) -> None: ... + +class NodeInfo(_message.Message): + __slots__ = ("address", "role") + ADDRESS_FIELD_NUMBER: _ClassVar[int] + ROLE_FIELD_NUMBER: _ClassVar[int] + address: _common_pb2.Address + role: str + def __init__(self, address: _Optional[_Union[_common_pb2.Address, _Mapping]] = ..., role: _Optional[str] = ...) -> None: ... + +class InitParams(_message.Message): + __slots__ = ("nodeID", "start_params") + NODEID_FIELD_NUMBER: _ClassVar[int] + START_PARAMS_FIELD_NUMBER: _ClassVar[int] + nodeID: int + start_params: _containers.RepeatedCompositeFieldContainer[_common_pb2.KeyValuePair] + def __init__(self, nodeID: _Optional[int] = ..., start_params: _Optional[_Iterable[_Union[_common_pb2.KeyValuePair, _Mapping]]] = ...) -> None: ... + +class StringList(_message.Message): + __slots__ = ("values", "status") + VALUES_FIELD_NUMBER: _ClassVar[int] + STATUS_FIELD_NUMBER: _ClassVar[int] + values: _containers.RepeatedScalarFieldContainer[str] + status: _common_pb2.Status + def __init__(self, values: _Optional[_Iterable[str]] = ..., status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ...) -> None: ... + +class GetStatisticsRequest(_message.Message): + __slots__ = ("base", "dbID", "collectionID", "partitionIDs", "travel_timestamp", "guarantee_timestamp", "timeout_timestamp") + BASE_FIELD_NUMBER: _ClassVar[int] + DBID_FIELD_NUMBER: _ClassVar[int] + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + PARTITIONIDS_FIELD_NUMBER: _ClassVar[int] + TRAVEL_TIMESTAMP_FIELD_NUMBER: _ClassVar[int] + GUARANTEE_TIMESTAMP_FIELD_NUMBER: _ClassVar[int] + TIMEOUT_TIMESTAMP_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + dbID: int + collectionID: int + partitionIDs: _containers.RepeatedScalarFieldContainer[int] + travel_timestamp: int + guarantee_timestamp: int + timeout_timestamp: int + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., dbID: _Optional[int] = ..., collectionID: _Optional[int] = ..., partitionIDs: _Optional[_Iterable[int]] = ..., travel_timestamp: _Optional[int] = ..., guarantee_timestamp: _Optional[int] = ..., timeout_timestamp: _Optional[int] = ...) -> None: ... + +class GetStatisticsResponse(_message.Message): + __slots__ = ("base", "status", "stats") + BASE_FIELD_NUMBER: _ClassVar[int] + STATUS_FIELD_NUMBER: _ClassVar[int] + STATS_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + status: _common_pb2.Status + stats: _containers.RepeatedCompositeFieldContainer[_common_pb2.KeyValuePair] + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., stats: _Optional[_Iterable[_Union[_common_pb2.KeyValuePair, _Mapping]]] = ...) -> None: ... + +class CreateAliasRequest(_message.Message): + __slots__ = ("base", "db_name", "collection_name", "alias") + BASE_FIELD_NUMBER: _ClassVar[int] + DB_NAME_FIELD_NUMBER: _ClassVar[int] + COLLECTION_NAME_FIELD_NUMBER: _ClassVar[int] + ALIAS_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + db_name: str + collection_name: str + alias: str + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., db_name: _Optional[str] = ..., collection_name: _Optional[str] = ..., alias: _Optional[str] = ...) -> None: ... + +class DropAliasRequest(_message.Message): + __slots__ = ("base", "db_name", "alias") + BASE_FIELD_NUMBER: _ClassVar[int] + DB_NAME_FIELD_NUMBER: _ClassVar[int] + ALIAS_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + db_name: str + alias: str + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., db_name: _Optional[str] = ..., alias: _Optional[str] = ...) -> None: ... + +class AlterAliasRequest(_message.Message): + __slots__ = ("base", "db_name", "collection_name", "alias") + BASE_FIELD_NUMBER: _ClassVar[int] + DB_NAME_FIELD_NUMBER: _ClassVar[int] + COLLECTION_NAME_FIELD_NUMBER: _ClassVar[int] + ALIAS_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + db_name: str + collection_name: str + alias: str + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., db_name: _Optional[str] = ..., collection_name: _Optional[str] = ..., alias: _Optional[str] = ...) -> None: ... + +class CreateIndexRequest(_message.Message): + __slots__ = ("base", "db_name", "collection_name", "field_name", "dbID", "collectionID", "fieldID", "extra_params") + BASE_FIELD_NUMBER: _ClassVar[int] + DB_NAME_FIELD_NUMBER: _ClassVar[int] + COLLECTION_NAME_FIELD_NUMBER: _ClassVar[int] + FIELD_NAME_FIELD_NUMBER: _ClassVar[int] + DBID_FIELD_NUMBER: _ClassVar[int] + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + FIELDID_FIELD_NUMBER: _ClassVar[int] + EXTRA_PARAMS_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + db_name: str + collection_name: str + field_name: str + dbID: int + collectionID: int + fieldID: int + extra_params: _containers.RepeatedCompositeFieldContainer[_common_pb2.KeyValuePair] + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., db_name: _Optional[str] = ..., collection_name: _Optional[str] = ..., field_name: _Optional[str] = ..., dbID: _Optional[int] = ..., collectionID: _Optional[int] = ..., fieldID: _Optional[int] = ..., extra_params: _Optional[_Iterable[_Union[_common_pb2.KeyValuePair, _Mapping]]] = ...) -> None: ... + +class SearchRequest(_message.Message): + __slots__ = ("base", "reqID", "dbID", "collectionID", "partitionIDs", "dsl", "placeholder_group", "dsl_type", "serialized_expr_plan", "output_fields_id", "mvcc_timestamp", "guarantee_timestamp", "timeout_timestamp", "nq", "topk", "metricType", "ignoreGrowing", "username") + BASE_FIELD_NUMBER: _ClassVar[int] + REQID_FIELD_NUMBER: _ClassVar[int] + DBID_FIELD_NUMBER: _ClassVar[int] + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + PARTITIONIDS_FIELD_NUMBER: _ClassVar[int] + DSL_FIELD_NUMBER: _ClassVar[int] + PLACEHOLDER_GROUP_FIELD_NUMBER: _ClassVar[int] + DSL_TYPE_FIELD_NUMBER: _ClassVar[int] + SERIALIZED_EXPR_PLAN_FIELD_NUMBER: _ClassVar[int] + OUTPUT_FIELDS_ID_FIELD_NUMBER: _ClassVar[int] + MVCC_TIMESTAMP_FIELD_NUMBER: _ClassVar[int] + GUARANTEE_TIMESTAMP_FIELD_NUMBER: _ClassVar[int] + TIMEOUT_TIMESTAMP_FIELD_NUMBER: _ClassVar[int] + NQ_FIELD_NUMBER: _ClassVar[int] + TOPK_FIELD_NUMBER: _ClassVar[int] + METRICTYPE_FIELD_NUMBER: _ClassVar[int] + IGNOREGROWING_FIELD_NUMBER: _ClassVar[int] + USERNAME_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + reqID: int + dbID: int + collectionID: int + partitionIDs: _containers.RepeatedScalarFieldContainer[int] + dsl: str + placeholder_group: bytes + dsl_type: _common_pb2.DslType + serialized_expr_plan: bytes + output_fields_id: _containers.RepeatedScalarFieldContainer[int] + mvcc_timestamp: int + guarantee_timestamp: int + timeout_timestamp: int + nq: int + topk: int + metricType: str + ignoreGrowing: bool + username: str + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., reqID: _Optional[int] = ..., dbID: _Optional[int] = ..., collectionID: _Optional[int] = ..., partitionIDs: _Optional[_Iterable[int]] = ..., dsl: _Optional[str] = ..., placeholder_group: _Optional[bytes] = ..., dsl_type: _Optional[_Union[_common_pb2.DslType, str]] = ..., serialized_expr_plan: _Optional[bytes] = ..., output_fields_id: _Optional[_Iterable[int]] = ..., mvcc_timestamp: _Optional[int] = ..., guarantee_timestamp: _Optional[int] = ..., timeout_timestamp: _Optional[int] = ..., nq: _Optional[int] = ..., topk: _Optional[int] = ..., metricType: _Optional[str] = ..., ignoreGrowing: bool = ..., username: _Optional[str] = ...) -> None: ... + +class HybridSearchRequest(_message.Message): + __slots__ = ("base", "reqID", "dbID", "collectionID", "partitionIDs", "reqs", "mvcc_timestamp", "guarantee_timestamp", "timeout_timestamp") + BASE_FIELD_NUMBER: _ClassVar[int] + REQID_FIELD_NUMBER: _ClassVar[int] + DBID_FIELD_NUMBER: _ClassVar[int] + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + PARTITIONIDS_FIELD_NUMBER: _ClassVar[int] + REQS_FIELD_NUMBER: _ClassVar[int] + MVCC_TIMESTAMP_FIELD_NUMBER: _ClassVar[int] + GUARANTEE_TIMESTAMP_FIELD_NUMBER: _ClassVar[int] + TIMEOUT_TIMESTAMP_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + reqID: int + dbID: int + collectionID: int + partitionIDs: _containers.RepeatedScalarFieldContainer[int] + reqs: _containers.RepeatedCompositeFieldContainer[SearchRequest] + mvcc_timestamp: int + guarantee_timestamp: int + timeout_timestamp: int + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., reqID: _Optional[int] = ..., dbID: _Optional[int] = ..., collectionID: _Optional[int] = ..., partitionIDs: _Optional[_Iterable[int]] = ..., reqs: _Optional[_Iterable[_Union[SearchRequest, _Mapping]]] = ..., mvcc_timestamp: _Optional[int] = ..., guarantee_timestamp: _Optional[int] = ..., timeout_timestamp: _Optional[int] = ...) -> None: ... + +class SearchResults(_message.Message): + __slots__ = ("base", "status", "reqID", "metric_type", "num_queries", "top_k", "sealed_segmentIDs_searched", "channelIDs_searched", "global_sealed_segmentIDs", "sliced_blob", "sliced_num_count", "sliced_offset", "costAggregation", "channels_mvcc", "all_search_count") + class ChannelsMvccEntry(_message.Message): + __slots__ = ("key", "value") + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: str + value: int + def __init__(self, key: _Optional[str] = ..., value: _Optional[int] = ...) -> None: ... + BASE_FIELD_NUMBER: _ClassVar[int] + STATUS_FIELD_NUMBER: _ClassVar[int] + REQID_FIELD_NUMBER: _ClassVar[int] + METRIC_TYPE_FIELD_NUMBER: _ClassVar[int] + NUM_QUERIES_FIELD_NUMBER: _ClassVar[int] + TOP_K_FIELD_NUMBER: _ClassVar[int] + SEALED_SEGMENTIDS_SEARCHED_FIELD_NUMBER: _ClassVar[int] + CHANNELIDS_SEARCHED_FIELD_NUMBER: _ClassVar[int] + GLOBAL_SEALED_SEGMENTIDS_FIELD_NUMBER: _ClassVar[int] + SLICED_BLOB_FIELD_NUMBER: _ClassVar[int] + SLICED_NUM_COUNT_FIELD_NUMBER: _ClassVar[int] + SLICED_OFFSET_FIELD_NUMBER: _ClassVar[int] + COSTAGGREGATION_FIELD_NUMBER: _ClassVar[int] + CHANNELS_MVCC_FIELD_NUMBER: _ClassVar[int] + ALL_SEARCH_COUNT_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + status: _common_pb2.Status + reqID: int + metric_type: str + num_queries: int + top_k: int + sealed_segmentIDs_searched: _containers.RepeatedScalarFieldContainer[int] + channelIDs_searched: _containers.RepeatedScalarFieldContainer[str] + global_sealed_segmentIDs: _containers.RepeatedScalarFieldContainer[int] + sliced_blob: bytes + sliced_num_count: int + sliced_offset: int + costAggregation: CostAggregation + channels_mvcc: _containers.ScalarMap[str, int] + all_search_count: int + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., reqID: _Optional[int] = ..., metric_type: _Optional[str] = ..., num_queries: _Optional[int] = ..., top_k: _Optional[int] = ..., sealed_segmentIDs_searched: _Optional[_Iterable[int]] = ..., channelIDs_searched: _Optional[_Iterable[str]] = ..., global_sealed_segmentIDs: _Optional[_Iterable[int]] = ..., sliced_blob: _Optional[bytes] = ..., sliced_num_count: _Optional[int] = ..., sliced_offset: _Optional[int] = ..., costAggregation: _Optional[_Union[CostAggregation, _Mapping]] = ..., channels_mvcc: _Optional[_Mapping[str, int]] = ..., all_search_count: _Optional[int] = ...) -> None: ... + +class CostAggregation(_message.Message): + __slots__ = ("responseTime", "serviceTime", "totalNQ") + RESPONSETIME_FIELD_NUMBER: _ClassVar[int] + SERVICETIME_FIELD_NUMBER: _ClassVar[int] + TOTALNQ_FIELD_NUMBER: _ClassVar[int] + responseTime: int + serviceTime: int + totalNQ: int + def __init__(self, responseTime: _Optional[int] = ..., serviceTime: _Optional[int] = ..., totalNQ: _Optional[int] = ...) -> None: ... + +class RetrieveRequest(_message.Message): + __slots__ = ("base", "reqID", "dbID", "collectionID", "partitionIDs", "serialized_expr_plan", "output_fields_id", "mvcc_timestamp", "guarantee_timestamp", "timeout_timestamp", "limit", "ignoreGrowing", "is_count", "iteration_extension_reduce_rate", "username", "reduce_stop_for_best") + BASE_FIELD_NUMBER: _ClassVar[int] + REQID_FIELD_NUMBER: _ClassVar[int] + DBID_FIELD_NUMBER: _ClassVar[int] + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + PARTITIONIDS_FIELD_NUMBER: _ClassVar[int] + SERIALIZED_EXPR_PLAN_FIELD_NUMBER: _ClassVar[int] + OUTPUT_FIELDS_ID_FIELD_NUMBER: _ClassVar[int] + MVCC_TIMESTAMP_FIELD_NUMBER: _ClassVar[int] + GUARANTEE_TIMESTAMP_FIELD_NUMBER: _ClassVar[int] + TIMEOUT_TIMESTAMP_FIELD_NUMBER: _ClassVar[int] + LIMIT_FIELD_NUMBER: _ClassVar[int] + IGNOREGROWING_FIELD_NUMBER: _ClassVar[int] + IS_COUNT_FIELD_NUMBER: _ClassVar[int] + ITERATION_EXTENSION_REDUCE_RATE_FIELD_NUMBER: _ClassVar[int] + USERNAME_FIELD_NUMBER: _ClassVar[int] + REDUCE_STOP_FOR_BEST_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + reqID: int + dbID: int + collectionID: int + partitionIDs: _containers.RepeatedScalarFieldContainer[int] + serialized_expr_plan: bytes + output_fields_id: _containers.RepeatedScalarFieldContainer[int] + mvcc_timestamp: int + guarantee_timestamp: int + timeout_timestamp: int + limit: int + ignoreGrowing: bool + is_count: bool + iteration_extension_reduce_rate: int + username: str + reduce_stop_for_best: bool + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., reqID: _Optional[int] = ..., dbID: _Optional[int] = ..., collectionID: _Optional[int] = ..., partitionIDs: _Optional[_Iterable[int]] = ..., serialized_expr_plan: _Optional[bytes] = ..., output_fields_id: _Optional[_Iterable[int]] = ..., mvcc_timestamp: _Optional[int] = ..., guarantee_timestamp: _Optional[int] = ..., timeout_timestamp: _Optional[int] = ..., limit: _Optional[int] = ..., ignoreGrowing: bool = ..., is_count: bool = ..., iteration_extension_reduce_rate: _Optional[int] = ..., username: _Optional[str] = ..., reduce_stop_for_best: bool = ...) -> None: ... + +class RetrieveResults(_message.Message): + __slots__ = ("base", "status", "reqID", "ids", "fields_data", "sealed_segmentIDs_retrieved", "channelIDs_retrieved", "global_sealed_segmentIDs", "costAggregation", "all_retrieve_count") + BASE_FIELD_NUMBER: _ClassVar[int] + STATUS_FIELD_NUMBER: _ClassVar[int] + REQID_FIELD_NUMBER: _ClassVar[int] + IDS_FIELD_NUMBER: _ClassVar[int] + FIELDS_DATA_FIELD_NUMBER: _ClassVar[int] + SEALED_SEGMENTIDS_RETRIEVED_FIELD_NUMBER: _ClassVar[int] + CHANNELIDS_RETRIEVED_FIELD_NUMBER: _ClassVar[int] + GLOBAL_SEALED_SEGMENTIDS_FIELD_NUMBER: _ClassVar[int] + COSTAGGREGATION_FIELD_NUMBER: _ClassVar[int] + ALL_RETRIEVE_COUNT_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + status: _common_pb2.Status + reqID: int + ids: _schema_pb2.IDs + fields_data: _containers.RepeatedCompositeFieldContainer[_schema_pb2.FieldData] + sealed_segmentIDs_retrieved: _containers.RepeatedScalarFieldContainer[int] + channelIDs_retrieved: _containers.RepeatedScalarFieldContainer[str] + global_sealed_segmentIDs: _containers.RepeatedScalarFieldContainer[int] + costAggregation: CostAggregation + all_retrieve_count: int + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., reqID: _Optional[int] = ..., ids: _Optional[_Union[_schema_pb2.IDs, _Mapping]] = ..., fields_data: _Optional[_Iterable[_Union[_schema_pb2.FieldData, _Mapping]]] = ..., sealed_segmentIDs_retrieved: _Optional[_Iterable[int]] = ..., channelIDs_retrieved: _Optional[_Iterable[str]] = ..., global_sealed_segmentIDs: _Optional[_Iterable[int]] = ..., costAggregation: _Optional[_Union[CostAggregation, _Mapping]] = ..., all_retrieve_count: _Optional[int] = ...) -> None: ... + +class LoadIndex(_message.Message): + __slots__ = ("base", "segmentID", "fieldName", "fieldID", "index_paths", "index_params") + BASE_FIELD_NUMBER: _ClassVar[int] + SEGMENTID_FIELD_NUMBER: _ClassVar[int] + FIELDNAME_FIELD_NUMBER: _ClassVar[int] + FIELDID_FIELD_NUMBER: _ClassVar[int] + INDEX_PATHS_FIELD_NUMBER: _ClassVar[int] + INDEX_PARAMS_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + segmentID: int + fieldName: str + fieldID: int + index_paths: _containers.RepeatedScalarFieldContainer[str] + index_params: _containers.RepeatedCompositeFieldContainer[_common_pb2.KeyValuePair] + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., segmentID: _Optional[int] = ..., fieldName: _Optional[str] = ..., fieldID: _Optional[int] = ..., index_paths: _Optional[_Iterable[str]] = ..., index_params: _Optional[_Iterable[_Union[_common_pb2.KeyValuePair, _Mapping]]] = ...) -> None: ... + +class IndexStats(_message.Message): + __slots__ = ("index_params", "num_related_segments") + INDEX_PARAMS_FIELD_NUMBER: _ClassVar[int] + NUM_RELATED_SEGMENTS_FIELD_NUMBER: _ClassVar[int] + index_params: _containers.RepeatedCompositeFieldContainer[_common_pb2.KeyValuePair] + num_related_segments: int + def __init__(self, index_params: _Optional[_Iterable[_Union[_common_pb2.KeyValuePair, _Mapping]]] = ..., num_related_segments: _Optional[int] = ...) -> None: ... + +class FieldStats(_message.Message): + __slots__ = ("collectionID", "fieldID", "index_stats") + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + FIELDID_FIELD_NUMBER: _ClassVar[int] + INDEX_STATS_FIELD_NUMBER: _ClassVar[int] + collectionID: int + fieldID: int + index_stats: _containers.RepeatedCompositeFieldContainer[IndexStats] + def __init__(self, collectionID: _Optional[int] = ..., fieldID: _Optional[int] = ..., index_stats: _Optional[_Iterable[_Union[IndexStats, _Mapping]]] = ...) -> None: ... + +class SegmentStats(_message.Message): + __slots__ = ("segmentID", "memory_size", "num_rows", "recently_modified") + SEGMENTID_FIELD_NUMBER: _ClassVar[int] + MEMORY_SIZE_FIELD_NUMBER: _ClassVar[int] + NUM_ROWS_FIELD_NUMBER: _ClassVar[int] + RECENTLY_MODIFIED_FIELD_NUMBER: _ClassVar[int] + segmentID: int + memory_size: int + num_rows: int + recently_modified: bool + def __init__(self, segmentID: _Optional[int] = ..., memory_size: _Optional[int] = ..., num_rows: _Optional[int] = ..., recently_modified: bool = ...) -> None: ... + +class ChannelTimeTickMsg(_message.Message): + __slots__ = ("base", "channelNames", "timestamps", "default_timestamp") + BASE_FIELD_NUMBER: _ClassVar[int] + CHANNELNAMES_FIELD_NUMBER: _ClassVar[int] + TIMESTAMPS_FIELD_NUMBER: _ClassVar[int] + DEFAULT_TIMESTAMP_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + channelNames: _containers.RepeatedScalarFieldContainer[str] + timestamps: _containers.RepeatedScalarFieldContainer[int] + default_timestamp: int + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., channelNames: _Optional[_Iterable[str]] = ..., timestamps: _Optional[_Iterable[int]] = ..., default_timestamp: _Optional[int] = ...) -> None: ... + +class CredentialInfo(_message.Message): + __slots__ = ("username", "encrypted_password", "tenant", "is_super", "sha256_password") + USERNAME_FIELD_NUMBER: _ClassVar[int] + ENCRYPTED_PASSWORD_FIELD_NUMBER: _ClassVar[int] + TENANT_FIELD_NUMBER: _ClassVar[int] + IS_SUPER_FIELD_NUMBER: _ClassVar[int] + SHA256_PASSWORD_FIELD_NUMBER: _ClassVar[int] + username: str + encrypted_password: str + tenant: str + is_super: bool + sha256_password: str + def __init__(self, username: _Optional[str] = ..., encrypted_password: _Optional[str] = ..., tenant: _Optional[str] = ..., is_super: bool = ..., sha256_password: _Optional[str] = ...) -> None: ... + +class ListPolicyRequest(_message.Message): + __slots__ = ("base",) + BASE_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ...) -> None: ... + +class ListPolicyResponse(_message.Message): + __slots__ = ("status", "policy_infos", "user_roles") + STATUS_FIELD_NUMBER: _ClassVar[int] + POLICY_INFOS_FIELD_NUMBER: _ClassVar[int] + USER_ROLES_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + policy_infos: _containers.RepeatedScalarFieldContainer[str] + user_roles: _containers.RepeatedScalarFieldContainer[str] + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., policy_infos: _Optional[_Iterable[str]] = ..., user_roles: _Optional[_Iterable[str]] = ...) -> None: ... + +class ShowConfigurationsRequest(_message.Message): + __slots__ = ("base", "pattern") + BASE_FIELD_NUMBER: _ClassVar[int] + PATTERN_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + pattern: str + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., pattern: _Optional[str] = ...) -> None: ... + +class ShowConfigurationsResponse(_message.Message): + __slots__ = ("status", "configuations") + STATUS_FIELD_NUMBER: _ClassVar[int] + CONFIGUATIONS_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + configuations: _containers.RepeatedCompositeFieldContainer[_common_pb2.KeyValuePair] + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., configuations: _Optional[_Iterable[_Union[_common_pb2.KeyValuePair, _Mapping]]] = ...) -> None: ... + +class Rate(_message.Message): + __slots__ = ("rt", "r") + RT_FIELD_NUMBER: _ClassVar[int] + R_FIELD_NUMBER: _ClassVar[int] + rt: RateType + r: float + def __init__(self, rt: _Optional[_Union[RateType, str]] = ..., r: _Optional[float] = ...) -> None: ... + +class ImportFile(_message.Message): + __slots__ = ("id", "paths") + ID_FIELD_NUMBER: _ClassVar[int] + PATHS_FIELD_NUMBER: _ClassVar[int] + id: int + paths: _containers.RepeatedScalarFieldContainer[str] + def __init__(self, id: _Optional[int] = ..., paths: _Optional[_Iterable[str]] = ...) -> None: ... + +class ImportRequestInternal(_message.Message): + __slots__ = ("dbID", "collectionID", "partitionIDs", "channel_names", "schema", "files", "options") + DBID_FIELD_NUMBER: _ClassVar[int] + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + PARTITIONIDS_FIELD_NUMBER: _ClassVar[int] + CHANNEL_NAMES_FIELD_NUMBER: _ClassVar[int] + SCHEMA_FIELD_NUMBER: _ClassVar[int] + FILES_FIELD_NUMBER: _ClassVar[int] + OPTIONS_FIELD_NUMBER: _ClassVar[int] + dbID: int + collectionID: int + partitionIDs: _containers.RepeatedScalarFieldContainer[int] + channel_names: _containers.RepeatedScalarFieldContainer[str] + schema: _schema_pb2.CollectionSchema + files: _containers.RepeatedCompositeFieldContainer[ImportFile] + options: _containers.RepeatedCompositeFieldContainer[_common_pb2.KeyValuePair] + def __init__(self, dbID: _Optional[int] = ..., collectionID: _Optional[int] = ..., partitionIDs: _Optional[_Iterable[int]] = ..., channel_names: _Optional[_Iterable[str]] = ..., schema: _Optional[_Union[_schema_pb2.CollectionSchema, _Mapping]] = ..., files: _Optional[_Iterable[_Union[ImportFile, _Mapping]]] = ..., options: _Optional[_Iterable[_Union[_common_pb2.KeyValuePair, _Mapping]]] = ...) -> None: ... + +class ImportRequest(_message.Message): + __slots__ = ("db_name", "collection_name", "partition_name", "files", "options") + DB_NAME_FIELD_NUMBER: _ClassVar[int] + COLLECTION_NAME_FIELD_NUMBER: _ClassVar[int] + PARTITION_NAME_FIELD_NUMBER: _ClassVar[int] + FILES_FIELD_NUMBER: _ClassVar[int] + OPTIONS_FIELD_NUMBER: _ClassVar[int] + db_name: str + collection_name: str + partition_name: str + files: _containers.RepeatedCompositeFieldContainer[ImportFile] + options: _containers.RepeatedCompositeFieldContainer[_common_pb2.KeyValuePair] + def __init__(self, db_name: _Optional[str] = ..., collection_name: _Optional[str] = ..., partition_name: _Optional[str] = ..., files: _Optional[_Iterable[_Union[ImportFile, _Mapping]]] = ..., options: _Optional[_Iterable[_Union[_common_pb2.KeyValuePair, _Mapping]]] = ...) -> None: ... + +class ImportResponse(_message.Message): + __slots__ = ("status", "jobID") + STATUS_FIELD_NUMBER: _ClassVar[int] + JOBID_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + jobID: str + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., jobID: _Optional[str] = ...) -> None: ... + +class GetImportProgressRequest(_message.Message): + __slots__ = ("db_name", "jobID") + DB_NAME_FIELD_NUMBER: _ClassVar[int] + JOBID_FIELD_NUMBER: _ClassVar[int] + db_name: str + jobID: str + def __init__(self, db_name: _Optional[str] = ..., jobID: _Optional[str] = ...) -> None: ... + +class GetImportProgressResponse(_message.Message): + __slots__ = ("status", "state", "reason", "progress") + STATUS_FIELD_NUMBER: _ClassVar[int] + STATE_FIELD_NUMBER: _ClassVar[int] + REASON_FIELD_NUMBER: _ClassVar[int] + PROGRESS_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + state: ImportJobState + reason: str + progress: int + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., state: _Optional[_Union[ImportJobState, str]] = ..., reason: _Optional[str] = ..., progress: _Optional[int] = ...) -> None: ... + +class ListImportsRequestInternal(_message.Message): + __slots__ = ("dbID", "collectionID") + DBID_FIELD_NUMBER: _ClassVar[int] + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + dbID: int + collectionID: int + def __init__(self, dbID: _Optional[int] = ..., collectionID: _Optional[int] = ...) -> None: ... + +class ListImportsRequest(_message.Message): + __slots__ = ("db_name", "collection_name") + DB_NAME_FIELD_NUMBER: _ClassVar[int] + COLLECTION_NAME_FIELD_NUMBER: _ClassVar[int] + db_name: str + collection_name: str + def __init__(self, db_name: _Optional[str] = ..., collection_name: _Optional[str] = ...) -> None: ... + +class ListImportsResponse(_message.Message): + __slots__ = ("status", "jobIDs", "states", "reasons", "progresses") + STATUS_FIELD_NUMBER: _ClassVar[int] + JOBIDS_FIELD_NUMBER: _ClassVar[int] + STATES_FIELD_NUMBER: _ClassVar[int] + REASONS_FIELD_NUMBER: _ClassVar[int] + PROGRESSES_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + jobIDs: _containers.RepeatedScalarFieldContainer[str] + states: _containers.RepeatedScalarFieldContainer[ImportJobState] + reasons: _containers.RepeatedScalarFieldContainer[str] + progresses: _containers.RepeatedScalarFieldContainer[int] + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., jobIDs: _Optional[_Iterable[str]] = ..., states: _Optional[_Iterable[_Union[ImportJobState, str]]] = ..., reasons: _Optional[_Iterable[str]] = ..., progresses: _Optional[_Iterable[int]] = ...) -> None: ... diff --git a/milvus_connector/protocol/internal_pb2_grpc.py b/milvus_connector/protocol/internal_pb2_grpc.py new file mode 100644 index 0000000..2daafff --- /dev/null +++ b/milvus_connector/protocol/internal_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/milvus_connector/protocol/milvus_pb2.py b/milvus_connector/protocol/milvus_pb2.py new file mode 100644 index 0000000..0200e10 --- /dev/null +++ b/milvus_connector/protocol/milvus_pb2.py @@ -0,0 +1,535 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: milvus.proto +# Protobuf Python Version: 4.25.1 +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from . import common_pb2 as common__pb2 +from . import rg_pb2 as rg__pb2 +from . import schema_pb2 as schema__pb2 +from . import feder_pb2 as feder__pb2 +from . import msg_pb2 as msg__pb2 +from google.protobuf import descriptor_pb2 as google_dot_protobuf_dot_descriptor__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x0cmilvus.proto\x12\x13milvus.proto.milvus\x1a\x0c\x63ommon.proto\x1a\x08rg.proto\x1a\x0cschema.proto\x1a\x0b\x66\x65\x64\x65r.proto\x1a\tmsg.proto\x1a google/protobuf/descriptor.proto\"\x8d\x01\n\x12\x43reateAliasRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x0f\n\x07\x64\x62_name\x18\x02 \x01(\t\x12\x17\n\x0f\x63ollection_name\x18\x03 \x01(\t\x12\r\n\x05\x61lias\x18\x04 \x01(\t:\x12\xca>\x0f\x08\x01\x10,\x18\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\"r\n\x10\x44ropAliasRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x0f\n\x07\x64\x62_name\x18\x02 \x01(\t\x12\r\n\x05\x61lias\x18\x03 \x01(\t:\x12\xca>\x0f\x08\x01\x10-\x18\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\"x\n\x11\x41lterAliasRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x0f\n\x07\x64\x62_name\x18\x02 \x01(\t\x12\x17\n\x0f\x63ollection_name\x18\x03 \x01(\t\x12\r\n\x05\x61lias\x18\x04 \x01(\t\"v\n\x14\x44\x65scribeAliasRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x0f\n\x07\x64\x62_name\x18\x02 \x01(\t\x12\r\n\x05\x61lias\x18\x03 \x01(\t:\x12\xca>\x0f\x08\x01\x10.\x18\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\"x\n\x15\x44\x65scribeAliasResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\x0f\n\x07\x64\x62_name\x18\x02 \x01(\t\x12\r\n\x05\x61lias\x18\x03 \x01(\t\x12\x12\n\ncollection\x18\x04 \x01(\t\"~\n\x12ListAliasesRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x0f\n\x07\x64\x62_name\x18\x02 \x01(\t\x12\x17\n\x0f\x63ollection_name\x18\x03 \x01(\t:\x12\xca>\x0f\x08\x01\x10/\x18\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\"}\n\x13ListAliasesResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\x0f\n\x07\x64\x62_name\x18\x02 \x01(\t\x12\x17\n\x0f\x63ollection_name\x18\x03 \x01(\t\x12\x0f\n\x07\x61liases\x18\x04 \x03(\t\"\xb8\x02\n\x17\x43reateCollectionRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x0f\n\x07\x64\x62_name\x18\x02 \x01(\t\x12\x17\n\x0f\x63ollection_name\x18\x03 \x01(\t\x12\x0e\n\x06schema\x18\x04 \x01(\x0c\x12\x12\n\nshards_num\x18\x05 \x01(\x05\x12@\n\x11\x63onsistency_level\x18\x06 \x01(\x0e\x32%.milvus.proto.common.ConsistencyLevel\x12\x35\n\nproperties\x18\x07 \x03(\x0b\x32!.milvus.proto.common.KeyValuePair\x12\x16\n\x0enum_partitions\x18\x08 \x01(\x03:\x12\xca>\x0f\x08\x01\x10\x01\x18\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\"\x81\x01\n\x15\x44ropCollectionRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x0f\n\x07\x64\x62_name\x18\x02 \x01(\t\x12\x17\n\x0f\x63ollection_name\x18\x03 \x01(\t:\x12\xca>\x0f\x08\x01\x10\x02\x18\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\"\xcf\x01\n\x16\x41lterCollectionRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x0f\n\x07\x64\x62_name\x18\x02 \x01(\t\x12\x17\n\x0f\x63ollection_name\x18\x03 \x01(\t\x12\x14\n\x0c\x63ollectionID\x18\x04 \x01(\x03\x12\x35\n\nproperties\x18\x05 \x03(\x0b\x32!.milvus.proto.common.KeyValuePair:\x12\xca>\x0f\x08\x01\x10\x01\x18\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\"\x80\x01\n\x14HasCollectionRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x0f\n\x07\x64\x62_name\x18\x02 \x01(\t\x12\x17\n\x0f\x63ollection_name\x18\x03 \x01(\t\x12\x12\n\ntime_stamp\x18\x04 \x01(\x04\"J\n\x0c\x42oolResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\r\n\x05value\x18\x02 \x01(\x08\"L\n\x0eStringResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\r\n\x05value\x18\x02 \x01(\t\"\xaf\x01\n\x19\x44\x65scribeCollectionRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x0f\n\x07\x64\x62_name\x18\x02 \x01(\t\x12\x17\n\x0f\x63ollection_name\x18\x03 \x01(\t\x12\x14\n\x0c\x63ollectionID\x18\x04 \x01(\x03\x12\x12\n\ntime_stamp\x18\x05 \x01(\x04:\x12\xca>\x0f\x08\x01\x10\x03\x18\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\"\xaa\x04\n\x1a\x44\x65scribeCollectionResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\x35\n\x06schema\x18\x02 \x01(\x0b\x32%.milvus.proto.schema.CollectionSchema\x12\x14\n\x0c\x63ollectionID\x18\x03 \x01(\x03\x12\x1d\n\x15virtual_channel_names\x18\x04 \x03(\t\x12\x1e\n\x16physical_channel_names\x18\x05 \x03(\t\x12\x19\n\x11\x63reated_timestamp\x18\x06 \x01(\x04\x12\x1d\n\x15\x63reated_utc_timestamp\x18\x07 \x01(\x04\x12\x12\n\nshards_num\x18\x08 \x01(\x05\x12\x0f\n\x07\x61liases\x18\t \x03(\t\x12\x39\n\x0fstart_positions\x18\n \x03(\x0b\x32 .milvus.proto.common.KeyDataPair\x12@\n\x11\x63onsistency_level\x18\x0b \x01(\x0e\x32%.milvus.proto.common.ConsistencyLevel\x12\x17\n\x0f\x63ollection_name\x18\x0c \x01(\t\x12\x35\n\nproperties\x18\r \x03(\x0b\x32!.milvus.proto.common.KeyValuePair\x12\x0f\n\x07\x64\x62_name\x18\x0e \x01(\t\x12\x16\n\x0enum_partitions\x18\x0f \x01(\x03\"\xb8\x01\n\x15LoadCollectionRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x0f\n\x07\x64\x62_name\x18\x02 \x01(\t\x12\x17\n\x0f\x63ollection_name\x18\x03 \x01(\t\x12\x16\n\x0ereplica_number\x18\x04 \x01(\x05\x12\x17\n\x0fresource_groups\x18\x05 \x03(\t\x12\x0f\n\x07refresh\x18\x06 \x01(\x08:\x07\xca>\x04\x10\x05\x18\x03\"y\n\x18ReleaseCollectionRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x0f\n\x07\x64\x62_name\x18\x02 \x01(\t\x12\x17\n\x0f\x63ollection_name\x18\x03 \x01(\t:\x07\xca>\x04\x10\x06\x18\x03\"\xab\x01\n\x14GetStatisticsRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x0f\n\x07\x64\x62_name\x18\x02 \x01(\t\x12\x17\n\x0f\x63ollection_name\x18\x03 \x01(\t\x12\x17\n\x0fpartition_names\x18\x04 \x03(\t\x12\x1b\n\x13guarantee_timestamp\x18\x05 \x01(\x04:\x07\xca>\x04\x10\n\x18\x03\"v\n\x15GetStatisticsResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\x30\n\x05stats\x18\x02 \x03(\x0b\x32!.milvus.proto.common.KeyValuePair\"\x7f\n\x1eGetCollectionStatisticsRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x0f\n\x07\x64\x62_name\x18\x02 \x01(\t\x12\x17\n\x0f\x63ollection_name\x18\x03 \x01(\t:\x07\xca>\x04\x10\n\x18\x03\"\x80\x01\n\x1fGetCollectionStatisticsResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\x30\n\x05stats\x18\x02 \x03(\x0b\x32!.milvus.proto.common.KeyValuePair\"\xc8\x01\n\x16ShowCollectionsRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x0f\n\x07\x64\x62_name\x18\x02 \x01(\t\x12\x12\n\ntime_stamp\x18\x03 \x01(\x04\x12+\n\x04type\x18\x04 \x01(\x0e\x32\x1d.milvus.proto.milvus.ShowType\x12\x1c\n\x10\x63ollection_names\x18\x05 \x03(\tB\x02\x18\x01:\x12\xca>\x0f\x08\x01\x10\x04\x18\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\"\xf7\x01\n\x17ShowCollectionsResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\x18\n\x10\x63ollection_names\x18\x02 \x03(\t\x12\x16\n\x0e\x63ollection_ids\x18\x03 \x03(\x03\x12\x1a\n\x12\x63reated_timestamps\x18\x04 \x03(\x04\x12\x1e\n\x16\x63reated_utc_timestamps\x18\x05 \x03(\x04\x12 \n\x14inMemory_percentages\x18\x06 \x03(\x03\x42\x02\x18\x01\x12\x1f\n\x17query_service_available\x18\x07 \x03(\x08\"\x8f\x01\n\x16\x43reatePartitionRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x0f\n\x07\x64\x62_name\x18\x02 \x01(\t\x12\x17\n\x0f\x63ollection_name\x18\x03 \x01(\t\x12\x16\n\x0epartition_name\x18\x04 \x01(\t:\x07\xca>\x04\x10\'\x18\x03\"\x8d\x01\n\x14\x44ropPartitionRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x0f\n\x07\x64\x62_name\x18\x02 \x01(\t\x12\x17\n\x0f\x63ollection_name\x18\x03 \x01(\t\x12\x16\n\x0epartition_name\x18\x04 \x01(\t:\x07\xca>\x04\x10(\x18\x03\"\x8c\x01\n\x13HasPartitionRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x0f\n\x07\x64\x62_name\x18\x02 \x01(\t\x12\x17\n\x0f\x63ollection_name\x18\x03 \x01(\t\x12\x16\n\x0epartition_name\x18\x04 \x01(\t:\x07\xca>\x04\x10*\x18\x03\"\xd1\x01\n\x15LoadPartitionsRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x0f\n\x07\x64\x62_name\x18\x02 \x01(\t\x12\x17\n\x0f\x63ollection_name\x18\x03 \x01(\t\x12\x17\n\x0fpartition_names\x18\x04 \x03(\t\x12\x16\n\x0ereplica_number\x18\x05 \x01(\x05\x12\x17\n\x0fresource_groups\x18\x06 \x03(\t\x12\x0f\n\x07refresh\x18\x07 \x01(\x08:\x07\xca>\x04\x10\x05\x18\x03\"\x92\x01\n\x18ReleasePartitionsRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x0f\n\x07\x64\x62_name\x18\x02 \x01(\t\x12\x17\n\x0f\x63ollection_name\x18\x03 \x01(\t\x12\x17\n\x0fpartition_names\x18\x04 \x03(\t:\x07\xca>\x04\x10\x06\x18\x03\"\x8d\x01\n\x1dGetPartitionStatisticsRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x0f\n\x07\x64\x62_name\x18\x02 \x01(\t\x12\x17\n\x0f\x63ollection_name\x18\x03 \x01(\t\x12\x16\n\x0epartition_name\x18\x04 \x01(\t\"\x7f\n\x1eGetPartitionStatisticsResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\x30\n\x05stats\x18\x02 \x03(\x0b\x32!.milvus.proto.common.KeyValuePair\"\xd6\x01\n\x15ShowPartitionsRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x0f\n\x07\x64\x62_name\x18\x02 \x01(\t\x12\x17\n\x0f\x63ollection_name\x18\x03 \x01(\t\x12\x14\n\x0c\x63ollectionID\x18\x04 \x01(\x03\x12\x17\n\x0fpartition_names\x18\x05 \x03(\t\x12/\n\x04type\x18\x06 \x01(\x0e\x32\x1d.milvus.proto.milvus.ShowTypeB\x02\x18\x01:\x07\xca>\x04\x10)\x18\x03\"\xd2\x01\n\x16ShowPartitionsResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\x17\n\x0fpartition_names\x18\x02 \x03(\t\x12\x14\n\x0cpartitionIDs\x18\x03 \x03(\x03\x12\x1a\n\x12\x63reated_timestamps\x18\x04 \x03(\x04\x12\x1e\n\x16\x63reated_utc_timestamps\x18\x05 \x03(\x04\x12 \n\x14inMemory_percentages\x18\x06 \x03(\x03\x42\x02\x18\x01\"m\n\x16\x44\x65scribeSegmentRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x14\n\x0c\x63ollectionID\x18\x02 \x01(\x03\x12\x11\n\tsegmentID\x18\x03 \x01(\x03\"\x8f\x01\n\x17\x44\x65scribeSegmentResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\x0f\n\x07indexID\x18\x02 \x01(\x03\x12\x0f\n\x07\x62uildID\x18\x03 \x01(\x03\x12\x14\n\x0c\x65nable_index\x18\x04 \x01(\x08\x12\x0f\n\x07\x66ieldID\x18\x05 \x01(\x03\"l\n\x13ShowSegmentsRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x14\n\x0c\x63ollectionID\x18\x02 \x01(\x03\x12\x13\n\x0bpartitionID\x18\x03 \x01(\x03\"W\n\x14ShowSegmentsResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\x12\n\nsegmentIDs\x18\x02 \x03(\x03\"\xd4\x01\n\x12\x43reateIndexRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x0f\n\x07\x64\x62_name\x18\x02 \x01(\t\x12\x17\n\x0f\x63ollection_name\x18\x03 \x01(\t\x12\x12\n\nfield_name\x18\x04 \x01(\t\x12\x37\n\x0c\x65xtra_params\x18\x05 \x03(\x0b\x32!.milvus.proto.common.KeyValuePair\x12\x12\n\nindex_name\x18\x06 \x01(\t:\x07\xca>\x04\x10\x0b\x18\x03\"\xbf\x01\n\x11\x41lterIndexRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x0f\n\x07\x64\x62_name\x18\x02 \x01(\t\x12\x17\n\x0f\x63ollection_name\x18\x03 \x01(\t\x12\x12\n\nindex_name\x18\x04 \x01(\t\x12\x37\n\x0c\x65xtra_params\x18\x05 \x03(\x0b\x32!.milvus.proto.common.KeyValuePair:\x07\xca>\x04\x10\x0b\x18\x03\"\xb0\x01\n\x14\x44\x65scribeIndexRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x0f\n\x07\x64\x62_name\x18\x02 \x01(\t\x12\x17\n\x0f\x63ollection_name\x18\x03 \x01(\t\x12\x12\n\nfield_name\x18\x04 \x01(\t\x12\x12\n\nindex_name\x18\x05 \x01(\t\x12\x11\n\ttimestamp\x18\x06 \x01(\x04:\x07\xca>\x04\x10\x0c\x18\x03\"\x95\x02\n\x10IndexDescription\x12\x12\n\nindex_name\x18\x01 \x01(\t\x12\x0f\n\x07indexID\x18\x02 \x01(\x03\x12\x31\n\x06params\x18\x03 \x03(\x0b\x32!.milvus.proto.common.KeyValuePair\x12\x12\n\nfield_name\x18\x04 \x01(\t\x12\x14\n\x0cindexed_rows\x18\x05 \x01(\x03\x12\x12\n\ntotal_rows\x18\x06 \x01(\x03\x12.\n\x05state\x18\x07 \x01(\x0e\x32\x1f.milvus.proto.common.IndexState\x12\x1f\n\x17index_state_fail_reason\x18\x08 \x01(\t\x12\x1a\n\x12pending_index_rows\x18\t \x01(\x03\"\x87\x01\n\x15\x44\x65scribeIndexResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\x41\n\x12index_descriptions\x18\x02 \x03(\x0b\x32%.milvus.proto.milvus.IndexDescription\"\xa5\x01\n\x1cGetIndexBuildProgressRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x0f\n\x07\x64\x62_name\x18\x02 \x01(\t\x12\x17\n\x0f\x63ollection_name\x18\x03 \x01(\t\x12\x12\n\nfield_name\x18\x04 \x01(\t\x12\x12\n\nindex_name\x18\x05 \x01(\t:\x07\xca>\x04\x10\x0c\x18\x03\"v\n\x1dGetIndexBuildProgressResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\x14\n\x0cindexed_rows\x18\x02 \x01(\x03\x12\x12\n\ntotal_rows\x18\x03 \x01(\x03\"\x9d\x01\n\x14GetIndexStateRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x0f\n\x07\x64\x62_name\x18\x02 \x01(\t\x12\x17\n\x0f\x63ollection_name\x18\x03 \x01(\t\x12\x12\n\nfield_name\x18\x04 \x01(\t\x12\x12\n\nindex_name\x18\x05 \x01(\t:\x07\xca>\x04\x10\x0c\x18\x03\"\x89\x01\n\x15GetIndexStateResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12.\n\x05state\x18\x02 \x01(\x0e\x32\x1f.milvus.proto.common.IndexState\x12\x13\n\x0b\x66\x61il_reason\x18\x03 \x01(\t\"\x99\x01\n\x10\x44ropIndexRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x0f\n\x07\x64\x62_name\x18\x02 \x01(\t\x12\x17\n\x0f\x63ollection_name\x18\x03 \x01(\t\x12\x12\n\nfield_name\x18\x04 \x01(\t\x12\x12\n\nindex_name\x18\x05 \x01(\t:\x07\xca>\x04\x10\r\x18\x03\"\xe0\x01\n\rInsertRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x0f\n\x07\x64\x62_name\x18\x02 \x01(\t\x12\x17\n\x0f\x63ollection_name\x18\x03 \x01(\t\x12\x16\n\x0epartition_name\x18\x04 \x01(\t\x12\x33\n\x0b\x66ields_data\x18\x05 \x03(\x0b\x32\x1e.milvus.proto.schema.FieldData\x12\x11\n\thash_keys\x18\x06 \x03(\r\x12\x10\n\x08num_rows\x18\x07 \x01(\r:\x07\xca>\x04\x10\x08\x18\x03\"\xe0\x01\n\rUpsertRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x0f\n\x07\x64\x62_name\x18\x02 \x01(\t\x12\x17\n\x0f\x63ollection_name\x18\x03 \x01(\t\x12\x16\n\x0epartition_name\x18\x04 \x01(\t\x12\x33\n\x0b\x66ields_data\x18\x05 \x03(\x0b\x32\x1e.milvus.proto.schema.FieldData\x12\x11\n\thash_keys\x18\x06 \x03(\r\x12\x10\n\x08num_rows\x18\x07 \x01(\r:\x07\xca>\x04\x10\x19\x18\x03\"\xf0\x01\n\x0eMutationResult\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12%\n\x03IDs\x18\x02 \x01(\x0b\x32\x18.milvus.proto.schema.IDs\x12\x12\n\nsucc_index\x18\x03 \x03(\r\x12\x11\n\terr_index\x18\x04 \x03(\r\x12\x14\n\x0c\x61\x63knowledged\x18\x05 \x01(\x08\x12\x12\n\ninsert_cnt\x18\x06 \x01(\x03\x12\x12\n\ndelete_cnt\x18\x07 \x01(\x03\x12\x12\n\nupsert_cnt\x18\x08 \x01(\x03\x12\x11\n\ttimestamp\x18\t \x01(\x04\"\xe9\x01\n\rDeleteRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x0f\n\x07\x64\x62_name\x18\x02 \x01(\t\x12\x17\n\x0f\x63ollection_name\x18\x03 \x01(\t\x12\x16\n\x0epartition_name\x18\x04 \x01(\t\x12\x0c\n\x04\x65xpr\x18\x05 \x01(\t\x12\x11\n\thash_keys\x18\x06 \x03(\r\x12@\n\x11\x63onsistency_level\x18\x07 \x01(\x0e\x32%.milvus.proto.common.ConsistencyLevel:\x07\xca>\x04\x10\t\x18\x03\"\x93\x04\n\rSearchRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x0f\n\x07\x64\x62_name\x18\x02 \x01(\t\x12\x17\n\x0f\x63ollection_name\x18\x03 \x01(\t\x12\x17\n\x0fpartition_names\x18\x04 \x03(\t\x12\x0b\n\x03\x64sl\x18\x05 \x01(\t\x12\x19\n\x11placeholder_group\x18\x06 \x01(\x0c\x12.\n\x08\x64sl_type\x18\x07 \x01(\x0e\x32\x1c.milvus.proto.common.DslType\x12\x15\n\routput_fields\x18\x08 \x03(\t\x12\x38\n\rsearch_params\x18\t \x03(\x0b\x32!.milvus.proto.common.KeyValuePair\x12\x18\n\x10travel_timestamp\x18\n \x01(\x04\x12\x1b\n\x13guarantee_timestamp\x18\x0b \x01(\x04\x12\n\n\x02nq\x18\x0c \x01(\x03\x12\x1b\n\x13not_return_all_meta\x18\r \x01(\x08\x12@\n\x11\x63onsistency_level\x18\x0e \x01(\x0e\x32%.milvus.proto.common.ConsistencyLevel\x12\x1f\n\x17use_default_consistency\x18\x0f \x01(\x08\x12\x1e\n\x16search_by_primary_keys\x18\x10 \x01(\x08:\x07\xca>\x04\x10\x0e\x18\x03\"5\n\x04Hits\x12\x0b\n\x03IDs\x18\x01 \x03(\x03\x12\x10\n\x08row_data\x18\x02 \x03(\x0c\x12\x0e\n\x06scores\x18\x03 \x03(\x02\"\x8d\x01\n\rSearchResults\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\x36\n\x07results\x18\x02 \x01(\x0b\x32%.milvus.proto.schema.SearchResultData\x12\x17\n\x0f\x63ollection_name\x18\x03 \x01(\t\"\xc9\x03\n\x13HybridSearchRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x0f\n\x07\x64\x62_name\x18\x02 \x01(\t\x12\x17\n\x0f\x63ollection_name\x18\x03 \x01(\t\x12\x17\n\x0fpartition_names\x18\x04 \x03(\t\x12\x34\n\x08requests\x18\x05 \x03(\x0b\x32\".milvus.proto.milvus.SearchRequest\x12\x36\n\x0brank_params\x18\x06 \x03(\x0b\x32!.milvus.proto.common.KeyValuePair\x12\x18\n\x10travel_timestamp\x18\x07 \x01(\x04\x12\x1b\n\x13guarantee_timestamp\x18\x08 \x01(\x04\x12\x1b\n\x13not_return_all_meta\x18\t \x01(\x08\x12\x15\n\routput_fields\x18\n \x03(\t\x12@\n\x11\x63onsistency_level\x18\x0b \x01(\x0e\x32%.milvus.proto.common.ConsistencyLevel\x12\x1f\n\x17use_default_consistency\x18\x0c \x01(\x08:\x07\xca>\x04\x10\x0e\x18\x03\"n\n\x0c\x46lushRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x0f\n\x07\x64\x62_name\x18\x02 \x01(\t\x12\x18\n\x10\x63ollection_names\x18\x03 \x03(\t:\x07\xca>\x04\x10\x0f \x03\"\x9b\x05\n\rFlushResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\x0f\n\x07\x64\x62_name\x18\x02 \x01(\t\x12G\n\x0b\x63oll_segIDs\x18\x03 \x03(\x0b\x32\x32.milvus.proto.milvus.FlushResponse.CollSegIDsEntry\x12R\n\x11\x66lush_coll_segIDs\x18\x04 \x03(\x0b\x32\x37.milvus.proto.milvus.FlushResponse.FlushCollSegIDsEntry\x12N\n\x0f\x63oll_seal_times\x18\x05 \x03(\x0b\x32\x35.milvus.proto.milvus.FlushResponse.CollSealTimesEntry\x12J\n\rcoll_flush_ts\x18\x06 \x03(\x0b\x32\x33.milvus.proto.milvus.FlushResponse.CollFlushTsEntry\x1aQ\n\x0f\x43ollSegIDsEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12-\n\x05value\x18\x02 \x01(\x0b\x32\x1e.milvus.proto.schema.LongArray:\x02\x38\x01\x1aV\n\x14\x46lushCollSegIDsEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12-\n\x05value\x18\x02 \x01(\x0b\x32\x1e.milvus.proto.schema.LongArray:\x02\x38\x01\x1a\x34\n\x12\x43ollSealTimesEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\x03:\x02\x38\x01\x1a\x32\n\x10\x43ollFlushTsEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\x04:\x02\x38\x01\"\x9b\x03\n\x0cQueryRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x0f\n\x07\x64\x62_name\x18\x02 \x01(\t\x12\x17\n\x0f\x63ollection_name\x18\x03 \x01(\t\x12\x0c\n\x04\x65xpr\x18\x04 \x01(\t\x12\x15\n\routput_fields\x18\x05 \x03(\t\x12\x17\n\x0fpartition_names\x18\x06 \x03(\t\x12\x18\n\x10travel_timestamp\x18\x07 \x01(\x04\x12\x1b\n\x13guarantee_timestamp\x18\x08 \x01(\x04\x12\x37\n\x0cquery_params\x18\t \x03(\x0b\x32!.milvus.proto.common.KeyValuePair\x12\x1b\n\x13not_return_all_meta\x18\n \x01(\x08\x12@\n\x11\x63onsistency_level\x18\x0b \x01(\x0e\x32%.milvus.proto.common.ConsistencyLevel\x12\x1f\n\x17use_default_consistency\x18\x0c \x01(\x08:\x07\xca>\x04\x10\x10\x18\x03\"\xa0\x01\n\x0cQueryResults\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\x33\n\x0b\x66ields_data\x18\x02 \x03(\x0b\x32\x1e.milvus.proto.schema.FieldData\x12\x17\n\x0f\x63ollection_name\x18\x03 \x01(\t\x12\x15\n\routput_fields\x18\x04 \x03(\t\"}\n\tVectorIDs\x12\x17\n\x0f\x63ollection_name\x18\x01 \x01(\t\x12\x12\n\nfield_name\x18\x02 \x01(\t\x12*\n\x08id_array\x18\x03 \x01(\x0b\x32\x18.milvus.proto.schema.IDs\x12\x17\n\x0fpartition_names\x18\x04 \x03(\t\"\x83\x01\n\x0cVectorsArray\x12\x32\n\x08id_array\x18\x01 \x01(\x0b\x32\x1e.milvus.proto.milvus.VectorIDsH\x00\x12\x36\n\ndata_array\x18\x02 \x01(\x0b\x32 .milvus.proto.schema.VectorFieldH\x00\x42\x07\n\x05\x61rray\"\xdd\x01\n\x13\x43\x61lcDistanceRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x32\n\x07op_left\x18\x02 \x01(\x0b\x32!.milvus.proto.milvus.VectorsArray\x12\x33\n\x08op_right\x18\x03 \x01(\x0b\x32!.milvus.proto.milvus.VectorsArray\x12\x31\n\x06params\x18\x04 \x03(\x0b\x32!.milvus.proto.common.KeyValuePair\"\xb5\x01\n\x13\x43\x61lcDistanceResults\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\x31\n\x08int_dist\x18\x02 \x01(\x0b\x32\x1d.milvus.proto.schema.IntArrayH\x00\x12\x35\n\nfloat_dist\x18\x03 \x01(\x0b\x32\x1f.milvus.proto.schema.FloatArrayH\x00\x42\x07\n\x05\x61rray\"b\n\x0f\x46lushAllRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x0f\n\x07\x64\x62_name\x18\x02 \x01(\t:\x12\xca>\x0f\x08\x01\x10&\x18\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\"U\n\x10\x46lushAllResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\x14\n\x0c\x66lush_all_ts\x18\x02 \x01(\x04\"\x99\x01\n\x15PersistentSegmentInfo\x12\x11\n\tsegmentID\x18\x01 \x01(\x03\x12\x14\n\x0c\x63ollectionID\x18\x02 \x01(\x03\x12\x13\n\x0bpartitionID\x18\x03 \x01(\x03\x12\x10\n\x08num_rows\x18\x04 \x01(\x03\x12\x30\n\x05state\x18\x05 \x01(\x0e\x32!.milvus.proto.common.SegmentState\"u\n\x1fGetPersistentSegmentInfoRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x0e\n\x06\x64\x62Name\x18\x02 \x01(\t\x12\x16\n\x0e\x63ollectionName\x18\x03 \x01(\t\"\x8a\x01\n GetPersistentSegmentInfoResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\x39\n\x05infos\x18\x02 \x03(\x0b\x32*.milvus.proto.milvus.PersistentSegmentInfo\"\xf0\x01\n\x10QuerySegmentInfo\x12\x11\n\tsegmentID\x18\x01 \x01(\x03\x12\x14\n\x0c\x63ollectionID\x18\x02 \x01(\x03\x12\x13\n\x0bpartitionID\x18\x03 \x01(\x03\x12\x10\n\x08mem_size\x18\x04 \x01(\x03\x12\x10\n\x08num_rows\x18\x05 \x01(\x03\x12\x12\n\nindex_name\x18\x06 \x01(\t\x12\x0f\n\x07indexID\x18\x07 \x01(\x03\x12\x12\n\x06nodeID\x18\x08 \x01(\x03\x42\x02\x18\x01\x12\x30\n\x05state\x18\t \x01(\x0e\x32!.milvus.proto.common.SegmentState\x12\x0f\n\x07nodeIds\x18\n \x03(\x03\"p\n\x1aGetQuerySegmentInfoRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x0e\n\x06\x64\x62Name\x18\x02 \x01(\t\x12\x16\n\x0e\x63ollectionName\x18\x03 \x01(\t\"\x80\x01\n\x1bGetQuerySegmentInfoResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\x34\n\x05infos\x18\x02 \x03(\x0b\x32%.milvus.proto.milvus.QuerySegmentInfo\"$\n\x0c\x44ummyRequest\x12\x14\n\x0crequest_type\x18\x01 \x01(\t\"!\n\rDummyResponse\x12\x10\n\x08response\x18\x01 \x01(\t\"\x15\n\x13RegisterLinkRequest\"r\n\x14RegisterLinkResponse\x12-\n\x07\x61\x64\x64ress\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.Address\x12+\n\x06status\x18\x02 \x01(\x0b\x32\x1b.milvus.proto.common.Status\"P\n\x11GetMetricsRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x0f\n\x07request\x18\x02 \x01(\t\"k\n\x12GetMetricsResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\x10\n\x08response\x18\x02 \x01(\t\x12\x16\n\x0e\x63omponent_name\x18\x03 \x01(\t\"\x98\x01\n\rComponentInfo\x12\x0e\n\x06nodeID\x18\x01 \x01(\x03\x12\x0c\n\x04role\x18\x02 \x01(\t\x12\x32\n\nstate_code\x18\x03 \x01(\x0e\x32\x1e.milvus.proto.common.StateCode\x12\x35\n\nextra_info\x18\x04 \x03(\x0b\x32!.milvus.proto.common.KeyValuePair\"\xb2\x01\n\x0f\x43omponentStates\x12\x31\n\x05state\x18\x01 \x01(\x0b\x32\".milvus.proto.milvus.ComponentInfo\x12?\n\x13subcomponent_states\x18\x02 \x03(\x0b\x32\".milvus.proto.milvus.ComponentInfo\x12+\n\x06status\x18\x03 \x01(\x0b\x32\x1b.milvus.proto.common.Status\"\x1b\n\x19GetComponentStatesRequest\"\xb6\x01\n\x12LoadBalanceRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x12\n\nsrc_nodeID\x18\x02 \x01(\x03\x12\x13\n\x0b\x64st_nodeIDs\x18\x03 \x03(\x03\x12\x19\n\x11sealed_segmentIDs\x18\x04 \x03(\x03\x12\x16\n\x0e\x63ollectionName\x18\x05 \x01(\t\x12\x0f\n\x07\x64\x62_name\x18\x06 \x01(\t:\x07\xca>\x04\x10\x11\x18\x05\"e\n\x17ManualCompactionRequest\x12\x14\n\x0c\x63ollectionID\x18\x01 \x01(\x03\x12\x12\n\ntimetravel\x18\x02 \x01(\x04\x12\x17\n\x0fmajorCompaction\x18\x03 \x01(\x08:\x07\xca>\x04\x10\x07\x18\x01\"z\n\x18ManualCompactionResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\x14\n\x0c\x63ompactionID\x18\x02 \x01(\x03\x12\x1b\n\x13\x63ompactionPlanCount\x18\x03 \x01(\x05\"1\n\x19GetCompactionStateRequest\x12\x14\n\x0c\x63ompactionID\x18\x01 \x01(\x03\"\xdd\x01\n\x1aGetCompactionStateResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\x33\n\x05state\x18\x02 \x01(\x0e\x32$.milvus.proto.common.CompactionState\x12\x17\n\x0f\x65xecutingPlanNo\x18\x03 \x01(\x03\x12\x15\n\rtimeoutPlanNo\x18\x04 \x01(\x03\x12\x17\n\x0f\x63ompletedPlanNo\x18\x05 \x01(\x03\x12\x14\n\x0c\x66\x61iledPlanNo\x18\x06 \x01(\x03\"1\n\x19GetCompactionPlansRequest\x12\x14\n\x0c\x63ompactionID\x18\x01 \x01(\x03\"\xbc\x01\n\x1aGetCompactionPlansResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\x33\n\x05state\x18\x02 \x01(\x0e\x32$.milvus.proto.common.CompactionState\x12<\n\nmergeInfos\x18\x03 \x03(\x0b\x32(.milvus.proto.milvus.CompactionMergeInfo\"6\n\x13\x43ompactionMergeInfo\x12\x0f\n\x07sources\x18\x01 \x03(\x03\x12\x0e\n\x06target\x18\x02 \x01(\x03\"o\n\x14GetFlushStateRequest\x12\x12\n\nsegmentIDs\x18\x01 \x03(\x03\x12\x10\n\x08\x66lush_ts\x18\x02 \x01(\x04\x12\x0f\n\x07\x64\x62_name\x18\x03 \x01(\t\x12\x17\n\x0f\x63ollection_name\x18\x04 \x01(\t:\x07\xca>\x04\x10+\x18\x04\"U\n\x15GetFlushStateResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\x0f\n\x07\x66lushed\x18\x02 \x01(\x08\"l\n\x17GetFlushAllStateRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x14\n\x0c\x66lush_all_ts\x18\x02 \x01(\x04\x12\x0f\n\x07\x64\x62_name\x18\x03 \x01(\t\"X\n\x18GetFlushAllStateResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\x0f\n\x07\x66lushed\x18\x02 \x01(\x08\"\xe0\x01\n\rImportRequest\x12\x17\n\x0f\x63ollection_name\x18\x01 \x01(\t\x12\x16\n\x0epartition_name\x18\x02 \x01(\t\x12\x15\n\rchannel_names\x18\x03 \x03(\t\x12\x11\n\trow_based\x18\x04 \x01(\x08\x12\r\n\x05\x66iles\x18\x05 \x03(\t\x12\x32\n\x07options\x18\x06 \x03(\x0b\x32!.milvus.proto.common.KeyValuePair\x12\x0f\n\x07\x64\x62_name\x18\x07 \x01(\t\x12\x17\n\x0f\x63lustering_info\x18\x08 \x01(\x0c:\x07\xca>\x04\x10\x12\x18\x01\"L\n\x0eImportResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\r\n\x05tasks\x18\x02 \x03(\x03\"%\n\x15GetImportStateRequest\x12\x0c\n\x04task\x18\x01 \x01(\x03\"\x97\x02\n\x16GetImportStateResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12/\n\x05state\x18\x02 \x01(\x0e\x32 .milvus.proto.common.ImportState\x12\x11\n\trow_count\x18\x03 \x01(\x03\x12\x0f\n\x07id_list\x18\x04 \x03(\x03\x12\x30\n\x05infos\x18\x05 \x03(\x0b\x32!.milvus.proto.common.KeyValuePair\x12\n\n\x02id\x18\x06 \x01(\x03\x12\x15\n\rcollection_id\x18\x07 \x01(\x03\x12\x13\n\x0bsegment_ids\x18\x08 \x03(\x03\x12\x11\n\tcreate_ts\x18\t \x01(\x03\"Q\n\x16ListImportTasksRequest\x12\x17\n\x0f\x63ollection_name\x18\x01 \x01(\t\x12\r\n\x05limit\x18\x02 \x01(\x03\x12\x0f\n\x07\x64\x62_name\x18\x03 \x01(\t\"\x82\x01\n\x17ListImportTasksResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12:\n\x05tasks\x18\x02 \x03(\x0b\x32+.milvus.proto.milvus.GetImportStateResponse\"\x9a\x01\n\x12GetReplicasRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x14\n\x0c\x63ollectionID\x18\x02 \x01(\x03\x12\x18\n\x10with_shard_nodes\x18\x03 \x01(\x08\x12\x17\n\x0f\x63ollection_name\x18\x04 \x01(\t\x12\x0f\n\x07\x64\x62_name\x18\x05 \x01(\t\"v\n\x13GetReplicasResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\x32\n\x08replicas\x18\x02 \x03(\x0b\x32 .milvus.proto.milvus.ReplicaInfo\"\xc1\x02\n\x0bReplicaInfo\x12\x11\n\treplicaID\x18\x01 \x01(\x03\x12\x14\n\x0c\x63ollectionID\x18\x02 \x01(\x03\x12\x15\n\rpartition_ids\x18\x03 \x03(\x03\x12\x39\n\x0eshard_replicas\x18\x04 \x03(\x0b\x32!.milvus.proto.milvus.ShardReplica\x12\x10\n\x08node_ids\x18\x05 \x03(\x03\x12\x1b\n\x13resource_group_name\x18\x06 \x01(\t\x12P\n\x11num_outbound_node\x18\x07 \x03(\x0b\x32\x35.milvus.proto.milvus.ReplicaInfo.NumOutboundNodeEntry\x1a\x36\n\x14NumOutboundNodeEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\x05:\x02\x38\x01\"`\n\x0cShardReplica\x12\x10\n\x08leaderID\x18\x01 \x01(\x03\x12\x13\n\x0bleader_addr\x18\x02 \x01(\t\x12\x17\n\x0f\x64m_channel_name\x18\x03 \x01(\t\x12\x10\n\x08node_ids\x18\x04 \x03(\x03\"\xbe\x01\n\x17\x43reateCredentialRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x10\n\x08username\x18\x02 \x01(\t\x12\x10\n\x08password\x18\x03 \x01(\t\x12\x1e\n\x16\x63reated_utc_timestamps\x18\x04 \x01(\x04\x12\x1f\n\x17modified_utc_timestamps\x18\x05 \x01(\x04:\x12\xca>\x0f\x08\x01\x10\x13\x18\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\"\xcd\x01\n\x17UpdateCredentialRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x10\n\x08username\x18\x02 \x01(\t\x12\x13\n\x0boldPassword\x18\x03 \x01(\t\x12\x13\n\x0bnewPassword\x18\x04 \x01(\t\x12\x1e\n\x16\x63reated_utc_timestamps\x18\x05 \x01(\x04\x12\x1f\n\x17modified_utc_timestamps\x18\x06 \x01(\x04:\t\xca>\x06\x08\x02\x10\x14\x18\x02\"k\n\x17\x44\x65leteCredentialRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x10\n\x08username\x18\x02 \x01(\t:\x12\xca>\x0f\x08\x01\x10\x15\x18\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\"W\n\x15ListCredUsersResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\x11\n\tusernames\x18\x02 \x03(\t\"V\n\x14ListCredUsersRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase:\x12\xca>\x0f\x08\x01\x10\x16\x18\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\"\x1a\n\nRoleEntity\x12\x0c\n\x04name\x18\x01 \x01(\t\"\x1a\n\nUserEntity\x12\x0c\n\x04name\x18\x01 \x01(\t\"\x84\x01\n\x11\x43reateRoleRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12/\n\x06\x65ntity\x18\x02 \x01(\x0b\x32\x1f.milvus.proto.milvus.RoleEntity:\x12\xca>\x0f\x08\x01\x10\x13\x18\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\"d\n\x0f\x44ropRoleRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x11\n\trole_name\x18\x02 \x01(\t:\x12\xca>\x0f\x08\x01\x10\x15\x18\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\"\xb5\x01\n\x16OperateUserRoleRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x10\n\x08username\x18\x02 \x01(\t\x12\x11\n\trole_name\x18\x03 \x01(\t\x12\x36\n\x04type\x18\x04 \x01(\x0e\x32(.milvus.proto.milvus.OperateUserRoleType:\x12\xca>\x0f\x08\x01\x10\x17\x18\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\"\x9d\x01\n\x11SelectRoleRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12-\n\x04role\x18\x02 \x01(\x0b\x32\x1f.milvus.proto.milvus.RoleEntity\x12\x19\n\x11include_user_info\x18\x03 \x01(\x08:\x12\xca>\x0f\x08\x01\x10\x16\x18\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\"k\n\nRoleResult\x12-\n\x04role\x18\x01 \x01(\x0b\x32\x1f.milvus.proto.milvus.RoleEntity\x12.\n\x05users\x18\x02 \x03(\x0b\x32\x1f.milvus.proto.milvus.UserEntity\"s\n\x12SelectRoleResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\x30\n\x07results\x18\x02 \x03(\x0b\x32\x1f.milvus.proto.milvus.RoleResult\"\x94\x01\n\x11SelectUserRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12-\n\x04user\x18\x02 \x01(\x0b\x32\x1f.milvus.proto.milvus.UserEntity\x12\x19\n\x11include_role_info\x18\x03 \x01(\x08:\t\xca>\x06\x08\x02\x10\x18\x18\x02\"k\n\nUserResult\x12-\n\x04user\x18\x01 \x01(\x0b\x32\x1f.milvus.proto.milvus.UserEntity\x12.\n\x05roles\x18\x02 \x03(\x0b\x32\x1f.milvus.proto.milvus.RoleEntity\"s\n\x12SelectUserResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\x30\n\x07results\x18\x02 \x03(\x0b\x32\x1f.milvus.proto.milvus.UserResult\"\x1c\n\x0cObjectEntity\x12\x0c\n\x04name\x18\x01 \x01(\t\"\x1f\n\x0fPrivilegeEntity\x12\x0c\n\x04name\x18\x01 \x01(\t\"w\n\rGrantorEntity\x12-\n\x04user\x18\x01 \x01(\x0b\x32\x1f.milvus.proto.milvus.UserEntity\x12\x37\n\tprivilege\x18\x02 \x01(\x0b\x32$.milvus.proto.milvus.PrivilegeEntity\"L\n\x14GrantPrivilegeEntity\x12\x34\n\x08\x65ntities\x18\x01 \x03(\x0b\x32\".milvus.proto.milvus.GrantorEntity\"\xca\x01\n\x0bGrantEntity\x12-\n\x04role\x18\x01 \x01(\x0b\x32\x1f.milvus.proto.milvus.RoleEntity\x12\x31\n\x06object\x18\x02 \x01(\x0b\x32!.milvus.proto.milvus.ObjectEntity\x12\x13\n\x0bobject_name\x18\x03 \x01(\t\x12\x33\n\x07grantor\x18\x04 \x01(\x0b\x32\".milvus.proto.milvus.GrantorEntity\x12\x0f\n\x07\x64\x62_name\x18\x05 \x01(\t\"\x86\x01\n\x12SelectGrantRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x30\n\x06\x65ntity\x18\x02 \x01(\x0b\x32 .milvus.proto.milvus.GrantEntity:\x12\xca>\x0f\x08\x01\x10\x16\x18\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\"v\n\x13SelectGrantResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\x32\n\x08\x65ntities\x18\x02 \x03(\x0b\x32 .milvus.proto.milvus.GrantEntity\"\xc4\x01\n\x17OperatePrivilegeRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x30\n\x06\x65ntity\x18\x02 \x01(\x0b\x32 .milvus.proto.milvus.GrantEntity\x12\x37\n\x04type\x18\x03 \x01(\x0e\x32).milvus.proto.milvus.OperatePrivilegeType:\x12\xca>\x0f\x08\x01\x10\x17\x18\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\"\x93\x01\n\x19GetLoadingProgressRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x17\n\x0f\x63ollection_name\x18\x02 \x01(\t\x12\x17\n\x0fpartition_names\x18\x03 \x03(\t\x12\x0f\n\x07\x64\x62_name\x18\x04 \x01(\t:\x07\xca>\x04\x10\x05\x18\x02\"u\n\x1aGetLoadingProgressResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\x10\n\x08progress\x18\x02 \x01(\x03\x12\x18\n\x10refresh_progress\x18\x03 \x01(\x03\"\x8d\x01\n\x13GetLoadStateRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x17\n\x0f\x63ollection_name\x18\x02 \x01(\t\x12\x17\n\x0fpartition_names\x18\x03 \x03(\t\x12\x0f\n\x07\x64\x62_name\x18\x04 \x01(\t:\x07\xca>\x04\x10\x05\x18\x02\"r\n\x14GetLoadStateResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12-\n\x05state\x18\x02 \x01(\x0e\x32\x1e.milvus.proto.common.LoadState\"\x1c\n\tMilvusExt\x12\x0f\n\x07version\x18\x01 \x01(\t\"\x13\n\x11GetVersionRequest\"R\n\x12GetVersionResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\x0f\n\x07version\x18\x02 \x01(\t\"\x14\n\x12\x43heckHealthRequest\"\x9d\x01\n\x13\x43heckHealthResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\x11\n\tisHealthy\x18\x02 \x01(\x08\x12\x0f\n\x07reasons\x18\x03 \x03(\t\x12\x35\n\x0cquota_states\x18\x04 \x03(\x0e\x32\x1f.milvus.proto.milvus.QuotaState\"\xaa\x01\n\x1a\x43reateResourceGroupRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x16\n\x0eresource_group\x18\x02 \x01(\t\x12\x34\n\x06\x63onfig\x18\x03 \x01(\x0b\x32$.milvus.proto.rg.ResourceGroupConfig:\x12\xca>\x0f\x08\x01\x10\x1a\x18\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\"\x99\x02\n\x1bUpdateResourceGroupsRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12]\n\x0fresource_groups\x18\x02 \x03(\x0b\x32\x44.milvus.proto.milvus.UpdateResourceGroupsRequest.ResourceGroupsEntry\x1a[\n\x13ResourceGroupsEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\x33\n\x05value\x18\x02 \x01(\x0b\x32$.milvus.proto.rg.ResourceGroupConfig:\x02\x38\x01:\x12\xca>\x0f\x08\x01\x10\x30\x18\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\"r\n\x18\x44ropResourceGroupRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x16\n\x0eresource_group\x18\x02 \x01(\t:\x12\xca>\x0f\x08\x01\x10\x1b\x18\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\"\xa5\x01\n\x13TransferNodeRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x1d\n\x15source_resource_group\x18\x02 \x01(\t\x12\x1d\n\x15target_resource_group\x18\x03 \x01(\t\x12\x10\n\x08num_node\x18\x04 \x01(\x05:\x12\xca>\x0f\x08\x01\x10\x1e\x18\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\"\xd5\x01\n\x16TransferReplicaRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x1d\n\x15source_resource_group\x18\x02 \x01(\t\x12\x1d\n\x15target_resource_group\x18\x03 \x01(\t\x12\x17\n\x0f\x63ollection_name\x18\x04 \x01(\t\x12\x13\n\x0bnum_replica\x18\x05 \x01(\x03\x12\x0f\n\x07\x64\x62_name\x18\x06 \x01(\t:\x12\xca>\x0f\x08\x01\x10\x1f\x18\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\"[\n\x19ListResourceGroupsRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase:\x12\xca>\x0f\x08\x01\x10\x1d\x18\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\"b\n\x1aListResourceGroupsResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\x17\n\x0fresource_groups\x18\x02 \x03(\t\"v\n\x1c\x44\x65scribeResourceGroupRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x16\n\x0eresource_group\x18\x02 \x01(\t:\x12\xca>\x0f\x08\x01\x10\x1c\x18\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\"\x88\x01\n\x1d\x44\x65scribeResourceGroupResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12:\n\x0eresource_group\x18\x02 \x01(\x0b\x32\".milvus.proto.milvus.ResourceGroup\"\xd6\x04\n\rResourceGroup\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x10\n\x08\x63\x61pacity\x18\x02 \x01(\x05\x12\x1a\n\x12num_available_node\x18\x03 \x01(\x05\x12T\n\x12num_loaded_replica\x18\x04 \x03(\x0b\x32\x38.milvus.proto.milvus.ResourceGroup.NumLoadedReplicaEntry\x12R\n\x11num_outgoing_node\x18\x05 \x03(\x0b\x32\x37.milvus.proto.milvus.ResourceGroup.NumOutgoingNodeEntry\x12R\n\x11num_incoming_node\x18\x06 \x03(\x0b\x32\x37.milvus.proto.milvus.ResourceGroup.NumIncomingNodeEntry\x12\x34\n\x06\x63onfig\x18\x07 \x01(\x0b\x32$.milvus.proto.rg.ResourceGroupConfig\x12,\n\x05nodes\x18\x08 \x03(\x0b\x32\x1d.milvus.proto.common.NodeInfo\x1a\x37\n\x15NumLoadedReplicaEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\x05:\x02\x38\x01\x1a\x36\n\x14NumOutgoingNodeEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\x05:\x02\x38\x01\x1a\x36\n\x14NumIncomingNodeEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\x05:\x02\x38\x01\"\x9f\x01\n\x17RenameCollectionRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x0f\n\x07\x64\x62_name\x18\x02 \x01(\t\x12\x0f\n\x07oldName\x18\x03 \x01(\t\x12\x0f\n\x07newName\x18\x04 \x01(\t\x12\x11\n\tnewDBName\x18\x05 \x01(\t:\x12\xca>\x0f\x08\x01\x10\"\x18\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\"\xa1\x01\n\x19GetIndexStatisticsRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x0f\n\x07\x64\x62_name\x18\x02 \x01(\t\x12\x17\n\x0f\x63ollection_name\x18\x03 \x01(\t\x12\x12\n\nindex_name\x18\x04 \x01(\t\x12\x11\n\ttimestamp\x18\x05 \x01(\x04:\x07\xca>\x04\x10\x0c\x18\x03\"\x8c\x01\n\x1aGetIndexStatisticsResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\x41\n\x12index_descriptions\x18\x02 \x03(\x0b\x32%.milvus.proto.milvus.IndexDescription\"r\n\x0e\x43onnectRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x34\n\x0b\x63lient_info\x18\x02 \x01(\x0b\x32\x1f.milvus.proto.common.ClientInfo\"\x88\x01\n\x0f\x43onnectResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\x34\n\x0bserver_info\x18\x02 \x01(\x0b\x32\x1f.milvus.proto.common.ServerInfo\x12\x12\n\nidentifier\x18\x03 \x01(\x03\"C\n\x15\x41llocTimestampRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\"X\n\x16\x41llocTimestampResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\x11\n\ttimestamp\x18\x02 \x01(\x04\"h\n\x15\x43reateDatabaseRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x0f\n\x07\x64\x62_name\x18\x02 \x01(\t:\x12\xca>\x0f\x08\x01\x10#\x18\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\"f\n\x13\x44ropDatabaseRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x0f\n\x07\x64\x62_name\x18\x02 \x01(\t:\x12\xca>\x0f\x08\x01\x10$\x18\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\"V\n\x14ListDatabasesRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase:\x12\xca>\x0f\x08\x01\x10%\x18\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\"\x85\x01\n\x15ListDatabasesResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\x10\n\x08\x64\x62_names\x18\x02 \x03(\t\x12\x19\n\x11\x63reated_timestamp\x18\x03 \x03(\x04:\x12\xca>\x0f\x08\x01\x10\x04\x18\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\"\xf5\x01\n\x17ReplicateMessageRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x14\n\x0c\x63hannel_name\x18\x02 \x01(\t\x12\x0f\n\x07\x42\x65ginTs\x18\x03 \x01(\x04\x12\r\n\x05\x45ndTs\x18\x04 \x01(\x04\x12\x0c\n\x04Msgs\x18\x05 \x03(\x0c\x12\x35\n\x0eStartPositions\x18\x06 \x03(\x0b\x32\x1d.milvus.proto.msg.MsgPosition\x12\x33\n\x0c\x45ndPositions\x18\x07 \x03(\x0b\x32\x1d.milvus.proto.msg.MsgPosition\"Y\n\x18ReplicateMessageResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\x10\n\x08position\x18\x02 \x01(\t*%\n\x08ShowType\x12\x07\n\x03\x41ll\x10\x00\x12\x0c\n\x08InMemory\x10\x01\x1a\x02\x18\x01*@\n\x13OperateUserRoleType\x12\x11\n\rAddUserToRole\x10\x00\x12\x16\n\x12RemoveUserFromRole\x10\x01*-\n\x14OperatePrivilegeType\x12\t\n\x05Grant\x10\x00\x12\n\n\x06Revoke\x10\x01*]\n\nQuotaState\x12\x0b\n\x07Unknown\x10\x00\x12\x0f\n\x0bReadLimited\x10\x02\x12\x10\n\x0cWriteLimited\x10\x03\x12\x0e\n\nDenyToRead\x10\x04\x12\x0f\n\x0b\x44\x65nyToWrite\x10\x05\x32\xec\x42\n\rMilvusService\x12_\n\x10\x43reateCollection\x12,.milvus.proto.milvus.CreateCollectionRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12[\n\x0e\x44ropCollection\x12*.milvus.proto.milvus.DropCollectionRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12_\n\rHasCollection\x12).milvus.proto.milvus.HasCollectionRequest\x1a!.milvus.proto.milvus.BoolResponse\"\x00\x12[\n\x0eLoadCollection\x12*.milvus.proto.milvus.LoadCollectionRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12\x61\n\x11ReleaseCollection\x12-.milvus.proto.milvus.ReleaseCollectionRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12w\n\x12\x44\x65scribeCollection\x12..milvus.proto.milvus.DescribeCollectionRequest\x1a/.milvus.proto.milvus.DescribeCollectionResponse\"\x00\x12\x86\x01\n\x17GetCollectionStatistics\x12\x33.milvus.proto.milvus.GetCollectionStatisticsRequest\x1a\x34.milvus.proto.milvus.GetCollectionStatisticsResponse\"\x00\x12n\n\x0fShowCollections\x12+.milvus.proto.milvus.ShowCollectionsRequest\x1a,.milvus.proto.milvus.ShowCollectionsResponse\"\x00\x12]\n\x0f\x41lterCollection\x12+.milvus.proto.milvus.AlterCollectionRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12]\n\x0f\x43reatePartition\x12+.milvus.proto.milvus.CreatePartitionRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12Y\n\rDropPartition\x12).milvus.proto.milvus.DropPartitionRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12]\n\x0cHasPartition\x12(.milvus.proto.milvus.HasPartitionRequest\x1a!.milvus.proto.milvus.BoolResponse\"\x00\x12[\n\x0eLoadPartitions\x12*.milvus.proto.milvus.LoadPartitionsRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12\x61\n\x11ReleasePartitions\x12-.milvus.proto.milvus.ReleasePartitionsRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12\x83\x01\n\x16GetPartitionStatistics\x12\x32.milvus.proto.milvus.GetPartitionStatisticsRequest\x1a\x33.milvus.proto.milvus.GetPartitionStatisticsResponse\"\x00\x12k\n\x0eShowPartitions\x12*.milvus.proto.milvus.ShowPartitionsRequest\x1a+.milvus.proto.milvus.ShowPartitionsResponse\"\x00\x12w\n\x12GetLoadingProgress\x12..milvus.proto.milvus.GetLoadingProgressRequest\x1a/.milvus.proto.milvus.GetLoadingProgressResponse\"\x00\x12\x65\n\x0cGetLoadState\x12(.milvus.proto.milvus.GetLoadStateRequest\x1a).milvus.proto.milvus.GetLoadStateResponse\"\x00\x12U\n\x0b\x43reateAlias\x12\'.milvus.proto.milvus.CreateAliasRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12Q\n\tDropAlias\x12%.milvus.proto.milvus.DropAliasRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12S\n\nAlterAlias\x12&.milvus.proto.milvus.AlterAliasRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12h\n\rDescribeAlias\x12).milvus.proto.milvus.DescribeAliasRequest\x1a*.milvus.proto.milvus.DescribeAliasResponse\"\x00\x12\x62\n\x0bListAliases\x12\'.milvus.proto.milvus.ListAliasesRequest\x1a(.milvus.proto.milvus.ListAliasesResponse\"\x00\x12U\n\x0b\x43reateIndex\x12\'.milvus.proto.milvus.CreateIndexRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12S\n\nAlterIndex\x12&.milvus.proto.milvus.AlterIndexRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12h\n\rDescribeIndex\x12).milvus.proto.milvus.DescribeIndexRequest\x1a*.milvus.proto.milvus.DescribeIndexResponse\"\x00\x12w\n\x12GetIndexStatistics\x12..milvus.proto.milvus.GetIndexStatisticsRequest\x1a/.milvus.proto.milvus.GetIndexStatisticsResponse\"\x00\x12k\n\rGetIndexState\x12).milvus.proto.milvus.GetIndexStateRequest\x1a*.milvus.proto.milvus.GetIndexStateResponse\"\x03\x88\x02\x01\x12\x83\x01\n\x15GetIndexBuildProgress\x12\x31.milvus.proto.milvus.GetIndexBuildProgressRequest\x1a\x32.milvus.proto.milvus.GetIndexBuildProgressResponse\"\x03\x88\x02\x01\x12Q\n\tDropIndex\x12%.milvus.proto.milvus.DropIndexRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12S\n\x06Insert\x12\".milvus.proto.milvus.InsertRequest\x1a#.milvus.proto.milvus.MutationResult\"\x00\x12S\n\x06\x44\x65lete\x12\".milvus.proto.milvus.DeleteRequest\x1a#.milvus.proto.milvus.MutationResult\"\x00\x12S\n\x06Upsert\x12\".milvus.proto.milvus.UpsertRequest\x1a#.milvus.proto.milvus.MutationResult\"\x00\x12R\n\x06Search\x12\".milvus.proto.milvus.SearchRequest\x1a\".milvus.proto.milvus.SearchResults\"\x00\x12^\n\x0cHybridSearch\x12(.milvus.proto.milvus.HybridSearchRequest\x1a\".milvus.proto.milvus.SearchResults\"\x00\x12P\n\x05\x46lush\x12!.milvus.proto.milvus.FlushRequest\x1a\".milvus.proto.milvus.FlushResponse\"\x00\x12O\n\x05Query\x12!.milvus.proto.milvus.QueryRequest\x1a!.milvus.proto.milvus.QueryResults\"\x00\x12\x64\n\x0c\x43\x61lcDistance\x12(.milvus.proto.milvus.CalcDistanceRequest\x1a(.milvus.proto.milvus.CalcDistanceResults\"\x00\x12Y\n\x08\x46lushAll\x12$.milvus.proto.milvus.FlushAllRequest\x1a%.milvus.proto.milvus.FlushAllResponse\"\x00\x12h\n\rGetFlushState\x12).milvus.proto.milvus.GetFlushStateRequest\x1a*.milvus.proto.milvus.GetFlushStateResponse\"\x00\x12q\n\x10GetFlushAllState\x12,.milvus.proto.milvus.GetFlushAllStateRequest\x1a-.milvus.proto.milvus.GetFlushAllStateResponse\"\x00\x12\x89\x01\n\x18GetPersistentSegmentInfo\x12\x34.milvus.proto.milvus.GetPersistentSegmentInfoRequest\x1a\x35.milvus.proto.milvus.GetPersistentSegmentInfoResponse\"\x00\x12z\n\x13GetQuerySegmentInfo\x12/.milvus.proto.milvus.GetQuerySegmentInfoRequest\x1a\x30.milvus.proto.milvus.GetQuerySegmentInfoResponse\"\x00\x12\x62\n\x0bGetReplicas\x12\'.milvus.proto.milvus.GetReplicasRequest\x1a(.milvus.proto.milvus.GetReplicasResponse\"\x00\x12P\n\x05\x44ummy\x12!.milvus.proto.milvus.DummyRequest\x1a\".milvus.proto.milvus.DummyResponse\"\x00\x12\x65\n\x0cRegisterLink\x12(.milvus.proto.milvus.RegisterLinkRequest\x1a).milvus.proto.milvus.RegisterLinkResponse\"\x00\x12_\n\nGetMetrics\x12&.milvus.proto.milvus.GetMetricsRequest\x1a\'.milvus.proto.milvus.GetMetricsResponse\"\x00\x12l\n\x12GetComponentStates\x12..milvus.proto.milvus.GetComponentStatesRequest\x1a$.milvus.proto.milvus.ComponentStates\"\x00\x12U\n\x0bLoadBalance\x12\'.milvus.proto.milvus.LoadBalanceRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12w\n\x12GetCompactionState\x12..milvus.proto.milvus.GetCompactionStateRequest\x1a/.milvus.proto.milvus.GetCompactionStateResponse\"\x00\x12q\n\x10ManualCompaction\x12,.milvus.proto.milvus.ManualCompactionRequest\x1a-.milvus.proto.milvus.ManualCompactionResponse\"\x00\x12\x80\x01\n\x1bGetCompactionStateWithPlans\x12..milvus.proto.milvus.GetCompactionPlansRequest\x1a/.milvus.proto.milvus.GetCompactionPlansResponse\"\x00\x12S\n\x06Import\x12\".milvus.proto.milvus.ImportRequest\x1a#.milvus.proto.milvus.ImportResponse\"\x00\x12k\n\x0eGetImportState\x12*.milvus.proto.milvus.GetImportStateRequest\x1a+.milvus.proto.milvus.GetImportStateResponse\"\x00\x12n\n\x0fListImportTasks\x12+.milvus.proto.milvus.ListImportTasksRequest\x1a,.milvus.proto.milvus.ListImportTasksResponse\"\x00\x12_\n\x10\x43reateCredential\x12,.milvus.proto.milvus.CreateCredentialRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12_\n\x10UpdateCredential\x12,.milvus.proto.milvus.UpdateCredentialRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12_\n\x10\x44\x65leteCredential\x12,.milvus.proto.milvus.DeleteCredentialRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12h\n\rListCredUsers\x12).milvus.proto.milvus.ListCredUsersRequest\x1a*.milvus.proto.milvus.ListCredUsersResponse\"\x00\x12S\n\nCreateRole\x12&.milvus.proto.milvus.CreateRoleRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12O\n\x08\x44ropRole\x12$.milvus.proto.milvus.DropRoleRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12]\n\x0fOperateUserRole\x12+.milvus.proto.milvus.OperateUserRoleRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12_\n\nSelectRole\x12&.milvus.proto.milvus.SelectRoleRequest\x1a\'.milvus.proto.milvus.SelectRoleResponse\"\x00\x12_\n\nSelectUser\x12&.milvus.proto.milvus.SelectUserRequest\x1a\'.milvus.proto.milvus.SelectUserResponse\"\x00\x12_\n\x10OperatePrivilege\x12,.milvus.proto.milvus.OperatePrivilegeRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12\x62\n\x0bSelectGrant\x12\'.milvus.proto.milvus.SelectGrantRequest\x1a(.milvus.proto.milvus.SelectGrantResponse\"\x00\x12_\n\nGetVersion\x12&.milvus.proto.milvus.GetVersionRequest\x1a\'.milvus.proto.milvus.GetVersionResponse\"\x00\x12\x62\n\x0b\x43heckHealth\x12\'.milvus.proto.milvus.CheckHealthRequest\x1a(.milvus.proto.milvus.CheckHealthResponse\"\x00\x12\x65\n\x13\x43reateResourceGroup\x12/.milvus.proto.milvus.CreateResourceGroupRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12\x61\n\x11\x44ropResourceGroup\x12-.milvus.proto.milvus.DropResourceGroupRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12g\n\x14UpdateResourceGroups\x12\x30.milvus.proto.milvus.UpdateResourceGroupsRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12W\n\x0cTransferNode\x12(.milvus.proto.milvus.TransferNodeRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12]\n\x0fTransferReplica\x12+.milvus.proto.milvus.TransferReplicaRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12w\n\x12ListResourceGroups\x12..milvus.proto.milvus.ListResourceGroupsRequest\x1a/.milvus.proto.milvus.ListResourceGroupsResponse\"\x00\x12\x80\x01\n\x15\x44\x65scribeResourceGroup\x12\x31.milvus.proto.milvus.DescribeResourceGroupRequest\x1a\x32.milvus.proto.milvus.DescribeResourceGroupResponse\"\x00\x12_\n\x10RenameCollection\x12,.milvus.proto.milvus.RenameCollectionRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12u\n\x12ListIndexedSegment\x12-.milvus.proto.feder.ListIndexedSegmentRequest\x1a..milvus.proto.feder.ListIndexedSegmentResponse\"\x00\x12\x87\x01\n\x18\x44\x65scribeSegmentIndexData\x12\x33.milvus.proto.feder.DescribeSegmentIndexDataRequest\x1a\x34.milvus.proto.feder.DescribeSegmentIndexDataResponse\"\x00\x12V\n\x07\x43onnect\x12#.milvus.proto.milvus.ConnectRequest\x1a$.milvus.proto.milvus.ConnectResponse\"\x00\x12k\n\x0e\x41llocTimestamp\x12*.milvus.proto.milvus.AllocTimestampRequest\x1a+.milvus.proto.milvus.AllocTimestampResponse\"\x00\x12[\n\x0e\x43reateDatabase\x12*.milvus.proto.milvus.CreateDatabaseRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12W\n\x0c\x44ropDatabase\x12(.milvus.proto.milvus.DropDatabaseRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12h\n\rListDatabases\x12).milvus.proto.milvus.ListDatabasesRequest\x1a*.milvus.proto.milvus.ListDatabasesResponse\"\x00\x12q\n\x10ReplicateMessage\x12,.milvus.proto.milvus.ReplicateMessageRequest\x1a-.milvus.proto.milvus.ReplicateMessageResponse\"\x00\x32u\n\x0cProxyService\x12\x65\n\x0cRegisterLink\x12(.milvus.proto.milvus.RegisterLinkRequest\x1a).milvus.proto.milvus.RegisterLinkResponse\"\x00:U\n\x0emilvus_ext_obj\x12\x1c.google.protobuf.FileOptions\x18\xe9\x07 \x01(\x0b\x32\x1e.milvus.proto.milvus.MilvusExtBm\n\x0eio.milvus.grpcB\x0bMilvusProtoP\x01Z4github.com/milvus-io/milvus-proto/go-api/v2/milvuspb\xa0\x01\x01\xaa\x02\x12Milvus.Client.Grpcb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'milvus_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + _globals['DESCRIPTOR']._options = None + _globals['DESCRIPTOR']._serialized_options = b'\n\016io.milvus.grpcB\013MilvusProtoP\001Z4github.com/milvus-io/milvus-proto/go-api/v2/milvuspb\240\001\001\252\002\022Milvus.Client.Grpc' + _globals['_SHOWTYPE']._options = None + _globals['_SHOWTYPE']._serialized_options = b'\030\001' + _globals['_CREATEALIASREQUEST']._options = None + _globals['_CREATEALIASREQUEST']._serialized_options = b'\312>\017\010\001\020,\030\377\377\377\377\377\377\377\377\377\001' + _globals['_DROPALIASREQUEST']._options = None + _globals['_DROPALIASREQUEST']._serialized_options = b'\312>\017\010\001\020-\030\377\377\377\377\377\377\377\377\377\001' + _globals['_DESCRIBEALIASREQUEST']._options = None + _globals['_DESCRIBEALIASREQUEST']._serialized_options = b'\312>\017\010\001\020.\030\377\377\377\377\377\377\377\377\377\001' + _globals['_LISTALIASESREQUEST']._options = None + _globals['_LISTALIASESREQUEST']._serialized_options = b'\312>\017\010\001\020/\030\377\377\377\377\377\377\377\377\377\001' + _globals['_CREATECOLLECTIONREQUEST']._options = None + _globals['_CREATECOLLECTIONREQUEST']._serialized_options = b'\312>\017\010\001\020\001\030\377\377\377\377\377\377\377\377\377\001' + _globals['_DROPCOLLECTIONREQUEST']._options = None + _globals['_DROPCOLLECTIONREQUEST']._serialized_options = b'\312>\017\010\001\020\002\030\377\377\377\377\377\377\377\377\377\001' + _globals['_ALTERCOLLECTIONREQUEST']._options = None + _globals['_ALTERCOLLECTIONREQUEST']._serialized_options = b'\312>\017\010\001\020\001\030\377\377\377\377\377\377\377\377\377\001' + _globals['_DESCRIBECOLLECTIONREQUEST']._options = None + _globals['_DESCRIBECOLLECTIONREQUEST']._serialized_options = b'\312>\017\010\001\020\003\030\377\377\377\377\377\377\377\377\377\001' + _globals['_LOADCOLLECTIONREQUEST']._options = None + _globals['_LOADCOLLECTIONREQUEST']._serialized_options = b'\312>\004\020\005\030\003' + _globals['_RELEASECOLLECTIONREQUEST']._options = None + _globals['_RELEASECOLLECTIONREQUEST']._serialized_options = b'\312>\004\020\006\030\003' + _globals['_GETSTATISTICSREQUEST']._options = None + _globals['_GETSTATISTICSREQUEST']._serialized_options = b'\312>\004\020\n\030\003' + _globals['_GETCOLLECTIONSTATISTICSREQUEST']._options = None + _globals['_GETCOLLECTIONSTATISTICSREQUEST']._serialized_options = b'\312>\004\020\n\030\003' + _globals['_SHOWCOLLECTIONSREQUEST'].fields_by_name['collection_names']._options = None + _globals['_SHOWCOLLECTIONSREQUEST'].fields_by_name['collection_names']._serialized_options = b'\030\001' + _globals['_SHOWCOLLECTIONSREQUEST']._options = None + _globals['_SHOWCOLLECTIONSREQUEST']._serialized_options = b'\312>\017\010\001\020\004\030\377\377\377\377\377\377\377\377\377\001' + _globals['_SHOWCOLLECTIONSRESPONSE'].fields_by_name['inMemory_percentages']._options = None + _globals['_SHOWCOLLECTIONSRESPONSE'].fields_by_name['inMemory_percentages']._serialized_options = b'\030\001' + _globals['_CREATEPARTITIONREQUEST']._options = None + _globals['_CREATEPARTITIONREQUEST']._serialized_options = b'\312>\004\020\'\030\003' + _globals['_DROPPARTITIONREQUEST']._options = None + _globals['_DROPPARTITIONREQUEST']._serialized_options = b'\312>\004\020(\030\003' + _globals['_HASPARTITIONREQUEST']._options = None + _globals['_HASPARTITIONREQUEST']._serialized_options = b'\312>\004\020*\030\003' + _globals['_LOADPARTITIONSREQUEST']._options = None + _globals['_LOADPARTITIONSREQUEST']._serialized_options = b'\312>\004\020\005\030\003' + _globals['_RELEASEPARTITIONSREQUEST']._options = None + _globals['_RELEASEPARTITIONSREQUEST']._serialized_options = b'\312>\004\020\006\030\003' + _globals['_SHOWPARTITIONSREQUEST'].fields_by_name['type']._options = None + _globals['_SHOWPARTITIONSREQUEST'].fields_by_name['type']._serialized_options = b'\030\001' + _globals['_SHOWPARTITIONSREQUEST']._options = None + _globals['_SHOWPARTITIONSREQUEST']._serialized_options = b'\312>\004\020)\030\003' + _globals['_SHOWPARTITIONSRESPONSE'].fields_by_name['inMemory_percentages']._options = None + _globals['_SHOWPARTITIONSRESPONSE'].fields_by_name['inMemory_percentages']._serialized_options = b'\030\001' + _globals['_CREATEINDEXREQUEST']._options = None + _globals['_CREATEINDEXREQUEST']._serialized_options = b'\312>\004\020\013\030\003' + _globals['_ALTERINDEXREQUEST']._options = None + _globals['_ALTERINDEXREQUEST']._serialized_options = b'\312>\004\020\013\030\003' + _globals['_DESCRIBEINDEXREQUEST']._options = None + _globals['_DESCRIBEINDEXREQUEST']._serialized_options = b'\312>\004\020\014\030\003' + _globals['_GETINDEXBUILDPROGRESSREQUEST']._options = None + _globals['_GETINDEXBUILDPROGRESSREQUEST']._serialized_options = b'\312>\004\020\014\030\003' + _globals['_GETINDEXSTATEREQUEST']._options = None + _globals['_GETINDEXSTATEREQUEST']._serialized_options = b'\312>\004\020\014\030\003' + _globals['_DROPINDEXREQUEST']._options = None + _globals['_DROPINDEXREQUEST']._serialized_options = b'\312>\004\020\r\030\003' + _globals['_INSERTREQUEST']._options = None + _globals['_INSERTREQUEST']._serialized_options = b'\312>\004\020\010\030\003' + _globals['_UPSERTREQUEST']._options = None + _globals['_UPSERTREQUEST']._serialized_options = b'\312>\004\020\031\030\003' + _globals['_DELETEREQUEST']._options = None + _globals['_DELETEREQUEST']._serialized_options = b'\312>\004\020\t\030\003' + _globals['_SEARCHREQUEST']._options = None + _globals['_SEARCHREQUEST']._serialized_options = b'\312>\004\020\016\030\003' + _globals['_HYBRIDSEARCHREQUEST']._options = None + _globals['_HYBRIDSEARCHREQUEST']._serialized_options = b'\312>\004\020\016\030\003' + _globals['_FLUSHREQUEST']._options = None + _globals['_FLUSHREQUEST']._serialized_options = b'\312>\004\020\017 \003' + _globals['_FLUSHRESPONSE_COLLSEGIDSENTRY']._options = None + _globals['_FLUSHRESPONSE_COLLSEGIDSENTRY']._serialized_options = b'8\001' + _globals['_FLUSHRESPONSE_FLUSHCOLLSEGIDSENTRY']._options = None + _globals['_FLUSHRESPONSE_FLUSHCOLLSEGIDSENTRY']._serialized_options = b'8\001' + _globals['_FLUSHRESPONSE_COLLSEALTIMESENTRY']._options = None + _globals['_FLUSHRESPONSE_COLLSEALTIMESENTRY']._serialized_options = b'8\001' + _globals['_FLUSHRESPONSE_COLLFLUSHTSENTRY']._options = None + _globals['_FLUSHRESPONSE_COLLFLUSHTSENTRY']._serialized_options = b'8\001' + _globals['_QUERYREQUEST']._options = None + _globals['_QUERYREQUEST']._serialized_options = b'\312>\004\020\020\030\003' + _globals['_FLUSHALLREQUEST']._options = None + _globals['_FLUSHALLREQUEST']._serialized_options = b'\312>\017\010\001\020&\030\377\377\377\377\377\377\377\377\377\001' + _globals['_QUERYSEGMENTINFO'].fields_by_name['nodeID']._options = None + _globals['_QUERYSEGMENTINFO'].fields_by_name['nodeID']._serialized_options = b'\030\001' + _globals['_LOADBALANCEREQUEST']._options = None + _globals['_LOADBALANCEREQUEST']._serialized_options = b'\312>\004\020\021\030\005' + _globals['_MANUALCOMPACTIONREQUEST']._options = None + _globals['_MANUALCOMPACTIONREQUEST']._serialized_options = b'\312>\004\020\007\030\001' + _globals['_GETFLUSHSTATEREQUEST']._options = None + _globals['_GETFLUSHSTATEREQUEST']._serialized_options = b'\312>\004\020+\030\004' + _globals['_IMPORTREQUEST']._options = None + _globals['_IMPORTREQUEST']._serialized_options = b'\312>\004\020\022\030\001' + _globals['_REPLICAINFO_NUMOUTBOUNDNODEENTRY']._options = None + _globals['_REPLICAINFO_NUMOUTBOUNDNODEENTRY']._serialized_options = b'8\001' + _globals['_CREATECREDENTIALREQUEST']._options = None + _globals['_CREATECREDENTIALREQUEST']._serialized_options = b'\312>\017\010\001\020\023\030\377\377\377\377\377\377\377\377\377\001' + _globals['_UPDATECREDENTIALREQUEST']._options = None + _globals['_UPDATECREDENTIALREQUEST']._serialized_options = b'\312>\006\010\002\020\024\030\002' + _globals['_DELETECREDENTIALREQUEST']._options = None + _globals['_DELETECREDENTIALREQUEST']._serialized_options = b'\312>\017\010\001\020\025\030\377\377\377\377\377\377\377\377\377\001' + _globals['_LISTCREDUSERSREQUEST']._options = None + _globals['_LISTCREDUSERSREQUEST']._serialized_options = b'\312>\017\010\001\020\026\030\377\377\377\377\377\377\377\377\377\001' + _globals['_CREATEROLEREQUEST']._options = None + _globals['_CREATEROLEREQUEST']._serialized_options = b'\312>\017\010\001\020\023\030\377\377\377\377\377\377\377\377\377\001' + _globals['_DROPROLEREQUEST']._options = None + _globals['_DROPROLEREQUEST']._serialized_options = b'\312>\017\010\001\020\025\030\377\377\377\377\377\377\377\377\377\001' + _globals['_OPERATEUSERROLEREQUEST']._options = None + _globals['_OPERATEUSERROLEREQUEST']._serialized_options = b'\312>\017\010\001\020\027\030\377\377\377\377\377\377\377\377\377\001' + _globals['_SELECTROLEREQUEST']._options = None + _globals['_SELECTROLEREQUEST']._serialized_options = b'\312>\017\010\001\020\026\030\377\377\377\377\377\377\377\377\377\001' + _globals['_SELECTUSERREQUEST']._options = None + _globals['_SELECTUSERREQUEST']._serialized_options = b'\312>\006\010\002\020\030\030\002' + _globals['_SELECTGRANTREQUEST']._options = None + _globals['_SELECTGRANTREQUEST']._serialized_options = b'\312>\017\010\001\020\026\030\377\377\377\377\377\377\377\377\377\001' + _globals['_OPERATEPRIVILEGEREQUEST']._options = None + _globals['_OPERATEPRIVILEGEREQUEST']._serialized_options = b'\312>\017\010\001\020\027\030\377\377\377\377\377\377\377\377\377\001' + _globals['_GETLOADINGPROGRESSREQUEST']._options = None + _globals['_GETLOADINGPROGRESSREQUEST']._serialized_options = b'\312>\004\020\005\030\002' + _globals['_GETLOADSTATEREQUEST']._options = None + _globals['_GETLOADSTATEREQUEST']._serialized_options = b'\312>\004\020\005\030\002' + _globals['_CREATERESOURCEGROUPREQUEST']._options = None + _globals['_CREATERESOURCEGROUPREQUEST']._serialized_options = b'\312>\017\010\001\020\032\030\377\377\377\377\377\377\377\377\377\001' + _globals['_UPDATERESOURCEGROUPSREQUEST_RESOURCEGROUPSENTRY']._options = None + _globals['_UPDATERESOURCEGROUPSREQUEST_RESOURCEGROUPSENTRY']._serialized_options = b'8\001' + _globals['_UPDATERESOURCEGROUPSREQUEST']._options = None + _globals['_UPDATERESOURCEGROUPSREQUEST']._serialized_options = b'\312>\017\010\001\0200\030\377\377\377\377\377\377\377\377\377\001' + _globals['_DROPRESOURCEGROUPREQUEST']._options = None + _globals['_DROPRESOURCEGROUPREQUEST']._serialized_options = b'\312>\017\010\001\020\033\030\377\377\377\377\377\377\377\377\377\001' + _globals['_TRANSFERNODEREQUEST']._options = None + _globals['_TRANSFERNODEREQUEST']._serialized_options = b'\312>\017\010\001\020\036\030\377\377\377\377\377\377\377\377\377\001' + _globals['_TRANSFERREPLICAREQUEST']._options = None + _globals['_TRANSFERREPLICAREQUEST']._serialized_options = b'\312>\017\010\001\020\037\030\377\377\377\377\377\377\377\377\377\001' + _globals['_LISTRESOURCEGROUPSREQUEST']._options = None + _globals['_LISTRESOURCEGROUPSREQUEST']._serialized_options = b'\312>\017\010\001\020\035\030\377\377\377\377\377\377\377\377\377\001' + _globals['_DESCRIBERESOURCEGROUPREQUEST']._options = None + _globals['_DESCRIBERESOURCEGROUPREQUEST']._serialized_options = b'\312>\017\010\001\020\034\030\377\377\377\377\377\377\377\377\377\001' + _globals['_RESOURCEGROUP_NUMLOADEDREPLICAENTRY']._options = None + _globals['_RESOURCEGROUP_NUMLOADEDREPLICAENTRY']._serialized_options = b'8\001' + _globals['_RESOURCEGROUP_NUMOUTGOINGNODEENTRY']._options = None + _globals['_RESOURCEGROUP_NUMOUTGOINGNODEENTRY']._serialized_options = b'8\001' + _globals['_RESOURCEGROUP_NUMINCOMINGNODEENTRY']._options = None + _globals['_RESOURCEGROUP_NUMINCOMINGNODEENTRY']._serialized_options = b'8\001' + _globals['_RENAMECOLLECTIONREQUEST']._options = None + _globals['_RENAMECOLLECTIONREQUEST']._serialized_options = b'\312>\017\010\001\020\"\030\377\377\377\377\377\377\377\377\377\001' + _globals['_GETINDEXSTATISTICSREQUEST']._options = None + _globals['_GETINDEXSTATISTICSREQUEST']._serialized_options = b'\312>\004\020\014\030\003' + _globals['_CREATEDATABASEREQUEST']._options = None + _globals['_CREATEDATABASEREQUEST']._serialized_options = b'\312>\017\010\001\020#\030\377\377\377\377\377\377\377\377\377\001' + _globals['_DROPDATABASEREQUEST']._options = None + _globals['_DROPDATABASEREQUEST']._serialized_options = b'\312>\017\010\001\020$\030\377\377\377\377\377\377\377\377\377\001' + _globals['_LISTDATABASESREQUEST']._options = None + _globals['_LISTDATABASESREQUEST']._serialized_options = b'\312>\017\010\001\020%\030\377\377\377\377\377\377\377\377\377\001' + _globals['_LISTDATABASESRESPONSE']._options = None + _globals['_LISTDATABASESRESPONSE']._serialized_options = b'\312>\017\010\001\020\004\030\377\377\377\377\377\377\377\377\377\001' + _globals['_MILVUSSERVICE'].methods_by_name['GetIndexState']._options = None + _globals['_MILVUSSERVICE'].methods_by_name['GetIndexState']._serialized_options = b'\210\002\001' + _globals['_MILVUSSERVICE'].methods_by_name['GetIndexBuildProgress']._options = None + _globals['_MILVUSSERVICE'].methods_by_name['GetIndexBuildProgress']._serialized_options = b'\210\002\001' + _globals['_SHOWTYPE']._serialized_start=24010 + _globals['_SHOWTYPE']._serialized_end=24047 + _globals['_OPERATEUSERROLETYPE']._serialized_start=24049 + _globals['_OPERATEUSERROLETYPE']._serialized_end=24113 + _globals['_OPERATEPRIVILEGETYPE']._serialized_start=24115 + _globals['_OPERATEPRIVILEGETYPE']._serialized_end=24160 + _globals['_QUOTASTATE']._serialized_start=24162 + _globals['_QUOTASTATE']._serialized_end=24255 + _globals['_CREATEALIASREQUEST']._serialized_start=134 + _globals['_CREATEALIASREQUEST']._serialized_end=275 + _globals['_DROPALIASREQUEST']._serialized_start=277 + _globals['_DROPALIASREQUEST']._serialized_end=391 + _globals['_ALTERALIASREQUEST']._serialized_start=393 + _globals['_ALTERALIASREQUEST']._serialized_end=513 + _globals['_DESCRIBEALIASREQUEST']._serialized_start=515 + _globals['_DESCRIBEALIASREQUEST']._serialized_end=633 + _globals['_DESCRIBEALIASRESPONSE']._serialized_start=635 + _globals['_DESCRIBEALIASRESPONSE']._serialized_end=755 + _globals['_LISTALIASESREQUEST']._serialized_start=757 + _globals['_LISTALIASESREQUEST']._serialized_end=883 + _globals['_LISTALIASESRESPONSE']._serialized_start=885 + _globals['_LISTALIASESRESPONSE']._serialized_end=1010 + _globals['_CREATECOLLECTIONREQUEST']._serialized_start=1013 + _globals['_CREATECOLLECTIONREQUEST']._serialized_end=1325 + _globals['_DROPCOLLECTIONREQUEST']._serialized_start=1328 + _globals['_DROPCOLLECTIONREQUEST']._serialized_end=1457 + _globals['_ALTERCOLLECTIONREQUEST']._serialized_start=1460 + _globals['_ALTERCOLLECTIONREQUEST']._serialized_end=1667 + _globals['_HASCOLLECTIONREQUEST']._serialized_start=1670 + _globals['_HASCOLLECTIONREQUEST']._serialized_end=1798 + _globals['_BOOLRESPONSE']._serialized_start=1800 + _globals['_BOOLRESPONSE']._serialized_end=1874 + _globals['_STRINGRESPONSE']._serialized_start=1876 + _globals['_STRINGRESPONSE']._serialized_end=1952 + _globals['_DESCRIBECOLLECTIONREQUEST']._serialized_start=1955 + _globals['_DESCRIBECOLLECTIONREQUEST']._serialized_end=2130 + _globals['_DESCRIBECOLLECTIONRESPONSE']._serialized_start=2133 + _globals['_DESCRIBECOLLECTIONRESPONSE']._serialized_end=2687 + _globals['_LOADCOLLECTIONREQUEST']._serialized_start=2690 + _globals['_LOADCOLLECTIONREQUEST']._serialized_end=2874 + _globals['_RELEASECOLLECTIONREQUEST']._serialized_start=2876 + _globals['_RELEASECOLLECTIONREQUEST']._serialized_end=2997 + _globals['_GETSTATISTICSREQUEST']._serialized_start=3000 + _globals['_GETSTATISTICSREQUEST']._serialized_end=3171 + _globals['_GETSTATISTICSRESPONSE']._serialized_start=3173 + _globals['_GETSTATISTICSRESPONSE']._serialized_end=3291 + _globals['_GETCOLLECTIONSTATISTICSREQUEST']._serialized_start=3293 + _globals['_GETCOLLECTIONSTATISTICSREQUEST']._serialized_end=3420 + _globals['_GETCOLLECTIONSTATISTICSRESPONSE']._serialized_start=3423 + _globals['_GETCOLLECTIONSTATISTICSRESPONSE']._serialized_end=3551 + _globals['_SHOWCOLLECTIONSREQUEST']._serialized_start=3554 + _globals['_SHOWCOLLECTIONSREQUEST']._serialized_end=3754 + _globals['_SHOWCOLLECTIONSRESPONSE']._serialized_start=3757 + _globals['_SHOWCOLLECTIONSRESPONSE']._serialized_end=4004 + _globals['_CREATEPARTITIONREQUEST']._serialized_start=4007 + _globals['_CREATEPARTITIONREQUEST']._serialized_end=4150 + _globals['_DROPPARTITIONREQUEST']._serialized_start=4153 + _globals['_DROPPARTITIONREQUEST']._serialized_end=4294 + _globals['_HASPARTITIONREQUEST']._serialized_start=4297 + _globals['_HASPARTITIONREQUEST']._serialized_end=4437 + _globals['_LOADPARTITIONSREQUEST']._serialized_start=4440 + _globals['_LOADPARTITIONSREQUEST']._serialized_end=4649 + _globals['_RELEASEPARTITIONSREQUEST']._serialized_start=4652 + _globals['_RELEASEPARTITIONSREQUEST']._serialized_end=4798 + _globals['_GETPARTITIONSTATISTICSREQUEST']._serialized_start=4801 + _globals['_GETPARTITIONSTATISTICSREQUEST']._serialized_end=4942 + _globals['_GETPARTITIONSTATISTICSRESPONSE']._serialized_start=4944 + _globals['_GETPARTITIONSTATISTICSRESPONSE']._serialized_end=5071 + _globals['_SHOWPARTITIONSREQUEST']._serialized_start=5074 + _globals['_SHOWPARTITIONSREQUEST']._serialized_end=5288 + _globals['_SHOWPARTITIONSRESPONSE']._serialized_start=5291 + _globals['_SHOWPARTITIONSRESPONSE']._serialized_end=5501 + _globals['_DESCRIBESEGMENTREQUEST']._serialized_start=5503 + _globals['_DESCRIBESEGMENTREQUEST']._serialized_end=5612 + _globals['_DESCRIBESEGMENTRESPONSE']._serialized_start=5615 + _globals['_DESCRIBESEGMENTRESPONSE']._serialized_end=5758 + _globals['_SHOWSEGMENTSREQUEST']._serialized_start=5760 + _globals['_SHOWSEGMENTSREQUEST']._serialized_end=5868 + _globals['_SHOWSEGMENTSRESPONSE']._serialized_start=5870 + _globals['_SHOWSEGMENTSRESPONSE']._serialized_end=5957 + _globals['_CREATEINDEXREQUEST']._serialized_start=5960 + _globals['_CREATEINDEXREQUEST']._serialized_end=6172 + _globals['_ALTERINDEXREQUEST']._serialized_start=6175 + _globals['_ALTERINDEXREQUEST']._serialized_end=6366 + _globals['_DESCRIBEINDEXREQUEST']._serialized_start=6369 + _globals['_DESCRIBEINDEXREQUEST']._serialized_end=6545 + _globals['_INDEXDESCRIPTION']._serialized_start=6548 + _globals['_INDEXDESCRIPTION']._serialized_end=6825 + _globals['_DESCRIBEINDEXRESPONSE']._serialized_start=6828 + _globals['_DESCRIBEINDEXRESPONSE']._serialized_end=6963 + _globals['_GETINDEXBUILDPROGRESSREQUEST']._serialized_start=6966 + _globals['_GETINDEXBUILDPROGRESSREQUEST']._serialized_end=7131 + _globals['_GETINDEXBUILDPROGRESSRESPONSE']._serialized_start=7133 + _globals['_GETINDEXBUILDPROGRESSRESPONSE']._serialized_end=7251 + _globals['_GETINDEXSTATEREQUEST']._serialized_start=7254 + _globals['_GETINDEXSTATEREQUEST']._serialized_end=7411 + _globals['_GETINDEXSTATERESPONSE']._serialized_start=7414 + _globals['_GETINDEXSTATERESPONSE']._serialized_end=7551 + _globals['_DROPINDEXREQUEST']._serialized_start=7554 + _globals['_DROPINDEXREQUEST']._serialized_end=7707 + _globals['_INSERTREQUEST']._serialized_start=7710 + _globals['_INSERTREQUEST']._serialized_end=7934 + _globals['_UPSERTREQUEST']._serialized_start=7937 + _globals['_UPSERTREQUEST']._serialized_end=8161 + _globals['_MUTATIONRESULT']._serialized_start=8164 + _globals['_MUTATIONRESULT']._serialized_end=8404 + _globals['_DELETEREQUEST']._serialized_start=8407 + _globals['_DELETEREQUEST']._serialized_end=8640 + _globals['_SEARCHREQUEST']._serialized_start=8643 + _globals['_SEARCHREQUEST']._serialized_end=9174 + _globals['_HITS']._serialized_start=9176 + _globals['_HITS']._serialized_end=9229 + _globals['_SEARCHRESULTS']._serialized_start=9232 + _globals['_SEARCHRESULTS']._serialized_end=9373 + _globals['_HYBRIDSEARCHREQUEST']._serialized_start=9376 + _globals['_HYBRIDSEARCHREQUEST']._serialized_end=9833 + _globals['_FLUSHREQUEST']._serialized_start=9835 + _globals['_FLUSHREQUEST']._serialized_end=9945 + _globals['_FLUSHRESPONSE']._serialized_start=9948 + _globals['_FLUSHRESPONSE']._serialized_end=10615 + _globals['_FLUSHRESPONSE_COLLSEGIDSENTRY']._serialized_start=10340 + _globals['_FLUSHRESPONSE_COLLSEGIDSENTRY']._serialized_end=10421 + _globals['_FLUSHRESPONSE_FLUSHCOLLSEGIDSENTRY']._serialized_start=10423 + _globals['_FLUSHRESPONSE_FLUSHCOLLSEGIDSENTRY']._serialized_end=10509 + _globals['_FLUSHRESPONSE_COLLSEALTIMESENTRY']._serialized_start=10511 + _globals['_FLUSHRESPONSE_COLLSEALTIMESENTRY']._serialized_end=10563 + _globals['_FLUSHRESPONSE_COLLFLUSHTSENTRY']._serialized_start=10565 + _globals['_FLUSHRESPONSE_COLLFLUSHTSENTRY']._serialized_end=10615 + _globals['_QUERYREQUEST']._serialized_start=10618 + _globals['_QUERYREQUEST']._serialized_end=11029 + _globals['_QUERYRESULTS']._serialized_start=11032 + _globals['_QUERYRESULTS']._serialized_end=11192 + _globals['_VECTORIDS']._serialized_start=11194 + _globals['_VECTORIDS']._serialized_end=11319 + _globals['_VECTORSARRAY']._serialized_start=11322 + _globals['_VECTORSARRAY']._serialized_end=11453 + _globals['_CALCDISTANCEREQUEST']._serialized_start=11456 + _globals['_CALCDISTANCEREQUEST']._serialized_end=11677 + _globals['_CALCDISTANCERESULTS']._serialized_start=11680 + _globals['_CALCDISTANCERESULTS']._serialized_end=11861 + _globals['_FLUSHALLREQUEST']._serialized_start=11863 + _globals['_FLUSHALLREQUEST']._serialized_end=11961 + _globals['_FLUSHALLRESPONSE']._serialized_start=11963 + _globals['_FLUSHALLRESPONSE']._serialized_end=12048 + _globals['_PERSISTENTSEGMENTINFO']._serialized_start=12051 + _globals['_PERSISTENTSEGMENTINFO']._serialized_end=12204 + _globals['_GETPERSISTENTSEGMENTINFOREQUEST']._serialized_start=12206 + _globals['_GETPERSISTENTSEGMENTINFOREQUEST']._serialized_end=12323 + _globals['_GETPERSISTENTSEGMENTINFORESPONSE']._serialized_start=12326 + _globals['_GETPERSISTENTSEGMENTINFORESPONSE']._serialized_end=12464 + _globals['_QUERYSEGMENTINFO']._serialized_start=12467 + _globals['_QUERYSEGMENTINFO']._serialized_end=12707 + _globals['_GETQUERYSEGMENTINFOREQUEST']._serialized_start=12709 + _globals['_GETQUERYSEGMENTINFOREQUEST']._serialized_end=12821 + _globals['_GETQUERYSEGMENTINFORESPONSE']._serialized_start=12824 + _globals['_GETQUERYSEGMENTINFORESPONSE']._serialized_end=12952 + _globals['_DUMMYREQUEST']._serialized_start=12954 + _globals['_DUMMYREQUEST']._serialized_end=12990 + _globals['_DUMMYRESPONSE']._serialized_start=12992 + _globals['_DUMMYRESPONSE']._serialized_end=13025 + _globals['_REGISTERLINKREQUEST']._serialized_start=13027 + _globals['_REGISTERLINKREQUEST']._serialized_end=13048 + _globals['_REGISTERLINKRESPONSE']._serialized_start=13050 + _globals['_REGISTERLINKRESPONSE']._serialized_end=13164 + _globals['_GETMETRICSREQUEST']._serialized_start=13166 + _globals['_GETMETRICSREQUEST']._serialized_end=13246 + _globals['_GETMETRICSRESPONSE']._serialized_start=13248 + _globals['_GETMETRICSRESPONSE']._serialized_end=13355 + _globals['_COMPONENTINFO']._serialized_start=13358 + _globals['_COMPONENTINFO']._serialized_end=13510 + _globals['_COMPONENTSTATES']._serialized_start=13513 + _globals['_COMPONENTSTATES']._serialized_end=13691 + _globals['_GETCOMPONENTSTATESREQUEST']._serialized_start=13693 + _globals['_GETCOMPONENTSTATESREQUEST']._serialized_end=13720 + _globals['_LOADBALANCEREQUEST']._serialized_start=13723 + _globals['_LOADBALANCEREQUEST']._serialized_end=13905 + _globals['_MANUALCOMPACTIONREQUEST']._serialized_start=13907 + _globals['_MANUALCOMPACTIONREQUEST']._serialized_end=14008 + _globals['_MANUALCOMPACTIONRESPONSE']._serialized_start=14010 + _globals['_MANUALCOMPACTIONRESPONSE']._serialized_end=14132 + _globals['_GETCOMPACTIONSTATEREQUEST']._serialized_start=14134 + _globals['_GETCOMPACTIONSTATEREQUEST']._serialized_end=14183 + _globals['_GETCOMPACTIONSTATERESPONSE']._serialized_start=14186 + _globals['_GETCOMPACTIONSTATERESPONSE']._serialized_end=14407 + _globals['_GETCOMPACTIONPLANSREQUEST']._serialized_start=14409 + _globals['_GETCOMPACTIONPLANSREQUEST']._serialized_end=14458 + _globals['_GETCOMPACTIONPLANSRESPONSE']._serialized_start=14461 + _globals['_GETCOMPACTIONPLANSRESPONSE']._serialized_end=14649 + _globals['_COMPACTIONMERGEINFO']._serialized_start=14651 + _globals['_COMPACTIONMERGEINFO']._serialized_end=14705 + _globals['_GETFLUSHSTATEREQUEST']._serialized_start=14707 + _globals['_GETFLUSHSTATEREQUEST']._serialized_end=14818 + _globals['_GETFLUSHSTATERESPONSE']._serialized_start=14820 + _globals['_GETFLUSHSTATERESPONSE']._serialized_end=14905 + _globals['_GETFLUSHALLSTATEREQUEST']._serialized_start=14907 + _globals['_GETFLUSHALLSTATEREQUEST']._serialized_end=15015 + _globals['_GETFLUSHALLSTATERESPONSE']._serialized_start=15017 + _globals['_GETFLUSHALLSTATERESPONSE']._serialized_end=15105 + _globals['_IMPORTREQUEST']._serialized_start=15108 + _globals['_IMPORTREQUEST']._serialized_end=15332 + _globals['_IMPORTRESPONSE']._serialized_start=15334 + _globals['_IMPORTRESPONSE']._serialized_end=15410 + _globals['_GETIMPORTSTATEREQUEST']._serialized_start=15412 + _globals['_GETIMPORTSTATEREQUEST']._serialized_end=15449 + _globals['_GETIMPORTSTATERESPONSE']._serialized_start=15452 + _globals['_GETIMPORTSTATERESPONSE']._serialized_end=15731 + _globals['_LISTIMPORTTASKSREQUEST']._serialized_start=15733 + _globals['_LISTIMPORTTASKSREQUEST']._serialized_end=15814 + _globals['_LISTIMPORTTASKSRESPONSE']._serialized_start=15817 + _globals['_LISTIMPORTTASKSRESPONSE']._serialized_end=15947 + _globals['_GETREPLICASREQUEST']._serialized_start=15950 + _globals['_GETREPLICASREQUEST']._serialized_end=16104 + _globals['_GETREPLICASRESPONSE']._serialized_start=16106 + _globals['_GETREPLICASRESPONSE']._serialized_end=16224 + _globals['_REPLICAINFO']._serialized_start=16227 + _globals['_REPLICAINFO']._serialized_end=16548 + _globals['_REPLICAINFO_NUMOUTBOUNDNODEENTRY']._serialized_start=16494 + _globals['_REPLICAINFO_NUMOUTBOUNDNODEENTRY']._serialized_end=16548 + _globals['_SHARDREPLICA']._serialized_start=16550 + _globals['_SHARDREPLICA']._serialized_end=16646 + _globals['_CREATECREDENTIALREQUEST']._serialized_start=16649 + _globals['_CREATECREDENTIALREQUEST']._serialized_end=16839 + _globals['_UPDATECREDENTIALREQUEST']._serialized_start=16842 + _globals['_UPDATECREDENTIALREQUEST']._serialized_end=17047 + _globals['_DELETECREDENTIALREQUEST']._serialized_start=17049 + _globals['_DELETECREDENTIALREQUEST']._serialized_end=17156 + _globals['_LISTCREDUSERSRESPONSE']._serialized_start=17158 + _globals['_LISTCREDUSERSRESPONSE']._serialized_end=17245 + _globals['_LISTCREDUSERSREQUEST']._serialized_start=17247 + _globals['_LISTCREDUSERSREQUEST']._serialized_end=17333 + _globals['_ROLEENTITY']._serialized_start=17335 + _globals['_ROLEENTITY']._serialized_end=17361 + _globals['_USERENTITY']._serialized_start=17363 + _globals['_USERENTITY']._serialized_end=17389 + _globals['_CREATEROLEREQUEST']._serialized_start=17392 + _globals['_CREATEROLEREQUEST']._serialized_end=17524 + _globals['_DROPROLEREQUEST']._serialized_start=17526 + _globals['_DROPROLEREQUEST']._serialized_end=17626 + _globals['_OPERATEUSERROLEREQUEST']._serialized_start=17629 + _globals['_OPERATEUSERROLEREQUEST']._serialized_end=17810 + _globals['_SELECTROLEREQUEST']._serialized_start=17813 + _globals['_SELECTROLEREQUEST']._serialized_end=17970 + _globals['_ROLERESULT']._serialized_start=17972 + _globals['_ROLERESULT']._serialized_end=18079 + _globals['_SELECTROLERESPONSE']._serialized_start=18081 + _globals['_SELECTROLERESPONSE']._serialized_end=18196 + _globals['_SELECTUSERREQUEST']._serialized_start=18199 + _globals['_SELECTUSERREQUEST']._serialized_end=18347 + _globals['_USERRESULT']._serialized_start=18349 + _globals['_USERRESULT']._serialized_end=18456 + _globals['_SELECTUSERRESPONSE']._serialized_start=18458 + _globals['_SELECTUSERRESPONSE']._serialized_end=18573 + _globals['_OBJECTENTITY']._serialized_start=18575 + _globals['_OBJECTENTITY']._serialized_end=18603 + _globals['_PRIVILEGEENTITY']._serialized_start=18605 + _globals['_PRIVILEGEENTITY']._serialized_end=18636 + _globals['_GRANTORENTITY']._serialized_start=18638 + _globals['_GRANTORENTITY']._serialized_end=18757 + _globals['_GRANTPRIVILEGEENTITY']._serialized_start=18759 + _globals['_GRANTPRIVILEGEENTITY']._serialized_end=18835 + _globals['_GRANTENTITY']._serialized_start=18838 + _globals['_GRANTENTITY']._serialized_end=19040 + _globals['_SELECTGRANTREQUEST']._serialized_start=19043 + _globals['_SELECTGRANTREQUEST']._serialized_end=19177 + _globals['_SELECTGRANTRESPONSE']._serialized_start=19179 + _globals['_SELECTGRANTRESPONSE']._serialized_end=19297 + _globals['_OPERATEPRIVILEGEREQUEST']._serialized_start=19300 + _globals['_OPERATEPRIVILEGEREQUEST']._serialized_end=19496 + _globals['_GETLOADINGPROGRESSREQUEST']._serialized_start=19499 + _globals['_GETLOADINGPROGRESSREQUEST']._serialized_end=19646 + _globals['_GETLOADINGPROGRESSRESPONSE']._serialized_start=19648 + _globals['_GETLOADINGPROGRESSRESPONSE']._serialized_end=19765 + _globals['_GETLOADSTATEREQUEST']._serialized_start=19768 + _globals['_GETLOADSTATEREQUEST']._serialized_end=19909 + _globals['_GETLOADSTATERESPONSE']._serialized_start=19911 + _globals['_GETLOADSTATERESPONSE']._serialized_end=20025 + _globals['_MILVUSEXT']._serialized_start=20027 + _globals['_MILVUSEXT']._serialized_end=20055 + _globals['_GETVERSIONREQUEST']._serialized_start=20057 + _globals['_GETVERSIONREQUEST']._serialized_end=20076 + _globals['_GETVERSIONRESPONSE']._serialized_start=20078 + _globals['_GETVERSIONRESPONSE']._serialized_end=20160 + _globals['_CHECKHEALTHREQUEST']._serialized_start=20162 + _globals['_CHECKHEALTHREQUEST']._serialized_end=20182 + _globals['_CHECKHEALTHRESPONSE']._serialized_start=20185 + _globals['_CHECKHEALTHRESPONSE']._serialized_end=20342 + _globals['_CREATERESOURCEGROUPREQUEST']._serialized_start=20345 + _globals['_CREATERESOURCEGROUPREQUEST']._serialized_end=20515 + _globals['_UPDATERESOURCEGROUPSREQUEST']._serialized_start=20518 + _globals['_UPDATERESOURCEGROUPSREQUEST']._serialized_end=20799 + _globals['_UPDATERESOURCEGROUPSREQUEST_RESOURCEGROUPSENTRY']._serialized_start=20688 + _globals['_UPDATERESOURCEGROUPSREQUEST_RESOURCEGROUPSENTRY']._serialized_end=20779 + _globals['_DROPRESOURCEGROUPREQUEST']._serialized_start=20801 + _globals['_DROPRESOURCEGROUPREQUEST']._serialized_end=20915 + _globals['_TRANSFERNODEREQUEST']._serialized_start=20918 + _globals['_TRANSFERNODEREQUEST']._serialized_end=21083 + _globals['_TRANSFERREPLICAREQUEST']._serialized_start=21086 + _globals['_TRANSFERREPLICAREQUEST']._serialized_end=21299 + _globals['_LISTRESOURCEGROUPSREQUEST']._serialized_start=21301 + _globals['_LISTRESOURCEGROUPSREQUEST']._serialized_end=21392 + _globals['_LISTRESOURCEGROUPSRESPONSE']._serialized_start=21394 + _globals['_LISTRESOURCEGROUPSRESPONSE']._serialized_end=21492 + _globals['_DESCRIBERESOURCEGROUPREQUEST']._serialized_start=21494 + _globals['_DESCRIBERESOURCEGROUPREQUEST']._serialized_end=21612 + _globals['_DESCRIBERESOURCEGROUPRESPONSE']._serialized_start=21615 + _globals['_DESCRIBERESOURCEGROUPRESPONSE']._serialized_end=21751 + _globals['_RESOURCEGROUP']._serialized_start=21754 + _globals['_RESOURCEGROUP']._serialized_end=22352 + _globals['_RESOURCEGROUP_NUMLOADEDREPLICAENTRY']._serialized_start=22185 + _globals['_RESOURCEGROUP_NUMLOADEDREPLICAENTRY']._serialized_end=22240 + _globals['_RESOURCEGROUP_NUMOUTGOINGNODEENTRY']._serialized_start=22242 + _globals['_RESOURCEGROUP_NUMOUTGOINGNODEENTRY']._serialized_end=22296 + _globals['_RESOURCEGROUP_NUMINCOMINGNODEENTRY']._serialized_start=22298 + _globals['_RESOURCEGROUP_NUMINCOMINGNODEENTRY']._serialized_end=22352 + _globals['_RENAMECOLLECTIONREQUEST']._serialized_start=22355 + _globals['_RENAMECOLLECTIONREQUEST']._serialized_end=22514 + _globals['_GETINDEXSTATISTICSREQUEST']._serialized_start=22517 + _globals['_GETINDEXSTATISTICSREQUEST']._serialized_end=22678 + _globals['_GETINDEXSTATISTICSRESPONSE']._serialized_start=22681 + _globals['_GETINDEXSTATISTICSRESPONSE']._serialized_end=22821 + _globals['_CONNECTREQUEST']._serialized_start=22823 + _globals['_CONNECTREQUEST']._serialized_end=22937 + _globals['_CONNECTRESPONSE']._serialized_start=22940 + _globals['_CONNECTRESPONSE']._serialized_end=23076 + _globals['_ALLOCTIMESTAMPREQUEST']._serialized_start=23078 + _globals['_ALLOCTIMESTAMPREQUEST']._serialized_end=23145 + _globals['_ALLOCTIMESTAMPRESPONSE']._serialized_start=23147 + _globals['_ALLOCTIMESTAMPRESPONSE']._serialized_end=23235 + _globals['_CREATEDATABASEREQUEST']._serialized_start=23237 + _globals['_CREATEDATABASEREQUEST']._serialized_end=23341 + _globals['_DROPDATABASEREQUEST']._serialized_start=23343 + _globals['_DROPDATABASEREQUEST']._serialized_end=23445 + _globals['_LISTDATABASESREQUEST']._serialized_start=23447 + _globals['_LISTDATABASESREQUEST']._serialized_end=23533 + _globals['_LISTDATABASESRESPONSE']._serialized_start=23536 + _globals['_LISTDATABASESRESPONSE']._serialized_end=23669 + _globals['_REPLICATEMESSAGEREQUEST']._serialized_start=23672 + _globals['_REPLICATEMESSAGEREQUEST']._serialized_end=23917 + _globals['_REPLICATEMESSAGERESPONSE']._serialized_start=23919 + _globals['_REPLICATEMESSAGERESPONSE']._serialized_end=24008 + _globals['_MILVUSSERVICE']._serialized_start=24258 + _globals['_MILVUSSERVICE']._serialized_end=32814 + _globals['_PROXYSERVICE']._serialized_start=32816 + _globals['_PROXYSERVICE']._serialized_end=32933 +# @@protoc_insertion_point(module_scope) diff --git a/milvus_connector/protocol/milvus_pb2.pyi b/milvus_connector/protocol/milvus_pb2.pyi new file mode 100644 index 0000000..10d62f8 --- /dev/null +++ b/milvus_connector/protocol/milvus_pb2.pyi @@ -0,0 +1,1894 @@ +from . import common_pb2 as _common_pb2 +from . import rg_pb2 as _rg_pb2 +from . import schema_pb2 as _schema_pb2 +from . import feder_pb2 as _feder_pb2 +from . import msg_pb2 as _msg_pb2 +from google.protobuf import descriptor_pb2 as _descriptor_pb2 +from google.protobuf.internal import containers as _containers +from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Iterable as _Iterable, Mapping as _Mapping, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class ShowType(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = () + All: _ClassVar[ShowType] + InMemory: _ClassVar[ShowType] + +class OperateUserRoleType(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = () + AddUserToRole: _ClassVar[OperateUserRoleType] + RemoveUserFromRole: _ClassVar[OperateUserRoleType] + +class OperatePrivilegeType(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = () + Grant: _ClassVar[OperatePrivilegeType] + Revoke: _ClassVar[OperatePrivilegeType] + +class QuotaState(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = () + Unknown: _ClassVar[QuotaState] + ReadLimited: _ClassVar[QuotaState] + WriteLimited: _ClassVar[QuotaState] + DenyToRead: _ClassVar[QuotaState] + DenyToWrite: _ClassVar[QuotaState] +All: ShowType +InMemory: ShowType +AddUserToRole: OperateUserRoleType +RemoveUserFromRole: OperateUserRoleType +Grant: OperatePrivilegeType +Revoke: OperatePrivilegeType +Unknown: QuotaState +ReadLimited: QuotaState +WriteLimited: QuotaState +DenyToRead: QuotaState +DenyToWrite: QuotaState +MILVUS_EXT_OBJ_FIELD_NUMBER: _ClassVar[int] +milvus_ext_obj: _descriptor.FieldDescriptor + +class CreateAliasRequest(_message.Message): + __slots__ = ("base", "db_name", "collection_name", "alias") + BASE_FIELD_NUMBER: _ClassVar[int] + DB_NAME_FIELD_NUMBER: _ClassVar[int] + COLLECTION_NAME_FIELD_NUMBER: _ClassVar[int] + ALIAS_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + db_name: str + collection_name: str + alias: str + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., db_name: _Optional[str] = ..., collection_name: _Optional[str] = ..., alias: _Optional[str] = ...) -> None: ... + +class DropAliasRequest(_message.Message): + __slots__ = ("base", "db_name", "alias") + BASE_FIELD_NUMBER: _ClassVar[int] + DB_NAME_FIELD_NUMBER: _ClassVar[int] + ALIAS_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + db_name: str + alias: str + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., db_name: _Optional[str] = ..., alias: _Optional[str] = ...) -> None: ... + +class AlterAliasRequest(_message.Message): + __slots__ = ("base", "db_name", "collection_name", "alias") + BASE_FIELD_NUMBER: _ClassVar[int] + DB_NAME_FIELD_NUMBER: _ClassVar[int] + COLLECTION_NAME_FIELD_NUMBER: _ClassVar[int] + ALIAS_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + db_name: str + collection_name: str + alias: str + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., db_name: _Optional[str] = ..., collection_name: _Optional[str] = ..., alias: _Optional[str] = ...) -> None: ... + +class DescribeAliasRequest(_message.Message): + __slots__ = ("base", "db_name", "alias") + BASE_FIELD_NUMBER: _ClassVar[int] + DB_NAME_FIELD_NUMBER: _ClassVar[int] + ALIAS_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + db_name: str + alias: str + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., db_name: _Optional[str] = ..., alias: _Optional[str] = ...) -> None: ... + +class DescribeAliasResponse(_message.Message): + __slots__ = ("status", "db_name", "alias", "collection") + STATUS_FIELD_NUMBER: _ClassVar[int] + DB_NAME_FIELD_NUMBER: _ClassVar[int] + ALIAS_FIELD_NUMBER: _ClassVar[int] + COLLECTION_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + db_name: str + alias: str + collection: str + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., db_name: _Optional[str] = ..., alias: _Optional[str] = ..., collection: _Optional[str] = ...) -> None: ... + +class ListAliasesRequest(_message.Message): + __slots__ = ("base", "db_name", "collection_name") + BASE_FIELD_NUMBER: _ClassVar[int] + DB_NAME_FIELD_NUMBER: _ClassVar[int] + COLLECTION_NAME_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + db_name: str + collection_name: str + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., db_name: _Optional[str] = ..., collection_name: _Optional[str] = ...) -> None: ... + +class ListAliasesResponse(_message.Message): + __slots__ = ("status", "db_name", "collection_name", "aliases") + STATUS_FIELD_NUMBER: _ClassVar[int] + DB_NAME_FIELD_NUMBER: _ClassVar[int] + COLLECTION_NAME_FIELD_NUMBER: _ClassVar[int] + ALIASES_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + db_name: str + collection_name: str + aliases: _containers.RepeatedScalarFieldContainer[str] + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., db_name: _Optional[str] = ..., collection_name: _Optional[str] = ..., aliases: _Optional[_Iterable[str]] = ...) -> None: ... + +class CreateCollectionRequest(_message.Message): + __slots__ = ("base", "db_name", "collection_name", "schema", "shards_num", "consistency_level", "properties", "num_partitions") + BASE_FIELD_NUMBER: _ClassVar[int] + DB_NAME_FIELD_NUMBER: _ClassVar[int] + COLLECTION_NAME_FIELD_NUMBER: _ClassVar[int] + SCHEMA_FIELD_NUMBER: _ClassVar[int] + SHARDS_NUM_FIELD_NUMBER: _ClassVar[int] + CONSISTENCY_LEVEL_FIELD_NUMBER: _ClassVar[int] + PROPERTIES_FIELD_NUMBER: _ClassVar[int] + NUM_PARTITIONS_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + db_name: str + collection_name: str + schema: bytes + shards_num: int + consistency_level: _common_pb2.ConsistencyLevel + properties: _containers.RepeatedCompositeFieldContainer[_common_pb2.KeyValuePair] + num_partitions: int + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., db_name: _Optional[str] = ..., collection_name: _Optional[str] = ..., schema: _Optional[bytes] = ..., shards_num: _Optional[int] = ..., consistency_level: _Optional[_Union[_common_pb2.ConsistencyLevel, str]] = ..., properties: _Optional[_Iterable[_Union[_common_pb2.KeyValuePair, _Mapping]]] = ..., num_partitions: _Optional[int] = ...) -> None: ... + +class DropCollectionRequest(_message.Message): + __slots__ = ("base", "db_name", "collection_name") + BASE_FIELD_NUMBER: _ClassVar[int] + DB_NAME_FIELD_NUMBER: _ClassVar[int] + COLLECTION_NAME_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + db_name: str + collection_name: str + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., db_name: _Optional[str] = ..., collection_name: _Optional[str] = ...) -> None: ... + +class AlterCollectionRequest(_message.Message): + __slots__ = ("base", "db_name", "collection_name", "collectionID", "properties") + BASE_FIELD_NUMBER: _ClassVar[int] + DB_NAME_FIELD_NUMBER: _ClassVar[int] + COLLECTION_NAME_FIELD_NUMBER: _ClassVar[int] + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + PROPERTIES_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + db_name: str + collection_name: str + collectionID: int + properties: _containers.RepeatedCompositeFieldContainer[_common_pb2.KeyValuePair] + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., db_name: _Optional[str] = ..., collection_name: _Optional[str] = ..., collectionID: _Optional[int] = ..., properties: _Optional[_Iterable[_Union[_common_pb2.KeyValuePair, _Mapping]]] = ...) -> None: ... + +class HasCollectionRequest(_message.Message): + __slots__ = ("base", "db_name", "collection_name", "time_stamp") + BASE_FIELD_NUMBER: _ClassVar[int] + DB_NAME_FIELD_NUMBER: _ClassVar[int] + COLLECTION_NAME_FIELD_NUMBER: _ClassVar[int] + TIME_STAMP_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + db_name: str + collection_name: str + time_stamp: int + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., db_name: _Optional[str] = ..., collection_name: _Optional[str] = ..., time_stamp: _Optional[int] = ...) -> None: ... + +class BoolResponse(_message.Message): + __slots__ = ("status", "value") + STATUS_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + value: bool + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., value: bool = ...) -> None: ... + +class StringResponse(_message.Message): + __slots__ = ("status", "value") + STATUS_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + value: str + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., value: _Optional[str] = ...) -> None: ... + +class DescribeCollectionRequest(_message.Message): + __slots__ = ("base", "db_name", "collection_name", "collectionID", "time_stamp") + BASE_FIELD_NUMBER: _ClassVar[int] + DB_NAME_FIELD_NUMBER: _ClassVar[int] + COLLECTION_NAME_FIELD_NUMBER: _ClassVar[int] + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + TIME_STAMP_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + db_name: str + collection_name: str + collectionID: int + time_stamp: int + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., db_name: _Optional[str] = ..., collection_name: _Optional[str] = ..., collectionID: _Optional[int] = ..., time_stamp: _Optional[int] = ...) -> None: ... + +class DescribeCollectionResponse(_message.Message): + __slots__ = ("status", "schema", "collectionID", "virtual_channel_names", "physical_channel_names", "created_timestamp", "created_utc_timestamp", "shards_num", "aliases", "start_positions", "consistency_level", "collection_name", "properties", "db_name", "num_partitions") + STATUS_FIELD_NUMBER: _ClassVar[int] + SCHEMA_FIELD_NUMBER: _ClassVar[int] + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + VIRTUAL_CHANNEL_NAMES_FIELD_NUMBER: _ClassVar[int] + PHYSICAL_CHANNEL_NAMES_FIELD_NUMBER: _ClassVar[int] + CREATED_TIMESTAMP_FIELD_NUMBER: _ClassVar[int] + CREATED_UTC_TIMESTAMP_FIELD_NUMBER: _ClassVar[int] + SHARDS_NUM_FIELD_NUMBER: _ClassVar[int] + ALIASES_FIELD_NUMBER: _ClassVar[int] + START_POSITIONS_FIELD_NUMBER: _ClassVar[int] + CONSISTENCY_LEVEL_FIELD_NUMBER: _ClassVar[int] + COLLECTION_NAME_FIELD_NUMBER: _ClassVar[int] + PROPERTIES_FIELD_NUMBER: _ClassVar[int] + DB_NAME_FIELD_NUMBER: _ClassVar[int] + NUM_PARTITIONS_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + schema: _schema_pb2.CollectionSchema + collectionID: int + virtual_channel_names: _containers.RepeatedScalarFieldContainer[str] + physical_channel_names: _containers.RepeatedScalarFieldContainer[str] + created_timestamp: int + created_utc_timestamp: int + shards_num: int + aliases: _containers.RepeatedScalarFieldContainer[str] + start_positions: _containers.RepeatedCompositeFieldContainer[_common_pb2.KeyDataPair] + consistency_level: _common_pb2.ConsistencyLevel + collection_name: str + properties: _containers.RepeatedCompositeFieldContainer[_common_pb2.KeyValuePair] + db_name: str + num_partitions: int + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., schema: _Optional[_Union[_schema_pb2.CollectionSchema, _Mapping]] = ..., collectionID: _Optional[int] = ..., virtual_channel_names: _Optional[_Iterable[str]] = ..., physical_channel_names: _Optional[_Iterable[str]] = ..., created_timestamp: _Optional[int] = ..., created_utc_timestamp: _Optional[int] = ..., shards_num: _Optional[int] = ..., aliases: _Optional[_Iterable[str]] = ..., start_positions: _Optional[_Iterable[_Union[_common_pb2.KeyDataPair, _Mapping]]] = ..., consistency_level: _Optional[_Union[_common_pb2.ConsistencyLevel, str]] = ..., collection_name: _Optional[str] = ..., properties: _Optional[_Iterable[_Union[_common_pb2.KeyValuePair, _Mapping]]] = ..., db_name: _Optional[str] = ..., num_partitions: _Optional[int] = ...) -> None: ... + +class LoadCollectionRequest(_message.Message): + __slots__ = ("base", "db_name", "collection_name", "replica_number", "resource_groups", "refresh") + BASE_FIELD_NUMBER: _ClassVar[int] + DB_NAME_FIELD_NUMBER: _ClassVar[int] + COLLECTION_NAME_FIELD_NUMBER: _ClassVar[int] + REPLICA_NUMBER_FIELD_NUMBER: _ClassVar[int] + RESOURCE_GROUPS_FIELD_NUMBER: _ClassVar[int] + REFRESH_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + db_name: str + collection_name: str + replica_number: int + resource_groups: _containers.RepeatedScalarFieldContainer[str] + refresh: bool + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., db_name: _Optional[str] = ..., collection_name: _Optional[str] = ..., replica_number: _Optional[int] = ..., resource_groups: _Optional[_Iterable[str]] = ..., refresh: bool = ...) -> None: ... + +class ReleaseCollectionRequest(_message.Message): + __slots__ = ("base", "db_name", "collection_name") + BASE_FIELD_NUMBER: _ClassVar[int] + DB_NAME_FIELD_NUMBER: _ClassVar[int] + COLLECTION_NAME_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + db_name: str + collection_name: str + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., db_name: _Optional[str] = ..., collection_name: _Optional[str] = ...) -> None: ... + +class GetStatisticsRequest(_message.Message): + __slots__ = ("base", "db_name", "collection_name", "partition_names", "guarantee_timestamp") + BASE_FIELD_NUMBER: _ClassVar[int] + DB_NAME_FIELD_NUMBER: _ClassVar[int] + COLLECTION_NAME_FIELD_NUMBER: _ClassVar[int] + PARTITION_NAMES_FIELD_NUMBER: _ClassVar[int] + GUARANTEE_TIMESTAMP_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + db_name: str + collection_name: str + partition_names: _containers.RepeatedScalarFieldContainer[str] + guarantee_timestamp: int + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., db_name: _Optional[str] = ..., collection_name: _Optional[str] = ..., partition_names: _Optional[_Iterable[str]] = ..., guarantee_timestamp: _Optional[int] = ...) -> None: ... + +class GetStatisticsResponse(_message.Message): + __slots__ = ("status", "stats") + STATUS_FIELD_NUMBER: _ClassVar[int] + STATS_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + stats: _containers.RepeatedCompositeFieldContainer[_common_pb2.KeyValuePair] + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., stats: _Optional[_Iterable[_Union[_common_pb2.KeyValuePair, _Mapping]]] = ...) -> None: ... + +class GetCollectionStatisticsRequest(_message.Message): + __slots__ = ("base", "db_name", "collection_name") + BASE_FIELD_NUMBER: _ClassVar[int] + DB_NAME_FIELD_NUMBER: _ClassVar[int] + COLLECTION_NAME_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + db_name: str + collection_name: str + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., db_name: _Optional[str] = ..., collection_name: _Optional[str] = ...) -> None: ... + +class GetCollectionStatisticsResponse(_message.Message): + __slots__ = ("status", "stats") + STATUS_FIELD_NUMBER: _ClassVar[int] + STATS_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + stats: _containers.RepeatedCompositeFieldContainer[_common_pb2.KeyValuePair] + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., stats: _Optional[_Iterable[_Union[_common_pb2.KeyValuePair, _Mapping]]] = ...) -> None: ... + +class ShowCollectionsRequest(_message.Message): + __slots__ = ("base", "db_name", "time_stamp", "type", "collection_names") + BASE_FIELD_NUMBER: _ClassVar[int] + DB_NAME_FIELD_NUMBER: _ClassVar[int] + TIME_STAMP_FIELD_NUMBER: _ClassVar[int] + TYPE_FIELD_NUMBER: _ClassVar[int] + COLLECTION_NAMES_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + db_name: str + time_stamp: int + type: ShowType + collection_names: _containers.RepeatedScalarFieldContainer[str] + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., db_name: _Optional[str] = ..., time_stamp: _Optional[int] = ..., type: _Optional[_Union[ShowType, str]] = ..., collection_names: _Optional[_Iterable[str]] = ...) -> None: ... + +class ShowCollectionsResponse(_message.Message): + __slots__ = ("status", "collection_names", "collection_ids", "created_timestamps", "created_utc_timestamps", "inMemory_percentages", "query_service_available") + STATUS_FIELD_NUMBER: _ClassVar[int] + COLLECTION_NAMES_FIELD_NUMBER: _ClassVar[int] + COLLECTION_IDS_FIELD_NUMBER: _ClassVar[int] + CREATED_TIMESTAMPS_FIELD_NUMBER: _ClassVar[int] + CREATED_UTC_TIMESTAMPS_FIELD_NUMBER: _ClassVar[int] + INMEMORY_PERCENTAGES_FIELD_NUMBER: _ClassVar[int] + QUERY_SERVICE_AVAILABLE_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + collection_names: _containers.RepeatedScalarFieldContainer[str] + collection_ids: _containers.RepeatedScalarFieldContainer[int] + created_timestamps: _containers.RepeatedScalarFieldContainer[int] + created_utc_timestamps: _containers.RepeatedScalarFieldContainer[int] + inMemory_percentages: _containers.RepeatedScalarFieldContainer[int] + query_service_available: _containers.RepeatedScalarFieldContainer[bool] + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., collection_names: _Optional[_Iterable[str]] = ..., collection_ids: _Optional[_Iterable[int]] = ..., created_timestamps: _Optional[_Iterable[int]] = ..., created_utc_timestamps: _Optional[_Iterable[int]] = ..., inMemory_percentages: _Optional[_Iterable[int]] = ..., query_service_available: _Optional[_Iterable[bool]] = ...) -> None: ... + +class CreatePartitionRequest(_message.Message): + __slots__ = ("base", "db_name", "collection_name", "partition_name") + BASE_FIELD_NUMBER: _ClassVar[int] + DB_NAME_FIELD_NUMBER: _ClassVar[int] + COLLECTION_NAME_FIELD_NUMBER: _ClassVar[int] + PARTITION_NAME_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + db_name: str + collection_name: str + partition_name: str + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., db_name: _Optional[str] = ..., collection_name: _Optional[str] = ..., partition_name: _Optional[str] = ...) -> None: ... + +class DropPartitionRequest(_message.Message): + __slots__ = ("base", "db_name", "collection_name", "partition_name") + BASE_FIELD_NUMBER: _ClassVar[int] + DB_NAME_FIELD_NUMBER: _ClassVar[int] + COLLECTION_NAME_FIELD_NUMBER: _ClassVar[int] + PARTITION_NAME_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + db_name: str + collection_name: str + partition_name: str + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., db_name: _Optional[str] = ..., collection_name: _Optional[str] = ..., partition_name: _Optional[str] = ...) -> None: ... + +class HasPartitionRequest(_message.Message): + __slots__ = ("base", "db_name", "collection_name", "partition_name") + BASE_FIELD_NUMBER: _ClassVar[int] + DB_NAME_FIELD_NUMBER: _ClassVar[int] + COLLECTION_NAME_FIELD_NUMBER: _ClassVar[int] + PARTITION_NAME_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + db_name: str + collection_name: str + partition_name: str + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., db_name: _Optional[str] = ..., collection_name: _Optional[str] = ..., partition_name: _Optional[str] = ...) -> None: ... + +class LoadPartitionsRequest(_message.Message): + __slots__ = ("base", "db_name", "collection_name", "partition_names", "replica_number", "resource_groups", "refresh") + BASE_FIELD_NUMBER: _ClassVar[int] + DB_NAME_FIELD_NUMBER: _ClassVar[int] + COLLECTION_NAME_FIELD_NUMBER: _ClassVar[int] + PARTITION_NAMES_FIELD_NUMBER: _ClassVar[int] + REPLICA_NUMBER_FIELD_NUMBER: _ClassVar[int] + RESOURCE_GROUPS_FIELD_NUMBER: _ClassVar[int] + REFRESH_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + db_name: str + collection_name: str + partition_names: _containers.RepeatedScalarFieldContainer[str] + replica_number: int + resource_groups: _containers.RepeatedScalarFieldContainer[str] + refresh: bool + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., db_name: _Optional[str] = ..., collection_name: _Optional[str] = ..., partition_names: _Optional[_Iterable[str]] = ..., replica_number: _Optional[int] = ..., resource_groups: _Optional[_Iterable[str]] = ..., refresh: bool = ...) -> None: ... + +class ReleasePartitionsRequest(_message.Message): + __slots__ = ("base", "db_name", "collection_name", "partition_names") + BASE_FIELD_NUMBER: _ClassVar[int] + DB_NAME_FIELD_NUMBER: _ClassVar[int] + COLLECTION_NAME_FIELD_NUMBER: _ClassVar[int] + PARTITION_NAMES_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + db_name: str + collection_name: str + partition_names: _containers.RepeatedScalarFieldContainer[str] + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., db_name: _Optional[str] = ..., collection_name: _Optional[str] = ..., partition_names: _Optional[_Iterable[str]] = ...) -> None: ... + +class GetPartitionStatisticsRequest(_message.Message): + __slots__ = ("base", "db_name", "collection_name", "partition_name") + BASE_FIELD_NUMBER: _ClassVar[int] + DB_NAME_FIELD_NUMBER: _ClassVar[int] + COLLECTION_NAME_FIELD_NUMBER: _ClassVar[int] + PARTITION_NAME_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + db_name: str + collection_name: str + partition_name: str + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., db_name: _Optional[str] = ..., collection_name: _Optional[str] = ..., partition_name: _Optional[str] = ...) -> None: ... + +class GetPartitionStatisticsResponse(_message.Message): + __slots__ = ("status", "stats") + STATUS_FIELD_NUMBER: _ClassVar[int] + STATS_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + stats: _containers.RepeatedCompositeFieldContainer[_common_pb2.KeyValuePair] + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., stats: _Optional[_Iterable[_Union[_common_pb2.KeyValuePair, _Mapping]]] = ...) -> None: ... + +class ShowPartitionsRequest(_message.Message): + __slots__ = ("base", "db_name", "collection_name", "collectionID", "partition_names", "type") + BASE_FIELD_NUMBER: _ClassVar[int] + DB_NAME_FIELD_NUMBER: _ClassVar[int] + COLLECTION_NAME_FIELD_NUMBER: _ClassVar[int] + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + PARTITION_NAMES_FIELD_NUMBER: _ClassVar[int] + TYPE_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + db_name: str + collection_name: str + collectionID: int + partition_names: _containers.RepeatedScalarFieldContainer[str] + type: ShowType + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., db_name: _Optional[str] = ..., collection_name: _Optional[str] = ..., collectionID: _Optional[int] = ..., partition_names: _Optional[_Iterable[str]] = ..., type: _Optional[_Union[ShowType, str]] = ...) -> None: ... + +class ShowPartitionsResponse(_message.Message): + __slots__ = ("status", "partition_names", "partitionIDs", "created_timestamps", "created_utc_timestamps", "inMemory_percentages") + STATUS_FIELD_NUMBER: _ClassVar[int] + PARTITION_NAMES_FIELD_NUMBER: _ClassVar[int] + PARTITIONIDS_FIELD_NUMBER: _ClassVar[int] + CREATED_TIMESTAMPS_FIELD_NUMBER: _ClassVar[int] + CREATED_UTC_TIMESTAMPS_FIELD_NUMBER: _ClassVar[int] + INMEMORY_PERCENTAGES_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + partition_names: _containers.RepeatedScalarFieldContainer[str] + partitionIDs: _containers.RepeatedScalarFieldContainer[int] + created_timestamps: _containers.RepeatedScalarFieldContainer[int] + created_utc_timestamps: _containers.RepeatedScalarFieldContainer[int] + inMemory_percentages: _containers.RepeatedScalarFieldContainer[int] + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., partition_names: _Optional[_Iterable[str]] = ..., partitionIDs: _Optional[_Iterable[int]] = ..., created_timestamps: _Optional[_Iterable[int]] = ..., created_utc_timestamps: _Optional[_Iterable[int]] = ..., inMemory_percentages: _Optional[_Iterable[int]] = ...) -> None: ... + +class DescribeSegmentRequest(_message.Message): + __slots__ = ("base", "collectionID", "segmentID") + BASE_FIELD_NUMBER: _ClassVar[int] + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + SEGMENTID_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + collectionID: int + segmentID: int + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., collectionID: _Optional[int] = ..., segmentID: _Optional[int] = ...) -> None: ... + +class DescribeSegmentResponse(_message.Message): + __slots__ = ("status", "indexID", "buildID", "enable_index", "fieldID") + STATUS_FIELD_NUMBER: _ClassVar[int] + INDEXID_FIELD_NUMBER: _ClassVar[int] + BUILDID_FIELD_NUMBER: _ClassVar[int] + ENABLE_INDEX_FIELD_NUMBER: _ClassVar[int] + FIELDID_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + indexID: int + buildID: int + enable_index: bool + fieldID: int + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., indexID: _Optional[int] = ..., buildID: _Optional[int] = ..., enable_index: bool = ..., fieldID: _Optional[int] = ...) -> None: ... + +class ShowSegmentsRequest(_message.Message): + __slots__ = ("base", "collectionID", "partitionID") + BASE_FIELD_NUMBER: _ClassVar[int] + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + PARTITIONID_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + collectionID: int + partitionID: int + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., collectionID: _Optional[int] = ..., partitionID: _Optional[int] = ...) -> None: ... + +class ShowSegmentsResponse(_message.Message): + __slots__ = ("status", "segmentIDs") + STATUS_FIELD_NUMBER: _ClassVar[int] + SEGMENTIDS_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + segmentIDs: _containers.RepeatedScalarFieldContainer[int] + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., segmentIDs: _Optional[_Iterable[int]] = ...) -> None: ... + +class CreateIndexRequest(_message.Message): + __slots__ = ("base", "db_name", "collection_name", "field_name", "extra_params", "index_name") + BASE_FIELD_NUMBER: _ClassVar[int] + DB_NAME_FIELD_NUMBER: _ClassVar[int] + COLLECTION_NAME_FIELD_NUMBER: _ClassVar[int] + FIELD_NAME_FIELD_NUMBER: _ClassVar[int] + EXTRA_PARAMS_FIELD_NUMBER: _ClassVar[int] + INDEX_NAME_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + db_name: str + collection_name: str + field_name: str + extra_params: _containers.RepeatedCompositeFieldContainer[_common_pb2.KeyValuePair] + index_name: str + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., db_name: _Optional[str] = ..., collection_name: _Optional[str] = ..., field_name: _Optional[str] = ..., extra_params: _Optional[_Iterable[_Union[_common_pb2.KeyValuePair, _Mapping]]] = ..., index_name: _Optional[str] = ...) -> None: ... + +class AlterIndexRequest(_message.Message): + __slots__ = ("base", "db_name", "collection_name", "index_name", "extra_params") + BASE_FIELD_NUMBER: _ClassVar[int] + DB_NAME_FIELD_NUMBER: _ClassVar[int] + COLLECTION_NAME_FIELD_NUMBER: _ClassVar[int] + INDEX_NAME_FIELD_NUMBER: _ClassVar[int] + EXTRA_PARAMS_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + db_name: str + collection_name: str + index_name: str + extra_params: _containers.RepeatedCompositeFieldContainer[_common_pb2.KeyValuePair] + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., db_name: _Optional[str] = ..., collection_name: _Optional[str] = ..., index_name: _Optional[str] = ..., extra_params: _Optional[_Iterable[_Union[_common_pb2.KeyValuePair, _Mapping]]] = ...) -> None: ... + +class DescribeIndexRequest(_message.Message): + __slots__ = ("base", "db_name", "collection_name", "field_name", "index_name", "timestamp") + BASE_FIELD_NUMBER: _ClassVar[int] + DB_NAME_FIELD_NUMBER: _ClassVar[int] + COLLECTION_NAME_FIELD_NUMBER: _ClassVar[int] + FIELD_NAME_FIELD_NUMBER: _ClassVar[int] + INDEX_NAME_FIELD_NUMBER: _ClassVar[int] + TIMESTAMP_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + db_name: str + collection_name: str + field_name: str + index_name: str + timestamp: int + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., db_name: _Optional[str] = ..., collection_name: _Optional[str] = ..., field_name: _Optional[str] = ..., index_name: _Optional[str] = ..., timestamp: _Optional[int] = ...) -> None: ... + +class IndexDescription(_message.Message): + __slots__ = ("index_name", "indexID", "params", "field_name", "indexed_rows", "total_rows", "state", "index_state_fail_reason", "pending_index_rows") + INDEX_NAME_FIELD_NUMBER: _ClassVar[int] + INDEXID_FIELD_NUMBER: _ClassVar[int] + PARAMS_FIELD_NUMBER: _ClassVar[int] + FIELD_NAME_FIELD_NUMBER: _ClassVar[int] + INDEXED_ROWS_FIELD_NUMBER: _ClassVar[int] + TOTAL_ROWS_FIELD_NUMBER: _ClassVar[int] + STATE_FIELD_NUMBER: _ClassVar[int] + INDEX_STATE_FAIL_REASON_FIELD_NUMBER: _ClassVar[int] + PENDING_INDEX_ROWS_FIELD_NUMBER: _ClassVar[int] + index_name: str + indexID: int + params: _containers.RepeatedCompositeFieldContainer[_common_pb2.KeyValuePair] + field_name: str + indexed_rows: int + total_rows: int + state: _common_pb2.IndexState + index_state_fail_reason: str + pending_index_rows: int + def __init__(self, index_name: _Optional[str] = ..., indexID: _Optional[int] = ..., params: _Optional[_Iterable[_Union[_common_pb2.KeyValuePair, _Mapping]]] = ..., field_name: _Optional[str] = ..., indexed_rows: _Optional[int] = ..., total_rows: _Optional[int] = ..., state: _Optional[_Union[_common_pb2.IndexState, str]] = ..., index_state_fail_reason: _Optional[str] = ..., pending_index_rows: _Optional[int] = ...) -> None: ... + +class DescribeIndexResponse(_message.Message): + __slots__ = ("status", "index_descriptions") + STATUS_FIELD_NUMBER: _ClassVar[int] + INDEX_DESCRIPTIONS_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + index_descriptions: _containers.RepeatedCompositeFieldContainer[IndexDescription] + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., index_descriptions: _Optional[_Iterable[_Union[IndexDescription, _Mapping]]] = ...) -> None: ... + +class GetIndexBuildProgressRequest(_message.Message): + __slots__ = ("base", "db_name", "collection_name", "field_name", "index_name") + BASE_FIELD_NUMBER: _ClassVar[int] + DB_NAME_FIELD_NUMBER: _ClassVar[int] + COLLECTION_NAME_FIELD_NUMBER: _ClassVar[int] + FIELD_NAME_FIELD_NUMBER: _ClassVar[int] + INDEX_NAME_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + db_name: str + collection_name: str + field_name: str + index_name: str + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., db_name: _Optional[str] = ..., collection_name: _Optional[str] = ..., field_name: _Optional[str] = ..., index_name: _Optional[str] = ...) -> None: ... + +class GetIndexBuildProgressResponse(_message.Message): + __slots__ = ("status", "indexed_rows", "total_rows") + STATUS_FIELD_NUMBER: _ClassVar[int] + INDEXED_ROWS_FIELD_NUMBER: _ClassVar[int] + TOTAL_ROWS_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + indexed_rows: int + total_rows: int + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., indexed_rows: _Optional[int] = ..., total_rows: _Optional[int] = ...) -> None: ... + +class GetIndexStateRequest(_message.Message): + __slots__ = ("base", "db_name", "collection_name", "field_name", "index_name") + BASE_FIELD_NUMBER: _ClassVar[int] + DB_NAME_FIELD_NUMBER: _ClassVar[int] + COLLECTION_NAME_FIELD_NUMBER: _ClassVar[int] + FIELD_NAME_FIELD_NUMBER: _ClassVar[int] + INDEX_NAME_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + db_name: str + collection_name: str + field_name: str + index_name: str + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., db_name: _Optional[str] = ..., collection_name: _Optional[str] = ..., field_name: _Optional[str] = ..., index_name: _Optional[str] = ...) -> None: ... + +class GetIndexStateResponse(_message.Message): + __slots__ = ("status", "state", "fail_reason") + STATUS_FIELD_NUMBER: _ClassVar[int] + STATE_FIELD_NUMBER: _ClassVar[int] + FAIL_REASON_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + state: _common_pb2.IndexState + fail_reason: str + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., state: _Optional[_Union[_common_pb2.IndexState, str]] = ..., fail_reason: _Optional[str] = ...) -> None: ... + +class DropIndexRequest(_message.Message): + __slots__ = ("base", "db_name", "collection_name", "field_name", "index_name") + BASE_FIELD_NUMBER: _ClassVar[int] + DB_NAME_FIELD_NUMBER: _ClassVar[int] + COLLECTION_NAME_FIELD_NUMBER: _ClassVar[int] + FIELD_NAME_FIELD_NUMBER: _ClassVar[int] + INDEX_NAME_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + db_name: str + collection_name: str + field_name: str + index_name: str + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., db_name: _Optional[str] = ..., collection_name: _Optional[str] = ..., field_name: _Optional[str] = ..., index_name: _Optional[str] = ...) -> None: ... + +class InsertRequest(_message.Message): + __slots__ = ("base", "db_name", "collection_name", "partition_name", "fields_data", "hash_keys", "num_rows") + BASE_FIELD_NUMBER: _ClassVar[int] + DB_NAME_FIELD_NUMBER: _ClassVar[int] + COLLECTION_NAME_FIELD_NUMBER: _ClassVar[int] + PARTITION_NAME_FIELD_NUMBER: _ClassVar[int] + FIELDS_DATA_FIELD_NUMBER: _ClassVar[int] + HASH_KEYS_FIELD_NUMBER: _ClassVar[int] + NUM_ROWS_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + db_name: str + collection_name: str + partition_name: str + fields_data: _containers.RepeatedCompositeFieldContainer[_schema_pb2.FieldData] + hash_keys: _containers.RepeatedScalarFieldContainer[int] + num_rows: int + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., db_name: _Optional[str] = ..., collection_name: _Optional[str] = ..., partition_name: _Optional[str] = ..., fields_data: _Optional[_Iterable[_Union[_schema_pb2.FieldData, _Mapping]]] = ..., hash_keys: _Optional[_Iterable[int]] = ..., num_rows: _Optional[int] = ...) -> None: ... + +class UpsertRequest(_message.Message): + __slots__ = ("base", "db_name", "collection_name", "partition_name", "fields_data", "hash_keys", "num_rows") + BASE_FIELD_NUMBER: _ClassVar[int] + DB_NAME_FIELD_NUMBER: _ClassVar[int] + COLLECTION_NAME_FIELD_NUMBER: _ClassVar[int] + PARTITION_NAME_FIELD_NUMBER: _ClassVar[int] + FIELDS_DATA_FIELD_NUMBER: _ClassVar[int] + HASH_KEYS_FIELD_NUMBER: _ClassVar[int] + NUM_ROWS_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + db_name: str + collection_name: str + partition_name: str + fields_data: _containers.RepeatedCompositeFieldContainer[_schema_pb2.FieldData] + hash_keys: _containers.RepeatedScalarFieldContainer[int] + num_rows: int + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., db_name: _Optional[str] = ..., collection_name: _Optional[str] = ..., partition_name: _Optional[str] = ..., fields_data: _Optional[_Iterable[_Union[_schema_pb2.FieldData, _Mapping]]] = ..., hash_keys: _Optional[_Iterable[int]] = ..., num_rows: _Optional[int] = ...) -> None: ... + +class MutationResult(_message.Message): + __slots__ = ("status", "IDs", "succ_index", "err_index", "acknowledged", "insert_cnt", "delete_cnt", "upsert_cnt", "timestamp") + STATUS_FIELD_NUMBER: _ClassVar[int] + IDS_FIELD_NUMBER: _ClassVar[int] + SUCC_INDEX_FIELD_NUMBER: _ClassVar[int] + ERR_INDEX_FIELD_NUMBER: _ClassVar[int] + ACKNOWLEDGED_FIELD_NUMBER: _ClassVar[int] + INSERT_CNT_FIELD_NUMBER: _ClassVar[int] + DELETE_CNT_FIELD_NUMBER: _ClassVar[int] + UPSERT_CNT_FIELD_NUMBER: _ClassVar[int] + TIMESTAMP_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + IDs: _schema_pb2.IDs + succ_index: _containers.RepeatedScalarFieldContainer[int] + err_index: _containers.RepeatedScalarFieldContainer[int] + acknowledged: bool + insert_cnt: int + delete_cnt: int + upsert_cnt: int + timestamp: int + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., IDs: _Optional[_Union[_schema_pb2.IDs, _Mapping]] = ..., succ_index: _Optional[_Iterable[int]] = ..., err_index: _Optional[_Iterable[int]] = ..., acknowledged: bool = ..., insert_cnt: _Optional[int] = ..., delete_cnt: _Optional[int] = ..., upsert_cnt: _Optional[int] = ..., timestamp: _Optional[int] = ...) -> None: ... + +class DeleteRequest(_message.Message): + __slots__ = ("base", "db_name", "collection_name", "partition_name", "expr", "hash_keys", "consistency_level") + BASE_FIELD_NUMBER: _ClassVar[int] + DB_NAME_FIELD_NUMBER: _ClassVar[int] + COLLECTION_NAME_FIELD_NUMBER: _ClassVar[int] + PARTITION_NAME_FIELD_NUMBER: _ClassVar[int] + EXPR_FIELD_NUMBER: _ClassVar[int] + HASH_KEYS_FIELD_NUMBER: _ClassVar[int] + CONSISTENCY_LEVEL_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + db_name: str + collection_name: str + partition_name: str + expr: str + hash_keys: _containers.RepeatedScalarFieldContainer[int] + consistency_level: _common_pb2.ConsistencyLevel + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., db_name: _Optional[str] = ..., collection_name: _Optional[str] = ..., partition_name: _Optional[str] = ..., expr: _Optional[str] = ..., hash_keys: _Optional[_Iterable[int]] = ..., consistency_level: _Optional[_Union[_common_pb2.ConsistencyLevel, str]] = ...) -> None: ... + +class SearchRequest(_message.Message): + __slots__ = ("base", "db_name", "collection_name", "partition_names", "dsl", "placeholder_group", "dsl_type", "output_fields", "search_params", "travel_timestamp", "guarantee_timestamp", "nq", "not_return_all_meta", "consistency_level", "use_default_consistency", "search_by_primary_keys") + BASE_FIELD_NUMBER: _ClassVar[int] + DB_NAME_FIELD_NUMBER: _ClassVar[int] + COLLECTION_NAME_FIELD_NUMBER: _ClassVar[int] + PARTITION_NAMES_FIELD_NUMBER: _ClassVar[int] + DSL_FIELD_NUMBER: _ClassVar[int] + PLACEHOLDER_GROUP_FIELD_NUMBER: _ClassVar[int] + DSL_TYPE_FIELD_NUMBER: _ClassVar[int] + OUTPUT_FIELDS_FIELD_NUMBER: _ClassVar[int] + SEARCH_PARAMS_FIELD_NUMBER: _ClassVar[int] + TRAVEL_TIMESTAMP_FIELD_NUMBER: _ClassVar[int] + GUARANTEE_TIMESTAMP_FIELD_NUMBER: _ClassVar[int] + NQ_FIELD_NUMBER: _ClassVar[int] + NOT_RETURN_ALL_META_FIELD_NUMBER: _ClassVar[int] + CONSISTENCY_LEVEL_FIELD_NUMBER: _ClassVar[int] + USE_DEFAULT_CONSISTENCY_FIELD_NUMBER: _ClassVar[int] + SEARCH_BY_PRIMARY_KEYS_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + db_name: str + collection_name: str + partition_names: _containers.RepeatedScalarFieldContainer[str] + dsl: str + placeholder_group: bytes + dsl_type: _common_pb2.DslType + output_fields: _containers.RepeatedScalarFieldContainer[str] + search_params: _containers.RepeatedCompositeFieldContainer[_common_pb2.KeyValuePair] + travel_timestamp: int + guarantee_timestamp: int + nq: int + not_return_all_meta: bool + consistency_level: _common_pb2.ConsistencyLevel + use_default_consistency: bool + search_by_primary_keys: bool + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., db_name: _Optional[str] = ..., collection_name: _Optional[str] = ..., partition_names: _Optional[_Iterable[str]] = ..., dsl: _Optional[str] = ..., placeholder_group: _Optional[bytes] = ..., dsl_type: _Optional[_Union[_common_pb2.DslType, str]] = ..., output_fields: _Optional[_Iterable[str]] = ..., search_params: _Optional[_Iterable[_Union[_common_pb2.KeyValuePair, _Mapping]]] = ..., travel_timestamp: _Optional[int] = ..., guarantee_timestamp: _Optional[int] = ..., nq: _Optional[int] = ..., not_return_all_meta: bool = ..., consistency_level: _Optional[_Union[_common_pb2.ConsistencyLevel, str]] = ..., use_default_consistency: bool = ..., search_by_primary_keys: bool = ...) -> None: ... + +class Hits(_message.Message): + __slots__ = ("IDs", "row_data", "scores") + IDS_FIELD_NUMBER: _ClassVar[int] + ROW_DATA_FIELD_NUMBER: _ClassVar[int] + SCORES_FIELD_NUMBER: _ClassVar[int] + IDs: _containers.RepeatedScalarFieldContainer[int] + row_data: _containers.RepeatedScalarFieldContainer[bytes] + scores: _containers.RepeatedScalarFieldContainer[float] + def __init__(self, IDs: _Optional[_Iterable[int]] = ..., row_data: _Optional[_Iterable[bytes]] = ..., scores: _Optional[_Iterable[float]] = ...) -> None: ... + +class SearchResults(_message.Message): + __slots__ = ("status", "results", "collection_name") + STATUS_FIELD_NUMBER: _ClassVar[int] + RESULTS_FIELD_NUMBER: _ClassVar[int] + COLLECTION_NAME_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + results: _schema_pb2.SearchResultData + collection_name: str + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., results: _Optional[_Union[_schema_pb2.SearchResultData, _Mapping]] = ..., collection_name: _Optional[str] = ...) -> None: ... + +class HybridSearchRequest(_message.Message): + __slots__ = ("base", "db_name", "collection_name", "partition_names", "requests", "rank_params", "travel_timestamp", "guarantee_timestamp", "not_return_all_meta", "output_fields", "consistency_level", "use_default_consistency") + BASE_FIELD_NUMBER: _ClassVar[int] + DB_NAME_FIELD_NUMBER: _ClassVar[int] + COLLECTION_NAME_FIELD_NUMBER: _ClassVar[int] + PARTITION_NAMES_FIELD_NUMBER: _ClassVar[int] + REQUESTS_FIELD_NUMBER: _ClassVar[int] + RANK_PARAMS_FIELD_NUMBER: _ClassVar[int] + TRAVEL_TIMESTAMP_FIELD_NUMBER: _ClassVar[int] + GUARANTEE_TIMESTAMP_FIELD_NUMBER: _ClassVar[int] + NOT_RETURN_ALL_META_FIELD_NUMBER: _ClassVar[int] + OUTPUT_FIELDS_FIELD_NUMBER: _ClassVar[int] + CONSISTENCY_LEVEL_FIELD_NUMBER: _ClassVar[int] + USE_DEFAULT_CONSISTENCY_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + db_name: str + collection_name: str + partition_names: _containers.RepeatedScalarFieldContainer[str] + requests: _containers.RepeatedCompositeFieldContainer[SearchRequest] + rank_params: _containers.RepeatedCompositeFieldContainer[_common_pb2.KeyValuePair] + travel_timestamp: int + guarantee_timestamp: int + not_return_all_meta: bool + output_fields: _containers.RepeatedScalarFieldContainer[str] + consistency_level: _common_pb2.ConsistencyLevel + use_default_consistency: bool + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., db_name: _Optional[str] = ..., collection_name: _Optional[str] = ..., partition_names: _Optional[_Iterable[str]] = ..., requests: _Optional[_Iterable[_Union[SearchRequest, _Mapping]]] = ..., rank_params: _Optional[_Iterable[_Union[_common_pb2.KeyValuePair, _Mapping]]] = ..., travel_timestamp: _Optional[int] = ..., guarantee_timestamp: _Optional[int] = ..., not_return_all_meta: bool = ..., output_fields: _Optional[_Iterable[str]] = ..., consistency_level: _Optional[_Union[_common_pb2.ConsistencyLevel, str]] = ..., use_default_consistency: bool = ...) -> None: ... + +class FlushRequest(_message.Message): + __slots__ = ("base", "db_name", "collection_names") + BASE_FIELD_NUMBER: _ClassVar[int] + DB_NAME_FIELD_NUMBER: _ClassVar[int] + COLLECTION_NAMES_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + db_name: str + collection_names: _containers.RepeatedScalarFieldContainer[str] + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., db_name: _Optional[str] = ..., collection_names: _Optional[_Iterable[str]] = ...) -> None: ... + +class FlushResponse(_message.Message): + __slots__ = ("status", "db_name", "coll_segIDs", "flush_coll_segIDs", "coll_seal_times", "coll_flush_ts") + class CollSegIDsEntry(_message.Message): + __slots__ = ("key", "value") + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: str + value: _schema_pb2.LongArray + def __init__(self, key: _Optional[str] = ..., value: _Optional[_Union[_schema_pb2.LongArray, _Mapping]] = ...) -> None: ... + class FlushCollSegIDsEntry(_message.Message): + __slots__ = ("key", "value") + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: str + value: _schema_pb2.LongArray + def __init__(self, key: _Optional[str] = ..., value: _Optional[_Union[_schema_pb2.LongArray, _Mapping]] = ...) -> None: ... + class CollSealTimesEntry(_message.Message): + __slots__ = ("key", "value") + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: str + value: int + def __init__(self, key: _Optional[str] = ..., value: _Optional[int] = ...) -> None: ... + class CollFlushTsEntry(_message.Message): + __slots__ = ("key", "value") + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: str + value: int + def __init__(self, key: _Optional[str] = ..., value: _Optional[int] = ...) -> None: ... + STATUS_FIELD_NUMBER: _ClassVar[int] + DB_NAME_FIELD_NUMBER: _ClassVar[int] + COLL_SEGIDS_FIELD_NUMBER: _ClassVar[int] + FLUSH_COLL_SEGIDS_FIELD_NUMBER: _ClassVar[int] + COLL_SEAL_TIMES_FIELD_NUMBER: _ClassVar[int] + COLL_FLUSH_TS_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + db_name: str + coll_segIDs: _containers.MessageMap[str, _schema_pb2.LongArray] + flush_coll_segIDs: _containers.MessageMap[str, _schema_pb2.LongArray] + coll_seal_times: _containers.ScalarMap[str, int] + coll_flush_ts: _containers.ScalarMap[str, int] + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., db_name: _Optional[str] = ..., coll_segIDs: _Optional[_Mapping[str, _schema_pb2.LongArray]] = ..., flush_coll_segIDs: _Optional[_Mapping[str, _schema_pb2.LongArray]] = ..., coll_seal_times: _Optional[_Mapping[str, int]] = ..., coll_flush_ts: _Optional[_Mapping[str, int]] = ...) -> None: ... + +class QueryRequest(_message.Message): + __slots__ = ("base", "db_name", "collection_name", "expr", "output_fields", "partition_names", "travel_timestamp", "guarantee_timestamp", "query_params", "not_return_all_meta", "consistency_level", "use_default_consistency") + BASE_FIELD_NUMBER: _ClassVar[int] + DB_NAME_FIELD_NUMBER: _ClassVar[int] + COLLECTION_NAME_FIELD_NUMBER: _ClassVar[int] + EXPR_FIELD_NUMBER: _ClassVar[int] + OUTPUT_FIELDS_FIELD_NUMBER: _ClassVar[int] + PARTITION_NAMES_FIELD_NUMBER: _ClassVar[int] + TRAVEL_TIMESTAMP_FIELD_NUMBER: _ClassVar[int] + GUARANTEE_TIMESTAMP_FIELD_NUMBER: _ClassVar[int] + QUERY_PARAMS_FIELD_NUMBER: _ClassVar[int] + NOT_RETURN_ALL_META_FIELD_NUMBER: _ClassVar[int] + CONSISTENCY_LEVEL_FIELD_NUMBER: _ClassVar[int] + USE_DEFAULT_CONSISTENCY_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + db_name: str + collection_name: str + expr: str + output_fields: _containers.RepeatedScalarFieldContainer[str] + partition_names: _containers.RepeatedScalarFieldContainer[str] + travel_timestamp: int + guarantee_timestamp: int + query_params: _containers.RepeatedCompositeFieldContainer[_common_pb2.KeyValuePair] + not_return_all_meta: bool + consistency_level: _common_pb2.ConsistencyLevel + use_default_consistency: bool + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., db_name: _Optional[str] = ..., collection_name: _Optional[str] = ..., expr: _Optional[str] = ..., output_fields: _Optional[_Iterable[str]] = ..., partition_names: _Optional[_Iterable[str]] = ..., travel_timestamp: _Optional[int] = ..., guarantee_timestamp: _Optional[int] = ..., query_params: _Optional[_Iterable[_Union[_common_pb2.KeyValuePair, _Mapping]]] = ..., not_return_all_meta: bool = ..., consistency_level: _Optional[_Union[_common_pb2.ConsistencyLevel, str]] = ..., use_default_consistency: bool = ...) -> None: ... + +class QueryResults(_message.Message): + __slots__ = ("status", "fields_data", "collection_name", "output_fields") + STATUS_FIELD_NUMBER: _ClassVar[int] + FIELDS_DATA_FIELD_NUMBER: _ClassVar[int] + COLLECTION_NAME_FIELD_NUMBER: _ClassVar[int] + OUTPUT_FIELDS_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + fields_data: _containers.RepeatedCompositeFieldContainer[_schema_pb2.FieldData] + collection_name: str + output_fields: _containers.RepeatedScalarFieldContainer[str] + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., fields_data: _Optional[_Iterable[_Union[_schema_pb2.FieldData, _Mapping]]] = ..., collection_name: _Optional[str] = ..., output_fields: _Optional[_Iterable[str]] = ...) -> None: ... + +class VectorIDs(_message.Message): + __slots__ = ("collection_name", "field_name", "id_array", "partition_names") + COLLECTION_NAME_FIELD_NUMBER: _ClassVar[int] + FIELD_NAME_FIELD_NUMBER: _ClassVar[int] + ID_ARRAY_FIELD_NUMBER: _ClassVar[int] + PARTITION_NAMES_FIELD_NUMBER: _ClassVar[int] + collection_name: str + field_name: str + id_array: _schema_pb2.IDs + partition_names: _containers.RepeatedScalarFieldContainer[str] + def __init__(self, collection_name: _Optional[str] = ..., field_name: _Optional[str] = ..., id_array: _Optional[_Union[_schema_pb2.IDs, _Mapping]] = ..., partition_names: _Optional[_Iterable[str]] = ...) -> None: ... + +class VectorsArray(_message.Message): + __slots__ = ("id_array", "data_array") + ID_ARRAY_FIELD_NUMBER: _ClassVar[int] + DATA_ARRAY_FIELD_NUMBER: _ClassVar[int] + id_array: VectorIDs + data_array: _schema_pb2.VectorField + def __init__(self, id_array: _Optional[_Union[VectorIDs, _Mapping]] = ..., data_array: _Optional[_Union[_schema_pb2.VectorField, _Mapping]] = ...) -> None: ... + +class CalcDistanceRequest(_message.Message): + __slots__ = ("base", "op_left", "op_right", "params") + BASE_FIELD_NUMBER: _ClassVar[int] + OP_LEFT_FIELD_NUMBER: _ClassVar[int] + OP_RIGHT_FIELD_NUMBER: _ClassVar[int] + PARAMS_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + op_left: VectorsArray + op_right: VectorsArray + params: _containers.RepeatedCompositeFieldContainer[_common_pb2.KeyValuePair] + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., op_left: _Optional[_Union[VectorsArray, _Mapping]] = ..., op_right: _Optional[_Union[VectorsArray, _Mapping]] = ..., params: _Optional[_Iterable[_Union[_common_pb2.KeyValuePair, _Mapping]]] = ...) -> None: ... + +class CalcDistanceResults(_message.Message): + __slots__ = ("status", "int_dist", "float_dist") + STATUS_FIELD_NUMBER: _ClassVar[int] + INT_DIST_FIELD_NUMBER: _ClassVar[int] + FLOAT_DIST_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + int_dist: _schema_pb2.IntArray + float_dist: _schema_pb2.FloatArray + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., int_dist: _Optional[_Union[_schema_pb2.IntArray, _Mapping]] = ..., float_dist: _Optional[_Union[_schema_pb2.FloatArray, _Mapping]] = ...) -> None: ... + +class FlushAllRequest(_message.Message): + __slots__ = ("base", "db_name") + BASE_FIELD_NUMBER: _ClassVar[int] + DB_NAME_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + db_name: str + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., db_name: _Optional[str] = ...) -> None: ... + +class FlushAllResponse(_message.Message): + __slots__ = ("status", "flush_all_ts") + STATUS_FIELD_NUMBER: _ClassVar[int] + FLUSH_ALL_TS_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + flush_all_ts: int + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., flush_all_ts: _Optional[int] = ...) -> None: ... + +class PersistentSegmentInfo(_message.Message): + __slots__ = ("segmentID", "collectionID", "partitionID", "num_rows", "state") + SEGMENTID_FIELD_NUMBER: _ClassVar[int] + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + PARTITIONID_FIELD_NUMBER: _ClassVar[int] + NUM_ROWS_FIELD_NUMBER: _ClassVar[int] + STATE_FIELD_NUMBER: _ClassVar[int] + segmentID: int + collectionID: int + partitionID: int + num_rows: int + state: _common_pb2.SegmentState + def __init__(self, segmentID: _Optional[int] = ..., collectionID: _Optional[int] = ..., partitionID: _Optional[int] = ..., num_rows: _Optional[int] = ..., state: _Optional[_Union[_common_pb2.SegmentState, str]] = ...) -> None: ... + +class GetPersistentSegmentInfoRequest(_message.Message): + __slots__ = ("base", "dbName", "collectionName") + BASE_FIELD_NUMBER: _ClassVar[int] + DBNAME_FIELD_NUMBER: _ClassVar[int] + COLLECTIONNAME_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + dbName: str + collectionName: str + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., dbName: _Optional[str] = ..., collectionName: _Optional[str] = ...) -> None: ... + +class GetPersistentSegmentInfoResponse(_message.Message): + __slots__ = ("status", "infos") + STATUS_FIELD_NUMBER: _ClassVar[int] + INFOS_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + infos: _containers.RepeatedCompositeFieldContainer[PersistentSegmentInfo] + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., infos: _Optional[_Iterable[_Union[PersistentSegmentInfo, _Mapping]]] = ...) -> None: ... + +class QuerySegmentInfo(_message.Message): + __slots__ = ("segmentID", "collectionID", "partitionID", "mem_size", "num_rows", "index_name", "indexID", "nodeID", "state", "nodeIds") + SEGMENTID_FIELD_NUMBER: _ClassVar[int] + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + PARTITIONID_FIELD_NUMBER: _ClassVar[int] + MEM_SIZE_FIELD_NUMBER: _ClassVar[int] + NUM_ROWS_FIELD_NUMBER: _ClassVar[int] + INDEX_NAME_FIELD_NUMBER: _ClassVar[int] + INDEXID_FIELD_NUMBER: _ClassVar[int] + NODEID_FIELD_NUMBER: _ClassVar[int] + STATE_FIELD_NUMBER: _ClassVar[int] + NODEIDS_FIELD_NUMBER: _ClassVar[int] + segmentID: int + collectionID: int + partitionID: int + mem_size: int + num_rows: int + index_name: str + indexID: int + nodeID: int + state: _common_pb2.SegmentState + nodeIds: _containers.RepeatedScalarFieldContainer[int] + def __init__(self, segmentID: _Optional[int] = ..., collectionID: _Optional[int] = ..., partitionID: _Optional[int] = ..., mem_size: _Optional[int] = ..., num_rows: _Optional[int] = ..., index_name: _Optional[str] = ..., indexID: _Optional[int] = ..., nodeID: _Optional[int] = ..., state: _Optional[_Union[_common_pb2.SegmentState, str]] = ..., nodeIds: _Optional[_Iterable[int]] = ...) -> None: ... + +class GetQuerySegmentInfoRequest(_message.Message): + __slots__ = ("base", "dbName", "collectionName") + BASE_FIELD_NUMBER: _ClassVar[int] + DBNAME_FIELD_NUMBER: _ClassVar[int] + COLLECTIONNAME_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + dbName: str + collectionName: str + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., dbName: _Optional[str] = ..., collectionName: _Optional[str] = ...) -> None: ... + +class GetQuerySegmentInfoResponse(_message.Message): + __slots__ = ("status", "infos") + STATUS_FIELD_NUMBER: _ClassVar[int] + INFOS_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + infos: _containers.RepeatedCompositeFieldContainer[QuerySegmentInfo] + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., infos: _Optional[_Iterable[_Union[QuerySegmentInfo, _Mapping]]] = ...) -> None: ... + +class DummyRequest(_message.Message): + __slots__ = ("request_type",) + REQUEST_TYPE_FIELD_NUMBER: _ClassVar[int] + request_type: str + def __init__(self, request_type: _Optional[str] = ...) -> None: ... + +class DummyResponse(_message.Message): + __slots__ = ("response",) + RESPONSE_FIELD_NUMBER: _ClassVar[int] + response: str + def __init__(self, response: _Optional[str] = ...) -> None: ... + +class RegisterLinkRequest(_message.Message): + __slots__ = () + def __init__(self) -> None: ... + +class RegisterLinkResponse(_message.Message): + __slots__ = ("address", "status") + ADDRESS_FIELD_NUMBER: _ClassVar[int] + STATUS_FIELD_NUMBER: _ClassVar[int] + address: _common_pb2.Address + status: _common_pb2.Status + def __init__(self, address: _Optional[_Union[_common_pb2.Address, _Mapping]] = ..., status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ...) -> None: ... + +class GetMetricsRequest(_message.Message): + __slots__ = ("base", "request") + BASE_FIELD_NUMBER: _ClassVar[int] + REQUEST_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + request: str + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., request: _Optional[str] = ...) -> None: ... + +class GetMetricsResponse(_message.Message): + __slots__ = ("status", "response", "component_name") + STATUS_FIELD_NUMBER: _ClassVar[int] + RESPONSE_FIELD_NUMBER: _ClassVar[int] + COMPONENT_NAME_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + response: str + component_name: str + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., response: _Optional[str] = ..., component_name: _Optional[str] = ...) -> None: ... + +class ComponentInfo(_message.Message): + __slots__ = ("nodeID", "role", "state_code", "extra_info") + NODEID_FIELD_NUMBER: _ClassVar[int] + ROLE_FIELD_NUMBER: _ClassVar[int] + STATE_CODE_FIELD_NUMBER: _ClassVar[int] + EXTRA_INFO_FIELD_NUMBER: _ClassVar[int] + nodeID: int + role: str + state_code: _common_pb2.StateCode + extra_info: _containers.RepeatedCompositeFieldContainer[_common_pb2.KeyValuePair] + def __init__(self, nodeID: _Optional[int] = ..., role: _Optional[str] = ..., state_code: _Optional[_Union[_common_pb2.StateCode, str]] = ..., extra_info: _Optional[_Iterable[_Union[_common_pb2.KeyValuePair, _Mapping]]] = ...) -> None: ... + +class ComponentStates(_message.Message): + __slots__ = ("state", "subcomponent_states", "status") + STATE_FIELD_NUMBER: _ClassVar[int] + SUBCOMPONENT_STATES_FIELD_NUMBER: _ClassVar[int] + STATUS_FIELD_NUMBER: _ClassVar[int] + state: ComponentInfo + subcomponent_states: _containers.RepeatedCompositeFieldContainer[ComponentInfo] + status: _common_pb2.Status + def __init__(self, state: _Optional[_Union[ComponentInfo, _Mapping]] = ..., subcomponent_states: _Optional[_Iterable[_Union[ComponentInfo, _Mapping]]] = ..., status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ...) -> None: ... + +class GetComponentStatesRequest(_message.Message): + __slots__ = () + def __init__(self) -> None: ... + +class LoadBalanceRequest(_message.Message): + __slots__ = ("base", "src_nodeID", "dst_nodeIDs", "sealed_segmentIDs", "collectionName", "db_name") + BASE_FIELD_NUMBER: _ClassVar[int] + SRC_NODEID_FIELD_NUMBER: _ClassVar[int] + DST_NODEIDS_FIELD_NUMBER: _ClassVar[int] + SEALED_SEGMENTIDS_FIELD_NUMBER: _ClassVar[int] + COLLECTIONNAME_FIELD_NUMBER: _ClassVar[int] + DB_NAME_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + src_nodeID: int + dst_nodeIDs: _containers.RepeatedScalarFieldContainer[int] + sealed_segmentIDs: _containers.RepeatedScalarFieldContainer[int] + collectionName: str + db_name: str + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., src_nodeID: _Optional[int] = ..., dst_nodeIDs: _Optional[_Iterable[int]] = ..., sealed_segmentIDs: _Optional[_Iterable[int]] = ..., collectionName: _Optional[str] = ..., db_name: _Optional[str] = ...) -> None: ... + +class ManualCompactionRequest(_message.Message): + __slots__ = ("collectionID", "timetravel", "majorCompaction") + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + TIMETRAVEL_FIELD_NUMBER: _ClassVar[int] + MAJORCOMPACTION_FIELD_NUMBER: _ClassVar[int] + collectionID: int + timetravel: int + majorCompaction: bool + def __init__(self, collectionID: _Optional[int] = ..., timetravel: _Optional[int] = ..., majorCompaction: bool = ...) -> None: ... + +class ManualCompactionResponse(_message.Message): + __slots__ = ("status", "compactionID", "compactionPlanCount") + STATUS_FIELD_NUMBER: _ClassVar[int] + COMPACTIONID_FIELD_NUMBER: _ClassVar[int] + COMPACTIONPLANCOUNT_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + compactionID: int + compactionPlanCount: int + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., compactionID: _Optional[int] = ..., compactionPlanCount: _Optional[int] = ...) -> None: ... + +class GetCompactionStateRequest(_message.Message): + __slots__ = ("compactionID",) + COMPACTIONID_FIELD_NUMBER: _ClassVar[int] + compactionID: int + def __init__(self, compactionID: _Optional[int] = ...) -> None: ... + +class GetCompactionStateResponse(_message.Message): + __slots__ = ("status", "state", "executingPlanNo", "timeoutPlanNo", "completedPlanNo", "failedPlanNo") + STATUS_FIELD_NUMBER: _ClassVar[int] + STATE_FIELD_NUMBER: _ClassVar[int] + EXECUTINGPLANNO_FIELD_NUMBER: _ClassVar[int] + TIMEOUTPLANNO_FIELD_NUMBER: _ClassVar[int] + COMPLETEDPLANNO_FIELD_NUMBER: _ClassVar[int] + FAILEDPLANNO_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + state: _common_pb2.CompactionState + executingPlanNo: int + timeoutPlanNo: int + completedPlanNo: int + failedPlanNo: int + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., state: _Optional[_Union[_common_pb2.CompactionState, str]] = ..., executingPlanNo: _Optional[int] = ..., timeoutPlanNo: _Optional[int] = ..., completedPlanNo: _Optional[int] = ..., failedPlanNo: _Optional[int] = ...) -> None: ... + +class GetCompactionPlansRequest(_message.Message): + __slots__ = ("compactionID",) + COMPACTIONID_FIELD_NUMBER: _ClassVar[int] + compactionID: int + def __init__(self, compactionID: _Optional[int] = ...) -> None: ... + +class GetCompactionPlansResponse(_message.Message): + __slots__ = ("status", "state", "mergeInfos") + STATUS_FIELD_NUMBER: _ClassVar[int] + STATE_FIELD_NUMBER: _ClassVar[int] + MERGEINFOS_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + state: _common_pb2.CompactionState + mergeInfos: _containers.RepeatedCompositeFieldContainer[CompactionMergeInfo] + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., state: _Optional[_Union[_common_pb2.CompactionState, str]] = ..., mergeInfos: _Optional[_Iterable[_Union[CompactionMergeInfo, _Mapping]]] = ...) -> None: ... + +class CompactionMergeInfo(_message.Message): + __slots__ = ("sources", "target") + SOURCES_FIELD_NUMBER: _ClassVar[int] + TARGET_FIELD_NUMBER: _ClassVar[int] + sources: _containers.RepeatedScalarFieldContainer[int] + target: int + def __init__(self, sources: _Optional[_Iterable[int]] = ..., target: _Optional[int] = ...) -> None: ... + +class GetFlushStateRequest(_message.Message): + __slots__ = ("segmentIDs", "flush_ts", "db_name", "collection_name") + SEGMENTIDS_FIELD_NUMBER: _ClassVar[int] + FLUSH_TS_FIELD_NUMBER: _ClassVar[int] + DB_NAME_FIELD_NUMBER: _ClassVar[int] + COLLECTION_NAME_FIELD_NUMBER: _ClassVar[int] + segmentIDs: _containers.RepeatedScalarFieldContainer[int] + flush_ts: int + db_name: str + collection_name: str + def __init__(self, segmentIDs: _Optional[_Iterable[int]] = ..., flush_ts: _Optional[int] = ..., db_name: _Optional[str] = ..., collection_name: _Optional[str] = ...) -> None: ... + +class GetFlushStateResponse(_message.Message): + __slots__ = ("status", "flushed") + STATUS_FIELD_NUMBER: _ClassVar[int] + FLUSHED_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + flushed: bool + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., flushed: bool = ...) -> None: ... + +class GetFlushAllStateRequest(_message.Message): + __slots__ = ("base", "flush_all_ts", "db_name") + BASE_FIELD_NUMBER: _ClassVar[int] + FLUSH_ALL_TS_FIELD_NUMBER: _ClassVar[int] + DB_NAME_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + flush_all_ts: int + db_name: str + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., flush_all_ts: _Optional[int] = ..., db_name: _Optional[str] = ...) -> None: ... + +class GetFlushAllStateResponse(_message.Message): + __slots__ = ("status", "flushed") + STATUS_FIELD_NUMBER: _ClassVar[int] + FLUSHED_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + flushed: bool + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., flushed: bool = ...) -> None: ... + +class ImportRequest(_message.Message): + __slots__ = ("collection_name", "partition_name", "channel_names", "row_based", "files", "options", "db_name", "clustering_info") + COLLECTION_NAME_FIELD_NUMBER: _ClassVar[int] + PARTITION_NAME_FIELD_NUMBER: _ClassVar[int] + CHANNEL_NAMES_FIELD_NUMBER: _ClassVar[int] + ROW_BASED_FIELD_NUMBER: _ClassVar[int] + FILES_FIELD_NUMBER: _ClassVar[int] + OPTIONS_FIELD_NUMBER: _ClassVar[int] + DB_NAME_FIELD_NUMBER: _ClassVar[int] + CLUSTERING_INFO_FIELD_NUMBER: _ClassVar[int] + collection_name: str + partition_name: str + channel_names: _containers.RepeatedScalarFieldContainer[str] + row_based: bool + files: _containers.RepeatedScalarFieldContainer[str] + options: _containers.RepeatedCompositeFieldContainer[_common_pb2.KeyValuePair] + db_name: str + clustering_info: bytes + def __init__(self, collection_name: _Optional[str] = ..., partition_name: _Optional[str] = ..., channel_names: _Optional[_Iterable[str]] = ..., row_based: bool = ..., files: _Optional[_Iterable[str]] = ..., options: _Optional[_Iterable[_Union[_common_pb2.KeyValuePair, _Mapping]]] = ..., db_name: _Optional[str] = ..., clustering_info: _Optional[bytes] = ...) -> None: ... + +class ImportResponse(_message.Message): + __slots__ = ("status", "tasks") + STATUS_FIELD_NUMBER: _ClassVar[int] + TASKS_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + tasks: _containers.RepeatedScalarFieldContainer[int] + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., tasks: _Optional[_Iterable[int]] = ...) -> None: ... + +class GetImportStateRequest(_message.Message): + __slots__ = ("task",) + TASK_FIELD_NUMBER: _ClassVar[int] + task: int + def __init__(self, task: _Optional[int] = ...) -> None: ... + +class GetImportStateResponse(_message.Message): + __slots__ = ("status", "state", "row_count", "id_list", "infos", "id", "collection_id", "segment_ids", "create_ts") + STATUS_FIELD_NUMBER: _ClassVar[int] + STATE_FIELD_NUMBER: _ClassVar[int] + ROW_COUNT_FIELD_NUMBER: _ClassVar[int] + ID_LIST_FIELD_NUMBER: _ClassVar[int] + INFOS_FIELD_NUMBER: _ClassVar[int] + ID_FIELD_NUMBER: _ClassVar[int] + COLLECTION_ID_FIELD_NUMBER: _ClassVar[int] + SEGMENT_IDS_FIELD_NUMBER: _ClassVar[int] + CREATE_TS_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + state: _common_pb2.ImportState + row_count: int + id_list: _containers.RepeatedScalarFieldContainer[int] + infos: _containers.RepeatedCompositeFieldContainer[_common_pb2.KeyValuePair] + id: int + collection_id: int + segment_ids: _containers.RepeatedScalarFieldContainer[int] + create_ts: int + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., state: _Optional[_Union[_common_pb2.ImportState, str]] = ..., row_count: _Optional[int] = ..., id_list: _Optional[_Iterable[int]] = ..., infos: _Optional[_Iterable[_Union[_common_pb2.KeyValuePair, _Mapping]]] = ..., id: _Optional[int] = ..., collection_id: _Optional[int] = ..., segment_ids: _Optional[_Iterable[int]] = ..., create_ts: _Optional[int] = ...) -> None: ... + +class ListImportTasksRequest(_message.Message): + __slots__ = ("collection_name", "limit", "db_name") + COLLECTION_NAME_FIELD_NUMBER: _ClassVar[int] + LIMIT_FIELD_NUMBER: _ClassVar[int] + DB_NAME_FIELD_NUMBER: _ClassVar[int] + collection_name: str + limit: int + db_name: str + def __init__(self, collection_name: _Optional[str] = ..., limit: _Optional[int] = ..., db_name: _Optional[str] = ...) -> None: ... + +class ListImportTasksResponse(_message.Message): + __slots__ = ("status", "tasks") + STATUS_FIELD_NUMBER: _ClassVar[int] + TASKS_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + tasks: _containers.RepeatedCompositeFieldContainer[GetImportStateResponse] + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., tasks: _Optional[_Iterable[_Union[GetImportStateResponse, _Mapping]]] = ...) -> None: ... + +class GetReplicasRequest(_message.Message): + __slots__ = ("base", "collectionID", "with_shard_nodes", "collection_name", "db_name") + BASE_FIELD_NUMBER: _ClassVar[int] + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + WITH_SHARD_NODES_FIELD_NUMBER: _ClassVar[int] + COLLECTION_NAME_FIELD_NUMBER: _ClassVar[int] + DB_NAME_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + collectionID: int + with_shard_nodes: bool + collection_name: str + db_name: str + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., collectionID: _Optional[int] = ..., with_shard_nodes: bool = ..., collection_name: _Optional[str] = ..., db_name: _Optional[str] = ...) -> None: ... + +class GetReplicasResponse(_message.Message): + __slots__ = ("status", "replicas") + STATUS_FIELD_NUMBER: _ClassVar[int] + REPLICAS_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + replicas: _containers.RepeatedCompositeFieldContainer[ReplicaInfo] + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., replicas: _Optional[_Iterable[_Union[ReplicaInfo, _Mapping]]] = ...) -> None: ... + +class ReplicaInfo(_message.Message): + __slots__ = ("replicaID", "collectionID", "partition_ids", "shard_replicas", "node_ids", "resource_group_name", "num_outbound_node") + class NumOutboundNodeEntry(_message.Message): + __slots__ = ("key", "value") + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: str + value: int + def __init__(self, key: _Optional[str] = ..., value: _Optional[int] = ...) -> None: ... + REPLICAID_FIELD_NUMBER: _ClassVar[int] + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + PARTITION_IDS_FIELD_NUMBER: _ClassVar[int] + SHARD_REPLICAS_FIELD_NUMBER: _ClassVar[int] + NODE_IDS_FIELD_NUMBER: _ClassVar[int] + RESOURCE_GROUP_NAME_FIELD_NUMBER: _ClassVar[int] + NUM_OUTBOUND_NODE_FIELD_NUMBER: _ClassVar[int] + replicaID: int + collectionID: int + partition_ids: _containers.RepeatedScalarFieldContainer[int] + shard_replicas: _containers.RepeatedCompositeFieldContainer[ShardReplica] + node_ids: _containers.RepeatedScalarFieldContainer[int] + resource_group_name: str + num_outbound_node: _containers.ScalarMap[str, int] + def __init__(self, replicaID: _Optional[int] = ..., collectionID: _Optional[int] = ..., partition_ids: _Optional[_Iterable[int]] = ..., shard_replicas: _Optional[_Iterable[_Union[ShardReplica, _Mapping]]] = ..., node_ids: _Optional[_Iterable[int]] = ..., resource_group_name: _Optional[str] = ..., num_outbound_node: _Optional[_Mapping[str, int]] = ...) -> None: ... + +class ShardReplica(_message.Message): + __slots__ = ("leaderID", "leader_addr", "dm_channel_name", "node_ids") + LEADERID_FIELD_NUMBER: _ClassVar[int] + LEADER_ADDR_FIELD_NUMBER: _ClassVar[int] + DM_CHANNEL_NAME_FIELD_NUMBER: _ClassVar[int] + NODE_IDS_FIELD_NUMBER: _ClassVar[int] + leaderID: int + leader_addr: str + dm_channel_name: str + node_ids: _containers.RepeatedScalarFieldContainer[int] + def __init__(self, leaderID: _Optional[int] = ..., leader_addr: _Optional[str] = ..., dm_channel_name: _Optional[str] = ..., node_ids: _Optional[_Iterable[int]] = ...) -> None: ... + +class CreateCredentialRequest(_message.Message): + __slots__ = ("base", "username", "password", "created_utc_timestamps", "modified_utc_timestamps") + BASE_FIELD_NUMBER: _ClassVar[int] + USERNAME_FIELD_NUMBER: _ClassVar[int] + PASSWORD_FIELD_NUMBER: _ClassVar[int] + CREATED_UTC_TIMESTAMPS_FIELD_NUMBER: _ClassVar[int] + MODIFIED_UTC_TIMESTAMPS_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + username: str + password: str + created_utc_timestamps: int + modified_utc_timestamps: int + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., username: _Optional[str] = ..., password: _Optional[str] = ..., created_utc_timestamps: _Optional[int] = ..., modified_utc_timestamps: _Optional[int] = ...) -> None: ... + +class UpdateCredentialRequest(_message.Message): + __slots__ = ("base", "username", "oldPassword", "newPassword", "created_utc_timestamps", "modified_utc_timestamps") + BASE_FIELD_NUMBER: _ClassVar[int] + USERNAME_FIELD_NUMBER: _ClassVar[int] + OLDPASSWORD_FIELD_NUMBER: _ClassVar[int] + NEWPASSWORD_FIELD_NUMBER: _ClassVar[int] + CREATED_UTC_TIMESTAMPS_FIELD_NUMBER: _ClassVar[int] + MODIFIED_UTC_TIMESTAMPS_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + username: str + oldPassword: str + newPassword: str + created_utc_timestamps: int + modified_utc_timestamps: int + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., username: _Optional[str] = ..., oldPassword: _Optional[str] = ..., newPassword: _Optional[str] = ..., created_utc_timestamps: _Optional[int] = ..., modified_utc_timestamps: _Optional[int] = ...) -> None: ... + +class DeleteCredentialRequest(_message.Message): + __slots__ = ("base", "username") + BASE_FIELD_NUMBER: _ClassVar[int] + USERNAME_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + username: str + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., username: _Optional[str] = ...) -> None: ... + +class ListCredUsersResponse(_message.Message): + __slots__ = ("status", "usernames") + STATUS_FIELD_NUMBER: _ClassVar[int] + USERNAMES_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + usernames: _containers.RepeatedScalarFieldContainer[str] + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., usernames: _Optional[_Iterable[str]] = ...) -> None: ... + +class ListCredUsersRequest(_message.Message): + __slots__ = ("base",) + BASE_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ...) -> None: ... + +class RoleEntity(_message.Message): + __slots__ = ("name",) + NAME_FIELD_NUMBER: _ClassVar[int] + name: str + def __init__(self, name: _Optional[str] = ...) -> None: ... + +class UserEntity(_message.Message): + __slots__ = ("name",) + NAME_FIELD_NUMBER: _ClassVar[int] + name: str + def __init__(self, name: _Optional[str] = ...) -> None: ... + +class CreateRoleRequest(_message.Message): + __slots__ = ("base", "entity") + BASE_FIELD_NUMBER: _ClassVar[int] + ENTITY_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + entity: RoleEntity + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., entity: _Optional[_Union[RoleEntity, _Mapping]] = ...) -> None: ... + +class DropRoleRequest(_message.Message): + __slots__ = ("base", "role_name") + BASE_FIELD_NUMBER: _ClassVar[int] + ROLE_NAME_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + role_name: str + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., role_name: _Optional[str] = ...) -> None: ... + +class OperateUserRoleRequest(_message.Message): + __slots__ = ("base", "username", "role_name", "type") + BASE_FIELD_NUMBER: _ClassVar[int] + USERNAME_FIELD_NUMBER: _ClassVar[int] + ROLE_NAME_FIELD_NUMBER: _ClassVar[int] + TYPE_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + username: str + role_name: str + type: OperateUserRoleType + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., username: _Optional[str] = ..., role_name: _Optional[str] = ..., type: _Optional[_Union[OperateUserRoleType, str]] = ...) -> None: ... + +class SelectRoleRequest(_message.Message): + __slots__ = ("base", "role", "include_user_info") + BASE_FIELD_NUMBER: _ClassVar[int] + ROLE_FIELD_NUMBER: _ClassVar[int] + INCLUDE_USER_INFO_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + role: RoleEntity + include_user_info: bool + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., role: _Optional[_Union[RoleEntity, _Mapping]] = ..., include_user_info: bool = ...) -> None: ... + +class RoleResult(_message.Message): + __slots__ = ("role", "users") + ROLE_FIELD_NUMBER: _ClassVar[int] + USERS_FIELD_NUMBER: _ClassVar[int] + role: RoleEntity + users: _containers.RepeatedCompositeFieldContainer[UserEntity] + def __init__(self, role: _Optional[_Union[RoleEntity, _Mapping]] = ..., users: _Optional[_Iterable[_Union[UserEntity, _Mapping]]] = ...) -> None: ... + +class SelectRoleResponse(_message.Message): + __slots__ = ("status", "results") + STATUS_FIELD_NUMBER: _ClassVar[int] + RESULTS_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + results: _containers.RepeatedCompositeFieldContainer[RoleResult] + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., results: _Optional[_Iterable[_Union[RoleResult, _Mapping]]] = ...) -> None: ... + +class SelectUserRequest(_message.Message): + __slots__ = ("base", "user", "include_role_info") + BASE_FIELD_NUMBER: _ClassVar[int] + USER_FIELD_NUMBER: _ClassVar[int] + INCLUDE_ROLE_INFO_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + user: UserEntity + include_role_info: bool + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., user: _Optional[_Union[UserEntity, _Mapping]] = ..., include_role_info: bool = ...) -> None: ... + +class UserResult(_message.Message): + __slots__ = ("user", "roles") + USER_FIELD_NUMBER: _ClassVar[int] + ROLES_FIELD_NUMBER: _ClassVar[int] + user: UserEntity + roles: _containers.RepeatedCompositeFieldContainer[RoleEntity] + def __init__(self, user: _Optional[_Union[UserEntity, _Mapping]] = ..., roles: _Optional[_Iterable[_Union[RoleEntity, _Mapping]]] = ...) -> None: ... + +class SelectUserResponse(_message.Message): + __slots__ = ("status", "results") + STATUS_FIELD_NUMBER: _ClassVar[int] + RESULTS_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + results: _containers.RepeatedCompositeFieldContainer[UserResult] + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., results: _Optional[_Iterable[_Union[UserResult, _Mapping]]] = ...) -> None: ... + +class ObjectEntity(_message.Message): + __slots__ = ("name",) + NAME_FIELD_NUMBER: _ClassVar[int] + name: str + def __init__(self, name: _Optional[str] = ...) -> None: ... + +class PrivilegeEntity(_message.Message): + __slots__ = ("name",) + NAME_FIELD_NUMBER: _ClassVar[int] + name: str + def __init__(self, name: _Optional[str] = ...) -> None: ... + +class GrantorEntity(_message.Message): + __slots__ = ("user", "privilege") + USER_FIELD_NUMBER: _ClassVar[int] + PRIVILEGE_FIELD_NUMBER: _ClassVar[int] + user: UserEntity + privilege: PrivilegeEntity + def __init__(self, user: _Optional[_Union[UserEntity, _Mapping]] = ..., privilege: _Optional[_Union[PrivilegeEntity, _Mapping]] = ...) -> None: ... + +class GrantPrivilegeEntity(_message.Message): + __slots__ = ("entities",) + ENTITIES_FIELD_NUMBER: _ClassVar[int] + entities: _containers.RepeatedCompositeFieldContainer[GrantorEntity] + def __init__(self, entities: _Optional[_Iterable[_Union[GrantorEntity, _Mapping]]] = ...) -> None: ... + +class GrantEntity(_message.Message): + __slots__ = ("role", "object", "object_name", "grantor", "db_name") + ROLE_FIELD_NUMBER: _ClassVar[int] + OBJECT_FIELD_NUMBER: _ClassVar[int] + OBJECT_NAME_FIELD_NUMBER: _ClassVar[int] + GRANTOR_FIELD_NUMBER: _ClassVar[int] + DB_NAME_FIELD_NUMBER: _ClassVar[int] + role: RoleEntity + object: ObjectEntity + object_name: str + grantor: GrantorEntity + db_name: str + def __init__(self, role: _Optional[_Union[RoleEntity, _Mapping]] = ..., object: _Optional[_Union[ObjectEntity, _Mapping]] = ..., object_name: _Optional[str] = ..., grantor: _Optional[_Union[GrantorEntity, _Mapping]] = ..., db_name: _Optional[str] = ...) -> None: ... + +class SelectGrantRequest(_message.Message): + __slots__ = ("base", "entity") + BASE_FIELD_NUMBER: _ClassVar[int] + ENTITY_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + entity: GrantEntity + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., entity: _Optional[_Union[GrantEntity, _Mapping]] = ...) -> None: ... + +class SelectGrantResponse(_message.Message): + __slots__ = ("status", "entities") + STATUS_FIELD_NUMBER: _ClassVar[int] + ENTITIES_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + entities: _containers.RepeatedCompositeFieldContainer[GrantEntity] + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., entities: _Optional[_Iterable[_Union[GrantEntity, _Mapping]]] = ...) -> None: ... + +class OperatePrivilegeRequest(_message.Message): + __slots__ = ("base", "entity", "type") + BASE_FIELD_NUMBER: _ClassVar[int] + ENTITY_FIELD_NUMBER: _ClassVar[int] + TYPE_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + entity: GrantEntity + type: OperatePrivilegeType + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., entity: _Optional[_Union[GrantEntity, _Mapping]] = ..., type: _Optional[_Union[OperatePrivilegeType, str]] = ...) -> None: ... + +class GetLoadingProgressRequest(_message.Message): + __slots__ = ("base", "collection_name", "partition_names", "db_name") + BASE_FIELD_NUMBER: _ClassVar[int] + COLLECTION_NAME_FIELD_NUMBER: _ClassVar[int] + PARTITION_NAMES_FIELD_NUMBER: _ClassVar[int] + DB_NAME_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + collection_name: str + partition_names: _containers.RepeatedScalarFieldContainer[str] + db_name: str + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., collection_name: _Optional[str] = ..., partition_names: _Optional[_Iterable[str]] = ..., db_name: _Optional[str] = ...) -> None: ... + +class GetLoadingProgressResponse(_message.Message): + __slots__ = ("status", "progress", "refresh_progress") + STATUS_FIELD_NUMBER: _ClassVar[int] + PROGRESS_FIELD_NUMBER: _ClassVar[int] + REFRESH_PROGRESS_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + progress: int + refresh_progress: int + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., progress: _Optional[int] = ..., refresh_progress: _Optional[int] = ...) -> None: ... + +class GetLoadStateRequest(_message.Message): + __slots__ = ("base", "collection_name", "partition_names", "db_name") + BASE_FIELD_NUMBER: _ClassVar[int] + COLLECTION_NAME_FIELD_NUMBER: _ClassVar[int] + PARTITION_NAMES_FIELD_NUMBER: _ClassVar[int] + DB_NAME_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + collection_name: str + partition_names: _containers.RepeatedScalarFieldContainer[str] + db_name: str + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., collection_name: _Optional[str] = ..., partition_names: _Optional[_Iterable[str]] = ..., db_name: _Optional[str] = ...) -> None: ... + +class GetLoadStateResponse(_message.Message): + __slots__ = ("status", "state") + STATUS_FIELD_NUMBER: _ClassVar[int] + STATE_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + state: _common_pb2.LoadState + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., state: _Optional[_Union[_common_pb2.LoadState, str]] = ...) -> None: ... + +class MilvusExt(_message.Message): + __slots__ = ("version",) + VERSION_FIELD_NUMBER: _ClassVar[int] + version: str + def __init__(self, version: _Optional[str] = ...) -> None: ... + +class GetVersionRequest(_message.Message): + __slots__ = () + def __init__(self) -> None: ... + +class GetVersionResponse(_message.Message): + __slots__ = ("status", "version") + STATUS_FIELD_NUMBER: _ClassVar[int] + VERSION_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + version: str + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., version: _Optional[str] = ...) -> None: ... + +class CheckHealthRequest(_message.Message): + __slots__ = () + def __init__(self) -> None: ... + +class CheckHealthResponse(_message.Message): + __slots__ = ("status", "isHealthy", "reasons", "quota_states") + STATUS_FIELD_NUMBER: _ClassVar[int] + ISHEALTHY_FIELD_NUMBER: _ClassVar[int] + REASONS_FIELD_NUMBER: _ClassVar[int] + QUOTA_STATES_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + isHealthy: bool + reasons: _containers.RepeatedScalarFieldContainer[str] + quota_states: _containers.RepeatedScalarFieldContainer[QuotaState] + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., isHealthy: bool = ..., reasons: _Optional[_Iterable[str]] = ..., quota_states: _Optional[_Iterable[_Union[QuotaState, str]]] = ...) -> None: ... + +class CreateResourceGroupRequest(_message.Message): + __slots__ = ("base", "resource_group", "config") + BASE_FIELD_NUMBER: _ClassVar[int] + RESOURCE_GROUP_FIELD_NUMBER: _ClassVar[int] + CONFIG_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + resource_group: str + config: _rg_pb2.ResourceGroupConfig + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., resource_group: _Optional[str] = ..., config: _Optional[_Union[_rg_pb2.ResourceGroupConfig, _Mapping]] = ...) -> None: ... + +class UpdateResourceGroupsRequest(_message.Message): + __slots__ = ("base", "resource_groups") + class ResourceGroupsEntry(_message.Message): + __slots__ = ("key", "value") + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: str + value: _rg_pb2.ResourceGroupConfig + def __init__(self, key: _Optional[str] = ..., value: _Optional[_Union[_rg_pb2.ResourceGroupConfig, _Mapping]] = ...) -> None: ... + BASE_FIELD_NUMBER: _ClassVar[int] + RESOURCE_GROUPS_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + resource_groups: _containers.MessageMap[str, _rg_pb2.ResourceGroupConfig] + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., resource_groups: _Optional[_Mapping[str, _rg_pb2.ResourceGroupConfig]] = ...) -> None: ... + +class DropResourceGroupRequest(_message.Message): + __slots__ = ("base", "resource_group") + BASE_FIELD_NUMBER: _ClassVar[int] + RESOURCE_GROUP_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + resource_group: str + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., resource_group: _Optional[str] = ...) -> None: ... + +class TransferNodeRequest(_message.Message): + __slots__ = ("base", "source_resource_group", "target_resource_group", "num_node") + BASE_FIELD_NUMBER: _ClassVar[int] + SOURCE_RESOURCE_GROUP_FIELD_NUMBER: _ClassVar[int] + TARGET_RESOURCE_GROUP_FIELD_NUMBER: _ClassVar[int] + NUM_NODE_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + source_resource_group: str + target_resource_group: str + num_node: int + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., source_resource_group: _Optional[str] = ..., target_resource_group: _Optional[str] = ..., num_node: _Optional[int] = ...) -> None: ... + +class TransferReplicaRequest(_message.Message): + __slots__ = ("base", "source_resource_group", "target_resource_group", "collection_name", "num_replica", "db_name") + BASE_FIELD_NUMBER: _ClassVar[int] + SOURCE_RESOURCE_GROUP_FIELD_NUMBER: _ClassVar[int] + TARGET_RESOURCE_GROUP_FIELD_NUMBER: _ClassVar[int] + COLLECTION_NAME_FIELD_NUMBER: _ClassVar[int] + NUM_REPLICA_FIELD_NUMBER: _ClassVar[int] + DB_NAME_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + source_resource_group: str + target_resource_group: str + collection_name: str + num_replica: int + db_name: str + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., source_resource_group: _Optional[str] = ..., target_resource_group: _Optional[str] = ..., collection_name: _Optional[str] = ..., num_replica: _Optional[int] = ..., db_name: _Optional[str] = ...) -> None: ... + +class ListResourceGroupsRequest(_message.Message): + __slots__ = ("base",) + BASE_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ...) -> None: ... + +class ListResourceGroupsResponse(_message.Message): + __slots__ = ("status", "resource_groups") + STATUS_FIELD_NUMBER: _ClassVar[int] + RESOURCE_GROUPS_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + resource_groups: _containers.RepeatedScalarFieldContainer[str] + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., resource_groups: _Optional[_Iterable[str]] = ...) -> None: ... + +class DescribeResourceGroupRequest(_message.Message): + __slots__ = ("base", "resource_group") + BASE_FIELD_NUMBER: _ClassVar[int] + RESOURCE_GROUP_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + resource_group: str + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., resource_group: _Optional[str] = ...) -> None: ... + +class DescribeResourceGroupResponse(_message.Message): + __slots__ = ("status", "resource_group") + STATUS_FIELD_NUMBER: _ClassVar[int] + RESOURCE_GROUP_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + resource_group: ResourceGroup + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., resource_group: _Optional[_Union[ResourceGroup, _Mapping]] = ...) -> None: ... + +class ResourceGroup(_message.Message): + __slots__ = ("name", "capacity", "num_available_node", "num_loaded_replica", "num_outgoing_node", "num_incoming_node", "config", "nodes") + class NumLoadedReplicaEntry(_message.Message): + __slots__ = ("key", "value") + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: str + value: int + def __init__(self, key: _Optional[str] = ..., value: _Optional[int] = ...) -> None: ... + class NumOutgoingNodeEntry(_message.Message): + __slots__ = ("key", "value") + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: str + value: int + def __init__(self, key: _Optional[str] = ..., value: _Optional[int] = ...) -> None: ... + class NumIncomingNodeEntry(_message.Message): + __slots__ = ("key", "value") + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: str + value: int + def __init__(self, key: _Optional[str] = ..., value: _Optional[int] = ...) -> None: ... + NAME_FIELD_NUMBER: _ClassVar[int] + CAPACITY_FIELD_NUMBER: _ClassVar[int] + NUM_AVAILABLE_NODE_FIELD_NUMBER: _ClassVar[int] + NUM_LOADED_REPLICA_FIELD_NUMBER: _ClassVar[int] + NUM_OUTGOING_NODE_FIELD_NUMBER: _ClassVar[int] + NUM_INCOMING_NODE_FIELD_NUMBER: _ClassVar[int] + CONFIG_FIELD_NUMBER: _ClassVar[int] + NODES_FIELD_NUMBER: _ClassVar[int] + name: str + capacity: int + num_available_node: int + num_loaded_replica: _containers.ScalarMap[str, int] + num_outgoing_node: _containers.ScalarMap[str, int] + num_incoming_node: _containers.ScalarMap[str, int] + config: _rg_pb2.ResourceGroupConfig + nodes: _containers.RepeatedCompositeFieldContainer[_common_pb2.NodeInfo] + def __init__(self, name: _Optional[str] = ..., capacity: _Optional[int] = ..., num_available_node: _Optional[int] = ..., num_loaded_replica: _Optional[_Mapping[str, int]] = ..., num_outgoing_node: _Optional[_Mapping[str, int]] = ..., num_incoming_node: _Optional[_Mapping[str, int]] = ..., config: _Optional[_Union[_rg_pb2.ResourceGroupConfig, _Mapping]] = ..., nodes: _Optional[_Iterable[_Union[_common_pb2.NodeInfo, _Mapping]]] = ...) -> None: ... + +class RenameCollectionRequest(_message.Message): + __slots__ = ("base", "db_name", "oldName", "newName", "newDBName") + BASE_FIELD_NUMBER: _ClassVar[int] + DB_NAME_FIELD_NUMBER: _ClassVar[int] + OLDNAME_FIELD_NUMBER: _ClassVar[int] + NEWNAME_FIELD_NUMBER: _ClassVar[int] + NEWDBNAME_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + db_name: str + oldName: str + newName: str + newDBName: str + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., db_name: _Optional[str] = ..., oldName: _Optional[str] = ..., newName: _Optional[str] = ..., newDBName: _Optional[str] = ...) -> None: ... + +class GetIndexStatisticsRequest(_message.Message): + __slots__ = ("base", "db_name", "collection_name", "index_name", "timestamp") + BASE_FIELD_NUMBER: _ClassVar[int] + DB_NAME_FIELD_NUMBER: _ClassVar[int] + COLLECTION_NAME_FIELD_NUMBER: _ClassVar[int] + INDEX_NAME_FIELD_NUMBER: _ClassVar[int] + TIMESTAMP_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + db_name: str + collection_name: str + index_name: str + timestamp: int + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., db_name: _Optional[str] = ..., collection_name: _Optional[str] = ..., index_name: _Optional[str] = ..., timestamp: _Optional[int] = ...) -> None: ... + +class GetIndexStatisticsResponse(_message.Message): + __slots__ = ("status", "index_descriptions") + STATUS_FIELD_NUMBER: _ClassVar[int] + INDEX_DESCRIPTIONS_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + index_descriptions: _containers.RepeatedCompositeFieldContainer[IndexDescription] + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., index_descriptions: _Optional[_Iterable[_Union[IndexDescription, _Mapping]]] = ...) -> None: ... + +class ConnectRequest(_message.Message): + __slots__ = ("base", "client_info") + BASE_FIELD_NUMBER: _ClassVar[int] + CLIENT_INFO_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + client_info: _common_pb2.ClientInfo + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., client_info: _Optional[_Union[_common_pb2.ClientInfo, _Mapping]] = ...) -> None: ... + +class ConnectResponse(_message.Message): + __slots__ = ("status", "server_info", "identifier") + STATUS_FIELD_NUMBER: _ClassVar[int] + SERVER_INFO_FIELD_NUMBER: _ClassVar[int] + IDENTIFIER_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + server_info: _common_pb2.ServerInfo + identifier: int + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., server_info: _Optional[_Union[_common_pb2.ServerInfo, _Mapping]] = ..., identifier: _Optional[int] = ...) -> None: ... + +class AllocTimestampRequest(_message.Message): + __slots__ = ("base",) + BASE_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ...) -> None: ... + +class AllocTimestampResponse(_message.Message): + __slots__ = ("status", "timestamp") + STATUS_FIELD_NUMBER: _ClassVar[int] + TIMESTAMP_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + timestamp: int + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., timestamp: _Optional[int] = ...) -> None: ... + +class CreateDatabaseRequest(_message.Message): + __slots__ = ("base", "db_name") + BASE_FIELD_NUMBER: _ClassVar[int] + DB_NAME_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + db_name: str + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., db_name: _Optional[str] = ...) -> None: ... + +class DropDatabaseRequest(_message.Message): + __slots__ = ("base", "db_name") + BASE_FIELD_NUMBER: _ClassVar[int] + DB_NAME_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + db_name: str + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., db_name: _Optional[str] = ...) -> None: ... + +class ListDatabasesRequest(_message.Message): + __slots__ = ("base",) + BASE_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ...) -> None: ... + +class ListDatabasesResponse(_message.Message): + __slots__ = ("status", "db_names", "created_timestamp") + STATUS_FIELD_NUMBER: _ClassVar[int] + DB_NAMES_FIELD_NUMBER: _ClassVar[int] + CREATED_TIMESTAMP_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + db_names: _containers.RepeatedScalarFieldContainer[str] + created_timestamp: _containers.RepeatedScalarFieldContainer[int] + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., db_names: _Optional[_Iterable[str]] = ..., created_timestamp: _Optional[_Iterable[int]] = ...) -> None: ... + +class ReplicateMessageRequest(_message.Message): + __slots__ = ("base", "channel_name", "BeginTs", "EndTs", "Msgs", "StartPositions", "EndPositions") + BASE_FIELD_NUMBER: _ClassVar[int] + CHANNEL_NAME_FIELD_NUMBER: _ClassVar[int] + BEGINTS_FIELD_NUMBER: _ClassVar[int] + ENDTS_FIELD_NUMBER: _ClassVar[int] + MSGS_FIELD_NUMBER: _ClassVar[int] + STARTPOSITIONS_FIELD_NUMBER: _ClassVar[int] + ENDPOSITIONS_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + channel_name: str + BeginTs: int + EndTs: int + Msgs: _containers.RepeatedScalarFieldContainer[bytes] + StartPositions: _containers.RepeatedCompositeFieldContainer[_msg_pb2.MsgPosition] + EndPositions: _containers.RepeatedCompositeFieldContainer[_msg_pb2.MsgPosition] + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., channel_name: _Optional[str] = ..., BeginTs: _Optional[int] = ..., EndTs: _Optional[int] = ..., Msgs: _Optional[_Iterable[bytes]] = ..., StartPositions: _Optional[_Iterable[_Union[_msg_pb2.MsgPosition, _Mapping]]] = ..., EndPositions: _Optional[_Iterable[_Union[_msg_pb2.MsgPosition, _Mapping]]] = ...) -> None: ... + +class ReplicateMessageResponse(_message.Message): + __slots__ = ("status", "position") + STATUS_FIELD_NUMBER: _ClassVar[int] + POSITION_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + position: str + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., position: _Optional[str] = ...) -> None: ... diff --git a/milvus_connector/protocol/milvus_pb2_grpc.py b/milvus_connector/protocol/milvus_pb2_grpc.py new file mode 100644 index 0000000..565e7bf --- /dev/null +++ b/milvus_connector/protocol/milvus_pb2_grpc.py @@ -0,0 +1,2875 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + +from . import common_pb2 as common__pb2 +from . import feder_pb2 as feder__pb2 +from . import milvus_pb2 as milvus__pb2 + + +class MilvusServiceStub(object): + """Missing associated documentation comment in .proto file.""" + + def __init__(self, channel): + """Constructor. + + Args: + channel: A grpc.Channel. + """ + self.CreateCollection = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/CreateCollection', + request_serializer=milvus__pb2.CreateCollectionRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.DropCollection = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/DropCollection', + request_serializer=milvus__pb2.DropCollectionRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.HasCollection = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/HasCollection', + request_serializer=milvus__pb2.HasCollectionRequest.SerializeToString, + response_deserializer=milvus__pb2.BoolResponse.FromString, + ) + self.LoadCollection = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/LoadCollection', + request_serializer=milvus__pb2.LoadCollectionRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.ReleaseCollection = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/ReleaseCollection', + request_serializer=milvus__pb2.ReleaseCollectionRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.DescribeCollection = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/DescribeCollection', + request_serializer=milvus__pb2.DescribeCollectionRequest.SerializeToString, + response_deserializer=milvus__pb2.DescribeCollectionResponse.FromString, + ) + self.GetCollectionStatistics = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/GetCollectionStatistics', + request_serializer=milvus__pb2.GetCollectionStatisticsRequest.SerializeToString, + response_deserializer=milvus__pb2.GetCollectionStatisticsResponse.FromString, + ) + self.ShowCollections = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/ShowCollections', + request_serializer=milvus__pb2.ShowCollectionsRequest.SerializeToString, + response_deserializer=milvus__pb2.ShowCollectionsResponse.FromString, + ) + self.AlterCollection = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/AlterCollection', + request_serializer=milvus__pb2.AlterCollectionRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.CreatePartition = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/CreatePartition', + request_serializer=milvus__pb2.CreatePartitionRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.DropPartition = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/DropPartition', + request_serializer=milvus__pb2.DropPartitionRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.HasPartition = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/HasPartition', + request_serializer=milvus__pb2.HasPartitionRequest.SerializeToString, + response_deserializer=milvus__pb2.BoolResponse.FromString, + ) + self.LoadPartitions = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/LoadPartitions', + request_serializer=milvus__pb2.LoadPartitionsRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.ReleasePartitions = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/ReleasePartitions', + request_serializer=milvus__pb2.ReleasePartitionsRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.GetPartitionStatistics = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/GetPartitionStatistics', + request_serializer=milvus__pb2.GetPartitionStatisticsRequest.SerializeToString, + response_deserializer=milvus__pb2.GetPartitionStatisticsResponse.FromString, + ) + self.ShowPartitions = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/ShowPartitions', + request_serializer=milvus__pb2.ShowPartitionsRequest.SerializeToString, + response_deserializer=milvus__pb2.ShowPartitionsResponse.FromString, + ) + self.GetLoadingProgress = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/GetLoadingProgress', + request_serializer=milvus__pb2.GetLoadingProgressRequest.SerializeToString, + response_deserializer=milvus__pb2.GetLoadingProgressResponse.FromString, + ) + self.GetLoadState = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/GetLoadState', + request_serializer=milvus__pb2.GetLoadStateRequest.SerializeToString, + response_deserializer=milvus__pb2.GetLoadStateResponse.FromString, + ) + self.CreateAlias = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/CreateAlias', + request_serializer=milvus__pb2.CreateAliasRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.DropAlias = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/DropAlias', + request_serializer=milvus__pb2.DropAliasRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.AlterAlias = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/AlterAlias', + request_serializer=milvus__pb2.AlterAliasRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.DescribeAlias = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/DescribeAlias', + request_serializer=milvus__pb2.DescribeAliasRequest.SerializeToString, + response_deserializer=milvus__pb2.DescribeAliasResponse.FromString, + ) + self.ListAliases = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/ListAliases', + request_serializer=milvus__pb2.ListAliasesRequest.SerializeToString, + response_deserializer=milvus__pb2.ListAliasesResponse.FromString, + ) + self.CreateIndex = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/CreateIndex', + request_serializer=milvus__pb2.CreateIndexRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.AlterIndex = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/AlterIndex', + request_serializer=milvus__pb2.AlterIndexRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.DescribeIndex = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/DescribeIndex', + request_serializer=milvus__pb2.DescribeIndexRequest.SerializeToString, + response_deserializer=milvus__pb2.DescribeIndexResponse.FromString, + ) + self.GetIndexStatistics = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/GetIndexStatistics', + request_serializer=milvus__pb2.GetIndexStatisticsRequest.SerializeToString, + response_deserializer=milvus__pb2.GetIndexStatisticsResponse.FromString, + ) + self.GetIndexState = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/GetIndexState', + request_serializer=milvus__pb2.GetIndexStateRequest.SerializeToString, + response_deserializer=milvus__pb2.GetIndexStateResponse.FromString, + ) + self.GetIndexBuildProgress = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/GetIndexBuildProgress', + request_serializer=milvus__pb2.GetIndexBuildProgressRequest.SerializeToString, + response_deserializer=milvus__pb2.GetIndexBuildProgressResponse.FromString, + ) + self.DropIndex = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/DropIndex', + request_serializer=milvus__pb2.DropIndexRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.Insert = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/Insert', + request_serializer=milvus__pb2.InsertRequest.SerializeToString, + response_deserializer=milvus__pb2.MutationResult.FromString, + ) + self.Delete = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/Delete', + request_serializer=milvus__pb2.DeleteRequest.SerializeToString, + response_deserializer=milvus__pb2.MutationResult.FromString, + ) + self.Upsert = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/Upsert', + request_serializer=milvus__pb2.UpsertRequest.SerializeToString, + response_deserializer=milvus__pb2.MutationResult.FromString, + ) + self.Search = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/Search', + request_serializer=milvus__pb2.SearchRequest.SerializeToString, + response_deserializer=milvus__pb2.SearchResults.FromString, + ) + self.HybridSearch = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/HybridSearch', + request_serializer=milvus__pb2.HybridSearchRequest.SerializeToString, + response_deserializer=milvus__pb2.SearchResults.FromString, + ) + self.Flush = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/Flush', + request_serializer=milvus__pb2.FlushRequest.SerializeToString, + response_deserializer=milvus__pb2.FlushResponse.FromString, + ) + self.Query = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/Query', + request_serializer=milvus__pb2.QueryRequest.SerializeToString, + response_deserializer=milvus__pb2.QueryResults.FromString, + ) + self.CalcDistance = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/CalcDistance', + request_serializer=milvus__pb2.CalcDistanceRequest.SerializeToString, + response_deserializer=milvus__pb2.CalcDistanceResults.FromString, + ) + self.FlushAll = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/FlushAll', + request_serializer=milvus__pb2.FlushAllRequest.SerializeToString, + response_deserializer=milvus__pb2.FlushAllResponse.FromString, + ) + self.GetFlushState = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/GetFlushState', + request_serializer=milvus__pb2.GetFlushStateRequest.SerializeToString, + response_deserializer=milvus__pb2.GetFlushStateResponse.FromString, + ) + self.GetFlushAllState = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/GetFlushAllState', + request_serializer=milvus__pb2.GetFlushAllStateRequest.SerializeToString, + response_deserializer=milvus__pb2.GetFlushAllStateResponse.FromString, + ) + self.GetPersistentSegmentInfo = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/GetPersistentSegmentInfo', + request_serializer=milvus__pb2.GetPersistentSegmentInfoRequest.SerializeToString, + response_deserializer=milvus__pb2.GetPersistentSegmentInfoResponse.FromString, + ) + self.GetQuerySegmentInfo = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/GetQuerySegmentInfo', + request_serializer=milvus__pb2.GetQuerySegmentInfoRequest.SerializeToString, + response_deserializer=milvus__pb2.GetQuerySegmentInfoResponse.FromString, + ) + self.GetReplicas = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/GetReplicas', + request_serializer=milvus__pb2.GetReplicasRequest.SerializeToString, + response_deserializer=milvus__pb2.GetReplicasResponse.FromString, + ) + self.Dummy = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/Dummy', + request_serializer=milvus__pb2.DummyRequest.SerializeToString, + response_deserializer=milvus__pb2.DummyResponse.FromString, + ) + self.RegisterLink = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/RegisterLink', + request_serializer=milvus__pb2.RegisterLinkRequest.SerializeToString, + response_deserializer=milvus__pb2.RegisterLinkResponse.FromString, + ) + self.GetMetrics = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/GetMetrics', + request_serializer=milvus__pb2.GetMetricsRequest.SerializeToString, + response_deserializer=milvus__pb2.GetMetricsResponse.FromString, + ) + self.GetComponentStates = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/GetComponentStates', + request_serializer=milvus__pb2.GetComponentStatesRequest.SerializeToString, + response_deserializer=milvus__pb2.ComponentStates.FromString, + ) + self.LoadBalance = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/LoadBalance', + request_serializer=milvus__pb2.LoadBalanceRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.GetCompactionState = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/GetCompactionState', + request_serializer=milvus__pb2.GetCompactionStateRequest.SerializeToString, + response_deserializer=milvus__pb2.GetCompactionStateResponse.FromString, + ) + self.ManualCompaction = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/ManualCompaction', + request_serializer=milvus__pb2.ManualCompactionRequest.SerializeToString, + response_deserializer=milvus__pb2.ManualCompactionResponse.FromString, + ) + self.GetCompactionStateWithPlans = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/GetCompactionStateWithPlans', + request_serializer=milvus__pb2.GetCompactionPlansRequest.SerializeToString, + response_deserializer=milvus__pb2.GetCompactionPlansResponse.FromString, + ) + self.Import = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/Import', + request_serializer=milvus__pb2.ImportRequest.SerializeToString, + response_deserializer=milvus__pb2.ImportResponse.FromString, + ) + self.GetImportState = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/GetImportState', + request_serializer=milvus__pb2.GetImportStateRequest.SerializeToString, + response_deserializer=milvus__pb2.GetImportStateResponse.FromString, + ) + self.ListImportTasks = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/ListImportTasks', + request_serializer=milvus__pb2.ListImportTasksRequest.SerializeToString, + response_deserializer=milvus__pb2.ListImportTasksResponse.FromString, + ) + self.CreateCredential = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/CreateCredential', + request_serializer=milvus__pb2.CreateCredentialRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.UpdateCredential = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/UpdateCredential', + request_serializer=milvus__pb2.UpdateCredentialRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.DeleteCredential = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/DeleteCredential', + request_serializer=milvus__pb2.DeleteCredentialRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.ListCredUsers = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/ListCredUsers', + request_serializer=milvus__pb2.ListCredUsersRequest.SerializeToString, + response_deserializer=milvus__pb2.ListCredUsersResponse.FromString, + ) + self.CreateRole = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/CreateRole', + request_serializer=milvus__pb2.CreateRoleRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.DropRole = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/DropRole', + request_serializer=milvus__pb2.DropRoleRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.OperateUserRole = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/OperateUserRole', + request_serializer=milvus__pb2.OperateUserRoleRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.SelectRole = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/SelectRole', + request_serializer=milvus__pb2.SelectRoleRequest.SerializeToString, + response_deserializer=milvus__pb2.SelectRoleResponse.FromString, + ) + self.SelectUser = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/SelectUser', + request_serializer=milvus__pb2.SelectUserRequest.SerializeToString, + response_deserializer=milvus__pb2.SelectUserResponse.FromString, + ) + self.OperatePrivilege = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/OperatePrivilege', + request_serializer=milvus__pb2.OperatePrivilegeRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.SelectGrant = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/SelectGrant', + request_serializer=milvus__pb2.SelectGrantRequest.SerializeToString, + response_deserializer=milvus__pb2.SelectGrantResponse.FromString, + ) + self.GetVersion = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/GetVersion', + request_serializer=milvus__pb2.GetVersionRequest.SerializeToString, + response_deserializer=milvus__pb2.GetVersionResponse.FromString, + ) + self.CheckHealth = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/CheckHealth', + request_serializer=milvus__pb2.CheckHealthRequest.SerializeToString, + response_deserializer=milvus__pb2.CheckHealthResponse.FromString, + ) + self.CreateResourceGroup = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/CreateResourceGroup', + request_serializer=milvus__pb2.CreateResourceGroupRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.DropResourceGroup = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/DropResourceGroup', + request_serializer=milvus__pb2.DropResourceGroupRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.UpdateResourceGroups = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/UpdateResourceGroups', + request_serializer=milvus__pb2.UpdateResourceGroupsRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.TransferNode = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/TransferNode', + request_serializer=milvus__pb2.TransferNodeRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.TransferReplica = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/TransferReplica', + request_serializer=milvus__pb2.TransferReplicaRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.ListResourceGroups = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/ListResourceGroups', + request_serializer=milvus__pb2.ListResourceGroupsRequest.SerializeToString, + response_deserializer=milvus__pb2.ListResourceGroupsResponse.FromString, + ) + self.DescribeResourceGroup = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/DescribeResourceGroup', + request_serializer=milvus__pb2.DescribeResourceGroupRequest.SerializeToString, + response_deserializer=milvus__pb2.DescribeResourceGroupResponse.FromString, + ) + self.RenameCollection = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/RenameCollection', + request_serializer=milvus__pb2.RenameCollectionRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.ListIndexedSegment = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/ListIndexedSegment', + request_serializer=feder__pb2.ListIndexedSegmentRequest.SerializeToString, + response_deserializer=feder__pb2.ListIndexedSegmentResponse.FromString, + ) + self.DescribeSegmentIndexData = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/DescribeSegmentIndexData', + request_serializer=feder__pb2.DescribeSegmentIndexDataRequest.SerializeToString, + response_deserializer=feder__pb2.DescribeSegmentIndexDataResponse.FromString, + ) + self.Connect = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/Connect', + request_serializer=milvus__pb2.ConnectRequest.SerializeToString, + response_deserializer=milvus__pb2.ConnectResponse.FromString, + ) + self.AllocTimestamp = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/AllocTimestamp', + request_serializer=milvus__pb2.AllocTimestampRequest.SerializeToString, + response_deserializer=milvus__pb2.AllocTimestampResponse.FromString, + ) + self.CreateDatabase = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/CreateDatabase', + request_serializer=milvus__pb2.CreateDatabaseRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.DropDatabase = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/DropDatabase', + request_serializer=milvus__pb2.DropDatabaseRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.ListDatabases = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/ListDatabases', + request_serializer=milvus__pb2.ListDatabasesRequest.SerializeToString, + response_deserializer=milvus__pb2.ListDatabasesResponse.FromString, + ) + self.ReplicateMessage = channel.unary_unary( + '/milvus.proto.milvus.MilvusService/ReplicateMessage', + request_serializer=milvus__pb2.ReplicateMessageRequest.SerializeToString, + response_deserializer=milvus__pb2.ReplicateMessageResponse.FromString, + ) + + +class MilvusServiceServicer(object): + """Missing associated documentation comment in .proto file.""" + + def CreateCollection(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def DropCollection(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def HasCollection(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def LoadCollection(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ReleaseCollection(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def DescribeCollection(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetCollectionStatistics(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ShowCollections(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def AlterCollection(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def CreatePartition(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def DropPartition(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def HasPartition(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def LoadPartitions(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ReleasePartitions(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetPartitionStatistics(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ShowPartitions(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetLoadingProgress(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetLoadState(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def CreateAlias(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def DropAlias(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def AlterAlias(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def DescribeAlias(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ListAliases(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def CreateIndex(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def AlterIndex(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def DescribeIndex(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetIndexStatistics(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetIndexState(self, request, context): + """Deprecated: use DescribeIndex instead + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetIndexBuildProgress(self, request, context): + """Deprecated: use DescribeIndex instead + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def DropIndex(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def Insert(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def Delete(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def Upsert(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def Search(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def HybridSearch(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def Flush(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def Query(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def CalcDistance(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def FlushAll(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetFlushState(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetFlushAllState(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetPersistentSegmentInfo(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetQuerySegmentInfo(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetReplicas(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def Dummy(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def RegisterLink(self, request, context): + """TODO: remove + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetMetrics(self, request, context): + """https://wiki.lfaidata.foundation/display/MIL/MEP+8+--+Add+metrics+for+proxy + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetComponentStates(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def LoadBalance(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetCompactionState(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ManualCompaction(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetCompactionStateWithPlans(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def Import(self, request, context): + """https://wiki.lfaidata.foundation/display/MIL/MEP+24+--+Support+bulk+load + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetImportState(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ListImportTasks(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def CreateCredential(self, request, context): + """https://wiki.lfaidata.foundation/display/MIL/MEP+27+--+Support+Basic+Authentication + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def UpdateCredential(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def DeleteCredential(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ListCredUsers(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def CreateRole(self, request, context): + """https://wiki.lfaidata.foundation/display/MIL/MEP+29+--+Support+Role-Based+Access+Control + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def DropRole(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def OperateUserRole(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def SelectRole(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def SelectUser(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def OperatePrivilege(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def SelectGrant(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetVersion(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def CheckHealth(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def CreateResourceGroup(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def DropResourceGroup(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def UpdateResourceGroups(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def TransferNode(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def TransferReplica(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ListResourceGroups(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def DescribeResourceGroup(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def RenameCollection(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ListIndexedSegment(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def DescribeSegmentIndexData(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def Connect(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def AllocTimestamp(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def CreateDatabase(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def DropDatabase(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ListDatabases(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ReplicateMessage(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + +def add_MilvusServiceServicer_to_server(servicer, server): + rpc_method_handlers = { + 'CreateCollection': grpc.unary_unary_rpc_method_handler( + servicer.CreateCollection, + request_deserializer=milvus__pb2.CreateCollectionRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'DropCollection': grpc.unary_unary_rpc_method_handler( + servicer.DropCollection, + request_deserializer=milvus__pb2.DropCollectionRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'HasCollection': grpc.unary_unary_rpc_method_handler( + servicer.HasCollection, + request_deserializer=milvus__pb2.HasCollectionRequest.FromString, + response_serializer=milvus__pb2.BoolResponse.SerializeToString, + ), + 'LoadCollection': grpc.unary_unary_rpc_method_handler( + servicer.LoadCollection, + request_deserializer=milvus__pb2.LoadCollectionRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'ReleaseCollection': grpc.unary_unary_rpc_method_handler( + servicer.ReleaseCollection, + request_deserializer=milvus__pb2.ReleaseCollectionRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'DescribeCollection': grpc.unary_unary_rpc_method_handler( + servicer.DescribeCollection, + request_deserializer=milvus__pb2.DescribeCollectionRequest.FromString, + response_serializer=milvus__pb2.DescribeCollectionResponse.SerializeToString, + ), + 'GetCollectionStatistics': grpc.unary_unary_rpc_method_handler( + servicer.GetCollectionStatistics, + request_deserializer=milvus__pb2.GetCollectionStatisticsRequest.FromString, + response_serializer=milvus__pb2.GetCollectionStatisticsResponse.SerializeToString, + ), + 'ShowCollections': grpc.unary_unary_rpc_method_handler( + servicer.ShowCollections, + request_deserializer=milvus__pb2.ShowCollectionsRequest.FromString, + response_serializer=milvus__pb2.ShowCollectionsResponse.SerializeToString, + ), + 'AlterCollection': grpc.unary_unary_rpc_method_handler( + servicer.AlterCollection, + request_deserializer=milvus__pb2.AlterCollectionRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'CreatePartition': grpc.unary_unary_rpc_method_handler( + servicer.CreatePartition, + request_deserializer=milvus__pb2.CreatePartitionRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'DropPartition': grpc.unary_unary_rpc_method_handler( + servicer.DropPartition, + request_deserializer=milvus__pb2.DropPartitionRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'HasPartition': grpc.unary_unary_rpc_method_handler( + servicer.HasPartition, + request_deserializer=milvus__pb2.HasPartitionRequest.FromString, + response_serializer=milvus__pb2.BoolResponse.SerializeToString, + ), + 'LoadPartitions': grpc.unary_unary_rpc_method_handler( + servicer.LoadPartitions, + request_deserializer=milvus__pb2.LoadPartitionsRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'ReleasePartitions': grpc.unary_unary_rpc_method_handler( + servicer.ReleasePartitions, + request_deserializer=milvus__pb2.ReleasePartitionsRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'GetPartitionStatistics': grpc.unary_unary_rpc_method_handler( + servicer.GetPartitionStatistics, + request_deserializer=milvus__pb2.GetPartitionStatisticsRequest.FromString, + response_serializer=milvus__pb2.GetPartitionStatisticsResponse.SerializeToString, + ), + 'ShowPartitions': grpc.unary_unary_rpc_method_handler( + servicer.ShowPartitions, + request_deserializer=milvus__pb2.ShowPartitionsRequest.FromString, + response_serializer=milvus__pb2.ShowPartitionsResponse.SerializeToString, + ), + 'GetLoadingProgress': grpc.unary_unary_rpc_method_handler( + servicer.GetLoadingProgress, + request_deserializer=milvus__pb2.GetLoadingProgressRequest.FromString, + response_serializer=milvus__pb2.GetLoadingProgressResponse.SerializeToString, + ), + 'GetLoadState': grpc.unary_unary_rpc_method_handler( + servicer.GetLoadState, + request_deserializer=milvus__pb2.GetLoadStateRequest.FromString, + response_serializer=milvus__pb2.GetLoadStateResponse.SerializeToString, + ), + 'CreateAlias': grpc.unary_unary_rpc_method_handler( + servicer.CreateAlias, + request_deserializer=milvus__pb2.CreateAliasRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'DropAlias': grpc.unary_unary_rpc_method_handler( + servicer.DropAlias, + request_deserializer=milvus__pb2.DropAliasRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'AlterAlias': grpc.unary_unary_rpc_method_handler( + servicer.AlterAlias, + request_deserializer=milvus__pb2.AlterAliasRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'DescribeAlias': grpc.unary_unary_rpc_method_handler( + servicer.DescribeAlias, + request_deserializer=milvus__pb2.DescribeAliasRequest.FromString, + response_serializer=milvus__pb2.DescribeAliasResponse.SerializeToString, + ), + 'ListAliases': grpc.unary_unary_rpc_method_handler( + servicer.ListAliases, + request_deserializer=milvus__pb2.ListAliasesRequest.FromString, + response_serializer=milvus__pb2.ListAliasesResponse.SerializeToString, + ), + 'CreateIndex': grpc.unary_unary_rpc_method_handler( + servicer.CreateIndex, + request_deserializer=milvus__pb2.CreateIndexRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'AlterIndex': grpc.unary_unary_rpc_method_handler( + servicer.AlterIndex, + request_deserializer=milvus__pb2.AlterIndexRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'DescribeIndex': grpc.unary_unary_rpc_method_handler( + servicer.DescribeIndex, + request_deserializer=milvus__pb2.DescribeIndexRequest.FromString, + response_serializer=milvus__pb2.DescribeIndexResponse.SerializeToString, + ), + 'GetIndexStatistics': grpc.unary_unary_rpc_method_handler( + servicer.GetIndexStatistics, + request_deserializer=milvus__pb2.GetIndexStatisticsRequest.FromString, + response_serializer=milvus__pb2.GetIndexStatisticsResponse.SerializeToString, + ), + 'GetIndexState': grpc.unary_unary_rpc_method_handler( + servicer.GetIndexState, + request_deserializer=milvus__pb2.GetIndexStateRequest.FromString, + response_serializer=milvus__pb2.GetIndexStateResponse.SerializeToString, + ), + 'GetIndexBuildProgress': grpc.unary_unary_rpc_method_handler( + servicer.GetIndexBuildProgress, + request_deserializer=milvus__pb2.GetIndexBuildProgressRequest.FromString, + response_serializer=milvus__pb2.GetIndexBuildProgressResponse.SerializeToString, + ), + 'DropIndex': grpc.unary_unary_rpc_method_handler( + servicer.DropIndex, + request_deserializer=milvus__pb2.DropIndexRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'Insert': grpc.unary_unary_rpc_method_handler( + servicer.Insert, + request_deserializer=milvus__pb2.InsertRequest.FromString, + response_serializer=milvus__pb2.MutationResult.SerializeToString, + ), + 'Delete': grpc.unary_unary_rpc_method_handler( + servicer.Delete, + request_deserializer=milvus__pb2.DeleteRequest.FromString, + response_serializer=milvus__pb2.MutationResult.SerializeToString, + ), + 'Upsert': grpc.unary_unary_rpc_method_handler( + servicer.Upsert, + request_deserializer=milvus__pb2.UpsertRequest.FromString, + response_serializer=milvus__pb2.MutationResult.SerializeToString, + ), + 'Search': grpc.unary_unary_rpc_method_handler( + servicer.Search, + request_deserializer=milvus__pb2.SearchRequest.FromString, + response_serializer=milvus__pb2.SearchResults.SerializeToString, + ), + 'HybridSearch': grpc.unary_unary_rpc_method_handler( + servicer.HybridSearch, + request_deserializer=milvus__pb2.HybridSearchRequest.FromString, + response_serializer=milvus__pb2.SearchResults.SerializeToString, + ), + 'Flush': grpc.unary_unary_rpc_method_handler( + servicer.Flush, + request_deserializer=milvus__pb2.FlushRequest.FromString, + response_serializer=milvus__pb2.FlushResponse.SerializeToString, + ), + 'Query': grpc.unary_unary_rpc_method_handler( + servicer.Query, + request_deserializer=milvus__pb2.QueryRequest.FromString, + response_serializer=milvus__pb2.QueryResults.SerializeToString, + ), + 'CalcDistance': grpc.unary_unary_rpc_method_handler( + servicer.CalcDistance, + request_deserializer=milvus__pb2.CalcDistanceRequest.FromString, + response_serializer=milvus__pb2.CalcDistanceResults.SerializeToString, + ), + 'FlushAll': grpc.unary_unary_rpc_method_handler( + servicer.FlushAll, + request_deserializer=milvus__pb2.FlushAllRequest.FromString, + response_serializer=milvus__pb2.FlushAllResponse.SerializeToString, + ), + 'GetFlushState': grpc.unary_unary_rpc_method_handler( + servicer.GetFlushState, + request_deserializer=milvus__pb2.GetFlushStateRequest.FromString, + response_serializer=milvus__pb2.GetFlushStateResponse.SerializeToString, + ), + 'GetFlushAllState': grpc.unary_unary_rpc_method_handler( + servicer.GetFlushAllState, + request_deserializer=milvus__pb2.GetFlushAllStateRequest.FromString, + response_serializer=milvus__pb2.GetFlushAllStateResponse.SerializeToString, + ), + 'GetPersistentSegmentInfo': grpc.unary_unary_rpc_method_handler( + servicer.GetPersistentSegmentInfo, + request_deserializer=milvus__pb2.GetPersistentSegmentInfoRequest.FromString, + response_serializer=milvus__pb2.GetPersistentSegmentInfoResponse.SerializeToString, + ), + 'GetQuerySegmentInfo': grpc.unary_unary_rpc_method_handler( + servicer.GetQuerySegmentInfo, + request_deserializer=milvus__pb2.GetQuerySegmentInfoRequest.FromString, + response_serializer=milvus__pb2.GetQuerySegmentInfoResponse.SerializeToString, + ), + 'GetReplicas': grpc.unary_unary_rpc_method_handler( + servicer.GetReplicas, + request_deserializer=milvus__pb2.GetReplicasRequest.FromString, + response_serializer=milvus__pb2.GetReplicasResponse.SerializeToString, + ), + 'Dummy': grpc.unary_unary_rpc_method_handler( + servicer.Dummy, + request_deserializer=milvus__pb2.DummyRequest.FromString, + response_serializer=milvus__pb2.DummyResponse.SerializeToString, + ), + 'RegisterLink': grpc.unary_unary_rpc_method_handler( + servicer.RegisterLink, + request_deserializer=milvus__pb2.RegisterLinkRequest.FromString, + response_serializer=milvus__pb2.RegisterLinkResponse.SerializeToString, + ), + 'GetMetrics': grpc.unary_unary_rpc_method_handler( + servicer.GetMetrics, + request_deserializer=milvus__pb2.GetMetricsRequest.FromString, + response_serializer=milvus__pb2.GetMetricsResponse.SerializeToString, + ), + 'GetComponentStates': grpc.unary_unary_rpc_method_handler( + servicer.GetComponentStates, + request_deserializer=milvus__pb2.GetComponentStatesRequest.FromString, + response_serializer=milvus__pb2.ComponentStates.SerializeToString, + ), + 'LoadBalance': grpc.unary_unary_rpc_method_handler( + servicer.LoadBalance, + request_deserializer=milvus__pb2.LoadBalanceRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'GetCompactionState': grpc.unary_unary_rpc_method_handler( + servicer.GetCompactionState, + request_deserializer=milvus__pb2.GetCompactionStateRequest.FromString, + response_serializer=milvus__pb2.GetCompactionStateResponse.SerializeToString, + ), + 'ManualCompaction': grpc.unary_unary_rpc_method_handler( + servicer.ManualCompaction, + request_deserializer=milvus__pb2.ManualCompactionRequest.FromString, + response_serializer=milvus__pb2.ManualCompactionResponse.SerializeToString, + ), + 'GetCompactionStateWithPlans': grpc.unary_unary_rpc_method_handler( + servicer.GetCompactionStateWithPlans, + request_deserializer=milvus__pb2.GetCompactionPlansRequest.FromString, + response_serializer=milvus__pb2.GetCompactionPlansResponse.SerializeToString, + ), + 'Import': grpc.unary_unary_rpc_method_handler( + servicer.Import, + request_deserializer=milvus__pb2.ImportRequest.FromString, + response_serializer=milvus__pb2.ImportResponse.SerializeToString, + ), + 'GetImportState': grpc.unary_unary_rpc_method_handler( + servicer.GetImportState, + request_deserializer=milvus__pb2.GetImportStateRequest.FromString, + response_serializer=milvus__pb2.GetImportStateResponse.SerializeToString, + ), + 'ListImportTasks': grpc.unary_unary_rpc_method_handler( + servicer.ListImportTasks, + request_deserializer=milvus__pb2.ListImportTasksRequest.FromString, + response_serializer=milvus__pb2.ListImportTasksResponse.SerializeToString, + ), + 'CreateCredential': grpc.unary_unary_rpc_method_handler( + servicer.CreateCredential, + request_deserializer=milvus__pb2.CreateCredentialRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'UpdateCredential': grpc.unary_unary_rpc_method_handler( + servicer.UpdateCredential, + request_deserializer=milvus__pb2.UpdateCredentialRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'DeleteCredential': grpc.unary_unary_rpc_method_handler( + servicer.DeleteCredential, + request_deserializer=milvus__pb2.DeleteCredentialRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'ListCredUsers': grpc.unary_unary_rpc_method_handler( + servicer.ListCredUsers, + request_deserializer=milvus__pb2.ListCredUsersRequest.FromString, + response_serializer=milvus__pb2.ListCredUsersResponse.SerializeToString, + ), + 'CreateRole': grpc.unary_unary_rpc_method_handler( + servicer.CreateRole, + request_deserializer=milvus__pb2.CreateRoleRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'DropRole': grpc.unary_unary_rpc_method_handler( + servicer.DropRole, + request_deserializer=milvus__pb2.DropRoleRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'OperateUserRole': grpc.unary_unary_rpc_method_handler( + servicer.OperateUserRole, + request_deserializer=milvus__pb2.OperateUserRoleRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'SelectRole': grpc.unary_unary_rpc_method_handler( + servicer.SelectRole, + request_deserializer=milvus__pb2.SelectRoleRequest.FromString, + response_serializer=milvus__pb2.SelectRoleResponse.SerializeToString, + ), + 'SelectUser': grpc.unary_unary_rpc_method_handler( + servicer.SelectUser, + request_deserializer=milvus__pb2.SelectUserRequest.FromString, + response_serializer=milvus__pb2.SelectUserResponse.SerializeToString, + ), + 'OperatePrivilege': grpc.unary_unary_rpc_method_handler( + servicer.OperatePrivilege, + request_deserializer=milvus__pb2.OperatePrivilegeRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'SelectGrant': grpc.unary_unary_rpc_method_handler( + servicer.SelectGrant, + request_deserializer=milvus__pb2.SelectGrantRequest.FromString, + response_serializer=milvus__pb2.SelectGrantResponse.SerializeToString, + ), + 'GetVersion': grpc.unary_unary_rpc_method_handler( + servicer.GetVersion, + request_deserializer=milvus__pb2.GetVersionRequest.FromString, + response_serializer=milvus__pb2.GetVersionResponse.SerializeToString, + ), + 'CheckHealth': grpc.unary_unary_rpc_method_handler( + servicer.CheckHealth, + request_deserializer=milvus__pb2.CheckHealthRequest.FromString, + response_serializer=milvus__pb2.CheckHealthResponse.SerializeToString, + ), + 'CreateResourceGroup': grpc.unary_unary_rpc_method_handler( + servicer.CreateResourceGroup, + request_deserializer=milvus__pb2.CreateResourceGroupRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'DropResourceGroup': grpc.unary_unary_rpc_method_handler( + servicer.DropResourceGroup, + request_deserializer=milvus__pb2.DropResourceGroupRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'UpdateResourceGroups': grpc.unary_unary_rpc_method_handler( + servicer.UpdateResourceGroups, + request_deserializer=milvus__pb2.UpdateResourceGroupsRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'TransferNode': grpc.unary_unary_rpc_method_handler( + servicer.TransferNode, + request_deserializer=milvus__pb2.TransferNodeRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'TransferReplica': grpc.unary_unary_rpc_method_handler( + servicer.TransferReplica, + request_deserializer=milvus__pb2.TransferReplicaRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'ListResourceGroups': grpc.unary_unary_rpc_method_handler( + servicer.ListResourceGroups, + request_deserializer=milvus__pb2.ListResourceGroupsRequest.FromString, + response_serializer=milvus__pb2.ListResourceGroupsResponse.SerializeToString, + ), + 'DescribeResourceGroup': grpc.unary_unary_rpc_method_handler( + servicer.DescribeResourceGroup, + request_deserializer=milvus__pb2.DescribeResourceGroupRequest.FromString, + response_serializer=milvus__pb2.DescribeResourceGroupResponse.SerializeToString, + ), + 'RenameCollection': grpc.unary_unary_rpc_method_handler( + servicer.RenameCollection, + request_deserializer=milvus__pb2.RenameCollectionRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'ListIndexedSegment': grpc.unary_unary_rpc_method_handler( + servicer.ListIndexedSegment, + request_deserializer=feder__pb2.ListIndexedSegmentRequest.FromString, + response_serializer=feder__pb2.ListIndexedSegmentResponse.SerializeToString, + ), + 'DescribeSegmentIndexData': grpc.unary_unary_rpc_method_handler( + servicer.DescribeSegmentIndexData, + request_deserializer=feder__pb2.DescribeSegmentIndexDataRequest.FromString, + response_serializer=feder__pb2.DescribeSegmentIndexDataResponse.SerializeToString, + ), + 'Connect': grpc.unary_unary_rpc_method_handler( + servicer.Connect, + request_deserializer=milvus__pb2.ConnectRequest.FromString, + response_serializer=milvus__pb2.ConnectResponse.SerializeToString, + ), + 'AllocTimestamp': grpc.unary_unary_rpc_method_handler( + servicer.AllocTimestamp, + request_deserializer=milvus__pb2.AllocTimestampRequest.FromString, + response_serializer=milvus__pb2.AllocTimestampResponse.SerializeToString, + ), + 'CreateDatabase': grpc.unary_unary_rpc_method_handler( + servicer.CreateDatabase, + request_deserializer=milvus__pb2.CreateDatabaseRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'DropDatabase': grpc.unary_unary_rpc_method_handler( + servicer.DropDatabase, + request_deserializer=milvus__pb2.DropDatabaseRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'ListDatabases': grpc.unary_unary_rpc_method_handler( + servicer.ListDatabases, + request_deserializer=milvus__pb2.ListDatabasesRequest.FromString, + response_serializer=milvus__pb2.ListDatabasesResponse.SerializeToString, + ), + 'ReplicateMessage': grpc.unary_unary_rpc_method_handler( + servicer.ReplicateMessage, + request_deserializer=milvus__pb2.ReplicateMessageRequest.FromString, + response_serializer=milvus__pb2.ReplicateMessageResponse.SerializeToString, + ), + } + generic_handler = grpc.method_handlers_generic_handler( + 'milvus.proto.milvus.MilvusService', rpc_method_handlers) + server.add_generic_rpc_handlers((generic_handler,)) + + + # This class is part of an EXPERIMENTAL API. +class MilvusService(object): + """Missing associated documentation comment in .proto file.""" + + @staticmethod + def CreateCollection(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/CreateCollection', + milvus__pb2.CreateCollectionRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def DropCollection(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/DropCollection', + milvus__pb2.DropCollectionRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def HasCollection(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/HasCollection', + milvus__pb2.HasCollectionRequest.SerializeToString, + milvus__pb2.BoolResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def LoadCollection(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/LoadCollection', + milvus__pb2.LoadCollectionRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def ReleaseCollection(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/ReleaseCollection', + milvus__pb2.ReleaseCollectionRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def DescribeCollection(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/DescribeCollection', + milvus__pb2.DescribeCollectionRequest.SerializeToString, + milvus__pb2.DescribeCollectionResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetCollectionStatistics(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/GetCollectionStatistics', + milvus__pb2.GetCollectionStatisticsRequest.SerializeToString, + milvus__pb2.GetCollectionStatisticsResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def ShowCollections(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/ShowCollections', + milvus__pb2.ShowCollectionsRequest.SerializeToString, + milvus__pb2.ShowCollectionsResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def AlterCollection(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/AlterCollection', + milvus__pb2.AlterCollectionRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def CreatePartition(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/CreatePartition', + milvus__pb2.CreatePartitionRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def DropPartition(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/DropPartition', + milvus__pb2.DropPartitionRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def HasPartition(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/HasPartition', + milvus__pb2.HasPartitionRequest.SerializeToString, + milvus__pb2.BoolResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def LoadPartitions(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/LoadPartitions', + milvus__pb2.LoadPartitionsRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def ReleasePartitions(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/ReleasePartitions', + milvus__pb2.ReleasePartitionsRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetPartitionStatistics(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/GetPartitionStatistics', + milvus__pb2.GetPartitionStatisticsRequest.SerializeToString, + milvus__pb2.GetPartitionStatisticsResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def ShowPartitions(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/ShowPartitions', + milvus__pb2.ShowPartitionsRequest.SerializeToString, + milvus__pb2.ShowPartitionsResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetLoadingProgress(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/GetLoadingProgress', + milvus__pb2.GetLoadingProgressRequest.SerializeToString, + milvus__pb2.GetLoadingProgressResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetLoadState(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/GetLoadState', + milvus__pb2.GetLoadStateRequest.SerializeToString, + milvus__pb2.GetLoadStateResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def CreateAlias(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/CreateAlias', + milvus__pb2.CreateAliasRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def DropAlias(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/DropAlias', + milvus__pb2.DropAliasRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def AlterAlias(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/AlterAlias', + milvus__pb2.AlterAliasRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def DescribeAlias(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/DescribeAlias', + milvus__pb2.DescribeAliasRequest.SerializeToString, + milvus__pb2.DescribeAliasResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def ListAliases(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/ListAliases', + milvus__pb2.ListAliasesRequest.SerializeToString, + milvus__pb2.ListAliasesResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def CreateIndex(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/CreateIndex', + milvus__pb2.CreateIndexRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def AlterIndex(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/AlterIndex', + milvus__pb2.AlterIndexRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def DescribeIndex(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/DescribeIndex', + milvus__pb2.DescribeIndexRequest.SerializeToString, + milvus__pb2.DescribeIndexResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetIndexStatistics(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/GetIndexStatistics', + milvus__pb2.GetIndexStatisticsRequest.SerializeToString, + milvus__pb2.GetIndexStatisticsResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetIndexState(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/GetIndexState', + milvus__pb2.GetIndexStateRequest.SerializeToString, + milvus__pb2.GetIndexStateResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetIndexBuildProgress(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/GetIndexBuildProgress', + milvus__pb2.GetIndexBuildProgressRequest.SerializeToString, + milvus__pb2.GetIndexBuildProgressResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def DropIndex(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/DropIndex', + milvus__pb2.DropIndexRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def Insert(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/Insert', + milvus__pb2.InsertRequest.SerializeToString, + milvus__pb2.MutationResult.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def Delete(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/Delete', + milvus__pb2.DeleteRequest.SerializeToString, + milvus__pb2.MutationResult.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def Upsert(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/Upsert', + milvus__pb2.UpsertRequest.SerializeToString, + milvus__pb2.MutationResult.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def Search(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/Search', + milvus__pb2.SearchRequest.SerializeToString, + milvus__pb2.SearchResults.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def HybridSearch(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/HybridSearch', + milvus__pb2.HybridSearchRequest.SerializeToString, + milvus__pb2.SearchResults.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def Flush(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/Flush', + milvus__pb2.FlushRequest.SerializeToString, + milvus__pb2.FlushResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def Query(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/Query', + milvus__pb2.QueryRequest.SerializeToString, + milvus__pb2.QueryResults.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def CalcDistance(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/CalcDistance', + milvus__pb2.CalcDistanceRequest.SerializeToString, + milvus__pb2.CalcDistanceResults.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def FlushAll(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/FlushAll', + milvus__pb2.FlushAllRequest.SerializeToString, + milvus__pb2.FlushAllResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetFlushState(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/GetFlushState', + milvus__pb2.GetFlushStateRequest.SerializeToString, + milvus__pb2.GetFlushStateResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetFlushAllState(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/GetFlushAllState', + milvus__pb2.GetFlushAllStateRequest.SerializeToString, + milvus__pb2.GetFlushAllStateResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetPersistentSegmentInfo(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/GetPersistentSegmentInfo', + milvus__pb2.GetPersistentSegmentInfoRequest.SerializeToString, + milvus__pb2.GetPersistentSegmentInfoResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetQuerySegmentInfo(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/GetQuerySegmentInfo', + milvus__pb2.GetQuerySegmentInfoRequest.SerializeToString, + milvus__pb2.GetQuerySegmentInfoResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetReplicas(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/GetReplicas', + milvus__pb2.GetReplicasRequest.SerializeToString, + milvus__pb2.GetReplicasResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def Dummy(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/Dummy', + milvus__pb2.DummyRequest.SerializeToString, + milvus__pb2.DummyResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def RegisterLink(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/RegisterLink', + milvus__pb2.RegisterLinkRequest.SerializeToString, + milvus__pb2.RegisterLinkResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetMetrics(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/GetMetrics', + milvus__pb2.GetMetricsRequest.SerializeToString, + milvus__pb2.GetMetricsResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetComponentStates(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/GetComponentStates', + milvus__pb2.GetComponentStatesRequest.SerializeToString, + milvus__pb2.ComponentStates.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def LoadBalance(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/LoadBalance', + milvus__pb2.LoadBalanceRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetCompactionState(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/GetCompactionState', + milvus__pb2.GetCompactionStateRequest.SerializeToString, + milvus__pb2.GetCompactionStateResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def ManualCompaction(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/ManualCompaction', + milvus__pb2.ManualCompactionRequest.SerializeToString, + milvus__pb2.ManualCompactionResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetCompactionStateWithPlans(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/GetCompactionStateWithPlans', + milvus__pb2.GetCompactionPlansRequest.SerializeToString, + milvus__pb2.GetCompactionPlansResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def Import(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/Import', + milvus__pb2.ImportRequest.SerializeToString, + milvus__pb2.ImportResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetImportState(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/GetImportState', + milvus__pb2.GetImportStateRequest.SerializeToString, + milvus__pb2.GetImportStateResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def ListImportTasks(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/ListImportTasks', + milvus__pb2.ListImportTasksRequest.SerializeToString, + milvus__pb2.ListImportTasksResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def CreateCredential(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/CreateCredential', + milvus__pb2.CreateCredentialRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def UpdateCredential(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/UpdateCredential', + milvus__pb2.UpdateCredentialRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def DeleteCredential(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/DeleteCredential', + milvus__pb2.DeleteCredentialRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def ListCredUsers(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/ListCredUsers', + milvus__pb2.ListCredUsersRequest.SerializeToString, + milvus__pb2.ListCredUsersResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def CreateRole(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/CreateRole', + milvus__pb2.CreateRoleRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def DropRole(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/DropRole', + milvus__pb2.DropRoleRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def OperateUserRole(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/OperateUserRole', + milvus__pb2.OperateUserRoleRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def SelectRole(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/SelectRole', + milvus__pb2.SelectRoleRequest.SerializeToString, + milvus__pb2.SelectRoleResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def SelectUser(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/SelectUser', + milvus__pb2.SelectUserRequest.SerializeToString, + milvus__pb2.SelectUserResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def OperatePrivilege(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/OperatePrivilege', + milvus__pb2.OperatePrivilegeRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def SelectGrant(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/SelectGrant', + milvus__pb2.SelectGrantRequest.SerializeToString, + milvus__pb2.SelectGrantResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetVersion(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/GetVersion', + milvus__pb2.GetVersionRequest.SerializeToString, + milvus__pb2.GetVersionResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def CheckHealth(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/CheckHealth', + milvus__pb2.CheckHealthRequest.SerializeToString, + milvus__pb2.CheckHealthResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def CreateResourceGroup(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/CreateResourceGroup', + milvus__pb2.CreateResourceGroupRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def DropResourceGroup(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/DropResourceGroup', + milvus__pb2.DropResourceGroupRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def UpdateResourceGroups(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/UpdateResourceGroups', + milvus__pb2.UpdateResourceGroupsRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def TransferNode(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/TransferNode', + milvus__pb2.TransferNodeRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def TransferReplica(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/TransferReplica', + milvus__pb2.TransferReplicaRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def ListResourceGroups(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/ListResourceGroups', + milvus__pb2.ListResourceGroupsRequest.SerializeToString, + milvus__pb2.ListResourceGroupsResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def DescribeResourceGroup(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/DescribeResourceGroup', + milvus__pb2.DescribeResourceGroupRequest.SerializeToString, + milvus__pb2.DescribeResourceGroupResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def RenameCollection(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/RenameCollection', + milvus__pb2.RenameCollectionRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def ListIndexedSegment(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/ListIndexedSegment', + feder__pb2.ListIndexedSegmentRequest.SerializeToString, + feder__pb2.ListIndexedSegmentResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def DescribeSegmentIndexData(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/DescribeSegmentIndexData', + feder__pb2.DescribeSegmentIndexDataRequest.SerializeToString, + feder__pb2.DescribeSegmentIndexDataResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def Connect(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/Connect', + milvus__pb2.ConnectRequest.SerializeToString, + milvus__pb2.ConnectResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def AllocTimestamp(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/AllocTimestamp', + milvus__pb2.AllocTimestampRequest.SerializeToString, + milvus__pb2.AllocTimestampResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def CreateDatabase(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/CreateDatabase', + milvus__pb2.CreateDatabaseRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def DropDatabase(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/DropDatabase', + milvus__pb2.DropDatabaseRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def ListDatabases(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/ListDatabases', + milvus__pb2.ListDatabasesRequest.SerializeToString, + milvus__pb2.ListDatabasesResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def ReplicateMessage(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.MilvusService/ReplicateMessage', + milvus__pb2.ReplicateMessageRequest.SerializeToString, + milvus__pb2.ReplicateMessageResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + +class ProxyServiceStub(object): + """Missing associated documentation comment in .proto file.""" + + def __init__(self, channel): + """Constructor. + + Args: + channel: A grpc.Channel. + """ + self.RegisterLink = channel.unary_unary( + '/milvus.proto.milvus.ProxyService/RegisterLink', + request_serializer=milvus__pb2.RegisterLinkRequest.SerializeToString, + response_deserializer=milvus__pb2.RegisterLinkResponse.FromString, + ) + + +class ProxyServiceServicer(object): + """Missing associated documentation comment in .proto file.""" + + def RegisterLink(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + +def add_ProxyServiceServicer_to_server(servicer, server): + rpc_method_handlers = { + 'RegisterLink': grpc.unary_unary_rpc_method_handler( + servicer.RegisterLink, + request_deserializer=milvus__pb2.RegisterLinkRequest.FromString, + response_serializer=milvus__pb2.RegisterLinkResponse.SerializeToString, + ), + } + generic_handler = grpc.method_handlers_generic_handler( + 'milvus.proto.milvus.ProxyService', rpc_method_handlers) + server.add_generic_rpc_handlers((generic_handler,)) + + + # This class is part of an EXPERIMENTAL API. +class ProxyService(object): + """Missing associated documentation comment in .proto file.""" + + @staticmethod + def RegisterLink(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.milvus.ProxyService/RegisterLink', + milvus__pb2.RegisterLinkRequest.SerializeToString, + milvus__pb2.RegisterLinkResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) diff --git a/milvus_connector/protocol/msg_pb2.py b/milvus_connector/protocol/msg_pb2.py new file mode 100644 index 0000000..4492b9b --- /dev/null +++ b/milvus_connector/protocol/msg_pb2.py @@ -0,0 +1,47 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: msg.proto +# Protobuf Python Version: 4.25.1 +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from . import common_pb2 as common__pb2 +from . import schema_pb2 as schema__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\tmsg.proto\x12\x10milvus.proto.msg\x1a\x0c\x63ommon.proto\x1a\x0cschema.proto\"\xaa\x03\n\rInsertRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x11\n\tshardName\x18\x02 \x01(\t\x12\x0f\n\x07\x64\x62_name\x18\x03 \x01(\t\x12\x17\n\x0f\x63ollection_name\x18\x04 \x01(\t\x12\x16\n\x0epartition_name\x18\x05 \x01(\t\x12\x0c\n\x04\x64\x62ID\x18\x06 \x01(\x03\x12\x14\n\x0c\x63ollectionID\x18\x07 \x01(\x03\x12\x13\n\x0bpartitionID\x18\x08 \x01(\x03\x12\x11\n\tsegmentID\x18\t \x01(\x03\x12\x12\n\ntimestamps\x18\n \x03(\x04\x12\x0e\n\x06rowIDs\x18\x0b \x03(\x03\x12+\n\x08row_data\x18\x0c \x03(\x0b\x32\x19.milvus.proto.common.Blob\x12\x33\n\x0b\x66ields_data\x18\r \x03(\x0b\x32\x1e.milvus.proto.schema.FieldData\x12\x10\n\x08num_rows\x18\x0e \x01(\x04\x12\x34\n\x07version\x18\x0f \x01(\x0e\x32#.milvus.proto.msg.InsertDataVersion\"\xbb\x02\n\rDeleteRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x11\n\tshardName\x18\x02 \x01(\t\x12\x0f\n\x07\x64\x62_name\x18\x03 \x01(\t\x12\x17\n\x0f\x63ollection_name\x18\x04 \x01(\t\x12\x16\n\x0epartition_name\x18\x05 \x01(\t\x12\x0c\n\x04\x64\x62ID\x18\x06 \x01(\x03\x12\x14\n\x0c\x63ollectionID\x18\x07 \x01(\x03\x12\x13\n\x0bpartitionID\x18\x08 \x01(\x03\x12\x1a\n\x12int64_primary_keys\x18\t \x03(\x03\x12\x12\n\ntimestamps\x18\n \x03(\x04\x12\x10\n\x08num_rows\x18\x0b \x01(\x03\x12.\n\x0cprimary_keys\x18\x0c \x01(\x0b\x32\x18.milvus.proto.schema.IDs\"W\n\x0bMsgPosition\x12\x14\n\x0c\x63hannel_name\x18\x01 \x01(\t\x12\r\n\x05msgID\x18\x02 \x01(\x0c\x12\x10\n\x08msgGroup\x18\x03 \x01(\t\x12\x11\n\ttimestamp\x18\x04 \x01(\x04\"\x9f\x02\n\x17\x43reateCollectionRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x0f\n\x07\x64\x62_name\x18\x02 \x01(\t\x12\x16\n\x0e\x63ollectionName\x18\x03 \x01(\t\x12\x15\n\rpartitionName\x18\x04 \x01(\t\x12\x0c\n\x04\x64\x62ID\x18\x05 \x01(\x03\x12\x14\n\x0c\x63ollectionID\x18\x06 \x01(\x03\x12\x13\n\x0bpartitionID\x18\x07 \x01(\x03\x12\x0e\n\x06schema\x18\x08 \x01(\x0c\x12\x1b\n\x13virtualChannelNames\x18\t \x03(\t\x12\x1c\n\x14physicalChannelNames\x18\n \x03(\t\x12\x14\n\x0cpartitionIDs\x18\x0b \x03(\x03\"\x90\x01\n\x15\x44ropCollectionRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x0f\n\x07\x64\x62_name\x18\x02 \x01(\t\x12\x16\n\x0e\x63ollectionName\x18\x03 \x01(\t\x12\x0c\n\x04\x64\x62ID\x18\x04 \x01(\x03\x12\x14\n\x0c\x63ollectionID\x18\x05 \x01(\x03\"\xbf\x01\n\x16\x43reatePartitionRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x0f\n\x07\x64\x62_name\x18\x02 \x01(\t\x12\x17\n\x0f\x63ollection_name\x18\x03 \x01(\t\x12\x16\n\x0epartition_name\x18\x04 \x01(\t\x12\x0c\n\x04\x64\x62ID\x18\x05 \x01(\x03\x12\x14\n\x0c\x63ollectionID\x18\x06 \x01(\x03\x12\x13\n\x0bpartitionID\x18\x07 \x01(\x03\"\xbd\x01\n\x14\x44ropPartitionRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x0f\n\x07\x64\x62_name\x18\x02 \x01(\t\x12\x17\n\x0f\x63ollection_name\x18\x03 \x01(\t\x12\x16\n\x0epartition_name\x18\x04 \x01(\t\x12\x0c\n\x04\x64\x62ID\x18\x05 \x01(\x03\x12\x14\n\x0c\x63ollectionID\x18\x06 \x01(\x03\x12\x13\n\x0bpartitionID\x18\x07 \x01(\x03\"9\n\x0bTimeTickMsg\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\"\x9f\x01\n\rDataNodeTtMsg\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x14\n\x0c\x63hannel_name\x18\x02 \x01(\t\x12\x11\n\ttimestamp\x18\x03 \x01(\x04\x12\x39\n\x0esegments_stats\x18\x04 \x03(\x0b\x32!.milvus.proto.common.SegmentStats*2\n\x11InsertDataVersion\x12\x0c\n\x08RowBased\x10\x00\x12\x0f\n\x0b\x43olumnBased\x10\x01\x42\x33Z1github.com/milvus-io/milvus-proto/go-api/v2/msgpbb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'msg_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + _globals['DESCRIPTOR']._options = None + _globals['DESCRIPTOR']._serialized_options = b'Z1github.com/milvus-io/milvus-proto/go-api/v2/msgpb' + _globals['_INSERTDATAVERSION']._serialized_start=1939 + _globals['_INSERTDATAVERSION']._serialized_end=1989 + _globals['_INSERTREQUEST']._serialized_start=60 + _globals['_INSERTREQUEST']._serialized_end=486 + _globals['_DELETEREQUEST']._serialized_start=489 + _globals['_DELETEREQUEST']._serialized_end=804 + _globals['_MSGPOSITION']._serialized_start=806 + _globals['_MSGPOSITION']._serialized_end=893 + _globals['_CREATECOLLECTIONREQUEST']._serialized_start=896 + _globals['_CREATECOLLECTIONREQUEST']._serialized_end=1183 + _globals['_DROPCOLLECTIONREQUEST']._serialized_start=1186 + _globals['_DROPCOLLECTIONREQUEST']._serialized_end=1330 + _globals['_CREATEPARTITIONREQUEST']._serialized_start=1333 + _globals['_CREATEPARTITIONREQUEST']._serialized_end=1524 + _globals['_DROPPARTITIONREQUEST']._serialized_start=1527 + _globals['_DROPPARTITIONREQUEST']._serialized_end=1716 + _globals['_TIMETICKMSG']._serialized_start=1718 + _globals['_TIMETICKMSG']._serialized_end=1775 + _globals['_DATANODETTMSG']._serialized_start=1778 + _globals['_DATANODETTMSG']._serialized_end=1937 +# @@protoc_insertion_point(module_scope) diff --git a/milvus_connector/protocol/msg_pb2.pyi b/milvus_connector/protocol/msg_pb2.pyi new file mode 100644 index 0000000..b3da275 --- /dev/null +++ b/milvus_connector/protocol/msg_pb2.pyi @@ -0,0 +1,184 @@ +from . import common_pb2 as _common_pb2 +from . import schema_pb2 as _schema_pb2 +from google.protobuf.internal import containers as _containers +from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Iterable as _Iterable, Mapping as _Mapping, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class InsertDataVersion(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = () + RowBased: _ClassVar[InsertDataVersion] + ColumnBased: _ClassVar[InsertDataVersion] +RowBased: InsertDataVersion +ColumnBased: InsertDataVersion + +class InsertRequest(_message.Message): + __slots__ = ("base", "shardName", "db_name", "collection_name", "partition_name", "dbID", "collectionID", "partitionID", "segmentID", "timestamps", "rowIDs", "row_data", "fields_data", "num_rows", "version") + BASE_FIELD_NUMBER: _ClassVar[int] + SHARDNAME_FIELD_NUMBER: _ClassVar[int] + DB_NAME_FIELD_NUMBER: _ClassVar[int] + COLLECTION_NAME_FIELD_NUMBER: _ClassVar[int] + PARTITION_NAME_FIELD_NUMBER: _ClassVar[int] + DBID_FIELD_NUMBER: _ClassVar[int] + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + PARTITIONID_FIELD_NUMBER: _ClassVar[int] + SEGMENTID_FIELD_NUMBER: _ClassVar[int] + TIMESTAMPS_FIELD_NUMBER: _ClassVar[int] + ROWIDS_FIELD_NUMBER: _ClassVar[int] + ROW_DATA_FIELD_NUMBER: _ClassVar[int] + FIELDS_DATA_FIELD_NUMBER: _ClassVar[int] + NUM_ROWS_FIELD_NUMBER: _ClassVar[int] + VERSION_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + shardName: str + db_name: str + collection_name: str + partition_name: str + dbID: int + collectionID: int + partitionID: int + segmentID: int + timestamps: _containers.RepeatedScalarFieldContainer[int] + rowIDs: _containers.RepeatedScalarFieldContainer[int] + row_data: _containers.RepeatedCompositeFieldContainer[_common_pb2.Blob] + fields_data: _containers.RepeatedCompositeFieldContainer[_schema_pb2.FieldData] + num_rows: int + version: InsertDataVersion + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., shardName: _Optional[str] = ..., db_name: _Optional[str] = ..., collection_name: _Optional[str] = ..., partition_name: _Optional[str] = ..., dbID: _Optional[int] = ..., collectionID: _Optional[int] = ..., partitionID: _Optional[int] = ..., segmentID: _Optional[int] = ..., timestamps: _Optional[_Iterable[int]] = ..., rowIDs: _Optional[_Iterable[int]] = ..., row_data: _Optional[_Iterable[_Union[_common_pb2.Blob, _Mapping]]] = ..., fields_data: _Optional[_Iterable[_Union[_schema_pb2.FieldData, _Mapping]]] = ..., num_rows: _Optional[int] = ..., version: _Optional[_Union[InsertDataVersion, str]] = ...) -> None: ... + +class DeleteRequest(_message.Message): + __slots__ = ("base", "shardName", "db_name", "collection_name", "partition_name", "dbID", "collectionID", "partitionID", "int64_primary_keys", "timestamps", "num_rows", "primary_keys") + BASE_FIELD_NUMBER: _ClassVar[int] + SHARDNAME_FIELD_NUMBER: _ClassVar[int] + DB_NAME_FIELD_NUMBER: _ClassVar[int] + COLLECTION_NAME_FIELD_NUMBER: _ClassVar[int] + PARTITION_NAME_FIELD_NUMBER: _ClassVar[int] + DBID_FIELD_NUMBER: _ClassVar[int] + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + PARTITIONID_FIELD_NUMBER: _ClassVar[int] + INT64_PRIMARY_KEYS_FIELD_NUMBER: _ClassVar[int] + TIMESTAMPS_FIELD_NUMBER: _ClassVar[int] + NUM_ROWS_FIELD_NUMBER: _ClassVar[int] + PRIMARY_KEYS_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + shardName: str + db_name: str + collection_name: str + partition_name: str + dbID: int + collectionID: int + partitionID: int + int64_primary_keys: _containers.RepeatedScalarFieldContainer[int] + timestamps: _containers.RepeatedScalarFieldContainer[int] + num_rows: int + primary_keys: _schema_pb2.IDs + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., shardName: _Optional[str] = ..., db_name: _Optional[str] = ..., collection_name: _Optional[str] = ..., partition_name: _Optional[str] = ..., dbID: _Optional[int] = ..., collectionID: _Optional[int] = ..., partitionID: _Optional[int] = ..., int64_primary_keys: _Optional[_Iterable[int]] = ..., timestamps: _Optional[_Iterable[int]] = ..., num_rows: _Optional[int] = ..., primary_keys: _Optional[_Union[_schema_pb2.IDs, _Mapping]] = ...) -> None: ... + +class MsgPosition(_message.Message): + __slots__ = ("channel_name", "msgID", "msgGroup", "timestamp") + CHANNEL_NAME_FIELD_NUMBER: _ClassVar[int] + MSGID_FIELD_NUMBER: _ClassVar[int] + MSGGROUP_FIELD_NUMBER: _ClassVar[int] + TIMESTAMP_FIELD_NUMBER: _ClassVar[int] + channel_name: str + msgID: bytes + msgGroup: str + timestamp: int + def __init__(self, channel_name: _Optional[str] = ..., msgID: _Optional[bytes] = ..., msgGroup: _Optional[str] = ..., timestamp: _Optional[int] = ...) -> None: ... + +class CreateCollectionRequest(_message.Message): + __slots__ = ("base", "db_name", "collectionName", "partitionName", "dbID", "collectionID", "partitionID", "schema", "virtualChannelNames", "physicalChannelNames", "partitionIDs") + BASE_FIELD_NUMBER: _ClassVar[int] + DB_NAME_FIELD_NUMBER: _ClassVar[int] + COLLECTIONNAME_FIELD_NUMBER: _ClassVar[int] + PARTITIONNAME_FIELD_NUMBER: _ClassVar[int] + DBID_FIELD_NUMBER: _ClassVar[int] + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + PARTITIONID_FIELD_NUMBER: _ClassVar[int] + SCHEMA_FIELD_NUMBER: _ClassVar[int] + VIRTUALCHANNELNAMES_FIELD_NUMBER: _ClassVar[int] + PHYSICALCHANNELNAMES_FIELD_NUMBER: _ClassVar[int] + PARTITIONIDS_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + db_name: str + collectionName: str + partitionName: str + dbID: int + collectionID: int + partitionID: int + schema: bytes + virtualChannelNames: _containers.RepeatedScalarFieldContainer[str] + physicalChannelNames: _containers.RepeatedScalarFieldContainer[str] + partitionIDs: _containers.RepeatedScalarFieldContainer[int] + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., db_name: _Optional[str] = ..., collectionName: _Optional[str] = ..., partitionName: _Optional[str] = ..., dbID: _Optional[int] = ..., collectionID: _Optional[int] = ..., partitionID: _Optional[int] = ..., schema: _Optional[bytes] = ..., virtualChannelNames: _Optional[_Iterable[str]] = ..., physicalChannelNames: _Optional[_Iterable[str]] = ..., partitionIDs: _Optional[_Iterable[int]] = ...) -> None: ... + +class DropCollectionRequest(_message.Message): + __slots__ = ("base", "db_name", "collectionName", "dbID", "collectionID") + BASE_FIELD_NUMBER: _ClassVar[int] + DB_NAME_FIELD_NUMBER: _ClassVar[int] + COLLECTIONNAME_FIELD_NUMBER: _ClassVar[int] + DBID_FIELD_NUMBER: _ClassVar[int] + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + db_name: str + collectionName: str + dbID: int + collectionID: int + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., db_name: _Optional[str] = ..., collectionName: _Optional[str] = ..., dbID: _Optional[int] = ..., collectionID: _Optional[int] = ...) -> None: ... + +class CreatePartitionRequest(_message.Message): + __slots__ = ("base", "db_name", "collection_name", "partition_name", "dbID", "collectionID", "partitionID") + BASE_FIELD_NUMBER: _ClassVar[int] + DB_NAME_FIELD_NUMBER: _ClassVar[int] + COLLECTION_NAME_FIELD_NUMBER: _ClassVar[int] + PARTITION_NAME_FIELD_NUMBER: _ClassVar[int] + DBID_FIELD_NUMBER: _ClassVar[int] + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + PARTITIONID_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + db_name: str + collection_name: str + partition_name: str + dbID: int + collectionID: int + partitionID: int + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., db_name: _Optional[str] = ..., collection_name: _Optional[str] = ..., partition_name: _Optional[str] = ..., dbID: _Optional[int] = ..., collectionID: _Optional[int] = ..., partitionID: _Optional[int] = ...) -> None: ... + +class DropPartitionRequest(_message.Message): + __slots__ = ("base", "db_name", "collection_name", "partition_name", "dbID", "collectionID", "partitionID") + BASE_FIELD_NUMBER: _ClassVar[int] + DB_NAME_FIELD_NUMBER: _ClassVar[int] + COLLECTION_NAME_FIELD_NUMBER: _ClassVar[int] + PARTITION_NAME_FIELD_NUMBER: _ClassVar[int] + DBID_FIELD_NUMBER: _ClassVar[int] + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + PARTITIONID_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + db_name: str + collection_name: str + partition_name: str + dbID: int + collectionID: int + partitionID: int + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., db_name: _Optional[str] = ..., collection_name: _Optional[str] = ..., partition_name: _Optional[str] = ..., dbID: _Optional[int] = ..., collectionID: _Optional[int] = ..., partitionID: _Optional[int] = ...) -> None: ... + +class TimeTickMsg(_message.Message): + __slots__ = ("base",) + BASE_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ...) -> None: ... + +class DataNodeTtMsg(_message.Message): + __slots__ = ("base", "channel_name", "timestamp", "segments_stats") + BASE_FIELD_NUMBER: _ClassVar[int] + CHANNEL_NAME_FIELD_NUMBER: _ClassVar[int] + TIMESTAMP_FIELD_NUMBER: _ClassVar[int] + SEGMENTS_STATS_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + channel_name: str + timestamp: int + segments_stats: _containers.RepeatedCompositeFieldContainer[_common_pb2.SegmentStats] + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., channel_name: _Optional[str] = ..., timestamp: _Optional[int] = ..., segments_stats: _Optional[_Iterable[_Union[_common_pb2.SegmentStats, _Mapping]]] = ...) -> None: ... diff --git a/milvus_connector/protocol/msg_pb2_grpc.py b/milvus_connector/protocol/msg_pb2_grpc.py new file mode 100644 index 0000000..2daafff --- /dev/null +++ b/milvus_connector/protocol/msg_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/milvus_connector/protocol/plan_pb2.py b/milvus_connector/protocol/plan_pb2.py new file mode 100644 index 0000000..f4bd6f8 --- /dev/null +++ b/milvus_connector/protocol/plan_pb2.py @@ -0,0 +1,82 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: plan.proto +# Protobuf Python Version: 4.25.1 +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from . import schema_pb2 as schema__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\nplan.proto\x12\x11milvus.proto.plan\x1a\x0cschema.proto\"\x98\x01\n\x0cGenericValue\x12\x12\n\x08\x62ool_val\x18\x01 \x01(\x08H\x00\x12\x13\n\tint64_val\x18\x02 \x01(\x03H\x00\x12\x13\n\tfloat_val\x18\x03 \x01(\x01H\x00\x12\x14\n\nstring_val\x18\x04 \x01(\tH\x00\x12-\n\tarray_val\x18\x05 \x01(\x0b\x32\x18.milvus.proto.plan.ArrayH\x00\x42\x05\n\x03val\"\x7f\n\x05\x41rray\x12.\n\x05\x61rray\x18\x01 \x03(\x0b\x32\x1f.milvus.proto.plan.GenericValue\x12\x11\n\tsame_type\x18\x02 \x01(\x08\x12\x33\n\x0c\x65lement_type\x18\x03 \x01(\x0e\x32\x1d.milvus.proto.schema.DataType\"w\n\tQueryInfo\x12\x0c\n\x04topk\x18\x01 \x01(\x03\x12\x13\n\x0bmetric_type\x18\x03 \x01(\t\x12\x15\n\rsearch_params\x18\x04 \x01(\t\x12\x15\n\rround_decimal\x18\x05 \x01(\x03\x12\x19\n\x11group_by_field_id\x18\x06 \x01(\x03\"\xdf\x01\n\nColumnInfo\x12\x10\n\x08\x66ield_id\x18\x01 \x01(\x03\x12\x30\n\tdata_type\x18\x02 \x01(\x0e\x32\x1d.milvus.proto.schema.DataType\x12\x16\n\x0eis_primary_key\x18\x03 \x01(\x08\x12\x11\n\tis_autoID\x18\x04 \x01(\x08\x12\x13\n\x0bnested_path\x18\x05 \x03(\t\x12\x18\n\x10is_partition_key\x18\x06 \x01(\x08\x12\x33\n\x0c\x65lement_type\x18\x07 \x01(\x0e\x32\x1d.milvus.proto.schema.DataType\"9\n\nColumnExpr\x12+\n\x04info\x18\x01 \x01(\x0b\x32\x1d.milvus.proto.plan.ColumnInfo\"9\n\nExistsExpr\x12+\n\x04info\x18\x01 \x01(\x0b\x32\x1d.milvus.proto.plan.ColumnInfo\";\n\tValueExpr\x12.\n\x05value\x18\x01 \x01(\x0b\x32\x1f.milvus.proto.plan.GenericValue\"\x9b\x01\n\x0eUnaryRangeExpr\x12\x32\n\x0b\x63olumn_info\x18\x01 \x01(\x0b\x32\x1d.milvus.proto.plan.ColumnInfo\x12%\n\x02op\x18\x02 \x01(\x0e\x32\x19.milvus.proto.plan.OpType\x12.\n\x05value\x18\x03 \x01(\x0b\x32\x1f.milvus.proto.plan.GenericValue\"\xe3\x01\n\x0f\x42inaryRangeExpr\x12\x32\n\x0b\x63olumn_info\x18\x01 \x01(\x0b\x32\x1d.milvus.proto.plan.ColumnInfo\x12\x17\n\x0flower_inclusive\x18\x02 \x01(\x08\x12\x17\n\x0fupper_inclusive\x18\x03 \x01(\x08\x12\x34\n\x0blower_value\x18\x04 \x01(\x0b\x32\x1f.milvus.proto.plan.GenericValue\x12\x34\n\x0bupper_value\x18\x05 \x01(\x0b\x32\x1f.milvus.proto.plan.GenericValue\"\xa7\x01\n\x0b\x43ompareExpr\x12\x37\n\x10left_column_info\x18\x01 \x01(\x0b\x32\x1d.milvus.proto.plan.ColumnInfo\x12\x38\n\x11right_column_info\x18\x02 \x01(\x0b\x32\x1d.milvus.proto.plan.ColumnInfo\x12%\n\x02op\x18\x03 \x01(\x0e\x32\x19.milvus.proto.plan.OpType\"\x84\x01\n\x08TermExpr\x12\x32\n\x0b\x63olumn_info\x18\x01 \x01(\x0b\x32\x1d.milvus.proto.plan.ColumnInfo\x12/\n\x06values\x18\x02 \x03(\x0b\x32\x1f.milvus.proto.plan.GenericValue\x12\x13\n\x0bis_in_field\x18\x03 \x01(\x08\"\x94\x02\n\x10JSONContainsExpr\x12\x32\n\x0b\x63olumn_info\x18\x01 \x01(\x0b\x32\x1d.milvus.proto.plan.ColumnInfo\x12\x31\n\x08\x65lements\x18\x02 \x03(\x0b\x32\x1f.milvus.proto.plan.GenericValue\x12\x36\n\x02op\x18\x03 \x01(\x0e\x32*.milvus.proto.plan.JSONContainsExpr.JSONOp\x12\x1a\n\x12\x65lements_same_type\x18\x04 \x01(\x08\"E\n\x06JSONOp\x12\x0b\n\x07Invalid\x10\x00\x12\x0c\n\x08\x43ontains\x10\x01\x12\x0f\n\x0b\x43ontainsAll\x10\x02\x12\x0f\n\x0b\x43ontainsAny\x10\x03\"\x86\x01\n\tUnaryExpr\x12\x30\n\x02op\x18\x01 \x01(\x0e\x32$.milvus.proto.plan.UnaryExpr.UnaryOp\x12&\n\x05\x63hild\x18\x02 \x01(\x0b\x32\x17.milvus.proto.plan.Expr\"\x1f\n\x07UnaryOp\x12\x0b\n\x07Invalid\x10\x00\x12\x07\n\x03Not\x10\x01\"\xc7\x01\n\nBinaryExpr\x12\x32\n\x02op\x18\x01 \x01(\x0e\x32&.milvus.proto.plan.BinaryExpr.BinaryOp\x12%\n\x04left\x18\x02 \x01(\x0b\x32\x17.milvus.proto.plan.Expr\x12&\n\x05right\x18\x03 \x01(\x0b\x32\x17.milvus.proto.plan.Expr\"6\n\x08\x42inaryOp\x12\x0b\n\x07Invalid\x10\x00\x12\x0e\n\nLogicalAnd\x10\x01\x12\r\n\tLogicalOr\x10\x02\"\xad\x01\n\rBinaryArithOp\x12\x32\n\x0b\x63olumn_info\x18\x01 \x01(\x0b\x32\x1d.milvus.proto.plan.ColumnInfo\x12\x30\n\x08\x61rith_op\x18\x02 \x01(\x0e\x32\x1e.milvus.proto.plan.ArithOpType\x12\x36\n\rright_operand\x18\x03 \x01(\x0b\x32\x1f.milvus.proto.plan.GenericValue\"\x8c\x01\n\x0f\x42inaryArithExpr\x12%\n\x04left\x18\x01 \x01(\x0b\x32\x17.milvus.proto.plan.Expr\x12&\n\x05right\x18\x02 \x01(\x0b\x32\x17.milvus.proto.plan.Expr\x12*\n\x02op\x18\x03 \x01(\x0e\x32\x1e.milvus.proto.plan.ArithOpType\"\x91\x02\n\x1a\x42inaryArithOpEvalRangeExpr\x12\x32\n\x0b\x63olumn_info\x18\x01 \x01(\x0b\x32\x1d.milvus.proto.plan.ColumnInfo\x12\x30\n\x08\x61rith_op\x18\x02 \x01(\x0e\x32\x1e.milvus.proto.plan.ArithOpType\x12\x36\n\rright_operand\x18\x03 \x01(\x0b\x32\x1f.milvus.proto.plan.GenericValue\x12%\n\x02op\x18\x04 \x01(\x0e\x32\x19.milvus.proto.plan.OpType\x12.\n\x05value\x18\x05 \x01(\x0b\x32\x1f.milvus.proto.plan.GenericValue\"\x10\n\x0e\x41lwaysTrueExpr\"\x9f\x06\n\x04\x45xpr\x12\x30\n\tterm_expr\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.plan.TermExprH\x00\x12\x32\n\nunary_expr\x18\x02 \x01(\x0b\x32\x1c.milvus.proto.plan.UnaryExprH\x00\x12\x34\n\x0b\x62inary_expr\x18\x03 \x01(\x0b\x32\x1d.milvus.proto.plan.BinaryExprH\x00\x12\x36\n\x0c\x63ompare_expr\x18\x04 \x01(\x0b\x32\x1e.milvus.proto.plan.CompareExprH\x00\x12=\n\x10unary_range_expr\x18\x05 \x01(\x0b\x32!.milvus.proto.plan.UnaryRangeExprH\x00\x12?\n\x11\x62inary_range_expr\x18\x06 \x01(\x0b\x32\".milvus.proto.plan.BinaryRangeExprH\x00\x12X\n\x1f\x62inary_arith_op_eval_range_expr\x18\x07 \x01(\x0b\x32-.milvus.proto.plan.BinaryArithOpEvalRangeExprH\x00\x12?\n\x11\x62inary_arith_expr\x18\x08 \x01(\x0b\x32\".milvus.proto.plan.BinaryArithExprH\x00\x12\x32\n\nvalue_expr\x18\t \x01(\x0b\x32\x1c.milvus.proto.plan.ValueExprH\x00\x12\x34\n\x0b\x63olumn_expr\x18\n \x01(\x0b\x32\x1d.milvus.proto.plan.ColumnExprH\x00\x12\x34\n\x0b\x65xists_expr\x18\x0b \x01(\x0b\x32\x1d.milvus.proto.plan.ExistsExprH\x00\x12=\n\x10\x61lways_true_expr\x18\x0c \x01(\x0b\x32!.milvus.proto.plan.AlwaysTrueExprH\x00\x12\x41\n\x12json_contains_expr\x18\r \x01(\x0b\x32#.milvus.proto.plan.JSONContainsExprH\x00\x42\x06\n\x04\x65xpr\"\xca\x01\n\nVectorANNS\x12\x32\n\x0bvector_type\x18\x01 \x01(\x0e\x32\x1d.milvus.proto.plan.VectorType\x12\x10\n\x08\x66ield_id\x18\x02 \x01(\x03\x12+\n\npredicates\x18\x03 \x01(\x0b\x32\x17.milvus.proto.plan.Expr\x12\x30\n\nquery_info\x18\x04 \x01(\x0b\x32\x1c.milvus.proto.plan.QueryInfo\x12\x17\n\x0fplaceholder_tag\x18\x05 \x01(\t\"]\n\rQueryPlanNode\x12+\n\npredicates\x18\x01 \x01(\x0b\x32\x17.milvus.proto.plan.Expr\x12\x10\n\x08is_count\x18\x02 \x01(\x08\x12\r\n\x05limit\x18\x03 \x01(\x03\"\xc4\x01\n\x08PlanNode\x12\x34\n\x0bvector_anns\x18\x01 \x01(\x0b\x32\x1d.milvus.proto.plan.VectorANNSH\x00\x12-\n\npredicates\x18\x02 \x01(\x0b\x32\x17.milvus.proto.plan.ExprH\x00\x12\x31\n\x05query\x18\x04 \x01(\x0b\x32 .milvus.proto.plan.QueryPlanNodeH\x00\x12\x18\n\x10output_field_ids\x18\x03 \x03(\x03\x42\x06\n\x04node*\xba\x01\n\x06OpType\x12\x0b\n\x07Invalid\x10\x00\x12\x0f\n\x0bGreaterThan\x10\x01\x12\x10\n\x0cGreaterEqual\x10\x02\x12\x0c\n\x08LessThan\x10\x03\x12\r\n\tLessEqual\x10\x04\x12\t\n\x05\x45qual\x10\x05\x12\x0c\n\x08NotEqual\x10\x06\x12\x0f\n\x0bPrefixMatch\x10\x07\x12\x10\n\x0cPostfixMatch\x10\x08\x12\t\n\x05Match\x10\t\x12\t\n\x05Range\x10\n\x12\x06\n\x02In\x10\x0b\x12\t\n\x05NotIn\x10\x0c*X\n\x0b\x41rithOpType\x12\x0b\n\x07Unknown\x10\x00\x12\x07\n\x03\x41\x64\x64\x10\x01\x12\x07\n\x03Sub\x10\x02\x12\x07\n\x03Mul\x10\x03\x12\x07\n\x03\x44iv\x10\x04\x12\x07\n\x03Mod\x10\x05\x12\x0f\n\x0b\x41rrayLength\x10\x06*m\n\nVectorType\x12\x10\n\x0c\x42inaryVector\x10\x00\x12\x0f\n\x0b\x46loatVector\x10\x01\x12\x11\n\rFloat16Vector\x10\x02\x12\x12\n\x0e\x42\x46loat16Vector\x10\x03\x12\x15\n\x11SparseFloatVector\x10\x04\x42\x33Z1github.com/milvus-io/milvus/internal/proto/planpbb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'plan_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + _globals['DESCRIPTOR']._options = None + _globals['DESCRIPTOR']._serialized_options = b'Z1github.com/milvus-io/milvus/internal/proto/planpb' + _globals['_OPTYPE']._serialized_start=4083 + _globals['_OPTYPE']._serialized_end=4269 + _globals['_ARITHOPTYPE']._serialized_start=4271 + _globals['_ARITHOPTYPE']._serialized_end=4359 + _globals['_VECTORTYPE']._serialized_start=4361 + _globals['_VECTORTYPE']._serialized_end=4470 + _globals['_GENERICVALUE']._serialized_start=48 + _globals['_GENERICVALUE']._serialized_end=200 + _globals['_ARRAY']._serialized_start=202 + _globals['_ARRAY']._serialized_end=329 + _globals['_QUERYINFO']._serialized_start=331 + _globals['_QUERYINFO']._serialized_end=450 + _globals['_COLUMNINFO']._serialized_start=453 + _globals['_COLUMNINFO']._serialized_end=676 + _globals['_COLUMNEXPR']._serialized_start=678 + _globals['_COLUMNEXPR']._serialized_end=735 + _globals['_EXISTSEXPR']._serialized_start=737 + _globals['_EXISTSEXPR']._serialized_end=794 + _globals['_VALUEEXPR']._serialized_start=796 + _globals['_VALUEEXPR']._serialized_end=855 + _globals['_UNARYRANGEEXPR']._serialized_start=858 + _globals['_UNARYRANGEEXPR']._serialized_end=1013 + _globals['_BINARYRANGEEXPR']._serialized_start=1016 + _globals['_BINARYRANGEEXPR']._serialized_end=1243 + _globals['_COMPAREEXPR']._serialized_start=1246 + _globals['_COMPAREEXPR']._serialized_end=1413 + _globals['_TERMEXPR']._serialized_start=1416 + _globals['_TERMEXPR']._serialized_end=1548 + _globals['_JSONCONTAINSEXPR']._serialized_start=1551 + _globals['_JSONCONTAINSEXPR']._serialized_end=1827 + _globals['_JSONCONTAINSEXPR_JSONOP']._serialized_start=1758 + _globals['_JSONCONTAINSEXPR_JSONOP']._serialized_end=1827 + _globals['_UNARYEXPR']._serialized_start=1830 + _globals['_UNARYEXPR']._serialized_end=1964 + _globals['_UNARYEXPR_UNARYOP']._serialized_start=1933 + _globals['_UNARYEXPR_UNARYOP']._serialized_end=1964 + _globals['_BINARYEXPR']._serialized_start=1967 + _globals['_BINARYEXPR']._serialized_end=2166 + _globals['_BINARYEXPR_BINARYOP']._serialized_start=2112 + _globals['_BINARYEXPR_BINARYOP']._serialized_end=2166 + _globals['_BINARYARITHOP']._serialized_start=2169 + _globals['_BINARYARITHOP']._serialized_end=2342 + _globals['_BINARYARITHEXPR']._serialized_start=2345 + _globals['_BINARYARITHEXPR']._serialized_end=2485 + _globals['_BINARYARITHOPEVALRANGEEXPR']._serialized_start=2488 + _globals['_BINARYARITHOPEVALRANGEEXPR']._serialized_end=2761 + _globals['_ALWAYSTRUEEXPR']._serialized_start=2763 + _globals['_ALWAYSTRUEEXPR']._serialized_end=2779 + _globals['_EXPR']._serialized_start=2782 + _globals['_EXPR']._serialized_end=3581 + _globals['_VECTORANNS']._serialized_start=3584 + _globals['_VECTORANNS']._serialized_end=3786 + _globals['_QUERYPLANNODE']._serialized_start=3788 + _globals['_QUERYPLANNODE']._serialized_end=3881 + _globals['_PLANNODE']._serialized_start=3884 + _globals['_PLANNODE']._serialized_end=4080 +# @@protoc_insertion_point(module_scope) diff --git a/milvus_connector/protocol/plan_pb2.pyi b/milvus_connector/protocol/plan_pb2.pyi new file mode 100644 index 0000000..f5a0de7 --- /dev/null +++ b/milvus_connector/protocol/plan_pb2.pyi @@ -0,0 +1,343 @@ +from . import schema_pb2 as _schema_pb2 +from google.protobuf.internal import containers as _containers +from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Iterable as _Iterable, Mapping as _Mapping, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class OpType(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = () + Invalid: _ClassVar[OpType] + GreaterThan: _ClassVar[OpType] + GreaterEqual: _ClassVar[OpType] + LessThan: _ClassVar[OpType] + LessEqual: _ClassVar[OpType] + Equal: _ClassVar[OpType] + NotEqual: _ClassVar[OpType] + PrefixMatch: _ClassVar[OpType] + PostfixMatch: _ClassVar[OpType] + Match: _ClassVar[OpType] + Range: _ClassVar[OpType] + In: _ClassVar[OpType] + NotIn: _ClassVar[OpType] + +class ArithOpType(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = () + Unknown: _ClassVar[ArithOpType] + Add: _ClassVar[ArithOpType] + Sub: _ClassVar[ArithOpType] + Mul: _ClassVar[ArithOpType] + Div: _ClassVar[ArithOpType] + Mod: _ClassVar[ArithOpType] + ArrayLength: _ClassVar[ArithOpType] + +class VectorType(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = () + BinaryVector: _ClassVar[VectorType] + FloatVector: _ClassVar[VectorType] + Float16Vector: _ClassVar[VectorType] + BFloat16Vector: _ClassVar[VectorType] + SparseFloatVector: _ClassVar[VectorType] +Invalid: OpType +GreaterThan: OpType +GreaterEqual: OpType +LessThan: OpType +LessEqual: OpType +Equal: OpType +NotEqual: OpType +PrefixMatch: OpType +PostfixMatch: OpType +Match: OpType +Range: OpType +In: OpType +NotIn: OpType +Unknown: ArithOpType +Add: ArithOpType +Sub: ArithOpType +Mul: ArithOpType +Div: ArithOpType +Mod: ArithOpType +ArrayLength: ArithOpType +BinaryVector: VectorType +FloatVector: VectorType +Float16Vector: VectorType +BFloat16Vector: VectorType +SparseFloatVector: VectorType + +class GenericValue(_message.Message): + __slots__ = ("bool_val", "int64_val", "float_val", "string_val", "array_val") + BOOL_VAL_FIELD_NUMBER: _ClassVar[int] + INT64_VAL_FIELD_NUMBER: _ClassVar[int] + FLOAT_VAL_FIELD_NUMBER: _ClassVar[int] + STRING_VAL_FIELD_NUMBER: _ClassVar[int] + ARRAY_VAL_FIELD_NUMBER: _ClassVar[int] + bool_val: bool + int64_val: int + float_val: float + string_val: str + array_val: Array + def __init__(self, bool_val: bool = ..., int64_val: _Optional[int] = ..., float_val: _Optional[float] = ..., string_val: _Optional[str] = ..., array_val: _Optional[_Union[Array, _Mapping]] = ...) -> None: ... + +class Array(_message.Message): + __slots__ = ("array", "same_type", "element_type") + ARRAY_FIELD_NUMBER: _ClassVar[int] + SAME_TYPE_FIELD_NUMBER: _ClassVar[int] + ELEMENT_TYPE_FIELD_NUMBER: _ClassVar[int] + array: _containers.RepeatedCompositeFieldContainer[GenericValue] + same_type: bool + element_type: _schema_pb2.DataType + def __init__(self, array: _Optional[_Iterable[_Union[GenericValue, _Mapping]]] = ..., same_type: bool = ..., element_type: _Optional[_Union[_schema_pb2.DataType, str]] = ...) -> None: ... + +class QueryInfo(_message.Message): + __slots__ = ("topk", "metric_type", "search_params", "round_decimal", "group_by_field_id") + TOPK_FIELD_NUMBER: _ClassVar[int] + METRIC_TYPE_FIELD_NUMBER: _ClassVar[int] + SEARCH_PARAMS_FIELD_NUMBER: _ClassVar[int] + ROUND_DECIMAL_FIELD_NUMBER: _ClassVar[int] + GROUP_BY_FIELD_ID_FIELD_NUMBER: _ClassVar[int] + topk: int + metric_type: str + search_params: str + round_decimal: int + group_by_field_id: int + def __init__(self, topk: _Optional[int] = ..., metric_type: _Optional[str] = ..., search_params: _Optional[str] = ..., round_decimal: _Optional[int] = ..., group_by_field_id: _Optional[int] = ...) -> None: ... + +class ColumnInfo(_message.Message): + __slots__ = ("field_id", "data_type", "is_primary_key", "is_autoID", "nested_path", "is_partition_key", "element_type") + FIELD_ID_FIELD_NUMBER: _ClassVar[int] + DATA_TYPE_FIELD_NUMBER: _ClassVar[int] + IS_PRIMARY_KEY_FIELD_NUMBER: _ClassVar[int] + IS_AUTOID_FIELD_NUMBER: _ClassVar[int] + NESTED_PATH_FIELD_NUMBER: _ClassVar[int] + IS_PARTITION_KEY_FIELD_NUMBER: _ClassVar[int] + ELEMENT_TYPE_FIELD_NUMBER: _ClassVar[int] + field_id: int + data_type: _schema_pb2.DataType + is_primary_key: bool + is_autoID: bool + nested_path: _containers.RepeatedScalarFieldContainer[str] + is_partition_key: bool + element_type: _schema_pb2.DataType + def __init__(self, field_id: _Optional[int] = ..., data_type: _Optional[_Union[_schema_pb2.DataType, str]] = ..., is_primary_key: bool = ..., is_autoID: bool = ..., nested_path: _Optional[_Iterable[str]] = ..., is_partition_key: bool = ..., element_type: _Optional[_Union[_schema_pb2.DataType, str]] = ...) -> None: ... + +class ColumnExpr(_message.Message): + __slots__ = ("info",) + INFO_FIELD_NUMBER: _ClassVar[int] + info: ColumnInfo + def __init__(self, info: _Optional[_Union[ColumnInfo, _Mapping]] = ...) -> None: ... + +class ExistsExpr(_message.Message): + __slots__ = ("info",) + INFO_FIELD_NUMBER: _ClassVar[int] + info: ColumnInfo + def __init__(self, info: _Optional[_Union[ColumnInfo, _Mapping]] = ...) -> None: ... + +class ValueExpr(_message.Message): + __slots__ = ("value",) + VALUE_FIELD_NUMBER: _ClassVar[int] + value: GenericValue + def __init__(self, value: _Optional[_Union[GenericValue, _Mapping]] = ...) -> None: ... + +class UnaryRangeExpr(_message.Message): + __slots__ = ("column_info", "op", "value") + COLUMN_INFO_FIELD_NUMBER: _ClassVar[int] + OP_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + column_info: ColumnInfo + op: OpType + value: GenericValue + def __init__(self, column_info: _Optional[_Union[ColumnInfo, _Mapping]] = ..., op: _Optional[_Union[OpType, str]] = ..., value: _Optional[_Union[GenericValue, _Mapping]] = ...) -> None: ... + +class BinaryRangeExpr(_message.Message): + __slots__ = ("column_info", "lower_inclusive", "upper_inclusive", "lower_value", "upper_value") + COLUMN_INFO_FIELD_NUMBER: _ClassVar[int] + LOWER_INCLUSIVE_FIELD_NUMBER: _ClassVar[int] + UPPER_INCLUSIVE_FIELD_NUMBER: _ClassVar[int] + LOWER_VALUE_FIELD_NUMBER: _ClassVar[int] + UPPER_VALUE_FIELD_NUMBER: _ClassVar[int] + column_info: ColumnInfo + lower_inclusive: bool + upper_inclusive: bool + lower_value: GenericValue + upper_value: GenericValue + def __init__(self, column_info: _Optional[_Union[ColumnInfo, _Mapping]] = ..., lower_inclusive: bool = ..., upper_inclusive: bool = ..., lower_value: _Optional[_Union[GenericValue, _Mapping]] = ..., upper_value: _Optional[_Union[GenericValue, _Mapping]] = ...) -> None: ... + +class CompareExpr(_message.Message): + __slots__ = ("left_column_info", "right_column_info", "op") + LEFT_COLUMN_INFO_FIELD_NUMBER: _ClassVar[int] + RIGHT_COLUMN_INFO_FIELD_NUMBER: _ClassVar[int] + OP_FIELD_NUMBER: _ClassVar[int] + left_column_info: ColumnInfo + right_column_info: ColumnInfo + op: OpType + def __init__(self, left_column_info: _Optional[_Union[ColumnInfo, _Mapping]] = ..., right_column_info: _Optional[_Union[ColumnInfo, _Mapping]] = ..., op: _Optional[_Union[OpType, str]] = ...) -> None: ... + +class TermExpr(_message.Message): + __slots__ = ("column_info", "values", "is_in_field") + COLUMN_INFO_FIELD_NUMBER: _ClassVar[int] + VALUES_FIELD_NUMBER: _ClassVar[int] + IS_IN_FIELD_FIELD_NUMBER: _ClassVar[int] + column_info: ColumnInfo + values: _containers.RepeatedCompositeFieldContainer[GenericValue] + is_in_field: bool + def __init__(self, column_info: _Optional[_Union[ColumnInfo, _Mapping]] = ..., values: _Optional[_Iterable[_Union[GenericValue, _Mapping]]] = ..., is_in_field: bool = ...) -> None: ... + +class JSONContainsExpr(_message.Message): + __slots__ = ("column_info", "elements", "op", "elements_same_type") + class JSONOp(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = () + Invalid: _ClassVar[JSONContainsExpr.JSONOp] + Contains: _ClassVar[JSONContainsExpr.JSONOp] + ContainsAll: _ClassVar[JSONContainsExpr.JSONOp] + ContainsAny: _ClassVar[JSONContainsExpr.JSONOp] + Invalid: JSONContainsExpr.JSONOp + Contains: JSONContainsExpr.JSONOp + ContainsAll: JSONContainsExpr.JSONOp + ContainsAny: JSONContainsExpr.JSONOp + COLUMN_INFO_FIELD_NUMBER: _ClassVar[int] + ELEMENTS_FIELD_NUMBER: _ClassVar[int] + OP_FIELD_NUMBER: _ClassVar[int] + ELEMENTS_SAME_TYPE_FIELD_NUMBER: _ClassVar[int] + column_info: ColumnInfo + elements: _containers.RepeatedCompositeFieldContainer[GenericValue] + op: JSONContainsExpr.JSONOp + elements_same_type: bool + def __init__(self, column_info: _Optional[_Union[ColumnInfo, _Mapping]] = ..., elements: _Optional[_Iterable[_Union[GenericValue, _Mapping]]] = ..., op: _Optional[_Union[JSONContainsExpr.JSONOp, str]] = ..., elements_same_type: bool = ...) -> None: ... + +class UnaryExpr(_message.Message): + __slots__ = ("op", "child") + class UnaryOp(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = () + Invalid: _ClassVar[UnaryExpr.UnaryOp] + Not: _ClassVar[UnaryExpr.UnaryOp] + Invalid: UnaryExpr.UnaryOp + Not: UnaryExpr.UnaryOp + OP_FIELD_NUMBER: _ClassVar[int] + CHILD_FIELD_NUMBER: _ClassVar[int] + op: UnaryExpr.UnaryOp + child: Expr + def __init__(self, op: _Optional[_Union[UnaryExpr.UnaryOp, str]] = ..., child: _Optional[_Union[Expr, _Mapping]] = ...) -> None: ... + +class BinaryExpr(_message.Message): + __slots__ = ("op", "left", "right") + class BinaryOp(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = () + Invalid: _ClassVar[BinaryExpr.BinaryOp] + LogicalAnd: _ClassVar[BinaryExpr.BinaryOp] + LogicalOr: _ClassVar[BinaryExpr.BinaryOp] + Invalid: BinaryExpr.BinaryOp + LogicalAnd: BinaryExpr.BinaryOp + LogicalOr: BinaryExpr.BinaryOp + OP_FIELD_NUMBER: _ClassVar[int] + LEFT_FIELD_NUMBER: _ClassVar[int] + RIGHT_FIELD_NUMBER: _ClassVar[int] + op: BinaryExpr.BinaryOp + left: Expr + right: Expr + def __init__(self, op: _Optional[_Union[BinaryExpr.BinaryOp, str]] = ..., left: _Optional[_Union[Expr, _Mapping]] = ..., right: _Optional[_Union[Expr, _Mapping]] = ...) -> None: ... + +class BinaryArithOp(_message.Message): + __slots__ = ("column_info", "arith_op", "right_operand") + COLUMN_INFO_FIELD_NUMBER: _ClassVar[int] + ARITH_OP_FIELD_NUMBER: _ClassVar[int] + RIGHT_OPERAND_FIELD_NUMBER: _ClassVar[int] + column_info: ColumnInfo + arith_op: ArithOpType + right_operand: GenericValue + def __init__(self, column_info: _Optional[_Union[ColumnInfo, _Mapping]] = ..., arith_op: _Optional[_Union[ArithOpType, str]] = ..., right_operand: _Optional[_Union[GenericValue, _Mapping]] = ...) -> None: ... + +class BinaryArithExpr(_message.Message): + __slots__ = ("left", "right", "op") + LEFT_FIELD_NUMBER: _ClassVar[int] + RIGHT_FIELD_NUMBER: _ClassVar[int] + OP_FIELD_NUMBER: _ClassVar[int] + left: Expr + right: Expr + op: ArithOpType + def __init__(self, left: _Optional[_Union[Expr, _Mapping]] = ..., right: _Optional[_Union[Expr, _Mapping]] = ..., op: _Optional[_Union[ArithOpType, str]] = ...) -> None: ... + +class BinaryArithOpEvalRangeExpr(_message.Message): + __slots__ = ("column_info", "arith_op", "right_operand", "op", "value") + COLUMN_INFO_FIELD_NUMBER: _ClassVar[int] + ARITH_OP_FIELD_NUMBER: _ClassVar[int] + RIGHT_OPERAND_FIELD_NUMBER: _ClassVar[int] + OP_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + column_info: ColumnInfo + arith_op: ArithOpType + right_operand: GenericValue + op: OpType + value: GenericValue + def __init__(self, column_info: _Optional[_Union[ColumnInfo, _Mapping]] = ..., arith_op: _Optional[_Union[ArithOpType, str]] = ..., right_operand: _Optional[_Union[GenericValue, _Mapping]] = ..., op: _Optional[_Union[OpType, str]] = ..., value: _Optional[_Union[GenericValue, _Mapping]] = ...) -> None: ... + +class AlwaysTrueExpr(_message.Message): + __slots__ = () + def __init__(self) -> None: ... + +class Expr(_message.Message): + __slots__ = ("term_expr", "unary_expr", "binary_expr", "compare_expr", "unary_range_expr", "binary_range_expr", "binary_arith_op_eval_range_expr", "binary_arith_expr", "value_expr", "column_expr", "exists_expr", "always_true_expr", "json_contains_expr") + TERM_EXPR_FIELD_NUMBER: _ClassVar[int] + UNARY_EXPR_FIELD_NUMBER: _ClassVar[int] + BINARY_EXPR_FIELD_NUMBER: _ClassVar[int] + COMPARE_EXPR_FIELD_NUMBER: _ClassVar[int] + UNARY_RANGE_EXPR_FIELD_NUMBER: _ClassVar[int] + BINARY_RANGE_EXPR_FIELD_NUMBER: _ClassVar[int] + BINARY_ARITH_OP_EVAL_RANGE_EXPR_FIELD_NUMBER: _ClassVar[int] + BINARY_ARITH_EXPR_FIELD_NUMBER: _ClassVar[int] + VALUE_EXPR_FIELD_NUMBER: _ClassVar[int] + COLUMN_EXPR_FIELD_NUMBER: _ClassVar[int] + EXISTS_EXPR_FIELD_NUMBER: _ClassVar[int] + ALWAYS_TRUE_EXPR_FIELD_NUMBER: _ClassVar[int] + JSON_CONTAINS_EXPR_FIELD_NUMBER: _ClassVar[int] + term_expr: TermExpr + unary_expr: UnaryExpr + binary_expr: BinaryExpr + compare_expr: CompareExpr + unary_range_expr: UnaryRangeExpr + binary_range_expr: BinaryRangeExpr + binary_arith_op_eval_range_expr: BinaryArithOpEvalRangeExpr + binary_arith_expr: BinaryArithExpr + value_expr: ValueExpr + column_expr: ColumnExpr + exists_expr: ExistsExpr + always_true_expr: AlwaysTrueExpr + json_contains_expr: JSONContainsExpr + def __init__(self, term_expr: _Optional[_Union[TermExpr, _Mapping]] = ..., unary_expr: _Optional[_Union[UnaryExpr, _Mapping]] = ..., binary_expr: _Optional[_Union[BinaryExpr, _Mapping]] = ..., compare_expr: _Optional[_Union[CompareExpr, _Mapping]] = ..., unary_range_expr: _Optional[_Union[UnaryRangeExpr, _Mapping]] = ..., binary_range_expr: _Optional[_Union[BinaryRangeExpr, _Mapping]] = ..., binary_arith_op_eval_range_expr: _Optional[_Union[BinaryArithOpEvalRangeExpr, _Mapping]] = ..., binary_arith_expr: _Optional[_Union[BinaryArithExpr, _Mapping]] = ..., value_expr: _Optional[_Union[ValueExpr, _Mapping]] = ..., column_expr: _Optional[_Union[ColumnExpr, _Mapping]] = ..., exists_expr: _Optional[_Union[ExistsExpr, _Mapping]] = ..., always_true_expr: _Optional[_Union[AlwaysTrueExpr, _Mapping]] = ..., json_contains_expr: _Optional[_Union[JSONContainsExpr, _Mapping]] = ...) -> None: ... + +class VectorANNS(_message.Message): + __slots__ = ("vector_type", "field_id", "predicates", "query_info", "placeholder_tag") + VECTOR_TYPE_FIELD_NUMBER: _ClassVar[int] + FIELD_ID_FIELD_NUMBER: _ClassVar[int] + PREDICATES_FIELD_NUMBER: _ClassVar[int] + QUERY_INFO_FIELD_NUMBER: _ClassVar[int] + PLACEHOLDER_TAG_FIELD_NUMBER: _ClassVar[int] + vector_type: VectorType + field_id: int + predicates: Expr + query_info: QueryInfo + placeholder_tag: str + def __init__(self, vector_type: _Optional[_Union[VectorType, str]] = ..., field_id: _Optional[int] = ..., predicates: _Optional[_Union[Expr, _Mapping]] = ..., query_info: _Optional[_Union[QueryInfo, _Mapping]] = ..., placeholder_tag: _Optional[str] = ...) -> None: ... + +class QueryPlanNode(_message.Message): + __slots__ = ("predicates", "is_count", "limit") + PREDICATES_FIELD_NUMBER: _ClassVar[int] + IS_COUNT_FIELD_NUMBER: _ClassVar[int] + LIMIT_FIELD_NUMBER: _ClassVar[int] + predicates: Expr + is_count: bool + limit: int + def __init__(self, predicates: _Optional[_Union[Expr, _Mapping]] = ..., is_count: bool = ..., limit: _Optional[int] = ...) -> None: ... + +class PlanNode(_message.Message): + __slots__ = ("vector_anns", "predicates", "query", "output_field_ids") + VECTOR_ANNS_FIELD_NUMBER: _ClassVar[int] + PREDICATES_FIELD_NUMBER: _ClassVar[int] + QUERY_FIELD_NUMBER: _ClassVar[int] + OUTPUT_FIELD_IDS_FIELD_NUMBER: _ClassVar[int] + vector_anns: VectorANNS + predicates: Expr + query: QueryPlanNode + output_field_ids: _containers.RepeatedScalarFieldContainer[int] + def __init__(self, vector_anns: _Optional[_Union[VectorANNS, _Mapping]] = ..., predicates: _Optional[_Union[Expr, _Mapping]] = ..., query: _Optional[_Union[QueryPlanNode, _Mapping]] = ..., output_field_ids: _Optional[_Iterable[int]] = ...) -> None: ... diff --git a/milvus_connector/protocol/plan_pb2_grpc.py b/milvus_connector/protocol/plan_pb2_grpc.py new file mode 100644 index 0000000..2daafff --- /dev/null +++ b/milvus_connector/protocol/plan_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/milvus_connector/protocol/proxy_pb2.py b/milvus_connector/protocol/proxy_pb2.py new file mode 100644 index 0000000..ff8e001 --- /dev/null +++ b/milvus_connector/protocol/proxy_pb2.py @@ -0,0 +1,46 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: proxy.proto +# Protobuf Python Version: 4.25.1 +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from . import common_pb2 as common__pb2 +from . import internal_pb2 as internal__pb2 +from . import milvus_pb2 as milvus__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x0bproxy.proto\x12\x12milvus.proto.proxy\x1a\x0c\x63ommon.proto\x1a\x0einternal.proto\x1a\x0cmilvus.proto\"\xa4\x01\n\x1eInvalidateCollMetaCacheRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x0f\n\x07\x64\x62_name\x18\x02 \x01(\t\x12\x17\n\x0f\x63ollection_name\x18\x03 \x01(\t\x12\x14\n\x0c\x63ollectionID\x18\x04 \x01(\x03\x12\x16\n\x0epartition_name\x18\x05 \x01(\t\"Z\n\x1aInvalidateCredCacheRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x10\n\x08username\x18\x02 \x01(\t\"h\n\x16UpdateCredCacheRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x10\n\x08username\x18\x02 \x01(\t\x12\x10\n\x08password\x18\x03 \x01(\t\"j\n\x1dRefreshPolicyInfoCacheRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x0e\n\x06opType\x18\x02 \x01(\x05\x12\r\n\x05opKey\x18\x03 \x01(\t\"\xb0\x01\n\x0e\x43ollectionRate\x12\x12\n\ncollection\x18\x01 \x01(\x03\x12*\n\x05rates\x18\x02 \x03(\x0b\x32\x1b.milvus.proto.internal.Rate\x12/\n\x06states\x18\x03 \x03(\x0e\x32\x1f.milvus.proto.milvus.QuotaState\x12-\n\x05\x63odes\x18\x04 \x03(\x0e\x32\x1e.milvus.proto.common.ErrorCode\"p\n\x0fSetRatesRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x31\n\x05rates\x18\x02 \x03(\x0b\x32\".milvus.proto.proxy.CollectionRate\"D\n\x16ListClientInfosRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\"}\n\x17ListClientInfosResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\x35\n\x0c\x63lient_infos\x18\x02 \x03(\x0b\x32\x1f.milvus.proto.common.ClientInfo2\xdc\n\n\x05Proxy\x12l\n\x12GetComponentStates\x12..milvus.proto.milvus.GetComponentStatesRequest\x1a$.milvus.proto.milvus.ComponentStates\"\x00\x12q\n\x14GetStatisticsChannel\x12\x32.milvus.proto.internal.GetStatisticsChannelRequest\x1a#.milvus.proto.milvus.StringResponse\"\x00\x12r\n\x1dInvalidateCollectionMetaCache\x12\x32.milvus.proto.proxy.InvalidateCollMetaCacheRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12\x61\n\x0cGetDdChannel\x12*.milvus.proto.internal.GetDdChannelRequest\x1a#.milvus.proto.milvus.StringResponse\"\x00\x12j\n\x19InvalidateCredentialCache\x12..milvus.proto.proxy.InvalidateCredCacheRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12\x62\n\x15UpdateCredentialCache\x12*.milvus.proto.proxy.UpdateCredCacheRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12j\n\x16RefreshPolicyInfoCache\x12\x31.milvus.proto.proxy.RefreshPolicyInfoCacheRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12\x64\n\x0fGetProxyMetrics\x12&.milvus.proto.milvus.GetMetricsRequest\x1a\'.milvus.proto.milvus.GetMetricsResponse\"\x00\x12N\n\x08SetRates\x12#.milvus.proto.proxy.SetRatesRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12l\n\x0fListClientInfos\x12*.milvus.proto.proxy.ListClientInfosRequest\x1a+.milvus.proto.proxy.ListClientInfosResponse\"\x00\x12Y\n\x08ImportV2\x12$.milvus.proto.internal.ImportRequest\x1a%.milvus.proto.internal.ImportResponse\"\x00\x12x\n\x11GetImportProgress\x12/.milvus.proto.internal.GetImportProgressRequest\x1a\x30.milvus.proto.internal.GetImportProgressResponse\"\x00\x12\x66\n\x0bListImports\x12).milvus.proto.internal.ListImportsRequest\x1a*.milvus.proto.internal.ListImportsResponse\"\x00\x42\x34Z2github.com/milvus-io/milvus/internal/proto/proxypbb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'proxy_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + _globals['DESCRIPTOR']._options = None + _globals['DESCRIPTOR']._serialized_options = b'Z2github.com/milvus-io/milvus/internal/proto/proxypb' + _globals['_INVALIDATECOLLMETACACHEREQUEST']._serialized_start=80 + _globals['_INVALIDATECOLLMETACACHEREQUEST']._serialized_end=244 + _globals['_INVALIDATECREDCACHEREQUEST']._serialized_start=246 + _globals['_INVALIDATECREDCACHEREQUEST']._serialized_end=336 + _globals['_UPDATECREDCACHEREQUEST']._serialized_start=338 + _globals['_UPDATECREDCACHEREQUEST']._serialized_end=442 + _globals['_REFRESHPOLICYINFOCACHEREQUEST']._serialized_start=444 + _globals['_REFRESHPOLICYINFOCACHEREQUEST']._serialized_end=550 + _globals['_COLLECTIONRATE']._serialized_start=553 + _globals['_COLLECTIONRATE']._serialized_end=729 + _globals['_SETRATESREQUEST']._serialized_start=731 + _globals['_SETRATESREQUEST']._serialized_end=843 + _globals['_LISTCLIENTINFOSREQUEST']._serialized_start=845 + _globals['_LISTCLIENTINFOSREQUEST']._serialized_end=913 + _globals['_LISTCLIENTINFOSRESPONSE']._serialized_start=915 + _globals['_LISTCLIENTINFOSRESPONSE']._serialized_end=1040 + _globals['_PROXY']._serialized_start=1043 + _globals['_PROXY']._serialized_end=2415 +# @@protoc_insertion_point(module_scope) diff --git a/milvus_connector/protocol/proxy_pb2.pyi b/milvus_connector/protocol/proxy_pb2.pyi new file mode 100644 index 0000000..892b0c3 --- /dev/null +++ b/milvus_connector/protocol/proxy_pb2.pyi @@ -0,0 +1,85 @@ +from . import common_pb2 as _common_pb2 +from . import internal_pb2 as _internal_pb2 +from . import milvus_pb2 as _milvus_pb2 +from google.protobuf.internal import containers as _containers +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Iterable as _Iterable, Mapping as _Mapping, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class InvalidateCollMetaCacheRequest(_message.Message): + __slots__ = ("base", "db_name", "collection_name", "collectionID", "partition_name") + BASE_FIELD_NUMBER: _ClassVar[int] + DB_NAME_FIELD_NUMBER: _ClassVar[int] + COLLECTION_NAME_FIELD_NUMBER: _ClassVar[int] + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + PARTITION_NAME_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + db_name: str + collection_name: str + collectionID: int + partition_name: str + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., db_name: _Optional[str] = ..., collection_name: _Optional[str] = ..., collectionID: _Optional[int] = ..., partition_name: _Optional[str] = ...) -> None: ... + +class InvalidateCredCacheRequest(_message.Message): + __slots__ = ("base", "username") + BASE_FIELD_NUMBER: _ClassVar[int] + USERNAME_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + username: str + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., username: _Optional[str] = ...) -> None: ... + +class UpdateCredCacheRequest(_message.Message): + __slots__ = ("base", "username", "password") + BASE_FIELD_NUMBER: _ClassVar[int] + USERNAME_FIELD_NUMBER: _ClassVar[int] + PASSWORD_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + username: str + password: str + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., username: _Optional[str] = ..., password: _Optional[str] = ...) -> None: ... + +class RefreshPolicyInfoCacheRequest(_message.Message): + __slots__ = ("base", "opType", "opKey") + BASE_FIELD_NUMBER: _ClassVar[int] + OPTYPE_FIELD_NUMBER: _ClassVar[int] + OPKEY_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + opType: int + opKey: str + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., opType: _Optional[int] = ..., opKey: _Optional[str] = ...) -> None: ... + +class CollectionRate(_message.Message): + __slots__ = ("collection", "rates", "states", "codes") + COLLECTION_FIELD_NUMBER: _ClassVar[int] + RATES_FIELD_NUMBER: _ClassVar[int] + STATES_FIELD_NUMBER: _ClassVar[int] + CODES_FIELD_NUMBER: _ClassVar[int] + collection: int + rates: _containers.RepeatedCompositeFieldContainer[_internal_pb2.Rate] + states: _containers.RepeatedScalarFieldContainer[_milvus_pb2.QuotaState] + codes: _containers.RepeatedScalarFieldContainer[_common_pb2.ErrorCode] + def __init__(self, collection: _Optional[int] = ..., rates: _Optional[_Iterable[_Union[_internal_pb2.Rate, _Mapping]]] = ..., states: _Optional[_Iterable[_Union[_milvus_pb2.QuotaState, str]]] = ..., codes: _Optional[_Iterable[_Union[_common_pb2.ErrorCode, str]]] = ...) -> None: ... + +class SetRatesRequest(_message.Message): + __slots__ = ("base", "rates") + BASE_FIELD_NUMBER: _ClassVar[int] + RATES_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + rates: _containers.RepeatedCompositeFieldContainer[CollectionRate] + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., rates: _Optional[_Iterable[_Union[CollectionRate, _Mapping]]] = ...) -> None: ... + +class ListClientInfosRequest(_message.Message): + __slots__ = ("base",) + BASE_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ...) -> None: ... + +class ListClientInfosResponse(_message.Message): + __slots__ = ("status", "client_infos") + STATUS_FIELD_NUMBER: _ClassVar[int] + CLIENT_INFOS_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + client_infos: _containers.RepeatedCompositeFieldContainer[_common_pb2.ClientInfo] + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., client_infos: _Optional[_Iterable[_Union[_common_pb2.ClientInfo, _Mapping]]] = ...) -> None: ... diff --git a/milvus_connector/protocol/proxy_pb2_grpc.py b/milvus_connector/protocol/proxy_pb2_grpc.py new file mode 100644 index 0000000..7880c3f --- /dev/null +++ b/milvus_connector/protocol/proxy_pb2_grpc.py @@ -0,0 +1,466 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + +from . import common_pb2 as common__pb2 +from . import internal_pb2 as internal__pb2 +from . import milvus_pb2 as milvus__pb2 +from . import proxy_pb2 as proxy__pb2 + + +class ProxyStub(object): + """Missing associated documentation comment in .proto file.""" + + def __init__(self, channel): + """Constructor. + + Args: + channel: A grpc.Channel. + """ + self.GetComponentStates = channel.unary_unary( + '/milvus.proto.proxy.Proxy/GetComponentStates', + request_serializer=milvus__pb2.GetComponentStatesRequest.SerializeToString, + response_deserializer=milvus__pb2.ComponentStates.FromString, + ) + self.GetStatisticsChannel = channel.unary_unary( + '/milvus.proto.proxy.Proxy/GetStatisticsChannel', + request_serializer=internal__pb2.GetStatisticsChannelRequest.SerializeToString, + response_deserializer=milvus__pb2.StringResponse.FromString, + ) + self.InvalidateCollectionMetaCache = channel.unary_unary( + '/milvus.proto.proxy.Proxy/InvalidateCollectionMetaCache', + request_serializer=proxy__pb2.InvalidateCollMetaCacheRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.GetDdChannel = channel.unary_unary( + '/milvus.proto.proxy.Proxy/GetDdChannel', + request_serializer=internal__pb2.GetDdChannelRequest.SerializeToString, + response_deserializer=milvus__pb2.StringResponse.FromString, + ) + self.InvalidateCredentialCache = channel.unary_unary( + '/milvus.proto.proxy.Proxy/InvalidateCredentialCache', + request_serializer=proxy__pb2.InvalidateCredCacheRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.UpdateCredentialCache = channel.unary_unary( + '/milvus.proto.proxy.Proxy/UpdateCredentialCache', + request_serializer=proxy__pb2.UpdateCredCacheRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.RefreshPolicyInfoCache = channel.unary_unary( + '/milvus.proto.proxy.Proxy/RefreshPolicyInfoCache', + request_serializer=proxy__pb2.RefreshPolicyInfoCacheRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.GetProxyMetrics = channel.unary_unary( + '/milvus.proto.proxy.Proxy/GetProxyMetrics', + request_serializer=milvus__pb2.GetMetricsRequest.SerializeToString, + response_deserializer=milvus__pb2.GetMetricsResponse.FromString, + ) + self.SetRates = channel.unary_unary( + '/milvus.proto.proxy.Proxy/SetRates', + request_serializer=proxy__pb2.SetRatesRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.ListClientInfos = channel.unary_unary( + '/milvus.proto.proxy.Proxy/ListClientInfos', + request_serializer=proxy__pb2.ListClientInfosRequest.SerializeToString, + response_deserializer=proxy__pb2.ListClientInfosResponse.FromString, + ) + self.ImportV2 = channel.unary_unary( + '/milvus.proto.proxy.Proxy/ImportV2', + request_serializer=internal__pb2.ImportRequest.SerializeToString, + response_deserializer=internal__pb2.ImportResponse.FromString, + ) + self.GetImportProgress = channel.unary_unary( + '/milvus.proto.proxy.Proxy/GetImportProgress', + request_serializer=internal__pb2.GetImportProgressRequest.SerializeToString, + response_deserializer=internal__pb2.GetImportProgressResponse.FromString, + ) + self.ListImports = channel.unary_unary( + '/milvus.proto.proxy.Proxy/ListImports', + request_serializer=internal__pb2.ListImportsRequest.SerializeToString, + response_deserializer=internal__pb2.ListImportsResponse.FromString, + ) + + +class ProxyServicer(object): + """Missing associated documentation comment in .proto file.""" + + def GetComponentStates(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetStatisticsChannel(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def InvalidateCollectionMetaCache(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetDdChannel(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def InvalidateCredentialCache(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def UpdateCredentialCache(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def RefreshPolicyInfoCache(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetProxyMetrics(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def SetRates(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ListClientInfos(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ImportV2(self, request, context): + """importV2 + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetImportProgress(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ListImports(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + +def add_ProxyServicer_to_server(servicer, server): + rpc_method_handlers = { + 'GetComponentStates': grpc.unary_unary_rpc_method_handler( + servicer.GetComponentStates, + request_deserializer=milvus__pb2.GetComponentStatesRequest.FromString, + response_serializer=milvus__pb2.ComponentStates.SerializeToString, + ), + 'GetStatisticsChannel': grpc.unary_unary_rpc_method_handler( + servicer.GetStatisticsChannel, + request_deserializer=internal__pb2.GetStatisticsChannelRequest.FromString, + response_serializer=milvus__pb2.StringResponse.SerializeToString, + ), + 'InvalidateCollectionMetaCache': grpc.unary_unary_rpc_method_handler( + servicer.InvalidateCollectionMetaCache, + request_deserializer=proxy__pb2.InvalidateCollMetaCacheRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'GetDdChannel': grpc.unary_unary_rpc_method_handler( + servicer.GetDdChannel, + request_deserializer=internal__pb2.GetDdChannelRequest.FromString, + response_serializer=milvus__pb2.StringResponse.SerializeToString, + ), + 'InvalidateCredentialCache': grpc.unary_unary_rpc_method_handler( + servicer.InvalidateCredentialCache, + request_deserializer=proxy__pb2.InvalidateCredCacheRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'UpdateCredentialCache': grpc.unary_unary_rpc_method_handler( + servicer.UpdateCredentialCache, + request_deserializer=proxy__pb2.UpdateCredCacheRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'RefreshPolicyInfoCache': grpc.unary_unary_rpc_method_handler( + servicer.RefreshPolicyInfoCache, + request_deserializer=proxy__pb2.RefreshPolicyInfoCacheRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'GetProxyMetrics': grpc.unary_unary_rpc_method_handler( + servicer.GetProxyMetrics, + request_deserializer=milvus__pb2.GetMetricsRequest.FromString, + response_serializer=milvus__pb2.GetMetricsResponse.SerializeToString, + ), + 'SetRates': grpc.unary_unary_rpc_method_handler( + servicer.SetRates, + request_deserializer=proxy__pb2.SetRatesRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'ListClientInfos': grpc.unary_unary_rpc_method_handler( + servicer.ListClientInfos, + request_deserializer=proxy__pb2.ListClientInfosRequest.FromString, + response_serializer=proxy__pb2.ListClientInfosResponse.SerializeToString, + ), + 'ImportV2': grpc.unary_unary_rpc_method_handler( + servicer.ImportV2, + request_deserializer=internal__pb2.ImportRequest.FromString, + response_serializer=internal__pb2.ImportResponse.SerializeToString, + ), + 'GetImportProgress': grpc.unary_unary_rpc_method_handler( + servicer.GetImportProgress, + request_deserializer=internal__pb2.GetImportProgressRequest.FromString, + response_serializer=internal__pb2.GetImportProgressResponse.SerializeToString, + ), + 'ListImports': grpc.unary_unary_rpc_method_handler( + servicer.ListImports, + request_deserializer=internal__pb2.ListImportsRequest.FromString, + response_serializer=internal__pb2.ListImportsResponse.SerializeToString, + ), + } + generic_handler = grpc.method_handlers_generic_handler( + 'milvus.proto.proxy.Proxy', rpc_method_handlers) + server.add_generic_rpc_handlers((generic_handler,)) + + + # This class is part of an EXPERIMENTAL API. +class Proxy(object): + """Missing associated documentation comment in .proto file.""" + + @staticmethod + def GetComponentStates(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.proxy.Proxy/GetComponentStates', + milvus__pb2.GetComponentStatesRequest.SerializeToString, + milvus__pb2.ComponentStates.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetStatisticsChannel(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.proxy.Proxy/GetStatisticsChannel', + internal__pb2.GetStatisticsChannelRequest.SerializeToString, + milvus__pb2.StringResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def InvalidateCollectionMetaCache(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.proxy.Proxy/InvalidateCollectionMetaCache', + proxy__pb2.InvalidateCollMetaCacheRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetDdChannel(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.proxy.Proxy/GetDdChannel', + internal__pb2.GetDdChannelRequest.SerializeToString, + milvus__pb2.StringResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def InvalidateCredentialCache(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.proxy.Proxy/InvalidateCredentialCache', + proxy__pb2.InvalidateCredCacheRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def UpdateCredentialCache(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.proxy.Proxy/UpdateCredentialCache', + proxy__pb2.UpdateCredCacheRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def RefreshPolicyInfoCache(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.proxy.Proxy/RefreshPolicyInfoCache', + proxy__pb2.RefreshPolicyInfoCacheRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetProxyMetrics(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.proxy.Proxy/GetProxyMetrics', + milvus__pb2.GetMetricsRequest.SerializeToString, + milvus__pb2.GetMetricsResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def SetRates(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.proxy.Proxy/SetRates', + proxy__pb2.SetRatesRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def ListClientInfos(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.proxy.Proxy/ListClientInfos', + proxy__pb2.ListClientInfosRequest.SerializeToString, + proxy__pb2.ListClientInfosResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def ImportV2(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.proxy.Proxy/ImportV2', + internal__pb2.ImportRequest.SerializeToString, + internal__pb2.ImportResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetImportProgress(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.proxy.Proxy/GetImportProgress', + internal__pb2.GetImportProgressRequest.SerializeToString, + internal__pb2.GetImportProgressResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def ListImports(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.proxy.Proxy/ListImports', + internal__pb2.ListImportsRequest.SerializeToString, + internal__pb2.ListImportsResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) diff --git a/milvus_connector/protocol/query_coord_pb2.py b/milvus_connector/protocol/query_coord_pb2.py new file mode 100644 index 0000000..bf2ed1f --- /dev/null +++ b/milvus_connector/protocol/query_coord_pb2.py @@ -0,0 +1,234 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: query_coord.proto +# Protobuf Python Version: 4.25.1 +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from . import common_pb2 as common__pb2 +from . import milvus_pb2 as milvus__pb2 +from . import internal_pb2 as internal__pb2 +from . import schema_pb2 as schema__pb2 +from . import msg_pb2 as msg__pb2 +from . import data_coord_pb2 as data__coord__pb2 +from . import index_coord_pb2 as index__coord__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x11query_coord.proto\x12\x12milvus.proto.query\x1a\x0c\x63ommon.proto\x1a\x0cmilvus.proto\x1a\x0einternal.proto\x1a\x0cschema.proto\x1a\tmsg.proto\x1a\x10\x64\x61ta_coord.proto\x1a\x11index_coord.proto\"i\n\x16ShowCollectionsRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x0c\n\x04\x64\x62ID\x18\x02 \x01(\x03\x12\x15\n\rcollectionIDs\x18\x03 \x03(\x03\"\xb6\x01\n\x17ShowCollectionsResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\x15\n\rcollectionIDs\x18\x02 \x03(\x03\x12\x1c\n\x14inMemory_percentages\x18\x03 \x03(\x03\x12\x1f\n\x17query_service_available\x18\x04 \x03(\x08\x12\x18\n\x10refresh_progress\x18\x05 \x03(\x03\"}\n\x15ShowPartitionsRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x0c\n\x04\x64\x62ID\x18\x02 \x01(\x03\x12\x14\n\x0c\x63ollectionID\x18\x03 \x01(\x03\x12\x14\n\x0cpartitionIDs\x18\x04 \x03(\x03\"\x93\x01\n\x16ShowPartitionsResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\x14\n\x0cpartitionIDs\x18\x02 \x03(\x03\x12\x1c\n\x14inMemory_percentages\x18\x03 \x03(\x03\x12\x18\n\x10refresh_progress\x18\x04 \x03(\x03\"\xe9\x02\n\x15LoadCollectionRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x0c\n\x04\x64\x62ID\x18\x02 \x01(\x03\x12\x14\n\x0c\x63ollectionID\x18\x03 \x01(\x03\x12\x35\n\x06schema\x18\x04 \x01(\x0b\x32%.milvus.proto.schema.CollectionSchema\x12\x16\n\x0ereplica_number\x18\x05 \x01(\x05\x12R\n\rfield_indexID\x18\x06 \x03(\x0b\x32;.milvus.proto.query.LoadCollectionRequest.FieldIndexIDEntry\x12\x0f\n\x07refresh\x18\x07 \x01(\x08\x12\x17\n\x0fresource_groups\x18\x08 \x03(\t\x1a\x33\n\x11\x46ieldIndexIDEntry\x12\x0b\n\x03key\x18\x01 \x01(\x03\x12\r\n\x05value\x18\x02 \x01(\x03:\x02\x38\x01\"z\n\x18ReleaseCollectionRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x0c\n\x04\x64\x62ID\x18\x02 \x01(\x03\x12\x14\n\x0c\x63ollectionID\x18\x03 \x01(\x03\x12\x0e\n\x06nodeID\x18\x04 \x01(\x03\"\xc3\x01\n\x14GetStatisticsRequest\x12\x38\n\x03req\x18\x01 \x01(\x0b\x32+.milvus.proto.internal.GetStatisticsRequest\x12\x14\n\x0c\x64ml_channels\x18\x02 \x03(\t\x12\x12\n\nsegmentIDs\x18\x03 \x03(\x03\x12\x19\n\x11\x66rom_shard_leader\x18\x04 \x01(\x08\x12,\n\x05scope\x18\x05 \x01(\x0e\x32\x1d.milvus.proto.query.DataScope\"\xb7\x03\n\x15LoadPartitionsRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x0c\n\x04\x64\x62ID\x18\x02 \x01(\x03\x12\x14\n\x0c\x63ollectionID\x18\x03 \x01(\x03\x12\x14\n\x0cpartitionIDs\x18\x04 \x03(\x03\x12\x35\n\x06schema\x18\x05 \x01(\x0b\x32%.milvus.proto.schema.CollectionSchema\x12\x16\n\x0ereplica_number\x18\x06 \x01(\x05\x12R\n\rfield_indexID\x18\x07 \x03(\x0b\x32;.milvus.proto.query.LoadPartitionsRequest.FieldIndexIDEntry\x12\x0f\n\x07refresh\x18\x08 \x01(\x08\x12\x17\n\x0fresource_groups\x18\t \x03(\t\x12\x36\n\x0findex_info_list\x18\n \x03(\x0b\x32\x1d.milvus.proto.index.IndexInfo\x1a\x33\n\x11\x46ieldIndexIDEntry\x12\x0b\n\x03key\x18\x01 \x01(\x03\x12\r\n\x05value\x18\x02 \x01(\x03:\x02\x38\x01\"\x90\x01\n\x18ReleasePartitionsRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x0c\n\x04\x64\x62ID\x18\x02 \x01(\x03\x12\x14\n\x0c\x63ollectionID\x18\x03 \x01(\x03\x12\x14\n\x0cpartitionIDs\x18\x04 \x03(\x03\x12\x0e\n\x06nodeID\x18\x05 \x01(\x03\"\x81\x01\n\x19GetPartitionStatesRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x0c\n\x04\x64\x62ID\x18\x02 \x01(\x03\x12\x14\n\x0c\x63ollectionID\x18\x03 \x01(\x03\x12\x14\n\x0cpartitionIDs\x18\x04 \x03(\x03\"\x8e\x01\n\x1aGetPartitionStatesResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\x43\n\x16partition_descriptions\x18\x02 \x03(\x0b\x32#.milvus.proto.query.PartitionStates\"m\n\x15GetSegmentInfoRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x12\n\nsegmentIDs\x18\x02 \x03(\x03\x12\x14\n\x0c\x63ollectionID\x18\x03 \x01(\x03\"u\n\x16GetSegmentInfoResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12.\n\x05infos\x18\x02 \x03(\x0b\x32\x1f.milvus.proto.query.SegmentInfo\"Z\n\x16GetShardLeadersRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x14\n\x0c\x63ollectionID\x18\x02 \x01(\x03\"|\n\x17GetShardLeadersResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\x34\n\x06shards\x18\x02 \x03(\x0b\x32$.milvus.proto.query.ShardLeadersList\"N\n\x10ShardLeadersList\x12\x14\n\x0c\x63hannel_name\x18\x01 \x01(\t\x12\x10\n\x08node_ids\x18\x02 \x03(\x03\x12\x12\n\nnode_addrs\x18\x03 \x03(\t\"w\n\x1eSyncNewCreatedPartitionRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x14\n\x0c\x63ollectionID\x18\x02 \x01(\x03\x12\x13\n\x0bpartitionID\x18\x03 \x01(\x03\"\x84\x01\n\x0cLoadMetaInfo\x12/\n\tload_type\x18\x01 \x01(\x0e\x32\x1c.milvus.proto.query.LoadType\x12\x14\n\x0c\x63ollectionID\x18\x02 \x01(\x03\x12\x14\n\x0cpartitionIDs\x18\x03 \x03(\x03\x12\x17\n\x0bmetric_type\x18\x04 \x01(\tB\x02\x18\x01\"\xf0\x04\n\x16WatchDmChannelsRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x0e\n\x06nodeID\x18\x02 \x01(\x03\x12\x14\n\x0c\x63ollectionID\x18\x03 \x01(\x03\x12\x14\n\x0cpartitionIDs\x18\x04 \x03(\x03\x12.\n\x05infos\x18\x05 \x03(\x0b\x32\x1f.milvus.proto.data.VchannelInfo\x12\x35\n\x06schema\x18\x06 \x01(\x0b\x32%.milvus.proto.schema.CollectionSchema\x12\x35\n\rexclude_infos\x18\x07 \x03(\x0b\x32\x1e.milvus.proto.data.SegmentInfo\x12\x33\n\tload_meta\x18\x08 \x01(\x0b\x32 .milvus.proto.query.LoadMetaInfo\x12\x11\n\treplicaID\x18\t \x01(\x03\x12S\n\rsegment_infos\x18\n \x03(\x0b\x32<.milvus.proto.query.WatchDmChannelsRequest.SegmentInfosEntry\x12\x15\n\rofflineNodeID\x18\x0b \x01(\x03\x12\x0f\n\x07version\x18\x0c \x01(\x03\x12\x36\n\x0findex_info_list\x18\r \x03(\x0b\x32\x1d.milvus.proto.index.IndexInfo\x1aS\n\x11SegmentInfosEntry\x12\x0b\n\x03key\x18\x01 \x01(\x03\x12-\n\x05value\x18\x02 \x01(\x0b\x32\x1e.milvus.proto.data.SegmentInfo:\x02\x38\x01\"\x7f\n\x15UnsubDmChannelRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x0e\n\x06nodeID\x18\x02 \x01(\x03\x12\x14\n\x0c\x63ollectionID\x18\x03 \x01(\x03\x12\x14\n\x0c\x63hannel_name\x18\x04 \x01(\t\"\xf0\x04\n\x0fSegmentLoadInfo\x12\x11\n\tsegmentID\x18\x01 \x01(\x03\x12\x13\n\x0bpartitionID\x18\x02 \x01(\x03\x12\x14\n\x0c\x63ollectionID\x18\x03 \x01(\x03\x12\x0c\n\x04\x64\x62ID\x18\x04 \x01(\x03\x12\x12\n\nflush_time\x18\x05 \x01(\x03\x12\x34\n\x0c\x62inlog_paths\x18\x06 \x03(\x0b\x32\x1e.milvus.proto.data.FieldBinlog\x12\x13\n\x0bnum_of_rows\x18\x07 \x01(\x03\x12\x31\n\tstatslogs\x18\x08 \x03(\x0b\x32\x1e.milvus.proto.data.FieldBinlog\x12\x31\n\tdeltalogs\x18\t \x03(\x0b\x32\x1e.milvus.proto.data.FieldBinlog\x12\x16\n\x0e\x63ompactionFrom\x18\n \x03(\x03\x12\x37\n\x0bindex_infos\x18\x0b \x03(\x0b\x32\".milvus.proto.query.FieldIndexInfo\x12\x14\n\x0csegment_size\x18\x0c \x01(\x03\x12\x16\n\x0einsert_channel\x18\r \x01(\t\x12\x35\n\x0estart_position\x18\x0e \x01(\x0b\x32\x1d.milvus.proto.msg.MsgPosition\x12\x35\n\x0e\x64\x65lta_position\x18\x0f \x01(\x0b\x32\x1d.milvus.proto.msg.MsgPosition\x12\x17\n\x0freadableVersion\x18\x10 \x01(\x03\x12.\n\x05level\x18\x11 \x01(\x0e\x32\x1f.milvus.proto.data.SegmentLevel\x12\x16\n\x0estorageVersion\x18\x12 \x01(\x03\"\xb9\x02\n\x0e\x46ieldIndexInfo\x12\x0f\n\x07\x66ieldID\x18\x01 \x01(\x03\x12\x14\n\x0c\x65nable_index\x18\x02 \x01(\x08\x12\x12\n\nindex_name\x18\x03 \x01(\t\x12\x0f\n\x07indexID\x18\x04 \x01(\x03\x12\x0f\n\x07\x62uildID\x18\x05 \x01(\x03\x12\x37\n\x0cindex_params\x18\x06 \x03(\x0b\x32!.milvus.proto.common.KeyValuePair\x12\x18\n\x10index_file_paths\x18\x07 \x03(\t\x12\x12\n\nindex_size\x18\x08 \x01(\x03\x12\x15\n\rindex_version\x18\t \x01(\x03\x12\x10\n\x08num_rows\x18\n \x01(\x03\x12\x1d\n\x15\x63urrent_index_version\x18\x0b \x01(\x05\x12\x1b\n\x13index_store_version\x18\x0c \x01(\x03\"\x93\x04\n\x13LoadSegmentsRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x12\n\ndst_nodeID\x18\x02 \x01(\x03\x12\x32\n\x05infos\x18\x03 \x03(\x0b\x32#.milvus.proto.query.SegmentLoadInfo\x12\x35\n\x06schema\x18\x04 \x01(\x0b\x32%.milvus.proto.schema.CollectionSchema\x12\x15\n\rsource_nodeID\x18\x05 \x01(\x03\x12\x14\n\x0c\x63ollectionID\x18\x06 \x01(\x03\x12\x33\n\tload_meta\x18\x07 \x01(\x0b\x32 .milvus.proto.query.LoadMetaInfo\x12\x11\n\treplicaID\x18\x08 \x01(\x03\x12\x36\n\x0f\x64\x65lta_positions\x18\t \x03(\x0b\x32\x1d.milvus.proto.msg.MsgPosition\x12\x0f\n\x07version\x18\n \x01(\x03\x12\x15\n\rneed_transfer\x18\x0b \x01(\x08\x12\x31\n\nload_scope\x18\x0c \x01(\x0e\x32\x1d.milvus.proto.query.LoadScope\x12\x36\n\x0findex_info_list\x18\r \x03(\x0b\x32\x1d.milvus.proto.index.IndexInfo\x12\x11\n\tlazy_load\x18\x0e \x01(\x08\"\xf6\x01\n\x16ReleaseSegmentsRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x0e\n\x06nodeID\x18\x02 \x01(\x03\x12\x0c\n\x04\x64\x62ID\x18\x03 \x01(\x03\x12\x14\n\x0c\x63ollectionID\x18\x04 \x01(\x03\x12\x14\n\x0cpartitionIDs\x18\x05 \x03(\x03\x12\x12\n\nsegmentIDs\x18\x06 \x03(\x03\x12,\n\x05scope\x18\x07 \x01(\x0e\x32\x1d.milvus.proto.query.DataScope\x12\r\n\x05shard\x18\x08 \x01(\t\x12\x15\n\rneed_transfer\x18\x0b \x01(\x08\"\xd0\x01\n\rSearchRequest\x12\x31\n\x03req\x18\x01 \x01(\x0b\x32$.milvus.proto.internal.SearchRequest\x12\x14\n\x0c\x64ml_channels\x18\x02 \x03(\t\x12\x12\n\nsegmentIDs\x18\x03 \x03(\x03\x12\x19\n\x11\x66rom_shard_leader\x18\x04 \x01(\x08\x12,\n\x05scope\x18\x05 \x01(\x0e\x32\x1d.milvus.proto.query.DataScope\x12\x19\n\x11total_channel_num\x18\x06 \x01(\x05\"\x7f\n\x13HybridSearchRequest\x12\x37\n\x03req\x18\x01 \x01(\x0b\x32*.milvus.proto.internal.HybridSearchRequest\x12\x14\n\x0c\x64ml_channels\x18\x02 \x03(\t\x12\x19\n\x11total_channel_num\x18\x03 \x01(\x05\"\xeb\x02\n\x12HybridSearchResult\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12+\n\x06status\x18\x02 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\x35\n\x07results\x18\x03 \x03(\x0b\x32$.milvus.proto.internal.SearchResults\x12?\n\x0f\x63ostAggregation\x18\x04 \x01(\x0b\x32&.milvus.proto.internal.CostAggregation\x12O\n\rchannels_mvcc\x18\x05 \x03(\x0b\x32\x38.milvus.proto.query.HybridSearchResult.ChannelsMvccEntry\x1a\x33\n\x11\x43hannelsMvccEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\x04:\x02\x38\x01\"\xb6\x01\n\x0cQueryRequest\x12\x33\n\x03req\x18\x01 \x01(\x0b\x32&.milvus.proto.internal.RetrieveRequest\x12\x14\n\x0c\x64ml_channels\x18\x02 \x03(\t\x12\x12\n\nsegmentIDs\x18\x03 \x03(\x03\x12\x19\n\x11\x66rom_shard_leader\x18\x04 \x01(\x08\x12,\n\x05scope\x18\x05 \x01(\x0e\x32\x1d.milvus.proto.query.DataScope\"\xa2\x01\n\x1aSyncReplicaSegmentsRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x15\n\rvchannel_name\x18\x02 \x01(\t\x12\x41\n\x10replica_segments\x18\x03 \x03(\x0b\x32\'.milvus.proto.query.ReplicaSegmentsInfo\"c\n\x13ReplicaSegmentsInfo\x12\x0f\n\x07node_id\x18\x01 \x01(\x03\x12\x14\n\x0cpartition_id\x18\x02 \x01(\x03\x12\x13\n\x0bsegment_ids\x18\x03 \x03(\x03\x12\x10\n\x08versions\x18\x04 \x03(\x03\"W\n\x12GetLoadInfoRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x15\n\rcollection_id\x18\x02 \x01(\x03\"\xbe\x01\n\x13GetLoadInfoResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\x35\n\x06schema\x18\x02 \x01(\x0b\x32%.milvus.proto.schema.CollectionSchema\x12/\n\tload_type\x18\x03 \x01(\x0e\x32\x1c.milvus.proto.query.LoadType\x12\x12\n\npartitions\x18\x04 \x03(\x03\"\x96\x01\n\x16HandoffSegmentsRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x35\n\x0csegmentInfos\x18\x02 \x03(\x0b\x32\x1f.milvus.proto.query.SegmentInfo\x12\x19\n\x11released_segments\x18\x03 \x03(\x03\"\xdc\x01\n\x12LoadBalanceRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x16\n\x0esource_nodeIDs\x18\x02 \x03(\x03\x12<\n\x0e\x62\x61lance_reason\x18\x03 \x01(\x0e\x32$.milvus.proto.query.TriggerCondition\x12\x13\n\x0b\x64st_nodeIDs\x18\x04 \x03(\x03\x12\x19\n\x11sealed_segmentIDs\x18\x05 \x03(\x03\x12\x14\n\x0c\x63ollectionID\x18\x06 \x01(\x03\"y\n\x12\x44mChannelWatchInfo\x12\x14\n\x0c\x63ollectionID\x18\x01 \x01(\x03\x12\x11\n\tdmChannel\x18\x02 \x01(\t\x12\x15\n\rnodeID_loaded\x18\x03 \x01(\x03\x12\x11\n\treplicaID\x18\x04 \x01(\x03\x12\x10\n\x08node_ids\x18\x05 \x03(\x03\"\xd4\x01\n\x10QueryChannelInfo\x12\x14\n\x0c\x63ollectionID\x18\x01 \x01(\x03\x12\x15\n\rquery_channel\x18\x02 \x01(\t\x12\x1c\n\x14query_result_channel\x18\x03 \x01(\t\x12?\n\x16global_sealed_segments\x18\x04 \x03(\x0b\x32\x1f.milvus.proto.query.SegmentInfo\x12\x34\n\rseek_position\x18\x05 \x01(\x0b\x32\x1d.milvus.proto.msg.MsgPosition\"v\n\x0fPartitionStates\x12\x13\n\x0bpartitionID\x18\x01 \x01(\x03\x12\x31\n\x05state\x18\x02 \x01(\x0e\x32\".milvus.proto.query.PartitionState\x12\x1b\n\x13inMemory_percentage\x18\x03 \x01(\x03\"\xad\x03\n\x0bSegmentInfo\x12\x11\n\tsegmentID\x18\x01 \x01(\x03\x12\x14\n\x0c\x63ollectionID\x18\x02 \x01(\x03\x12\x13\n\x0bpartitionID\x18\x03 \x01(\x03\x12\x0e\n\x06nodeID\x18\x04 \x01(\x03\x12\x10\n\x08mem_size\x18\x05 \x01(\x03\x12\x10\n\x08num_rows\x18\x06 \x01(\x03\x12\x12\n\nindex_name\x18\x07 \x01(\t\x12\x0f\n\x07indexID\x18\x08 \x01(\x03\x12\x11\n\tdmChannel\x18\t \x01(\t\x12\x16\n\x0e\x63ompactionFrom\x18\n \x03(\x03\x12\x1b\n\x13\x63reatedByCompaction\x18\x0b \x01(\x08\x12\x38\n\rsegment_state\x18\x0c \x01(\x0e\x32!.milvus.proto.common.SegmentState\x12\x37\n\x0bindex_infos\x18\r \x03(\x0b\x32\".milvus.proto.query.FieldIndexInfo\x12\x13\n\x0breplica_ids\x18\x0e \x03(\x03\x12\x10\n\x08node_ids\x18\x0f \x03(\x03\x12\x14\n\x0c\x65nable_index\x18\x10 \x01(\x08\x12\x0f\n\x07is_fake\x18\x11 \x01(\x08\"\xcc\x02\n\x0e\x43ollectionInfo\x12\x14\n\x0c\x63ollectionID\x18\x01 \x01(\x03\x12\x14\n\x0cpartitionIDs\x18\x02 \x03(\x03\x12=\n\x10partition_states\x18\x03 \x03(\x0b\x32#.milvus.proto.query.PartitionStates\x12/\n\tload_type\x18\x04 \x01(\x0e\x32\x1c.milvus.proto.query.LoadType\x12\x35\n\x06schema\x18\x05 \x01(\x0b\x32%.milvus.proto.schema.CollectionSchema\x12\x1d\n\x15released_partitionIDs\x18\x06 \x03(\x03\x12\x1b\n\x13inMemory_percentage\x18\x07 \x01(\x03\x12\x13\n\x0breplica_ids\x18\x08 \x03(\x03\x12\x16\n\x0ereplica_number\x18\t \x01(\x05\"=\n\x13UnsubscribeChannels\x12\x14\n\x0c\x63ollectionID\x18\x01 \x01(\x03\x12\x10\n\x08\x63hannels\x18\x02 \x03(\t\"n\n\x16UnsubscribeChannelInfo\x12\x0e\n\x06nodeID\x18\x01 \x01(\x03\x12\x44\n\x13\x63ollection_channels\x18\x02 \x03(\x0b\x32\'.milvus.proto.query.UnsubscribeChannels\"\xb7\x01\n\x11SegmentChangeInfo\x12\x15\n\ronline_nodeID\x18\x01 \x01(\x03\x12\x38\n\x0fonline_segments\x18\x02 \x03(\x0b\x32\x1f.milvus.proto.query.SegmentInfo\x12\x16\n\x0eoffline_nodeID\x18\x03 \x01(\x03\x12\x39\n\x10offline_segments\x18\x04 \x03(\x0b\x32\x1f.milvus.proto.query.SegmentInfo\"|\n\x18SealedSegmentsChangeInfo\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x34\n\x05infos\x18\x02 \x03(\x0b\x32%.milvus.proto.query.SegmentChangeInfo\"\xf1\x01\n\x1aGetDataDistributionRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12T\n\x0b\x63heckpoints\x18\x02 \x03(\x0b\x32?.milvus.proto.query.GetDataDistributionRequest.CheckpointsEntry\x1aQ\n\x10\x43heckpointsEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12,\n\x05value\x18\x02 \x01(\x0b\x32\x1d.milvus.proto.msg.MsgPosition:\x02\x38\x01\"\x84\x02\n\x1bGetDataDistributionResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\x0e\n\x06nodeID\x18\x02 \x01(\x03\x12\x38\n\x08segments\x18\x03 \x03(\x0b\x32&.milvus.proto.query.SegmentVersionInfo\x12\x38\n\x08\x63hannels\x18\x04 \x03(\x0b\x32&.milvus.proto.query.ChannelVersionInfo\x12\x34\n\x0cleader_views\x18\x05 \x03(\x0b\x32\x1e.milvus.proto.query.LeaderView\"\xc3\x03\n\nLeaderView\x12\x12\n\ncollection\x18\x01 \x01(\x03\x12\x0f\n\x07\x63hannel\x18\x02 \x01(\t\x12\x45\n\x0csegment_dist\x18\x03 \x03(\x0b\x32/.milvus.proto.query.LeaderView.SegmentDistEntry\x12\x1a\n\x12growing_segmentIDs\x18\x04 \x03(\x03\x12M\n\x10growing_segments\x18\x05 \x03(\x0b\x32\x33.milvus.proto.query.LeaderView.GrowingSegmentsEntry\x12\x15\n\rTargetVersion\x18\x06 \x01(\x03\x12\x1b\n\x13num_of_growing_rows\x18\x07 \x01(\x03\x1aS\n\x10SegmentDistEntry\x12\x0b\n\x03key\x18\x01 \x01(\x03\x12.\n\x05value\x18\x02 \x01(\x0b\x32\x1f.milvus.proto.query.SegmentDist:\x02\x38\x01\x1aU\n\x14GrowingSegmentsEntry\x12\x0b\n\x03key\x18\x01 \x01(\x03\x12,\n\x05value\x18\x02 \x01(\x0b\x32\x1d.milvus.proto.msg.MsgPosition:\x02\x38\x01\".\n\x0bSegmentDist\x12\x0e\n\x06nodeID\x18\x01 \x01(\x03\x12\x0f\n\x07version\x18\x02 \x01(\x03\"\xa8\x02\n\x12SegmentVersionInfo\x12\n\n\x02ID\x18\x01 \x01(\x03\x12\x12\n\ncollection\x18\x02 \x01(\x03\x12\x11\n\tpartition\x18\x03 \x01(\x03\x12\x0f\n\x07\x63hannel\x18\x04 \x01(\t\x12\x0f\n\x07version\x18\x05 \x01(\x03\x12\x1c\n\x14last_delta_timestamp\x18\x06 \x01(\x04\x12I\n\nindex_info\x18\x07 \x03(\x0b\x32\x35.milvus.proto.query.SegmentVersionInfo.IndexInfoEntry\x1aT\n\x0eIndexInfoEntry\x12\x0b\n\x03key\x18\x01 \x01(\x03\x12\x31\n\x05value\x18\x02 \x01(\x0b\x32\".milvus.proto.query.FieldIndexInfo:\x02\x38\x01\"J\n\x12\x43hannelVersionInfo\x12\x0f\n\x07\x63hannel\x18\x01 \x01(\t\x12\x12\n\ncollection\x18\x02 \x01(\x03\x12\x0f\n\x07version\x18\x03 \x01(\x03\"\xdd\x02\n\x12\x43ollectionLoadInfo\x12\x14\n\x0c\x63ollectionID\x18\x01 \x01(\x03\x12\x1b\n\x13released_partitions\x18\x02 \x03(\x03\x12\x16\n\x0ereplica_number\x18\x03 \x01(\x05\x12.\n\x06status\x18\x04 \x01(\x0e\x32\x1e.milvus.proto.query.LoadStatus\x12O\n\rfield_indexID\x18\x05 \x03(\x0b\x32\x38.milvus.proto.query.CollectionLoadInfo.FieldIndexIDEntry\x12/\n\tload_type\x18\x06 \x01(\x0e\x32\x1c.milvus.proto.query.LoadType\x12\x15\n\rrecover_times\x18\x07 \x01(\x05\x1a\x33\n\x11\x46ieldIndexIDEntry\x12\x0b\n\x03key\x18\x01 \x01(\x03\x12\r\n\x05value\x18\x02 \x01(\x03:\x02\x38\x01\"\xa2\x02\n\x11PartitionLoadInfo\x12\x14\n\x0c\x63ollectionID\x18\x01 \x01(\x03\x12\x13\n\x0bpartitionID\x18\x02 \x01(\x03\x12\x16\n\x0ereplica_number\x18\x03 \x01(\x05\x12.\n\x06status\x18\x04 \x01(\x0e\x32\x1e.milvus.proto.query.LoadStatus\x12N\n\rfield_indexID\x18\x05 \x03(\x0b\x32\x37.milvus.proto.query.PartitionLoadInfo.FieldIndexIDEntry\x12\x15\n\rrecover_times\x18\x07 \x01(\x05\x1a\x33\n\x11\x46ieldIndexIDEntry\x12\x0b\n\x03key\x18\x01 \x01(\x03\x12\r\n\x05value\x18\x02 \x01(\x03:\x02\x38\x01\"R\n\x07Replica\x12\n\n\x02ID\x18\x01 \x01(\x03\x12\x14\n\x0c\x63ollectionID\x18\x02 \x01(\x03\x12\r\n\x05nodes\x18\x03 \x03(\x03\x12\x16\n\x0eresource_group\x18\x04 \x01(\t\"\xc8\x02\n\nSyncAction\x12*\n\x04type\x18\x01 \x01(\x0e\x32\x1c.milvus.proto.query.SyncType\x12\x13\n\x0bpartitionID\x18\x02 \x01(\x03\x12\x11\n\tsegmentID\x18\x03 \x01(\x03\x12\x0e\n\x06nodeID\x18\x04 \x01(\x03\x12\x0f\n\x07version\x18\x05 \x01(\x03\x12\x31\n\x04info\x18\x06 \x01(\x0b\x32#.milvus.proto.query.SegmentLoadInfo\x12\x17\n\x0fgrowingInTarget\x18\x07 \x03(\x03\x12\x16\n\x0esealedInTarget\x18\x08 \x03(\x03\x12\x15\n\rTargetVersion\x18\t \x01(\x03\x12\x17\n\x0f\x64roppedInTarget\x18\n \x03(\x03\x12\x31\n\ncheckpoint\x18\x0b \x01(\x0b\x32\x1d.milvus.proto.msg.MsgPosition\"\xe5\x02\n\x17SyncDistributionRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x14\n\x0c\x63ollectionID\x18\x02 \x01(\x03\x12\x0f\n\x07\x63hannel\x18\x03 \x01(\t\x12/\n\x07\x61\x63tions\x18\x04 \x03(\x0b\x32\x1e.milvus.proto.query.SyncAction\x12\x35\n\x06schema\x18\x05 \x01(\x0b\x32%.milvus.proto.schema.CollectionSchema\x12\x33\n\tload_meta\x18\x06 \x01(\x0b\x32 .milvus.proto.query.LoadMetaInfo\x12\x11\n\treplicaID\x18\x07 \x01(\x03\x12\x0f\n\x07version\x18\x08 \x01(\x03\x12\x36\n\x0findex_info_list\x18\t \x03(\x0b\x32\x1d.milvus.proto.index.IndexInfo\">\n\rResourceGroup\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x10\n\x08\x63\x61pacity\x18\x02 \x01(\x05\x12\r\n\x05nodes\x18\x03 \x03(\x03\"\xad\x01\n\x16TransferReplicaRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x1d\n\x15source_resource_group\x18\x02 \x01(\t\x12\x1d\n\x15target_resource_group\x18\x03 \x01(\t\x12\x14\n\x0c\x63ollectionID\x18\x04 \x01(\x03\x12\x13\n\x0bnum_replica\x18\x05 \x01(\x03\"b\n\x1c\x44\x65scribeResourceGroupRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x16\n\x0eresource_group\x18\x02 \x01(\t\"\x8b\x01\n\x1d\x44\x65scribeResourceGroupResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12=\n\x0eresource_group\x18\x02 \x01(\x0b\x32%.milvus.proto.query.ResourceGroupInfo\"\xff\x03\n\x11ResourceGroupInfo\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x10\n\x08\x63\x61pacity\x18\x02 \x01(\x05\x12\x1a\n\x12num_available_node\x18\x03 \x01(\x05\x12W\n\x12num_loaded_replica\x18\x04 \x03(\x0b\x32;.milvus.proto.query.ResourceGroupInfo.NumLoadedReplicaEntry\x12U\n\x11num_outgoing_node\x18\x05 \x03(\x0b\x32:.milvus.proto.query.ResourceGroupInfo.NumOutgoingNodeEntry\x12U\n\x11num_incoming_node\x18\x06 \x03(\x0b\x32:.milvus.proto.query.ResourceGroupInfo.NumIncomingNodeEntry\x1a\x37\n\x15NumLoadedReplicaEntry\x12\x0b\n\x03key\x18\x01 \x01(\x03\x12\r\n\x05value\x18\x02 \x01(\x05:\x02\x38\x01\x1a\x36\n\x14NumOutgoingNodeEntry\x12\x0b\n\x03key\x18\x01 \x01(\x03\x12\r\n\x05value\x18\x02 \x01(\x05:\x02\x38\x01\x1a\x36\n\x14NumIncomingNodeEntry\x12\x0b\n\x03key\x18\x01 \x01(\x03\x12\r\n\x05value\x18\x02 \x01(\x05:\x02\x38\x01\"\x85\x02\n\rDeleteRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x15\n\rcollection_id\x18\x02 \x01(\x03\x12\x14\n\x0cpartition_id\x18\x03 \x01(\x03\x12\x15\n\rvchannel_name\x18\x04 \x01(\t\x12\x12\n\nsegment_id\x18\x05 \x01(\x03\x12.\n\x0cprimary_keys\x18\x06 \x01(\x0b\x32\x18.milvus.proto.schema.IDs\x12\x12\n\ntimestamps\x18\x07 \x03(\x04\x12,\n\x05scope\x18\x08 \x01(\x0e\x32\x1d.milvus.proto.query.DataScope\"W\n\x16\x41\x63tivateCheckerRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x11\n\tcheckerID\x18\x02 \x01(\x05\"Y\n\x18\x44\x65\x61\x63tivateCheckerRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x11\n\tcheckerID\x18\x02 \x01(\x05\"U\n\x13ListCheckersRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x12\n\ncheckerIDs\x18\x02 \x03(\x05\"z\n\x14ListCheckersResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\x35\n\x0c\x63heckerInfos\x18\x02 \x03(\x0b\x32\x1f.milvus.proto.query.CheckerInfo\"I\n\x0b\x43heckerInfo\x12\n\n\x02id\x18\x01 \x01(\x05\x12\x0c\n\x04\x64\x65sc\x18\x02 \x01(\t\x12\x11\n\tactivated\x18\x03 \x01(\x08\x12\r\n\x05\x66ound\x18\x04 \x01(\x08*+\n\tLoadScope\x12\x08\n\x04\x46ull\x10\x00\x12\t\n\x05\x44\x65lta\x10\x01\x12\t\n\x05Index\x10\x02*@\n\tDataScope\x12\x0b\n\x07UnKnown\x10\x00\x12\x07\n\x03\x41ll\x10\x01\x12\r\n\tStreaming\x10\x02\x12\x0e\n\nHistorical\x10\x03*z\n\x0ePartitionState\x12\x0c\n\x08NotExist\x10\x00\x12\x0e\n\nNotPresent\x10\x01\x12\n\n\x06OnDisk\x10\x02\x12\x13\n\x0fPartialInMemory\x10\x03\x12\x0c\n\x08InMemory\x10\x04\x12\x10\n\x0cPartialInGPU\x10\x05\x12\t\n\x05InGPU\x10\x06*d\n\x10TriggerCondition\x12\x13\n\x0fUnKnowCondition\x10\x00\x12\x0b\n\x07Handoff\x10\x01\x12\x0f\n\x0bLoadBalance\x10\x02\x12\x0f\n\x0bGrpcRequest\x10\x03\x12\x0c\n\x08NodeDown\x10\x04*B\n\x08LoadType\x12\x0f\n\x0bUnKnownType\x10\x00\x12\x11\n\rLoadPartition\x10\x01\x12\x12\n\x0eLoadCollection\x10\x02*2\n\nLoadStatus\x12\x0b\n\x07Invalid\x10\x00\x12\x0b\n\x07Loading\x10\x01\x12\n\n\x06Loaded\x10\x02*=\n\x08SyncType\x12\n\n\x06Remove\x10\x00\x12\x07\n\x03Set\x10\x01\x12\t\n\x05\x41mend\x10\x02\x12\x11\n\rUpdateVersion\x10\x03\x32\x8a\x16\n\nQueryCoord\x12l\n\x12GetComponentStates\x12..milvus.proto.milvus.GetComponentStatesRequest\x1a$.milvus.proto.milvus.ComponentStates\"\x00\x12m\n\x12GetTimeTickChannel\x12\x30.milvus.proto.internal.GetTimeTickChannelRequest\x1a#.milvus.proto.milvus.StringResponse\"\x00\x12q\n\x14GetStatisticsChannel\x12\x32.milvus.proto.internal.GetStatisticsChannelRequest\x1a#.milvus.proto.milvus.StringResponse\"\x00\x12l\n\x0fShowCollections\x12*.milvus.proto.query.ShowCollectionsRequest\x1a+.milvus.proto.query.ShowCollectionsResponse\"\x00\x12i\n\x0eShowPartitions\x12).milvus.proto.query.ShowPartitionsRequest\x1a*.milvus.proto.query.ShowPartitionsResponse\"\x00\x12Z\n\x0eLoadPartitions\x12).milvus.proto.query.LoadPartitionsRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12`\n\x11ReleasePartitions\x12,.milvus.proto.query.ReleasePartitionsRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12Z\n\x0eLoadCollection\x12).milvus.proto.query.LoadCollectionRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12`\n\x11ReleaseCollection\x12,.milvus.proto.query.ReleaseCollectionRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12l\n\x17SyncNewCreatedPartition\x12\x32.milvus.proto.query.SyncNewCreatedPartitionRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12u\n\x12GetPartitionStates\x12-.milvus.proto.query.GetPartitionStatesRequest\x1a..milvus.proto.query.GetPartitionStatesResponse\"\x00\x12i\n\x0eGetSegmentInfo\x12).milvus.proto.query.GetSegmentInfoRequest\x1a*.milvus.proto.query.GetSegmentInfoResponse\"\x00\x12T\n\x0bLoadBalance\x12&.milvus.proto.query.LoadBalanceRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12{\n\x12ShowConfigurations\x12\x30.milvus.proto.internal.ShowConfigurationsRequest\x1a\x31.milvus.proto.internal.ShowConfigurationsResponse\"\x00\x12_\n\nGetMetrics\x12&.milvus.proto.milvus.GetMetricsRequest\x1a\'.milvus.proto.milvus.GetMetricsResponse\"\x00\x12\x62\n\x0bGetReplicas\x12\'.milvus.proto.milvus.GetReplicasRequest\x1a(.milvus.proto.milvus.GetReplicasResponse\"\x00\x12l\n\x0fGetShardLeaders\x12*.milvus.proto.query.GetShardLeadersRequest\x1a+.milvus.proto.query.GetShardLeadersResponse\"\x00\x12\x62\n\x0b\x43heckHealth\x12\'.milvus.proto.milvus.CheckHealthRequest\x1a(.milvus.proto.milvus.CheckHealthResponse\"\x00\x12\x65\n\x13\x43reateResourceGroup\x12/.milvus.proto.milvus.CreateResourceGroupRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12\x61\n\x11\x44ropResourceGroup\x12-.milvus.proto.milvus.DropResourceGroupRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12W\n\x0cTransferNode\x12(.milvus.proto.milvus.TransferNodeRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12\\\n\x0fTransferReplica\x12*.milvus.proto.query.TransferReplicaRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12w\n\x12ListResourceGroups\x12..milvus.proto.milvus.ListResourceGroupsRequest\x1a/.milvus.proto.milvus.ListResourceGroupsResponse\"\x00\x12~\n\x15\x44\x65scribeResourceGroup\x12\x30.milvus.proto.query.DescribeResourceGroupRequest\x1a\x31.milvus.proto.query.DescribeResourceGroupResponse\"\x00\x12\x63\n\x0cListCheckers\x12\'.milvus.proto.query.ListCheckersRequest\x1a(.milvus.proto.query.ListCheckersResponse\"\x00\x12\\\n\x0f\x41\x63tivateChecker\x12*.milvus.proto.query.ActivateCheckerRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12`\n\x11\x44\x65\x61\x63tivateChecker\x12,.milvus.proto.query.DeactivateCheckerRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x32\xb4\x13\n\tQueryNode\x12l\n\x12GetComponentStates\x12..milvus.proto.milvus.GetComponentStatesRequest\x1a$.milvus.proto.milvus.ComponentStates\"\x00\x12m\n\x12GetTimeTickChannel\x12\x30.milvus.proto.internal.GetTimeTickChannelRequest\x1a#.milvus.proto.milvus.StringResponse\"\x00\x12q\n\x14GetStatisticsChannel\x12\x32.milvus.proto.internal.GetStatisticsChannelRequest\x1a#.milvus.proto.milvus.StringResponse\"\x00\x12\\\n\x0fWatchDmChannels\x12*.milvus.proto.query.WatchDmChannelsRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12Z\n\x0eUnsubDmChannel\x12).milvus.proto.query.UnsubDmChannelRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12V\n\x0cLoadSegments\x12\'.milvus.proto.query.LoadSegmentsRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12`\n\x11ReleaseCollection\x12,.milvus.proto.query.ReleaseCollectionRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12Z\n\x0eLoadPartitions\x12).milvus.proto.query.LoadPartitionsRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12`\n\x11ReleasePartitions\x12,.milvus.proto.query.ReleasePartitionsRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12\\\n\x0fReleaseSegments\x12*.milvus.proto.query.ReleaseSegmentsRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12i\n\x0eGetSegmentInfo\x12).milvus.proto.query.GetSegmentInfoRequest\x1a*.milvus.proto.query.GetSegmentInfoResponse\"\x00\x12\x64\n\x13SyncReplicaSegments\x12..milvus.proto.query.SyncReplicaSegmentsRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12i\n\rGetStatistics\x12(.milvus.proto.query.GetStatisticsRequest\x1a,.milvus.proto.internal.GetStatisticsResponse\"\x00\x12S\n\x06Search\x12!.milvus.proto.query.SearchRequest\x1a$.milvus.proto.internal.SearchResults\"\x00\x12\x61\n\x0cHybridSearch\x12\'.milvus.proto.query.HybridSearchRequest\x1a&.milvus.proto.query.HybridSearchResult\"\x00\x12[\n\x0eSearchSegments\x12!.milvus.proto.query.SearchRequest\x1a$.milvus.proto.internal.SearchResults\"\x00\x12S\n\x05Query\x12 .milvus.proto.query.QueryRequest\x1a&.milvus.proto.internal.RetrieveResults\"\x00\x12[\n\x0bQueryStream\x12 .milvus.proto.query.QueryRequest\x1a&.milvus.proto.internal.RetrieveResults\"\x00\x30\x01\x12[\n\rQuerySegments\x12 .milvus.proto.query.QueryRequest\x1a&.milvus.proto.internal.RetrieveResults\"\x00\x12\x63\n\x13QueryStreamSegments\x12 .milvus.proto.query.QueryRequest\x1a&.milvus.proto.internal.RetrieveResults\"\x00\x30\x01\x12{\n\x12ShowConfigurations\x12\x30.milvus.proto.internal.ShowConfigurationsRequest\x1a\x31.milvus.proto.internal.ShowConfigurationsResponse\"\x00\x12_\n\nGetMetrics\x12&.milvus.proto.milvus.GetMetricsRequest\x1a\'.milvus.proto.milvus.GetMetricsResponse\"\x00\x12x\n\x13GetDataDistribution\x12..milvus.proto.query.GetDataDistributionRequest\x1a/.milvus.proto.query.GetDataDistributionResponse\"\x00\x12^\n\x10SyncDistribution\x12+.milvus.proto.query.SyncDistributionRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12J\n\x06\x44\x65lete\x12!.milvus.proto.query.DeleteRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x42\x34Z2github.com/milvus-io/milvus/internal/proto/querypbb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'query_coord_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + _globals['DESCRIPTOR']._options = None + _globals['DESCRIPTOR']._serialized_options = b'Z2github.com/milvus-io/milvus/internal/proto/querypb' + _globals['_LOADCOLLECTIONREQUEST_FIELDINDEXIDENTRY']._options = None + _globals['_LOADCOLLECTIONREQUEST_FIELDINDEXIDENTRY']._serialized_options = b'8\001' + _globals['_LOADPARTITIONSREQUEST_FIELDINDEXIDENTRY']._options = None + _globals['_LOADPARTITIONSREQUEST_FIELDINDEXIDENTRY']._serialized_options = b'8\001' + _globals['_LOADMETAINFO'].fields_by_name['metric_type']._options = None + _globals['_LOADMETAINFO'].fields_by_name['metric_type']._serialized_options = b'\030\001' + _globals['_WATCHDMCHANNELSREQUEST_SEGMENTINFOSENTRY']._options = None + _globals['_WATCHDMCHANNELSREQUEST_SEGMENTINFOSENTRY']._serialized_options = b'8\001' + _globals['_HYBRIDSEARCHRESULT_CHANNELSMVCCENTRY']._options = None + _globals['_HYBRIDSEARCHRESULT_CHANNELSMVCCENTRY']._serialized_options = b'8\001' + _globals['_GETDATADISTRIBUTIONREQUEST_CHECKPOINTSENTRY']._options = None + _globals['_GETDATADISTRIBUTIONREQUEST_CHECKPOINTSENTRY']._serialized_options = b'8\001' + _globals['_LEADERVIEW_SEGMENTDISTENTRY']._options = None + _globals['_LEADERVIEW_SEGMENTDISTENTRY']._serialized_options = b'8\001' + _globals['_LEADERVIEW_GROWINGSEGMENTSENTRY']._options = None + _globals['_LEADERVIEW_GROWINGSEGMENTSENTRY']._serialized_options = b'8\001' + _globals['_SEGMENTVERSIONINFO_INDEXINFOENTRY']._options = None + _globals['_SEGMENTVERSIONINFO_INDEXINFOENTRY']._serialized_options = b'8\001' + _globals['_COLLECTIONLOADINFO_FIELDINDEXIDENTRY']._options = None + _globals['_COLLECTIONLOADINFO_FIELDINDEXIDENTRY']._serialized_options = b'8\001' + _globals['_PARTITIONLOADINFO_FIELDINDEXIDENTRY']._options = None + _globals['_PARTITIONLOADINFO_FIELDINDEXIDENTRY']._serialized_options = b'8\001' + _globals['_RESOURCEGROUPINFO_NUMLOADEDREPLICAENTRY']._options = None + _globals['_RESOURCEGROUPINFO_NUMLOADEDREPLICAENTRY']._serialized_options = b'8\001' + _globals['_RESOURCEGROUPINFO_NUMOUTGOINGNODEENTRY']._options = None + _globals['_RESOURCEGROUPINFO_NUMOUTGOINGNODEENTRY']._serialized_options = b'8\001' + _globals['_RESOURCEGROUPINFO_NUMINCOMINGNODEENTRY']._options = None + _globals['_RESOURCEGROUPINFO_NUMINCOMINGNODEENTRY']._serialized_options = b'8\001' + _globals['_LOADSCOPE']._serialized_start=13591 + _globals['_LOADSCOPE']._serialized_end=13634 + _globals['_DATASCOPE']._serialized_start=13636 + _globals['_DATASCOPE']._serialized_end=13700 + _globals['_PARTITIONSTATE']._serialized_start=13702 + _globals['_PARTITIONSTATE']._serialized_end=13824 + _globals['_TRIGGERCONDITION']._serialized_start=13826 + _globals['_TRIGGERCONDITION']._serialized_end=13926 + _globals['_LOADTYPE']._serialized_start=13928 + _globals['_LOADTYPE']._serialized_end=13994 + _globals['_LOADSTATUS']._serialized_start=13996 + _globals['_LOADSTATUS']._serialized_end=14046 + _globals['_SYNCTYPE']._serialized_start=14048 + _globals['_SYNCTYPE']._serialized_end=14109 + _globals['_SHOWCOLLECTIONSREQUEST']._serialized_start=147 + _globals['_SHOWCOLLECTIONSREQUEST']._serialized_end=252 + _globals['_SHOWCOLLECTIONSRESPONSE']._serialized_start=255 + _globals['_SHOWCOLLECTIONSRESPONSE']._serialized_end=437 + _globals['_SHOWPARTITIONSREQUEST']._serialized_start=439 + _globals['_SHOWPARTITIONSREQUEST']._serialized_end=564 + _globals['_SHOWPARTITIONSRESPONSE']._serialized_start=567 + _globals['_SHOWPARTITIONSRESPONSE']._serialized_end=714 + _globals['_LOADCOLLECTIONREQUEST']._serialized_start=717 + _globals['_LOADCOLLECTIONREQUEST']._serialized_end=1078 + _globals['_LOADCOLLECTIONREQUEST_FIELDINDEXIDENTRY']._serialized_start=1027 + _globals['_LOADCOLLECTIONREQUEST_FIELDINDEXIDENTRY']._serialized_end=1078 + _globals['_RELEASECOLLECTIONREQUEST']._serialized_start=1080 + _globals['_RELEASECOLLECTIONREQUEST']._serialized_end=1202 + _globals['_GETSTATISTICSREQUEST']._serialized_start=1205 + _globals['_GETSTATISTICSREQUEST']._serialized_end=1400 + _globals['_LOADPARTITIONSREQUEST']._serialized_start=1403 + _globals['_LOADPARTITIONSREQUEST']._serialized_end=1842 + _globals['_LOADPARTITIONSREQUEST_FIELDINDEXIDENTRY']._serialized_start=1027 + _globals['_LOADPARTITIONSREQUEST_FIELDINDEXIDENTRY']._serialized_end=1078 + _globals['_RELEASEPARTITIONSREQUEST']._serialized_start=1845 + _globals['_RELEASEPARTITIONSREQUEST']._serialized_end=1989 + _globals['_GETPARTITIONSTATESREQUEST']._serialized_start=1992 + _globals['_GETPARTITIONSTATESREQUEST']._serialized_end=2121 + _globals['_GETPARTITIONSTATESRESPONSE']._serialized_start=2124 + _globals['_GETPARTITIONSTATESRESPONSE']._serialized_end=2266 + _globals['_GETSEGMENTINFOREQUEST']._serialized_start=2268 + _globals['_GETSEGMENTINFOREQUEST']._serialized_end=2377 + _globals['_GETSEGMENTINFORESPONSE']._serialized_start=2379 + _globals['_GETSEGMENTINFORESPONSE']._serialized_end=2496 + _globals['_GETSHARDLEADERSREQUEST']._serialized_start=2498 + _globals['_GETSHARDLEADERSREQUEST']._serialized_end=2588 + _globals['_GETSHARDLEADERSRESPONSE']._serialized_start=2590 + _globals['_GETSHARDLEADERSRESPONSE']._serialized_end=2714 + _globals['_SHARDLEADERSLIST']._serialized_start=2716 + _globals['_SHARDLEADERSLIST']._serialized_end=2794 + _globals['_SYNCNEWCREATEDPARTITIONREQUEST']._serialized_start=2796 + _globals['_SYNCNEWCREATEDPARTITIONREQUEST']._serialized_end=2915 + _globals['_LOADMETAINFO']._serialized_start=2918 + _globals['_LOADMETAINFO']._serialized_end=3050 + _globals['_WATCHDMCHANNELSREQUEST']._serialized_start=3053 + _globals['_WATCHDMCHANNELSREQUEST']._serialized_end=3677 + _globals['_WATCHDMCHANNELSREQUEST_SEGMENTINFOSENTRY']._serialized_start=3594 + _globals['_WATCHDMCHANNELSREQUEST_SEGMENTINFOSENTRY']._serialized_end=3677 + _globals['_UNSUBDMCHANNELREQUEST']._serialized_start=3679 + _globals['_UNSUBDMCHANNELREQUEST']._serialized_end=3806 + _globals['_SEGMENTLOADINFO']._serialized_start=3809 + _globals['_SEGMENTLOADINFO']._serialized_end=4433 + _globals['_FIELDINDEXINFO']._serialized_start=4436 + _globals['_FIELDINDEXINFO']._serialized_end=4749 + _globals['_LOADSEGMENTSREQUEST']._serialized_start=4752 + _globals['_LOADSEGMENTSREQUEST']._serialized_end=5283 + _globals['_RELEASESEGMENTSREQUEST']._serialized_start=5286 + _globals['_RELEASESEGMENTSREQUEST']._serialized_end=5532 + _globals['_SEARCHREQUEST']._serialized_start=5535 + _globals['_SEARCHREQUEST']._serialized_end=5743 + _globals['_HYBRIDSEARCHREQUEST']._serialized_start=5745 + _globals['_HYBRIDSEARCHREQUEST']._serialized_end=5872 + _globals['_HYBRIDSEARCHRESULT']._serialized_start=5875 + _globals['_HYBRIDSEARCHRESULT']._serialized_end=6238 + _globals['_HYBRIDSEARCHRESULT_CHANNELSMVCCENTRY']._serialized_start=6187 + _globals['_HYBRIDSEARCHRESULT_CHANNELSMVCCENTRY']._serialized_end=6238 + _globals['_QUERYREQUEST']._serialized_start=6241 + _globals['_QUERYREQUEST']._serialized_end=6423 + _globals['_SYNCREPLICASEGMENTSREQUEST']._serialized_start=6426 + _globals['_SYNCREPLICASEGMENTSREQUEST']._serialized_end=6588 + _globals['_REPLICASEGMENTSINFO']._serialized_start=6590 + _globals['_REPLICASEGMENTSINFO']._serialized_end=6689 + _globals['_GETLOADINFOREQUEST']._serialized_start=6691 + _globals['_GETLOADINFOREQUEST']._serialized_end=6778 + _globals['_GETLOADINFORESPONSE']._serialized_start=6781 + _globals['_GETLOADINFORESPONSE']._serialized_end=6971 + _globals['_HANDOFFSEGMENTSREQUEST']._serialized_start=6974 + _globals['_HANDOFFSEGMENTSREQUEST']._serialized_end=7124 + _globals['_LOADBALANCEREQUEST']._serialized_start=7127 + _globals['_LOADBALANCEREQUEST']._serialized_end=7347 + _globals['_DMCHANNELWATCHINFO']._serialized_start=7349 + _globals['_DMCHANNELWATCHINFO']._serialized_end=7470 + _globals['_QUERYCHANNELINFO']._serialized_start=7473 + _globals['_QUERYCHANNELINFO']._serialized_end=7685 + _globals['_PARTITIONSTATES']._serialized_start=7687 + _globals['_PARTITIONSTATES']._serialized_end=7805 + _globals['_SEGMENTINFO']._serialized_start=7808 + _globals['_SEGMENTINFO']._serialized_end=8237 + _globals['_COLLECTIONINFO']._serialized_start=8240 + _globals['_COLLECTIONINFO']._serialized_end=8572 + _globals['_UNSUBSCRIBECHANNELS']._serialized_start=8574 + _globals['_UNSUBSCRIBECHANNELS']._serialized_end=8635 + _globals['_UNSUBSCRIBECHANNELINFO']._serialized_start=8637 + _globals['_UNSUBSCRIBECHANNELINFO']._serialized_end=8747 + _globals['_SEGMENTCHANGEINFO']._serialized_start=8750 + _globals['_SEGMENTCHANGEINFO']._serialized_end=8933 + _globals['_SEALEDSEGMENTSCHANGEINFO']._serialized_start=8935 + _globals['_SEALEDSEGMENTSCHANGEINFO']._serialized_end=9059 + _globals['_GETDATADISTRIBUTIONREQUEST']._serialized_start=9062 + _globals['_GETDATADISTRIBUTIONREQUEST']._serialized_end=9303 + _globals['_GETDATADISTRIBUTIONREQUEST_CHECKPOINTSENTRY']._serialized_start=9222 + _globals['_GETDATADISTRIBUTIONREQUEST_CHECKPOINTSENTRY']._serialized_end=9303 + _globals['_GETDATADISTRIBUTIONRESPONSE']._serialized_start=9306 + _globals['_GETDATADISTRIBUTIONRESPONSE']._serialized_end=9566 + _globals['_LEADERVIEW']._serialized_start=9569 + _globals['_LEADERVIEW']._serialized_end=10020 + _globals['_LEADERVIEW_SEGMENTDISTENTRY']._serialized_start=9850 + _globals['_LEADERVIEW_SEGMENTDISTENTRY']._serialized_end=9933 + _globals['_LEADERVIEW_GROWINGSEGMENTSENTRY']._serialized_start=9935 + _globals['_LEADERVIEW_GROWINGSEGMENTSENTRY']._serialized_end=10020 + _globals['_SEGMENTDIST']._serialized_start=10022 + _globals['_SEGMENTDIST']._serialized_end=10068 + _globals['_SEGMENTVERSIONINFO']._serialized_start=10071 + _globals['_SEGMENTVERSIONINFO']._serialized_end=10367 + _globals['_SEGMENTVERSIONINFO_INDEXINFOENTRY']._serialized_start=10283 + _globals['_SEGMENTVERSIONINFO_INDEXINFOENTRY']._serialized_end=10367 + _globals['_CHANNELVERSIONINFO']._serialized_start=10369 + _globals['_CHANNELVERSIONINFO']._serialized_end=10443 + _globals['_COLLECTIONLOADINFO']._serialized_start=10446 + _globals['_COLLECTIONLOADINFO']._serialized_end=10795 + _globals['_COLLECTIONLOADINFO_FIELDINDEXIDENTRY']._serialized_start=1027 + _globals['_COLLECTIONLOADINFO_FIELDINDEXIDENTRY']._serialized_end=1078 + _globals['_PARTITIONLOADINFO']._serialized_start=10798 + _globals['_PARTITIONLOADINFO']._serialized_end=11088 + _globals['_PARTITIONLOADINFO_FIELDINDEXIDENTRY']._serialized_start=1027 + _globals['_PARTITIONLOADINFO_FIELDINDEXIDENTRY']._serialized_end=1078 + _globals['_REPLICA']._serialized_start=11090 + _globals['_REPLICA']._serialized_end=11172 + _globals['_SYNCACTION']._serialized_start=11175 + _globals['_SYNCACTION']._serialized_end=11503 + _globals['_SYNCDISTRIBUTIONREQUEST']._serialized_start=11506 + _globals['_SYNCDISTRIBUTIONREQUEST']._serialized_end=11863 + _globals['_RESOURCEGROUP']._serialized_start=11865 + _globals['_RESOURCEGROUP']._serialized_end=11927 + _globals['_TRANSFERREPLICAREQUEST']._serialized_start=11930 + _globals['_TRANSFERREPLICAREQUEST']._serialized_end=12103 + _globals['_DESCRIBERESOURCEGROUPREQUEST']._serialized_start=12105 + _globals['_DESCRIBERESOURCEGROUPREQUEST']._serialized_end=12203 + _globals['_DESCRIBERESOURCEGROUPRESPONSE']._serialized_start=12206 + _globals['_DESCRIBERESOURCEGROUPRESPONSE']._serialized_end=12345 + _globals['_RESOURCEGROUPINFO']._serialized_start=12348 + _globals['_RESOURCEGROUPINFO']._serialized_end=12859 + _globals['_RESOURCEGROUPINFO_NUMLOADEDREPLICAENTRY']._serialized_start=12692 + _globals['_RESOURCEGROUPINFO_NUMLOADEDREPLICAENTRY']._serialized_end=12747 + _globals['_RESOURCEGROUPINFO_NUMOUTGOINGNODEENTRY']._serialized_start=12749 + _globals['_RESOURCEGROUPINFO_NUMOUTGOINGNODEENTRY']._serialized_end=12803 + _globals['_RESOURCEGROUPINFO_NUMINCOMINGNODEENTRY']._serialized_start=12805 + _globals['_RESOURCEGROUPINFO_NUMINCOMINGNODEENTRY']._serialized_end=12859 + _globals['_DELETEREQUEST']._serialized_start=12862 + _globals['_DELETEREQUEST']._serialized_end=13123 + _globals['_ACTIVATECHECKERREQUEST']._serialized_start=13125 + _globals['_ACTIVATECHECKERREQUEST']._serialized_end=13212 + _globals['_DEACTIVATECHECKERREQUEST']._serialized_start=13214 + _globals['_DEACTIVATECHECKERREQUEST']._serialized_end=13303 + _globals['_LISTCHECKERSREQUEST']._serialized_start=13305 + _globals['_LISTCHECKERSREQUEST']._serialized_end=13390 + _globals['_LISTCHECKERSRESPONSE']._serialized_start=13392 + _globals['_LISTCHECKERSRESPONSE']._serialized_end=13514 + _globals['_CHECKERINFO']._serialized_start=13516 + _globals['_CHECKERINFO']._serialized_end=13589 + _globals['_QUERYCOORD']._serialized_start=14112 + _globals['_QUERYCOORD']._serialized_end=16938 + _globals['_QUERYNODE']._serialized_start=16941 + _globals['_QUERYNODE']._serialized_end=19425 +# @@protoc_insertion_point(module_scope) diff --git a/milvus_connector/protocol/query_coord_pb2.pyi b/milvus_connector/protocol/query_coord_pb2.pyi new file mode 100644 index 0000000..7e288ca --- /dev/null +++ b/milvus_connector/protocol/query_coord_pb2.pyi @@ -0,0 +1,1112 @@ +from . import common_pb2 as _common_pb2 +from . import milvus_pb2 as _milvus_pb2 +from . import internal_pb2 as _internal_pb2 +from . import schema_pb2 as _schema_pb2 +from . import msg_pb2 as _msg_pb2 +from . import data_coord_pb2 as _data_coord_pb2 +from . import index_coord_pb2 as _index_coord_pb2 +from google.protobuf.internal import containers as _containers +from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Iterable as _Iterable, Mapping as _Mapping, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class LoadScope(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = () + Full: _ClassVar[LoadScope] + Delta: _ClassVar[LoadScope] + Index: _ClassVar[LoadScope] + +class DataScope(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = () + UnKnown: _ClassVar[DataScope] + All: _ClassVar[DataScope] + Streaming: _ClassVar[DataScope] + Historical: _ClassVar[DataScope] + +class PartitionState(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = () + NotExist: _ClassVar[PartitionState] + NotPresent: _ClassVar[PartitionState] + OnDisk: _ClassVar[PartitionState] + PartialInMemory: _ClassVar[PartitionState] + InMemory: _ClassVar[PartitionState] + PartialInGPU: _ClassVar[PartitionState] + InGPU: _ClassVar[PartitionState] + +class TriggerCondition(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = () + UnKnowCondition: _ClassVar[TriggerCondition] + Handoff: _ClassVar[TriggerCondition] + LoadBalance: _ClassVar[TriggerCondition] + GrpcRequest: _ClassVar[TriggerCondition] + NodeDown: _ClassVar[TriggerCondition] + +class LoadType(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = () + UnKnownType: _ClassVar[LoadType] + LoadPartition: _ClassVar[LoadType] + LoadCollection: _ClassVar[LoadType] + +class LoadStatus(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = () + Invalid: _ClassVar[LoadStatus] + Loading: _ClassVar[LoadStatus] + Loaded: _ClassVar[LoadStatus] + +class SyncType(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = () + Remove: _ClassVar[SyncType] + Set: _ClassVar[SyncType] + Amend: _ClassVar[SyncType] + UpdateVersion: _ClassVar[SyncType] +Full: LoadScope +Delta: LoadScope +Index: LoadScope +UnKnown: DataScope +All: DataScope +Streaming: DataScope +Historical: DataScope +NotExist: PartitionState +NotPresent: PartitionState +OnDisk: PartitionState +PartialInMemory: PartitionState +InMemory: PartitionState +PartialInGPU: PartitionState +InGPU: PartitionState +UnKnowCondition: TriggerCondition +Handoff: TriggerCondition +LoadBalance: TriggerCondition +GrpcRequest: TriggerCondition +NodeDown: TriggerCondition +UnKnownType: LoadType +LoadPartition: LoadType +LoadCollection: LoadType +Invalid: LoadStatus +Loading: LoadStatus +Loaded: LoadStatus +Remove: SyncType +Set: SyncType +Amend: SyncType +UpdateVersion: SyncType + +class ShowCollectionsRequest(_message.Message): + __slots__ = ("base", "dbID", "collectionIDs") + BASE_FIELD_NUMBER: _ClassVar[int] + DBID_FIELD_NUMBER: _ClassVar[int] + COLLECTIONIDS_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + dbID: int + collectionIDs: _containers.RepeatedScalarFieldContainer[int] + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., dbID: _Optional[int] = ..., collectionIDs: _Optional[_Iterable[int]] = ...) -> None: ... + +class ShowCollectionsResponse(_message.Message): + __slots__ = ("status", "collectionIDs", "inMemory_percentages", "query_service_available", "refresh_progress") + STATUS_FIELD_NUMBER: _ClassVar[int] + COLLECTIONIDS_FIELD_NUMBER: _ClassVar[int] + INMEMORY_PERCENTAGES_FIELD_NUMBER: _ClassVar[int] + QUERY_SERVICE_AVAILABLE_FIELD_NUMBER: _ClassVar[int] + REFRESH_PROGRESS_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + collectionIDs: _containers.RepeatedScalarFieldContainer[int] + inMemory_percentages: _containers.RepeatedScalarFieldContainer[int] + query_service_available: _containers.RepeatedScalarFieldContainer[bool] + refresh_progress: _containers.RepeatedScalarFieldContainer[int] + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., collectionIDs: _Optional[_Iterable[int]] = ..., inMemory_percentages: _Optional[_Iterable[int]] = ..., query_service_available: _Optional[_Iterable[bool]] = ..., refresh_progress: _Optional[_Iterable[int]] = ...) -> None: ... + +class ShowPartitionsRequest(_message.Message): + __slots__ = ("base", "dbID", "collectionID", "partitionIDs") + BASE_FIELD_NUMBER: _ClassVar[int] + DBID_FIELD_NUMBER: _ClassVar[int] + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + PARTITIONIDS_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + dbID: int + collectionID: int + partitionIDs: _containers.RepeatedScalarFieldContainer[int] + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., dbID: _Optional[int] = ..., collectionID: _Optional[int] = ..., partitionIDs: _Optional[_Iterable[int]] = ...) -> None: ... + +class ShowPartitionsResponse(_message.Message): + __slots__ = ("status", "partitionIDs", "inMemory_percentages", "refresh_progress") + STATUS_FIELD_NUMBER: _ClassVar[int] + PARTITIONIDS_FIELD_NUMBER: _ClassVar[int] + INMEMORY_PERCENTAGES_FIELD_NUMBER: _ClassVar[int] + REFRESH_PROGRESS_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + partitionIDs: _containers.RepeatedScalarFieldContainer[int] + inMemory_percentages: _containers.RepeatedScalarFieldContainer[int] + refresh_progress: _containers.RepeatedScalarFieldContainer[int] + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., partitionIDs: _Optional[_Iterable[int]] = ..., inMemory_percentages: _Optional[_Iterable[int]] = ..., refresh_progress: _Optional[_Iterable[int]] = ...) -> None: ... + +class LoadCollectionRequest(_message.Message): + __slots__ = ("base", "dbID", "collectionID", "schema", "replica_number", "field_indexID", "refresh", "resource_groups") + class FieldIndexIDEntry(_message.Message): + __slots__ = ("key", "value") + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: int + value: int + def __init__(self, key: _Optional[int] = ..., value: _Optional[int] = ...) -> None: ... + BASE_FIELD_NUMBER: _ClassVar[int] + DBID_FIELD_NUMBER: _ClassVar[int] + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + SCHEMA_FIELD_NUMBER: _ClassVar[int] + REPLICA_NUMBER_FIELD_NUMBER: _ClassVar[int] + FIELD_INDEXID_FIELD_NUMBER: _ClassVar[int] + REFRESH_FIELD_NUMBER: _ClassVar[int] + RESOURCE_GROUPS_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + dbID: int + collectionID: int + schema: _schema_pb2.CollectionSchema + replica_number: int + field_indexID: _containers.ScalarMap[int, int] + refresh: bool + resource_groups: _containers.RepeatedScalarFieldContainer[str] + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., dbID: _Optional[int] = ..., collectionID: _Optional[int] = ..., schema: _Optional[_Union[_schema_pb2.CollectionSchema, _Mapping]] = ..., replica_number: _Optional[int] = ..., field_indexID: _Optional[_Mapping[int, int]] = ..., refresh: bool = ..., resource_groups: _Optional[_Iterable[str]] = ...) -> None: ... + +class ReleaseCollectionRequest(_message.Message): + __slots__ = ("base", "dbID", "collectionID", "nodeID") + BASE_FIELD_NUMBER: _ClassVar[int] + DBID_FIELD_NUMBER: _ClassVar[int] + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + NODEID_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + dbID: int + collectionID: int + nodeID: int + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., dbID: _Optional[int] = ..., collectionID: _Optional[int] = ..., nodeID: _Optional[int] = ...) -> None: ... + +class GetStatisticsRequest(_message.Message): + __slots__ = ("req", "dml_channels", "segmentIDs", "from_shard_leader", "scope") + REQ_FIELD_NUMBER: _ClassVar[int] + DML_CHANNELS_FIELD_NUMBER: _ClassVar[int] + SEGMENTIDS_FIELD_NUMBER: _ClassVar[int] + FROM_SHARD_LEADER_FIELD_NUMBER: _ClassVar[int] + SCOPE_FIELD_NUMBER: _ClassVar[int] + req: _internal_pb2.GetStatisticsRequest + dml_channels: _containers.RepeatedScalarFieldContainer[str] + segmentIDs: _containers.RepeatedScalarFieldContainer[int] + from_shard_leader: bool + scope: DataScope + def __init__(self, req: _Optional[_Union[_internal_pb2.GetStatisticsRequest, _Mapping]] = ..., dml_channels: _Optional[_Iterable[str]] = ..., segmentIDs: _Optional[_Iterable[int]] = ..., from_shard_leader: bool = ..., scope: _Optional[_Union[DataScope, str]] = ...) -> None: ... + +class LoadPartitionsRequest(_message.Message): + __slots__ = ("base", "dbID", "collectionID", "partitionIDs", "schema", "replica_number", "field_indexID", "refresh", "resource_groups", "index_info_list") + class FieldIndexIDEntry(_message.Message): + __slots__ = ("key", "value") + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: int + value: int + def __init__(self, key: _Optional[int] = ..., value: _Optional[int] = ...) -> None: ... + BASE_FIELD_NUMBER: _ClassVar[int] + DBID_FIELD_NUMBER: _ClassVar[int] + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + PARTITIONIDS_FIELD_NUMBER: _ClassVar[int] + SCHEMA_FIELD_NUMBER: _ClassVar[int] + REPLICA_NUMBER_FIELD_NUMBER: _ClassVar[int] + FIELD_INDEXID_FIELD_NUMBER: _ClassVar[int] + REFRESH_FIELD_NUMBER: _ClassVar[int] + RESOURCE_GROUPS_FIELD_NUMBER: _ClassVar[int] + INDEX_INFO_LIST_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + dbID: int + collectionID: int + partitionIDs: _containers.RepeatedScalarFieldContainer[int] + schema: _schema_pb2.CollectionSchema + replica_number: int + field_indexID: _containers.ScalarMap[int, int] + refresh: bool + resource_groups: _containers.RepeatedScalarFieldContainer[str] + index_info_list: _containers.RepeatedCompositeFieldContainer[_index_coord_pb2.IndexInfo] + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., dbID: _Optional[int] = ..., collectionID: _Optional[int] = ..., partitionIDs: _Optional[_Iterable[int]] = ..., schema: _Optional[_Union[_schema_pb2.CollectionSchema, _Mapping]] = ..., replica_number: _Optional[int] = ..., field_indexID: _Optional[_Mapping[int, int]] = ..., refresh: bool = ..., resource_groups: _Optional[_Iterable[str]] = ..., index_info_list: _Optional[_Iterable[_Union[_index_coord_pb2.IndexInfo, _Mapping]]] = ...) -> None: ... + +class ReleasePartitionsRequest(_message.Message): + __slots__ = ("base", "dbID", "collectionID", "partitionIDs", "nodeID") + BASE_FIELD_NUMBER: _ClassVar[int] + DBID_FIELD_NUMBER: _ClassVar[int] + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + PARTITIONIDS_FIELD_NUMBER: _ClassVar[int] + NODEID_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + dbID: int + collectionID: int + partitionIDs: _containers.RepeatedScalarFieldContainer[int] + nodeID: int + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., dbID: _Optional[int] = ..., collectionID: _Optional[int] = ..., partitionIDs: _Optional[_Iterable[int]] = ..., nodeID: _Optional[int] = ...) -> None: ... + +class GetPartitionStatesRequest(_message.Message): + __slots__ = ("base", "dbID", "collectionID", "partitionIDs") + BASE_FIELD_NUMBER: _ClassVar[int] + DBID_FIELD_NUMBER: _ClassVar[int] + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + PARTITIONIDS_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + dbID: int + collectionID: int + partitionIDs: _containers.RepeatedScalarFieldContainer[int] + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., dbID: _Optional[int] = ..., collectionID: _Optional[int] = ..., partitionIDs: _Optional[_Iterable[int]] = ...) -> None: ... + +class GetPartitionStatesResponse(_message.Message): + __slots__ = ("status", "partition_descriptions") + STATUS_FIELD_NUMBER: _ClassVar[int] + PARTITION_DESCRIPTIONS_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + partition_descriptions: _containers.RepeatedCompositeFieldContainer[PartitionStates] + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., partition_descriptions: _Optional[_Iterable[_Union[PartitionStates, _Mapping]]] = ...) -> None: ... + +class GetSegmentInfoRequest(_message.Message): + __slots__ = ("base", "segmentIDs", "collectionID") + BASE_FIELD_NUMBER: _ClassVar[int] + SEGMENTIDS_FIELD_NUMBER: _ClassVar[int] + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + segmentIDs: _containers.RepeatedScalarFieldContainer[int] + collectionID: int + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., segmentIDs: _Optional[_Iterable[int]] = ..., collectionID: _Optional[int] = ...) -> None: ... + +class GetSegmentInfoResponse(_message.Message): + __slots__ = ("status", "infos") + STATUS_FIELD_NUMBER: _ClassVar[int] + INFOS_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + infos: _containers.RepeatedCompositeFieldContainer[SegmentInfo] + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., infos: _Optional[_Iterable[_Union[SegmentInfo, _Mapping]]] = ...) -> None: ... + +class GetShardLeadersRequest(_message.Message): + __slots__ = ("base", "collectionID") + BASE_FIELD_NUMBER: _ClassVar[int] + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + collectionID: int + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., collectionID: _Optional[int] = ...) -> None: ... + +class GetShardLeadersResponse(_message.Message): + __slots__ = ("status", "shards") + STATUS_FIELD_NUMBER: _ClassVar[int] + SHARDS_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + shards: _containers.RepeatedCompositeFieldContainer[ShardLeadersList] + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., shards: _Optional[_Iterable[_Union[ShardLeadersList, _Mapping]]] = ...) -> None: ... + +class ShardLeadersList(_message.Message): + __slots__ = ("channel_name", "node_ids", "node_addrs") + CHANNEL_NAME_FIELD_NUMBER: _ClassVar[int] + NODE_IDS_FIELD_NUMBER: _ClassVar[int] + NODE_ADDRS_FIELD_NUMBER: _ClassVar[int] + channel_name: str + node_ids: _containers.RepeatedScalarFieldContainer[int] + node_addrs: _containers.RepeatedScalarFieldContainer[str] + def __init__(self, channel_name: _Optional[str] = ..., node_ids: _Optional[_Iterable[int]] = ..., node_addrs: _Optional[_Iterable[str]] = ...) -> None: ... + +class SyncNewCreatedPartitionRequest(_message.Message): + __slots__ = ("base", "collectionID", "partitionID") + BASE_FIELD_NUMBER: _ClassVar[int] + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + PARTITIONID_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + collectionID: int + partitionID: int + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., collectionID: _Optional[int] = ..., partitionID: _Optional[int] = ...) -> None: ... + +class LoadMetaInfo(_message.Message): + __slots__ = ("load_type", "collectionID", "partitionIDs", "metric_type") + LOAD_TYPE_FIELD_NUMBER: _ClassVar[int] + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + PARTITIONIDS_FIELD_NUMBER: _ClassVar[int] + METRIC_TYPE_FIELD_NUMBER: _ClassVar[int] + load_type: LoadType + collectionID: int + partitionIDs: _containers.RepeatedScalarFieldContainer[int] + metric_type: str + def __init__(self, load_type: _Optional[_Union[LoadType, str]] = ..., collectionID: _Optional[int] = ..., partitionIDs: _Optional[_Iterable[int]] = ..., metric_type: _Optional[str] = ...) -> None: ... + +class WatchDmChannelsRequest(_message.Message): + __slots__ = ("base", "nodeID", "collectionID", "partitionIDs", "infos", "schema", "exclude_infos", "load_meta", "replicaID", "segment_infos", "offlineNodeID", "version", "index_info_list") + class SegmentInfosEntry(_message.Message): + __slots__ = ("key", "value") + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: int + value: _data_coord_pb2.SegmentInfo + def __init__(self, key: _Optional[int] = ..., value: _Optional[_Union[_data_coord_pb2.SegmentInfo, _Mapping]] = ...) -> None: ... + BASE_FIELD_NUMBER: _ClassVar[int] + NODEID_FIELD_NUMBER: _ClassVar[int] + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + PARTITIONIDS_FIELD_NUMBER: _ClassVar[int] + INFOS_FIELD_NUMBER: _ClassVar[int] + SCHEMA_FIELD_NUMBER: _ClassVar[int] + EXCLUDE_INFOS_FIELD_NUMBER: _ClassVar[int] + LOAD_META_FIELD_NUMBER: _ClassVar[int] + REPLICAID_FIELD_NUMBER: _ClassVar[int] + SEGMENT_INFOS_FIELD_NUMBER: _ClassVar[int] + OFFLINENODEID_FIELD_NUMBER: _ClassVar[int] + VERSION_FIELD_NUMBER: _ClassVar[int] + INDEX_INFO_LIST_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + nodeID: int + collectionID: int + partitionIDs: _containers.RepeatedScalarFieldContainer[int] + infos: _containers.RepeatedCompositeFieldContainer[_data_coord_pb2.VchannelInfo] + schema: _schema_pb2.CollectionSchema + exclude_infos: _containers.RepeatedCompositeFieldContainer[_data_coord_pb2.SegmentInfo] + load_meta: LoadMetaInfo + replicaID: int + segment_infos: _containers.MessageMap[int, _data_coord_pb2.SegmentInfo] + offlineNodeID: int + version: int + index_info_list: _containers.RepeatedCompositeFieldContainer[_index_coord_pb2.IndexInfo] + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., nodeID: _Optional[int] = ..., collectionID: _Optional[int] = ..., partitionIDs: _Optional[_Iterable[int]] = ..., infos: _Optional[_Iterable[_Union[_data_coord_pb2.VchannelInfo, _Mapping]]] = ..., schema: _Optional[_Union[_schema_pb2.CollectionSchema, _Mapping]] = ..., exclude_infos: _Optional[_Iterable[_Union[_data_coord_pb2.SegmentInfo, _Mapping]]] = ..., load_meta: _Optional[_Union[LoadMetaInfo, _Mapping]] = ..., replicaID: _Optional[int] = ..., segment_infos: _Optional[_Mapping[int, _data_coord_pb2.SegmentInfo]] = ..., offlineNodeID: _Optional[int] = ..., version: _Optional[int] = ..., index_info_list: _Optional[_Iterable[_Union[_index_coord_pb2.IndexInfo, _Mapping]]] = ...) -> None: ... + +class UnsubDmChannelRequest(_message.Message): + __slots__ = ("base", "nodeID", "collectionID", "channel_name") + BASE_FIELD_NUMBER: _ClassVar[int] + NODEID_FIELD_NUMBER: _ClassVar[int] + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + CHANNEL_NAME_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + nodeID: int + collectionID: int + channel_name: str + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., nodeID: _Optional[int] = ..., collectionID: _Optional[int] = ..., channel_name: _Optional[str] = ...) -> None: ... + +class SegmentLoadInfo(_message.Message): + __slots__ = ("segmentID", "partitionID", "collectionID", "dbID", "flush_time", "binlog_paths", "num_of_rows", "statslogs", "deltalogs", "compactionFrom", "index_infos", "segment_size", "insert_channel", "start_position", "delta_position", "readableVersion", "level", "storageVersion") + SEGMENTID_FIELD_NUMBER: _ClassVar[int] + PARTITIONID_FIELD_NUMBER: _ClassVar[int] + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + DBID_FIELD_NUMBER: _ClassVar[int] + FLUSH_TIME_FIELD_NUMBER: _ClassVar[int] + BINLOG_PATHS_FIELD_NUMBER: _ClassVar[int] + NUM_OF_ROWS_FIELD_NUMBER: _ClassVar[int] + STATSLOGS_FIELD_NUMBER: _ClassVar[int] + DELTALOGS_FIELD_NUMBER: _ClassVar[int] + COMPACTIONFROM_FIELD_NUMBER: _ClassVar[int] + INDEX_INFOS_FIELD_NUMBER: _ClassVar[int] + SEGMENT_SIZE_FIELD_NUMBER: _ClassVar[int] + INSERT_CHANNEL_FIELD_NUMBER: _ClassVar[int] + START_POSITION_FIELD_NUMBER: _ClassVar[int] + DELTA_POSITION_FIELD_NUMBER: _ClassVar[int] + READABLEVERSION_FIELD_NUMBER: _ClassVar[int] + LEVEL_FIELD_NUMBER: _ClassVar[int] + STORAGEVERSION_FIELD_NUMBER: _ClassVar[int] + segmentID: int + partitionID: int + collectionID: int + dbID: int + flush_time: int + binlog_paths: _containers.RepeatedCompositeFieldContainer[_data_coord_pb2.FieldBinlog] + num_of_rows: int + statslogs: _containers.RepeatedCompositeFieldContainer[_data_coord_pb2.FieldBinlog] + deltalogs: _containers.RepeatedCompositeFieldContainer[_data_coord_pb2.FieldBinlog] + compactionFrom: _containers.RepeatedScalarFieldContainer[int] + index_infos: _containers.RepeatedCompositeFieldContainer[FieldIndexInfo] + segment_size: int + insert_channel: str + start_position: _msg_pb2.MsgPosition + delta_position: _msg_pb2.MsgPosition + readableVersion: int + level: _data_coord_pb2.SegmentLevel + storageVersion: int + def __init__(self, segmentID: _Optional[int] = ..., partitionID: _Optional[int] = ..., collectionID: _Optional[int] = ..., dbID: _Optional[int] = ..., flush_time: _Optional[int] = ..., binlog_paths: _Optional[_Iterable[_Union[_data_coord_pb2.FieldBinlog, _Mapping]]] = ..., num_of_rows: _Optional[int] = ..., statslogs: _Optional[_Iterable[_Union[_data_coord_pb2.FieldBinlog, _Mapping]]] = ..., deltalogs: _Optional[_Iterable[_Union[_data_coord_pb2.FieldBinlog, _Mapping]]] = ..., compactionFrom: _Optional[_Iterable[int]] = ..., index_infos: _Optional[_Iterable[_Union[FieldIndexInfo, _Mapping]]] = ..., segment_size: _Optional[int] = ..., insert_channel: _Optional[str] = ..., start_position: _Optional[_Union[_msg_pb2.MsgPosition, _Mapping]] = ..., delta_position: _Optional[_Union[_msg_pb2.MsgPosition, _Mapping]] = ..., readableVersion: _Optional[int] = ..., level: _Optional[_Union[_data_coord_pb2.SegmentLevel, str]] = ..., storageVersion: _Optional[int] = ...) -> None: ... + +class FieldIndexInfo(_message.Message): + __slots__ = ("fieldID", "enable_index", "index_name", "indexID", "buildID", "index_params", "index_file_paths", "index_size", "index_version", "num_rows", "current_index_version", "index_store_version") + FIELDID_FIELD_NUMBER: _ClassVar[int] + ENABLE_INDEX_FIELD_NUMBER: _ClassVar[int] + INDEX_NAME_FIELD_NUMBER: _ClassVar[int] + INDEXID_FIELD_NUMBER: _ClassVar[int] + BUILDID_FIELD_NUMBER: _ClassVar[int] + INDEX_PARAMS_FIELD_NUMBER: _ClassVar[int] + INDEX_FILE_PATHS_FIELD_NUMBER: _ClassVar[int] + INDEX_SIZE_FIELD_NUMBER: _ClassVar[int] + INDEX_VERSION_FIELD_NUMBER: _ClassVar[int] + NUM_ROWS_FIELD_NUMBER: _ClassVar[int] + CURRENT_INDEX_VERSION_FIELD_NUMBER: _ClassVar[int] + INDEX_STORE_VERSION_FIELD_NUMBER: _ClassVar[int] + fieldID: int + enable_index: bool + index_name: str + indexID: int + buildID: int + index_params: _containers.RepeatedCompositeFieldContainer[_common_pb2.KeyValuePair] + index_file_paths: _containers.RepeatedScalarFieldContainer[str] + index_size: int + index_version: int + num_rows: int + current_index_version: int + index_store_version: int + def __init__(self, fieldID: _Optional[int] = ..., enable_index: bool = ..., index_name: _Optional[str] = ..., indexID: _Optional[int] = ..., buildID: _Optional[int] = ..., index_params: _Optional[_Iterable[_Union[_common_pb2.KeyValuePair, _Mapping]]] = ..., index_file_paths: _Optional[_Iterable[str]] = ..., index_size: _Optional[int] = ..., index_version: _Optional[int] = ..., num_rows: _Optional[int] = ..., current_index_version: _Optional[int] = ..., index_store_version: _Optional[int] = ...) -> None: ... + +class LoadSegmentsRequest(_message.Message): + __slots__ = ("base", "dst_nodeID", "infos", "schema", "source_nodeID", "collectionID", "load_meta", "replicaID", "delta_positions", "version", "need_transfer", "load_scope", "index_info_list", "lazy_load") + BASE_FIELD_NUMBER: _ClassVar[int] + DST_NODEID_FIELD_NUMBER: _ClassVar[int] + INFOS_FIELD_NUMBER: _ClassVar[int] + SCHEMA_FIELD_NUMBER: _ClassVar[int] + SOURCE_NODEID_FIELD_NUMBER: _ClassVar[int] + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + LOAD_META_FIELD_NUMBER: _ClassVar[int] + REPLICAID_FIELD_NUMBER: _ClassVar[int] + DELTA_POSITIONS_FIELD_NUMBER: _ClassVar[int] + VERSION_FIELD_NUMBER: _ClassVar[int] + NEED_TRANSFER_FIELD_NUMBER: _ClassVar[int] + LOAD_SCOPE_FIELD_NUMBER: _ClassVar[int] + INDEX_INFO_LIST_FIELD_NUMBER: _ClassVar[int] + LAZY_LOAD_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + dst_nodeID: int + infos: _containers.RepeatedCompositeFieldContainer[SegmentLoadInfo] + schema: _schema_pb2.CollectionSchema + source_nodeID: int + collectionID: int + load_meta: LoadMetaInfo + replicaID: int + delta_positions: _containers.RepeatedCompositeFieldContainer[_msg_pb2.MsgPosition] + version: int + need_transfer: bool + load_scope: LoadScope + index_info_list: _containers.RepeatedCompositeFieldContainer[_index_coord_pb2.IndexInfo] + lazy_load: bool + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., dst_nodeID: _Optional[int] = ..., infos: _Optional[_Iterable[_Union[SegmentLoadInfo, _Mapping]]] = ..., schema: _Optional[_Union[_schema_pb2.CollectionSchema, _Mapping]] = ..., source_nodeID: _Optional[int] = ..., collectionID: _Optional[int] = ..., load_meta: _Optional[_Union[LoadMetaInfo, _Mapping]] = ..., replicaID: _Optional[int] = ..., delta_positions: _Optional[_Iterable[_Union[_msg_pb2.MsgPosition, _Mapping]]] = ..., version: _Optional[int] = ..., need_transfer: bool = ..., load_scope: _Optional[_Union[LoadScope, str]] = ..., index_info_list: _Optional[_Iterable[_Union[_index_coord_pb2.IndexInfo, _Mapping]]] = ..., lazy_load: bool = ...) -> None: ... + +class ReleaseSegmentsRequest(_message.Message): + __slots__ = ("base", "nodeID", "dbID", "collectionID", "partitionIDs", "segmentIDs", "scope", "shard", "need_transfer") + BASE_FIELD_NUMBER: _ClassVar[int] + NODEID_FIELD_NUMBER: _ClassVar[int] + DBID_FIELD_NUMBER: _ClassVar[int] + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + PARTITIONIDS_FIELD_NUMBER: _ClassVar[int] + SEGMENTIDS_FIELD_NUMBER: _ClassVar[int] + SCOPE_FIELD_NUMBER: _ClassVar[int] + SHARD_FIELD_NUMBER: _ClassVar[int] + NEED_TRANSFER_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + nodeID: int + dbID: int + collectionID: int + partitionIDs: _containers.RepeatedScalarFieldContainer[int] + segmentIDs: _containers.RepeatedScalarFieldContainer[int] + scope: DataScope + shard: str + need_transfer: bool + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., nodeID: _Optional[int] = ..., dbID: _Optional[int] = ..., collectionID: _Optional[int] = ..., partitionIDs: _Optional[_Iterable[int]] = ..., segmentIDs: _Optional[_Iterable[int]] = ..., scope: _Optional[_Union[DataScope, str]] = ..., shard: _Optional[str] = ..., need_transfer: bool = ...) -> None: ... + +class SearchRequest(_message.Message): + __slots__ = ("req", "dml_channels", "segmentIDs", "from_shard_leader", "scope", "total_channel_num") + REQ_FIELD_NUMBER: _ClassVar[int] + DML_CHANNELS_FIELD_NUMBER: _ClassVar[int] + SEGMENTIDS_FIELD_NUMBER: _ClassVar[int] + FROM_SHARD_LEADER_FIELD_NUMBER: _ClassVar[int] + SCOPE_FIELD_NUMBER: _ClassVar[int] + TOTAL_CHANNEL_NUM_FIELD_NUMBER: _ClassVar[int] + req: _internal_pb2.SearchRequest + dml_channels: _containers.RepeatedScalarFieldContainer[str] + segmentIDs: _containers.RepeatedScalarFieldContainer[int] + from_shard_leader: bool + scope: DataScope + total_channel_num: int + def __init__(self, req: _Optional[_Union[_internal_pb2.SearchRequest, _Mapping]] = ..., dml_channels: _Optional[_Iterable[str]] = ..., segmentIDs: _Optional[_Iterable[int]] = ..., from_shard_leader: bool = ..., scope: _Optional[_Union[DataScope, str]] = ..., total_channel_num: _Optional[int] = ...) -> None: ... + +class HybridSearchRequest(_message.Message): + __slots__ = ("req", "dml_channels", "total_channel_num") + REQ_FIELD_NUMBER: _ClassVar[int] + DML_CHANNELS_FIELD_NUMBER: _ClassVar[int] + TOTAL_CHANNEL_NUM_FIELD_NUMBER: _ClassVar[int] + req: _internal_pb2.HybridSearchRequest + dml_channels: _containers.RepeatedScalarFieldContainer[str] + total_channel_num: int + def __init__(self, req: _Optional[_Union[_internal_pb2.HybridSearchRequest, _Mapping]] = ..., dml_channels: _Optional[_Iterable[str]] = ..., total_channel_num: _Optional[int] = ...) -> None: ... + +class HybridSearchResult(_message.Message): + __slots__ = ("base", "status", "results", "costAggregation", "channels_mvcc") + class ChannelsMvccEntry(_message.Message): + __slots__ = ("key", "value") + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: str + value: int + def __init__(self, key: _Optional[str] = ..., value: _Optional[int] = ...) -> None: ... + BASE_FIELD_NUMBER: _ClassVar[int] + STATUS_FIELD_NUMBER: _ClassVar[int] + RESULTS_FIELD_NUMBER: _ClassVar[int] + COSTAGGREGATION_FIELD_NUMBER: _ClassVar[int] + CHANNELS_MVCC_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + status: _common_pb2.Status + results: _containers.RepeatedCompositeFieldContainer[_internal_pb2.SearchResults] + costAggregation: _internal_pb2.CostAggregation + channels_mvcc: _containers.ScalarMap[str, int] + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., results: _Optional[_Iterable[_Union[_internal_pb2.SearchResults, _Mapping]]] = ..., costAggregation: _Optional[_Union[_internal_pb2.CostAggregation, _Mapping]] = ..., channels_mvcc: _Optional[_Mapping[str, int]] = ...) -> None: ... + +class QueryRequest(_message.Message): + __slots__ = ("req", "dml_channels", "segmentIDs", "from_shard_leader", "scope") + REQ_FIELD_NUMBER: _ClassVar[int] + DML_CHANNELS_FIELD_NUMBER: _ClassVar[int] + SEGMENTIDS_FIELD_NUMBER: _ClassVar[int] + FROM_SHARD_LEADER_FIELD_NUMBER: _ClassVar[int] + SCOPE_FIELD_NUMBER: _ClassVar[int] + req: _internal_pb2.RetrieveRequest + dml_channels: _containers.RepeatedScalarFieldContainer[str] + segmentIDs: _containers.RepeatedScalarFieldContainer[int] + from_shard_leader: bool + scope: DataScope + def __init__(self, req: _Optional[_Union[_internal_pb2.RetrieveRequest, _Mapping]] = ..., dml_channels: _Optional[_Iterable[str]] = ..., segmentIDs: _Optional[_Iterable[int]] = ..., from_shard_leader: bool = ..., scope: _Optional[_Union[DataScope, str]] = ...) -> None: ... + +class SyncReplicaSegmentsRequest(_message.Message): + __slots__ = ("base", "vchannel_name", "replica_segments") + BASE_FIELD_NUMBER: _ClassVar[int] + VCHANNEL_NAME_FIELD_NUMBER: _ClassVar[int] + REPLICA_SEGMENTS_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + vchannel_name: str + replica_segments: _containers.RepeatedCompositeFieldContainer[ReplicaSegmentsInfo] + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., vchannel_name: _Optional[str] = ..., replica_segments: _Optional[_Iterable[_Union[ReplicaSegmentsInfo, _Mapping]]] = ...) -> None: ... + +class ReplicaSegmentsInfo(_message.Message): + __slots__ = ("node_id", "partition_id", "segment_ids", "versions") + NODE_ID_FIELD_NUMBER: _ClassVar[int] + PARTITION_ID_FIELD_NUMBER: _ClassVar[int] + SEGMENT_IDS_FIELD_NUMBER: _ClassVar[int] + VERSIONS_FIELD_NUMBER: _ClassVar[int] + node_id: int + partition_id: int + segment_ids: _containers.RepeatedScalarFieldContainer[int] + versions: _containers.RepeatedScalarFieldContainer[int] + def __init__(self, node_id: _Optional[int] = ..., partition_id: _Optional[int] = ..., segment_ids: _Optional[_Iterable[int]] = ..., versions: _Optional[_Iterable[int]] = ...) -> None: ... + +class GetLoadInfoRequest(_message.Message): + __slots__ = ("base", "collection_id") + BASE_FIELD_NUMBER: _ClassVar[int] + COLLECTION_ID_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + collection_id: int + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., collection_id: _Optional[int] = ...) -> None: ... + +class GetLoadInfoResponse(_message.Message): + __slots__ = ("status", "schema", "load_type", "partitions") + STATUS_FIELD_NUMBER: _ClassVar[int] + SCHEMA_FIELD_NUMBER: _ClassVar[int] + LOAD_TYPE_FIELD_NUMBER: _ClassVar[int] + PARTITIONS_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + schema: _schema_pb2.CollectionSchema + load_type: LoadType + partitions: _containers.RepeatedScalarFieldContainer[int] + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., schema: _Optional[_Union[_schema_pb2.CollectionSchema, _Mapping]] = ..., load_type: _Optional[_Union[LoadType, str]] = ..., partitions: _Optional[_Iterable[int]] = ...) -> None: ... + +class HandoffSegmentsRequest(_message.Message): + __slots__ = ("base", "segmentInfos", "released_segments") + BASE_FIELD_NUMBER: _ClassVar[int] + SEGMENTINFOS_FIELD_NUMBER: _ClassVar[int] + RELEASED_SEGMENTS_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + segmentInfos: _containers.RepeatedCompositeFieldContainer[SegmentInfo] + released_segments: _containers.RepeatedScalarFieldContainer[int] + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., segmentInfos: _Optional[_Iterable[_Union[SegmentInfo, _Mapping]]] = ..., released_segments: _Optional[_Iterable[int]] = ...) -> None: ... + +class LoadBalanceRequest(_message.Message): + __slots__ = ("base", "source_nodeIDs", "balance_reason", "dst_nodeIDs", "sealed_segmentIDs", "collectionID") + BASE_FIELD_NUMBER: _ClassVar[int] + SOURCE_NODEIDS_FIELD_NUMBER: _ClassVar[int] + BALANCE_REASON_FIELD_NUMBER: _ClassVar[int] + DST_NODEIDS_FIELD_NUMBER: _ClassVar[int] + SEALED_SEGMENTIDS_FIELD_NUMBER: _ClassVar[int] + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + source_nodeIDs: _containers.RepeatedScalarFieldContainer[int] + balance_reason: TriggerCondition + dst_nodeIDs: _containers.RepeatedScalarFieldContainer[int] + sealed_segmentIDs: _containers.RepeatedScalarFieldContainer[int] + collectionID: int + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., source_nodeIDs: _Optional[_Iterable[int]] = ..., balance_reason: _Optional[_Union[TriggerCondition, str]] = ..., dst_nodeIDs: _Optional[_Iterable[int]] = ..., sealed_segmentIDs: _Optional[_Iterable[int]] = ..., collectionID: _Optional[int] = ...) -> None: ... + +class DmChannelWatchInfo(_message.Message): + __slots__ = ("collectionID", "dmChannel", "nodeID_loaded", "replicaID", "node_ids") + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + DMCHANNEL_FIELD_NUMBER: _ClassVar[int] + NODEID_LOADED_FIELD_NUMBER: _ClassVar[int] + REPLICAID_FIELD_NUMBER: _ClassVar[int] + NODE_IDS_FIELD_NUMBER: _ClassVar[int] + collectionID: int + dmChannel: str + nodeID_loaded: int + replicaID: int + node_ids: _containers.RepeatedScalarFieldContainer[int] + def __init__(self, collectionID: _Optional[int] = ..., dmChannel: _Optional[str] = ..., nodeID_loaded: _Optional[int] = ..., replicaID: _Optional[int] = ..., node_ids: _Optional[_Iterable[int]] = ...) -> None: ... + +class QueryChannelInfo(_message.Message): + __slots__ = ("collectionID", "query_channel", "query_result_channel", "global_sealed_segments", "seek_position") + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + QUERY_CHANNEL_FIELD_NUMBER: _ClassVar[int] + QUERY_RESULT_CHANNEL_FIELD_NUMBER: _ClassVar[int] + GLOBAL_SEALED_SEGMENTS_FIELD_NUMBER: _ClassVar[int] + SEEK_POSITION_FIELD_NUMBER: _ClassVar[int] + collectionID: int + query_channel: str + query_result_channel: str + global_sealed_segments: _containers.RepeatedCompositeFieldContainer[SegmentInfo] + seek_position: _msg_pb2.MsgPosition + def __init__(self, collectionID: _Optional[int] = ..., query_channel: _Optional[str] = ..., query_result_channel: _Optional[str] = ..., global_sealed_segments: _Optional[_Iterable[_Union[SegmentInfo, _Mapping]]] = ..., seek_position: _Optional[_Union[_msg_pb2.MsgPosition, _Mapping]] = ...) -> None: ... + +class PartitionStates(_message.Message): + __slots__ = ("partitionID", "state", "inMemory_percentage") + PARTITIONID_FIELD_NUMBER: _ClassVar[int] + STATE_FIELD_NUMBER: _ClassVar[int] + INMEMORY_PERCENTAGE_FIELD_NUMBER: _ClassVar[int] + partitionID: int + state: PartitionState + inMemory_percentage: int + def __init__(self, partitionID: _Optional[int] = ..., state: _Optional[_Union[PartitionState, str]] = ..., inMemory_percentage: _Optional[int] = ...) -> None: ... + +class SegmentInfo(_message.Message): + __slots__ = ("segmentID", "collectionID", "partitionID", "nodeID", "mem_size", "num_rows", "index_name", "indexID", "dmChannel", "compactionFrom", "createdByCompaction", "segment_state", "index_infos", "replica_ids", "node_ids", "enable_index", "is_fake") + SEGMENTID_FIELD_NUMBER: _ClassVar[int] + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + PARTITIONID_FIELD_NUMBER: _ClassVar[int] + NODEID_FIELD_NUMBER: _ClassVar[int] + MEM_SIZE_FIELD_NUMBER: _ClassVar[int] + NUM_ROWS_FIELD_NUMBER: _ClassVar[int] + INDEX_NAME_FIELD_NUMBER: _ClassVar[int] + INDEXID_FIELD_NUMBER: _ClassVar[int] + DMCHANNEL_FIELD_NUMBER: _ClassVar[int] + COMPACTIONFROM_FIELD_NUMBER: _ClassVar[int] + CREATEDBYCOMPACTION_FIELD_NUMBER: _ClassVar[int] + SEGMENT_STATE_FIELD_NUMBER: _ClassVar[int] + INDEX_INFOS_FIELD_NUMBER: _ClassVar[int] + REPLICA_IDS_FIELD_NUMBER: _ClassVar[int] + NODE_IDS_FIELD_NUMBER: _ClassVar[int] + ENABLE_INDEX_FIELD_NUMBER: _ClassVar[int] + IS_FAKE_FIELD_NUMBER: _ClassVar[int] + segmentID: int + collectionID: int + partitionID: int + nodeID: int + mem_size: int + num_rows: int + index_name: str + indexID: int + dmChannel: str + compactionFrom: _containers.RepeatedScalarFieldContainer[int] + createdByCompaction: bool + segment_state: _common_pb2.SegmentState + index_infos: _containers.RepeatedCompositeFieldContainer[FieldIndexInfo] + replica_ids: _containers.RepeatedScalarFieldContainer[int] + node_ids: _containers.RepeatedScalarFieldContainer[int] + enable_index: bool + is_fake: bool + def __init__(self, segmentID: _Optional[int] = ..., collectionID: _Optional[int] = ..., partitionID: _Optional[int] = ..., nodeID: _Optional[int] = ..., mem_size: _Optional[int] = ..., num_rows: _Optional[int] = ..., index_name: _Optional[str] = ..., indexID: _Optional[int] = ..., dmChannel: _Optional[str] = ..., compactionFrom: _Optional[_Iterable[int]] = ..., createdByCompaction: bool = ..., segment_state: _Optional[_Union[_common_pb2.SegmentState, str]] = ..., index_infos: _Optional[_Iterable[_Union[FieldIndexInfo, _Mapping]]] = ..., replica_ids: _Optional[_Iterable[int]] = ..., node_ids: _Optional[_Iterable[int]] = ..., enable_index: bool = ..., is_fake: bool = ...) -> None: ... + +class CollectionInfo(_message.Message): + __slots__ = ("collectionID", "partitionIDs", "partition_states", "load_type", "schema", "released_partitionIDs", "inMemory_percentage", "replica_ids", "replica_number") + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + PARTITIONIDS_FIELD_NUMBER: _ClassVar[int] + PARTITION_STATES_FIELD_NUMBER: _ClassVar[int] + LOAD_TYPE_FIELD_NUMBER: _ClassVar[int] + SCHEMA_FIELD_NUMBER: _ClassVar[int] + RELEASED_PARTITIONIDS_FIELD_NUMBER: _ClassVar[int] + INMEMORY_PERCENTAGE_FIELD_NUMBER: _ClassVar[int] + REPLICA_IDS_FIELD_NUMBER: _ClassVar[int] + REPLICA_NUMBER_FIELD_NUMBER: _ClassVar[int] + collectionID: int + partitionIDs: _containers.RepeatedScalarFieldContainer[int] + partition_states: _containers.RepeatedCompositeFieldContainer[PartitionStates] + load_type: LoadType + schema: _schema_pb2.CollectionSchema + released_partitionIDs: _containers.RepeatedScalarFieldContainer[int] + inMemory_percentage: int + replica_ids: _containers.RepeatedScalarFieldContainer[int] + replica_number: int + def __init__(self, collectionID: _Optional[int] = ..., partitionIDs: _Optional[_Iterable[int]] = ..., partition_states: _Optional[_Iterable[_Union[PartitionStates, _Mapping]]] = ..., load_type: _Optional[_Union[LoadType, str]] = ..., schema: _Optional[_Union[_schema_pb2.CollectionSchema, _Mapping]] = ..., released_partitionIDs: _Optional[_Iterable[int]] = ..., inMemory_percentage: _Optional[int] = ..., replica_ids: _Optional[_Iterable[int]] = ..., replica_number: _Optional[int] = ...) -> None: ... + +class UnsubscribeChannels(_message.Message): + __slots__ = ("collectionID", "channels") + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + CHANNELS_FIELD_NUMBER: _ClassVar[int] + collectionID: int + channels: _containers.RepeatedScalarFieldContainer[str] + def __init__(self, collectionID: _Optional[int] = ..., channels: _Optional[_Iterable[str]] = ...) -> None: ... + +class UnsubscribeChannelInfo(_message.Message): + __slots__ = ("nodeID", "collection_channels") + NODEID_FIELD_NUMBER: _ClassVar[int] + COLLECTION_CHANNELS_FIELD_NUMBER: _ClassVar[int] + nodeID: int + collection_channels: _containers.RepeatedCompositeFieldContainer[UnsubscribeChannels] + def __init__(self, nodeID: _Optional[int] = ..., collection_channels: _Optional[_Iterable[_Union[UnsubscribeChannels, _Mapping]]] = ...) -> None: ... + +class SegmentChangeInfo(_message.Message): + __slots__ = ("online_nodeID", "online_segments", "offline_nodeID", "offline_segments") + ONLINE_NODEID_FIELD_NUMBER: _ClassVar[int] + ONLINE_SEGMENTS_FIELD_NUMBER: _ClassVar[int] + OFFLINE_NODEID_FIELD_NUMBER: _ClassVar[int] + OFFLINE_SEGMENTS_FIELD_NUMBER: _ClassVar[int] + online_nodeID: int + online_segments: _containers.RepeatedCompositeFieldContainer[SegmentInfo] + offline_nodeID: int + offline_segments: _containers.RepeatedCompositeFieldContainer[SegmentInfo] + def __init__(self, online_nodeID: _Optional[int] = ..., online_segments: _Optional[_Iterable[_Union[SegmentInfo, _Mapping]]] = ..., offline_nodeID: _Optional[int] = ..., offline_segments: _Optional[_Iterable[_Union[SegmentInfo, _Mapping]]] = ...) -> None: ... + +class SealedSegmentsChangeInfo(_message.Message): + __slots__ = ("base", "infos") + BASE_FIELD_NUMBER: _ClassVar[int] + INFOS_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + infos: _containers.RepeatedCompositeFieldContainer[SegmentChangeInfo] + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., infos: _Optional[_Iterable[_Union[SegmentChangeInfo, _Mapping]]] = ...) -> None: ... + +class GetDataDistributionRequest(_message.Message): + __slots__ = ("base", "checkpoints") + class CheckpointsEntry(_message.Message): + __slots__ = ("key", "value") + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: str + value: _msg_pb2.MsgPosition + def __init__(self, key: _Optional[str] = ..., value: _Optional[_Union[_msg_pb2.MsgPosition, _Mapping]] = ...) -> None: ... + BASE_FIELD_NUMBER: _ClassVar[int] + CHECKPOINTS_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + checkpoints: _containers.MessageMap[str, _msg_pb2.MsgPosition] + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., checkpoints: _Optional[_Mapping[str, _msg_pb2.MsgPosition]] = ...) -> None: ... + +class GetDataDistributionResponse(_message.Message): + __slots__ = ("status", "nodeID", "segments", "channels", "leader_views") + STATUS_FIELD_NUMBER: _ClassVar[int] + NODEID_FIELD_NUMBER: _ClassVar[int] + SEGMENTS_FIELD_NUMBER: _ClassVar[int] + CHANNELS_FIELD_NUMBER: _ClassVar[int] + LEADER_VIEWS_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + nodeID: int + segments: _containers.RepeatedCompositeFieldContainer[SegmentVersionInfo] + channels: _containers.RepeatedCompositeFieldContainer[ChannelVersionInfo] + leader_views: _containers.RepeatedCompositeFieldContainer[LeaderView] + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., nodeID: _Optional[int] = ..., segments: _Optional[_Iterable[_Union[SegmentVersionInfo, _Mapping]]] = ..., channels: _Optional[_Iterable[_Union[ChannelVersionInfo, _Mapping]]] = ..., leader_views: _Optional[_Iterable[_Union[LeaderView, _Mapping]]] = ...) -> None: ... + +class LeaderView(_message.Message): + __slots__ = ("collection", "channel", "segment_dist", "growing_segmentIDs", "growing_segments", "TargetVersion", "num_of_growing_rows") + class SegmentDistEntry(_message.Message): + __slots__ = ("key", "value") + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: int + value: SegmentDist + def __init__(self, key: _Optional[int] = ..., value: _Optional[_Union[SegmentDist, _Mapping]] = ...) -> None: ... + class GrowingSegmentsEntry(_message.Message): + __slots__ = ("key", "value") + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: int + value: _msg_pb2.MsgPosition + def __init__(self, key: _Optional[int] = ..., value: _Optional[_Union[_msg_pb2.MsgPosition, _Mapping]] = ...) -> None: ... + COLLECTION_FIELD_NUMBER: _ClassVar[int] + CHANNEL_FIELD_NUMBER: _ClassVar[int] + SEGMENT_DIST_FIELD_NUMBER: _ClassVar[int] + GROWING_SEGMENTIDS_FIELD_NUMBER: _ClassVar[int] + GROWING_SEGMENTS_FIELD_NUMBER: _ClassVar[int] + TARGETVERSION_FIELD_NUMBER: _ClassVar[int] + NUM_OF_GROWING_ROWS_FIELD_NUMBER: _ClassVar[int] + collection: int + channel: str + segment_dist: _containers.MessageMap[int, SegmentDist] + growing_segmentIDs: _containers.RepeatedScalarFieldContainer[int] + growing_segments: _containers.MessageMap[int, _msg_pb2.MsgPosition] + TargetVersion: int + num_of_growing_rows: int + def __init__(self, collection: _Optional[int] = ..., channel: _Optional[str] = ..., segment_dist: _Optional[_Mapping[int, SegmentDist]] = ..., growing_segmentIDs: _Optional[_Iterable[int]] = ..., growing_segments: _Optional[_Mapping[int, _msg_pb2.MsgPosition]] = ..., TargetVersion: _Optional[int] = ..., num_of_growing_rows: _Optional[int] = ...) -> None: ... + +class SegmentDist(_message.Message): + __slots__ = ("nodeID", "version") + NODEID_FIELD_NUMBER: _ClassVar[int] + VERSION_FIELD_NUMBER: _ClassVar[int] + nodeID: int + version: int + def __init__(self, nodeID: _Optional[int] = ..., version: _Optional[int] = ...) -> None: ... + +class SegmentVersionInfo(_message.Message): + __slots__ = ("ID", "collection", "partition", "channel", "version", "last_delta_timestamp", "index_info") + class IndexInfoEntry(_message.Message): + __slots__ = ("key", "value") + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: int + value: FieldIndexInfo + def __init__(self, key: _Optional[int] = ..., value: _Optional[_Union[FieldIndexInfo, _Mapping]] = ...) -> None: ... + ID_FIELD_NUMBER: _ClassVar[int] + COLLECTION_FIELD_NUMBER: _ClassVar[int] + PARTITION_FIELD_NUMBER: _ClassVar[int] + CHANNEL_FIELD_NUMBER: _ClassVar[int] + VERSION_FIELD_NUMBER: _ClassVar[int] + LAST_DELTA_TIMESTAMP_FIELD_NUMBER: _ClassVar[int] + INDEX_INFO_FIELD_NUMBER: _ClassVar[int] + ID: int + collection: int + partition: int + channel: str + version: int + last_delta_timestamp: int + index_info: _containers.MessageMap[int, FieldIndexInfo] + def __init__(self, ID: _Optional[int] = ..., collection: _Optional[int] = ..., partition: _Optional[int] = ..., channel: _Optional[str] = ..., version: _Optional[int] = ..., last_delta_timestamp: _Optional[int] = ..., index_info: _Optional[_Mapping[int, FieldIndexInfo]] = ...) -> None: ... + +class ChannelVersionInfo(_message.Message): + __slots__ = ("channel", "collection", "version") + CHANNEL_FIELD_NUMBER: _ClassVar[int] + COLLECTION_FIELD_NUMBER: _ClassVar[int] + VERSION_FIELD_NUMBER: _ClassVar[int] + channel: str + collection: int + version: int + def __init__(self, channel: _Optional[str] = ..., collection: _Optional[int] = ..., version: _Optional[int] = ...) -> None: ... + +class CollectionLoadInfo(_message.Message): + __slots__ = ("collectionID", "released_partitions", "replica_number", "status", "field_indexID", "load_type", "recover_times") + class FieldIndexIDEntry(_message.Message): + __slots__ = ("key", "value") + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: int + value: int + def __init__(self, key: _Optional[int] = ..., value: _Optional[int] = ...) -> None: ... + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + RELEASED_PARTITIONS_FIELD_NUMBER: _ClassVar[int] + REPLICA_NUMBER_FIELD_NUMBER: _ClassVar[int] + STATUS_FIELD_NUMBER: _ClassVar[int] + FIELD_INDEXID_FIELD_NUMBER: _ClassVar[int] + LOAD_TYPE_FIELD_NUMBER: _ClassVar[int] + RECOVER_TIMES_FIELD_NUMBER: _ClassVar[int] + collectionID: int + released_partitions: _containers.RepeatedScalarFieldContainer[int] + replica_number: int + status: LoadStatus + field_indexID: _containers.ScalarMap[int, int] + load_type: LoadType + recover_times: int + def __init__(self, collectionID: _Optional[int] = ..., released_partitions: _Optional[_Iterable[int]] = ..., replica_number: _Optional[int] = ..., status: _Optional[_Union[LoadStatus, str]] = ..., field_indexID: _Optional[_Mapping[int, int]] = ..., load_type: _Optional[_Union[LoadType, str]] = ..., recover_times: _Optional[int] = ...) -> None: ... + +class PartitionLoadInfo(_message.Message): + __slots__ = ("collectionID", "partitionID", "replica_number", "status", "field_indexID", "recover_times") + class FieldIndexIDEntry(_message.Message): + __slots__ = ("key", "value") + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: int + value: int + def __init__(self, key: _Optional[int] = ..., value: _Optional[int] = ...) -> None: ... + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + PARTITIONID_FIELD_NUMBER: _ClassVar[int] + REPLICA_NUMBER_FIELD_NUMBER: _ClassVar[int] + STATUS_FIELD_NUMBER: _ClassVar[int] + FIELD_INDEXID_FIELD_NUMBER: _ClassVar[int] + RECOVER_TIMES_FIELD_NUMBER: _ClassVar[int] + collectionID: int + partitionID: int + replica_number: int + status: LoadStatus + field_indexID: _containers.ScalarMap[int, int] + recover_times: int + def __init__(self, collectionID: _Optional[int] = ..., partitionID: _Optional[int] = ..., replica_number: _Optional[int] = ..., status: _Optional[_Union[LoadStatus, str]] = ..., field_indexID: _Optional[_Mapping[int, int]] = ..., recover_times: _Optional[int] = ...) -> None: ... + +class Replica(_message.Message): + __slots__ = ("ID", "collectionID", "nodes", "resource_group") + ID_FIELD_NUMBER: _ClassVar[int] + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + NODES_FIELD_NUMBER: _ClassVar[int] + RESOURCE_GROUP_FIELD_NUMBER: _ClassVar[int] + ID: int + collectionID: int + nodes: _containers.RepeatedScalarFieldContainer[int] + resource_group: str + def __init__(self, ID: _Optional[int] = ..., collectionID: _Optional[int] = ..., nodes: _Optional[_Iterable[int]] = ..., resource_group: _Optional[str] = ...) -> None: ... + +class SyncAction(_message.Message): + __slots__ = ("type", "partitionID", "segmentID", "nodeID", "version", "info", "growingInTarget", "sealedInTarget", "TargetVersion", "droppedInTarget", "checkpoint") + TYPE_FIELD_NUMBER: _ClassVar[int] + PARTITIONID_FIELD_NUMBER: _ClassVar[int] + SEGMENTID_FIELD_NUMBER: _ClassVar[int] + NODEID_FIELD_NUMBER: _ClassVar[int] + VERSION_FIELD_NUMBER: _ClassVar[int] + INFO_FIELD_NUMBER: _ClassVar[int] + GROWINGINTARGET_FIELD_NUMBER: _ClassVar[int] + SEALEDINTARGET_FIELD_NUMBER: _ClassVar[int] + TARGETVERSION_FIELD_NUMBER: _ClassVar[int] + DROPPEDINTARGET_FIELD_NUMBER: _ClassVar[int] + CHECKPOINT_FIELD_NUMBER: _ClassVar[int] + type: SyncType + partitionID: int + segmentID: int + nodeID: int + version: int + info: SegmentLoadInfo + growingInTarget: _containers.RepeatedScalarFieldContainer[int] + sealedInTarget: _containers.RepeatedScalarFieldContainer[int] + TargetVersion: int + droppedInTarget: _containers.RepeatedScalarFieldContainer[int] + checkpoint: _msg_pb2.MsgPosition + def __init__(self, type: _Optional[_Union[SyncType, str]] = ..., partitionID: _Optional[int] = ..., segmentID: _Optional[int] = ..., nodeID: _Optional[int] = ..., version: _Optional[int] = ..., info: _Optional[_Union[SegmentLoadInfo, _Mapping]] = ..., growingInTarget: _Optional[_Iterable[int]] = ..., sealedInTarget: _Optional[_Iterable[int]] = ..., TargetVersion: _Optional[int] = ..., droppedInTarget: _Optional[_Iterable[int]] = ..., checkpoint: _Optional[_Union[_msg_pb2.MsgPosition, _Mapping]] = ...) -> None: ... + +class SyncDistributionRequest(_message.Message): + __slots__ = ("base", "collectionID", "channel", "actions", "schema", "load_meta", "replicaID", "version", "index_info_list") + BASE_FIELD_NUMBER: _ClassVar[int] + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + CHANNEL_FIELD_NUMBER: _ClassVar[int] + ACTIONS_FIELD_NUMBER: _ClassVar[int] + SCHEMA_FIELD_NUMBER: _ClassVar[int] + LOAD_META_FIELD_NUMBER: _ClassVar[int] + REPLICAID_FIELD_NUMBER: _ClassVar[int] + VERSION_FIELD_NUMBER: _ClassVar[int] + INDEX_INFO_LIST_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + collectionID: int + channel: str + actions: _containers.RepeatedCompositeFieldContainer[SyncAction] + schema: _schema_pb2.CollectionSchema + load_meta: LoadMetaInfo + replicaID: int + version: int + index_info_list: _containers.RepeatedCompositeFieldContainer[_index_coord_pb2.IndexInfo] + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., collectionID: _Optional[int] = ..., channel: _Optional[str] = ..., actions: _Optional[_Iterable[_Union[SyncAction, _Mapping]]] = ..., schema: _Optional[_Union[_schema_pb2.CollectionSchema, _Mapping]] = ..., load_meta: _Optional[_Union[LoadMetaInfo, _Mapping]] = ..., replicaID: _Optional[int] = ..., version: _Optional[int] = ..., index_info_list: _Optional[_Iterable[_Union[_index_coord_pb2.IndexInfo, _Mapping]]] = ...) -> None: ... + +class ResourceGroup(_message.Message): + __slots__ = ("name", "capacity", "nodes") + NAME_FIELD_NUMBER: _ClassVar[int] + CAPACITY_FIELD_NUMBER: _ClassVar[int] + NODES_FIELD_NUMBER: _ClassVar[int] + name: str + capacity: int + nodes: _containers.RepeatedScalarFieldContainer[int] + def __init__(self, name: _Optional[str] = ..., capacity: _Optional[int] = ..., nodes: _Optional[_Iterable[int]] = ...) -> None: ... + +class TransferReplicaRequest(_message.Message): + __slots__ = ("base", "source_resource_group", "target_resource_group", "collectionID", "num_replica") + BASE_FIELD_NUMBER: _ClassVar[int] + SOURCE_RESOURCE_GROUP_FIELD_NUMBER: _ClassVar[int] + TARGET_RESOURCE_GROUP_FIELD_NUMBER: _ClassVar[int] + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + NUM_REPLICA_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + source_resource_group: str + target_resource_group: str + collectionID: int + num_replica: int + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., source_resource_group: _Optional[str] = ..., target_resource_group: _Optional[str] = ..., collectionID: _Optional[int] = ..., num_replica: _Optional[int] = ...) -> None: ... + +class DescribeResourceGroupRequest(_message.Message): + __slots__ = ("base", "resource_group") + BASE_FIELD_NUMBER: _ClassVar[int] + RESOURCE_GROUP_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + resource_group: str + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., resource_group: _Optional[str] = ...) -> None: ... + +class DescribeResourceGroupResponse(_message.Message): + __slots__ = ("status", "resource_group") + STATUS_FIELD_NUMBER: _ClassVar[int] + RESOURCE_GROUP_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + resource_group: ResourceGroupInfo + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., resource_group: _Optional[_Union[ResourceGroupInfo, _Mapping]] = ...) -> None: ... + +class ResourceGroupInfo(_message.Message): + __slots__ = ("name", "capacity", "num_available_node", "num_loaded_replica", "num_outgoing_node", "num_incoming_node") + class NumLoadedReplicaEntry(_message.Message): + __slots__ = ("key", "value") + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: int + value: int + def __init__(self, key: _Optional[int] = ..., value: _Optional[int] = ...) -> None: ... + class NumOutgoingNodeEntry(_message.Message): + __slots__ = ("key", "value") + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: int + value: int + def __init__(self, key: _Optional[int] = ..., value: _Optional[int] = ...) -> None: ... + class NumIncomingNodeEntry(_message.Message): + __slots__ = ("key", "value") + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: int + value: int + def __init__(self, key: _Optional[int] = ..., value: _Optional[int] = ...) -> None: ... + NAME_FIELD_NUMBER: _ClassVar[int] + CAPACITY_FIELD_NUMBER: _ClassVar[int] + NUM_AVAILABLE_NODE_FIELD_NUMBER: _ClassVar[int] + NUM_LOADED_REPLICA_FIELD_NUMBER: _ClassVar[int] + NUM_OUTGOING_NODE_FIELD_NUMBER: _ClassVar[int] + NUM_INCOMING_NODE_FIELD_NUMBER: _ClassVar[int] + name: str + capacity: int + num_available_node: int + num_loaded_replica: _containers.ScalarMap[int, int] + num_outgoing_node: _containers.ScalarMap[int, int] + num_incoming_node: _containers.ScalarMap[int, int] + def __init__(self, name: _Optional[str] = ..., capacity: _Optional[int] = ..., num_available_node: _Optional[int] = ..., num_loaded_replica: _Optional[_Mapping[int, int]] = ..., num_outgoing_node: _Optional[_Mapping[int, int]] = ..., num_incoming_node: _Optional[_Mapping[int, int]] = ...) -> None: ... + +class DeleteRequest(_message.Message): + __slots__ = ("base", "collection_id", "partition_id", "vchannel_name", "segment_id", "primary_keys", "timestamps", "scope") + BASE_FIELD_NUMBER: _ClassVar[int] + COLLECTION_ID_FIELD_NUMBER: _ClassVar[int] + PARTITION_ID_FIELD_NUMBER: _ClassVar[int] + VCHANNEL_NAME_FIELD_NUMBER: _ClassVar[int] + SEGMENT_ID_FIELD_NUMBER: _ClassVar[int] + PRIMARY_KEYS_FIELD_NUMBER: _ClassVar[int] + TIMESTAMPS_FIELD_NUMBER: _ClassVar[int] + SCOPE_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + collection_id: int + partition_id: int + vchannel_name: str + segment_id: int + primary_keys: _schema_pb2.IDs + timestamps: _containers.RepeatedScalarFieldContainer[int] + scope: DataScope + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., collection_id: _Optional[int] = ..., partition_id: _Optional[int] = ..., vchannel_name: _Optional[str] = ..., segment_id: _Optional[int] = ..., primary_keys: _Optional[_Union[_schema_pb2.IDs, _Mapping]] = ..., timestamps: _Optional[_Iterable[int]] = ..., scope: _Optional[_Union[DataScope, str]] = ...) -> None: ... + +class ActivateCheckerRequest(_message.Message): + __slots__ = ("base", "checkerID") + BASE_FIELD_NUMBER: _ClassVar[int] + CHECKERID_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + checkerID: int + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., checkerID: _Optional[int] = ...) -> None: ... + +class DeactivateCheckerRequest(_message.Message): + __slots__ = ("base", "checkerID") + BASE_FIELD_NUMBER: _ClassVar[int] + CHECKERID_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + checkerID: int + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., checkerID: _Optional[int] = ...) -> None: ... + +class ListCheckersRequest(_message.Message): + __slots__ = ("base", "checkerIDs") + BASE_FIELD_NUMBER: _ClassVar[int] + CHECKERIDS_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + checkerIDs: _containers.RepeatedScalarFieldContainer[int] + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., checkerIDs: _Optional[_Iterable[int]] = ...) -> None: ... + +class ListCheckersResponse(_message.Message): + __slots__ = ("status", "checkerInfos") + STATUS_FIELD_NUMBER: _ClassVar[int] + CHECKERINFOS_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + checkerInfos: _containers.RepeatedCompositeFieldContainer[CheckerInfo] + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., checkerInfos: _Optional[_Iterable[_Union[CheckerInfo, _Mapping]]] = ...) -> None: ... + +class CheckerInfo(_message.Message): + __slots__ = ("id", "desc", "activated", "found") + ID_FIELD_NUMBER: _ClassVar[int] + DESC_FIELD_NUMBER: _ClassVar[int] + ACTIVATED_FIELD_NUMBER: _ClassVar[int] + FOUND_FIELD_NUMBER: _ClassVar[int] + id: int + desc: str + activated: bool + found: bool + def __init__(self, id: _Optional[int] = ..., desc: _Optional[str] = ..., activated: bool = ..., found: bool = ...) -> None: ... diff --git a/milvus_connector/protocol/query_coord_pb2_grpc.py b/milvus_connector/protocol/query_coord_pb2_grpc.py new file mode 100644 index 0000000..b8adbec --- /dev/null +++ b/milvus_connector/protocol/query_coord_pb2_grpc.py @@ -0,0 +1,1784 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + +from . import common_pb2 as common__pb2 +from . import internal_pb2 as internal__pb2 +from . import milvus_pb2 as milvus__pb2 +from . import query_coord_pb2 as query__coord__pb2 + + +class QueryCoordStub(object): + """Missing associated documentation comment in .proto file.""" + + def __init__(self, channel): + """Constructor. + + Args: + channel: A grpc.Channel. + """ + self.GetComponentStates = channel.unary_unary( + '/milvus.proto.query.QueryCoord/GetComponentStates', + request_serializer=milvus__pb2.GetComponentStatesRequest.SerializeToString, + response_deserializer=milvus__pb2.ComponentStates.FromString, + ) + self.GetTimeTickChannel = channel.unary_unary( + '/milvus.proto.query.QueryCoord/GetTimeTickChannel', + request_serializer=internal__pb2.GetTimeTickChannelRequest.SerializeToString, + response_deserializer=milvus__pb2.StringResponse.FromString, + ) + self.GetStatisticsChannel = channel.unary_unary( + '/milvus.proto.query.QueryCoord/GetStatisticsChannel', + request_serializer=internal__pb2.GetStatisticsChannelRequest.SerializeToString, + response_deserializer=milvus__pb2.StringResponse.FromString, + ) + self.ShowCollections = channel.unary_unary( + '/milvus.proto.query.QueryCoord/ShowCollections', + request_serializer=query__coord__pb2.ShowCollectionsRequest.SerializeToString, + response_deserializer=query__coord__pb2.ShowCollectionsResponse.FromString, + ) + self.ShowPartitions = channel.unary_unary( + '/milvus.proto.query.QueryCoord/ShowPartitions', + request_serializer=query__coord__pb2.ShowPartitionsRequest.SerializeToString, + response_deserializer=query__coord__pb2.ShowPartitionsResponse.FromString, + ) + self.LoadPartitions = channel.unary_unary( + '/milvus.proto.query.QueryCoord/LoadPartitions', + request_serializer=query__coord__pb2.LoadPartitionsRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.ReleasePartitions = channel.unary_unary( + '/milvus.proto.query.QueryCoord/ReleasePartitions', + request_serializer=query__coord__pb2.ReleasePartitionsRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.LoadCollection = channel.unary_unary( + '/milvus.proto.query.QueryCoord/LoadCollection', + request_serializer=query__coord__pb2.LoadCollectionRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.ReleaseCollection = channel.unary_unary( + '/milvus.proto.query.QueryCoord/ReleaseCollection', + request_serializer=query__coord__pb2.ReleaseCollectionRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.SyncNewCreatedPartition = channel.unary_unary( + '/milvus.proto.query.QueryCoord/SyncNewCreatedPartition', + request_serializer=query__coord__pb2.SyncNewCreatedPartitionRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.GetPartitionStates = channel.unary_unary( + '/milvus.proto.query.QueryCoord/GetPartitionStates', + request_serializer=query__coord__pb2.GetPartitionStatesRequest.SerializeToString, + response_deserializer=query__coord__pb2.GetPartitionStatesResponse.FromString, + ) + self.GetSegmentInfo = channel.unary_unary( + '/milvus.proto.query.QueryCoord/GetSegmentInfo', + request_serializer=query__coord__pb2.GetSegmentInfoRequest.SerializeToString, + response_deserializer=query__coord__pb2.GetSegmentInfoResponse.FromString, + ) + self.LoadBalance = channel.unary_unary( + '/milvus.proto.query.QueryCoord/LoadBalance', + request_serializer=query__coord__pb2.LoadBalanceRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.ShowConfigurations = channel.unary_unary( + '/milvus.proto.query.QueryCoord/ShowConfigurations', + request_serializer=internal__pb2.ShowConfigurationsRequest.SerializeToString, + response_deserializer=internal__pb2.ShowConfigurationsResponse.FromString, + ) + self.GetMetrics = channel.unary_unary( + '/milvus.proto.query.QueryCoord/GetMetrics', + request_serializer=milvus__pb2.GetMetricsRequest.SerializeToString, + response_deserializer=milvus__pb2.GetMetricsResponse.FromString, + ) + self.GetReplicas = channel.unary_unary( + '/milvus.proto.query.QueryCoord/GetReplicas', + request_serializer=milvus__pb2.GetReplicasRequest.SerializeToString, + response_deserializer=milvus__pb2.GetReplicasResponse.FromString, + ) + self.GetShardLeaders = channel.unary_unary( + '/milvus.proto.query.QueryCoord/GetShardLeaders', + request_serializer=query__coord__pb2.GetShardLeadersRequest.SerializeToString, + response_deserializer=query__coord__pb2.GetShardLeadersResponse.FromString, + ) + self.CheckHealth = channel.unary_unary( + '/milvus.proto.query.QueryCoord/CheckHealth', + request_serializer=milvus__pb2.CheckHealthRequest.SerializeToString, + response_deserializer=milvus__pb2.CheckHealthResponse.FromString, + ) + self.CreateResourceGroup = channel.unary_unary( + '/milvus.proto.query.QueryCoord/CreateResourceGroup', + request_serializer=milvus__pb2.CreateResourceGroupRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.DropResourceGroup = channel.unary_unary( + '/milvus.proto.query.QueryCoord/DropResourceGroup', + request_serializer=milvus__pb2.DropResourceGroupRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.TransferNode = channel.unary_unary( + '/milvus.proto.query.QueryCoord/TransferNode', + request_serializer=milvus__pb2.TransferNodeRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.TransferReplica = channel.unary_unary( + '/milvus.proto.query.QueryCoord/TransferReplica', + request_serializer=query__coord__pb2.TransferReplicaRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.ListResourceGroups = channel.unary_unary( + '/milvus.proto.query.QueryCoord/ListResourceGroups', + request_serializer=milvus__pb2.ListResourceGroupsRequest.SerializeToString, + response_deserializer=milvus__pb2.ListResourceGroupsResponse.FromString, + ) + self.DescribeResourceGroup = channel.unary_unary( + '/milvus.proto.query.QueryCoord/DescribeResourceGroup', + request_serializer=query__coord__pb2.DescribeResourceGroupRequest.SerializeToString, + response_deserializer=query__coord__pb2.DescribeResourceGroupResponse.FromString, + ) + self.ListCheckers = channel.unary_unary( + '/milvus.proto.query.QueryCoord/ListCheckers', + request_serializer=query__coord__pb2.ListCheckersRequest.SerializeToString, + response_deserializer=query__coord__pb2.ListCheckersResponse.FromString, + ) + self.ActivateChecker = channel.unary_unary( + '/milvus.proto.query.QueryCoord/ActivateChecker', + request_serializer=query__coord__pb2.ActivateCheckerRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.DeactivateChecker = channel.unary_unary( + '/milvus.proto.query.QueryCoord/DeactivateChecker', + request_serializer=query__coord__pb2.DeactivateCheckerRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + + +class QueryCoordServicer(object): + """Missing associated documentation comment in .proto file.""" + + def GetComponentStates(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetTimeTickChannel(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetStatisticsChannel(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ShowCollections(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ShowPartitions(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def LoadPartitions(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ReleasePartitions(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def LoadCollection(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ReleaseCollection(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def SyncNewCreatedPartition(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetPartitionStates(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetSegmentInfo(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def LoadBalance(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ShowConfigurations(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetMetrics(self, request, context): + """https://wiki.lfaidata.foundation/display/MIL/MEP+8+--+Add+metrics+for+proxy + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetReplicas(self, request, context): + """https://wiki.lfaidata.foundation/display/MIL/MEP+23+--+Multiple+memory+replication+design + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetShardLeaders(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def CheckHealth(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def CreateResourceGroup(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def DropResourceGroup(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def TransferNode(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def TransferReplica(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ListResourceGroups(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def DescribeResourceGroup(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ListCheckers(self, request, context): + """ops interfaces + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ActivateChecker(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def DeactivateChecker(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + +def add_QueryCoordServicer_to_server(servicer, server): + rpc_method_handlers = { + 'GetComponentStates': grpc.unary_unary_rpc_method_handler( + servicer.GetComponentStates, + request_deserializer=milvus__pb2.GetComponentStatesRequest.FromString, + response_serializer=milvus__pb2.ComponentStates.SerializeToString, + ), + 'GetTimeTickChannel': grpc.unary_unary_rpc_method_handler( + servicer.GetTimeTickChannel, + request_deserializer=internal__pb2.GetTimeTickChannelRequest.FromString, + response_serializer=milvus__pb2.StringResponse.SerializeToString, + ), + 'GetStatisticsChannel': grpc.unary_unary_rpc_method_handler( + servicer.GetStatisticsChannel, + request_deserializer=internal__pb2.GetStatisticsChannelRequest.FromString, + response_serializer=milvus__pb2.StringResponse.SerializeToString, + ), + 'ShowCollections': grpc.unary_unary_rpc_method_handler( + servicer.ShowCollections, + request_deserializer=query__coord__pb2.ShowCollectionsRequest.FromString, + response_serializer=query__coord__pb2.ShowCollectionsResponse.SerializeToString, + ), + 'ShowPartitions': grpc.unary_unary_rpc_method_handler( + servicer.ShowPartitions, + request_deserializer=query__coord__pb2.ShowPartitionsRequest.FromString, + response_serializer=query__coord__pb2.ShowPartitionsResponse.SerializeToString, + ), + 'LoadPartitions': grpc.unary_unary_rpc_method_handler( + servicer.LoadPartitions, + request_deserializer=query__coord__pb2.LoadPartitionsRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'ReleasePartitions': grpc.unary_unary_rpc_method_handler( + servicer.ReleasePartitions, + request_deserializer=query__coord__pb2.ReleasePartitionsRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'LoadCollection': grpc.unary_unary_rpc_method_handler( + servicer.LoadCollection, + request_deserializer=query__coord__pb2.LoadCollectionRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'ReleaseCollection': grpc.unary_unary_rpc_method_handler( + servicer.ReleaseCollection, + request_deserializer=query__coord__pb2.ReleaseCollectionRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'SyncNewCreatedPartition': grpc.unary_unary_rpc_method_handler( + servicer.SyncNewCreatedPartition, + request_deserializer=query__coord__pb2.SyncNewCreatedPartitionRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'GetPartitionStates': grpc.unary_unary_rpc_method_handler( + servicer.GetPartitionStates, + request_deserializer=query__coord__pb2.GetPartitionStatesRequest.FromString, + response_serializer=query__coord__pb2.GetPartitionStatesResponse.SerializeToString, + ), + 'GetSegmentInfo': grpc.unary_unary_rpc_method_handler( + servicer.GetSegmentInfo, + request_deserializer=query__coord__pb2.GetSegmentInfoRequest.FromString, + response_serializer=query__coord__pb2.GetSegmentInfoResponse.SerializeToString, + ), + 'LoadBalance': grpc.unary_unary_rpc_method_handler( + servicer.LoadBalance, + request_deserializer=query__coord__pb2.LoadBalanceRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'ShowConfigurations': grpc.unary_unary_rpc_method_handler( + servicer.ShowConfigurations, + request_deserializer=internal__pb2.ShowConfigurationsRequest.FromString, + response_serializer=internal__pb2.ShowConfigurationsResponse.SerializeToString, + ), + 'GetMetrics': grpc.unary_unary_rpc_method_handler( + servicer.GetMetrics, + request_deserializer=milvus__pb2.GetMetricsRequest.FromString, + response_serializer=milvus__pb2.GetMetricsResponse.SerializeToString, + ), + 'GetReplicas': grpc.unary_unary_rpc_method_handler( + servicer.GetReplicas, + request_deserializer=milvus__pb2.GetReplicasRequest.FromString, + response_serializer=milvus__pb2.GetReplicasResponse.SerializeToString, + ), + 'GetShardLeaders': grpc.unary_unary_rpc_method_handler( + servicer.GetShardLeaders, + request_deserializer=query__coord__pb2.GetShardLeadersRequest.FromString, + response_serializer=query__coord__pb2.GetShardLeadersResponse.SerializeToString, + ), + 'CheckHealth': grpc.unary_unary_rpc_method_handler( + servicer.CheckHealth, + request_deserializer=milvus__pb2.CheckHealthRequest.FromString, + response_serializer=milvus__pb2.CheckHealthResponse.SerializeToString, + ), + 'CreateResourceGroup': grpc.unary_unary_rpc_method_handler( + servicer.CreateResourceGroup, + request_deserializer=milvus__pb2.CreateResourceGroupRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'DropResourceGroup': grpc.unary_unary_rpc_method_handler( + servicer.DropResourceGroup, + request_deserializer=milvus__pb2.DropResourceGroupRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'TransferNode': grpc.unary_unary_rpc_method_handler( + servicer.TransferNode, + request_deserializer=milvus__pb2.TransferNodeRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'TransferReplica': grpc.unary_unary_rpc_method_handler( + servicer.TransferReplica, + request_deserializer=query__coord__pb2.TransferReplicaRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'ListResourceGroups': grpc.unary_unary_rpc_method_handler( + servicer.ListResourceGroups, + request_deserializer=milvus__pb2.ListResourceGroupsRequest.FromString, + response_serializer=milvus__pb2.ListResourceGroupsResponse.SerializeToString, + ), + 'DescribeResourceGroup': grpc.unary_unary_rpc_method_handler( + servicer.DescribeResourceGroup, + request_deserializer=query__coord__pb2.DescribeResourceGroupRequest.FromString, + response_serializer=query__coord__pb2.DescribeResourceGroupResponse.SerializeToString, + ), + 'ListCheckers': grpc.unary_unary_rpc_method_handler( + servicer.ListCheckers, + request_deserializer=query__coord__pb2.ListCheckersRequest.FromString, + response_serializer=query__coord__pb2.ListCheckersResponse.SerializeToString, + ), + 'ActivateChecker': grpc.unary_unary_rpc_method_handler( + servicer.ActivateChecker, + request_deserializer=query__coord__pb2.ActivateCheckerRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'DeactivateChecker': grpc.unary_unary_rpc_method_handler( + servicer.DeactivateChecker, + request_deserializer=query__coord__pb2.DeactivateCheckerRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + } + generic_handler = grpc.method_handlers_generic_handler( + 'milvus.proto.query.QueryCoord', rpc_method_handlers) + server.add_generic_rpc_handlers((generic_handler,)) + + + # This class is part of an EXPERIMENTAL API. +class QueryCoord(object): + """Missing associated documentation comment in .proto file.""" + + @staticmethod + def GetComponentStates(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.query.QueryCoord/GetComponentStates', + milvus__pb2.GetComponentStatesRequest.SerializeToString, + milvus__pb2.ComponentStates.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetTimeTickChannel(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.query.QueryCoord/GetTimeTickChannel', + internal__pb2.GetTimeTickChannelRequest.SerializeToString, + milvus__pb2.StringResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetStatisticsChannel(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.query.QueryCoord/GetStatisticsChannel', + internal__pb2.GetStatisticsChannelRequest.SerializeToString, + milvus__pb2.StringResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def ShowCollections(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.query.QueryCoord/ShowCollections', + query__coord__pb2.ShowCollectionsRequest.SerializeToString, + query__coord__pb2.ShowCollectionsResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def ShowPartitions(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.query.QueryCoord/ShowPartitions', + query__coord__pb2.ShowPartitionsRequest.SerializeToString, + query__coord__pb2.ShowPartitionsResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def LoadPartitions(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.query.QueryCoord/LoadPartitions', + query__coord__pb2.LoadPartitionsRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def ReleasePartitions(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.query.QueryCoord/ReleasePartitions', + query__coord__pb2.ReleasePartitionsRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def LoadCollection(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.query.QueryCoord/LoadCollection', + query__coord__pb2.LoadCollectionRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def ReleaseCollection(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.query.QueryCoord/ReleaseCollection', + query__coord__pb2.ReleaseCollectionRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def SyncNewCreatedPartition(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.query.QueryCoord/SyncNewCreatedPartition', + query__coord__pb2.SyncNewCreatedPartitionRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetPartitionStates(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.query.QueryCoord/GetPartitionStates', + query__coord__pb2.GetPartitionStatesRequest.SerializeToString, + query__coord__pb2.GetPartitionStatesResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetSegmentInfo(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.query.QueryCoord/GetSegmentInfo', + query__coord__pb2.GetSegmentInfoRequest.SerializeToString, + query__coord__pb2.GetSegmentInfoResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def LoadBalance(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.query.QueryCoord/LoadBalance', + query__coord__pb2.LoadBalanceRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def ShowConfigurations(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.query.QueryCoord/ShowConfigurations', + internal__pb2.ShowConfigurationsRequest.SerializeToString, + internal__pb2.ShowConfigurationsResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetMetrics(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.query.QueryCoord/GetMetrics', + milvus__pb2.GetMetricsRequest.SerializeToString, + milvus__pb2.GetMetricsResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetReplicas(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.query.QueryCoord/GetReplicas', + milvus__pb2.GetReplicasRequest.SerializeToString, + milvus__pb2.GetReplicasResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetShardLeaders(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.query.QueryCoord/GetShardLeaders', + query__coord__pb2.GetShardLeadersRequest.SerializeToString, + query__coord__pb2.GetShardLeadersResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def CheckHealth(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.query.QueryCoord/CheckHealth', + milvus__pb2.CheckHealthRequest.SerializeToString, + milvus__pb2.CheckHealthResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def CreateResourceGroup(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.query.QueryCoord/CreateResourceGroup', + milvus__pb2.CreateResourceGroupRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def DropResourceGroup(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.query.QueryCoord/DropResourceGroup', + milvus__pb2.DropResourceGroupRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def TransferNode(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.query.QueryCoord/TransferNode', + milvus__pb2.TransferNodeRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def TransferReplica(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.query.QueryCoord/TransferReplica', + query__coord__pb2.TransferReplicaRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def ListResourceGroups(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.query.QueryCoord/ListResourceGroups', + milvus__pb2.ListResourceGroupsRequest.SerializeToString, + milvus__pb2.ListResourceGroupsResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def DescribeResourceGroup(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.query.QueryCoord/DescribeResourceGroup', + query__coord__pb2.DescribeResourceGroupRequest.SerializeToString, + query__coord__pb2.DescribeResourceGroupResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def ListCheckers(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.query.QueryCoord/ListCheckers', + query__coord__pb2.ListCheckersRequest.SerializeToString, + query__coord__pb2.ListCheckersResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def ActivateChecker(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.query.QueryCoord/ActivateChecker', + query__coord__pb2.ActivateCheckerRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def DeactivateChecker(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.query.QueryCoord/DeactivateChecker', + query__coord__pb2.DeactivateCheckerRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + +class QueryNodeStub(object): + """Missing associated documentation comment in .proto file.""" + + def __init__(self, channel): + """Constructor. + + Args: + channel: A grpc.Channel. + """ + self.GetComponentStates = channel.unary_unary( + '/milvus.proto.query.QueryNode/GetComponentStates', + request_serializer=milvus__pb2.GetComponentStatesRequest.SerializeToString, + response_deserializer=milvus__pb2.ComponentStates.FromString, + ) + self.GetTimeTickChannel = channel.unary_unary( + '/milvus.proto.query.QueryNode/GetTimeTickChannel', + request_serializer=internal__pb2.GetTimeTickChannelRequest.SerializeToString, + response_deserializer=milvus__pb2.StringResponse.FromString, + ) + self.GetStatisticsChannel = channel.unary_unary( + '/milvus.proto.query.QueryNode/GetStatisticsChannel', + request_serializer=internal__pb2.GetStatisticsChannelRequest.SerializeToString, + response_deserializer=milvus__pb2.StringResponse.FromString, + ) + self.WatchDmChannels = channel.unary_unary( + '/milvus.proto.query.QueryNode/WatchDmChannels', + request_serializer=query__coord__pb2.WatchDmChannelsRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.UnsubDmChannel = channel.unary_unary( + '/milvus.proto.query.QueryNode/UnsubDmChannel', + request_serializer=query__coord__pb2.UnsubDmChannelRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.LoadSegments = channel.unary_unary( + '/milvus.proto.query.QueryNode/LoadSegments', + request_serializer=query__coord__pb2.LoadSegmentsRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.ReleaseCollection = channel.unary_unary( + '/milvus.proto.query.QueryNode/ReleaseCollection', + request_serializer=query__coord__pb2.ReleaseCollectionRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.LoadPartitions = channel.unary_unary( + '/milvus.proto.query.QueryNode/LoadPartitions', + request_serializer=query__coord__pb2.LoadPartitionsRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.ReleasePartitions = channel.unary_unary( + '/milvus.proto.query.QueryNode/ReleasePartitions', + request_serializer=query__coord__pb2.ReleasePartitionsRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.ReleaseSegments = channel.unary_unary( + '/milvus.proto.query.QueryNode/ReleaseSegments', + request_serializer=query__coord__pb2.ReleaseSegmentsRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.GetSegmentInfo = channel.unary_unary( + '/milvus.proto.query.QueryNode/GetSegmentInfo', + request_serializer=query__coord__pb2.GetSegmentInfoRequest.SerializeToString, + response_deserializer=query__coord__pb2.GetSegmentInfoResponse.FromString, + ) + self.SyncReplicaSegments = channel.unary_unary( + '/milvus.proto.query.QueryNode/SyncReplicaSegments', + request_serializer=query__coord__pb2.SyncReplicaSegmentsRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.GetStatistics = channel.unary_unary( + '/milvus.proto.query.QueryNode/GetStatistics', + request_serializer=query__coord__pb2.GetStatisticsRequest.SerializeToString, + response_deserializer=internal__pb2.GetStatisticsResponse.FromString, + ) + self.Search = channel.unary_unary( + '/milvus.proto.query.QueryNode/Search', + request_serializer=query__coord__pb2.SearchRequest.SerializeToString, + response_deserializer=internal__pb2.SearchResults.FromString, + ) + self.HybridSearch = channel.unary_unary( + '/milvus.proto.query.QueryNode/HybridSearch', + request_serializer=query__coord__pb2.HybridSearchRequest.SerializeToString, + response_deserializer=query__coord__pb2.HybridSearchResult.FromString, + ) + self.SearchSegments = channel.unary_unary( + '/milvus.proto.query.QueryNode/SearchSegments', + request_serializer=query__coord__pb2.SearchRequest.SerializeToString, + response_deserializer=internal__pb2.SearchResults.FromString, + ) + self.Query = channel.unary_unary( + '/milvus.proto.query.QueryNode/Query', + request_serializer=query__coord__pb2.QueryRequest.SerializeToString, + response_deserializer=internal__pb2.RetrieveResults.FromString, + ) + self.QueryStream = channel.unary_stream( + '/milvus.proto.query.QueryNode/QueryStream', + request_serializer=query__coord__pb2.QueryRequest.SerializeToString, + response_deserializer=internal__pb2.RetrieveResults.FromString, + ) + self.QuerySegments = channel.unary_unary( + '/milvus.proto.query.QueryNode/QuerySegments', + request_serializer=query__coord__pb2.QueryRequest.SerializeToString, + response_deserializer=internal__pb2.RetrieveResults.FromString, + ) + self.QueryStreamSegments = channel.unary_stream( + '/milvus.proto.query.QueryNode/QueryStreamSegments', + request_serializer=query__coord__pb2.QueryRequest.SerializeToString, + response_deserializer=internal__pb2.RetrieveResults.FromString, + ) + self.ShowConfigurations = channel.unary_unary( + '/milvus.proto.query.QueryNode/ShowConfigurations', + request_serializer=internal__pb2.ShowConfigurationsRequest.SerializeToString, + response_deserializer=internal__pb2.ShowConfigurationsResponse.FromString, + ) + self.GetMetrics = channel.unary_unary( + '/milvus.proto.query.QueryNode/GetMetrics', + request_serializer=milvus__pb2.GetMetricsRequest.SerializeToString, + response_deserializer=milvus__pb2.GetMetricsResponse.FromString, + ) + self.GetDataDistribution = channel.unary_unary( + '/milvus.proto.query.QueryNode/GetDataDistribution', + request_serializer=query__coord__pb2.GetDataDistributionRequest.SerializeToString, + response_deserializer=query__coord__pb2.GetDataDistributionResponse.FromString, + ) + self.SyncDistribution = channel.unary_unary( + '/milvus.proto.query.QueryNode/SyncDistribution', + request_serializer=query__coord__pb2.SyncDistributionRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.Delete = channel.unary_unary( + '/milvus.proto.query.QueryNode/Delete', + request_serializer=query__coord__pb2.DeleteRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + + +class QueryNodeServicer(object): + """Missing associated documentation comment in .proto file.""" + + def GetComponentStates(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetTimeTickChannel(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetStatisticsChannel(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def WatchDmChannels(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def UnsubDmChannel(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def LoadSegments(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ReleaseCollection(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def LoadPartitions(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ReleasePartitions(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ReleaseSegments(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetSegmentInfo(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def SyncReplicaSegments(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetStatistics(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def Search(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def HybridSearch(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def SearchSegments(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def Query(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def QueryStream(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def QuerySegments(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def QueryStreamSegments(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ShowConfigurations(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetMetrics(self, request, context): + """https://wiki.lfaidata.foundation/display/MIL/MEP+8+--+Add+metrics+for+proxy + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetDataDistribution(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def SyncDistribution(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def Delete(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + +def add_QueryNodeServicer_to_server(servicer, server): + rpc_method_handlers = { + 'GetComponentStates': grpc.unary_unary_rpc_method_handler( + servicer.GetComponentStates, + request_deserializer=milvus__pb2.GetComponentStatesRequest.FromString, + response_serializer=milvus__pb2.ComponentStates.SerializeToString, + ), + 'GetTimeTickChannel': grpc.unary_unary_rpc_method_handler( + servicer.GetTimeTickChannel, + request_deserializer=internal__pb2.GetTimeTickChannelRequest.FromString, + response_serializer=milvus__pb2.StringResponse.SerializeToString, + ), + 'GetStatisticsChannel': grpc.unary_unary_rpc_method_handler( + servicer.GetStatisticsChannel, + request_deserializer=internal__pb2.GetStatisticsChannelRequest.FromString, + response_serializer=milvus__pb2.StringResponse.SerializeToString, + ), + 'WatchDmChannels': grpc.unary_unary_rpc_method_handler( + servicer.WatchDmChannels, + request_deserializer=query__coord__pb2.WatchDmChannelsRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'UnsubDmChannel': grpc.unary_unary_rpc_method_handler( + servicer.UnsubDmChannel, + request_deserializer=query__coord__pb2.UnsubDmChannelRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'LoadSegments': grpc.unary_unary_rpc_method_handler( + servicer.LoadSegments, + request_deserializer=query__coord__pb2.LoadSegmentsRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'ReleaseCollection': grpc.unary_unary_rpc_method_handler( + servicer.ReleaseCollection, + request_deserializer=query__coord__pb2.ReleaseCollectionRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'LoadPartitions': grpc.unary_unary_rpc_method_handler( + servicer.LoadPartitions, + request_deserializer=query__coord__pb2.LoadPartitionsRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'ReleasePartitions': grpc.unary_unary_rpc_method_handler( + servicer.ReleasePartitions, + request_deserializer=query__coord__pb2.ReleasePartitionsRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'ReleaseSegments': grpc.unary_unary_rpc_method_handler( + servicer.ReleaseSegments, + request_deserializer=query__coord__pb2.ReleaseSegmentsRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'GetSegmentInfo': grpc.unary_unary_rpc_method_handler( + servicer.GetSegmentInfo, + request_deserializer=query__coord__pb2.GetSegmentInfoRequest.FromString, + response_serializer=query__coord__pb2.GetSegmentInfoResponse.SerializeToString, + ), + 'SyncReplicaSegments': grpc.unary_unary_rpc_method_handler( + servicer.SyncReplicaSegments, + request_deserializer=query__coord__pb2.SyncReplicaSegmentsRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'GetStatistics': grpc.unary_unary_rpc_method_handler( + servicer.GetStatistics, + request_deserializer=query__coord__pb2.GetStatisticsRequest.FromString, + response_serializer=internal__pb2.GetStatisticsResponse.SerializeToString, + ), + 'Search': grpc.unary_unary_rpc_method_handler( + servicer.Search, + request_deserializer=query__coord__pb2.SearchRequest.FromString, + response_serializer=internal__pb2.SearchResults.SerializeToString, + ), + 'HybridSearch': grpc.unary_unary_rpc_method_handler( + servicer.HybridSearch, + request_deserializer=query__coord__pb2.HybridSearchRequest.FromString, + response_serializer=query__coord__pb2.HybridSearchResult.SerializeToString, + ), + 'SearchSegments': grpc.unary_unary_rpc_method_handler( + servicer.SearchSegments, + request_deserializer=query__coord__pb2.SearchRequest.FromString, + response_serializer=internal__pb2.SearchResults.SerializeToString, + ), + 'Query': grpc.unary_unary_rpc_method_handler( + servicer.Query, + request_deserializer=query__coord__pb2.QueryRequest.FromString, + response_serializer=internal__pb2.RetrieveResults.SerializeToString, + ), + 'QueryStream': grpc.unary_stream_rpc_method_handler( + servicer.QueryStream, + request_deserializer=query__coord__pb2.QueryRequest.FromString, + response_serializer=internal__pb2.RetrieveResults.SerializeToString, + ), + 'QuerySegments': grpc.unary_unary_rpc_method_handler( + servicer.QuerySegments, + request_deserializer=query__coord__pb2.QueryRequest.FromString, + response_serializer=internal__pb2.RetrieveResults.SerializeToString, + ), + 'QueryStreamSegments': grpc.unary_stream_rpc_method_handler( + servicer.QueryStreamSegments, + request_deserializer=query__coord__pb2.QueryRequest.FromString, + response_serializer=internal__pb2.RetrieveResults.SerializeToString, + ), + 'ShowConfigurations': grpc.unary_unary_rpc_method_handler( + servicer.ShowConfigurations, + request_deserializer=internal__pb2.ShowConfigurationsRequest.FromString, + response_serializer=internal__pb2.ShowConfigurationsResponse.SerializeToString, + ), + 'GetMetrics': grpc.unary_unary_rpc_method_handler( + servicer.GetMetrics, + request_deserializer=milvus__pb2.GetMetricsRequest.FromString, + response_serializer=milvus__pb2.GetMetricsResponse.SerializeToString, + ), + 'GetDataDistribution': grpc.unary_unary_rpc_method_handler( + servicer.GetDataDistribution, + request_deserializer=query__coord__pb2.GetDataDistributionRequest.FromString, + response_serializer=query__coord__pb2.GetDataDistributionResponse.SerializeToString, + ), + 'SyncDistribution': grpc.unary_unary_rpc_method_handler( + servicer.SyncDistribution, + request_deserializer=query__coord__pb2.SyncDistributionRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'Delete': grpc.unary_unary_rpc_method_handler( + servicer.Delete, + request_deserializer=query__coord__pb2.DeleteRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + } + generic_handler = grpc.method_handlers_generic_handler( + 'milvus.proto.query.QueryNode', rpc_method_handlers) + server.add_generic_rpc_handlers((generic_handler,)) + + + # This class is part of an EXPERIMENTAL API. +class QueryNode(object): + """Missing associated documentation comment in .proto file.""" + + @staticmethod + def GetComponentStates(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.query.QueryNode/GetComponentStates', + milvus__pb2.GetComponentStatesRequest.SerializeToString, + milvus__pb2.ComponentStates.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetTimeTickChannel(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.query.QueryNode/GetTimeTickChannel', + internal__pb2.GetTimeTickChannelRequest.SerializeToString, + milvus__pb2.StringResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetStatisticsChannel(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.query.QueryNode/GetStatisticsChannel', + internal__pb2.GetStatisticsChannelRequest.SerializeToString, + milvus__pb2.StringResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def WatchDmChannels(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.query.QueryNode/WatchDmChannels', + query__coord__pb2.WatchDmChannelsRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def UnsubDmChannel(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.query.QueryNode/UnsubDmChannel', + query__coord__pb2.UnsubDmChannelRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def LoadSegments(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.query.QueryNode/LoadSegments', + query__coord__pb2.LoadSegmentsRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def ReleaseCollection(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.query.QueryNode/ReleaseCollection', + query__coord__pb2.ReleaseCollectionRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def LoadPartitions(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.query.QueryNode/LoadPartitions', + query__coord__pb2.LoadPartitionsRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def ReleasePartitions(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.query.QueryNode/ReleasePartitions', + query__coord__pb2.ReleasePartitionsRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def ReleaseSegments(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.query.QueryNode/ReleaseSegments', + query__coord__pb2.ReleaseSegmentsRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetSegmentInfo(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.query.QueryNode/GetSegmentInfo', + query__coord__pb2.GetSegmentInfoRequest.SerializeToString, + query__coord__pb2.GetSegmentInfoResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def SyncReplicaSegments(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.query.QueryNode/SyncReplicaSegments', + query__coord__pb2.SyncReplicaSegmentsRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetStatistics(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.query.QueryNode/GetStatistics', + query__coord__pb2.GetStatisticsRequest.SerializeToString, + internal__pb2.GetStatisticsResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def Search(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.query.QueryNode/Search', + query__coord__pb2.SearchRequest.SerializeToString, + internal__pb2.SearchResults.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def HybridSearch(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.query.QueryNode/HybridSearch', + query__coord__pb2.HybridSearchRequest.SerializeToString, + query__coord__pb2.HybridSearchResult.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def SearchSegments(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.query.QueryNode/SearchSegments', + query__coord__pb2.SearchRequest.SerializeToString, + internal__pb2.SearchResults.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def Query(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.query.QueryNode/Query', + query__coord__pb2.QueryRequest.SerializeToString, + internal__pb2.RetrieveResults.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def QueryStream(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_stream(request, target, '/milvus.proto.query.QueryNode/QueryStream', + query__coord__pb2.QueryRequest.SerializeToString, + internal__pb2.RetrieveResults.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def QuerySegments(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.query.QueryNode/QuerySegments', + query__coord__pb2.QueryRequest.SerializeToString, + internal__pb2.RetrieveResults.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def QueryStreamSegments(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_stream(request, target, '/milvus.proto.query.QueryNode/QueryStreamSegments', + query__coord__pb2.QueryRequest.SerializeToString, + internal__pb2.RetrieveResults.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def ShowConfigurations(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.query.QueryNode/ShowConfigurations', + internal__pb2.ShowConfigurationsRequest.SerializeToString, + internal__pb2.ShowConfigurationsResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetMetrics(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.query.QueryNode/GetMetrics', + milvus__pb2.GetMetricsRequest.SerializeToString, + milvus__pb2.GetMetricsResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetDataDistribution(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.query.QueryNode/GetDataDistribution', + query__coord__pb2.GetDataDistributionRequest.SerializeToString, + query__coord__pb2.GetDataDistributionResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def SyncDistribution(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.query.QueryNode/SyncDistribution', + query__coord__pb2.SyncDistributionRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def Delete(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.query.QueryNode/Delete', + query__coord__pb2.DeleteRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) diff --git a/milvus_connector/protocol/rg_pb2.py b/milvus_connector/protocol/rg_pb2.py new file mode 100644 index 0000000..fbb06ef --- /dev/null +++ b/milvus_connector/protocol/rg_pb2.py @@ -0,0 +1,31 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: rg.proto +# Protobuf Python Version: 4.25.1 +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x08rg.proto\x12\x0fmilvus.proto.rg\"%\n\x12ResourceGroupLimit\x12\x0f\n\x07nodeNum\x18\x01 \x01(\x05\"/\n\x15ResourceGroupTransfer\x12\x16\n\x0eresource_group\x18\x01 \x01(\t\"\xeb\x01\n\x13ResourceGroupConfig\x12\x35\n\x08requests\x18\x01 \x01(\x0b\x32#.milvus.proto.rg.ResourceGroupLimit\x12\x33\n\x06limits\x18\x02 \x01(\x0b\x32#.milvus.proto.rg.ResourceGroupLimit\x12\x34\n\x04\x66rom\x18\x03 \x03(\x0b\x32&.milvus.proto.rg.ResourceGroupTransfer\x12\x32\n\x02to\x18\x04 \x03(\x0b\x32&.milvus.proto.rg.ResourceGroupTransferBp\n\x0eio.milvus.grpcB\x12ResourceGroupProtoP\x01Z0github.com/milvus-io/milvus-proto/go-api/v2/rgpb\xa0\x01\x01\xaa\x02\x12Milvus.Client.Grpcb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'rg_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + _globals['DESCRIPTOR']._options = None + _globals['DESCRIPTOR']._serialized_options = b'\n\016io.milvus.grpcB\022ResourceGroupProtoP\001Z0github.com/milvus-io/milvus-proto/go-api/v2/rgpb\240\001\001\252\002\022Milvus.Client.Grpc' + _globals['_RESOURCEGROUPLIMIT']._serialized_start=29 + _globals['_RESOURCEGROUPLIMIT']._serialized_end=66 + _globals['_RESOURCEGROUPTRANSFER']._serialized_start=68 + _globals['_RESOURCEGROUPTRANSFER']._serialized_end=115 + _globals['_RESOURCEGROUPCONFIG']._serialized_start=118 + _globals['_RESOURCEGROUPCONFIG']._serialized_end=353 +# @@protoc_insertion_point(module_scope) diff --git a/milvus_connector/protocol/rg_pb2.pyi b/milvus_connector/protocol/rg_pb2.pyi new file mode 100644 index 0000000..c9ba690 --- /dev/null +++ b/milvus_connector/protocol/rg_pb2.pyi @@ -0,0 +1,29 @@ +from google.protobuf.internal import containers as _containers +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Iterable as _Iterable, Mapping as _Mapping, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class ResourceGroupLimit(_message.Message): + __slots__ = ("nodeNum",) + NODENUM_FIELD_NUMBER: _ClassVar[int] + nodeNum: int + def __init__(self, nodeNum: _Optional[int] = ...) -> None: ... + +class ResourceGroupTransfer(_message.Message): + __slots__ = ("resource_group",) + RESOURCE_GROUP_FIELD_NUMBER: _ClassVar[int] + resource_group: str + def __init__(self, resource_group: _Optional[str] = ...) -> None: ... + +class ResourceGroupConfig(_message.Message): + __slots__ = ("requests", "limits", "to") + REQUESTS_FIELD_NUMBER: _ClassVar[int] + LIMITS_FIELD_NUMBER: _ClassVar[int] + FROM_FIELD_NUMBER: _ClassVar[int] + TO_FIELD_NUMBER: _ClassVar[int] + requests: ResourceGroupLimit + limits: ResourceGroupLimit + to: _containers.RepeatedCompositeFieldContainer[ResourceGroupTransfer] + def __init__(self, requests: _Optional[_Union[ResourceGroupLimit, _Mapping]] = ..., limits: _Optional[_Union[ResourceGroupLimit, _Mapping]] = ..., to: _Optional[_Iterable[_Union[ResourceGroupTransfer, _Mapping]]] = ..., **kwargs) -> None: ... diff --git a/milvus_connector/protocol/rg_pb2_grpc.py b/milvus_connector/protocol/rg_pb2_grpc.py new file mode 100644 index 0000000..2daafff --- /dev/null +++ b/milvus_connector/protocol/rg_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/milvus_connector/protocol/root_coord_pb2.py b/milvus_connector/protocol/root_coord_pb2.py new file mode 100644 index 0000000..c3728cd --- /dev/null +++ b/milvus_connector/protocol/root_coord_pb2.py @@ -0,0 +1,62 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: root_coord.proto +# Protobuf Python Version: 4.25.1 +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from . import common_pb2 as common__pb2 +from . import milvus_pb2 as milvus__pb2 +from . import internal_pb2 as internal__pb2 +from . import proxy_pb2 as proxy__pb2 +from . import etcd_meta_pb2 as etcd__meta__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x10root_coord.proto\x12\x16milvus.proto.rootcoord\x1a\x0c\x63ommon.proto\x1a\x0cmilvus.proto\x1a\x0einternal.proto\x1a\x0bproxy.proto\x1a\x0f\x65tcd_meta.proto\"R\n\x15\x41llocTimestampRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\r\n\x05\x63ount\x18\x03 \x01(\r\"g\n\x16\x41llocTimestampResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\x11\n\ttimestamp\x18\x02 \x01(\x04\x12\r\n\x05\x63ount\x18\x03 \x01(\r\"K\n\x0e\x41llocIDRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\r\n\x05\x63ount\x18\x02 \x01(\r\"Y\n\x0f\x41llocIDResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\n\n\x02ID\x18\x02 \x01(\x03\x12\r\n\x05\x63ount\x18\x03 \x01(\r\"\xfb\x01\n\x0cImportResult\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\x0f\n\x07task_id\x18\x02 \x01(\x03\x12\x13\n\x0b\x64\x61tanode_id\x18\x03 \x01(\x03\x12/\n\x05state\x18\x04 \x01(\x0e\x32 .milvus.proto.common.ImportState\x12\x10\n\x08segments\x18\x05 \x03(\x03\x12\x10\n\x08\x61uto_ids\x18\x06 \x03(\x03\x12\x11\n\trow_count\x18\x07 \x01(\x03\x12\x30\n\x05infos\x18\x08 \x03(\x0b\x32!.milvus.proto.common.KeyValuePair\"o\n\x17\x44\x65scribeSegmentsRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x14\n\x0c\x63ollectionID\x18\x02 \x01(\x03\x12\x12\n\nsegmentIDs\x18\x03 \x03(\x03\"O\n\x0fSegmentBaseInfo\x12\x14\n\x0c\x63ollectionID\x18\x01 \x01(\x03\x12\x13\n\x0bpartitionID\x18\x02 \x01(\x03\x12\x11\n\tsegmentID\x18\x03 \x01(\x03\"\xb0\x02\n\x0cSegmentInfos\x12:\n\tbase_info\x18\x01 \x01(\x0b\x32\'.milvus.proto.rootcoord.SegmentBaseInfo\x12\x38\n\x0bindex_infos\x18\x02 \x03(\x0b\x32#.milvus.proto.etcd.SegmentIndexInfo\x12T\n\x11\x65xtra_index_infos\x18\x03 \x03(\x0b\x32\x39.milvus.proto.rootcoord.SegmentInfos.ExtraIndexInfosEntry\x1aT\n\x14\x45xtraIndexInfosEntry\x12\x0b\n\x03key\x18\x01 \x01(\x03\x12+\n\x05value\x18\x02 \x01(\x0b\x32\x1c.milvus.proto.etcd.IndexInfo:\x02\x38\x01\"\x93\x02\n\x18\x44\x65scribeSegmentsResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\x14\n\x0c\x63ollectionID\x18\x02 \x01(\x03\x12Y\n\rsegment_infos\x18\x03 \x03(\x0b\x32\x42.milvus.proto.rootcoord.DescribeSegmentsResponse.SegmentInfosEntry\x1aY\n\x11SegmentInfosEntry\x12\x0b\n\x03key\x18\x01 \x01(\x03\x12\x33\n\x05value\x18\x02 \x01(\x0b\x32$.milvus.proto.rootcoord.SegmentInfos:\x02\x38\x01\"T\n\x14GetCredentialRequest\x12*\n\x04\x62\x61se\x18\x01 \x01(\x0b\x32\x1c.milvus.proto.common.MsgBase\x12\x10\n\x08username\x18\x02 \x01(\t\"h\n\x15GetCredentialResponse\x12+\n\x06status\x18\x01 \x01(\x0b\x32\x1b.milvus.proto.common.Status\x12\x10\n\x08username\x18\x02 \x01(\t\x12\x10\n\x08password\x18\x03 \x01(\t2\xc4&\n\tRootCoord\x12l\n\x12GetComponentStates\x12..milvus.proto.milvus.GetComponentStatesRequest\x1a$.milvus.proto.milvus.ComponentStates\"\x00\x12m\n\x12GetTimeTickChannel\x12\x30.milvus.proto.internal.GetTimeTickChannelRequest\x1a#.milvus.proto.milvus.StringResponse\"\x00\x12q\n\x14GetStatisticsChannel\x12\x32.milvus.proto.internal.GetStatisticsChannelRequest\x1a#.milvus.proto.milvus.StringResponse\"\x00\x12_\n\x10\x43reateCollection\x12,.milvus.proto.milvus.CreateCollectionRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12[\n\x0e\x44ropCollection\x12*.milvus.proto.milvus.DropCollectionRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12_\n\rHasCollection\x12).milvus.proto.milvus.HasCollectionRequest\x1a!.milvus.proto.milvus.BoolResponse\"\x00\x12w\n\x12\x44\x65scribeCollection\x12..milvus.proto.milvus.DescribeCollectionRequest\x1a/.milvus.proto.milvus.DescribeCollectionResponse\"\x00\x12\x7f\n\x1a\x44\x65scribeCollectionInternal\x12..milvus.proto.milvus.DescribeCollectionRequest\x1a/.milvus.proto.milvus.DescribeCollectionResponse\"\x00\x12U\n\x0b\x43reateAlias\x12\'.milvus.proto.milvus.CreateAliasRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12Q\n\tDropAlias\x12%.milvus.proto.milvus.DropAliasRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12S\n\nAlterAlias\x12&.milvus.proto.milvus.AlterAliasRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12h\n\rDescribeAlias\x12).milvus.proto.milvus.DescribeAliasRequest\x1a*.milvus.proto.milvus.DescribeAliasResponse\"\x00\x12\x62\n\x0bListAliases\x12\'.milvus.proto.milvus.ListAliasesRequest\x1a(.milvus.proto.milvus.ListAliasesResponse\"\x00\x12n\n\x0fShowCollections\x12+.milvus.proto.milvus.ShowCollectionsRequest\x1a,.milvus.proto.milvus.ShowCollectionsResponse\"\x00\x12]\n\x0f\x41lterCollection\x12+.milvus.proto.milvus.AlterCollectionRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12]\n\x0f\x43reatePartition\x12+.milvus.proto.milvus.CreatePartitionRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12Y\n\rDropPartition\x12).milvus.proto.milvus.DropPartitionRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12]\n\x0cHasPartition\x12(.milvus.proto.milvus.HasPartitionRequest\x1a!.milvus.proto.milvus.BoolResponse\"\x00\x12k\n\x0eShowPartitions\x12*.milvus.proto.milvus.ShowPartitionsRequest\x1a+.milvus.proto.milvus.ShowPartitionsResponse\"\x00\x12s\n\x16ShowPartitionsInternal\x12*.milvus.proto.milvus.ShowPartitionsRequest\x1a+.milvus.proto.milvus.ShowPartitionsResponse\"\x00\x12\x65\n\x0cShowSegments\x12(.milvus.proto.milvus.ShowSegmentsRequest\x1a).milvus.proto.milvus.ShowSegmentsResponse\"\x00\x12q\n\x0e\x41llocTimestamp\x12-.milvus.proto.rootcoord.AllocTimestampRequest\x1a..milvus.proto.rootcoord.AllocTimestampResponse\"\x00\x12\\\n\x07\x41llocID\x12&.milvus.proto.rootcoord.AllocIDRequest\x1a\'.milvus.proto.rootcoord.AllocIDResponse\"\x00\x12\x61\n\x15UpdateChannelTimeTick\x12).milvus.proto.internal.ChannelTimeTickMsg\x1a\x1b.milvus.proto.common.Status\"\x00\x12r\n\x1dInvalidateCollectionMetaCache\x12\x32.milvus.proto.proxy.InvalidateCollMetaCacheRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12{\n\x12ShowConfigurations\x12\x30.milvus.proto.internal.ShowConfigurationsRequest\x1a\x31.milvus.proto.internal.ShowConfigurationsResponse\"\x00\x12_\n\nGetMetrics\x12&.milvus.proto.milvus.GetMetricsRequest\x1a\'.milvus.proto.milvus.GetMetricsResponse\"\x00\x12S\n\x06Import\x12\".milvus.proto.milvus.ImportRequest\x1a#.milvus.proto.milvus.ImportResponse\"\x00\x12k\n\x0eGetImportState\x12*.milvus.proto.milvus.GetImportStateRequest\x1a+.milvus.proto.milvus.GetImportStateResponse\"\x00\x12n\n\x0fListImportTasks\x12+.milvus.proto.milvus.ListImportTasksRequest\x1a,.milvus.proto.milvus.ListImportTasksResponse\"\x00\x12S\n\x0cReportImport\x12$.milvus.proto.rootcoord.ImportResult\x1a\x1b.milvus.proto.common.Status\"\x00\x12X\n\x10\x43reateCredential\x12%.milvus.proto.internal.CredentialInfo\x1a\x1b.milvus.proto.common.Status\"\x00\x12X\n\x10UpdateCredential\x12%.milvus.proto.internal.CredentialInfo\x1a\x1b.milvus.proto.common.Status\"\x00\x12_\n\x10\x44\x65leteCredential\x12,.milvus.proto.milvus.DeleteCredentialRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12h\n\rListCredUsers\x12).milvus.proto.milvus.ListCredUsersRequest\x1a*.milvus.proto.milvus.ListCredUsersResponse\"\x00\x12n\n\rGetCredential\x12,.milvus.proto.rootcoord.GetCredentialRequest\x1a-.milvus.proto.rootcoord.GetCredentialResponse\"\x00\x12S\n\nCreateRole\x12&.milvus.proto.milvus.CreateRoleRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12O\n\x08\x44ropRole\x12$.milvus.proto.milvus.DropRoleRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12]\n\x0fOperateUserRole\x12+.milvus.proto.milvus.OperateUserRoleRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12_\n\nSelectRole\x12&.milvus.proto.milvus.SelectRoleRequest\x1a\'.milvus.proto.milvus.SelectRoleResponse\"\x00\x12_\n\nSelectUser\x12&.milvus.proto.milvus.SelectUserRequest\x1a\'.milvus.proto.milvus.SelectUserResponse\"\x00\x12_\n\x10OperatePrivilege\x12,.milvus.proto.milvus.OperatePrivilegeRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12\x62\n\x0bSelectGrant\x12\'.milvus.proto.milvus.SelectGrantRequest\x1a(.milvus.proto.milvus.SelectGrantResponse\"\x00\x12\x63\n\nListPolicy\x12(.milvus.proto.internal.ListPolicyRequest\x1a).milvus.proto.internal.ListPolicyResponse\"\x00\x12\x62\n\x0b\x43heckHealth\x12\'.milvus.proto.milvus.CheckHealthRequest\x1a(.milvus.proto.milvus.CheckHealthResponse\"\x00\x12_\n\x10RenameCollection\x12,.milvus.proto.milvus.RenameCollectionRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12[\n\x0e\x43reateDatabase\x12*.milvus.proto.milvus.CreateDatabaseRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12W\n\x0c\x44ropDatabase\x12(.milvus.proto.milvus.DropDatabaseRequest\x1a\x1b.milvus.proto.common.Status\"\x00\x12h\n\rListDatabases\x12).milvus.proto.milvus.ListDatabasesRequest\x1a*.milvus.proto.milvus.ListDatabasesResponse\"\x00\x42\x38Z6github.com/milvus-io/milvus/internal/proto/rootcoordpbb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'root_coord_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + _globals['DESCRIPTOR']._options = None + _globals['DESCRIPTOR']._serialized_options = b'Z6github.com/milvus-io/milvus/internal/proto/rootcoordpb' + _globals['_SEGMENTINFOS_EXTRAINDEXINFOSENTRY']._options = None + _globals['_SEGMENTINFOS_EXTRAINDEXINFOSENTRY']._serialized_options = b'8\001' + _globals['_DESCRIBESEGMENTSRESPONSE_SEGMENTINFOSENTRY']._options = None + _globals['_DESCRIBESEGMENTSRESPONSE_SEGMENTINFOSENTRY']._serialized_options = b'8\001' + _globals['_ALLOCTIMESTAMPREQUEST']._serialized_start=118 + _globals['_ALLOCTIMESTAMPREQUEST']._serialized_end=200 + _globals['_ALLOCTIMESTAMPRESPONSE']._serialized_start=202 + _globals['_ALLOCTIMESTAMPRESPONSE']._serialized_end=305 + _globals['_ALLOCIDREQUEST']._serialized_start=307 + _globals['_ALLOCIDREQUEST']._serialized_end=382 + _globals['_ALLOCIDRESPONSE']._serialized_start=384 + _globals['_ALLOCIDRESPONSE']._serialized_end=473 + _globals['_IMPORTRESULT']._serialized_start=476 + _globals['_IMPORTRESULT']._serialized_end=727 + _globals['_DESCRIBESEGMENTSREQUEST']._serialized_start=729 + _globals['_DESCRIBESEGMENTSREQUEST']._serialized_end=840 + _globals['_SEGMENTBASEINFO']._serialized_start=842 + _globals['_SEGMENTBASEINFO']._serialized_end=921 + _globals['_SEGMENTINFOS']._serialized_start=924 + _globals['_SEGMENTINFOS']._serialized_end=1228 + _globals['_SEGMENTINFOS_EXTRAINDEXINFOSENTRY']._serialized_start=1144 + _globals['_SEGMENTINFOS_EXTRAINDEXINFOSENTRY']._serialized_end=1228 + _globals['_DESCRIBESEGMENTSRESPONSE']._serialized_start=1231 + _globals['_DESCRIBESEGMENTSRESPONSE']._serialized_end=1506 + _globals['_DESCRIBESEGMENTSRESPONSE_SEGMENTINFOSENTRY']._serialized_start=1417 + _globals['_DESCRIBESEGMENTSRESPONSE_SEGMENTINFOSENTRY']._serialized_end=1506 + _globals['_GETCREDENTIALREQUEST']._serialized_start=1508 + _globals['_GETCREDENTIALREQUEST']._serialized_end=1592 + _globals['_GETCREDENTIALRESPONSE']._serialized_start=1594 + _globals['_GETCREDENTIALRESPONSE']._serialized_end=1698 + _globals['_ROOTCOORD']._serialized_start=1701 + _globals['_ROOTCOORD']._serialized_end=6633 +# @@protoc_insertion_point(module_scope) diff --git a/milvus_connector/protocol/root_coord_pb2.pyi b/milvus_connector/protocol/root_coord_pb2.pyi new file mode 100644 index 0000000..40877d6 --- /dev/null +++ b/milvus_connector/protocol/root_coord_pb2.pyi @@ -0,0 +1,139 @@ +from . import common_pb2 as _common_pb2 +from . import milvus_pb2 as _milvus_pb2 +from . import internal_pb2 as _internal_pb2 +from . import proxy_pb2 as _proxy_pb2 +from . import etcd_meta_pb2 as _etcd_meta_pb2 +from google.protobuf.internal import containers as _containers +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Iterable as _Iterable, Mapping as _Mapping, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class AllocTimestampRequest(_message.Message): + __slots__ = ("base", "count") + BASE_FIELD_NUMBER: _ClassVar[int] + COUNT_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + count: int + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., count: _Optional[int] = ...) -> None: ... + +class AllocTimestampResponse(_message.Message): + __slots__ = ("status", "timestamp", "count") + STATUS_FIELD_NUMBER: _ClassVar[int] + TIMESTAMP_FIELD_NUMBER: _ClassVar[int] + COUNT_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + timestamp: int + count: int + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., timestamp: _Optional[int] = ..., count: _Optional[int] = ...) -> None: ... + +class AllocIDRequest(_message.Message): + __slots__ = ("base", "count") + BASE_FIELD_NUMBER: _ClassVar[int] + COUNT_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + count: int + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., count: _Optional[int] = ...) -> None: ... + +class AllocIDResponse(_message.Message): + __slots__ = ("status", "ID", "count") + STATUS_FIELD_NUMBER: _ClassVar[int] + ID_FIELD_NUMBER: _ClassVar[int] + COUNT_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + ID: int + count: int + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., ID: _Optional[int] = ..., count: _Optional[int] = ...) -> None: ... + +class ImportResult(_message.Message): + __slots__ = ("status", "task_id", "datanode_id", "state", "segments", "auto_ids", "row_count", "infos") + STATUS_FIELD_NUMBER: _ClassVar[int] + TASK_ID_FIELD_NUMBER: _ClassVar[int] + DATANODE_ID_FIELD_NUMBER: _ClassVar[int] + STATE_FIELD_NUMBER: _ClassVar[int] + SEGMENTS_FIELD_NUMBER: _ClassVar[int] + AUTO_IDS_FIELD_NUMBER: _ClassVar[int] + ROW_COUNT_FIELD_NUMBER: _ClassVar[int] + INFOS_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + task_id: int + datanode_id: int + state: _common_pb2.ImportState + segments: _containers.RepeatedScalarFieldContainer[int] + auto_ids: _containers.RepeatedScalarFieldContainer[int] + row_count: int + infos: _containers.RepeatedCompositeFieldContainer[_common_pb2.KeyValuePair] + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., task_id: _Optional[int] = ..., datanode_id: _Optional[int] = ..., state: _Optional[_Union[_common_pb2.ImportState, str]] = ..., segments: _Optional[_Iterable[int]] = ..., auto_ids: _Optional[_Iterable[int]] = ..., row_count: _Optional[int] = ..., infos: _Optional[_Iterable[_Union[_common_pb2.KeyValuePair, _Mapping]]] = ...) -> None: ... + +class DescribeSegmentsRequest(_message.Message): + __slots__ = ("base", "collectionID", "segmentIDs") + BASE_FIELD_NUMBER: _ClassVar[int] + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + SEGMENTIDS_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + collectionID: int + segmentIDs: _containers.RepeatedScalarFieldContainer[int] + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., collectionID: _Optional[int] = ..., segmentIDs: _Optional[_Iterable[int]] = ...) -> None: ... + +class SegmentBaseInfo(_message.Message): + __slots__ = ("collectionID", "partitionID", "segmentID") + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + PARTITIONID_FIELD_NUMBER: _ClassVar[int] + SEGMENTID_FIELD_NUMBER: _ClassVar[int] + collectionID: int + partitionID: int + segmentID: int + def __init__(self, collectionID: _Optional[int] = ..., partitionID: _Optional[int] = ..., segmentID: _Optional[int] = ...) -> None: ... + +class SegmentInfos(_message.Message): + __slots__ = ("base_info", "index_infos", "extra_index_infos") + class ExtraIndexInfosEntry(_message.Message): + __slots__ = ("key", "value") + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: int + value: _etcd_meta_pb2.IndexInfo + def __init__(self, key: _Optional[int] = ..., value: _Optional[_Union[_etcd_meta_pb2.IndexInfo, _Mapping]] = ...) -> None: ... + BASE_INFO_FIELD_NUMBER: _ClassVar[int] + INDEX_INFOS_FIELD_NUMBER: _ClassVar[int] + EXTRA_INDEX_INFOS_FIELD_NUMBER: _ClassVar[int] + base_info: SegmentBaseInfo + index_infos: _containers.RepeatedCompositeFieldContainer[_etcd_meta_pb2.SegmentIndexInfo] + extra_index_infos: _containers.MessageMap[int, _etcd_meta_pb2.IndexInfo] + def __init__(self, base_info: _Optional[_Union[SegmentBaseInfo, _Mapping]] = ..., index_infos: _Optional[_Iterable[_Union[_etcd_meta_pb2.SegmentIndexInfo, _Mapping]]] = ..., extra_index_infos: _Optional[_Mapping[int, _etcd_meta_pb2.IndexInfo]] = ...) -> None: ... + +class DescribeSegmentsResponse(_message.Message): + __slots__ = ("status", "collectionID", "segment_infos") + class SegmentInfosEntry(_message.Message): + __slots__ = ("key", "value") + KEY_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + key: int + value: SegmentInfos + def __init__(self, key: _Optional[int] = ..., value: _Optional[_Union[SegmentInfos, _Mapping]] = ...) -> None: ... + STATUS_FIELD_NUMBER: _ClassVar[int] + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + SEGMENT_INFOS_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + collectionID: int + segment_infos: _containers.MessageMap[int, SegmentInfos] + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., collectionID: _Optional[int] = ..., segment_infos: _Optional[_Mapping[int, SegmentInfos]] = ...) -> None: ... + +class GetCredentialRequest(_message.Message): + __slots__ = ("base", "username") + BASE_FIELD_NUMBER: _ClassVar[int] + USERNAME_FIELD_NUMBER: _ClassVar[int] + base: _common_pb2.MsgBase + username: str + def __init__(self, base: _Optional[_Union[_common_pb2.MsgBase, _Mapping]] = ..., username: _Optional[str] = ...) -> None: ... + +class GetCredentialResponse(_message.Message): + __slots__ = ("status", "username", "password") + STATUS_FIELD_NUMBER: _ClassVar[int] + USERNAME_FIELD_NUMBER: _ClassVar[int] + PASSWORD_FIELD_NUMBER: _ClassVar[int] + status: _common_pb2.Status + username: str + password: str + def __init__(self, status: _Optional[_Union[_common_pb2.Status, _Mapping]] = ..., username: _Optional[str] = ..., password: _Optional[str] = ...) -> None: ... diff --git a/milvus_connector/protocol/root_coord_pb2_grpc.py b/milvus_connector/protocol/root_coord_pb2_grpc.py new file mode 100644 index 0000000..dfd8bd9 --- /dev/null +++ b/milvus_connector/protocol/root_coord_pb2_grpc.py @@ -0,0 +1,1711 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + +from . import common_pb2 as common__pb2 +from . import internal_pb2 as internal__pb2 +from . import milvus_pb2 as milvus__pb2 +from . import proxy_pb2 as proxy__pb2 +from . import root_coord_pb2 as root__coord__pb2 + + +class RootCoordStub(object): + """Missing associated documentation comment in .proto file.""" + + def __init__(self, channel): + """Constructor. + + Args: + channel: A grpc.Channel. + """ + self.GetComponentStates = channel.unary_unary( + '/milvus.proto.rootcoord.RootCoord/GetComponentStates', + request_serializer=milvus__pb2.GetComponentStatesRequest.SerializeToString, + response_deserializer=milvus__pb2.ComponentStates.FromString, + ) + self.GetTimeTickChannel = channel.unary_unary( + '/milvus.proto.rootcoord.RootCoord/GetTimeTickChannel', + request_serializer=internal__pb2.GetTimeTickChannelRequest.SerializeToString, + response_deserializer=milvus__pb2.StringResponse.FromString, + ) + self.GetStatisticsChannel = channel.unary_unary( + '/milvus.proto.rootcoord.RootCoord/GetStatisticsChannel', + request_serializer=internal__pb2.GetStatisticsChannelRequest.SerializeToString, + response_deserializer=milvus__pb2.StringResponse.FromString, + ) + self.CreateCollection = channel.unary_unary( + '/milvus.proto.rootcoord.RootCoord/CreateCollection', + request_serializer=milvus__pb2.CreateCollectionRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.DropCollection = channel.unary_unary( + '/milvus.proto.rootcoord.RootCoord/DropCollection', + request_serializer=milvus__pb2.DropCollectionRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.HasCollection = channel.unary_unary( + '/milvus.proto.rootcoord.RootCoord/HasCollection', + request_serializer=milvus__pb2.HasCollectionRequest.SerializeToString, + response_deserializer=milvus__pb2.BoolResponse.FromString, + ) + self.DescribeCollection = channel.unary_unary( + '/milvus.proto.rootcoord.RootCoord/DescribeCollection', + request_serializer=milvus__pb2.DescribeCollectionRequest.SerializeToString, + response_deserializer=milvus__pb2.DescribeCollectionResponse.FromString, + ) + self.DescribeCollectionInternal = channel.unary_unary( + '/milvus.proto.rootcoord.RootCoord/DescribeCollectionInternal', + request_serializer=milvus__pb2.DescribeCollectionRequest.SerializeToString, + response_deserializer=milvus__pb2.DescribeCollectionResponse.FromString, + ) + self.CreateAlias = channel.unary_unary( + '/milvus.proto.rootcoord.RootCoord/CreateAlias', + request_serializer=milvus__pb2.CreateAliasRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.DropAlias = channel.unary_unary( + '/milvus.proto.rootcoord.RootCoord/DropAlias', + request_serializer=milvus__pb2.DropAliasRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.AlterAlias = channel.unary_unary( + '/milvus.proto.rootcoord.RootCoord/AlterAlias', + request_serializer=milvus__pb2.AlterAliasRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.DescribeAlias = channel.unary_unary( + '/milvus.proto.rootcoord.RootCoord/DescribeAlias', + request_serializer=milvus__pb2.DescribeAliasRequest.SerializeToString, + response_deserializer=milvus__pb2.DescribeAliasResponse.FromString, + ) + self.ListAliases = channel.unary_unary( + '/milvus.proto.rootcoord.RootCoord/ListAliases', + request_serializer=milvus__pb2.ListAliasesRequest.SerializeToString, + response_deserializer=milvus__pb2.ListAliasesResponse.FromString, + ) + self.ShowCollections = channel.unary_unary( + '/milvus.proto.rootcoord.RootCoord/ShowCollections', + request_serializer=milvus__pb2.ShowCollectionsRequest.SerializeToString, + response_deserializer=milvus__pb2.ShowCollectionsResponse.FromString, + ) + self.AlterCollection = channel.unary_unary( + '/milvus.proto.rootcoord.RootCoord/AlterCollection', + request_serializer=milvus__pb2.AlterCollectionRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.CreatePartition = channel.unary_unary( + '/milvus.proto.rootcoord.RootCoord/CreatePartition', + request_serializer=milvus__pb2.CreatePartitionRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.DropPartition = channel.unary_unary( + '/milvus.proto.rootcoord.RootCoord/DropPartition', + request_serializer=milvus__pb2.DropPartitionRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.HasPartition = channel.unary_unary( + '/milvus.proto.rootcoord.RootCoord/HasPartition', + request_serializer=milvus__pb2.HasPartitionRequest.SerializeToString, + response_deserializer=milvus__pb2.BoolResponse.FromString, + ) + self.ShowPartitions = channel.unary_unary( + '/milvus.proto.rootcoord.RootCoord/ShowPartitions', + request_serializer=milvus__pb2.ShowPartitionsRequest.SerializeToString, + response_deserializer=milvus__pb2.ShowPartitionsResponse.FromString, + ) + self.ShowPartitionsInternal = channel.unary_unary( + '/milvus.proto.rootcoord.RootCoord/ShowPartitionsInternal', + request_serializer=milvus__pb2.ShowPartitionsRequest.SerializeToString, + response_deserializer=milvus__pb2.ShowPartitionsResponse.FromString, + ) + self.ShowSegments = channel.unary_unary( + '/milvus.proto.rootcoord.RootCoord/ShowSegments', + request_serializer=milvus__pb2.ShowSegmentsRequest.SerializeToString, + response_deserializer=milvus__pb2.ShowSegmentsResponse.FromString, + ) + self.AllocTimestamp = channel.unary_unary( + '/milvus.proto.rootcoord.RootCoord/AllocTimestamp', + request_serializer=root__coord__pb2.AllocTimestampRequest.SerializeToString, + response_deserializer=root__coord__pb2.AllocTimestampResponse.FromString, + ) + self.AllocID = channel.unary_unary( + '/milvus.proto.rootcoord.RootCoord/AllocID', + request_serializer=root__coord__pb2.AllocIDRequest.SerializeToString, + response_deserializer=root__coord__pb2.AllocIDResponse.FromString, + ) + self.UpdateChannelTimeTick = channel.unary_unary( + '/milvus.proto.rootcoord.RootCoord/UpdateChannelTimeTick', + request_serializer=internal__pb2.ChannelTimeTickMsg.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.InvalidateCollectionMetaCache = channel.unary_unary( + '/milvus.proto.rootcoord.RootCoord/InvalidateCollectionMetaCache', + request_serializer=proxy__pb2.InvalidateCollMetaCacheRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.ShowConfigurations = channel.unary_unary( + '/milvus.proto.rootcoord.RootCoord/ShowConfigurations', + request_serializer=internal__pb2.ShowConfigurationsRequest.SerializeToString, + response_deserializer=internal__pb2.ShowConfigurationsResponse.FromString, + ) + self.GetMetrics = channel.unary_unary( + '/milvus.proto.rootcoord.RootCoord/GetMetrics', + request_serializer=milvus__pb2.GetMetricsRequest.SerializeToString, + response_deserializer=milvus__pb2.GetMetricsResponse.FromString, + ) + self.Import = channel.unary_unary( + '/milvus.proto.rootcoord.RootCoord/Import', + request_serializer=milvus__pb2.ImportRequest.SerializeToString, + response_deserializer=milvus__pb2.ImportResponse.FromString, + ) + self.GetImportState = channel.unary_unary( + '/milvus.proto.rootcoord.RootCoord/GetImportState', + request_serializer=milvus__pb2.GetImportStateRequest.SerializeToString, + response_deserializer=milvus__pb2.GetImportStateResponse.FromString, + ) + self.ListImportTasks = channel.unary_unary( + '/milvus.proto.rootcoord.RootCoord/ListImportTasks', + request_serializer=milvus__pb2.ListImportTasksRequest.SerializeToString, + response_deserializer=milvus__pb2.ListImportTasksResponse.FromString, + ) + self.ReportImport = channel.unary_unary( + '/milvus.proto.rootcoord.RootCoord/ReportImport', + request_serializer=root__coord__pb2.ImportResult.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.CreateCredential = channel.unary_unary( + '/milvus.proto.rootcoord.RootCoord/CreateCredential', + request_serializer=internal__pb2.CredentialInfo.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.UpdateCredential = channel.unary_unary( + '/milvus.proto.rootcoord.RootCoord/UpdateCredential', + request_serializer=internal__pb2.CredentialInfo.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.DeleteCredential = channel.unary_unary( + '/milvus.proto.rootcoord.RootCoord/DeleteCredential', + request_serializer=milvus__pb2.DeleteCredentialRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.ListCredUsers = channel.unary_unary( + '/milvus.proto.rootcoord.RootCoord/ListCredUsers', + request_serializer=milvus__pb2.ListCredUsersRequest.SerializeToString, + response_deserializer=milvus__pb2.ListCredUsersResponse.FromString, + ) + self.GetCredential = channel.unary_unary( + '/milvus.proto.rootcoord.RootCoord/GetCredential', + request_serializer=root__coord__pb2.GetCredentialRequest.SerializeToString, + response_deserializer=root__coord__pb2.GetCredentialResponse.FromString, + ) + self.CreateRole = channel.unary_unary( + '/milvus.proto.rootcoord.RootCoord/CreateRole', + request_serializer=milvus__pb2.CreateRoleRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.DropRole = channel.unary_unary( + '/milvus.proto.rootcoord.RootCoord/DropRole', + request_serializer=milvus__pb2.DropRoleRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.OperateUserRole = channel.unary_unary( + '/milvus.proto.rootcoord.RootCoord/OperateUserRole', + request_serializer=milvus__pb2.OperateUserRoleRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.SelectRole = channel.unary_unary( + '/milvus.proto.rootcoord.RootCoord/SelectRole', + request_serializer=milvus__pb2.SelectRoleRequest.SerializeToString, + response_deserializer=milvus__pb2.SelectRoleResponse.FromString, + ) + self.SelectUser = channel.unary_unary( + '/milvus.proto.rootcoord.RootCoord/SelectUser', + request_serializer=milvus__pb2.SelectUserRequest.SerializeToString, + response_deserializer=milvus__pb2.SelectUserResponse.FromString, + ) + self.OperatePrivilege = channel.unary_unary( + '/milvus.proto.rootcoord.RootCoord/OperatePrivilege', + request_serializer=milvus__pb2.OperatePrivilegeRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.SelectGrant = channel.unary_unary( + '/milvus.proto.rootcoord.RootCoord/SelectGrant', + request_serializer=milvus__pb2.SelectGrantRequest.SerializeToString, + response_deserializer=milvus__pb2.SelectGrantResponse.FromString, + ) + self.ListPolicy = channel.unary_unary( + '/milvus.proto.rootcoord.RootCoord/ListPolicy', + request_serializer=internal__pb2.ListPolicyRequest.SerializeToString, + response_deserializer=internal__pb2.ListPolicyResponse.FromString, + ) + self.CheckHealth = channel.unary_unary( + '/milvus.proto.rootcoord.RootCoord/CheckHealth', + request_serializer=milvus__pb2.CheckHealthRequest.SerializeToString, + response_deserializer=milvus__pb2.CheckHealthResponse.FromString, + ) + self.RenameCollection = channel.unary_unary( + '/milvus.proto.rootcoord.RootCoord/RenameCollection', + request_serializer=milvus__pb2.RenameCollectionRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.CreateDatabase = channel.unary_unary( + '/milvus.proto.rootcoord.RootCoord/CreateDatabase', + request_serializer=milvus__pb2.CreateDatabaseRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.DropDatabase = channel.unary_unary( + '/milvus.proto.rootcoord.RootCoord/DropDatabase', + request_serializer=milvus__pb2.DropDatabaseRequest.SerializeToString, + response_deserializer=common__pb2.Status.FromString, + ) + self.ListDatabases = channel.unary_unary( + '/milvus.proto.rootcoord.RootCoord/ListDatabases', + request_serializer=milvus__pb2.ListDatabasesRequest.SerializeToString, + response_deserializer=milvus__pb2.ListDatabasesResponse.FromString, + ) + + +class RootCoordServicer(object): + """Missing associated documentation comment in .proto file.""" + + def GetComponentStates(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetTimeTickChannel(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetStatisticsChannel(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def CreateCollection(self, request, context): + """* + @brief This method is used to create collection + + @param CreateCollectionRequest, use to provide collection information to be created. + + @return Status + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def DropCollection(self, request, context): + """* + @brief This method is used to delete collection. + + @param DropCollectionRequest, collection name is going to be deleted. + + @return Status + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def HasCollection(self, request, context): + """* + @brief This method is used to test collection existence. + + @param HasCollectionRequest, collection name is going to be tested. + + @return BoolResponse + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def DescribeCollection(self, request, context): + """* + @brief This method is used to get collection schema. + + @param DescribeCollectionRequest, target collection name. + + @return CollectionSchema + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def DescribeCollectionInternal(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def CreateAlias(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def DropAlias(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def AlterAlias(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def DescribeAlias(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ListAliases(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ShowCollections(self, request, context): + """* + @brief This method is used to list all collections. + + @return StringListResponse, collection name list + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def AlterCollection(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def CreatePartition(self, request, context): + """* + @brief This method is used to create partition + + @return Status + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def DropPartition(self, request, context): + """* + @brief This method is used to drop partition + + @return Status + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def HasPartition(self, request, context): + """* + @brief This method is used to test partition existence. + + @return BoolResponse + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ShowPartitions(self, request, context): + """* + @brief This method is used to show partition information + + @param ShowPartitionRequest, target collection name. + + @return StringListResponse + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ShowPartitionsInternal(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ShowSegments(self, request, context): + """rpc DescribeSegment(milvus.DescribeSegmentRequest) returns (milvus.DescribeSegmentResponse) {} + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def AllocTimestamp(self, request, context): + """rpc CreateIndex(milvus.CreateIndexRequest) returns (common.Status) {} + rpc DescribeIndex(milvus.DescribeIndexRequest) returns (milvus.DescribeIndexResponse) {} + rpc DropIndex(milvus.DropIndexRequest) returns (common.Status) {} + rpc GetIndexState(milvus.GetIndexStateRequest) returns (milvus.GetIndexStateResponse) {} + + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def AllocID(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def UpdateChannelTimeTick(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def InvalidateCollectionMetaCache(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ShowConfigurations(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetMetrics(self, request, context): + """https://wiki.lfaidata.foundation/display/MIL/MEP+8+--+Add+metrics+for+proxy + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def Import(self, request, context): + """https://wiki.lfaidata.foundation/display/MIL/MEP+24+--+Support+bulk+load + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetImportState(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ListImportTasks(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ReportImport(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def CreateCredential(self, request, context): + """https://wiki.lfaidata.foundation/display/MIL/MEP+27+--+Support+Basic+Authentication + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def UpdateCredential(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def DeleteCredential(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ListCredUsers(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetCredential(self, request, context): + """userd by proxy, not exposed to sdk + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def CreateRole(self, request, context): + """https://wiki.lfaidata.foundation/display/MIL/MEP+29+--+Support+Role-Based+Access+Control + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def DropRole(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def OperateUserRole(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def SelectRole(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def SelectUser(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def OperatePrivilege(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def SelectGrant(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ListPolicy(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def CheckHealth(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def RenameCollection(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def CreateDatabase(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def DropDatabase(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ListDatabases(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + +def add_RootCoordServicer_to_server(servicer, server): + rpc_method_handlers = { + 'GetComponentStates': grpc.unary_unary_rpc_method_handler( + servicer.GetComponentStates, + request_deserializer=milvus__pb2.GetComponentStatesRequest.FromString, + response_serializer=milvus__pb2.ComponentStates.SerializeToString, + ), + 'GetTimeTickChannel': grpc.unary_unary_rpc_method_handler( + servicer.GetTimeTickChannel, + request_deserializer=internal__pb2.GetTimeTickChannelRequest.FromString, + response_serializer=milvus__pb2.StringResponse.SerializeToString, + ), + 'GetStatisticsChannel': grpc.unary_unary_rpc_method_handler( + servicer.GetStatisticsChannel, + request_deserializer=internal__pb2.GetStatisticsChannelRequest.FromString, + response_serializer=milvus__pb2.StringResponse.SerializeToString, + ), + 'CreateCollection': grpc.unary_unary_rpc_method_handler( + servicer.CreateCollection, + request_deserializer=milvus__pb2.CreateCollectionRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'DropCollection': grpc.unary_unary_rpc_method_handler( + servicer.DropCollection, + request_deserializer=milvus__pb2.DropCollectionRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'HasCollection': grpc.unary_unary_rpc_method_handler( + servicer.HasCollection, + request_deserializer=milvus__pb2.HasCollectionRequest.FromString, + response_serializer=milvus__pb2.BoolResponse.SerializeToString, + ), + 'DescribeCollection': grpc.unary_unary_rpc_method_handler( + servicer.DescribeCollection, + request_deserializer=milvus__pb2.DescribeCollectionRequest.FromString, + response_serializer=milvus__pb2.DescribeCollectionResponse.SerializeToString, + ), + 'DescribeCollectionInternal': grpc.unary_unary_rpc_method_handler( + servicer.DescribeCollectionInternal, + request_deserializer=milvus__pb2.DescribeCollectionRequest.FromString, + response_serializer=milvus__pb2.DescribeCollectionResponse.SerializeToString, + ), + 'CreateAlias': grpc.unary_unary_rpc_method_handler( + servicer.CreateAlias, + request_deserializer=milvus__pb2.CreateAliasRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'DropAlias': grpc.unary_unary_rpc_method_handler( + servicer.DropAlias, + request_deserializer=milvus__pb2.DropAliasRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'AlterAlias': grpc.unary_unary_rpc_method_handler( + servicer.AlterAlias, + request_deserializer=milvus__pb2.AlterAliasRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'DescribeAlias': grpc.unary_unary_rpc_method_handler( + servicer.DescribeAlias, + request_deserializer=milvus__pb2.DescribeAliasRequest.FromString, + response_serializer=milvus__pb2.DescribeAliasResponse.SerializeToString, + ), + 'ListAliases': grpc.unary_unary_rpc_method_handler( + servicer.ListAliases, + request_deserializer=milvus__pb2.ListAliasesRequest.FromString, + response_serializer=milvus__pb2.ListAliasesResponse.SerializeToString, + ), + 'ShowCollections': grpc.unary_unary_rpc_method_handler( + servicer.ShowCollections, + request_deserializer=milvus__pb2.ShowCollectionsRequest.FromString, + response_serializer=milvus__pb2.ShowCollectionsResponse.SerializeToString, + ), + 'AlterCollection': grpc.unary_unary_rpc_method_handler( + servicer.AlterCollection, + request_deserializer=milvus__pb2.AlterCollectionRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'CreatePartition': grpc.unary_unary_rpc_method_handler( + servicer.CreatePartition, + request_deserializer=milvus__pb2.CreatePartitionRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'DropPartition': grpc.unary_unary_rpc_method_handler( + servicer.DropPartition, + request_deserializer=milvus__pb2.DropPartitionRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'HasPartition': grpc.unary_unary_rpc_method_handler( + servicer.HasPartition, + request_deserializer=milvus__pb2.HasPartitionRequest.FromString, + response_serializer=milvus__pb2.BoolResponse.SerializeToString, + ), + 'ShowPartitions': grpc.unary_unary_rpc_method_handler( + servicer.ShowPartitions, + request_deserializer=milvus__pb2.ShowPartitionsRequest.FromString, + response_serializer=milvus__pb2.ShowPartitionsResponse.SerializeToString, + ), + 'ShowPartitionsInternal': grpc.unary_unary_rpc_method_handler( + servicer.ShowPartitionsInternal, + request_deserializer=milvus__pb2.ShowPartitionsRequest.FromString, + response_serializer=milvus__pb2.ShowPartitionsResponse.SerializeToString, + ), + 'ShowSegments': grpc.unary_unary_rpc_method_handler( + servicer.ShowSegments, + request_deserializer=milvus__pb2.ShowSegmentsRequest.FromString, + response_serializer=milvus__pb2.ShowSegmentsResponse.SerializeToString, + ), + 'AllocTimestamp': grpc.unary_unary_rpc_method_handler( + servicer.AllocTimestamp, + request_deserializer=root__coord__pb2.AllocTimestampRequest.FromString, + response_serializer=root__coord__pb2.AllocTimestampResponse.SerializeToString, + ), + 'AllocID': grpc.unary_unary_rpc_method_handler( + servicer.AllocID, + request_deserializer=root__coord__pb2.AllocIDRequest.FromString, + response_serializer=root__coord__pb2.AllocIDResponse.SerializeToString, + ), + 'UpdateChannelTimeTick': grpc.unary_unary_rpc_method_handler( + servicer.UpdateChannelTimeTick, + request_deserializer=internal__pb2.ChannelTimeTickMsg.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'InvalidateCollectionMetaCache': grpc.unary_unary_rpc_method_handler( + servicer.InvalidateCollectionMetaCache, + request_deserializer=proxy__pb2.InvalidateCollMetaCacheRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'ShowConfigurations': grpc.unary_unary_rpc_method_handler( + servicer.ShowConfigurations, + request_deserializer=internal__pb2.ShowConfigurationsRequest.FromString, + response_serializer=internal__pb2.ShowConfigurationsResponse.SerializeToString, + ), + 'GetMetrics': grpc.unary_unary_rpc_method_handler( + servicer.GetMetrics, + request_deserializer=milvus__pb2.GetMetricsRequest.FromString, + response_serializer=milvus__pb2.GetMetricsResponse.SerializeToString, + ), + 'Import': grpc.unary_unary_rpc_method_handler( + servicer.Import, + request_deserializer=milvus__pb2.ImportRequest.FromString, + response_serializer=milvus__pb2.ImportResponse.SerializeToString, + ), + 'GetImportState': grpc.unary_unary_rpc_method_handler( + servicer.GetImportState, + request_deserializer=milvus__pb2.GetImportStateRequest.FromString, + response_serializer=milvus__pb2.GetImportStateResponse.SerializeToString, + ), + 'ListImportTasks': grpc.unary_unary_rpc_method_handler( + servicer.ListImportTasks, + request_deserializer=milvus__pb2.ListImportTasksRequest.FromString, + response_serializer=milvus__pb2.ListImportTasksResponse.SerializeToString, + ), + 'ReportImport': grpc.unary_unary_rpc_method_handler( + servicer.ReportImport, + request_deserializer=root__coord__pb2.ImportResult.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'CreateCredential': grpc.unary_unary_rpc_method_handler( + servicer.CreateCredential, + request_deserializer=internal__pb2.CredentialInfo.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'UpdateCredential': grpc.unary_unary_rpc_method_handler( + servicer.UpdateCredential, + request_deserializer=internal__pb2.CredentialInfo.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'DeleteCredential': grpc.unary_unary_rpc_method_handler( + servicer.DeleteCredential, + request_deserializer=milvus__pb2.DeleteCredentialRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'ListCredUsers': grpc.unary_unary_rpc_method_handler( + servicer.ListCredUsers, + request_deserializer=milvus__pb2.ListCredUsersRequest.FromString, + response_serializer=milvus__pb2.ListCredUsersResponse.SerializeToString, + ), + 'GetCredential': grpc.unary_unary_rpc_method_handler( + servicer.GetCredential, + request_deserializer=root__coord__pb2.GetCredentialRequest.FromString, + response_serializer=root__coord__pb2.GetCredentialResponse.SerializeToString, + ), + 'CreateRole': grpc.unary_unary_rpc_method_handler( + servicer.CreateRole, + request_deserializer=milvus__pb2.CreateRoleRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'DropRole': grpc.unary_unary_rpc_method_handler( + servicer.DropRole, + request_deserializer=milvus__pb2.DropRoleRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'OperateUserRole': grpc.unary_unary_rpc_method_handler( + servicer.OperateUserRole, + request_deserializer=milvus__pb2.OperateUserRoleRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'SelectRole': grpc.unary_unary_rpc_method_handler( + servicer.SelectRole, + request_deserializer=milvus__pb2.SelectRoleRequest.FromString, + response_serializer=milvus__pb2.SelectRoleResponse.SerializeToString, + ), + 'SelectUser': grpc.unary_unary_rpc_method_handler( + servicer.SelectUser, + request_deserializer=milvus__pb2.SelectUserRequest.FromString, + response_serializer=milvus__pb2.SelectUserResponse.SerializeToString, + ), + 'OperatePrivilege': grpc.unary_unary_rpc_method_handler( + servicer.OperatePrivilege, + request_deserializer=milvus__pb2.OperatePrivilegeRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'SelectGrant': grpc.unary_unary_rpc_method_handler( + servicer.SelectGrant, + request_deserializer=milvus__pb2.SelectGrantRequest.FromString, + response_serializer=milvus__pb2.SelectGrantResponse.SerializeToString, + ), + 'ListPolicy': grpc.unary_unary_rpc_method_handler( + servicer.ListPolicy, + request_deserializer=internal__pb2.ListPolicyRequest.FromString, + response_serializer=internal__pb2.ListPolicyResponse.SerializeToString, + ), + 'CheckHealth': grpc.unary_unary_rpc_method_handler( + servicer.CheckHealth, + request_deserializer=milvus__pb2.CheckHealthRequest.FromString, + response_serializer=milvus__pb2.CheckHealthResponse.SerializeToString, + ), + 'RenameCollection': grpc.unary_unary_rpc_method_handler( + servicer.RenameCollection, + request_deserializer=milvus__pb2.RenameCollectionRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'CreateDatabase': grpc.unary_unary_rpc_method_handler( + servicer.CreateDatabase, + request_deserializer=milvus__pb2.CreateDatabaseRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'DropDatabase': grpc.unary_unary_rpc_method_handler( + servicer.DropDatabase, + request_deserializer=milvus__pb2.DropDatabaseRequest.FromString, + response_serializer=common__pb2.Status.SerializeToString, + ), + 'ListDatabases': grpc.unary_unary_rpc_method_handler( + servicer.ListDatabases, + request_deserializer=milvus__pb2.ListDatabasesRequest.FromString, + response_serializer=milvus__pb2.ListDatabasesResponse.SerializeToString, + ), + } + generic_handler = grpc.method_handlers_generic_handler( + 'milvus.proto.rootcoord.RootCoord', rpc_method_handlers) + server.add_generic_rpc_handlers((generic_handler,)) + + + # This class is part of an EXPERIMENTAL API. +class RootCoord(object): + """Missing associated documentation comment in .proto file.""" + + @staticmethod + def GetComponentStates(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.rootcoord.RootCoord/GetComponentStates', + milvus__pb2.GetComponentStatesRequest.SerializeToString, + milvus__pb2.ComponentStates.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetTimeTickChannel(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.rootcoord.RootCoord/GetTimeTickChannel', + internal__pb2.GetTimeTickChannelRequest.SerializeToString, + milvus__pb2.StringResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetStatisticsChannel(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.rootcoord.RootCoord/GetStatisticsChannel', + internal__pb2.GetStatisticsChannelRequest.SerializeToString, + milvus__pb2.StringResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def CreateCollection(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.rootcoord.RootCoord/CreateCollection', + milvus__pb2.CreateCollectionRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def DropCollection(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.rootcoord.RootCoord/DropCollection', + milvus__pb2.DropCollectionRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def HasCollection(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.rootcoord.RootCoord/HasCollection', + milvus__pb2.HasCollectionRequest.SerializeToString, + milvus__pb2.BoolResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def DescribeCollection(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.rootcoord.RootCoord/DescribeCollection', + milvus__pb2.DescribeCollectionRequest.SerializeToString, + milvus__pb2.DescribeCollectionResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def DescribeCollectionInternal(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.rootcoord.RootCoord/DescribeCollectionInternal', + milvus__pb2.DescribeCollectionRequest.SerializeToString, + milvus__pb2.DescribeCollectionResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def CreateAlias(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.rootcoord.RootCoord/CreateAlias', + milvus__pb2.CreateAliasRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def DropAlias(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.rootcoord.RootCoord/DropAlias', + milvus__pb2.DropAliasRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def AlterAlias(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.rootcoord.RootCoord/AlterAlias', + milvus__pb2.AlterAliasRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def DescribeAlias(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.rootcoord.RootCoord/DescribeAlias', + milvus__pb2.DescribeAliasRequest.SerializeToString, + milvus__pb2.DescribeAliasResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def ListAliases(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.rootcoord.RootCoord/ListAliases', + milvus__pb2.ListAliasesRequest.SerializeToString, + milvus__pb2.ListAliasesResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def ShowCollections(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.rootcoord.RootCoord/ShowCollections', + milvus__pb2.ShowCollectionsRequest.SerializeToString, + milvus__pb2.ShowCollectionsResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def AlterCollection(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.rootcoord.RootCoord/AlterCollection', + milvus__pb2.AlterCollectionRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def CreatePartition(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.rootcoord.RootCoord/CreatePartition', + milvus__pb2.CreatePartitionRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def DropPartition(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.rootcoord.RootCoord/DropPartition', + milvus__pb2.DropPartitionRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def HasPartition(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.rootcoord.RootCoord/HasPartition', + milvus__pb2.HasPartitionRequest.SerializeToString, + milvus__pb2.BoolResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def ShowPartitions(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.rootcoord.RootCoord/ShowPartitions', + milvus__pb2.ShowPartitionsRequest.SerializeToString, + milvus__pb2.ShowPartitionsResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def ShowPartitionsInternal(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.rootcoord.RootCoord/ShowPartitionsInternal', + milvus__pb2.ShowPartitionsRequest.SerializeToString, + milvus__pb2.ShowPartitionsResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def ShowSegments(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.rootcoord.RootCoord/ShowSegments', + milvus__pb2.ShowSegmentsRequest.SerializeToString, + milvus__pb2.ShowSegmentsResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def AllocTimestamp(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.rootcoord.RootCoord/AllocTimestamp', + root__coord__pb2.AllocTimestampRequest.SerializeToString, + root__coord__pb2.AllocTimestampResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def AllocID(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.rootcoord.RootCoord/AllocID', + root__coord__pb2.AllocIDRequest.SerializeToString, + root__coord__pb2.AllocIDResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def UpdateChannelTimeTick(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.rootcoord.RootCoord/UpdateChannelTimeTick', + internal__pb2.ChannelTimeTickMsg.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def InvalidateCollectionMetaCache(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.rootcoord.RootCoord/InvalidateCollectionMetaCache', + proxy__pb2.InvalidateCollMetaCacheRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def ShowConfigurations(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.rootcoord.RootCoord/ShowConfigurations', + internal__pb2.ShowConfigurationsRequest.SerializeToString, + internal__pb2.ShowConfigurationsResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetMetrics(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.rootcoord.RootCoord/GetMetrics', + milvus__pb2.GetMetricsRequest.SerializeToString, + milvus__pb2.GetMetricsResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def Import(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.rootcoord.RootCoord/Import', + milvus__pb2.ImportRequest.SerializeToString, + milvus__pb2.ImportResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetImportState(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.rootcoord.RootCoord/GetImportState', + milvus__pb2.GetImportStateRequest.SerializeToString, + milvus__pb2.GetImportStateResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def ListImportTasks(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.rootcoord.RootCoord/ListImportTasks', + milvus__pb2.ListImportTasksRequest.SerializeToString, + milvus__pb2.ListImportTasksResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def ReportImport(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.rootcoord.RootCoord/ReportImport', + root__coord__pb2.ImportResult.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def CreateCredential(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.rootcoord.RootCoord/CreateCredential', + internal__pb2.CredentialInfo.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def UpdateCredential(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.rootcoord.RootCoord/UpdateCredential', + internal__pb2.CredentialInfo.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def DeleteCredential(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.rootcoord.RootCoord/DeleteCredential', + milvus__pb2.DeleteCredentialRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def ListCredUsers(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.rootcoord.RootCoord/ListCredUsers', + milvus__pb2.ListCredUsersRequest.SerializeToString, + milvus__pb2.ListCredUsersResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def GetCredential(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.rootcoord.RootCoord/GetCredential', + root__coord__pb2.GetCredentialRequest.SerializeToString, + root__coord__pb2.GetCredentialResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def CreateRole(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.rootcoord.RootCoord/CreateRole', + milvus__pb2.CreateRoleRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def DropRole(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.rootcoord.RootCoord/DropRole', + milvus__pb2.DropRoleRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def OperateUserRole(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.rootcoord.RootCoord/OperateUserRole', + milvus__pb2.OperateUserRoleRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def SelectRole(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.rootcoord.RootCoord/SelectRole', + milvus__pb2.SelectRoleRequest.SerializeToString, + milvus__pb2.SelectRoleResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def SelectUser(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.rootcoord.RootCoord/SelectUser', + milvus__pb2.SelectUserRequest.SerializeToString, + milvus__pb2.SelectUserResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def OperatePrivilege(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.rootcoord.RootCoord/OperatePrivilege', + milvus__pb2.OperatePrivilegeRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def SelectGrant(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.rootcoord.RootCoord/SelectGrant', + milvus__pb2.SelectGrantRequest.SerializeToString, + milvus__pb2.SelectGrantResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def ListPolicy(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.rootcoord.RootCoord/ListPolicy', + internal__pb2.ListPolicyRequest.SerializeToString, + internal__pb2.ListPolicyResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def CheckHealth(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.rootcoord.RootCoord/CheckHealth', + milvus__pb2.CheckHealthRequest.SerializeToString, + milvus__pb2.CheckHealthResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def RenameCollection(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.rootcoord.RootCoord/RenameCollection', + milvus__pb2.RenameCollectionRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def CreateDatabase(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.rootcoord.RootCoord/CreateDatabase', + milvus__pb2.CreateDatabaseRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def DropDatabase(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.rootcoord.RootCoord/DropDatabase', + milvus__pb2.DropDatabaseRequest.SerializeToString, + common__pb2.Status.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) + + @staticmethod + def ListDatabases(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary(request, target, '/milvus.proto.rootcoord.RootCoord/ListDatabases', + milvus__pb2.ListDatabasesRequest.SerializeToString, + milvus__pb2.ListDatabasesResponse.FromString, + options, channel_credentials, + insecure, call_credentials, compression, wait_for_ready, timeout, metadata) diff --git a/milvus_connector/protocol/schema_pb2.py b/milvus_connector/protocol/schema_pb2.py new file mode 100644 index 0000000..86c1a0e --- /dev/null +++ b/milvus_connector/protocol/schema_pb2.py @@ -0,0 +1,75 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: schema.proto +# Protobuf Python Version: 4.25.1 +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from . import common_pb2 as common__pb2 +from google.protobuf import descriptor_pb2 as google_dot_protobuf_dot_descriptor__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x0cschema.proto\x12\x13milvus.proto.schema\x1a\x0c\x63ommon.proto\x1a google/protobuf/descriptor.proto\"\xf2\x03\n\x0b\x46ieldSchema\x12\x0f\n\x07\x66ieldID\x18\x01 \x01(\x03\x12\x0c\n\x04name\x18\x02 \x01(\t\x12\x16\n\x0eis_primary_key\x18\x03 \x01(\x08\x12\x13\n\x0b\x64\x65scription\x18\x04 \x01(\t\x12\x30\n\tdata_type\x18\x05 \x01(\x0e\x32\x1d.milvus.proto.schema.DataType\x12\x36\n\x0btype_params\x18\x06 \x03(\x0b\x32!.milvus.proto.common.KeyValuePair\x12\x37\n\x0cindex_params\x18\x07 \x03(\x0b\x32!.milvus.proto.common.KeyValuePair\x12\x0e\n\x06\x61utoID\x18\x08 \x01(\x08\x12.\n\x05state\x18\t \x01(\x0e\x32\x1f.milvus.proto.schema.FieldState\x12\x33\n\x0c\x65lement_type\x18\n \x01(\x0e\x32\x1d.milvus.proto.schema.DataType\x12\x36\n\rdefault_value\x18\x0b \x01(\x0b\x32\x1f.milvus.proto.schema.ValueField\x12\x12\n\nis_dynamic\x18\x0c \x01(\x08\x12\x18\n\x10is_partition_key\x18\r \x01(\x08\x12\x19\n\x11is_clustering_key\x18\x0e \x01(\x08\"\xd0\x01\n\x10\x43ollectionSchema\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x13\n\x0b\x64\x65scription\x18\x02 \x01(\t\x12\x12\n\x06\x61utoID\x18\x03 \x01(\x08\x42\x02\x18\x01\x12\x30\n\x06\x66ields\x18\x04 \x03(\x0b\x32 .milvus.proto.schema.FieldSchema\x12\x1c\n\x14\x65nable_dynamic_field\x18\x05 \x01(\x08\x12\x35\n\nproperties\x18\x06 \x03(\x0b\x32!.milvus.proto.common.KeyValuePair\"\x19\n\tBoolArray\x12\x0c\n\x04\x64\x61ta\x18\x01 \x03(\x08\"\x18\n\x08IntArray\x12\x0c\n\x04\x64\x61ta\x18\x01 \x03(\x05\"\x19\n\tLongArray\x12\x0c\n\x04\x64\x61ta\x18\x01 \x03(\x03\"\x1a\n\nFloatArray\x12\x0c\n\x04\x64\x61ta\x18\x01 \x03(\x02\"\x1b\n\x0b\x44oubleArray\x12\x0c\n\x04\x64\x61ta\x18\x01 \x03(\x01\"\x1a\n\nBytesArray\x12\x0c\n\x04\x64\x61ta\x18\x01 \x03(\x0c\"\x1b\n\x0bStringArray\x12\x0c\n\x04\x64\x61ta\x18\x01 \x03(\t\"q\n\nArrayArray\x12.\n\x04\x64\x61ta\x18\x01 \x03(\x0b\x32 .milvus.proto.schema.ScalarField\x12\x33\n\x0c\x65lement_type\x18\x02 \x01(\x0e\x32\x1d.milvus.proto.schema.DataType\"\x19\n\tJSONArray\x12\x0c\n\x04\x64\x61ta\x18\x01 \x03(\x0c\"\xac\x01\n\nValueField\x12\x13\n\tbool_data\x18\x01 \x01(\x08H\x00\x12\x12\n\x08int_data\x18\x02 \x01(\x05H\x00\x12\x13\n\tlong_data\x18\x03 \x01(\x03H\x00\x12\x14\n\nfloat_data\x18\x04 \x01(\x02H\x00\x12\x15\n\x0b\x64ouble_data\x18\x05 \x01(\x01H\x00\x12\x15\n\x0bstring_data\x18\x06 \x01(\tH\x00\x12\x14\n\nbytes_data\x18\x07 \x01(\x0cH\x00\x42\x06\n\x04\x64\x61ta\"\xfe\x03\n\x0bScalarField\x12\x33\n\tbool_data\x18\x01 \x01(\x0b\x32\x1e.milvus.proto.schema.BoolArrayH\x00\x12\x31\n\x08int_data\x18\x02 \x01(\x0b\x32\x1d.milvus.proto.schema.IntArrayH\x00\x12\x33\n\tlong_data\x18\x03 \x01(\x0b\x32\x1e.milvus.proto.schema.LongArrayH\x00\x12\x35\n\nfloat_data\x18\x04 \x01(\x0b\x32\x1f.milvus.proto.schema.FloatArrayH\x00\x12\x37\n\x0b\x64ouble_data\x18\x05 \x01(\x0b\x32 .milvus.proto.schema.DoubleArrayH\x00\x12\x37\n\x0bstring_data\x18\x06 \x01(\x0b\x32 .milvus.proto.schema.StringArrayH\x00\x12\x35\n\nbytes_data\x18\x07 \x01(\x0b\x32\x1f.milvus.proto.schema.BytesArrayH\x00\x12\x35\n\narray_data\x18\x08 \x01(\x0b\x32\x1f.milvus.proto.schema.ArrayArrayH\x00\x12\x33\n\tjson_data\x18\t \x01(\x0b\x32\x1e.milvus.proto.schema.JSONArrayH\x00\x42\x06\n\x04\x64\x61ta\"1\n\x10SparseFloatArray\x12\x10\n\x08\x63ontents\x18\x01 \x03(\x0c\x12\x0b\n\x03\x64im\x18\x02 \x01(\x03\"\xef\x01\n\x0bVectorField\x12\x0b\n\x03\x64im\x18\x01 \x01(\x03\x12\x37\n\x0c\x66loat_vector\x18\x02 \x01(\x0b\x32\x1f.milvus.proto.schema.FloatArrayH\x00\x12\x17\n\rbinary_vector\x18\x03 \x01(\x0cH\x00\x12\x18\n\x0e\x66loat16_vector\x18\x04 \x01(\x0cH\x00\x12\x19\n\x0f\x62\x66loat16_vector\x18\x05 \x01(\x0cH\x00\x12\x44\n\x13sparse_float_vector\x18\x06 \x01(\x0b\x32%.milvus.proto.schema.SparseFloatArrayH\x00\x42\x06\n\x04\x64\x61ta\"\xe5\x01\n\tFieldData\x12+\n\x04type\x18\x01 \x01(\x0e\x32\x1d.milvus.proto.schema.DataType\x12\x12\n\nfield_name\x18\x02 \x01(\t\x12\x33\n\x07scalars\x18\x03 \x01(\x0b\x32 .milvus.proto.schema.ScalarFieldH\x00\x12\x33\n\x07vectors\x18\x04 \x01(\x0b\x32 .milvus.proto.schema.VectorFieldH\x00\x12\x10\n\x08\x66ield_id\x18\x05 \x01(\x03\x12\x12\n\nis_dynamic\x18\x06 \x01(\x08\x42\x07\n\x05\x66ield\"w\n\x03IDs\x12\x30\n\x06int_id\x18\x01 \x01(\x0b\x32\x1e.milvus.proto.schema.LongArrayH\x00\x12\x32\n\x06str_id\x18\x02 \x01(\x0b\x32 .milvus.proto.schema.StringArrayH\x00\x42\n\n\x08id_field\"\xa0\x02\n\x10SearchResultData\x12\x13\n\x0bnum_queries\x18\x01 \x01(\x03\x12\r\n\x05top_k\x18\x02 \x01(\x03\x12\x33\n\x0b\x66ields_data\x18\x03 \x03(\x0b\x32\x1e.milvus.proto.schema.FieldData\x12\x0e\n\x06scores\x18\x04 \x03(\x02\x12%\n\x03ids\x18\x05 \x01(\x0b\x32\x18.milvus.proto.schema.IDs\x12\r\n\x05topks\x18\x06 \x03(\x03\x12\x15\n\routput_fields\x18\x07 \x03(\t\x12<\n\x14group_by_field_value\x18\x08 \x01(\x0b\x32\x1e.milvus.proto.schema.FieldData\x12\x18\n\x10\x61ll_search_count\x18\t \x01(\x03\"Y\n\x14VectorClusteringInfo\x12\r\n\x05\x66ield\x18\x01 \x01(\t\x12\x32\n\x08\x63\x65ntroid\x18\x02 \x01(\x0b\x32 .milvus.proto.schema.VectorField\"%\n\x14ScalarClusteringInfo\x12\r\n\x05\x66ield\x18\x01 \x01(\t\"\xa8\x01\n\x0e\x43lusteringInfo\x12J\n\x17vector_clustering_infos\x18\x01 \x03(\x0b\x32).milvus.proto.schema.VectorClusteringInfo\x12J\n\x17scalar_clustering_infos\x18\x02 \x03(\x0b\x32).milvus.proto.schema.ScalarClusteringInfo*\xef\x01\n\x08\x44\x61taType\x12\x08\n\x04None\x10\x00\x12\x08\n\x04\x42ool\x10\x01\x12\x08\n\x04Int8\x10\x02\x12\t\n\x05Int16\x10\x03\x12\t\n\x05Int32\x10\x04\x12\t\n\x05Int64\x10\x05\x12\t\n\x05\x46loat\x10\n\x12\n\n\x06\x44ouble\x10\x0b\x12\n\n\x06String\x10\x14\x12\x0b\n\x07VarChar\x10\x15\x12\t\n\x05\x41rray\x10\x16\x12\x08\n\x04JSON\x10\x17\x12\x10\n\x0c\x42inaryVector\x10\x64\x12\x0f\n\x0b\x46loatVector\x10\x65\x12\x11\n\rFloat16Vector\x10\x66\x12\x12\n\x0e\x42\x46loat16Vector\x10g\x12\x15\n\x11SparseFloatVector\x10h*V\n\nFieldState\x12\x10\n\x0c\x46ieldCreated\x10\x00\x12\x11\n\rFieldCreating\x10\x01\x12\x11\n\rFieldDropping\x10\x02\x12\x10\n\x0c\x46ieldDropped\x10\x03\x42m\n\x0eio.milvus.grpcB\x0bSchemaProtoP\x01Z4github.com/milvus-io/milvus-proto/go-api/v2/schemapb\xa0\x01\x01\xaa\x02\x12Milvus.Client.Grpcb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'schema_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + _globals['DESCRIPTOR']._options = None + _globals['DESCRIPTOR']._serialized_options = b'\n\016io.milvus.grpcB\013SchemaProtoP\001Z4github.com/milvus-io/milvus-proto/go-api/v2/schemapb\240\001\001\252\002\022Milvus.Client.Grpc' + _globals['_COLLECTIONSCHEMA'].fields_by_name['autoID']._options = None + _globals['_COLLECTIONSCHEMA'].fields_by_name['autoID']._serialized_options = b'\030\001' + _globals['_DATATYPE']._serialized_start=3060 + _globals['_DATATYPE']._serialized_end=3299 + _globals['_FIELDSTATE']._serialized_start=3301 + _globals['_FIELDSTATE']._serialized_end=3387 + _globals['_FIELDSCHEMA']._serialized_start=86 + _globals['_FIELDSCHEMA']._serialized_end=584 + _globals['_COLLECTIONSCHEMA']._serialized_start=587 + _globals['_COLLECTIONSCHEMA']._serialized_end=795 + _globals['_BOOLARRAY']._serialized_start=797 + _globals['_BOOLARRAY']._serialized_end=822 + _globals['_INTARRAY']._serialized_start=824 + _globals['_INTARRAY']._serialized_end=848 + _globals['_LONGARRAY']._serialized_start=850 + _globals['_LONGARRAY']._serialized_end=875 + _globals['_FLOATARRAY']._serialized_start=877 + _globals['_FLOATARRAY']._serialized_end=903 + _globals['_DOUBLEARRAY']._serialized_start=905 + _globals['_DOUBLEARRAY']._serialized_end=932 + _globals['_BYTESARRAY']._serialized_start=934 + _globals['_BYTESARRAY']._serialized_end=960 + _globals['_STRINGARRAY']._serialized_start=962 + _globals['_STRINGARRAY']._serialized_end=989 + _globals['_ARRAYARRAY']._serialized_start=991 + _globals['_ARRAYARRAY']._serialized_end=1104 + _globals['_JSONARRAY']._serialized_start=1106 + _globals['_JSONARRAY']._serialized_end=1131 + _globals['_VALUEFIELD']._serialized_start=1134 + _globals['_VALUEFIELD']._serialized_end=1306 + _globals['_SCALARFIELD']._serialized_start=1309 + _globals['_SCALARFIELD']._serialized_end=1819 + _globals['_SPARSEFLOATARRAY']._serialized_start=1821 + _globals['_SPARSEFLOATARRAY']._serialized_end=1870 + _globals['_VECTORFIELD']._serialized_start=1873 + _globals['_VECTORFIELD']._serialized_end=2112 + _globals['_FIELDDATA']._serialized_start=2115 + _globals['_FIELDDATA']._serialized_end=2344 + _globals['_IDS']._serialized_start=2346 + _globals['_IDS']._serialized_end=2465 + _globals['_SEARCHRESULTDATA']._serialized_start=2468 + _globals['_SEARCHRESULTDATA']._serialized_end=2756 + _globals['_VECTORCLUSTERINGINFO']._serialized_start=2758 + _globals['_VECTORCLUSTERINGINFO']._serialized_end=2847 + _globals['_SCALARCLUSTERINGINFO']._serialized_start=2849 + _globals['_SCALARCLUSTERINGINFO']._serialized_end=2886 + _globals['_CLUSTERINGINFO']._serialized_start=2889 + _globals['_CLUSTERINGINFO']._serialized_end=3057 +# @@protoc_insertion_point(module_scope) diff --git a/milvus_connector/protocol/schema_pb2.pyi b/milvus_connector/protocol/schema_pb2.pyi new file mode 100644 index 0000000..f40f9ff --- /dev/null +++ b/milvus_connector/protocol/schema_pb2.pyi @@ -0,0 +1,293 @@ +from . import common_pb2 as _common_pb2 +from google.protobuf import descriptor_pb2 as _descriptor_pb2 +from google.protobuf.internal import containers as _containers +from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Iterable as _Iterable, Mapping as _Mapping, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class DataType(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = () + None: _ClassVar[DataType] + Bool: _ClassVar[DataType] + Int8: _ClassVar[DataType] + Int16: _ClassVar[DataType] + Int32: _ClassVar[DataType] + Int64: _ClassVar[DataType] + Float: _ClassVar[DataType] + Double: _ClassVar[DataType] + String: _ClassVar[DataType] + VarChar: _ClassVar[DataType] + Array: _ClassVar[DataType] + JSON: _ClassVar[DataType] + BinaryVector: _ClassVar[DataType] + FloatVector: _ClassVar[DataType] + Float16Vector: _ClassVar[DataType] + BFloat16Vector: _ClassVar[DataType] + SparseFloatVector: _ClassVar[DataType] + +class FieldState(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = () + FieldCreated: _ClassVar[FieldState] + FieldCreating: _ClassVar[FieldState] + FieldDropping: _ClassVar[FieldState] + FieldDropped: _ClassVar[FieldState] +None: DataType +Bool: DataType +Int8: DataType +Int16: DataType +Int32: DataType +Int64: DataType +Float: DataType +Double: DataType +String: DataType +VarChar: DataType +Array: DataType +JSON: DataType +BinaryVector: DataType +FloatVector: DataType +Float16Vector: DataType +BFloat16Vector: DataType +SparseFloatVector: DataType +FieldCreated: FieldState +FieldCreating: FieldState +FieldDropping: FieldState +FieldDropped: FieldState + +class FieldSchema(_message.Message): + __slots__ = ("fieldID", "name", "is_primary_key", "description", "data_type", "type_params", "index_params", "autoID", "state", "element_type", "default_value", "is_dynamic", "is_partition_key", "is_clustering_key") + FIELDID_FIELD_NUMBER: _ClassVar[int] + NAME_FIELD_NUMBER: _ClassVar[int] + IS_PRIMARY_KEY_FIELD_NUMBER: _ClassVar[int] + DESCRIPTION_FIELD_NUMBER: _ClassVar[int] + DATA_TYPE_FIELD_NUMBER: _ClassVar[int] + TYPE_PARAMS_FIELD_NUMBER: _ClassVar[int] + INDEX_PARAMS_FIELD_NUMBER: _ClassVar[int] + AUTOID_FIELD_NUMBER: _ClassVar[int] + STATE_FIELD_NUMBER: _ClassVar[int] + ELEMENT_TYPE_FIELD_NUMBER: _ClassVar[int] + DEFAULT_VALUE_FIELD_NUMBER: _ClassVar[int] + IS_DYNAMIC_FIELD_NUMBER: _ClassVar[int] + IS_PARTITION_KEY_FIELD_NUMBER: _ClassVar[int] + IS_CLUSTERING_KEY_FIELD_NUMBER: _ClassVar[int] + fieldID: int + name: str + is_primary_key: bool + description: str + data_type: DataType + type_params: _containers.RepeatedCompositeFieldContainer[_common_pb2.KeyValuePair] + index_params: _containers.RepeatedCompositeFieldContainer[_common_pb2.KeyValuePair] + autoID: bool + state: FieldState + element_type: DataType + default_value: ValueField + is_dynamic: bool + is_partition_key: bool + is_clustering_key: bool + def __init__(self, fieldID: _Optional[int] = ..., name: _Optional[str] = ..., is_primary_key: bool = ..., description: _Optional[str] = ..., data_type: _Optional[_Union[DataType, str]] = ..., type_params: _Optional[_Iterable[_Union[_common_pb2.KeyValuePair, _Mapping]]] = ..., index_params: _Optional[_Iterable[_Union[_common_pb2.KeyValuePair, _Mapping]]] = ..., autoID: bool = ..., state: _Optional[_Union[FieldState, str]] = ..., element_type: _Optional[_Union[DataType, str]] = ..., default_value: _Optional[_Union[ValueField, _Mapping]] = ..., is_dynamic: bool = ..., is_partition_key: bool = ..., is_clustering_key: bool = ...) -> None: ... + +class CollectionSchema(_message.Message): + __slots__ = ("name", "description", "autoID", "fields", "enable_dynamic_field", "properties") + NAME_FIELD_NUMBER: _ClassVar[int] + DESCRIPTION_FIELD_NUMBER: _ClassVar[int] + AUTOID_FIELD_NUMBER: _ClassVar[int] + FIELDS_FIELD_NUMBER: _ClassVar[int] + ENABLE_DYNAMIC_FIELD_FIELD_NUMBER: _ClassVar[int] + PROPERTIES_FIELD_NUMBER: _ClassVar[int] + name: str + description: str + autoID: bool + fields: _containers.RepeatedCompositeFieldContainer[FieldSchema] + enable_dynamic_field: bool + properties: _containers.RepeatedCompositeFieldContainer[_common_pb2.KeyValuePair] + def __init__(self, name: _Optional[str] = ..., description: _Optional[str] = ..., autoID: bool = ..., fields: _Optional[_Iterable[_Union[FieldSchema, _Mapping]]] = ..., enable_dynamic_field: bool = ..., properties: _Optional[_Iterable[_Union[_common_pb2.KeyValuePair, _Mapping]]] = ...) -> None: ... + +class BoolArray(_message.Message): + __slots__ = ("data",) + DATA_FIELD_NUMBER: _ClassVar[int] + data: _containers.RepeatedScalarFieldContainer[bool] + def __init__(self, data: _Optional[_Iterable[bool]] = ...) -> None: ... + +class IntArray(_message.Message): + __slots__ = ("data",) + DATA_FIELD_NUMBER: _ClassVar[int] + data: _containers.RepeatedScalarFieldContainer[int] + def __init__(self, data: _Optional[_Iterable[int]] = ...) -> None: ... + +class LongArray(_message.Message): + __slots__ = ("data",) + DATA_FIELD_NUMBER: _ClassVar[int] + data: _containers.RepeatedScalarFieldContainer[int] + def __init__(self, data: _Optional[_Iterable[int]] = ...) -> None: ... + +class FloatArray(_message.Message): + __slots__ = ("data",) + DATA_FIELD_NUMBER: _ClassVar[int] + data: _containers.RepeatedScalarFieldContainer[float] + def __init__(self, data: _Optional[_Iterable[float]] = ...) -> None: ... + +class DoubleArray(_message.Message): + __slots__ = ("data",) + DATA_FIELD_NUMBER: _ClassVar[int] + data: _containers.RepeatedScalarFieldContainer[float] + def __init__(self, data: _Optional[_Iterable[float]] = ...) -> None: ... + +class BytesArray(_message.Message): + __slots__ = ("data",) + DATA_FIELD_NUMBER: _ClassVar[int] + data: _containers.RepeatedScalarFieldContainer[bytes] + def __init__(self, data: _Optional[_Iterable[bytes]] = ...) -> None: ... + +class StringArray(_message.Message): + __slots__ = ("data",) + DATA_FIELD_NUMBER: _ClassVar[int] + data: _containers.RepeatedScalarFieldContainer[str] + def __init__(self, data: _Optional[_Iterable[str]] = ...) -> None: ... + +class ArrayArray(_message.Message): + __slots__ = ("data", "element_type") + DATA_FIELD_NUMBER: _ClassVar[int] + ELEMENT_TYPE_FIELD_NUMBER: _ClassVar[int] + data: _containers.RepeatedCompositeFieldContainer[ScalarField] + element_type: DataType + def __init__(self, data: _Optional[_Iterable[_Union[ScalarField, _Mapping]]] = ..., element_type: _Optional[_Union[DataType, str]] = ...) -> None: ... + +class JSONArray(_message.Message): + __slots__ = ("data",) + DATA_FIELD_NUMBER: _ClassVar[int] + data: _containers.RepeatedScalarFieldContainer[bytes] + def __init__(self, data: _Optional[_Iterable[bytes]] = ...) -> None: ... + +class ValueField(_message.Message): + __slots__ = ("bool_data", "int_data", "long_data", "float_data", "double_data", "string_data", "bytes_data") + BOOL_DATA_FIELD_NUMBER: _ClassVar[int] + INT_DATA_FIELD_NUMBER: _ClassVar[int] + LONG_DATA_FIELD_NUMBER: _ClassVar[int] + FLOAT_DATA_FIELD_NUMBER: _ClassVar[int] + DOUBLE_DATA_FIELD_NUMBER: _ClassVar[int] + STRING_DATA_FIELD_NUMBER: _ClassVar[int] + BYTES_DATA_FIELD_NUMBER: _ClassVar[int] + bool_data: bool + int_data: int + long_data: int + float_data: float + double_data: float + string_data: str + bytes_data: bytes + def __init__(self, bool_data: bool = ..., int_data: _Optional[int] = ..., long_data: _Optional[int] = ..., float_data: _Optional[float] = ..., double_data: _Optional[float] = ..., string_data: _Optional[str] = ..., bytes_data: _Optional[bytes] = ...) -> None: ... + +class ScalarField(_message.Message): + __slots__ = ("bool_data", "int_data", "long_data", "float_data", "double_data", "string_data", "bytes_data", "array_data", "json_data") + BOOL_DATA_FIELD_NUMBER: _ClassVar[int] + INT_DATA_FIELD_NUMBER: _ClassVar[int] + LONG_DATA_FIELD_NUMBER: _ClassVar[int] + FLOAT_DATA_FIELD_NUMBER: _ClassVar[int] + DOUBLE_DATA_FIELD_NUMBER: _ClassVar[int] + STRING_DATA_FIELD_NUMBER: _ClassVar[int] + BYTES_DATA_FIELD_NUMBER: _ClassVar[int] + ARRAY_DATA_FIELD_NUMBER: _ClassVar[int] + JSON_DATA_FIELD_NUMBER: _ClassVar[int] + bool_data: BoolArray + int_data: IntArray + long_data: LongArray + float_data: FloatArray + double_data: DoubleArray + string_data: StringArray + bytes_data: BytesArray + array_data: ArrayArray + json_data: JSONArray + def __init__(self, bool_data: _Optional[_Union[BoolArray, _Mapping]] = ..., int_data: _Optional[_Union[IntArray, _Mapping]] = ..., long_data: _Optional[_Union[LongArray, _Mapping]] = ..., float_data: _Optional[_Union[FloatArray, _Mapping]] = ..., double_data: _Optional[_Union[DoubleArray, _Mapping]] = ..., string_data: _Optional[_Union[StringArray, _Mapping]] = ..., bytes_data: _Optional[_Union[BytesArray, _Mapping]] = ..., array_data: _Optional[_Union[ArrayArray, _Mapping]] = ..., json_data: _Optional[_Union[JSONArray, _Mapping]] = ...) -> None: ... + +class SparseFloatArray(_message.Message): + __slots__ = ("contents", "dim") + CONTENTS_FIELD_NUMBER: _ClassVar[int] + DIM_FIELD_NUMBER: _ClassVar[int] + contents: _containers.RepeatedScalarFieldContainer[bytes] + dim: int + def __init__(self, contents: _Optional[_Iterable[bytes]] = ..., dim: _Optional[int] = ...) -> None: ... + +class VectorField(_message.Message): + __slots__ = ("dim", "float_vector", "binary_vector", "float16_vector", "bfloat16_vector", "sparse_float_vector") + DIM_FIELD_NUMBER: _ClassVar[int] + FLOAT_VECTOR_FIELD_NUMBER: _ClassVar[int] + BINARY_VECTOR_FIELD_NUMBER: _ClassVar[int] + FLOAT16_VECTOR_FIELD_NUMBER: _ClassVar[int] + BFLOAT16_VECTOR_FIELD_NUMBER: _ClassVar[int] + SPARSE_FLOAT_VECTOR_FIELD_NUMBER: _ClassVar[int] + dim: int + float_vector: FloatArray + binary_vector: bytes + float16_vector: bytes + bfloat16_vector: bytes + sparse_float_vector: SparseFloatArray + def __init__(self, dim: _Optional[int] = ..., float_vector: _Optional[_Union[FloatArray, _Mapping]] = ..., binary_vector: _Optional[bytes] = ..., float16_vector: _Optional[bytes] = ..., bfloat16_vector: _Optional[bytes] = ..., sparse_float_vector: _Optional[_Union[SparseFloatArray, _Mapping]] = ...) -> None: ... + +class FieldData(_message.Message): + __slots__ = ("type", "field_name", "scalars", "vectors", "field_id", "is_dynamic") + TYPE_FIELD_NUMBER: _ClassVar[int] + FIELD_NAME_FIELD_NUMBER: _ClassVar[int] + SCALARS_FIELD_NUMBER: _ClassVar[int] + VECTORS_FIELD_NUMBER: _ClassVar[int] + FIELD_ID_FIELD_NUMBER: _ClassVar[int] + IS_DYNAMIC_FIELD_NUMBER: _ClassVar[int] + type: DataType + field_name: str + scalars: ScalarField + vectors: VectorField + field_id: int + is_dynamic: bool + def __init__(self, type: _Optional[_Union[DataType, str]] = ..., field_name: _Optional[str] = ..., scalars: _Optional[_Union[ScalarField, _Mapping]] = ..., vectors: _Optional[_Union[VectorField, _Mapping]] = ..., field_id: _Optional[int] = ..., is_dynamic: bool = ...) -> None: ... + +class IDs(_message.Message): + __slots__ = ("int_id", "str_id") + INT_ID_FIELD_NUMBER: _ClassVar[int] + STR_ID_FIELD_NUMBER: _ClassVar[int] + int_id: LongArray + str_id: StringArray + def __init__(self, int_id: _Optional[_Union[LongArray, _Mapping]] = ..., str_id: _Optional[_Union[StringArray, _Mapping]] = ...) -> None: ... + +class SearchResultData(_message.Message): + __slots__ = ("num_queries", "top_k", "fields_data", "scores", "ids", "topks", "output_fields", "group_by_field_value", "all_search_count") + NUM_QUERIES_FIELD_NUMBER: _ClassVar[int] + TOP_K_FIELD_NUMBER: _ClassVar[int] + FIELDS_DATA_FIELD_NUMBER: _ClassVar[int] + SCORES_FIELD_NUMBER: _ClassVar[int] + IDS_FIELD_NUMBER: _ClassVar[int] + TOPKS_FIELD_NUMBER: _ClassVar[int] + OUTPUT_FIELDS_FIELD_NUMBER: _ClassVar[int] + GROUP_BY_FIELD_VALUE_FIELD_NUMBER: _ClassVar[int] + ALL_SEARCH_COUNT_FIELD_NUMBER: _ClassVar[int] + num_queries: int + top_k: int + fields_data: _containers.RepeatedCompositeFieldContainer[FieldData] + scores: _containers.RepeatedScalarFieldContainer[float] + ids: IDs + topks: _containers.RepeatedScalarFieldContainer[int] + output_fields: _containers.RepeatedScalarFieldContainer[str] + group_by_field_value: FieldData + all_search_count: int + def __init__(self, num_queries: _Optional[int] = ..., top_k: _Optional[int] = ..., fields_data: _Optional[_Iterable[_Union[FieldData, _Mapping]]] = ..., scores: _Optional[_Iterable[float]] = ..., ids: _Optional[_Union[IDs, _Mapping]] = ..., topks: _Optional[_Iterable[int]] = ..., output_fields: _Optional[_Iterable[str]] = ..., group_by_field_value: _Optional[_Union[FieldData, _Mapping]] = ..., all_search_count: _Optional[int] = ...) -> None: ... + +class VectorClusteringInfo(_message.Message): + __slots__ = ("field", "centroid") + FIELD_FIELD_NUMBER: _ClassVar[int] + CENTROID_FIELD_NUMBER: _ClassVar[int] + field: str + centroid: VectorField + def __init__(self, field: _Optional[str] = ..., centroid: _Optional[_Union[VectorField, _Mapping]] = ...) -> None: ... + +class ScalarClusteringInfo(_message.Message): + __slots__ = ("field",) + FIELD_FIELD_NUMBER: _ClassVar[int] + field: str + def __init__(self, field: _Optional[str] = ...) -> None: ... + +class ClusteringInfo(_message.Message): + __slots__ = ("vector_clustering_infos", "scalar_clustering_infos") + VECTOR_CLUSTERING_INFOS_FIELD_NUMBER: _ClassVar[int] + SCALAR_CLUSTERING_INFOS_FIELD_NUMBER: _ClassVar[int] + vector_clustering_infos: _containers.RepeatedCompositeFieldContainer[VectorClusteringInfo] + scalar_clustering_infos: _containers.RepeatedCompositeFieldContainer[ScalarClusteringInfo] + def __init__(self, vector_clustering_infos: _Optional[_Iterable[_Union[VectorClusteringInfo, _Mapping]]] = ..., scalar_clustering_infos: _Optional[_Iterable[_Union[ScalarClusteringInfo, _Mapping]]] = ...) -> None: ... diff --git a/milvus_connector/protocol/schema_pb2_grpc.py b/milvus_connector/protocol/schema_pb2_grpc.py new file mode 100644 index 0000000..2daafff --- /dev/null +++ b/milvus_connector/protocol/schema_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/milvus_connector/protocol/segcore_pb2.py b/milvus_connector/protocol/segcore_pb2.py new file mode 100644 index 0000000..6f61a29 --- /dev/null +++ b/milvus_connector/protocol/segcore_pb2.py @@ -0,0 +1,39 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: segcore.proto +# Protobuf Python Version: 4.25.1 +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from . import schema_pb2 as schema__pb2 +from . import common_pb2 as common__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\rsegcore.proto\x12\x14milvus.proto.segcore\x1a\x0cschema.proto\x1a\x0c\x63ommon.proto\"\x99\x01\n\x0fRetrieveResults\x12%\n\x03ids\x18\x01 \x01(\x0b\x32\x18.milvus.proto.schema.IDs\x12\x0e\n\x06offset\x18\x02 \x03(\x03\x12\x33\n\x0b\x66ields_data\x18\x03 \x03(\x0b\x32\x1e.milvus.proto.schema.FieldData\x12\x1a\n\x12\x61ll_retrieve_count\x18\x04 \x01(\x03\"P\n\rLoadFieldMeta\x12\x15\n\rmin_timestamp\x18\x01 \x01(\x03\x12\x15\n\rmax_timestamp\x18\x02 \x01(\x03\x12\x11\n\trow_count\x18\x03 \x01(\x03\"Y\n\x0fLoadSegmentMeta\x12\x32\n\x05metas\x18\x01 \x03(\x0b\x32#.milvus.proto.segcore.LoadFieldMeta\x12\x12\n\ntotal_size\x18\x02 \x01(\x03\"U\n\x0cInsertRecord\x12\x33\n\x0b\x66ields_data\x18\x01 \x03(\x0b\x32\x1e.milvus.proto.schema.FieldData\x12\x10\n\x08num_rows\x18\x02 \x01(\x03\"\x91\x02\n\x0e\x46ieldIndexMeta\x12\x0f\n\x07\x66ieldID\x18\x01 \x01(\x03\x12\x14\n\x0c\x63ollectionID\x18\x02 \x01(\x03\x12\x12\n\nindex_name\x18\x03 \x01(\t\x12\x36\n\x0btype_params\x18\x04 \x03(\x0b\x32!.milvus.proto.common.KeyValuePair\x12\x37\n\x0cindex_params\x18\x05 \x03(\x0b\x32!.milvus.proto.common.KeyValuePair\x12\x15\n\ris_auto_index\x18\x06 \x01(\x08\x12<\n\x11user_index_params\x18\x07 \x03(\x0b\x32!.milvus.proto.common.KeyValuePair\"j\n\x13\x43ollectionIndexMeta\x12\x18\n\x10maxIndexRowCount\x18\x01 \x01(\x03\x12\x39\n\x0bindex_metas\x18\x02 \x03(\x0b\x32$.milvus.proto.segcore.FieldIndexMetaB6Z4github.com/milvus-io/milvus/internal/proto/segcorepbb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'segcore_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + _globals['DESCRIPTOR']._options = None + _globals['DESCRIPTOR']._serialized_options = b'Z4github.com/milvus-io/milvus/internal/proto/segcorepb' + _globals['_RETRIEVERESULTS']._serialized_start=68 + _globals['_RETRIEVERESULTS']._serialized_end=221 + _globals['_LOADFIELDMETA']._serialized_start=223 + _globals['_LOADFIELDMETA']._serialized_end=303 + _globals['_LOADSEGMENTMETA']._serialized_start=305 + _globals['_LOADSEGMENTMETA']._serialized_end=394 + _globals['_INSERTRECORD']._serialized_start=396 + _globals['_INSERTRECORD']._serialized_end=481 + _globals['_FIELDINDEXMETA']._serialized_start=484 + _globals['_FIELDINDEXMETA']._serialized_end=757 + _globals['_COLLECTIONINDEXMETA']._serialized_start=759 + _globals['_COLLECTIONINDEXMETA']._serialized_end=865 +# @@protoc_insertion_point(module_scope) diff --git a/milvus_connector/protocol/segcore_pb2.pyi b/milvus_connector/protocol/segcore_pb2.pyi new file mode 100644 index 0000000..832a3c0 --- /dev/null +++ b/milvus_connector/protocol/segcore_pb2.pyi @@ -0,0 +1,72 @@ +from . import schema_pb2 as _schema_pb2 +from . import common_pb2 as _common_pb2 +from google.protobuf.internal import containers as _containers +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Iterable as _Iterable, Mapping as _Mapping, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class RetrieveResults(_message.Message): + __slots__ = ("ids", "offset", "fields_data", "all_retrieve_count") + IDS_FIELD_NUMBER: _ClassVar[int] + OFFSET_FIELD_NUMBER: _ClassVar[int] + FIELDS_DATA_FIELD_NUMBER: _ClassVar[int] + ALL_RETRIEVE_COUNT_FIELD_NUMBER: _ClassVar[int] + ids: _schema_pb2.IDs + offset: _containers.RepeatedScalarFieldContainer[int] + fields_data: _containers.RepeatedCompositeFieldContainer[_schema_pb2.FieldData] + all_retrieve_count: int + def __init__(self, ids: _Optional[_Union[_schema_pb2.IDs, _Mapping]] = ..., offset: _Optional[_Iterable[int]] = ..., fields_data: _Optional[_Iterable[_Union[_schema_pb2.FieldData, _Mapping]]] = ..., all_retrieve_count: _Optional[int] = ...) -> None: ... + +class LoadFieldMeta(_message.Message): + __slots__ = ("min_timestamp", "max_timestamp", "row_count") + MIN_TIMESTAMP_FIELD_NUMBER: _ClassVar[int] + MAX_TIMESTAMP_FIELD_NUMBER: _ClassVar[int] + ROW_COUNT_FIELD_NUMBER: _ClassVar[int] + min_timestamp: int + max_timestamp: int + row_count: int + def __init__(self, min_timestamp: _Optional[int] = ..., max_timestamp: _Optional[int] = ..., row_count: _Optional[int] = ...) -> None: ... + +class LoadSegmentMeta(_message.Message): + __slots__ = ("metas", "total_size") + METAS_FIELD_NUMBER: _ClassVar[int] + TOTAL_SIZE_FIELD_NUMBER: _ClassVar[int] + metas: _containers.RepeatedCompositeFieldContainer[LoadFieldMeta] + total_size: int + def __init__(self, metas: _Optional[_Iterable[_Union[LoadFieldMeta, _Mapping]]] = ..., total_size: _Optional[int] = ...) -> None: ... + +class InsertRecord(_message.Message): + __slots__ = ("fields_data", "num_rows") + FIELDS_DATA_FIELD_NUMBER: _ClassVar[int] + NUM_ROWS_FIELD_NUMBER: _ClassVar[int] + fields_data: _containers.RepeatedCompositeFieldContainer[_schema_pb2.FieldData] + num_rows: int + def __init__(self, fields_data: _Optional[_Iterable[_Union[_schema_pb2.FieldData, _Mapping]]] = ..., num_rows: _Optional[int] = ...) -> None: ... + +class FieldIndexMeta(_message.Message): + __slots__ = ("fieldID", "collectionID", "index_name", "type_params", "index_params", "is_auto_index", "user_index_params") + FIELDID_FIELD_NUMBER: _ClassVar[int] + COLLECTIONID_FIELD_NUMBER: _ClassVar[int] + INDEX_NAME_FIELD_NUMBER: _ClassVar[int] + TYPE_PARAMS_FIELD_NUMBER: _ClassVar[int] + INDEX_PARAMS_FIELD_NUMBER: _ClassVar[int] + IS_AUTO_INDEX_FIELD_NUMBER: _ClassVar[int] + USER_INDEX_PARAMS_FIELD_NUMBER: _ClassVar[int] + fieldID: int + collectionID: int + index_name: str + type_params: _containers.RepeatedCompositeFieldContainer[_common_pb2.KeyValuePair] + index_params: _containers.RepeatedCompositeFieldContainer[_common_pb2.KeyValuePair] + is_auto_index: bool + user_index_params: _containers.RepeatedCompositeFieldContainer[_common_pb2.KeyValuePair] + def __init__(self, fieldID: _Optional[int] = ..., collectionID: _Optional[int] = ..., index_name: _Optional[str] = ..., type_params: _Optional[_Iterable[_Union[_common_pb2.KeyValuePair, _Mapping]]] = ..., index_params: _Optional[_Iterable[_Union[_common_pb2.KeyValuePair, _Mapping]]] = ..., is_auto_index: bool = ..., user_index_params: _Optional[_Iterable[_Union[_common_pb2.KeyValuePair, _Mapping]]] = ...) -> None: ... + +class CollectionIndexMeta(_message.Message): + __slots__ = ("maxIndexRowCount", "index_metas") + MAXINDEXROWCOUNT_FIELD_NUMBER: _ClassVar[int] + INDEX_METAS_FIELD_NUMBER: _ClassVar[int] + maxIndexRowCount: int + index_metas: _containers.RepeatedCompositeFieldContainer[FieldIndexMeta] + def __init__(self, maxIndexRowCount: _Optional[int] = ..., index_metas: _Optional[_Iterable[_Union[FieldIndexMeta, _Mapping]]] = ...) -> None: ... diff --git a/milvus_connector/protocol/segcore_pb2_grpc.py b/milvus_connector/protocol/segcore_pb2_grpc.py new file mode 100644 index 0000000..2daafff --- /dev/null +++ b/milvus_connector/protocol/segcore_pb2_grpc.py @@ -0,0 +1,4 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc + diff --git a/poetry.lock b/poetry.lock new file mode 100644 index 0000000..f45e143 --- /dev/null +++ b/poetry.lock @@ -0,0 +1,472 @@ +# This file is automatically @generated by Poetry 1.7.1 and should not be changed by hand. + +[[package]] +name = "annotated-types" +version = "0.6.0" +description = "Reusable constraint types to use with typing.Annotated" +optional = false +python-versions = ">=3.8" +files = [ + {file = "annotated_types-0.6.0-py3-none-any.whl", hash = "sha256:0641064de18ba7a25dee8f96403ebc39113d0cb953a01429249d5c7564666a43"}, + {file = "annotated_types-0.6.0.tar.gz", hash = "sha256:563339e807e53ffd9c267e99fc6d9ea23eb8443c08f112651963e24e22f84a5d"}, +] + +[package.dependencies] +typing-extensions = {version = ">=4.0.0", markers = "python_version < \"3.9\""} + +[[package]] +name = "colorama" +version = "0.4.6" +description = "Cross-platform colored terminal text." +optional = false +python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,!=3.6.*,>=2.7" +files = [ + {file = "colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6"}, + {file = "colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44"}, +] + +[[package]] +name = "exceptiongroup" +version = "1.2.0" +description = "Backport of PEP 654 (exception groups)" +optional = false +python-versions = ">=3.7" +files = [ + {file = "exceptiongroup-1.2.0-py3-none-any.whl", hash = "sha256:4bfd3996ac73b41e9b9628b04e079f193850720ea5945fc96a08633c66912f14"}, + {file = "exceptiongroup-1.2.0.tar.gz", hash = "sha256:91f5c769735f051a4290d52edd0858999b57e5876e9f85937691bd4c9fa3ed68"}, +] + +[package.extras] +test = ["pytest (>=6)"] + +[[package]] +name = "furl" +version = "2.1.3" +description = "URL manipulation made simple." +optional = false +python-versions = "*" +files = [ + {file = "furl-2.1.3-py2.py3-none-any.whl", hash = "sha256:9ab425062c4217f9802508e45feb4a83e54324273ac4b202f1850363309666c0"}, + {file = "furl-2.1.3.tar.gz", hash = "sha256:5a6188fe2666c484a12159c18be97a1977a71d632ef5bb867ef15f54af39cc4e"}, +] + +[package.dependencies] +orderedmultidict = ">=1.0.1" +six = ">=1.8.0" + +[[package]] +name = "grpcio" +version = "1.62.0" +description = "HTTP/2-based RPC framework" +optional = false +python-versions = ">=3.7" +files = [ + {file = "grpcio-1.62.0-cp310-cp310-linux_armv7l.whl", hash = "sha256:136ffd79791b1eddda8d827b607a6285474ff8a1a5735c4947b58c481e5e4271"}, + {file = "grpcio-1.62.0-cp310-cp310-macosx_12_0_universal2.whl", hash = "sha256:d6a56ba703be6b6267bf19423d888600c3f574ac7c2cc5e6220af90662a4d6b0"}, + {file = "grpcio-1.62.0-cp310-cp310-manylinux_2_17_aarch64.whl", hash = "sha256:4cd356211579043fce9f52acc861e519316fff93980a212c8109cca8f47366b6"}, + {file = "grpcio-1.62.0-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e803e9b58d8f9b4ff0ea991611a8d51b31c68d2e24572cd1fe85e99e8cc1b4f8"}, + {file = "grpcio-1.62.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f4c04fe33039b35b97c02d2901a164bbbb2f21fb9c4e2a45a959f0b044c3512c"}, + {file = "grpcio-1.62.0-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:95370c71b8c9062f9ea033a0867c4c73d6f0ff35113ebd2618171ec1f1e903e0"}, + {file = "grpcio-1.62.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:c912688acc05e4ff012c8891803659d6a8a8b5106f0f66e0aed3fb7e77898fa6"}, + {file = "grpcio-1.62.0-cp310-cp310-win32.whl", hash = "sha256:821a44bd63d0f04e33cf4ddf33c14cae176346486b0df08b41a6132b976de5fc"}, + {file = "grpcio-1.62.0-cp310-cp310-win_amd64.whl", hash = "sha256:81531632f93fece32b2762247c4c169021177e58e725494f9a746ca62c83acaa"}, + {file = "grpcio-1.62.0-cp311-cp311-linux_armv7l.whl", hash = "sha256:3fa15850a6aba230eed06b236287c50d65a98f05054a0f01ccedf8e1cc89d57f"}, + {file = "grpcio-1.62.0-cp311-cp311-macosx_10_10_universal2.whl", hash = "sha256:36df33080cd7897623feff57831eb83c98b84640b016ce443305977fac7566fb"}, + {file = "grpcio-1.62.0-cp311-cp311-manylinux_2_17_aarch64.whl", hash = "sha256:7a195531828b46ea9c4623c47e1dc45650fc7206f8a71825898dd4c9004b0928"}, + {file = "grpcio-1.62.0-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ab140a3542bbcea37162bdfc12ce0d47a3cda3f2d91b752a124cc9fe6776a9e2"}, + {file = "grpcio-1.62.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7f9d6c3223914abb51ac564dc9c3782d23ca445d2864321b9059d62d47144021"}, + {file = "grpcio-1.62.0-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:fbe0c20ce9a1cff75cfb828b21f08d0a1ca527b67f2443174af6626798a754a4"}, + {file = "grpcio-1.62.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:38f69de9c28c1e7a8fd24e4af4264726637b72f27c2099eaea6e513e7142b47e"}, + {file = "grpcio-1.62.0-cp311-cp311-win32.whl", hash = "sha256:ce1aafdf8d3f58cb67664f42a617af0e34555fe955450d42c19e4a6ad41c84bd"}, + {file = "grpcio-1.62.0-cp311-cp311-win_amd64.whl", hash = "sha256:eef1d16ac26c5325e7d39f5452ea98d6988c700c427c52cbc7ce3201e6d93334"}, + {file = "grpcio-1.62.0-cp312-cp312-linux_armv7l.whl", hash = "sha256:8aab8f90b2a41208c0a071ec39a6e5dbba16fd827455aaa070fec241624ccef8"}, + {file = "grpcio-1.62.0-cp312-cp312-macosx_10_10_universal2.whl", hash = "sha256:62aa1659d8b6aad7329ede5d5b077e3d71bf488d85795db517118c390358d5f6"}, + {file = "grpcio-1.62.0-cp312-cp312-manylinux_2_17_aarch64.whl", hash = "sha256:0d7ae7fc7dbbf2d78d6323641ded767d9ec6d121aaf931ec4a5c50797b886532"}, + {file = "grpcio-1.62.0-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f359d635ee9428f0294bea062bb60c478a8ddc44b0b6f8e1f42997e5dc12e2ee"}, + {file = "grpcio-1.62.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:77d48e5b1f8f4204889f1acf30bb57c30378e17c8d20df5acbe8029e985f735c"}, + {file = "grpcio-1.62.0-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:662d3df5314ecde3184cf87ddd2c3a66095b3acbb2d57a8cada571747af03873"}, + {file = "grpcio-1.62.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:92cdb616be44c8ac23a57cce0243af0137a10aa82234f23cd46e69e115071388"}, + {file = "grpcio-1.62.0-cp312-cp312-win32.whl", hash = "sha256:0b9179478b09ee22f4a36b40ca87ad43376acdccc816ce7c2193a9061bf35701"}, + {file = "grpcio-1.62.0-cp312-cp312-win_amd64.whl", hash = "sha256:614c3ed234208e76991992342bab725f379cc81c7dd5035ee1de2f7e3f7a9842"}, + {file = "grpcio-1.62.0-cp37-cp37m-linux_armv7l.whl", hash = "sha256:7e1f51e2a460b7394670fdb615e26d31d3260015154ea4f1501a45047abe06c9"}, + {file = "grpcio-1.62.0-cp37-cp37m-macosx_10_10_universal2.whl", hash = "sha256:bcff647e7fe25495e7719f779cc219bbb90b9e79fbd1ce5bda6aae2567f469f2"}, + {file = "grpcio-1.62.0-cp37-cp37m-manylinux_2_17_aarch64.whl", hash = "sha256:56ca7ba0b51ed0de1646f1735154143dcbdf9ec2dbe8cc6645def299bb527ca1"}, + {file = "grpcio-1.62.0-cp37-cp37m-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:2e84bfb2a734e4a234b116be208d6f0214e68dcf7804306f97962f93c22a1839"}, + {file = "grpcio-1.62.0-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2c1488b31a521fbba50ae86423f5306668d6f3a46d124f7819c603979fc538c4"}, + {file = "grpcio-1.62.0-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:98d8f4eb91f1ce0735bf0b67c3b2a4fea68b52b2fd13dc4318583181f9219b4b"}, + {file = "grpcio-1.62.0-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:b3d3d755cfa331d6090e13aac276d4a3fb828bf935449dc16c3d554bf366136b"}, + {file = "grpcio-1.62.0-cp37-cp37m-win_amd64.whl", hash = "sha256:a33f2bfd8a58a02aab93f94f6c61279be0f48f99fcca20ebaee67576cd57307b"}, + {file = "grpcio-1.62.0-cp38-cp38-linux_armv7l.whl", hash = "sha256:5e709f7c8028ce0443bddc290fb9c967c1e0e9159ef7a030e8c21cac1feabd35"}, + {file = "grpcio-1.62.0-cp38-cp38-macosx_10_10_universal2.whl", hash = "sha256:2f3d9a4d0abb57e5f49ed5039d3ed375826c2635751ab89dcc25932ff683bbb6"}, + {file = "grpcio-1.62.0-cp38-cp38-manylinux_2_17_aarch64.whl", hash = "sha256:62ccb92f594d3d9fcd00064b149a0187c246b11e46ff1b7935191f169227f04c"}, + {file = "grpcio-1.62.0-cp38-cp38-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:921148f57c2e4b076af59a815467d399b7447f6e0ee10ef6d2601eb1e9c7f402"}, + {file = "grpcio-1.62.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f897b16190b46bc4d4aaf0a32a4b819d559a37a756d7c6b571e9562c360eed72"}, + {file = "grpcio-1.62.0-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:1bc8449084fe395575ed24809752e1dc4592bb70900a03ca42bf236ed5bf008f"}, + {file = "grpcio-1.62.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:81d444e5e182be4c7856cd33a610154fe9ea1726bd071d07e7ba13fafd202e38"}, + {file = "grpcio-1.62.0-cp38-cp38-win32.whl", hash = "sha256:88f41f33da3840b4a9bbec68079096d4caf629e2c6ed3a72112159d570d98ebe"}, + {file = "grpcio-1.62.0-cp38-cp38-win_amd64.whl", hash = "sha256:fc2836cb829895ee190813446dce63df67e6ed7b9bf76060262c55fcd097d270"}, + {file = "grpcio-1.62.0-cp39-cp39-linux_armv7l.whl", hash = "sha256:fcc98cff4084467839d0a20d16abc2a76005f3d1b38062464d088c07f500d170"}, + {file = "grpcio-1.62.0-cp39-cp39-macosx_10_10_universal2.whl", hash = "sha256:0d3dee701e48ee76b7d6fbbba18ba8bc142e5b231ef7d3d97065204702224e0e"}, + {file = "grpcio-1.62.0-cp39-cp39-manylinux_2_17_aarch64.whl", hash = "sha256:b7a6be562dd18e5d5bec146ae9537f20ae1253beb971c0164f1e8a2f5a27e829"}, + {file = "grpcio-1.62.0-cp39-cp39-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:29cb592c4ce64a023712875368bcae13938c7f03e99f080407e20ffe0a9aa33b"}, + {file = "grpcio-1.62.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1eda79574aec8ec4d00768dcb07daba60ed08ef32583b62b90bbf274b3c279f7"}, + {file = "grpcio-1.62.0-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:7eea57444a354ee217fda23f4b479a4cdfea35fb918ca0d8a0e73c271e52c09c"}, + {file = "grpcio-1.62.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:0e97f37a3b7c89f9125b92d22e9c8323f4e76e7993ba7049b9f4ccbe8bae958a"}, + {file = "grpcio-1.62.0-cp39-cp39-win32.whl", hash = "sha256:39cd45bd82a2e510e591ca2ddbe22352e8413378852ae814549c162cf3992a93"}, + {file = "grpcio-1.62.0-cp39-cp39-win_amd64.whl", hash = "sha256:b71c65427bf0ec6a8b48c68c17356cb9fbfc96b1130d20a07cb462f4e4dcdcd5"}, + {file = "grpcio-1.62.0.tar.gz", hash = "sha256:748496af9238ac78dcd98cce65421f1adce28c3979393e3609683fcd7f3880d7"}, +] + +[package.extras] +protobuf = ["grpcio-tools (>=1.62.0)"] + +[[package]] +name = "grpcio-tools" +version = "1.62.0" +description = "Protobuf code generator for gRPC" +optional = false +python-versions = ">=3.7" +files = [ + {file = "grpcio-tools-1.62.0.tar.gz", hash = "sha256:7fca6ecfbbf0549058bb29dcc6e435d885b878d07701e77ac58e1e1f591736dc"}, + {file = "grpcio_tools-1.62.0-cp310-cp310-linux_armv7l.whl", hash = "sha256:465c51ebaa184ee3bb619cd5bfaf562bbdde166f2822a6935461e6a741f5ac19"}, + {file = "grpcio_tools-1.62.0-cp310-cp310-macosx_12_0_universal2.whl", hash = "sha256:0d9c9a4832f52c4597d6dc12d9ab3109c3bd0ee1686b8bf6d64f9eab4145e3cb"}, + {file = "grpcio_tools-1.62.0-cp310-cp310-manylinux_2_17_aarch64.whl", hash = "sha256:5a482d9625209023481e631c29a6df1392bfc49f9accfa880dabbacff642559a"}, + {file = "grpcio_tools-1.62.0-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:74196beed18383d53ff3e2412a6c1eefa3ff109e987be240368496bc3dcabc8b"}, + {file = "grpcio_tools-1.62.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:75aca28cbeb605c59b5689a7e000fbc2bd659d2f322c58461f3912f00069f6da"}, + {file = "grpcio_tools-1.62.0-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:523adf731fa4c5af0bf7ee2edb65e8c7ef4d9df9951461d6a18fe096688efd2d"}, + {file = "grpcio_tools-1.62.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:791aa220f8f1936e65bc079e9eb954fa0202a1f16e28b83956e59d17dface127"}, + {file = "grpcio_tools-1.62.0-cp310-cp310-win32.whl", hash = "sha256:5dacc691b18d2c294ea971720ff980a1e2d68a3f7ddcd2f0670b3204e81c4b18"}, + {file = "grpcio_tools-1.62.0-cp310-cp310-win_amd64.whl", hash = "sha256:6999a4e705b03aacad46e625feb7610e47ec88dbd51220c2282b6334f90721fc"}, + {file = "grpcio_tools-1.62.0-cp311-cp311-linux_armv7l.whl", hash = "sha256:19b74e141937c885c9e56b6a7dfa190ca7d583bd48bce9171dd65bbf108b9271"}, + {file = "grpcio_tools-1.62.0-cp311-cp311-macosx_10_10_universal2.whl", hash = "sha256:17c16e9a89c0b9f4ff2b143f232c5256383453ce7b55fe981598f9517adc8252"}, + {file = "grpcio_tools-1.62.0-cp311-cp311-manylinux_2_17_aarch64.whl", hash = "sha256:3730b1cd998a0cffc817602cc55e51f268fa97b3e38fa4bee578e3741474547a"}, + {file = "grpcio_tools-1.62.0-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:14201950513636f515dd455a06890e3a21d115b943cf6a8f5af67ad1413cfa1f"}, + {file = "grpcio_tools-1.62.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f74e0053360e0eadd75193c0c379b6d7f51d074ebbff856bd41780e1a028b38d"}, + {file = "grpcio_tools-1.62.0-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:d5959e3df126931d28cd94dd5f0a708b7dd96019de80ab715fb922fd0c8a838d"}, + {file = "grpcio_tools-1.62.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:1927934dfba4658a97c2dab267e53ed239264d40fdd5b295fc317693543db85b"}, + {file = "grpcio_tools-1.62.0-cp311-cp311-win32.whl", hash = "sha256:2f5bd22203e64e1732e149bfdd3083716d038abca294e4e2852159b3d893f9ec"}, + {file = "grpcio_tools-1.62.0-cp311-cp311-win_amd64.whl", hash = "sha256:cd1f4caeca614b04db803566473f7db0971e7a88268f95e4a529b0ace699b949"}, + {file = "grpcio_tools-1.62.0-cp312-cp312-linux_armv7l.whl", hash = "sha256:f0884eaf6a2bbd7b03fea456e808909ee48dd4f7f455519d67defda791116368"}, + {file = "grpcio_tools-1.62.0-cp312-cp312-macosx_10_10_universal2.whl", hash = "sha256:6b900ae319b6f9ac1be0ca572dfb41c23a7ff6fcbf36e3be6d3054e1e4c60de6"}, + {file = "grpcio_tools-1.62.0-cp312-cp312-manylinux_2_17_aarch64.whl", hash = "sha256:3bbe79b134dfb7c98cf60e4962e31039bef824834cc7034bdf1886a2ed1097f9"}, + {file = "grpcio_tools-1.62.0-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:77196c7ac8741d4a2aebb023bcc2964ac65ca44180fd791640889ab2afed3e47"}, + {file = "grpcio_tools-1.62.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b65288ebe12e38dd3650fea65d82fcce0d35df1ae4a770b525c10119ee71962f"}, + {file = "grpcio_tools-1.62.0-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:52b216c458458f6c292e12428916e80974c5113abc505a61e7b0b9f8932a785d"}, + {file = "grpcio_tools-1.62.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:88aa62303278aec45bbb26bf679269c7890346c37140ae30e39da1070c341e11"}, + {file = "grpcio_tools-1.62.0-cp312-cp312-win32.whl", hash = "sha256:bb6802d63e42734d2baf02e1343377fe18590ed6a1f5ffbdebbbe0f8331f176b"}, + {file = "grpcio_tools-1.62.0-cp312-cp312-win_amd64.whl", hash = "sha256:d5652d3a52a2e8e1d9bdf28fbd15e21b166e31b968cd7c8c604bf31611c0bb5b"}, + {file = "grpcio_tools-1.62.0-cp37-cp37m-linux_armv7l.whl", hash = "sha256:84e27206bd884be83a7fdcef8be3c90eb1591341c0ba9b0d25ec9db1043ba2f2"}, + {file = "grpcio_tools-1.62.0-cp37-cp37m-macosx_10_10_universal2.whl", hash = "sha256:5eb63d9207b02a0fa30216907e1e7705cc2670f933e77236c6e0eb966ad3b4bf"}, + {file = "grpcio_tools-1.62.0-cp37-cp37m-manylinux_2_17_aarch64.whl", hash = "sha256:95e49839d49e79187c43cd63af5c206dc5743a01d7d3d2f039772fa743cbb30c"}, + {file = "grpcio_tools-1.62.0-cp37-cp37m-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:9ae5cd2f89e33a529790bf8aa59a459484edb05e4f58d4cf78836b9dfa1fab43"}, + {file = "grpcio_tools-1.62.0-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2e1fd7301d762bf5984b7e7fb62fce82cff864d75f0a57e15cfd07ae1bd79133"}, + {file = "grpcio_tools-1.62.0-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:e38d5800151e6804d500e329f7ddfb615c50eee0c1607593e3147a4b21037e40"}, + {file = "grpcio_tools-1.62.0-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:563a75924109e75809b2919e68d7e6ae7872e63d20258aae7899b14f6ff9e18b"}, + {file = "grpcio_tools-1.62.0-cp37-cp37m-win_amd64.whl", hash = "sha256:5f8934715577c9cc0c792b8a77f7d0dd2bb60e951161b10c5f46b60856673240"}, + {file = "grpcio_tools-1.62.0-cp38-cp38-linux_armv7l.whl", hash = "sha256:ed6cf7ff4a10c46f85340f9c68982f9efb29f51ee4b66828310fcdf3c2d7ffd1"}, + {file = "grpcio_tools-1.62.0-cp38-cp38-macosx_10_10_universal2.whl", hash = "sha256:1faa5006fe9e7b9e65c47bc23f7cd333fdcdd4ba35d44080303848266db5ab05"}, + {file = "grpcio_tools-1.62.0-cp38-cp38-manylinux_2_17_aarch64.whl", hash = "sha256:3b526dc5566161a3a17599753838b9cfbdd4cb15b6ad419aae8a5d12053fa8ae"}, + {file = "grpcio_tools-1.62.0-cp38-cp38-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a09db3688efd3499ce3c0b02c0bac0656abdab4cb99716f81ad879c08b92c56e"}, + {file = "grpcio_tools-1.62.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:006ea0cc16e8bf8f307326e0556e1384f24abb402cc4e6a720aa1dfe8f268647"}, + {file = "grpcio_tools-1.62.0-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:b46ba0b6552b4375ede65e0c89491af532635347f78d52a72f8a027529e713ed"}, + {file = "grpcio_tools-1.62.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:ec6f561c86fe13cff3be16f297cc05e1aa1274294524743a4cf91d971866fbb0"}, + {file = "grpcio_tools-1.62.0-cp38-cp38-win32.whl", hash = "sha256:c85391e06620d6e16a56341caae5007d0c6219beba065e1e288f2523fba6a335"}, + {file = "grpcio_tools-1.62.0-cp38-cp38-win_amd64.whl", hash = "sha256:679cf2507090e010da73e5001665c76de2a5927b2e2110e459222b1c81cb10c2"}, + {file = "grpcio_tools-1.62.0-cp39-cp39-linux_armv7l.whl", hash = "sha256:0e87f105f1d152934759f8975ed002d5ce057b3cdf1cc6cb63fe6008671a27b9"}, + {file = "grpcio_tools-1.62.0-cp39-cp39-macosx_10_10_universal2.whl", hash = "sha256:bf9f281f528e0220558d57e09b4518dec148dcb250d78bd9cbb27e09edabb3f9"}, + {file = "grpcio_tools-1.62.0-cp39-cp39-manylinux_2_17_aarch64.whl", hash = "sha256:711314cb4c6c8b3d51bafaee380ffa5012bd0567ed68f1b0b1fc07492b27acab"}, + {file = "grpcio_tools-1.62.0-cp39-cp39-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:54bb570bd963905de3bda596b35e06026552705edebbb2cb737b57aa5252b9e5"}, + {file = "grpcio_tools-1.62.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dce5f04676cf94e6e2d13d7f91ac2de79097d86675bc4d404a3c24dcc0332c88"}, + {file = "grpcio_tools-1.62.0-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:98ddf871c614cc0ed331c7159ebbbf5040be562279677d3bb97c2e6083539f72"}, + {file = "grpcio_tools-1.62.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:f3aaf3b20c0f7063856b2432335af8f76cf580f898e04085548cde28332d6833"}, + {file = "grpcio_tools-1.62.0-cp39-cp39-win32.whl", hash = "sha256:3dee3be61d9032f777a9b4e2696ea3d0748a582cb99c672b5d41ca66821e8c87"}, + {file = "grpcio_tools-1.62.0-cp39-cp39-win_amd64.whl", hash = "sha256:f54b5181784464bd3573ae7dbcf053da18a4b7a75fe19960791f383be3d035ca"}, +] + +[package.dependencies] +grpcio = ">=1.62.0" +protobuf = ">=4.21.6,<5.0dev" +setuptools = "*" + +[[package]] +name = "iniconfig" +version = "2.0.0" +description = "brain-dead simple config-ini parsing" +optional = false +python-versions = ">=3.7" +files = [ + {file = "iniconfig-2.0.0-py3-none-any.whl", hash = "sha256:b6a85871a79d2e3b22d2d1b94ac2824226a63c6b741c88f7ae975f18b6778374"}, + {file = "iniconfig-2.0.0.tar.gz", hash = "sha256:2d91e135bf72d31a410b17c16da610a82cb55f6b0477d1a902134b24a455b8b3"}, +] + +[[package]] +name = "orderedmultidict" +version = "1.0.1" +description = "Ordered Multivalue Dictionary" +optional = false +python-versions = "*" +files = [ + {file = "orderedmultidict-1.0.1-py2.py3-none-any.whl", hash = "sha256:43c839a17ee3cdd62234c47deca1a8508a3f2ca1d0678a3bf791c87cf84adbf3"}, + {file = "orderedmultidict-1.0.1.tar.gz", hash = "sha256:04070bbb5e87291cc9bfa51df413677faf2141c73c61d2a5f7b26bea3cd882ad"}, +] + +[package.dependencies] +six = ">=1.8.0" + +[[package]] +name = "packaging" +version = "24.0" +description = "Core utilities for Python packages" +optional = false +python-versions = ">=3.7" +files = [ + {file = "packaging-24.0-py3-none-any.whl", hash = "sha256:2ddfb553fdf02fb784c234c7ba6ccc288296ceabec964ad2eae3777778130bc5"}, + {file = "packaging-24.0.tar.gz", hash = "sha256:eb82c5e3e56209074766e6885bb04b8c38a0c015d0a30036ebe7ece34c9989e9"}, +] + +[[package]] +name = "pluggy" +version = "1.4.0" +description = "plugin and hook calling mechanisms for python" +optional = false +python-versions = ">=3.8" +files = [ + {file = "pluggy-1.4.0-py3-none-any.whl", hash = "sha256:7db9f7b503d67d1c5b95f59773ebb58a8c1c288129a88665838012cfb07b8981"}, + {file = "pluggy-1.4.0.tar.gz", hash = "sha256:8c85c2876142a764e5b7548e7d9a0e0ddb46f5185161049a79b7e974454223be"}, +] + +[package.extras] +dev = ["pre-commit", "tox"] +testing = ["pytest", "pytest-benchmark"] + +[[package]] +name = "protobuf" +version = "4.25.3" +description = "" +optional = false +python-versions = ">=3.8" +files = [ + {file = "protobuf-4.25.3-cp310-abi3-win32.whl", hash = "sha256:d4198877797a83cbfe9bffa3803602bbe1625dc30d8a097365dbc762e5790faa"}, + {file = "protobuf-4.25.3-cp310-abi3-win_amd64.whl", hash = "sha256:209ba4cc916bab46f64e56b85b090607a676f66b473e6b762e6f1d9d591eb2e8"}, + {file = "protobuf-4.25.3-cp37-abi3-macosx_10_9_universal2.whl", hash = "sha256:f1279ab38ecbfae7e456a108c5c0681e4956d5b1090027c1de0f934dfdb4b35c"}, + {file = "protobuf-4.25.3-cp37-abi3-manylinux2014_aarch64.whl", hash = "sha256:e7cb0ae90dd83727f0c0718634ed56837bfeeee29a5f82a7514c03ee1364c019"}, + {file = "protobuf-4.25.3-cp37-abi3-manylinux2014_x86_64.whl", hash = "sha256:7c8daa26095f82482307bc717364e7c13f4f1c99659be82890dcfc215194554d"}, + {file = "protobuf-4.25.3-cp38-cp38-win32.whl", hash = "sha256:f4f118245c4a087776e0a8408be33cf09f6c547442c00395fbfb116fac2f8ac2"}, + {file = "protobuf-4.25.3-cp38-cp38-win_amd64.whl", hash = "sha256:c053062984e61144385022e53678fbded7aea14ebb3e0305ae3592fb219ccfa4"}, + {file = "protobuf-4.25.3-cp39-cp39-win32.whl", hash = "sha256:19b270aeaa0099f16d3ca02628546b8baefe2955bbe23224aaf856134eccf1e4"}, + {file = "protobuf-4.25.3-cp39-cp39-win_amd64.whl", hash = "sha256:e3c97a1555fd6388f857770ff8b9703083de6bf1f9274a002a332d65fbb56c8c"}, + {file = "protobuf-4.25.3-py3-none-any.whl", hash = "sha256:f0700d54bcf45424477e46a9f0944155b46fb0639d69728739c0e47bab83f2b9"}, + {file = "protobuf-4.25.3.tar.gz", hash = "sha256:25b5d0b42fd000320bd7830b349e3b696435f3b329810427a6bcce6a5492cc5c"}, +] + +[[package]] +name = "pydantic" +version = "2.6.3" +description = "Data validation using Python type hints" +optional = false +python-versions = ">=3.8" +files = [ + {file = "pydantic-2.6.3-py3-none-any.whl", hash = "sha256:72c6034df47f46ccdf81869fddb81aade68056003900a8724a4f160700016a2a"}, + {file = "pydantic-2.6.3.tar.gz", hash = "sha256:e07805c4c7f5c6826e33a1d4c9d47950d7eaf34868e2690f8594d2e30241f11f"}, +] + +[package.dependencies] +annotated-types = ">=0.4.0" +pydantic-core = "2.16.3" +typing-extensions = ">=4.6.1" + +[package.extras] +email = ["email-validator (>=2.0.0)"] + +[[package]] +name = "pydantic-core" +version = "2.16.3" +description = "" +optional = false +python-versions = ">=3.8" +files = [ + {file = "pydantic_core-2.16.3-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:75b81e678d1c1ede0785c7f46690621e4c6e63ccd9192af1f0bd9d504bbb6bf4"}, + {file = "pydantic_core-2.16.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:9c865a7ee6f93783bd5d781af5a4c43dadc37053a5b42f7d18dc019f8c9d2bd1"}, + {file = "pydantic_core-2.16.3-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:162e498303d2b1c036b957a1278fa0899d02b2842f1ff901b6395104c5554a45"}, + {file = "pydantic_core-2.16.3-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:2f583bd01bbfbff4eaee0868e6fc607efdfcc2b03c1c766b06a707abbc856187"}, + {file = "pydantic_core-2.16.3-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b926dd38db1519ed3043a4de50214e0d600d404099c3392f098a7f9d75029ff8"}, + {file = "pydantic_core-2.16.3-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:716b542728d4c742353448765aa7cdaa519a7b82f9564130e2b3f6766018c9ec"}, + {file = "pydantic_core-2.16.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fc4ad7f7ee1a13d9cb49d8198cd7d7e3aa93e425f371a68235f784e99741561f"}, + {file = "pydantic_core-2.16.3-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:bd87f48924f360e5d1c5f770d6155ce0e7d83f7b4e10c2f9ec001c73cf475c99"}, + {file = "pydantic_core-2.16.3-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:0df446663464884297c793874573549229f9eca73b59360878f382a0fc085979"}, + {file = "pydantic_core-2.16.3-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:4df8a199d9f6afc5ae9a65f8f95ee52cae389a8c6b20163762bde0426275b7db"}, + {file = "pydantic_core-2.16.3-cp310-none-win32.whl", hash = "sha256:456855f57b413f077dff513a5a28ed838dbbb15082ba00f80750377eed23d132"}, + {file = "pydantic_core-2.16.3-cp310-none-win_amd64.whl", hash = "sha256:732da3243e1b8d3eab8c6ae23ae6a58548849d2e4a4e03a1924c8ddf71a387cb"}, + {file = "pydantic_core-2.16.3-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:519ae0312616026bf4cedc0fe459e982734f3ca82ee8c7246c19b650b60a5ee4"}, + {file = "pydantic_core-2.16.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:b3992a322a5617ded0a9f23fd06dbc1e4bd7cf39bc4ccf344b10f80af58beacd"}, + {file = "pydantic_core-2.16.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8d62da299c6ecb04df729e4b5c52dc0d53f4f8430b4492b93aa8de1f541c4aac"}, + {file = "pydantic_core-2.16.3-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:2acca2be4bb2f2147ada8cac612f8a98fc09f41c89f87add7256ad27332c2fda"}, + {file = "pydantic_core-2.16.3-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1b662180108c55dfbf1280d865b2d116633d436cfc0bba82323554873967b340"}, + {file = "pydantic_core-2.16.3-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e7c6ed0dc9d8e65f24f5824291550139fe6f37fac03788d4580da0d33bc00c97"}, + {file = "pydantic_core-2.16.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a6b1bb0827f56654b4437955555dc3aeeebeddc47c2d7ed575477f082622c49e"}, + {file = "pydantic_core-2.16.3-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:e56f8186d6210ac7ece503193ec84104da7ceb98f68ce18c07282fcc2452e76f"}, + {file = "pydantic_core-2.16.3-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:936e5db01dd49476fa8f4383c259b8b1303d5dd5fb34c97de194560698cc2c5e"}, + {file = "pydantic_core-2.16.3-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:33809aebac276089b78db106ee692bdc9044710e26f24a9a2eaa35a0f9fa70ba"}, + {file = "pydantic_core-2.16.3-cp311-none-win32.whl", hash = "sha256:ded1c35f15c9dea16ead9bffcde9bb5c7c031bff076355dc58dcb1cb436c4721"}, + {file = "pydantic_core-2.16.3-cp311-none-win_amd64.whl", hash = "sha256:d89ca19cdd0dd5f31606a9329e309d4fcbb3df860960acec32630297d61820df"}, + {file = "pydantic_core-2.16.3-cp311-none-win_arm64.whl", hash = "sha256:6162f8d2dc27ba21027f261e4fa26f8bcb3cf9784b7f9499466a311ac284b5b9"}, + {file = "pydantic_core-2.16.3-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:0f56ae86b60ea987ae8bcd6654a887238fd53d1384f9b222ac457070b7ac4cff"}, + {file = "pydantic_core-2.16.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:c9bd22a2a639e26171068f8ebb5400ce2c1bc7d17959f60a3b753ae13c632975"}, + {file = "pydantic_core-2.16.3-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4204e773b4b408062960e65468d5346bdfe139247ee5f1ca2a378983e11388a2"}, + {file = "pydantic_core-2.16.3-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f651dd19363c632f4abe3480a7c87a9773be27cfe1341aef06e8759599454120"}, + {file = "pydantic_core-2.16.3-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:aaf09e615a0bf98d406657e0008e4a8701b11481840be7d31755dc9f97c44053"}, + {file = "pydantic_core-2.16.3-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8e47755d8152c1ab5b55928ab422a76e2e7b22b5ed8e90a7d584268dd49e9c6b"}, + {file = "pydantic_core-2.16.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:500960cb3a0543a724a81ba859da816e8cf01b0e6aaeedf2c3775d12ee49cade"}, + {file = "pydantic_core-2.16.3-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:cf6204fe865da605285c34cf1172879d0314ff267b1c35ff59de7154f35fdc2e"}, + {file = "pydantic_core-2.16.3-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:d33dd21f572545649f90c38c227cc8631268ba25c460b5569abebdd0ec5974ca"}, + {file = "pydantic_core-2.16.3-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:49d5d58abd4b83fb8ce763be7794d09b2f50f10aa65c0f0c1696c677edeb7cbf"}, + {file = "pydantic_core-2.16.3-cp312-none-win32.whl", hash = "sha256:f53aace168a2a10582e570b7736cc5bef12cae9cf21775e3eafac597e8551fbe"}, + {file = "pydantic_core-2.16.3-cp312-none-win_amd64.whl", hash = "sha256:0d32576b1de5a30d9a97f300cc6a3f4694c428d956adbc7e6e2f9cad279e45ed"}, + {file = "pydantic_core-2.16.3-cp312-none-win_arm64.whl", hash = "sha256:ec08be75bb268473677edb83ba71e7e74b43c008e4a7b1907c6d57e940bf34b6"}, + {file = "pydantic_core-2.16.3-cp38-cp38-macosx_10_12_x86_64.whl", hash = "sha256:b1f6f5938d63c6139860f044e2538baeee6f0b251a1816e7adb6cbce106a1f01"}, + {file = "pydantic_core-2.16.3-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:2a1ef6a36fdbf71538142ed604ad19b82f67b05749512e47f247a6ddd06afdc7"}, + {file = "pydantic_core-2.16.3-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:704d35ecc7e9c31d48926150afada60401c55efa3b46cd1ded5a01bdffaf1d48"}, + {file = "pydantic_core-2.16.3-cp38-cp38-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:d937653a696465677ed583124b94a4b2d79f5e30b2c46115a68e482c6a591c8a"}, + {file = "pydantic_core-2.16.3-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c9803edf8e29bd825f43481f19c37f50d2b01899448273b3a7758441b512acf8"}, + {file = "pydantic_core-2.16.3-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:72282ad4892a9fb2da25defeac8c2e84352c108705c972db82ab121d15f14e6d"}, + {file = "pydantic_core-2.16.3-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7f752826b5b8361193df55afcdf8ca6a57d0232653494ba473630a83ba50d8c9"}, + {file = "pydantic_core-2.16.3-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:4384a8f68ddb31a0b0c3deae88765f5868a1b9148939c3f4121233314ad5532c"}, + {file = "pydantic_core-2.16.3-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:a4b2bf78342c40b3dc830880106f54328928ff03e357935ad26c7128bbd66ce8"}, + {file = "pydantic_core-2.16.3-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:13dcc4802961b5f843a9385fc821a0b0135e8c07fc3d9949fd49627c1a5e6ae5"}, + {file = "pydantic_core-2.16.3-cp38-none-win32.whl", hash = "sha256:e3e70c94a0c3841e6aa831edab1619ad5c511199be94d0c11ba75fe06efe107a"}, + {file = "pydantic_core-2.16.3-cp38-none-win_amd64.whl", hash = "sha256:ecdf6bf5f578615f2e985a5e1f6572e23aa632c4bd1dc67f8f406d445ac115ed"}, + {file = "pydantic_core-2.16.3-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:bda1ee3e08252b8d41fa5537413ffdddd58fa73107171a126d3b9ff001b9b820"}, + {file = "pydantic_core-2.16.3-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:21b888c973e4f26b7a96491c0965a8a312e13be108022ee510248fe379a5fa23"}, + {file = "pydantic_core-2.16.3-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:be0ec334369316fa73448cc8c982c01e5d2a81c95969d58b8f6e272884df0074"}, + {file = "pydantic_core-2.16.3-cp39-cp39-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b5b6079cc452a7c53dd378c6f881ac528246b3ac9aae0f8eef98498a75657805"}, + {file = "pydantic_core-2.16.3-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:7ee8d5f878dccb6d499ba4d30d757111847b6849ae07acdd1205fffa1fc1253c"}, + {file = "pydantic_core-2.16.3-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7233d65d9d651242a68801159763d09e9ec96e8a158dbf118dc090cd77a104c9"}, + {file = "pydantic_core-2.16.3-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c6119dc90483a5cb50a1306adb8d52c66e447da88ea44f323e0ae1a5fcb14256"}, + {file = "pydantic_core-2.16.3-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:578114bc803a4c1ff9946d977c221e4376620a46cf78da267d946397dc9514a8"}, + {file = "pydantic_core-2.16.3-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:d8f99b147ff3fcf6b3cc60cb0c39ea443884d5559a30b1481e92495f2310ff2b"}, + {file = "pydantic_core-2.16.3-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:4ac6b4ce1e7283d715c4b729d8f9dab9627586dafce81d9eaa009dd7f25dd972"}, + {file = "pydantic_core-2.16.3-cp39-none-win32.whl", hash = "sha256:e7774b570e61cb998490c5235740d475413a1f6de823169b4cf94e2fe9e9f6b2"}, + {file = "pydantic_core-2.16.3-cp39-none-win_amd64.whl", hash = "sha256:9091632a25b8b87b9a605ec0e61f241c456e9248bfdcf7abdf344fdb169c81cf"}, + {file = "pydantic_core-2.16.3-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:36fa178aacbc277bc6b62a2c3da95226520da4f4e9e206fdf076484363895d2c"}, + {file = "pydantic_core-2.16.3-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:dcca5d2bf65c6fb591fff92da03f94cd4f315972f97c21975398bd4bd046854a"}, + {file = "pydantic_core-2.16.3-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2a72fb9963cba4cd5793854fd12f4cfee731e86df140f59ff52a49b3552db241"}, + {file = "pydantic_core-2.16.3-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b60cc1a081f80a2105a59385b92d82278b15d80ebb3adb200542ae165cd7d183"}, + {file = "pydantic_core-2.16.3-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:cbcc558401de90a746d02ef330c528f2e668c83350f045833543cd57ecead1ad"}, + {file = "pydantic_core-2.16.3-pp310-pypy310_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:fee427241c2d9fb7192b658190f9f5fd6dfe41e02f3c1489d2ec1e6a5ab1e04a"}, + {file = "pydantic_core-2.16.3-pp310-pypy310_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:f4cb85f693044e0f71f394ff76c98ddc1bc0953e48c061725e540396d5c8a2e1"}, + {file = "pydantic_core-2.16.3-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:b29eeb887aa931c2fcef5aa515d9d176d25006794610c264ddc114c053bf96fe"}, + {file = "pydantic_core-2.16.3-pp39-pypy39_pp73-macosx_10_12_x86_64.whl", hash = "sha256:a425479ee40ff021f8216c9d07a6a3b54b31c8267c6e17aa88b70d7ebd0e5e5b"}, + {file = "pydantic_core-2.16.3-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:5c5cbc703168d1b7a838668998308018a2718c2130595e8e190220238addc96f"}, + {file = "pydantic_core-2.16.3-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:99b6add4c0b39a513d323d3b93bc173dac663c27b99860dd5bf491b240d26137"}, + {file = "pydantic_core-2.16.3-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:75f76ee558751746d6a38f89d60b6228fa174e5172d143886af0f85aa306fd89"}, + {file = "pydantic_core-2.16.3-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:00ee1c97b5364b84cb0bd82e9bbf645d5e2871fb8c58059d158412fee2d33d8a"}, + {file = "pydantic_core-2.16.3-pp39-pypy39_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:287073c66748f624be4cef893ef9174e3eb88fe0b8a78dc22e88eca4bc357ca6"}, + {file = "pydantic_core-2.16.3-pp39-pypy39_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:ed25e1835c00a332cb10c683cd39da96a719ab1dfc08427d476bce41b92531fc"}, + {file = "pydantic_core-2.16.3-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:86b3d0033580bd6bbe07590152007275bd7af95f98eaa5bd36f3da219dcd93da"}, + {file = "pydantic_core-2.16.3.tar.gz", hash = "sha256:1cac689f80a3abab2d3c0048b29eea5751114054f032a941a32de4c852c59cad"}, +] + +[package.dependencies] +typing-extensions = ">=4.6.0,<4.7.0 || >4.7.0" + +[[package]] +name = "pytest" +version = "8.1.1" +description = "pytest: simple powerful testing with Python" +optional = false +python-versions = ">=3.8" +files = [ + {file = "pytest-8.1.1-py3-none-any.whl", hash = "sha256:2a8386cfc11fa9d2c50ee7b2a57e7d898ef90470a7a34c4b949ff59662bb78b7"}, + {file = "pytest-8.1.1.tar.gz", hash = "sha256:ac978141a75948948817d360297b7aae0fcb9d6ff6bc9ec6d514b85d5a65c044"}, +] + +[package.dependencies] +colorama = {version = "*", markers = "sys_platform == \"win32\""} +exceptiongroup = {version = ">=1.0.0rc8", markers = "python_version < \"3.11\""} +iniconfig = "*" +packaging = "*" +pluggy = ">=1.4,<2.0" +tomli = {version = ">=1", markers = "python_version < \"3.11\""} + +[package.extras] +testing = ["argcomplete", "attrs (>=19.2)", "hypothesis (>=3.56)", "mock", "pygments (>=2.7.2)", "requests", "setuptools", "xmlschema"] + +[[package]] +name = "ruff" +version = "0.3.3" +description = "An extremely fast Python linter and code formatter, written in Rust." +optional = false +python-versions = ">=3.7" +files = [ + {file = "ruff-0.3.3-py3-none-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:973a0e388b7bc2e9148c7f9be8b8c6ae7471b9be37e1cc732f8f44a6f6d7720d"}, + {file = "ruff-0.3.3-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:cfa60d23269d6e2031129b053fdb4e5a7b0637fc6c9c0586737b962b2f834493"}, + {file = "ruff-0.3.3-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1eca7ff7a47043cf6ce5c7f45f603b09121a7cc047447744b029d1b719278eb5"}, + {file = "ruff-0.3.3-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e7d3f6762217c1da954de24b4a1a70515630d29f71e268ec5000afe81377642d"}, + {file = "ruff-0.3.3-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b24c19e8598916d9c6f5a5437671f55ee93c212a2c4c569605dc3842b6820386"}, + {file = "ruff-0.3.3-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:5a6cbf216b69c7090f0fe4669501a27326c34e119068c1494f35aaf4cc683778"}, + {file = "ruff-0.3.3-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:352e95ead6964974b234e16ba8a66dad102ec7bf8ac064a23f95371d8b198aab"}, + {file = "ruff-0.3.3-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8d6ab88c81c4040a817aa432484e838aaddf8bfd7ca70e4e615482757acb64f8"}, + {file = "ruff-0.3.3-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:79bca3a03a759cc773fca69e0bdeac8abd1c13c31b798d5bb3c9da4a03144a9f"}, + {file = "ruff-0.3.3-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:2700a804d5336bcffe063fd789ca2c7b02b552d2e323a336700abb8ae9e6a3f8"}, + {file = "ruff-0.3.3-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:fd66469f1a18fdb9d32e22b79f486223052ddf057dc56dea0caaf1a47bdfaf4e"}, + {file = "ruff-0.3.3-py3-none-musllinux_1_2_i686.whl", hash = "sha256:45817af234605525cdf6317005923bf532514e1ea3d9270acf61ca2440691376"}, + {file = "ruff-0.3.3-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:0da458989ce0159555ef224d5b7c24d3d2e4bf4c300b85467b08c3261c6bc6a8"}, + {file = "ruff-0.3.3-py3-none-win32.whl", hash = "sha256:f2831ec6a580a97f1ea82ea1eda0401c3cdf512cf2045fa3c85e8ef109e87de0"}, + {file = "ruff-0.3.3-py3-none-win_amd64.whl", hash = "sha256:be90bcae57c24d9f9d023b12d627e958eb55f595428bafcb7fec0791ad25ddfc"}, + {file = "ruff-0.3.3-py3-none-win_arm64.whl", hash = "sha256:0171aab5fecdc54383993389710a3d1227f2da124d76a2784a7098e818f92d61"}, + {file = "ruff-0.3.3.tar.gz", hash = "sha256:38671be06f57a2f8aba957d9f701ea889aa5736be806f18c0cd03d6ff0cbca8d"}, +] + +[[package]] +name = "setuptools" +version = "69.1.1" +description = "Easily download, build, install, upgrade, and uninstall Python packages" +optional = false +python-versions = ">=3.8" +files = [ + {file = "setuptools-69.1.1-py3-none-any.whl", hash = "sha256:02fa291a0471b3a18b2b2481ed902af520c69e8ae0919c13da936542754b4c56"}, + {file = "setuptools-69.1.1.tar.gz", hash = "sha256:5c0806c7d9af348e6dd3777b4f4dbb42c7ad85b190104837488eab9a7c945cf8"}, +] + +[package.extras] +docs = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "pygments-github-lexers (==0.0.5)", "rst.linker (>=1.9)", "sphinx (<7.2.5)", "sphinx (>=3.5)", "sphinx-favicon", "sphinx-inline-tabs", "sphinx-lint", "sphinx-notfound-page (>=1,<2)", "sphinx-reredirects", "sphinxcontrib-towncrier"] +testing = ["build[virtualenv]", "filelock (>=3.4.0)", "flake8-2020", "ini2toml[lite] (>=0.9)", "jaraco.develop (>=7.21)", "jaraco.envs (>=2.2)", "jaraco.path (>=3.2.0)", "packaging (>=23.2)", "pip (>=19.1)", "pytest (>=6)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=2.2)", "pytest-home (>=0.5)", "pytest-mypy (>=0.9.1)", "pytest-perf", "pytest-ruff (>=0.2.1)", "pytest-timeout", "pytest-xdist", "tomli-w (>=1.0.0)", "virtualenv (>=13.0.0)", "wheel"] +testing-integration = ["build[virtualenv] (>=1.0.3)", "filelock (>=3.4.0)", "jaraco.envs (>=2.2)", "jaraco.path (>=3.2.0)", "packaging (>=23.2)", "pytest", "pytest-enabler", "pytest-xdist", "tomli", "virtualenv (>=13.0.0)", "wheel"] + +[[package]] +name = "six" +version = "1.16.0" +description = "Python 2 and 3 compatibility utilities" +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*" +files = [ + {file = "six-1.16.0-py2.py3-none-any.whl", hash = "sha256:8abb2f1d86890a2dfb989f9a77cfcfd3e47c2a354b01111771326f8aa26e0254"}, + {file = "six-1.16.0.tar.gz", hash = "sha256:1e61c37477a1626458e36f7b1d82aa5c9b094fa4802892072e49de9c60c4c926"}, +] + +[[package]] +name = "tomli" +version = "2.0.1" +description = "A lil' TOML parser" +optional = false +python-versions = ">=3.7" +files = [ + {file = "tomli-2.0.1-py3-none-any.whl", hash = "sha256:939de3e7a6161af0c887ef91b7d41a53e7c5a1ca976325f429cb46ea9bc30ecc"}, + {file = "tomli-2.0.1.tar.gz", hash = "sha256:de526c12914f0c550d15924c62d72abc48d6fe7364aa87328337a31007fe8a4f"}, +] + +[[package]] +name = "typing-extensions" +version = "4.10.0" +description = "Backported and Experimental Type Hints for Python 3.8+" +optional = false +python-versions = ">=3.8" +files = [ + {file = "typing_extensions-4.10.0-py3-none-any.whl", hash = "sha256:69b1a937c3a517342112fb4c6df7e72fc39a38e7891a5730ed4985b5214b5475"}, + {file = "typing_extensions-4.10.0.tar.gz", hash = "sha256:b0abd7c89e8fb96f98db18d86106ff1d90ab692004eb746cf6eda2682f91b3cb"}, +] + +[metadata] +lock-version = "2.0" +python-versions = "^3.8" +content-hash = "3cb512f984c5760846d59b08c768c955367837cc9139a2611fe92869eb8fb483" diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 0000000..00a73aa --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,23 @@ +[tool.poetry] +name = "milvus-connector" +version = "0.1.0" +description = "" +authors = ["SimFG <1142838399@qq.com>"] +readme = "README.md" + +[tool.poetry.dependencies] +python = "^3.8" +grpcio = "^1.62.0" +grpcio-tools = "^1.62.0" +furl = "^2.1.3" +typing-extensions = "^4.10.0" +pydantic = "^2.6.3" + + +[tool.poetry.group.dev.dependencies] +pytest = "^8.1.1" +ruff = "^0.3.3" + +[build-system] +requires = ["poetry-core"] +build-backend = "poetry.core.masonry.api" diff --git a/ruff.toml b/ruff.toml new file mode 100644 index 0000000..2de2384 --- /dev/null +++ b/ruff.toml @@ -0,0 +1,63 @@ +# Exclude a variety of commonly ignored directories. +exclude = [ + ".bzr", + ".direnv", + ".eggs", + ".git", + ".git-rewrite", + ".hg", + ".ipynb_checkpoints", + ".mypy_cache", + ".nox", + ".pants.d", + ".pyenv", + ".pytest_cache", + ".pytype", + ".ruff_cache", + ".svn", + ".tox", + ".venv", + ".vscode", + "__pypackages__", + "_build", + "buck-out", + "build", + "dist", + "node_modules", + "site-packages", + "venv", + "all_proto", + "milvus_connector/protocol", +] + +# Same as Black. +line-length = 100 +indent-width = 4 + +# Assume Python 3.8 +target-version = "py310" + +[lint] +# Enable Pyflakes (`F`) and a subset of the pycodestyle (`E`) codes by default. +select = ["E4", "E7", "E9", "F"] +ignore = ["F403", "F405"] + +# Allow fix for all enabled rules (when `--fix`) is provided. +fixable = ["ALL"] +unfixable = [] + +# Allow unused variables when underscore-prefixed. +dummy-variable-rgx = "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$" + +[format] +# Like Black, use double quotes for strings. +quote-style = "double" + +# Like Black, indent with spaces, rather than tabs. +indent-style = "space" + +# Like Black, respect magic trailing commas. +skip-magic-trailing-comma = false + +# Like Black, automatically detect the appropriate line ending. +line-ending = "auto" \ No newline at end of file diff --git a/script/generate_proto.sh b/script/generate_proto.sh new file mode 100755 index 0000000..ee9000f --- /dev/null +++ b/script/generate_proto.sh @@ -0,0 +1,27 @@ +#!/bin/bash + +src="../all_proto" +dst="../milvus_connector/protocol" + +files=$(find "$src" -type f -name "*.proto") + +for file in $files; do + filename=$(basename "$file" .proto) + + python -m grpc_tools.protoc -I "$src" --python_out="$dst" --grpc_python_out="$dst" --pyi_out="$dst" "$src/$filename.proto" +done + +files=$(find "$dst" -type f -name "*.py*") + +if [[ $(uname -s) == "Darwin" ]]; then + if ! brew --prefix --installed gnu-sed >/dev/null 2>&1; then + brew install gnu-sed + fi + export PATH="/usr/local/opt/gsed/libexec/gnubin:$PATH" +fi + +for file in $files; do + sed -i '/^import.*_pb2/ s/^/from . /' $file +done + +echo "generate_proto done." \ No newline at end of file diff --git a/tests/__init__.py b/tests/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/test_milvus.py b/tests/test_milvus.py new file mode 100644 index 0000000..199dc25 --- /dev/null +++ b/tests/test_milvus.py @@ -0,0 +1,7 @@ +from milvus_connector.core.milvus import Milvus + + +def test_milvus(): + m = Milvus() + m.show_collections() + # print(m.json().list_collections())