binance-sdk-alpha 1.0.0__tar.gz

binance_sdk_alpha-1.0.0/CHANGELOG.md

@@ -0,0 +1,5 @@
+# Changelog
+
+## 1.0.0 - 2026-01-23
+
+- Initial release

binance_sdk_alpha-1.0.0/LICENCE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Binance
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

binance_sdk_alpha-1.0.0/PKG-INFO

@@ -0,0 +1,27 @@
+Metadata-Version: 2.4
+Name: binance-sdk-alpha
+Version: 1.0.0
+Summary: Official Binance Alpha Connector - A lightweight library that provides a convenient interface to Binance's Alpha REST API
+License: MIT
+License-File: LICENCE
+Author: Binance
+Requires-Python: >=3.9,<3.15
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Provides-Extra: dev
+Requires-Dist: aiohttp (>=3.9,<4.0)
+Requires-Dist: binance-common (==3.4.1)
+Requires-Dist: black (>=25.1.0,<26.0.0)
+Requires-Dist: pycryptodome (>=3.17,<4.0)
+Requires-Dist: pydantic (>=2.10.0)
+Requires-Dist: pytest (>=6.2.5) ; extra == "dev"
+Requires-Dist: requests (>=2.31.0)
+Requires-Dist: ruff (>=0.12.0,<0.13.0)
+Requires-Dist: websocket-client (>=1.6.3)
+Requires-Dist: websockets (>=15.0.1,<16.0.0)

binance_sdk_alpha-1.0.0/pyproject.toml

@@ -0,0 +1,39 @@
+[tool.poetry]
+name = "binance-sdk-alpha"
+version = "1.0.0"
+description = "Official Binance Alpha Connector - A lightweight library that provides a convenient interface to Binance's Alpha REST API"
+authors = ["Binance"]
+license = "MIT"
+include = ["CHANGELOG.md", "LICENSE"]
+packages = [
+  { include = "binance_sdk_alpha", from = "src" }
+]
+
+[tool.poetry.dependencies]
+python = ">=3.9,<3.15"
+requests = ">=2.31.0"
+pydantic = ">=2.10.0"
+websockets = "^15.0.1"
+websocket-client = ">=1.6.3"
+black = "^25.1.0"
+ruff = "^0.12.0"
+pycryptodome = "^3.17"
+aiohttp = "^3.9"
+binance-common = "3.4.1"
+pytest = { version = ">=6.2.5", optional = true }
+
+[tool.poetry.extras]
+dev = ["pytest"]
+
+[tool.poetry.group.dev.dependencies]
+tox = "^4.27.0"
+pytest = ">=8.4.1"
+pytest-asyncio = "^1.0.0"
+
+[tool.ruff]
+exclude = [".git", ".tox", "build", "dist"]
+lint.ignore = ["E741"]
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"

binance_sdk_alpha-1.0.0/src/binance_sdk_alpha/__init__.py

@@ -0,0 +1,31 @@
+from binance_sdk_alpha.alpha import Alpha
+from binance_common.errors import (
+    ClientError,
+    RequiredError,
+    UnauthorizedError,
+    ForbiddenError,
+    TooManyRequestsError,
+    RateLimitBanError,
+    ServerError,
+    NetworkError,
+    NotFoundError,
+    BadRequestError,
+)
+from binance_common.constants import (
+    ALPHA_REST_API_PROD_URL,
+)
+
+__all__ = [
+    "Alpha",
+    "ALPHA_REST_API_PROD_URL",
+    "ClientError",
+    "RequiredError",
+    "UnauthorizedError",
+    "ForbiddenError",
+    "TooManyRequestsError",
+    "RateLimitBanError",
+    "ServerError",
+    "NetworkError",
+    "NotFoundError",
+    "BadRequestError",
+]

binance_sdk_alpha-1.0.0/src/binance_sdk_alpha/alpha.py

@@ -0,0 +1,34 @@
+import platform
+from importlib.metadata import version
+
+from binance_common.configuration import ConfigurationRestAPI
+from binance_common.constants import ALPHA_REST_API_PROD_URL
+from . import metadata
+from .rest_api import AlphaRestAPI
+
+LIB_NAME = metadata.NAME
+LIB_VERSION = version(LIB_NAME)
+
+
+class Alpha:
+    """Alpha API that exposes REST APIs in a single interface."""
+
+    def __init__(self, config_rest_api: ConfigurationRestAPI = None) -> None:
+        self._rest_api = None
+        self._rest_api_config = (
+            ConfigurationRestAPI() if config_rest_api is None else config_rest_api
+        )
+
+    @property
+    def rest_api(self) -> AlphaRestAPI:
+        if self._rest_api is None and self._rest_api_config:
+            self._rest_api_config.base_headers["User-Agent"] = (
+                f"{LIB_NAME}/{LIB_VERSION} (Python/{platform.python_version()}; {platform.system()}; {platform.machine()})"
+            )
+            self._rest_api_config.base_path = (
+                ALPHA_REST_API_PROD_URL
+                if self._rest_api_config.base_path is None
+                else self._rest_api_config.base_path
+            )
+            self._rest_api = AlphaRestAPI(self._rest_api_config)
+        return self._rest_api

