feat: add Python Spark command client

This commit is contained in:
arham committed 2026-09-30 06:59:05 +00:00
1 parent bf404bc691
commit ab7a5c6bfb
10 files changed
+793

No files matched your search

@@ -0,0 +1,3 @@
build/
dist/
src/*.egg-info/
+36
View File
@@ -0,0 +1,36 @@
# Spark command client
An independently packaged async Python client for the standalone Spark command
bridge. It contains generated public bridge messages and does not import
Quickbus, `libspark`, Spark internal protobufs, BlueOrb, or the public WebSocket
server.
```python
from spark_command_client import SparkCommandClient
async with SparkCommandClient("127.0.0.1:50051") as client:
result = await client.enter_order(
client_order_id="strategy-a-1",
account="ACC-A",
security_id="123",
side="buy",
order_type="limit",
quantity="2",
price="100.25",
)
```
The target is a gRPC authority such as `127.0.0.1:50051`, without an HTTP URL
scheme.
## Release
Set the release version in `pyproject.toml`, then build the wheel, source
distribution, and checksums:
```sh
PYTHON=python3.10 ./build-release.sh 0.1.0
```
The complete release and independent deployment process is documented in
[`../RELEASE_AND_DEPLOYMENT.md`](../RELEASE_AND_DEPLOYMENT.md).
+36
View File
@@ -0,0 +1,36 @@
#!/usr/bin/env sh
set -eu
if [ "$#" -ne 1 ]; then
echo "usage: $0 <version-from-pyproject>" >&2
exit 2
fi
requested_version=$1
component_dir=$(CDPATH= cd -- "$(dirname -- "$0")" && pwd)
python_bin=${PYTHON:-python3}
declared_version=$(sed -n 's/^version = "\([^"]*\)"/\1/p' "$component_dir/pyproject.toml")
if [ "$requested_version" != "$declared_version" ]; then
echo "requested version $requested_version does not match pyproject.toml version $declared_version" >&2
exit 1
fi
dist_dir="$component_dir/dist"
wheel_name="spark_command_client-$declared_version-py3-none-any.whl"
sdist_name="spark_command_client-$declared_version.tar.gz"
if [ -e "$dist_dir/$wheel_name" ] || [ -e "$dist_dir/$sdist_name" ]; then
echo "release output already exists for $declared_version; remove it or bump the package version" >&2
exit 1
fi
mkdir -p "$dist_dir"
"$python_bin" -m build --wheel --sdist --outdir "$dist_dir" "$component_dir"
(
cd "$dist_dir"
sha256sum "$wheel_name" "$sdist_name" > "spark-command-client-$declared_version.sha256"
)
echo "created $dist_dir/$wheel_name"
echo "created $dist_dir/$sdist_name"
@@ -0,0 +1,19 @@
[build-system]
requires = ["setuptools>=68"]
build-backend = "setuptools.build_meta"
[project]
name = "spark-command-client"
version = "0.1.2"
description = "Async Python client for the standalone Spark command bridge"
requires-python = ">=3.10"
dependencies = [
"grpcio>=1.84,<2",
"protobuf>=6.31,<8",
]
[project.optional-dependencies]
test = ["grpcio-tools>=1.84,<2", "pytest>=8,<10", "pytest-asyncio>=0.24,<1"]
[tool.setuptools.packages.find]
where = ["src"]
@@ -0,0 +1,13 @@
from .client import (
BridgeError,
CommandUnavailable,
SparkCommandClient,
create_sdk,
)
__all__ = [
"BridgeError",
"CommandUnavailable",
"SparkCommandClient",
"create_sdk",
]
@@ -0,0 +1,237 @@
"""Async facade over the generated Spark command bridge client."""
from __future__ import annotations
import os
from collections.abc import Mapping
from typing import Any
import grpc
from .generated import spark_command_pb2 as messages
from .generated import spark_command_pb2_grpc as services
class BridgeError(RuntimeError):
def __init__(self, code: str, message: str):
super().__init__(message)
self.code = code
self.message = message
class CommandUnavailable(BridgeError):
pass
_SIDES = {"buy": messages.SIDE_BUY, "sell": messages.SIDE_SELL}
_ORDER_TYPES = {
"market": messages.ORDER_TYPE_MARKET,
"limit": messages.ORDER_TYPE_LIMIT,
}
_PRICE_CALCULATIONS = {
"standard": messages.PRICE_CALCULATION_STANDARD,
"net_change": messages.PRICE_CALCULATION_NET_CHANGE,
"notional_leg": messages.PRICE_CALCULATION_NOTIONAL_LEG,
}
_HEDGE_PRICING = {
"cached_drivers": messages.HEDGE_PRICING_CACHED_DRIVERS,
"recalculate_crosses": messages.HEDGE_PRICING_RECALCULATE_CROSSES,
}
_SPREADER_TYPES = {
"requote": messages.SPREADER_TYPE_REQUOTE,
"reverse_hedge": messages.SPREADER_TYPE_REVERSE_HEDGE,
"sniper": messages.SPREADER_TYPE_SNIPER,
}
_MARKET_DATA_TYPES = {
"merged": messages.MARKET_DATA_TYPE_MERGED,
"direct": messages.MARKET_DATA_TYPE_DIRECT,
}
class SparkCommandClient:
def __init__(
self,
address: str,
*,
timeout: float = 10.0,
channel: grpc.aio.Channel | None = None,
) -> None:
self._address = address
self._timeout = timeout
self._owns_channel = channel is None
self._channel = channel
self._stub: services.SparkCommandServiceStub | None = None
async def __aenter__(self) -> SparkCommandClient:
return self
async def __aexit__(self, *_: object) -> None:
await self.close()
async def close(self) -> None:
if self._owns_channel and self._channel is not None:
await self._channel.close()
async def health(self) -> dict[str, Any]:
response = await self._call(self._service().Health, messages.HealthRequest())
return {"ready": response.ready, "message": response.message}
async def enter_order(self, request: Any = None, **values: Any) -> dict[str, Any]:
data = _request_values(request, values)
message = messages.EnterOrderRequest(
client_order_id=str(data["client_order_id"]),
account=str(data["account"]),
side=_SIDES[str(data["side"])],
order_type=_ORDER_TYPES[str(data["order_type"])],
quantity=str(data["quantity"]),
)
if data.get("security_id") is not None:
message.security_id = str(data["security_id"])
if data.get("exchange") is not None:
message.exchange = str(data["exchange"])
if data.get("exchange_security_name") is not None:
message.exchange_security_name = str(data["exchange_security_name"])
if data.get("price") is not None:
message.price = str(data["price"])
return _order_result(await self._call(self._service().EnterOrder, message))
async def update_order(self, request: Any = None, **values: Any) -> dict[str, Any]:
data = _request_values(request, values)
message = messages.UpdateOrderRequest(order_id=str(data["order_id"]))
if data.get("quantity") is not None:
message.quantity = str(data["quantity"])
if data.get("price") is not None:
message.price = str(data["price"])
return _order_result(await self._call(self._service().UpdateOrder, message))
async def delete_order(self, request: Any = None, **values: Any) -> dict[str, Any]:
data = _request_values(request, values)
message = messages.DeleteOrderRequest(order_id=str(data["order_id"]))
return _order_result(await self._call(self._service().DeleteOrder, message))
async def create_synthetic_spread(
self, request: Any = None, **values: Any
) -> dict[str, Any]:
data = _request_values(request, values)
message = messages.CreateSyntheticSpreadRequest(
leg1=_leg(data, "leg1", default_side="buy", default_multiplier="1"),
leg2=_leg(data, "leg2", default_side="sell", default_multiplier="-1"),
)
_set_optional(message, data, "name", str)
_set_optional(message, data, "symbol", str)
_set_optional(message, data, "currency", str)
_set_optional(message, data, "tick_size", str)
_set_optional(message, data, "cash_per_point", str)
_set_optional(message, data, "price_multiplier", str)
_set_optional(message, data, "main_fraction", int)
_set_optional(message, data, "sub_fraction", int)
_set_optional(message, data, "price_display_format", int)
_set_enum(message, data, "price_calc", "price_calculation", _PRICE_CALCULATIONS)
_set_optional(message, data, "cancel_hedges_on_cancel", bool)
_set_enum(message, data, "hedge_pricing", "hedge_pricing", _HEDGE_PRICING)
_set_enum(message, data, "spreader_type", "spreader_type", _SPREADER_TYPES)
_set_optional(message, data, "lean_quantity_ratio", str)
response = await self._call(self._service().CreateSyntheticSpread, message)
return {"security_id": response.security_id}
def _service(self) -> services.SparkCommandServiceStub:
if self._channel is None:
self._channel = grpc.aio.insecure_channel(self._address)
if self._stub is None:
self._stub = services.SparkCommandServiceStub(self._channel)
return self._stub
async def _call(self, method: Any, request: Any) -> Any:
try:
return await method(request, timeout=self._timeout)
except grpc.aio.AioRpcError as exc:
code = exc.code()
message = exc.details() or code.name
if code == grpc.StatusCode.DEADLINE_EXCEEDED:
raise BridgeError("outcome_unknown", message) from exc
if code == grpc.StatusCode.UNAVAILABLE:
raise CommandUnavailable("backend_unavailable", message) from exc
if code == grpc.StatusCode.INVALID_ARGUMENT:
raise BridgeError("invalid_params", message) from exc
if code == grpc.StatusCode.NOT_FOUND:
raise BridgeError("not_found", message) from exc
raise BridgeError("bridge_error", message) from exc
def create_sdk() -> SparkCommandClient:
return SparkCommandClient(
os.environ.get("SPARK_COMMAND_ADDRESS", "127.0.0.1:50051"),
timeout=float(os.environ.get("SPARK_COMMAND_TIMEOUT", "10")),
)
def _request_values(request: Any, explicit: Mapping[str, Any]) -> dict[str, Any]:
if request is None:
return dict(explicit)
if explicit:
raise TypeError("pass either a request object or keyword values")
if hasattr(request, "model_dump"):
return request.model_dump(mode="python")
if isinstance(request, Mapping):
return dict(request)
return dict(vars(request))
def _leg(
data: Mapping[str, Any], prefix: str, *, default_side: str, default_multiplier: str
) -> messages.SyntheticLeg:
message = messages.SyntheticLeg(
price_multiplier=str(data.get(f"{prefix}_price_multiplier") or default_multiplier),
side=_SIDES[str(data.get(f"{prefix}_side") or default_side)],
)
security_id = data.get(f"{prefix}_security_id")
if security_id is not None:
message.security_id = str(security_id)
exchange = data.get(f"{prefix}_exchange")
if exchange is not None:
message.exchange = str(exchange)
exchange_security_name = data.get(f"{prefix}_exchange_security_name")
if exchange_security_name is not None:
message.exchange_security_name = str(exchange_security_name)
for suffix, converter in (
("quantity", str),
("leg_delta", str),
("is_active_quoting", bool),
("enable_hedging", bool),
):
key = f"{prefix}_{suffix}"
if data.get(key) is not None:
setattr(message, suffix, converter(data[key]))
market_data_type = data.get(f"{prefix}_market_data_type")
if market_data_type is not None:
message.market_data_type = _MARKET_DATA_TYPES[str(market_data_type)]
return message
def _set_optional(message: Any, data: Mapping[str, Any], key: str, converter: Any) -> None:
if data.get(key) is not None:
setattr(message, key, converter(data[key]))
def _set_enum(
message: Any,
data: Mapping[str, Any],
source_key: str,
target_key: str,
values: Mapping[str, int],
) -> None:
if data.get(source_key) is not None:
setattr(message, target_key, values[str(data[source_key])])
def _order_result(response: Any) -> dict[str, Any]:
statuses = {
messages.COMMAND_STATUS_ACCEPTED: "accepted",
messages.COMMAND_STATUS_REJECTED: "rejected",
messages.COMMAND_STATUS_UNKNOWN: "pending",
}
return {
"order_id": response.order_id,
"status": statuses.get(response.status, "pending"),
"message": response.message or None,
}
@@ -0,0 +1 @@
"""Generated gRPC modules for spark.command.v1."""
@@ -0,0 +1,69 @@
# -*- coding: utf-8 -*-
# Generated by the protocol buffer compiler. DO NOT EDIT!
# NO CHECKED-IN PROTOBUF GENCODE
# source: spark_command.proto
# Protobuf Python Version: 7.35.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 runtime_version as _runtime_version
from google.protobuf import symbol_database as _symbol_database
from google.protobuf.internal import builder as _builder
_runtime_version.ValidateProtobufRuntimeVersion(
_runtime_version.Domain.PUBLIC,
7,
35,
1,
'',
'spark_command.proto'
)
# @@protoc_insertion_point(imports)
_sym_db = _symbol_database.Default()
DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x13spark_command.proto\x12\x10spark.command.v1\"\xbd\x02\n\x11\x45nterOrderRequest\x12\x17\n\x0f\x63lient_order_id\x18\x01 \x01(\t\x12\x0f\n\x07\x61\x63\x63ount\x18\x02 \x01(\t\x12\x13\n\x0bsecurity_id\x18\x03 \x01(\t\x12$\n\x04side\x18\x04 \x01(\x0e\x32\x16.spark.command.v1.Side\x12/\n\norder_type\x18\x05 \x01(\x0e\x32\x1b.spark.command.v1.OrderType\x12\x10\n\x08quantity\x18\x06 \x01(\t\x12\x12\n\x05price\x18\x07 \x01(\tH\x00\x88\x01\x01\x12\x15\n\x08\x65xchange\x18\x08 \x01(\tH\x01\x88\x01\x01\x12#\n\x16\x65xchange_security_name\x18\t \x01(\tH\x02\x88\x01\x01\x42\x08\n\x06_priceB\x0b\n\t_exchangeB\x19\n\x17_exchange_security_name\"h\n\x12UpdateOrderRequest\x12\x10\n\x08order_id\x18\x01 \x01(\t\x12\x15\n\x08quantity\x18\x02 \x01(\tH\x00\x88\x01\x01\x12\x12\n\x05price\x18\x03 \x01(\tH\x01\x88\x01\x01\x42\x0b\n\t_quantityB\x08\n\x06_price\"&\n\x12\x44\x65leteOrderRequest\x12\x10\n\x08order_id\x18\x01 \x01(\t\"v\n\x0bOrderResult\x12\x10\n\x08order_id\x18\x01 \x01(\t\x12/\n\x06status\x18\x02 \x01(\x0e\x32\x1f.spark.command.v1.CommandStatus\x12\x0f\n\x07message\x18\x03 \x01(\t\x12\x13\n\x0bspark_error\x18\x04 \x01(\t\"\xf5\x03\n\x0cSyntheticLeg\x12\x13\n\x0bsecurity_id\x18\x01 \x01(\t\x12\x15\n\x08quantity\x18\x02 \x01(\tH\x00\x88\x01\x01\x12\x1d\n\x10price_multiplier\x18\x03 \x01(\tH\x01\x88\x01\x01\x12\x16\n\tleg_delta\x18\x04 \x01(\tH\x02\x88\x01\x01\x12)\n\x04side\x18\x05 \x01(\x0e\x32\x16.spark.command.v1.SideH\x03\x88\x01\x01\x12\x1e\n\x11is_active_quoting\x18\x06 \x01(\x08H\x04\x88\x01\x01\x12\x1b\n\x0e\x65nable_hedging\x18\x07 \x01(\x08H\x05\x88\x01\x01\x12?\n\x10market_data_type\x18\x08 \x01(\x0e\x32 .spark.command.v1.MarketDataTypeH\x06\x88\x01\x01\x12\x15\n\x08\x65xchange\x18\t \x01(\tH\x07\x88\x01\x01\x12#\n\x16\x65xchange_security_name\x18\n \x01(\tH\x08\x88\x01\x01\x42\x0b\n\t_quantityB\x13\n\x11_price_multiplierB\x0c\n\n_leg_deltaB\x07\n\x05_sideB\x14\n\x12_is_active_quotingB\x11\n\x0f_enable_hedgingB\x13\n\x11_market_data_typeB\x0b\n\t_exchangeB\x19\n\x17_exchange_security_name\"\xec\x06\n\x1c\x43reateSyntheticSpreadRequest\x12,\n\x04leg1\x18\x01 \x01(\x0b\x32\x1e.spark.command.v1.SyntheticLeg\x12,\n\x04leg2\x18\x02 \x01(\x0b\x32\x1e.spark.command.v1.SyntheticLeg\x12\x11\n\x04name\x18\x03 \x01(\tH\x00\x88\x01\x01\x12\x13\n\x06symbol\x18\x04 \x01(\tH\x01\x88\x01\x01\x12\x15\n\x08\x63urrency\x18\x05 \x01(\tH\x02\x88\x01\x01\x12\x16\n\ttick_size\x18\x06 \x01(\tH\x03\x88\x01\x01\x12\x1b\n\x0e\x63\x61sh_per_point\x18\x07 \x01(\tH\x04\x88\x01\x01\x12\x1d\n\x10price_multiplier\x18\x08 \x01(\tH\x05\x88\x01\x01\x12\x1a\n\rmain_fraction\x18\t \x01(\rH\x06\x88\x01\x01\x12\x19\n\x0csub_fraction\x18\n \x01(\rH\x07\x88\x01\x01\x12!\n\x14price_display_format\x18\x0b \x01(\rH\x08\x88\x01\x01\x12\x42\n\x11price_calculation\x18\x0c \x01(\x0e\x32\".spark.command.v1.PriceCalculationH\t\x88\x01\x01\x12$\n\x17\x63\x61ncel_hedges_on_cancel\x18\r \x01(\x08H\n\x88\x01\x01\x12:\n\rhedge_pricing\x18\x0e \x01(\x0e\x32\x1e.spark.command.v1.HedgePricingH\x0b\x88\x01\x01\x12:\n\rspreader_type\x18\x0f \x01(\x0e\x32\x1e.spark.command.v1.SpreaderTypeH\x0c\x88\x01\x01\x12 \n\x13lean_quantity_ratio\x18\x10 \x01(\tH\r\x88\x01\x01\x42\x07\n\x05_nameB\t\n\x07_symbolB\x0b\n\t_currencyB\x0c\n\n_tick_sizeB\x11\n\x0f_cash_per_pointB\x13\n\x11_price_multiplierB\x10\n\x0e_main_fractionB\x0f\n\r_sub_fractionB\x17\n\x15_price_display_formatB\x14\n\x12_price_calculationB\x1a\n\x18_cancel_hedges_on_cancelB\x10\n\x0e_hedge_pricingB\x10\n\x0e_spreader_typeB\x16\n\x14_lean_quantity_ratio\"2\n\x1b\x43reateSyntheticSpreadResult\x12\x13\n\x0bsecurity_id\x18\x01 \x01(\t\"\x0f\n\rHealthRequest\".\n\x0cHealthResult\x12\r\n\x05ready\x18\x01 \x01(\x08\x12\x0f\n\x07message\x18\x02 \x01(\t*9\n\x04Side\x12\x14\n\x10SIDE_UNSPECIFIED\x10\x00\x12\x0c\n\x08SIDE_BUY\x10\x01\x12\r\n\tSIDE_SELL\x10\x02*T\n\tOrderType\x12\x1a\n\x16ORDER_TYPE_UNSPECIFIED\x10\x00\x12\x15\n\x11ORDER_TYPE_MARKET\x10\x01\x12\x14\n\x10ORDER_TYPE_LIMIT\x10\x02*\x85\x01\n\rCommandStatus\x12\x1e\n\x1a\x43OMMAND_STATUS_UNSPECIFIED\x10\x00\x12\x1b\n\x17\x43OMMAND_STATUS_ACCEPTED\x10\x01\x12\x1b\n\x17\x43OMMAND_STATUS_REJECTED\x10\x02\x12\x1a\n\x16\x43OMMAND_STATUS_UNKNOWN\x10\x03*x\n\x10PriceCalculation\x12\x1e\n\x1aPRICE_CALCULATION_STANDARD\x10\x00\x12 \n\x1cPRICE_CALCULATION_NET_CHANGE\x10\x01\x12\"\n\x1ePRICE_CALCULATION_NOTIONAL_LEG\x10\x02*W\n\x0cHedgePricing\x12 \n\x1cHEDGE_PRICING_CACHED_DRIVERS\x10\x00\x12%\n!HEDGE_PRICING_RECALCULATE_CROSSES\x10\x01*d\n\x0cSpreaderType\x12\x19\n\x15SPREADER_TYPE_REQUOTE\x10\x00\x12\x1f\n\x1bSPREADER_TYPE_REVERSE_HEDGE\x10\x01\x12\x18\n\x14SPREADER_TYPE_SNIPER\x10\x02*J\n\x0eMarketDataType\x12\x1b\n\x17MARKET_DATA_TYPE_MERGED\x10\x00\x12\x1b\n\x17MARKET_DATA_TYPE_DIRECT\x10\x01\x32\xd2\x03\n\x13SparkCommandService\x12P\n\nEnterOrder\x12#.spark.command.v1.EnterOrderRequest\x1a\x1d.spark.command.v1.OrderResult\x12R\n\x0bUpdateOrder\x12$.spark.command.v1.UpdateOrderRequest\x1a\x1d.spark.comLine truncated
_globals = globals()
_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'spark_command_pb2', _globals)
if not _descriptor._USE_C_DESCRIPTORS:
_globals['DESCRIPTOR']._loaded_options = None
_globals['DESCRIPTOR']._serialized_options = b'\252\002\020Spark.Command.V1'
_globals['_SIDE']._serialized_start=2127
_globals['_SIDE']._serialized_end=2184
_globals['_ORDERTYPE']._serialized_start=2186
_globals['_ORDERTYPE']._serialized_end=2270
_globals['_COMMANDSTATUS']._serialized_start=2273
_globals['_COMMANDSTATUS']._serialized_end=2406
_globals['_PRICECALCULATION']._serialized_start=2408
_globals['_PRICECALCULATION']._serialized_end=2528
_globals['_HEDGEPRICING']._serialized_start=2530
_globals['_HEDGEPRICING']._serialized_end=2617
_globals['_SPREADERTYPE']._serialized_start=2619
_globals['_SPREADERTYPE']._serialized_end=2719
_globals['_MARKETDATATYPE']._serialized_start=2721
_globals['_MARKETDATATYPE']._serialized_end=2795
_globals['_ENTERORDERREQUEST']._serialized_start=42
_globals['_ENTERORDERREQUEST']._serialized_end=359
_globals['_UPDATEORDERREQUEST']._serialized_start=361
_globals['_UPDATEORDERREQUEST']._serialized_end=465
_globals['_DELETEORDERREQUEST']._serialized_start=467
_globals['_DELETEORDERREQUEST']._serialized_end=505
_globals['_ORDERRESULT']._serialized_start=507
_globals['_ORDERRESULT']._serialized_end=625
_globals['_SYNTHETICLEG']._serialized_start=628
_globals['_SYNTHETICLEG']._serialized_end=1129
_globals['_CREATESYNTHETICSPREADREQUEST']._serialized_start=1132
_globals['_CREATESYNTHETICSPREADREQUEST']._serialized_end=2008
_globals['_CREATESYNTHETICSPREADRESULT']._serialized_start=2010
_globals['_CREATESYNTHETICSPREADRESULT']._serialized_end=2060
_globals['_HEALTHREQUEST']._serialized_start=2062
_globals['_HEALTHREQUEST']._serialized_end=2077
_globals['_HEALTHRESULT']._serialized_start=2079
_globals['_HEALTHRESULT']._serialized_end=2125
_globals['_SPARKCOMMANDSERVICE']._serialized_start=2798
_globals['_SPARKCOMMANDSERVICE']._serialized_end=3264
# @@protoc_insertion_point(module_scope)
@@ -0,0 +1,269 @@
# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
"""Client and server classes corresponding to protobuf-defined services."""
import grpc
import warnings
from . import spark_command_pb2 as spark__command__pb2
GRPC_GENERATED_VERSION = '1.84.0'
GRPC_VERSION = grpc.__version__
_version_not_supported = False
try:
from grpc._utilities import first_version_is_lower
_version_not_supported = first_version_is_lower(GRPC_VERSION, GRPC_GENERATED_VERSION)
except ImportError:
_version_not_supported = True
if _version_not_supported:
raise RuntimeError(
f'The grpc package installed is at version {GRPC_VERSION},'
+ ' but the generated code in spark_command_pb2_grpc.py depends on'
+ f' grpcio>={GRPC_GENERATED_VERSION}.'
+ f' Please upgrade your grpc module to grpcio>={GRPC_GENERATED_VERSION}'
+ f' or downgrade your generated code using grpcio-tools<={GRPC_VERSION}.'
)
class SparkCommandServiceStub:
"""Missing associated documentation comment in .proto file."""
def __init__(self, channel):
"""Constructor.
Args:
channel: A grpc.Channel.
"""
self.EnterOrder = channel.unary_unary(
'/spark.command.v1.SparkCommandService/EnterOrder',
request_serializer=spark__command__pb2.EnterOrderRequest.SerializeToString,
response_deserializer=spark__command__pb2.OrderResult.FromString,
_registered_method=True)
self.UpdateOrder = channel.unary_unary(
'/spark.command.v1.SparkCommandService/UpdateOrder',
request_serializer=spark__command__pb2.UpdateOrderRequest.SerializeToString,
response_deserializer=spark__command__pb2.OrderResult.FromString,
_registered_method=True)
self.DeleteOrder = channel.unary_unary(
'/spark.command.v1.SparkCommandService/DeleteOrder',
request_serializer=spark__command__pb2.DeleteOrderRequest.SerializeToString,
response_deserializer=spark__command__pb2.OrderResult.FromString,
_registered_method=True)
self.CreateSyntheticSpread = channel.unary_unary(
'/spark.command.v1.SparkCommandService/CreateSyntheticSpread',
request_serializer=spark__command__pb2.CreateSyntheticSpreadRequest.SerializeToString,
response_deserializer=spark__command__pb2.CreateSyntheticSpreadResult.FromString,
_registered_method=True)
self.Health = channel.unary_unary(
'/spark.command.v1.SparkCommandService/Health',
request_serializer=spark__command__pb2.HealthRequest.SerializeToString,
response_deserializer=spark__command__pb2.HealthResult.FromString,
_registered_method=True)
class SparkCommandServiceServicer:
"""Missing associated documentation comment in .proto file."""
def EnterOrder(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 UpdateOrder(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 DeleteOrder(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 CreateSyntheticSpread(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 Health(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_SparkCommandServiceServicer_to_server(servicer, server):
rpc_method_handlers = {
'EnterOrder': grpc.unary_unary_rpc_method_handler(
servicer.EnterOrder,
request_deserializer=spark__command__pb2.EnterOrderRequest.FromString,
response_serializer=spark__command__pb2.OrderResult.SerializeToString,
),
'UpdateOrder': grpc.unary_unary_rpc_method_handler(
servicer.UpdateOrder,
request_deserializer=spark__command__pb2.UpdateOrderRequest.FromString,
response_serializer=spark__command__pb2.OrderResult.SerializeToString,
),
'DeleteOrder': grpc.unary_unary_rpc_method_handler(
servicer.DeleteOrder,
request_deserializer=spark__command__pb2.DeleteOrderRequest.FromString,
response_serializer=spark__command__pb2.OrderResult.SerializeToString,
),
'CreateSyntheticSpread': grpc.unary_unary_rpc_method_handler(
servicer.CreateSyntheticSpread,
request_deserializer=spark__command__pb2.CreateSyntheticSpreadRequest.FromString,
response_serializer=spark__command__pb2.CreateSyntheticSpreadResult.SerializeToString,
),
'Health': grpc.unary_unary_rpc_method_handler(
servicer.Health,
request_deserializer=spark__command__pb2.HealthRequest.FromString,
response_serializer=spark__command__pb2.HealthResult.SerializeToString,
),
}
generic_handler = grpc.method_handlers_generic_handler(
'spark.command.v1.SparkCommandService', rpc_method_handlers)
server.add_generic_rpc_handlers((generic_handler,))
server.add_registered_method_handlers('spark.command.v1.SparkCommandService', rpc_method_handlers)
# This class is part of an EXPERIMENTAL API.
class SparkCommandService:
"""Missing associated documentation comment in .proto file."""
@staticmethod
def EnterOrder(request,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None):
return grpc.experimental.unary_unary(
request,
target,
'/spark.command.v1.SparkCommandService/EnterOrder',
spark__command__pb2.EnterOrderRequest.SerializeToString,
spark__command__pb2.OrderResult.FromString,
options,
channel_credentials,
insecure,
call_credentials,
compression,
wait_for_ready,
timeout,
metadata,
_registered_method=True)
@staticmethod
def UpdateOrder(request,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None):
return grpc.experimental.unary_unary(
request,
target,
'/spark.command.v1.SparkCommandService/UpdateOrder',
spark__command__pb2.UpdateOrderRequest.SerializeToString,
spark__command__pb2.OrderResult.FromString,
options,
channel_credentials,
insecure,
call_credentials,
compression,
wait_for_ready,
timeout,
metadata,
_registered_method=True)
@staticmethod
def DeleteOrder(request,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None):
return grpc.experimental.unary_unary(
request,
target,
'/spark.command.v1.SparkCommandService/DeleteOrder',
spark__command__pb2.DeleteOrderRequest.SerializeToString,
spark__command__pb2.OrderResult.FromString,
options,
channel_credentials,
insecure,
call_credentials,
compression,
wait_for_ready,
timeout,
metadata,
_registered_method=True)
@staticmethod
def CreateSyntheticSpread(request,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None):
return grpc.experimental.unary_unary(
request,
target,
'/spark.command.v1.SparkCommandService/CreateSyntheticSpread',
spark__command__pb2.CreateSyntheticSpreadRequest.SerializeToString,
spark__command__pb2.CreateSyntheticSpreadResult.FromString,
options,
channel_credentials,
insecure,
call_credentials,
compression,
wait_for_ready,
timeout,
metadata,
_registered_method=True)
@staticmethod
def Health(request,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None):
return grpc.experimental.unary_unary(
request,
target,
'/spark.command.v1.SparkCommandService/Health',
spark__command__pb2.HealthRequest.SerializeToString,
spark__command__pb2.HealthResult.FromString,
options,
channel_credentials,
insecure,
call_credentials,
compression,
wait_for_ready,
timeout,
metadata,
_registered_method=True)
@@ -0,0 +1,110 @@
import asyncio
from concurrent.futures import ThreadPoolExecutor
import grpc
from spark_command_client import SparkCommandClient
from spark_command_client.generated import spark_command_pb2 as messages
from spark_command_client.generated import spark_command_pb2_grpc as services
class FakeBridge(services.SparkCommandServiceServicer):
def __init__(self):
self.entered = []
self.spreads = []
def Health(self, request, context):
return messages.HealthResult(ready=True, message="ready")
def EnterOrder(self, request, context):
self.entered.append(request)
return messages.OrderResult(
order_id="101",
status=messages.COMMAND_STATUS_ACCEPTED,
)
def UpdateOrder(self, request, context):
return messages.OrderResult(
order_id=request.order_id,
status=messages.COMMAND_STATUS_ACCEPTED,
)
def DeleteOrder(self, request, context):
return messages.OrderResult(
order_id=request.order_id,
status=messages.COMMAND_STATUS_ACCEPTED,
)
def CreateSyntheticSpread(self, request, context):
self.spreads.append(request)
return messages.CreateSyntheticSpreadResult(security_id="303")
def test_async_client_maps_all_commands():
bridge = FakeBridge()
server = grpc.server(ThreadPoolExecutor(max_workers=2))
services.add_SparkCommandServiceServicer_to_server(bridge, server)
port = server.add_insecure_port("127.0.0.1:0")
server.start()
async def run():
async with SparkCommandClient(f"127.0.0.1:{port}") as client:
assert (await client.health())["ready"]
entered = await client.enter_order(
client_order_id="client-1",
account="ACC-A",
security_id="11",
side="buy",
order_type="limit",
quantity="2",
price="100.25",
)
assert entered == {"order_id": "101", "status": "accepted", "message": None}
assert bridge.entered[0].price == "100.25"
named_order = await client.enter_order(
client_order_id="client-2",
account="ACC-A",
exchange="okx",
exchange_security_name="SOL-USDC",
side="buy",
order_type="limit",
quantity="1",
price="1.00",
)
assert named_order["status"] == "accepted"
assert bridge.entered[1].security_id == ""
assert bridge.entered[1].exchange == "okx"
assert bridge.entered[1].exchange_security_name == "SOL-USDC"
updated = await client.update_order(order_id="101", quantity="3")
assert updated["order_id"] == "101"
deleted = await client.delete_order(order_id="101")
assert deleted["status"] == "accepted"
spread = await client.create_synthetic_spread(
leg1_security_id="11",
leg2_security_id="12",
tick_size="0.01",
leg2_price_multiplier="-1",
)
assert spread == {"security_id": "303"}
assert bridge.spreads[0].leg1.security_id == "11"
assert bridge.spreads[0].leg2.price_multiplier == "-1"
named_spread = await client.create_synthetic_spread(
leg1_exchange="okx",
leg1_exchange_security_name="SOL-USDC",
leg2_exchange="orca",
leg2_exchange_security_name="SOL-USDC-1",
)
assert named_spread == {"security_id": "303"}
assert bridge.spreads[1].leg1.exchange == "okx"
assert bridge.spreads[1].leg1.exchange_security_name == "SOL-USDC"
assert bridge.spreads[1].leg2.exchange == "orca"
assert bridge.spreads[1].leg2.exchange_security_name == "SOL-USDC-1"
try:
asyncio.run(run())
finally:
server.stop(grace=0).wait()