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

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

pybinbot/shared/indicators.py

@@ -0,0 +1,271 @@
+from typing import cast
+from pandas import DataFrame, Series, Timedelta, concat, to_datetime
+
+
+class Indicators:
+    """
+    Technical indicators for financial data analysis
+    this avoids using ta-lib because that requires
+    dependencies that causes issues in the infrastructure
+    """
+
+    @staticmethod
+    def moving_averages(df: DataFrame, period=7) -> DataFrame:
+        """
+        Calculate moving averages for 7, 25, 100 days
+        this also takes care of Bollinguer bands
+        """
+        df[f"ma_{period}"] = df["close"].rolling(window=period).mean()
+        return df
+
+    @staticmethod
+    def macd(df: DataFrame) -> DataFrame:
+        """
+        Moving Average Convergence Divergence (MACD) indicator
+        https://www.alpharithms.com/calculate-macd-python-272222/
+        """
+
+        k = df["close"].ewm(span=12, min_periods=12).mean()
+        # Get the 12-day EMA of the closing price
+        d = df["close"].ewm(span=26, min_periods=26).mean()
+        # Subtract the 26-day EMA from the 12-Day EMA to get the MACD
+        macd = k - d
+        # Get the 9-Day EMA of the MACD for the Trigger line
+        # Get the 9-Day EMA of the MACD for the Trigger line
+        macd_s = macd.ewm(span=9, min_periods=9).mean()
+
+        df["macd"] = macd
+        df["macd_signal"] = macd_s
+
+        return df
+
+    @staticmethod
+    def ema(
+        df: DataFrame, column: str = "close", span: int = 9, out_col: str | None = None
+    ) -> DataFrame:
+        """Exponential moving average for a given column.
+
+        Adds a new column with the EMA values and returns the DataFrame.
+        """
+        target_col = out_col or f"ema_{span}"
+        df[target_col] = df[column].ewm(span=span, adjust=False).mean()
+        return df
+
+    @staticmethod
+    def trend_ema(
+        df: DataFrame, column: str = "close", fast_span: int = 9, slow_span: int = 21
+    ) -> DataFrame:
+        """Compute fast and slow EMAs for trend analysis.
+
+        Adds 'ema_fast' and 'ema_slow' columns and returns the DataFrame.
+        """
+        df = Indicators.ema(df, column=column, span=fast_span, out_col="ema_fast")
+        df = Indicators.ema(df, column=column, span=slow_span, out_col="ema_slow")
+        return df
+
+    @staticmethod
+    def rsi(df: DataFrame, window: int = 14) -> DataFrame:
+        """
+        Relative Strength Index (RSI) indicator
+        https://www.qmr.ai/relative-strength-index-rsi-in-python/
+        """
+
+        change = df["close"].astype(float).diff()
+
+        gain = change.mask(change < 0, 0.0)
+        loss = -change.mask(change > 0, -0.0)
+
+        # Verify that we did not make any mistakes
+        change.equals(gain + loss)
+
+        # Calculate the rolling average of average up and average down
+        avg_up = gain.rolling(window).mean()
+        avg_down = loss.rolling(window).mean().abs()
+
+        rsi = 100 * avg_up / (avg_up + avg_down)
+        df["rsi"] = rsi
+
+        return df
+
+    @staticmethod
+    def standard_rsi(df: DataFrame, window: int = 14) -> DataFrame:
+        delta = df["close"].diff()
+        gain = delta.where(delta > 0, 0).rolling(window=window, min_periods=1).mean()
+        loss = (-delta.where(delta < 0, 0)).rolling(window=window, min_periods=1).mean()
+        rs = gain / (loss + 1e-10)
+        df["rsi"] = 100 - (100 / (1 + rs))
+        return df
+
+    @staticmethod
+    def ma_spreads(df: DataFrame) -> DataFrame:
+        """
+        Calculates spread based on bollinger bands,
+        for later use in take profit and stop loss
+
+        Returns:
+        - top_band: diff between ma_25 and ma_100
+        - bottom_band: diff between ma_7 and ma_25
+        """
+
+        band_1 = (abs(df["ma_100"] - df["ma_25"]) / df["ma_100"]) * 100
+        band_2 = (abs(df["ma_25"] - df["ma_7"]) / df["ma_25"]) * 100
+
+        df["big_ma_spread"] = band_1
+        df["small_ma_spread"] = band_2
+
+        return df
+
+    @staticmethod
+    def bollinguer_spreads(df: DataFrame, window=20, num_std=2) -> DataFrame:
+        """
+        Calculates Bollinguer bands
+
+        https://www.kaggle.com/code/blakemarterella/pandas-bollinger-bands
+
+        """
+        bb_df = df.copy()
+        bb_df["rolling_mean"] = bb_df["close"].rolling(window).mean()
+        bb_df["rolling_std"] = bb_df["close"].rolling(window).std()
+        bb_df["upper_band"] = bb_df["rolling_mean"] + (num_std * bb_df["rolling_std"])
+        bb_df["lower_band"] = bb_df["rolling_mean"] - (num_std * bb_df["rolling_std"])
+
+        df["bb_upper"] = bb_df["upper_band"]
+        df["bb_lower"] = bb_df["lower_band"]
+        df["bb_mid"] = bb_df["rolling_mean"]
+
+        return df
+
+    @staticmethod
+    def log_volatility(df: DataFrame, window_size=7) -> DataFrame:
+        """
+        Volatility (standard deviation of returns) using logarithm, this normalizes data
+        so it's easily comparable with other assets
+
+        Returns:
+        - Volatility in percentage
+        """
+        log_volatility = (
+            Series(df["close"]).astype(float).pct_change().rolling(window_size).std()
+        )
+        df["perc_volatility"] = log_volatility
+
+        return df
+
+    @staticmethod
+    def set_twap(df: DataFrame, periods: int = 30) -> DataFrame:
+        """
+        Time-weighted average price
+        https://stackoverflow.com/a/69517577/2454059
+
+        Periods kept at 4 by default,
+        otherwise there's not enough data
+        """
+        pre_df = df.copy()
+        pre_df["Event Time"] = to_datetime(pre_df["close_time"])
+        time_diff_td = cast(
+            "Series[Timedelta]", pre_df["Event Time"].diff(periods=periods)
+        )
+        pre_df["Time Diff"] = time_diff_td.dt.total_seconds() / 3600
+        pre_df["Weighted Value"] = pre_df["close"] * pre_df["Time Diff"]
+        pre_df["Weighted Average"] = (
+            pre_df["Weighted Value"].rolling(periods).sum() / pre_df["Time Diff"].sum()
+        )
+        # Fixed window of given interval
+        df["twap"] = pre_df["Weighted Average"]
+
+        return df
+
+    @staticmethod
+    def atr(
+        df: DataFrame,
+        window: int = 14,
+        min_periods: int | None = None,
+        col_prefix: str = "",
+    ) -> DataFrame:
+        """
+        Generic ATR indicator.
+
+        Adds column: '{prefix}ATR'
+        """
+        if df.empty:
+            return df
+
+        if min_periods is None:
+            min_periods = window
+
+        prev_close = df["close"].shift(1)
+
+        tr = concat(
+            [
+                df["high"] - df["low"],
+                (df["high"] - prev_close).abs(),
+                (df["low"] - prev_close).abs(),
+            ],
+            axis=1,
+        ).max(axis=1)
+
+        df[f"{col_prefix}ATR"] = tr.rolling(
+            window=window, min_periods=min_periods
+        ).mean()
+
+        return df
+
+    @staticmethod
+    def set_supertrend(
+        df: DataFrame,
+        atr_col: str = "ATR",
+        multiplier: float = 3.0,
+        prefix: str = "",
+    ) -> DataFrame:
+        """
+        Supertrend indicator.
+
+        Requires ATR to already exist.
+        Adds:
+        - '{prefix}supertrend'
+        - '{prefix}supertrend_dir'  (1 bullish, -1 bearish)
+        """
+        if df.empty or atr_col not in df:
+            return df
+
+        hl2 = (df["high"] + df["low"]) / 2
+        atr = df[atr_col]
+
+        upperband = hl2 + multiplier * atr
+        lowerband = hl2 - multiplier * atr
+
+        final_upper = upperband.copy()
+        final_lower = lowerband.copy()
+
+        for i in range(1, len(df)):
+            final_upper.iloc[i] = (
+                min(upperband.iloc[i], final_upper.iloc[i - 1])
+                if df["close"].iloc[i - 1] <= final_upper.iloc[i - 1]
+                else upperband.iloc[i]
+            )
+
+            final_lower.iloc[i] = (
+                max(lowerband.iloc[i], final_lower.iloc[i - 1])
+                if df["close"].iloc[i - 1] >= final_lower.iloc[i - 1]
+                else lowerband.iloc[i]
+            )
+
+        direction = [0] * len(df)
+        supertrend = [None] * len(df)
+
+        for i in range(1, len(df)):
+            if df["close"].iloc[i] > final_upper.iloc[i - 1]:
+                direction[i] = 1
+            elif df["close"].iloc[i] < final_lower.iloc[i - 1]:
+                direction[i] = -1
+            else:
+                direction[i] = direction[i - 1]
+
+            supertrend[i] = (
+                final_lower.iloc[i] if direction[i] == 1 else final_upper.iloc[i]
+            )
+
+        df[f"{prefix}supertrend"] = supertrend
+        df[f"{prefix}supertrend_dir"] = direction
+
+        return df