binance_sdk_alpha-1.0.0/src/binance_sdk_alpha/metadata.py

@@ -0,0 +1 @@
+NAME = "binance-sdk-alpha"

binance_sdk_alpha-1.0.0/src/binance_sdk_alpha/rest_api/__init__.py

@@ -0,0 +1,13 @@
+"""
+Binance Alpha REST API
+
+OpenAPI Specification for the Binance Alpha REST API
+The version of the OpenAPI document: 1.0.0
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+from .rest_api import AlphaRestAPI
+
+__all__ = ["AlphaRestAPI"]

binance_sdk_alpha-1.0.0/src/binance_sdk_alpha/rest_api/api/__init__.py

@@ -0,0 +1,11 @@
+"""
+Binance Alpha REST API
+
+OpenAPI Specification for the Binance Alpha REST API
+The version of the OpenAPI document: 1.0.0
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+from .market_data_api import MarketDataApi as MarketDataApi

binance_sdk_alpha-1.0.0/src/binance_sdk_alpha/rest_api/api/market_data_api.py

@@ -0,0 +1,270 @@
+"""
+Binance Alpha REST API
+
+OpenAPI Specification for the Binance Alpha REST API
+The version of the OpenAPI document: 1.0.0
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+from typing import Optional, Union
+from requests import Session
+from binance_common.configuration import ConfigurationRestAPI
+from binance_common.errors import RequiredError
+from binance_common.models import ApiResponse
+from binance_common.signature import Signers
+from binance_common.utils import send_request
+
+from ..models import AggregatedTradesResponse
+from ..models import GetExchangeInfoResponse
+from ..models import KlinesResponse
+from ..models import TickerResponse
+from ..models import TokenListResponse
+
+
+class MarketDataApi:
+    """API Client for MarketDataApi endpoints."""
+
+    def __init__(
+        self,
+        configuration: ConfigurationRestAPI = None,
+        session: Session = None,
+        signer: Signers = None,
+    ) -> None:
+        self._configuration = configuration
+        self._session = session
+        self._signer = signer
+
+    def aggregated_trades(
+        self,
+        symbol: Union[str, None],
+        from_id: Optional[int] = None,
+        start_time: Optional[int] = None,
+        end_time: Optional[int] = None,
+        limit: Optional[int] = None,
+    ) -> ApiResponse[AggregatedTradesResponse]:
+        """
+                Aggregated Trades
+                GET /bapi/defi/v1/public/alpha-trade/agg-trades
+                https://developers.binance.com/docs/alpha/market-data/rest-api/Aggregated-Trades
+
+                Retrieves compressed, aggregated historical trades for a specific symbol. Useful for recent trade history.
+
+        Weight: 0
+
+                Args:
+                    symbol (Union[str, None]): e.g., "ALPHA_175USDT" – use token ID from Token List
+                    from_id (Optional[int] = None): starting trade ID to fetch from
+                    start_time (Optional[int] = None): start timestamp (milliseconds)
+                    end_time (Optional[int] = None): end timestamp (milliseconds)
+                    limit (Optional[int] = None): number of results to return (default 500, max 1000)
+
+                Returns:
+                    ApiResponse[AggregatedTradesResponse]
+
+                Raises:
+                    RequiredError: If a required parameter is missing.
+
+        """
+
+        if symbol is None:
+            raise RequiredError(
+                field="symbol", error_message="Missing required parameter 'symbol'"
+            )
+
+        body = {}
+        payload = {
+            "symbol": symbol,
+            "from_id": from_id,
+            "start_time": start_time,
+            "end_time": end_time,
+            "limit": limit,
+        }
+
+        return send_request(
+            self._session,
+            self._configuration,
+            method="GET",
+            path="/bapi/defi/v1/public/alpha-trade/agg-trades",
+            payload=payload,
+            body=body,
+            time_unit=self._configuration.time_unit,
+            response_model=AggregatedTradesResponse,
+        )
+
+    def get_exchange_info(
+        self,
+    ) -> ApiResponse[GetExchangeInfoResponse]:
+        """
+                Get Exchange Info
+                GET /bapi/defi/v1/public/alpha-trade/get-exchange-info
+                https://developers.binance.com/docs/alpha/market-data/rest-api/Get-Exchange-Info
+
+                Fetches general exchange information, such as supported symbols, rate limits, and server time.
+
+        Weight: 0
+
+                Args:
+
+                Returns:
+                    ApiResponse[GetExchangeInfoResponse]
+
+                Raises:
+                    RequiredError: If a required parameter is missing.
+
+        """
+
+        body = None
+        payload = None
+
+        return send_request(
+            self._session,
+            self._configuration,
+            method="GET",
+            path="/bapi/defi/v1/public/alpha-trade/get-exchange-info",
+            payload=payload,
+            body=body,
+            time_unit=self._configuration.time_unit,
+            response_model=GetExchangeInfoResponse,
+        )
+
+    def klines(
+        self,
+        symbol: Union[str, None],
+        interval: Union[str, None],
+        limit: Optional[int] = None,
+        start_time: Optional[int] = None,
+        end_time: Optional[int] = None,
+    ) -> ApiResponse[KlinesResponse]:
+        """
+                Klines (Candlestick Data)
+                GET /bapi/defi/v1/public/alpha-trade/klines
+                https://developers.binance.com/docs/alpha/market-data/rest-api/Klines
+
+                Fetches Kline/candlestick bars for a symbol, which include open/high/low/close prices and volume over intervals. Useful for charting and analysis.
+
+        Weight: 0
+
+                Args:
+                    symbol (Union[str, None]): e.g., "ALPHA_175USDT" – use token ID from Token List
+                    interval (Union[str, None]): e.g., "1h" – supported intervals: 1s, 15s, 1m, 3m, 5m, 15m, 30m, 1h, 2h, 4h, 6h, 8h, 12h, 1d, 3d, 1w, 1M
+                    limit (Optional[int] = None): number of results to return (default 500, max 1000)
+                    start_time (Optional[int] = None): start timestamp (milliseconds)
+                    end_time (Optional[int] = None): end timestamp (milliseconds)
+
+                Returns:
+                    ApiResponse[KlinesResponse]
+
+                Raises:
+                    RequiredError: If a required parameter is missing.
+
+        """
+
+        if symbol is None:
+            raise RequiredError(
+                field="symbol", error_message="Missing required parameter 'symbol'"
+            )
+        if interval is None:
+            raise RequiredError(
+                field="interval", error_message="Missing required parameter 'interval'"
+            )
+
+        body = {}
+        payload = {
+            "symbol": symbol,
+            "interval": interval,
+            "limit": limit,
+            "start_time": start_time,
+            "end_time": end_time,
+        }
+
+        return send_request(
+            self._session,
+            self._configuration,
+            method="GET",
+            path="/bapi/defi/v1/public/alpha-trade/klines",
+            payload=payload,
+            body=body,
+            time_unit=self._configuration.time_unit,
+            response_model=KlinesResponse,
+        )
+
+    def ticker(
+        self,
+        symbol: Union[str, None],
+    ) -> ApiResponse[TickerResponse]:
+        """
+                Ticker (24hr Price Statistics)
+                GET /bapi/defi/v1/public/alpha-trade/ticker
+                https://developers.binance.com/docs/alpha/market-data/rest-api/24hr-ticker-price-change
+
+                Gets the 24-hour rolling window price change statistics for a symbol, including volume and price changes.
+
+        Weight: 0
+
+                Args:
+                    symbol (Union[str, None]): e.g., "ALPHA_175USDT" – use token ID from Token List
+
+                Returns:
+                    ApiResponse[TickerResponse]
+
+                Raises:
+                    RequiredError: If a required parameter is missing.
+
+        """
+
+        if symbol is None:
+            raise RequiredError(
+                field="symbol", error_message="Missing required parameter 'symbol'"
+            )
+
+        body = {}
+        payload = {"symbol": symbol}
+
+        return send_request(
+            self._session,
+            self._configuration,
+            method="GET",
+            path="/bapi/defi/v1/public/alpha-trade/ticker",
+            payload=payload,
+            body=body,
+            time_unit=self._configuration.time_unit,
+            response_model=TickerResponse,
+        )
+
+    def token_list(
+        self,
+    ) -> ApiResponse[TokenListResponse]:
+        """
+                Token List
+                GET /bapi/defi/v1/public/wallet-direct/buw/wallet/cex/alpha/all/token/list
+                https://developers.binance.com/docs/alpha/market-data/rest-api/Token-List
+
+                Retrieves a list of all available ALPHA tokens, including their IDs and symbols. Use this to find the token ID for constructing symbols in other endpoints.
+
+        Weight: 0
+
+                Args:
+
+                Returns:
+                    ApiResponse[TokenListResponse]
+
+                Raises:
+                    RequiredError: If a required parameter is missing.
+
+        """
+
+        body = None
+        payload = None
+
+        return send_request(
+            self._session,
+            self._configuration,
+            method="GET",
+            path="/bapi/defi/v1/public/wallet-direct/buw/wallet/cex/alpha/all/token/list",
+            payload=payload,
+            body=body,
+            time_unit=self._configuration.time_unit,
+            response_model=TokenListResponse,
+        )

binance_sdk_alpha-1.0.0/src/binance_sdk_alpha/rest_api/models/__init__.py

@@ -0,0 +1,42 @@
+"""
+Binance Alpha REST API
+
+OpenAPI Specification for the Binance Alpha REST API
+The version of the OpenAPI document: 1.0.0
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+from .aggregated_trades_response import (
+    AggregatedTradesResponse as AggregatedTradesResponse,
+)
+from .aggregated_trades_response_data_inner import (
+    AggregatedTradesResponseDataInner as AggregatedTradesResponseDataInner,
+)
+from .get_exchange_info_response import (
+    GetExchangeInfoResponse as GetExchangeInfoResponse,
+)
+from .get_exchange_info_response_data import (
+    GetExchangeInfoResponseData as GetExchangeInfoResponseData,
+)
+from .get_exchange_info_response_data_assets_inner import (
+    GetExchangeInfoResponseDataAssetsInner as GetExchangeInfoResponseDataAssetsInner,
+)
+from .get_exchange_info_response_data_symbols_inner import (
+    GetExchangeInfoResponseDataSymbolsInner as GetExchangeInfoResponseDataSymbolsInner,
+)
+from .get_exchange_info_response_data_symbols_inner_filters_inner import (
+    GetExchangeInfoResponseDataSymbolsInnerFiltersInner as GetExchangeInfoResponseDataSymbolsInnerFiltersInner,
+)
+from .klines_response import KlinesResponse as KlinesResponse
+from .klines_response_data_item import KlinesResponseDataItem as KlinesResponseDataItem
+from .klines_response_data_item_inner import (
+    KlinesResponseDataItemInner as KlinesResponseDataItemInner,
+)
+from .ticker_response import TickerResponse as TickerResponse
+from .ticker_response_data import TickerResponseData as TickerResponseData
+from .token_list_response import TokenListResponse as TokenListResponse
+from .token_list_response_data_inner import (
+    TokenListResponseDataInner as TokenListResponseDataInner,
+)

