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

{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

pybinbot/shared/heikin_ashi.py

@@ -0,0 +1,198 @@
+from typing import cast
+
+from pandas import DataFrame, to_numeric, concat
+from pandas.api.types import is_numeric_dtype
+from pandas import to_datetime
+from pybinbot.shared.enums import ExchangeId
+
+
+class HeikinAshi:
+    """
+    Dataframe operations shared across projects and Heikin Ashi candle transformation.
+    This avoids circular imports and groups related functionality.
+
+    Canonical formulas applied to OHLC data:
+        HA_Close = (O + H + L + C) / 4
+        HA_Open  = (prev_HA_Open + prev_HA_Close) / 2, seed = (O0 + C0) / 2
+        HA_High  = max(H, HA_Open, HA_Close)
+        HA_Low   = min(L, HA_Open, HA_Close)
+
+    This version:
+      * Works if a 'timestamp' column exists (sorted chronologically first).
+      * Does NOT mutate the original dataframe in-place; returns a copy.
+      * Validates required columns.
+    """
+
+    binance_cols = [
+        "open_time",
+        "open",
+        "high",
+        "low",
+        "close",
+        "volume",
+        "close_time",
+        "quote_asset_volume",
+        "number_of_trades",
+        "taker_buy_base_asset_volume",
+        "taker_buy_quote_asset_volume",
+    ]
+    kucoin_cols = [
+        "open_time",
+        "open",
+        "high",
+        "low",
+        "close",
+        "volume",
+        "close_time",
+        "quote_asset_volume",
+    ]
+
+    numeric_cols = [
+        "open",
+        "high",
+        "low",
+        "close",
+        "open_time",
+        "close_time",
+        "volume",
+        "quote_asset_volume",
+    ]
+
+    ohlc_cols = ["open", "high", "low", "close"]
+
+    REQUIRED_COLUMNS = kucoin_cols
+
+    def pre_process(self, exchange: ExchangeId, candles: list):
+        df_1h = DataFrame()
+        df_4h = DataFrame()
+        if exchange == ExchangeId.BINANCE:
+            # Binance API may return extra columns; only take the expected ones
+            df_raw = DataFrame(candles)
+            df = df_raw.iloc[:, : len(self.binance_cols)]
+            df.columns = self.binance_cols
+            columns = self.binance_cols
+        else:
+            df = DataFrame(candles, columns=self.kucoin_cols)
+            columns = self.kucoin_cols
+
+        # Ensure the dataframe has exactly the expected columns
+        if len(df.columns) != len(columns):
+            raise ValueError(
+                f"Column mismatch: {len(df.columns)} vs expected {len(columns)}"
+            )
+
+        # Convert only numeric columns safely
+        numeric_cols = ["open", "high", "low", "close", "volume"]
+        for col in numeric_cols:
+            df[col] = to_numeric(df[col], errors="coerce")
+
+        df = self.get_heikin_ashi(df)
+
+        # Ensure close_time is datetime and set as index for proper resampling
+        df["timestamp"] = to_datetime(df["close_time"], unit="ms")
+        df.set_index("timestamp", inplace=True)
+        df = df.sort_index()
+        df = df[~df.index.duplicated(keep="last")]
+
+        # Create aggregation dictionary without close_time and open_time since they're now index-based
+        resample_aggregation = {
+            "open": "first",
+            "close": "last",
+            "high": "max",
+            "low": "min",
+            "volume": "sum",  # Add volume if it exists in your data
+            "close_time": "first",
+            "open_time": "first",
+        }
+
+        # Resample to 4 hour candles for TWAP (align to calendar hours like MongoDB)
+        df_4h = df.resample("4h").agg(cast(dict, resample_aggregation))
+        # Add open_time and close_time back as columns for 4h data
+        df_4h["open_time"] = df_4h.index
+        df_4h["close_time"] = df_4h.index
+
+        # Resample to 1 hour candles for Supertrend (align to calendar hours like MongoDB)
+        df_1h = df.resample("1h").agg(cast(dict, resample_aggregation))
+        # Add open_time and close_time back as columns for 1h data
+        df_1h["open_time"] = df_1h.index
+        df_1h["close_time"] = df_1h.index
+
+        return df, df_1h, df_4h
+
+    @staticmethod
+    def post_process(df: DataFrame) -> DataFrame:
+        """
+        Post-process the DataFrame by filling missing values and
+        converting data types as needed.
+        """
+        df.dropna(inplace=True)
+        df.reset_index(drop=True, inplace=True)
+        return df
+
+    def ensure_ohlc(self, df: DataFrame) -> DataFrame:
+        """Validate & coerce a DataFrame into an DataFrame.
+
+        Steps:
+        - Verify all REQUIRED_COLUMNS are present (raises ValueError if missing).
+        - Coerce numeric columns (including *_time which are expected as ms epoch).
+        - Perform early failure if quote_asset_volume becomes entirely NaN.
+        - Return the same underlying object cast to DataFrame (no deep copy).
+        """
+        missing = set(self.REQUIRED_COLUMNS) - set(df.columns)
+        if missing:
+            raise ValueError(f"Missing required OHLC columns: {missing}")
+
+        for col in self.numeric_cols:
+            if col in df.columns and not is_numeric_dtype(df[col]):
+                df[col] = to_numeric(df[col], errors="coerce")
+
+        if (
+            "quote_asset_volume" in df.columns
+            and df["quote_asset_volume"].notna().sum() == 0
+        ):
+            raise ValueError(
+                "quote_asset_volume column is entirely non-numeric after coercion; cannot compute quote_volume_ratio"
+            )
+
+        return df
+
+    def get_heikin_ashi(self, df: DataFrame) -> DataFrame:
+        if df.empty:
+            return df
+
+        # Validate & coerce using the new type guard helper.
+        df = self.ensure_ohlc(df)
+        work = df.reset_index(drop=True).copy()
+
+        # Compute HA_Close from ORIGINAL OHLC (still intact in 'work').
+        # Ensure numeric dtypes (API feeds sometimes deliver strings)
+        for c in self.ohlc_cols:
+            # Only attempt conversion if dtype is not already numeric
+            if not is_numeric_dtype(work[c]):
+                work.loc[:, c] = to_numeric(work[c], errors="coerce")
+
+        if work[self.ohlc_cols].isna().any().any():
+            # Drop rows that became NaN after coercion (invalid numeric data)
+            work = work.dropna(subset=self.ohlc_cols).reset_index(drop=True)
+            if work.empty:
+                raise ValueError("All OHLC rows became NaN after numeric coercion.")
+
+        ha_close = (work["open"] + work["high"] + work["low"] + work["close"]) / 4.0
+
+        # Seed HA_Open with original O & C (not HA close).
+        ha_open = ha_close.copy()
+        ha_open.iloc[0] = (work["open"].iloc[0] + work["close"].iloc[0]) / 2.0
+        for i in range(1, len(work)):
+            ha_open.iloc[i] = (ha_open.iloc[i - 1] + ha_close.iloc[i - 1]) / 2.0
+
+        # High / Low derived from max/min of (raw high/low, ha_open, ha_close)
+        ha_high = concat([work["high"], ha_open, ha_close], axis=1).max(axis=1)
+        ha_low = concat([work["low"], ha_open, ha_close], axis=1).min(axis=1)
+
+        # Assign transformed values.
+        work.loc[:, "open"] = ha_open
+        work.loc[:, "high"] = ha_high
+        work.loc[:, "low"] = ha_low
+        work.loc[:, "close"] = ha_close
+
+        return work