resp-benchmark 0.1.7__cp39-cp39-musllinux_1_2_x86_64.whl → 0.2.0__cp39-cp39-musllinux_1_2_x86_64.whl

resp_benchmark/__init__.py

@@ -1 +1,3 @@
 from .wrapper import Benchmark, Result
+
+__all__ = ["Benchmark", "Result"]

resp_benchmark/cli.py

@@ -18,6 +18,7 @@ def parse_args():
     parser.add_argument("--cores", type=str, default=f"", help="Comma-separated list of CPU cores to use (default all)")
     parser.add_argument("--cluster", action="store_true", help="Use cluster mode (default false)")
     parser.add_argument("-n", metavar="requests", type=int, default=0, help="Total number of requests (default 0), 0 for unlimited.")
+    parser.add_argument("-t", metavar="target", type=int, default=0, help="Target number of requests per second, 0 for unlimited, recommended to be multiple of 100.")
     parser.add_argument("-s", metavar="seconds", type=int, default=0, help="Total time in seconds (default 0), 0 for unlimited.")
     parser.add_argument("-P", metavar="pipeline", type=int, default=1, help="Pipeline <numreq> requests. Default 1 (no pipeline).")
     # parser.add_argument("--tls", action="store_true", help="Use TLS for connection (default false)")
@@ -34,9 +35,9 @@ def main():
     args = parse_args()
     bm = Benchmark(host=args.h, port=args.p, username=args.u, password=args.a, cluster=args.cluster, cores=args.cores, timeout=30)
     if args.load:
-        bm.load_data(command=args.command, connections=args.c, pipeline=args.P, count=args.n)
+        bm.load_data(command=args.command, connections=args.c, pipeline=args.P, count=args.n, target=args.t)
     else:
-        bm.bench(command=args.command, connections=args.c, pipeline=args.P, count=args.n, seconds=args.s)
+        bm.bench(command=args.command, connections=args.c, pipeline=args.P, count=args.n, target=args.t, seconds=args.s)
 
 
 if __name__ == "__main__":

resp_benchmark/wrapper.py

@@ -69,6 +69,7 @@ class Benchmark:
             connections: int = 0,
             pipeline: int = 1,
             count: int = 0,
+            target: int = 0,
             seconds: int = 0,
             quiet: bool = False,
     ) -> Result:
@@ -80,6 +81,7 @@ class Benchmark:
             connections (int): The number of parallel connections.
             pipeline (int): The number of commands to pipeline.
             count (int): The total number of requests to make.
+            target(int): The number of requests to send per second.
             seconds (int): The duration of the test in seconds.
             quiet: (bool): Whether to suppress output.
         Returns:
@@ -100,6 +102,7 @@ class Benchmark:
             connections=connections,
             pipeline=pipeline,
             count=count,
+            target=target,
             seconds=seconds,
             load=False,
             quiet=quiet,
@@ -113,13 +116,14 @@ class Benchmark:
 
         return result
 
