Bloomberg Enterprise Orders Python Library

The Bloomberg Enterprise Orders Python library provides convenient access to the Bloomberg Enterprise Orders APIs from Python.

Table of Contents

• Installation
• Usage
• Environments
• Async Client
• Exception Handling
• Oauth Token Override
• Advanced
  • Access Raw Response Data
  • Retries
  • Timeouts
  • Custom Client

Installation

pip install bloomberg-enterprise-orders

Usage

Instantiate and use the client with the following:

from bloomberg.enterprise.orders import Orders, InstrumentSymbol, QuantityTypeCode, SideTypeCode, OrderType_Limit, TimeInForceType_Day, PreAllocation, Parties

client = Orders(
    client_id="<clientId>",
    client_secret="<clientSecret>",
)

client.orders.compliance_order_what_if(
    idempotency_key="3fa85f64-5717-4562-b3fc-2c963f66afa6",
    instrument=InstrumentSymbol(
        symbol="AAPL US Equity",
    ),
    quantity=500,
    quantity_type=QuantityTypeCode.UNITS,
    side=SideTypeCode.BUY,
    order_type=OrderType_Limit(
        limit_price=281.82,
    ),
    time_in_force=TimeInForceType_Day(),
    pre_allocations=[
        PreAllocation(
            quantity=500,
            account_code="EQ1",
            custom_allocation_id="ALLOC-EQ-001",
        )
    ],
    parties=Parties(
        portfolio_manager_uuid=7829341,
        trader_uuid=5610284,
        trading_desk="EQTY-US",
    ),
    custom_order_id="WI-EQ-AAPL-001",
)

Environments

This SDK allows you to configure different environments for API requests.

from bloomberg.enterprise.orders import Orders
from bloomberg.enterprise.orders.environment import OrdersEnvironment

client = Orders(
    environment=OrdersEnvironment.PRODUCTION,
)

Async Client

The SDK also exports an async client so that you can make non-blocking calls to our API. Note that if you are constructing an Async httpx client class to pass into this client, use httpx.AsyncClient() instead of httpx.Client() (e.g. for the httpx_client parameter of this client).

import asyncio

from bloomberg.enterprise.orders import AsyncOrders, InstrumentSymbol, QuantityTypeCode, SideTypeCode, OrderType_Limit, TimeInForceType_Day, PreAllocation, Parties

client = AsyncOrders(
    client_id="<clientId>",
    client_secret="<clientSecret>",
)


async def main() -> None:
    await client.orders.compliance_order_what_if(
        idempotency_key="3fa85f64-5717-4562-b3fc-2c963f66afa6",
        instrument=InstrumentSymbol(
            symbol="AAPL US Equity",
        ),
        quantity=500,
        quantity_type=QuantityTypeCode.UNITS,
        side=SideTypeCode.BUY,
        order_type=OrderType_Limit(
            limit_price=281.82,
        ),
        time_in_force=TimeInForceType_Day(),
        pre_allocations=[
            PreAllocation(
                quantity=500,
                account_code="EQ1",
                custom_allocation_id="ALLOC-EQ-001",
            )
        ],
        parties=Parties(
            portfolio_manager_uuid=7829341,
            trader_uuid=5610284,
            trading_desk="EQTY-US",
        ),
        custom_order_id="WI-EQ-AAPL-001",
    )


asyncio.run(main())

Exception Handling

When the API returns a non-success status code (4xx or 5xx response), a subclass of the following error will be thrown.

from bloomberg.enterprise.orders.core.api_error import ApiError

try:
    client.orders.compliance_order_what_if(...)
except ApiError as e:
    print(e.status_code)
    print(e.body)

Oauth Token Override

This SDK supports two authentication methods: OAuth client credentials flow (automatic token management) or direct bearer token authentication. You can choose between these options when initializing the client:

from bloomberg.enterprise.orders import Orders

# Option 1: Direct bearer token (bypass OAuth flow)
client = Orders(
    ...,
    token="my-pre-generated-bearer-token",
)

# Option 2: OAuth client credentials flow (automatic token management)
client = Orders(
    ...,
    client_id="your-client-id",
    client_secret="your-client-secret",
)

Advanced

Access Raw Response Data

The SDK provides access to raw response data, including headers, through the .with_raw_response property. The .with_raw_response property returns a "raw" client that can be used to access the .headers and .data attributes.

from bloomberg.enterprise.orders import Orders

client = Orders(...)
response = client.orders.with_raw_response.compliance_order_what_if(...)
print(response.headers)  # access the response headers
print(response.status_code)  # access the response status code
print(response.data)  # access the underlying object

Retries

The SDK is instrumented with automatic retries with exponential backoff. A request will be retried as long as the request is deemed retryable and the number of retry attempts has not grown larger than the configured retry limit (default: 2).

Which status codes are retried depends on the retryStatusCodes generator configuration:

legacy (current default): retries on

• 408 (Timeout)
• 409 (Conflict)
• 429 (Too Many Requests)
• 5XX (All server errors, including 500)

recommended: retries on

• 408 (Timeout)
• 409 (Conflict)
• 429 (Too Many Requests)
• 502 (Bad Gateway)
• 503 (Service Unavailable)
• 504 (Gateway Timeout)

Use the max_retries request option to configure this behavior.

client.orders.compliance_order_what_if(..., request_options={
    "max_retries": 1
})

Timeouts

The SDK defaults to a 60 second timeout. You can configure this with a timeout option at the client or request level.

from bloomberg.enterprise.orders import Orders

client = Orders(..., timeout=20.0)

# Override timeout for a specific method
client.orders.compliance_order_what_if(..., request_options={
    "timeout": 1
})

Custom Client

You can override the httpx client to customize it for your use-case. Some common use-cases include support for proxies and transports.

import httpx
from bloomberg.enterprise.orders import Orders

client = Orders(
    ...,
    httpx_client=httpx.Client(
        proxy="http://my.test.proxy.example.com",
        transport=httpx.HTTPTransport(local_address="0.0.0.0"),
    ),
)