binance_sdk_alpha-1.0.0/src/binance_sdk_alpha/rest_api/models/aggregated_trades_response.py

@@ -0,0 +1,129 @@
+# coding: utf-8
+
+"""
+Binance Alpha REST API
+
+OpenAPI Specification for the Binance Alpha REST API
+The version of the OpenAPI document: 1.0.0
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from binance_sdk_alpha.rest_api.models.aggregated_trades_response_data_inner import (
+    AggregatedTradesResponseDataInner,
+)
+from typing import Set
+from typing_extensions import Self
+
+
+class AggregatedTradesResponse(BaseModel):
+    """
+    AggregatedTradesResponse
+    """  # noqa: E501
+
+    code: Optional[StrictStr] = None
+    message: Optional[StrictStr] = None
+    message_detail: Optional[StrictStr] = Field(default=None, alias="messageDetail")
+    data: Optional[List[AggregatedTradesResponseDataInner]] = None
+    additional_properties: Dict[str, Any] = {}
+    __properties: ClassVar[List[str]] = ["code", "message", "messageDetail", "data"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def is_array(cls) -> bool:
+        return False
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of AggregatedTradesResponse from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        * Fields in `self.additional_properties` are added to the output dict.
+        """
+        excluded_fields: Set[str] = set(
+            [
+                "additional_properties",
+            ]
+        )
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of each item in data (list)
+        _items = []
+        if self.data:
+            for _item_data in self.data:
+                if _item_data:
+                    _items.append(_item_data.to_dict())
+            _dict["data"] = _items
+        # puts key-value pairs in additional_properties in the top level
+        if self.additional_properties is not None:
+            for _key, _value in self.additional_properties.items():
+                _dict[_key] = _value
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of AggregatedTradesResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "code": obj.get("code"),
+                "message": obj.get("message"),
+                "messageDetail": obj.get("messageDetail"),
+                "data": (
+                    [
+                        AggregatedTradesResponseDataInner.from_dict(_item)
+                        for _item in obj["data"]
+                    ]
+                    if obj.get("data") is not None
+                    else None
+                ),
+            }
+        )
+        # store additional fields in additional_properties
+        for _key in obj.keys():
+            if _key not in cls.__properties:
+                _obj.additional_properties[_key] = obj.get(_key)
+
+        return _obj