-    def load_data(self, command: str, count: int, connections: int = 128, pipeline: int = 10, quiet: bool = False):
+    def load_data(self, command: str, count: int, target: int = 0, connections: int = 128, pipeline: int = 10, quiet: bool = False):
         """
         Load data into the Redis server using the specified command.
 
         Args:
             command (str): The Redis command to use for loading data.
             count (int): The total number of requests to make.
+            target(int): The number of requests to send per second.
             connections (int): The number of parallel connections.
             pipeline (int): The number of commands to pipeline
             quiet: (bool): Whether to suppress output.
@@ -140,6 +144,7 @@ class Benchmark:
             connections=connections,
             pipeline=pipeline,
             count=count,
+            target=target,
             seconds=0,
             load=True,
             quiet=quiet,

resp_benchmark-0.2.0.dist-info/METADATA

@@ -0,0 +1,386 @@
+Metadata-Version: 2.4
+Name: resp-benchmark
+Version: 0.2.0
+Classifier: Programming Language :: Rust
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Requires-Dist: pydantic
+Requires-Dist: redis
+License-File: LICENSE
+Summary: resp-benchmark is a benchmark tool for testing databases that support the RESP protocol, such as Redis, Valkey, and Tair.
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+
+# resp-benchmark
+
+[![Python - Version](https://img.shields.io/badge/python-%3E%3D3.8-brightgreen)](https://www.python.org/doc/versions/)
+[![PyPI - Version](https://img.shields.io/pypi/v/resp-benchmark?color=%231772b4)](https://pypi.org/project/resp-benchmark/)
+[![PyPI - Downloads](https://img.shields.io/pypi/dw/resp-benchmark?color=%231ba784)](https://pypi.org/project/resp-benchmark/)
+[![License](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/tair-opensource/resp-benchmark/blob/main/LICENSE)
+
+[English](README_en.md) | 中文
+
+一个基于 Rust 构建的 RESP (Redis 序列化协议) 数据库基准测试工具，提供 Python 绑定。用于测试 Redis、Valkey、Tair 等 RESP 兼容数据库的性能。
+
+## 主要功能
+
+- 支持自定义命令模板和占位符
+- 多线程并发测试
+- 支持连接池和管道操作
+- 支持 Redis 集群模式
+- 提供 CLI 工具和 Python 库接口
+- 内置 QPS 限流控制
+
+## 安装
+
+需要 Python 3.9 或更高版本。
+
+```bash
+pip install resp-benchmark
+```
+
+## 快速开始
+
+### 命令行使用
+
+```bash
+# 基础基准测试
+resp-benchmark -s 10 "SET {key uniform 100000} {value 64}"
+
+# 加载数据然后测试
+resp-benchmark --load -n 1000000 "SET {key sequence 100000} {value 64}"
+resp-benchmark -s 10 "GET {key uniform 100000}"
+
+# 自定义连接数和管道
+resp-benchmark -c 128 -P 10 -s 30 "SET {key uniform 1000000} {value 128}"
+```
+
+### Python 库使用
+
+```python
+from resp_benchmark import Benchmark
+
+# 初始化基准测试
+bm = Benchmark(host="127.0.0.1", port=6379)
+
+# 加载测试数据
+bm.load_data(
+    command="SET {key sequence 1000000} {value 64}", 
+    count=1000000, 
+    connections=128
+)
+
+# 运行基准测试
+result = bm.bench(
+    command="GET {key uniform 1000000}", 
+    seconds=30, 
+    connections=64
+)
+
+print(f"QPS: {result.qps}")
+print(f"平均延迟: {result.avg_latency_ms}ms")
+print(f"P99 延迟: {result.p99_latency_ms}ms")
+```
+
+## 命令语法
+
+resp-benchmark 使用强大的占位符系统来生成多样化和真实的测试数据：
+
+### 键占位符
+
+- **`{key uniform N}`**: 从 0 到 N-1 的随机键
+  - 示例: `{key uniform 100000}` → `key_0000099999`
+  
+- **`{key sequence N}`**: 从 0 到 N-1 的顺序键（适用于加载数据）
+  - 示例: `{key sequence 100000}` → `key_0000000000`, `key_0000000001`, ...
+  
+- **`{key zipfian N}`**: Zipfian 分布键（模拟真实世界的访问模式）
+  - 示例: `{key zipfian 100000}` → 遵循指数为 1.03 的 Zipfian 分布
+
+### 值占位符
+
+- **`{value N}`**: N 字节的随机字符串
+  - 示例: `{value 64}` → `a8x9mK2p...` (64 字节)
+  
+- **`{rand N}`**: 0 到 N-1 的随机数
+  - 示例: `{rand 1000}` → `742`
+  
+- **`{range N W}`**: 范围 N 内相差 W 的两个数字
+  - 示例: `{range 100 10}` → `45 55`
+
+### 命令示例
+
+```bash
+# 字符串操作
+SET {key uniform 1000000} {value 64}
+GET {key uniform 1000000}
+INCR {key uniform 100000}
+
+# 列表操作
+LPUSH {key uniform 1000} {value 64}
+LINDEX {key uniform 1000} {rand 100}
+
+# 集合操作
+SADD {key uniform 1000} {value 64}
+SISMEMBER {key uniform 1000} {value 64}
+
+# 有序集合操作
+ZADD {key uniform 1000} {rand 1000} {value 64}
+ZRANGEBYSCORE {key uniform 1000} {range 1000 100}
+
+# 哈希操作
+HSET {key uniform 1000} {key uniform 100} {value 64}
+HGET {key uniform 1000} {key uniform 100}
+```
+
+## 命令行选项
+
+| 选项 | 描述 | 默认值 |
+|------|------|--------|
+| `-h` | 服务器主机名 | 127.0.0.1 |
+| `-p` | 服务器端口 | 6379 |
+| `-u` | 认证用户名 | "" |
+| `-a` | 认证密码 | "" |
+| `-c` | 连接数（0 为自动） | 0 |
+| `-n` | 总请求数（0 为无限） | 0 |
+| `-s` | 持续时间（秒）（0 为无限） | 0 |
+| `-t` | 目标 QPS（0 为无限） | 0 |
+| `-P` | 管道深度 | 1 |
+| `--cores` | 使用的 CPU 核心（逗号分隔） | 全部 |
+| `--cluster` | 启用集群模式 | false |
+| `--load` | 仅加载数据，不进行基准测试 | false |
+
+## 高级特性
+
+### 连接自动扩展
+
+当指定 `-c 0` 时，resp-benchmark 根据系统资源和目标 QPS 自动确定最优连接数。
+
+### CPU 核心绑定
+
+将基准测试线程绑定到特定 CPU 核心以获得一致的性能：
+
+```bash
+# 使用核心 0, 1, 2, 3
+resp-benchmark --cores 0,1,2,3 -s 10 "SET {key uniform 100000} {value 64}"
+```
+
+### 速率限制
+
+控制请求速率进行渐进式负载测试：
+
+```bash
+# 目标 10,000 QPS
+resp-benchmark -t 10000 -s 30 "SET {key uniform 100000} {value 64}"
+```
+
+### 管道操作
+
+使用管道进行批量操作：
+
+```bash
+# 每个连接管道 10 个请求
+resp-benchmark -P 10 -c 128 -s 30 "SET {key uniform 100000} {value 64}"
+```
+
+### 集群模式
+
+使用自动槽位分布测试 Redis 集群：
+
+```bash
+resp-benchmark --cluster -h cluster-endpoint -p 7000 -s 30 "SET {key uniform 100000} {value 64}"
+```
+
+## 性能优化
+
+### 最佳实践
+
+1. **预加载数据**: 使用 `--load` 在基准测试前填充测试数据
+2. **适当的连接数**: 从 `-c 128` 开始，根据结果调整
+3. **键分布**: 读取使用 `uniform`，写入使用 `sequence`
+4. **明智使用管道**: 批量操作使用 `-P 10`，延迟测试使用 `-P 1`
+5. **清洁状态**: 测试之间清除数据以避免干扰
+
+### 示例工作流程
+
+```bash
+# 1. 清除现有数据
+redis-cli FLUSHALL
+
+# 2. 加载测试数据
+resp-benchmark --load -c 256 -P 10 -n 1000000 "SET {key sequence 100000} {value 64}"
+
+# 3. 使用不同模式进行基准测试
+resp-benchmark -c 128 -s 30 "GET {key uniform 100000}"    # 随机访问
+resp-benchmark -c 128 -s 30 "GET {key zipfian 100000}"    # 真实访问模式
+```
+
+## 完整示例
+
+### 字符串操作
+
+```bash
+# 基本 SET/GET
+resp-benchmark --load -n 1000000 "SET {key sequence 100000} {value 64}"
+resp-benchmark -s 10 "GET {key uniform 100000}"
+
+# 大值
+resp-benchmark -s 10 "SET {key uniform 10000} {value 1024}"
+
+# 递增操作
+resp-benchmark -s 10 "INCR {key uniform 10000}"
+```
+
+### 列表操作
+
+```bash
+# 构建列表
+resp-benchmark --load -n 1000000 "LPUSH {key sequence 1000} {value 64}"
+
+# 随机访问
+resp-benchmark -s 10 "LINDEX {key uniform 1000} {rand 1000}"
+
+# 范围操作
+resp-benchmark -s 10 "LRANGE {key uniform 1000} {range 1000 10}"
+```
+
+### 集合操作
+
+```bash
+# 填充集合
+resp-benchmark --load -n 1000000 "SADD {key sequence 1000} {key sequence 1000}"
+
+# 测试成员关系
+resp-benchmark -s 10 "SISMEMBER {key uniform 1000} {key uniform 1000}"
+```
+
+### 有序集合操作
+
+```bash
+# 添加带分数的成员
+resp-benchmark --load -n 1000000 "ZADD {key sequence 1000} {rand 10000} {key sequence 1000}"
+
+# 分数查询
+resp-benchmark -s 10 "ZSCORE {key uniform 1000} {key uniform 1000}"
+
+# 范围查询
+resp-benchmark -s 10 "ZRANGEBYSCORE {key uniform 1000} {range 10000 100}"
+```
+
+### 哈希操作
+
+```bash
+# 填充哈希
+resp-benchmark --load -n 1000000 "HSET {key sequence 1000} {key sequence 100} {value 64}"
+
+# 字段访问
+resp-benchmark -s 10 "HGET {key uniform 1000} {key uniform 100}"
+```
+
+### Lua 脚本
+
+```bash
+# 加载脚本
+redis-cli SCRIPT LOAD "return redis.call('SET', KEYS[1], ARGV[1])"
+
+# 基准测试脚本执行
+resp-benchmark -s 10 "EVALSHA d8f2fad9f8e86a53d2a6ebd960b33c4972cacc37 1 {key uniform 100000} {value 64}"
+```
+
+## Python 库 API
+
+### 初始化
+
+```python
+from resp_benchmark import Benchmark
+
+# 基本连接
+bm = Benchmark(host="127.0.0.1", port=6379)
+
+# 带认证
+bm = Benchmark(
+    host="redis.example.com",
+    port=6379,
+    username="user",
+    password="pass"
+)
+
+# 集群模式
+bm = Benchmark(
+    host="cluster-endpoint",
+    port=7000,
+    cluster=True
+)
+
+# 自定义配置
+bm = Benchmark(
+    host="127.0.0.1",
+    port=6379,
+    cores="0,1,2,3",  # 使用特定核心
+    timeout=30        # 连接超时
+)
+```
+
+### 加载数据
+
+```python
+# 顺序加载（推荐）
+bm.load_data(
+    command="SET {key sequence 1000000} {value 64}",
+    count=1000000,
+    connections=128,
+    pipeline=10
+)
+
+# 带速率限制
+bm.load_data(
+    command="SET {key sequence 1000000} {value 64}",
+    count=1000000,
+    connections=128,
+    target=50000  # 50k QPS
+)
+```
+
+### 基准测试
+
+```python
+# 基于时间的基准测试
+result = bm.bench(
+    command="GET {key uniform 1000000}",
+    seconds=30,
+    connections=64
+)
+
+# 基于计数的基准测试
+result = bm.bench(
+    command="GET {key uniform 1000000}",
+    count=1000000,
+    connections=64
+)
+
+# 带管道
+result = bm.bench(
+    command="SET {key uniform 1000000} {value 64}",
+    seconds=30,
+    connections=64,
+    pipeline=10
+)
+```
+
+### 结果分析
+
+```python
+# 访问基准测试结果
+print(f"QPS: {result.qps:.2f}")
+print(f"平均延迟: {result.avg_latency_ms:.2f}ms")
+print(f"P99 延迟: {result.p99_latency_ms:.2f}ms")
+print(f"使用的连接数: {result.connections}")
+```
+
+## 贡献
+
+欢迎贡献！请随时提交拉取请求或开启议题。
+
+## 许可证
+
+该项目基于 MIT 许可证 - 详见 [LICENSE](LICENSE) 文件。

resp_benchmark-0.2.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+resp_benchmark-0.2.0.dist-info/METADATA,sha256=BxS1x3Bjr63N3XyEZDirnxWF1GQ6v_QfT7ab-mScQo4,9432
+resp_benchmark-0.2.0.dist-info/WHEEL,sha256=ucV9ka2KinNaGscBEPXN-smAVjDumtk6IwmlYpiQ4-E,105
+resp_benchmark-0.2.0.dist-info/entry_points.txt,sha256=q1llaLwyhHn2jvpR28wBbila30DyZ1B5_4ackdlZ2R4,57
+resp_benchmark-0.2.0.dist-info/licenses/LICENSE,sha256=Kj-yFXYfT2SMHVx80nmX0ta2SPNqCQAq1_fwhkPqJrw,1072
+resp_benchmark.libs/libgcc_s-1e52349c.so.1,sha256=Ani0u_W_tB8ESsFePO4D2mn2lrgWLhyFdw6RETxBTYM,437537
+resp_benchmark/__init__.py,sha256=5DYLIsYOU6wd-xMX2sJF1IMr3vktktFIBE6CyxUc3A4,74
+resp_benchmark/_resp_benchmark_rust_lib.cpython-39-x86_64-linux-gnu.so,sha256=f-odrqk_AFkQtvXBfdpqVGD2o2zz1znmNXs-0tfpQKw,3022153
+resp_benchmark/cli.py,sha256=MH7MfDBBzEVCfTuq_K9vd_iKGVIs4LW4pk_U1tZpGoM,2695
+resp_benchmark/cores.py,sha256=bSEaHXJYo6spGIK_j-beTz8qbun3D7bgYrYxjUaMuDw,619
+resp_benchmark/wrapper.py,sha256=6S1YChLkEc65pGY5SxGnjO5biwVpZ8gHMGVt8tHeXtU,4989
+resp_benchmark-0.2.0.dist-info/RECORD,,

{resp_benchmark-0.1.7.dist-info → resp_benchmark-0.2.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: maturin (1.7.0)
+Generator: maturin (1.9.1)
 Root-Is-Purelib: false
 Tag: cp39-cp39-musllinux_1_2_x86_64

resp_benchmark-0.1.7.dist-info/METADATA

@@ -1,94 +0,0 @@
-Metadata-Version: 2.3
-Name: resp-benchmark
-Version: 0.1.7
-Classifier: Programming Language :: Rust
-Classifier: Programming Language :: Python :: Implementation :: CPython
-Classifier: Programming Language :: Python :: Implementation :: PyPy
-Requires-Dist: pydantic
-Requires-Dist: redis
-License-File: LICENSE
-Summary: resp-benchmark is a benchmark tool for testing databases that support the RESP protocol, such as Redis, Valkey, and Tair.
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
-
-# resp-benchmark
-
-[![Python - Version](https://img.shields.io/badge/python-%3E%3D3.8-brightgreen)](https://www.python.org/doc/versions/)
-[![PyPI - Version](https://img.shields.io/pypi/v/resp-benchmark?color=%231772b4)](https://pypi.org/project/resp-benchmark/)
-[![PyPI - Downloads](https://img.shields.io/pypi/dw/resp-benchmark?color=%231ba784)](https://pypi.org/project/resp-benchmark/)
-[![License](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/tair-opensource/resp-benchmark/blob/main/LICENSE)
-
-resp-benchmark is a benchmark tool for testing databases that support the RESP protocol, 
-such as [Redis](https://github.com/redis/redis), [Valkey](https://github.com/valkey-io/valkey), 
-and [Tair](https://www.alibabacloud.com/en/product/tair). It offers both a command-line interface and a Python library.
-
-## Installation
-
-Requires Python 3.8 or higher.
-```bash
-pip install resp-benchmark
-```
-
-## Usage
-
-### Command-Line Tool
-
-```bash
-resp-benchmark --help
-```
-
-### Python Library
-
-```python
-from resp_benchmark import Benchmark
-
-bm = Benchmark(host="127.0.0.1", port=6379)
-bm.flushall()
-bm.load_data(command="SET {key sequence 10000000} {value 64}", count=1000000, connections=128)
-result = bm.bench("GET {key uniform 10000000}", seconds=3, connections=16)
-print(result.qps, result.avg_latency_ms, result.p99_latency_ms)
-```
-
-## Custom Commands
-
-resp-benchmark supports custom test commands using placeholder syntax like `SET {key uniform 10000000} {value 64}` which means the SET command will have a key uniformly distributed in the range
-0-10000000 and a value of 64 bytes.
-
-Supported placeholders include:
-
-- **`{key uniform N}`**: Generates a random number between `0` and `N-1`. For example, `{key uniform 100}` might generate `key_0000000099`.
-- **`{key sequence N}`**: Sequentially generates from `0` to `N-1`, ensuring coverage during data loading. For example, `{key sequence 100}` generates `key_0000000000`, `key_0000000001`, etc.
-- **`{key zipfian N}`**: Generates according to a Zipfian distribution (exponent 1.03), simulating real-world key distribution.
-- **`{value N}`**: Generates a random string of length `N` bytes. For example, `{value 8}` might generate `92xsqdNg`.
-- **`{rand N}`**: Generates a random number between `0` and `N-1`. For example, `{rand 100}` might generate `99`.
-- **`{range N W}`**: Generates a pair of random numbers within the range `0` to `N-1`, with a difference of `W`, used for testing `*range*` commands. For example, `{range 100 10}` might generate
-  `89 99`.
-
-## Best Practices
-
-### Benchmarking zset
-
-```shell
-# Load data
-resp-benchmark --load -P 10 -c 256 -n 10007000 "ZADD {key sequence 1000} {rand 70000} {key sequence 10007}"
-# Benchmark ZSCORE
-resp-benchmark -s 10 "ZSCORE {key uniform 1000} {key uniform 10007}"
-# Benchmark ZRANGEBYSCORE
-resp-benchmark -s 10 "ZRANGEBYSCORE {key uniform 1000} {range 70000 10}"
-```
-
-### Benchmarking Lua Scripts
-
-```shell
-redis-cli 'SCRIPT LOAD "return redis.call('\''SET'\'', KEYS[1], ARGV[1])"'
-resp-benchmark -s 10 "EVALSHA d8f2fad9f8e86a53d2a6ebd960b33c4972cacc37 1 {key uniform 100000} {value 64}"
-```
-
-## Differences with redis-benchmark
-
-When testing Redis with resp-benchmark and redis-benchmark, you might get different results due to:
-
-1. redis-benchmark always uses the same value when testing the set command, which does not trigger DB persistence and replication. In contrast, resp-benchmark uses `{value 64}` to generate different data for each command.
-2. redis-benchmark always uses the same primary key when testing list/set/zset/hash commands, while resp-benchmark generates different keys using placeholders like `{key uniform 10000000}`.
-3. In cluster mode, redis-benchmark sends requests to each node, but all requests target the same slot on every node.
-

resp_benchmark-0.1.7.dist-info/RECORD

@@ -1,11 +0,0 @@
-resp_benchmark-0.1.7.dist-info/METADATA,sha256=A5D_wJsa1YrDNZU2RduWECrTNcat_hjnWgbtcnxkBhQ,4321
-resp_benchmark-0.1.7.dist-info/WHEEL,sha256=jrioNBLbBfUtdW-iVpMDzknADPj2ElwsdpVfykES-TU,105
-resp_benchmark-0.1.7.dist-info/entry_points.txt,sha256=q1llaLwyhHn2jvpR28wBbila30DyZ1B5_4ackdlZ2R4,57
-resp_benchmark-0.1.7.dist-info/license_files/LICENSE,sha256=Kj-yFXYfT2SMHVx80nmX0ta2SPNqCQAq1_fwhkPqJrw,1072
-resp_benchmark.libs/libgcc_s-1e52349c.so.1,sha256=Ani0u_W_tB8ESsFePO4D2mn2lrgWLhyFdw6RETxBTYM,437537
-resp_benchmark/cli.py,sha256=Jj8DrtXVd85oo_nySbpXnYDgpEbIIjM-qUWco0v8Pjk,2498
-resp_benchmark/cores.py,sha256=bSEaHXJYo6spGIK_j-beTz8qbun3D7bgYrYxjUaMuDw,619
-resp_benchmark/__init__.py,sha256=-7qaTnVRokIpURaFVsO6ZP-l7oeHLbsNsGwBLvZrU14,39
-resp_benchmark/wrapper.py,sha256=cAXXX4L9vROEMD4RXjzj_rh6xWFvnRMDGbwLMpWSheM,4753
-resp_benchmark/_resp_benchmark_rust_lib.cpython-39-x86_64-linux-gnu.so,sha256=kEQZ6z1AfUetWg3EfgpGHVmQ7qw5spcJsWjoBbEXYsI,2882833
-resp_benchmark-0.1.7.dist-info/RECORD,,