diff --git a/src/client/spark_command_client/.gitignore b/src/client/spark_command_client/.gitignore new file mode 100644 index 000000000..c50bcdc95 --- /dev/null +++ b/src/client/spark_command_client/.gitignore @@ -0,0 +1,3 @@ +build/ +dist/ +src/*.egg-info/ diff --git a/src/client/spark_command_client/README.md b/src/client/spark_command_client/README.md new file mode 100644 index 000000000..c0e2cc1aa --- /dev/null +++ b/src/client/spark_command_client/README.md @@ -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). diff --git a/src/client/spark_command_client/build-release.sh b/src/client/spark_command_client/build-release.sh new file mode 100755 index 000000000..b334ceb56 --- /dev/null +++ b/src/client/spark_command_client/build-release.sh @@ -0,0 +1,36 @@ +#!/usr/bin/env sh +set -eu + +if [ "$#" -ne 1 ]; then + echo "usage: $0 " >&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" diff --git a/src/client/spark_command_client/pyproject.toml b/src/client/spark_command_client/pyproject.toml new file mode 100644 index 000000000..f63bad49a --- /dev/null +++ b/src/client/spark_command_client/pyproject.toml @@ -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"] diff --git a/src/client/spark_command_client/src/spark_command_client/__init__.py b/src/client/spark_command_client/src/spark_command_client/__init__.py new file mode 100644 index 000000000..3490a38aa --- /dev/null +++ b/src/client/spark_command_client/src/spark_command_client/__init__.py @@ -0,0 +1,13 @@ +from .client import ( + BridgeError, + CommandUnavailable, + SparkCommandClient, + create_sdk, +) + +__all__ = [ + "BridgeError", + "CommandUnavailable", + "SparkCommandClient", + "create_sdk", +] diff --git a/src/client/spark_command_client/src/spark_command_client/client.py b/src/client/spark_command_client/src/spark_command_client/client.py new file mode 100644 index 000000000..e0a120b42 --- /dev/null +++ b/src/client/spark_command_client/src/spark_command_client/client.py @@ -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, + } diff --git a/src/client/spark_command_client/src/spark_command_client/generated/__init__.py b/src/client/spark_command_client/src/spark_command_client/generated/__init__.py new file mode 100644 index 000000000..bbe88d47b --- /dev/null +++ b/src/client/spark_command_client/src/spark_command_client/generated/__init__.py @@ -0,0 +1 @@ +"""Generated gRPC modules for spark.command.v1.""" diff --git a/src/client/spark_command_client/src/spark_command_client/generated/spark_command_pb2.py b/src/client/spark_command_client/src/spark_command_client/generated/spark_command_pb2.py new file mode 100644 index 000000000..ed416982a --- /dev/null +++ b/src/client/spark_command_client/src/spark_command_client/generated/spark_command_pb2.py @@ -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.command.v1.OrderResult\x12R\n\x0b\x44\x65leteOrder\x12$.spark.command.v1.DeleteOrderRequest\x1a\x1d.spark.command.v1.OrderResult\x12v\n\x15\x43reateSyntheticSpread\x12..spark.command.v1.CreateSyntheticSpreadRequest\x1a-.spark.command.v1.CreateSyntheticSpreadResult\x12I\n\x06Health\x12\x1f.spark.command.v1.HealthRequest\x1a\x1e.spark.command.v1.HealthResultB\x13\xaa\x02\x10Spark.Command.V1b\x06proto3') + +_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) diff --git a/src/client/spark_command_client/src/spark_command_client/generated/spark_command_pb2_grpc.py b/src/client/spark_command_client/src/spark_command_client/generated/spark_command_pb2_grpc.py new file mode 100644 index 000000000..ddbeee99c --- /dev/null +++ b/src/client/spark_command_client/src/spark_command_client/generated/spark_command_pb2_grpc.py @@ -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) diff --git a/src/client/spark_command_client/tests/test_client.py b/src/client/spark_command_client/tests/test_client.py new file mode 100644 index 000000000..cc6940e37 --- /dev/null +++ b/src/client/spark_command_client/tests/test_client.py @@ -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()