pybinbot 0.1.6__py3-none-any.whl → 0.4.0__py3-none-any.whl

pybinbot/__init__.py

@@ -0,0 +1,160 @@
+"""Public API for the ``pybinbot`` distribution.
+
+This package exposes a flat, convenient API for common types, enums and
+models, while still allowing access to the structured subpackages via
+``pybinbot.shared`` and ``pybinbot.models``.
+"""
+
+from pybinbot.shared.maths import (
+    format_ts,
+    interval_to_millisecs,
+    round_numbers,
+    round_numbers_ceiling,
+    round_numbers_floor,
+    supress_notation,
+    supress_trailling,
+    zero_remainder,
+)
+from pybinbot.shared.timestamps import (
+    ms_to_sec,
+    round_timestamp,
+    sec_to_ms,
+    timestamp,
+    timestamp_to_datetime,
+    ts_to_day,
+    ts_to_humandate,
+)
+from pybinbot.shared.enums import (
+    AutotradeSettingsDocument,
+    BinanceKlineIntervals,
+    BinanceOrderModel,
+    CloseConditions,
+    DealType,
+    ExchangeId,
+    KafkaTopics,
+    KucoinKlineIntervals,
+    MarketDominance,
+    OrderSide,
+    OrderStatus,
+    OrderType,
+    QuoteAssets,
+    Status,
+    Strategy,
+    TimeInForce,
+    TrendEnum,
+    UserRoles,
+)
+from pybinbot.shared.indicators import Indicators
+from pybinbot.shared.heikin_ashi import HeikinAshi
+from pybinbot.shared.logging_config import configure_logging
+from pybinbot.shared.types import Amount
+from pybinbot.shared.cache import cache
+from pybinbot.shared.handlers import handle_binance_errors, aio_response_handler
+from pybinbot.models.bot_base import BotBase
+from pybinbot.models.deal import DealBase
+from pybinbot.models.order import OrderBase
+from pybinbot.models.signals import HABollinguerSpread, SignalsConsumer
+from pybinbot.models.routes import StandardResponse
+from pybinbot.apis.binance.base import BinanceApi
+from pybinbot.apis.binbot.base import BinbotApi
+from pybinbot.apis.binbot.exceptions import (
+    BinbotErrors,
+    QuantityTooLow,
+    IsolateBalanceError,
+    DealCreationError,
+    MarginShortError,
+    MarginLoanNotFound,
+    DeleteOrderError,
+    LowBalanceCleanupError,
+    SaveBotError,
+    InsufficientBalance,
+)
+from pybinbot.apis.kucoin.base import KucoinApi
+from pybinbot.apis.kucoin.exceptions import KucoinErrors
+from pybinbot.apis.binance.exceptions import (
+    BinanceErrors,
+    InvalidSymbol,
+    NotEnoughFunds,
+)
+
+
+from . import models, shared
+
+__all__ = [
+    # subpackages
+    "shared",
+    "models",
+    # models
+    "BotBase",
+    "OrderBase",
+    "DealBase",
+    "StandardResponse",
+    "HABollinguerSpread",
+    "SignalsConsumer",
+    # misc
+    "Amount",
+    "configure_logging",
+    "cache",
+    "handle_binance_errors",
+    "aio_response_handler",
+    # maths helpers
+    "supress_trailling",
+    "round_numbers",
+    "round_numbers_ceiling",
+    "round_numbers_floor",
+    "supress_notation",
+    "interval_to_millisecs",
+    "format_ts",
+    "zero_remainder",
+    # timestamp helpers
+    "timestamp",
+    "round_timestamp",
+    "ts_to_day",
+    "ms_to_sec",
+    "sec_to_ms",
+    "ts_to_humandate",
+    "timestamp_to_datetime",
+    # dataframes
+    "Indicators",
+    "HeikinAshi",
+    # enums
+    "CloseConditions",
+    "KafkaTopics",
+    "DealType",
+    "BinanceOrderModel",
+    "Status",
+    "Strategy",
+    "OrderType",
+    "TimeInForce",
+    "OrderSide",
+    "OrderStatus",
+    "TrendEnum",
+    "BinanceKlineIntervals",
+    "KucoinKlineIntervals",
+    "AutotradeSettingsDocument",
+    "UserRoles",
+    "QuoteAssets",
+    "ExchangeId",
+    "HABollinguerSpread",
+    "SignalsConsumer",
+    "MarketDominance",
+    # exchange apis
+    "BinbotApi",
+    "BinanceApi",
+    "KucoinApi",
+    "KucoinErrors",
+    # exceptions
+    "BinanceErrors",
+    "InvalidSymbol",
+    "NotEnoughFunds",
+    "BinbotErrors",
+    "QuantityTooLow",
+    "IsolateBalanceError",
+    "MarginShortError",
+    "MarginLoanNotFound",
+    "DeleteOrderError",
+    "LowBalanceCleanupError",
+    "DealCreationError",
+    "SaveBotError",
+    "InsufficientBalance",
+]