{shared → pybinbot/shared}/logging_config.py

@@ -16,9 +16,7 @@ def configure_logging(
     force: bool = True,
     quiet_loggers: Iterable[str] | None = ("uvicorn", "confluent_kafka"),
 ) -> None:
-    """
-    Configure root logging consistently across API services.
-    """
+    """Configure root logging consistently across services."""
     resolved_level = str(level or os.environ.get("LOG_LEVEL", "INFO")).upper()
     logging.basicConfig(
         level=resolved_level,

{shared → pybinbot/shared}/timestamps.py

@@ -2,11 +2,13 @@ import os
 from time import time
 import math
 from zoneinfo import ZoneInfo
-from shared.maths import round_numbers_ceiling
 from datetime import datetime
 
+from .maths import round_numbers_ceiling
+
 format = "%Y-%m-%d %H:%M:%S"
 
+
 def timestamp() -> int:
     ts = time() * 1000
     rounded_ts = round_timestamp(ts)
@@ -44,8 +46,8 @@ def ts_to_day(ts: float | int) -> str:
         ts = ts * pow(10, 10 - digits)
 
     dt_obj = datetime.fromtimestamp(ts)
-    b_str_date = datetime.strftime(dt_obj, format)
-    return b_str_date
+    # ts_to_day returns a date string without time component
+    return datetime.strftime(dt_obj, "%Y-%m-%d")
 
 
 def ms_to_sec(ms: int) -> int:
@@ -94,4 +96,3 @@ def timestamp_to_datetime(timestamp: str | int) -> str:
         timestamp, tz=ZoneInfo(os.getenv("TZ", "Europe/London"))
     )
     return dt.strftime(format)
-    

{shared → pybinbot/shared}/types.py

@@ -1,6 +1,9 @@
 from typing import Annotated
+
 from pydantic import BeforeValidator
-from shared.maths import ensure_float
+
+from .maths import ensure_float
+
 
 Amount = Annotated[
     float,

{pybinbot-0.1.6.dist-info → pybinbot-0.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pybinbot
-Version: 0.1.6
+Version: 0.4.0
 Summary: Utility functions for the binbot project.
 Author-email: Carlos Wu <carkodw@gmail.com>
 Requires-Python: >=3.11
@@ -10,9 +10,18 @@ Requires-Dist: pydantic[email]>=2.0.0
 Requires-Dist: numpy==2.2.0
 Requires-Dist: pandas>=2.2.3
 Requires-Dist: pymongo==4.6.3
+Requires-Dist: pandas-stubs>=2.3.3.251219
+Requires-Dist: requests>=2.32.5
+Requires-Dist: kucoin-universal-sdk>=1.3.0
+Requires-Dist: aiohttp>=3.13.3
+Requires-Dist: python-dotenv>=1.2.1
 Provides-Extra: dev
 Requires-Dist: pytest>=9.0.2; extra == "dev"
-Requires-Dist: ruff; extra == "dev"
+Requires-Dist: ruff>=0.11.12; extra == "dev"
+Requires-Dist: mypy>=1.19.1; extra == "dev"
+Requires-Dist: types-requests>=2.32.4.20260107; extra == "dev"
+Requires-Dist: httpx>=0.28.1; extra == "dev"
+Requires-Dist: pytest-asyncio>=1.3.0; extra == "dev"
 Dynamic: license-file
 
 # PyBinbot
@@ -39,6 +48,9 @@ uv sync --extra dev
 
 ## Publishing
 
+1. Save your changes and do the usual Git flow (add, commit, don't push the changes yet).
+2. Bump the version, choose one of these:
+
 ```bash
 make bump-patch
 ```
@@ -54,4 +66,12 @@ or
 make bump-major
 ```
 
+3. Git tag the version for Github. This will read the bump version. There's a convenience command:
+```
+make tag
+```
+
+4. `git commit --amend`. This is to put these new changes in the previous commit so we don't dup uncessary commits. Then `git push`
+
+
 For further commands take a look at the `Makefile` such as testing `make test`

pybinbot-0.4.0.dist-info/RECORD

@@ -0,0 +1,23 @@
+pybinbot/__init__.py,sha256=4yW8FlBmbjfSiY6xcl_18_BRYppwMlDjB5s7zaxjogM,3791
+pybinbot/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pybinbot/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pybinbot/models/bot_base.py,sha256=uOVM4sdNTVV3hpUj9CLh-nZQ4bQmFrkFHdZcv-K9AeQ,3592
+pybinbot/models/deal.py,sha256=9TBqt-WgaGJ7raZE2gHUimvZohiH831oRL-mH0dvGQ8,2443
+pybinbot/models/order.py,sha256=1I9LJuEOysfMa9qJew2QIXhpwvl3xsfAP7DKbAH24sc,3492
+pybinbot/models/routes.py,sha256=ZyRBrlabJYXOGW05-6sxpUKyTnF1AjYpc88KQtXeRFU,126
+pybinbot/models/signals.py,sha256=Br0q32L9m13hVw8C8A1UtBG5vQQxdQzkVREIdDE_SaA,1256
+pybinbot/shared/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pybinbot/shared/cache.py,sha256=iIl0IPqYVhKNbQLYuDigZYQzKfyQzPFZSWzD4oSWu_A,984
+pybinbot/shared/enums.py,sha256=dO3KMvxcmzaEVfJqrMSi6vvJGdjc__GyCI7MbRAmRro,7303
+pybinbot/shared/handlers.py,sha256=6BtNVSlU8WKuMN5O66oDAyS6d0M5oID7G_aCaDEsIkg,2961
+pybinbot/shared/heikin_ashi.py,sha256=ypV31YXIv63G-02v7KyeBR2rwraMCoU2CYIolm5OC6w,7083
+pybinbot/shared/indicators.py,sha256=_yGcxRsaPq8v-h_OXiLSg-ygvOEfse6uFSVi9ViIxBQ,8509
+pybinbot/shared/logging_config.py,sha256=Bg38T5gL5H7BMxnOEEZNiBUQT2ccV96UZNxwJIyDc5s,1130
+pybinbot/shared/maths.py,sha256=JjlrgV0INlJG4Zj28ahRkfzcI2Ec4noilrDwX2p82TM,3207
+pybinbot/shared/timestamps.py,sha256=84N9t78Zs5CqKGPbIHlaJGyZzHcwrMwAw9r4hPTR0ro,2616
+pybinbot/shared/types.py,sha256=JNMZiO3UPMa4xuo9fUO4kZff-mTNT6CaI5uQ_8WtcY4,170
+pybinbot-0.4.0.dist-info/licenses/LICENSE,sha256=ECEAqAQ81zTT8PeN7gYqbkZtewkyeleEqQ26MxuHQxs,938
+pybinbot-0.4.0.dist-info/METADATA,sha256=ZE1wloj_6zQPJbNAdq3QJnjvphVlvDZy2GwVbiXx4XE,2140
+pybinbot-0.4.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pybinbot-0.4.0.dist-info/top_level.txt,sha256=agwNV3TckcrWlAb8UpSJdWxfoMu2IvnOsmMd--F7Si8,9
+pybinbot-0.4.0.dist-info/RECORD,,

pybinbot-0.4.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pybinbot

pybinbot-0.1.6.dist-info/RECORD

@@ -1,15 +0,0 @@
-pybinbot.py,sha256=bLB9AYwuk3cbQ7HVlVGwTtzqNSV3FsZv4Rtbetg0Kas,1920
-models/bot_base.py,sha256=z9hSK7uVLW4oDmPdtntYozo8RnQnpZtFi8fL1r9Qd5Q,3593
-models/deal.py,sha256=jOdMSobN_K4-be3hG38l0WeZq5ln5JndA-BBgMUElsI,2402
-models/order.py,sha256=FHs7qi2JNYn-kXfWD2m5oFSSeMQDKmw0uPDwOvy5KkQ,3592
-models/signals.py,sha256=DAcV2ft6n5iJW4kqspdfEakFZ3igx97erwyTiyDMlgM,1356
-pybinbot-0.1.6.dist-info/licenses/LICENSE,sha256=ECEAqAQ81zTT8PeN7gYqbkZtewkyeleEqQ26MxuHQxs,938
-shared/enums.py,sha256=b472TAbRrnznDRDDVrLW_2I_9dURafqeC3pMu4DHQ1w,6730
-shared/logging_config.py,sha256=XZblKXH9KsLUDbIJqFRZPzI0h17-CRBZH4KktVak-TI,1144
-shared/maths.py,sha256=JjlrgV0INlJG4Zj28ahRkfzcI2Ec4noilrDwX2p82TM,3207
-shared/timestamps.py,sha256=401JkggjW--trNenxkUBEObnWyy9Cd-L3xVpqdbW8Tc,2587
-shared/types.py,sha256=KfuJzjsbMUHFcBaQ6ZXUbuSyFHbHqehgeY73Zt8lqO8,173
-pybinbot-0.1.6.dist-info/METADATA,sha256=LEBxxxJ0TBmDQ77xJpskIZYprx8_5y52oRgDFxsRf60,1358
-pybinbot-0.1.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pybinbot-0.1.6.dist-info/top_level.txt,sha256=rfaU2KRcKvquGQYwN5weorBMzgHpWW4eZlITOQwjRvw,23
-pybinbot-0.1.6.dist-info/RECORD,,

pybinbot-0.1.6.dist-info/top_level.txt

@@ -1,3 +0,0 @@
-models
-pybinbot
-shared