{models → pybinbot/models}/bot_base.py

@@ -1,14 +1,14 @@
 from pydantic import BaseModel, Field, field_validator
-from shared.types import Amount
-from shared.timestamps import timestamp
-from shared.enums import (
-    QuoteAssets,
+
+from pybinbot.shared.enums import (
     BinanceKlineIntervals,
     CloseConditions,
+    QuoteAssets,
     Status,
     Strategy,
 )
-from shared.timestamps import ts_to_humandate
+from pybinbot.shared.timestamps import timestamp, ts_to_humandate
+from pybinbot.shared.types import Amount
 
 
 class BotBase(BaseModel):

{models → pybinbot/models}/deal.py

@@ -1,56 +1,64 @@
 from pydantic import BaseModel, Field, field_validator
-from shared.types import Amount
+
+from pybinbot.shared.types import Amount
 
 
 class DealBase(BaseModel):
-    """
-    Data model that is used for operations,
-    so it should all be numbers (int or float)
-    """
+    """Operational deal data model with numeric fields."""
 
     base_order_size: Amount = Field(default=0, gt=-1)
     current_price: Amount = Field(default=0)
     take_profit_price: Amount = Field(default=0)
     trailling_stop_loss_price: Amount = Field(
         default=0,
-        description="take_profit but for trailling, to avoid confusion, trailling_profit_price always be > trailling_stop_loss_price",
+        description=(
+            "take_profit but for trailling, to avoid confusion, "
+            "trailling_profit_price always be > trailling_stop_loss_price"
+        ),
     )
     trailling_profit_price: Amount = Field(default=0)
     stop_loss_price: Amount = Field(default=0)
-
-    # fields for margin trading
     total_interests: float = Field(default=0, gt=-1)
     total_commissions: float = Field(default=0, gt=-1)
     margin_loan_id: int = Field(
         default=0,
         ge=0,
-        description="Txid from Binance. This is used to check if there is a loan, 0 means no loan",
+        description=(
+            "Txid from Binance. This is used to check if there is a loan, "
+            "0 means no loan"
+        ),
     )
     margin_repay_id: int = Field(
         default=0, ge=0, description="= 0, it has not been repaid"
     )
-
-    # Refactored deal prices that combine both margin and spot
     opening_price: Amount = Field(
         default=0,
-        description="replaces previous buy_price or short_sell_price/margin_short_sell_price",
+        description=(
+            "replaces previous buy_price or short_sell_price/margin_short_sell_price"
+        ),
     )
     opening_qty: Amount = Field(
         default=0,
-        description="replaces previous buy_total_qty or short_sell_qty/margin_short_sell_qty",
+        description=(
+            "replaces previous buy_total_qty or short_sell_qty/margin_short_sell_qty"
+        ),
     )
     opening_timestamp: int = Field(default=0)
     closing_price: Amount = Field(
         default=0,
-        description="replaces previous sell_price or short_sell_price/margin_short_sell_price",
+        description=(
+            "replaces previous sell_price or short_sell_price/margin_short_sell_price"
+        ),
     )
     closing_qty: Amount = Field(
         default=0,
-        description="replaces previous sell_qty or short_sell_qty/margin_short_sell_qty",
+        description=(
+            "replaces previous sell_qty or short_sell_qty/margin_short_sell_qty"
+        ),
     )
     closing_timestamp: int = Field(
         default=0,
-        description="replaces previous buy_timestamp or margin/short_sell timestamps",
+        description=("replaces previous buy_timestamp or margin/short_sell timestamps"),
     )
 
     @field_validator("margin_loan_id", mode="before")

{models → pybinbot/models}/order.py

@@ -1,22 +1,29 @@
-from pydantic import BaseModel, Field, field_validator
-from shared.types import Amount
-from shared.enums import (
-    DealType,
-    OrderStatus,
-)
+from pydantic import BaseModel, Field
+
+from pybinbot.shared.enums import DealType, OrderStatus
+from pybinbot.shared.types import Amount
 
 
 class OrderBase(BaseModel):
     order_type: str = Field(
-        description="Because every exchange has different naming, we should keep it as a str rather than OrderType enum"
+        description=(
+            "Because every exchange has different naming, we should keep it as a "
+            "str rather than OrderType enum"
+        )
     )
     time_in_force: str
     timestamp: int = Field(default=0)
     order_id: int | str = Field(
-        description="Because every exchange has id type, we should keep it as looose as possible. Int is for backwards compatibility"
+        description=(
+            "Because every exchange has id type, we should keep it as loose as "
+            "possible. Int is for backwards compatibility"
+        )
     )
     order_side: str = Field(
-        description="Because every exchange has different naming, we should keep it as a str rather than OrderType enum"
+        description=(
+            "Because every exchange has different naming, we should keep it as a "
+            "str rather than OrderType enum"
+        )
     )
     pair: str
     qty: float
@@ -27,7 +34,10 @@ class OrderBase(BaseModel):
         "from_attributes": True,
         "use_enum_values": True,
         "json_schema_extra": {
-            "description": "Most fields are optional. Deal field is generated internally, orders are filled up by Exchange",
+            "description": (
+                "Most fields are optional. Deal field is generated internally, "
+                "orders are filled up by Exchange"
+            ),
             "examples": [
                 {
                     "order_type": "LIMIT",
@@ -51,7 +61,10 @@ class DealModel(BaseModel):
     take_profit_price: Amount = Field(default=0)
     trailling_stop_loss_price: Amount = Field(
         default=0,
-        description="take_profit but for trailling, to avoid confusion, trailling_profit_price always be > trailling_stop_loss_price",
+        description=(
+            "take_profit but for trailling, to avoid confusion, "
+            "trailling_profit_price always be > trailling_stop_loss_price"
+        ),
     )
     trailling_profit_price: Amount = Field(default=0)
     stop_loss_price: Amount = Field(default=0)
@@ -60,45 +73,40 @@ class DealModel(BaseModel):
     margin_loan_id: int = Field(
         default=0,
         ge=0,
-        description="Txid from Binance. This is used to check if there is a loan, 0 means no loan",
+        description=(
+            "Txid from Binance. This is used to check if there is a loan, "
+            "0 means no loan"
+        ),
     )
     margin_repay_id: int = Field(
         default=0, ge=0, description="= 0, it has not been repaid"
     )
     opening_price: Amount = Field(
         default=0,
-        description="replaces previous buy_price or short_sell_price/margin_short_sell_price",
+        description=(
+            "replaces previous buy_price or short_sell_price/margin_short_sell_price"
+        ),
     )
     opening_qty: Amount = Field(
         default=0,
-        description="replaces previous buy_total_qty or short_sell_qty/margin_short_sell_qty",
+        description=(
+            "replaces previous buy_total_qty or short_sell_qty/margin_short_sell_qty"
+        ),
     )
     opening_timestamp: int = Field(default=0)
     closing_price: Amount = Field(
         default=0,
-        description="replaces previous sell_price or short_sell_price/margin_short_sell_price",
+        description=(
+            "replaces previous sell_price or short_sell_price/margin_short_sell_price"
+        ),
     )
     closing_qty: Amount = Field(
         default=0,
-        description="replaces previous sell_qty or short_sell_qty/margin_short_sell_qty",
+        description=(
+            "replaces previous sell_qty or short_sell_qty/margin_short_sell_qty"
+        ),
     )
     closing_timestamp: int = Field(
         default=0,
-        description="replaces previous buy_timestamp or margin/short_sell timestamps",
+        description=("replaces previous buy_timestamp or margin/short_sell timestamps"),
     )
-
-    @field_validator("margin_loan_id", mode="before")
-    @classmethod
-    def validate_margin_loan_id(cls, value):
-        if isinstance(value, float):
-            return int(value)
-        else:
-            return value
-
-    @field_validator("margin_loan_id", mode="after")
-    @classmethod
-    def cast_float(cls, value):
-        if isinstance(value, float):
-            return int(value)
-        else:
-            return value

pybinbot/models/routes.py

@@ -0,0 +1,6 @@
+from pydantic import BaseModel, Field
+
+
+class StandardResponse(BaseModel):
+    message: str
+    error: int = Field(default=0)

{models → pybinbot/models}/signals.py

@@ -1,14 +1,11 @@
-from pydantic import BaseModel, Field, field_validator, ConfigDict
-from typing import Optional
 from datetime import datetime
+from typing import Optional
+
+from pydantic import BaseModel, ConfigDict, Field, field_validator
 
 
-# Example shared model (copy actual model code from source files)
 class HABollinguerSpread(BaseModel):
-    """
-    Pydantic model for the Bollinguer spread.
-    (optional)
-    """
+    """Pydantic model for the Bollinguer spread."""
 
     bb_high: float
     bb_mid: float
@@ -16,9 +13,7 @@ class HABollinguerSpread(BaseModel):
 
 
 class SignalsConsumer(BaseModel):
-    """
-    Pydantic model for the signals consumer.
-    """
+    """Pydantic model for the signals consumer."""
 
     type: str = Field(default="signal")
     date: str = Field(

pybinbot/shared/cache.py

@@ -0,0 +1,32 @@
+import time
+from functools import wraps
+from typing import Any, Callable, Dict, Tuple
+
+
+def cache(
+    ttl_seconds: int = 3600,
+) -> Callable[[Callable[..., Any]], Callable[..., Any]]:
+    """Simple in-process TTL cache decorator (per process).
+    Caches function results by args/kwargs for ttl_seconds.
+    """
+
+    def decorator(func: Callable[..., Any]) -> Callable[..., Any]:
+        store: Dict[
+            Tuple[Tuple[Any, ...], Tuple[Tuple[str, Any], ...]], Tuple[float, Any]
+        ] = {}
+
+        @wraps(func)
+        def wrapper(*args: Any, **kwargs: Any) -> Any:
+            key = (args, tuple(sorted(kwargs.items())))
+            now = time.monotonic()
+            if key in store:
+                expiry, value = store[key]
+                if now < expiry:
+                    return value
+            value = func(*args, **kwargs)
+            store[key] = (now + max(0, int(ttl_seconds)), value)
+            return value
+
+        return wrapper
+
+    return decorator

{shared → pybinbot/shared}/enums.py

@@ -2,6 +2,18 @@ from enum import Enum
 from pydantic import BaseModel, field_validator
 
 
+class DealType(str, Enum):
+    base_order = "base_order"
+    take_profit = "take_profit"
+    stop_loss = "stop_loss"
+    short_sell = "short_sell"
+    short_buy = "short_buy"
+    margin_short = "margin_short"
+    panic_close = "panic_close"
+    trailling_profit = "trailling_profit"
+    conversion = "conversion"  # converts one crypto to another
+
+
 class CloseConditions(str, Enum):
     dynamic_trailling = "dynamic_trailling"
     # No trailling, standard stop loss
@@ -18,16 +30,6 @@ class KafkaTopics(str, Enum):
     restart_autotrade = "restart-autotrade"
 
 
-class DealType(str, Enum):
-    base_order = "base_order"
-    take_profit = "take_profit"
-    stop_loss = "stop_loss"
-    short_sell = "short_sell"
-    short_buy = "short_buy"
-    margin_short = "margin_short"
-    panic_close = "panic_close"
-
-
 class BinanceOrderModel(BaseModel):
     """
     Data model given by Binance,
@@ -112,18 +114,6 @@ class TrendEnum(str, Enum):
     neutral = None
 
 
-class DealType(str, Enum):
-    base_order = "base_order"
-    take_profit = "take_profit"
-    stop_loss = "stop_loss"
-    short_sell = "short_sell"
-    short_buy = "short_buy"
-    margin_short = "margin_short"
-    panic_close = "panic_close"
-    trailling_profit = "trailling_profit"
-    conversion = "conversion"  # converts one crypto to another
-
-
 class BinanceKlineIntervals(str, Enum):
     one_minute = "1m"
     three_minutes = "3m"
@@ -182,6 +172,27 @@ class BinanceKlineIntervals(str, Enum):
         }
         return interval_map.get(self.value, self.value)
 
+    def get_interval_ms(interval_str: str) -> int:
+        """Convert Binance interval string to milliseconds"""
+        interval_map = {
+            "1m": 60 * 1000,
+            "3m": 3 * 60 * 1000,
+            "5m": 5 * 60 * 1000,
+            "15m": 15 * 60 * 1000,
+            "30m": 30 * 1000,
+            "1h": 60 * 60 * 1000,
+            "2h": 2 * 60 * 60 * 1000,
+            "4h": 4 * 60 * 60 * 1000,
+            "6h": 6 * 60 * 60 * 1000,
+            "8h": 8 * 60 * 60 * 1000,
+            "12h": 12 * 60 * 60 * 1000,
+            "1d": 24 * 60 * 60 * 1000,
+            "3d": 3 * 24 * 60 * 60 * 1000,
+            "1w": 7 * 24 * 60 * 60 * 1000,
+            "1M": 30 * 24 * 60 * 60 * 1000,  # Approximate month as 30 days
+        }
+        return interval_map.get(interval_str, 60 * 1000)  # Default to 1 minute
+
 
 class KucoinKlineIntervals(str, Enum):
     ONE_MINUTE = "1min"

pybinbot/shared/handlers.py

@@ -0,0 +1,89 @@
+import logging
+from time import sleep
+from requests import Response, HTTPError
+from aiohttp import ClientResponse
+from pybinbot.apis.binbot.exceptions import (
+    BinbotErrors,
+    QuantityTooLow,
+)
+from pybinbot.apis.binance.exceptions import (
+    BinanceErrors,
+    InvalidSymbol,
+    NotEnoughFunds,
+)
+
+
+async def aio_response_handler(response: ClientResponse):
+    content = await response.json()
+    return content
+
+
+def handle_binance_errors(response: Response) -> dict:
+    """
+    Handles:
+    - HTTP codes, not authorized, rate limits...
+    - Bad request errors, binance internal e.g. {"code": -1013, "msg": "Invalid quantity"}
+    - Binbot internal errors - bot errors, returns "errored"
+
+    """
+
+    if "x-mbx-used-weight-1m" in response.headers:
+        logging.info(
+            f"Request to {response.url} weight: {response.headers.get('x-mbx-used-weight-1m')}"
+        )
+    # Binance doesn't seem to reach 418 or 429 even after 2000 weight requests
+    if (
+        response.headers.get("x-mbx-used-weight-1m")
+        and float(response.headers.get("x-mbx-used-weight-1m", 0)) > 7000
+    ):
+        logging.warning("Request weight limit prevention pause, waiting 1 min")
+        sleep(120)
+
+    if response.status_code == 418 or response.status_code == 429:
+        logging.warning("Request weight limit hit, ban will come soon, waiting 1 hour")
+        sleep(3600)
+
+    # Cloudfront 403 error
+    if response.status_code == 403 and response.reason:
+        raise HTTPError(response=response)
+
+    content = response.json()
+
+    if response.status_code == 404:
+        raise HTTPError(response=response)
+
+    # Show error messsage for bad requests
+    if response.status_code >= 400:
+        # Binance errors
+        if "msg" in content and "code" in content:
+            raise BinanceErrors(content["msg"], content["code"])
+
+        # Binbot errors
+        if content and "error" in content and content["error"] == 1:
+            raise BinbotErrors(content["message"], content["error"])
+
+    # Binance errors
+    if content and "code" in content:
+        if content["code"] == -1013:
+            raise QuantityTooLow(content["message"], content["error"])
+        if content["code"] == 200:
+            return content
+        if (
+            content["code"] == -2010
+            or content["code"] == -1013
+            or content["code"] == -2015
+        ):
+            # Not enough funds. Ignore, send to bot errors
+            # Need to be dealt with at higher levels
+            raise NotEnoughFunds(content["msg"], content["code"])
+
+        if content["code"] == -1003:
+            # Too many requests, most likely exceeded API rate limits
+            # Back off for > 5 minutes, which is Binance's ban time
+            print("Too many requests. Back off for 1 min...")
+            sleep(60)
+
+        if content["code"] == -1121:
+            raise InvalidSymbol(f"Binance error: {content['msg']}", content["code"])
+
+    return content