investing-algorithm-framework 1.5__py3-none-any.whl → 7.25.6__py3-none-any.whl

investing_algorithm_framework/infrastructure/services/market_service.py

@@ -1,410 +0,0 @@
-import logging
-from datetime import datetime
-from time import sleep
-
-import ccxt
-
-from investing_algorithm_framework.domain import OperationalException, \
-    OHLCV, AssetPrice, Order, CCXT_DATETIME_FORMAT
-
-logger = logging.getLogger("investing_algorithm_framework")
-
-
-class MarketService:
-    exchange = None
-    _market = None
-    api_key = None,
-    secret_key = None
-    exchange_class = None
-    msec = 1000
-    minute = 60 * msec
-
-    @property
-    def market(self):
-        return self._market
-
-    @market.setter
-    def market(self, value):
-
-        if not isinstance(value, str):
-            raise OperationalException("Market must be a string")
-
-        self._market = value.lower()
-
-        if not hasattr(ccxt, self._market):
-            raise OperationalException(
-                f"No market service found for market id {self._market}"
-            )
-
-        self.exchange_class = getattr(ccxt, self._market)
-        self.exchange = self.exchange_class()
-
-    def initialize(self, portfolio_configuration):
-        self.api_key = portfolio_configuration.api_key
-        self.secret_key = portfolio_configuration.secret_key
-        self._market = portfolio_configuration.market
-
-        if not hasattr(ccxt, self.market):
-            raise OperationalException(
-                f"No market service found for market id {self.market}"
-            )
-
-        self.exchange_class = getattr(ccxt, self.market)
-
-        if self.exchange_class is None:
-            raise OperationalException(
-                f"No market service found for market id {self.market}"
-            )
-
-        if self.api_key is not None or self.secret_key is not None:
-            self.exchange = self.exchange_class({
-                'apiKey': self.api_key,
-                'secret': self.secret_key,
-            })
-        else:
-            self.exchange = self.exchange_class({})
-
-    def pair_exists(self, target_symbol: str, trading_symbol: str):
-
-        if not self.exchange.has['fetchTicker']:
-            raise OperationalException(
-                f"Market service {self.market} does not support "
-                f"functionality pair_exists"
-            )
-
-        try:
-            data = self.get_ticker(f"{target_symbol}/{trading_symbol}")
-            return "symbol" in data
-        except OperationalException:
-            return False
-
-    def get_ticker(self, symbol):
-
-        if not self.exchange.has['fetchTicker']:
-            raise OperationalException(
-                f"Market service {self.market} does not support "
-                f"functionality get_ticker"
-            )
-
-        try:
-            return self.exchange.fetchTicker(symbol)
-        except Exception as e:
-            logger.exception(e)
-            raise OperationalException(
-                f"Could not retrieve ticker for symbol {symbol}"
-            )
-
-    def get_tickers(self, symbols):
-
-        if not self.exchange.has['fetchTickers']:
-            raise OperationalException(
-                f"Market service {self.market} does not support "
-                f"functionality get_tickers"
-            )
-
-        try:
-            return self.exchange.fetchTickers(symbols)
-        except Exception as e:
-            logger.exception(e)
-            raise OperationalException(
-                "Could not retrieve selection of tickers"
-            )
-
-    def get_order_book(self, symbol):
-
-        if not self.exchange.has['fetchOrderBook']:
-            raise OperationalException(
-                f"Market service {self.market} does not support "
-                f"functionality get_order_book"
-            )
-
-        try:
-            return self.exchange.fetchOrderBook(symbol)
-        except Exception as e:
-            logger.exception(e)
-            raise OperationalException("Could not retrieve order book")
-
-    def get_order_books(self, symbols):
-        data = {}
-
-        for symbol in symbols:
-            try:
-                entry = self.get_order_book(symbol)
-                del entry['symbol']
-                data[symbol] = entry
-            except Exception as e:
-                logger.exception(e)
-
-        return data
-
-    def get_order(self, order):
-        symbol = f"{order.target_symbol.upper()}/" \
-                 f"{order.trading_symbol.upper()}"
-
-        if not self.exchange.has['fetchOrder']:
-            raise OperationalException(
-                f"Market service {self.market} does not support "
-                f"functionality get_order"
-            )
-
-        try:
-            order = self.exchange.fetchOrder(order.external_id, symbol)
-            return Order.from_ccxt_order(order)
-        except Exception as e:
-            logger.exception(e)
-            raise OperationalException("Could not retrieve order")
-
-    def get_orders(self, symbol, since: datetime = None):
-
-        if not self.exchange.has['fetchOrders']:
-            raise OperationalException(
-                f"Market service {self.market} does not support "
-                f"functionality get_orders"
-            )
-
-        if since is not None:
-            since = self.exchange.parse8601(
-                since.strftime(":%Y-%m-%d %H:%M:%S")
-            )
-
-            try:
-                ccxt_orders = self.exchange.fetchOrders(symbol, since=since)
-                return [Order.from_ccxt_order(order) for order in ccxt_orders]
-            except Exception as e:
-                logger.exception(e)
-                raise OperationalException("Could not retrieve orders")
-        else:
-            try:
-                ccxt_orders = self.exchange.fetchOrders(symbol)
-                return [Order.from_ccxt_order(order) for order in ccxt_orders]
-            except Exception as e:
-                logger.exception(e)
-                raise OperationalException("Could not retrieve orders")
-
-    def get_balance(self):
-
-        if not self.exchange.has['fetchBalance']:
-            raise OperationalException(
-                f"Market service {self.market} does not support "
-                f"functionality get_balance"
-            )
-
-        try:
-            return self.exchange.fetchBalance()
-        except Exception as e:
-            logger.exception(e)
-            raise OperationalException("Could not retrieve balance")
-
-    def create_limit_buy_order(
-        self,
-        target_symbol: str,
-        trading_symbol: str,
-        amount: float,
-        price: float
-    ):
-
-        if not self.exchange.has['createLimitBuyOrder']:
-            raise OperationalException(
-                f"Market service {self.market} does not support "
-                f"functionality create_limit_buy_order"
-            )
-
-        symbol = f"{target_symbol.upper()}/{trading_symbol.upper()}"
-
-        try:
-            order = self.exchange.createLimitBuyOrder(
-                symbol, amount, price
-            )
-            return Order.from_ccxt_order(order)
-        except Exception as e:
-            logger.exception(e)
-            raise OperationalException("Could not create limit buy order")
-
-    def create_limit_sell_order(
-        self,
-        target_symbol: str,
-        trading_symbol: str,
-        amount: float,
-        price: float
-    ):
-
-        if not self.exchange.has['createLimitSellOrder']:
-            raise OperationalException(
-                f"Market service {self.market} does not support "
-                f"functionality create_limit_sell_order"
-            )
-
-        symbol = f"{target_symbol.upper()}/{trading_symbol.upper()}"
-
-        try:
-            order = self.exchange.createLimitSellOrder(
-                symbol, amount, price
-            )
-            return Order.from_ccxt_order(order)
-        except Exception as e:
-            logger.exception(e)
-            raise OperationalException("Could not create limit sell order")
-
-    def create_market_sell_order(
-        self,
-        target_symbol: str,
-        trading_symbol: str,
-        amount: float,
-    ):
-
-        if not self.exchange.has['createMarketSellOrder']:
-            raise OperationalException(
-                f"Market service {self.market} does not support "
-                f"functionality create_market_sell_order"
-            )
-
-        symbol = f"{target_symbol.upper()}/{trading_symbol.upper()}"
-
-        try:
-            order = self.exchange.createMarketSellOrder(symbol, amount)
-            return Order.from_ccxt_order(order)
-        except Exception as e:
-            logger.exception(e)
-            raise OperationalException("Could not create market sell order")
-
-    def cancel_order(self, order):
-        if not self.exchange.has['cancelOrder']:
-            raise OperationalException(
-                f"Market service {self.market} does not support "
-                f"functionality cancel_order"
-            )
-
-        self.exchange.cancelOrder(
-            order.get_order_reference(),
-            f"{order.get_target_symbol()}/{order.get_trading_symbol()}")
-
-    def get_open_orders(
-        self, target_symbol: str = None, trading_symbol: str = None
-    ):
-
-        if not self.exchange.has['fetchOpenOrders']:
-            raise OperationalException(
-                f"Market service {self.market} does not support "
-                f"functionality get_open_orders"
-            )
-
-        try:
-            if target_symbol is None or trading_symbol is None:
-                return self.exchange.fetchOpenOrders()
-
-            symbol = f"{target_symbol.upper()}/{trading_symbol.upper()}"
-            ccxt_orders = self.exchange.fetchOpenOrders(symbol)
-            return [Order.from_ccxt_order(order) for order in ccxt_orders]
-        except Exception as e:
-            logger.exception(e)
-            raise OperationalException("Could not retrieve open orders")
-
-    def get_closed_orders(
-        self, target_symbol: str = None, trading_symbol: str = None
-    ):
-
-        if not self.exchange.has['fetchClosedOrders']:
-            raise OperationalException(
-                f"Market service {self.market} does not support "
-                f"functionality get_closed_orders"
-            )
-
-        try:
-            if target_symbol is None or trading_symbol is None:
-                return self.exchange.fetchClosedOrders()
-
-            symbol = f"{target_symbol.upper()}/{trading_symbol.upper()}"
-            ccxt_orders = self.exchange.fetchClosedOrders(symbol)
-            return [Order.from_ccxt_order(order) for order in ccxt_orders]
-        except Exception as e:
-            logger.exception(e)
-            raise OperationalException("Could not retrieve closed orders")
-
-    def get_prices(self, symbols):
-        asset_prices = []
-
-        try:
-            tickers = self.exchange.fetchTickers(symbols)
-            for ticker in tickers:
-                asset_prices.append(
-                    AssetPrice(
-                        tickers[ticker]["symbol"],
-                        tickers[ticker]["ask"],
-                        tickers[ticker]["datetime"]
-                    )
-                )
-
-            return asset_prices
-        except Exception as e:
-            logger.exception(e)
-            raise OperationalException("Could not retrieve prices")
-
-    def get_ohclv(self, symbol, time_frame, from_timestamp, to_timestamp=None):
-
-        if not self.exchange.has['fetchOHLCV']:
-            raise OperationalException(
-                f"Market service {self.market} does not support "
-                f"functionality get_ohclvs"
-            )
-
-        time_stamp = self.exchange.parse8601(
-            from_timestamp.strftime(CCXT_DATETIME_FORMAT)
-        )
-
-        if to_timestamp is None:
-            to_timestamp = self.exchange.milliseconds()
-        else:
-            to_timestamp = self.exchange.parse8601(
-                to_timestamp.strftime(CCXT_DATETIME_FORMAT)
-            )
-        data = []
-
-        while time_stamp < to_timestamp:
-            ohlcv = self.exchange.fetch_ohlcv(
-                symbol, time_frame.to_ccxt_string(), time_stamp
-            )
-
-            if len(ohlcv) > 0:
-                time_stamp = \
-                    ohlcv[-1][0] + \
-                    self.exchange.parse_timeframe(
-                        time_frame.to_ccxt_string()
-                    ) * 1000
-            else:
-                time_stamp = to_timestamp
-
-            for candle in ohlcv:
-                datetime_stamp = datetime.strptime(
-                    self.exchange.iso8601(candle[0]), CCXT_DATETIME_FORMAT
-                )
-                to_timestamp_datetime = datetime.strptime(
-                    self.exchange.iso8601(to_timestamp), CCXT_DATETIME_FORMAT
-                )
-
-                if datetime_stamp < to_timestamp_datetime:
-                    data.append([datetime_stamp] + candle[1:])
-
-            sleep(self.exchange.rateLimit / 1000)
-
-        return data
-
-    def get_ohclvs(
-        self,
-        symbols,
-        time_frame,
-        from_timestamp,
-        to_timestamp=None
-    ):
-        ohlcvs = {}
-
-        for symbol in symbols:
-
-            try:
-                ohlcvs[symbol] = self.get_ohclv(
-                    symbol, time_frame, from_timestamp, to_timestamp
-                )
-            except Exception as e:
-                logger.exception(e)
-                logger.error(f"Could not retrieve ohclv data for {symbol}")
-
-        return ohlcvs

investing_algorithm_framework/infrastructure/services/performance_service.py

@@ -1,192 +0,0 @@
-from investing_algorithm_framework.domain import OrderStatus, OrderSide
-
-
-class PerformanceService:
-
-    def __init__(
-        self,
-        order_repository,
-        position_repository,
-        portfolio_repository,
-    ):
-        self.order_repository = order_repository
-        self.position_repository = position_repository
-        self.portfolio_repository = portfolio_repository
-
-    def get_total_net_gain(self, portfolio_id):
-        pass
-
-    def get_total_size(self, portfolio_id):
-        pass
-
-    def get_percentage_change(self, portfolio_id, time_frame):
-        pass
-
-    def get_total_cost(self, portfolio_id):
-        pass
-
-    def get_number_of_trades_closed(self, portfolio_id):
-        portfolio = self.portfolio_repository.find({"id": portfolio_id})
-        number_of_trades_closed = 0
-        orders = self.order_repository.get_all(
-            {
-                "portfolio_id": portfolio.id,
-                "order_side": OrderSide.BUY.value,
-            }
-        )
-
-        for order in orders:
-            if order.get_trade_closed_at() is not None:
-                number_of_trades_closed += 1
-
-        return number_of_trades_closed
-
-    def get_number_of_trades_open(self, portfolio_id):
-        portfolio = self.portfolio_repository.find({"id": portfolio_id})
-        number_of_trades_open = 0
-        orders = self.order_repository.get_all(
-            {
-                "portfolio_id": portfolio.id,
-                "order_side": OrderSide.BUY.value,
-            }
-        )
-
-        for order in orders:
-            if order.get_trade_closed_at() is None:
-                number_of_trades_open += 1
-
-        return number_of_trades_open
-
-    def get_percentage_positive_trades(self, portfolio_id):
-        portfolio = self.portfolio_repository.find({"id": portfolio_id})
-        orders = self.order_repository.get_all(
-            {"portfolio_id": portfolio.id, "status": OrderStatus.CLOSED.value}
-        )
-        total_number_of_orders = len(orders)
-
-        if total_number_of_orders == 0:
-            return 0.0
-
-        positive_orders = [
-            order for order in orders if order.get_net_gain() > 0
-        ]
-        total_number_of_positive_orders = len(positive_orders)
-        return total_number_of_positive_orders / total_number_of_orders * 100
-
-    def get_percentage_negative_trades(self, portfolio_id):
-        portfolio = self.portfolio_repository.find({"id": portfolio_id})
-        orders = self.order_repository.get_all(
-            {"portfolio_id": portfolio.id, "status": OrderStatus.CLOSED.value}
-        )
-        total_number_of_orders = len(orders)
-
-        if total_number_of_orders == 0:
-            return 0.0
-
-        negative_orders = [
-            order for order in orders if order.get_net_gain() < 0
-        ]
-        total_number_of_negative_orders = len(negative_orders)
-        return total_number_of_negative_orders / total_number_of_orders * 100
-
-    def get_growth_rate_of_backtest(self, portfolio_id, tickers, backtest_profile):
-        portfolio = self.portfolio_repository.find({"id": portfolio_id})
-        positions = self.position_repository.get_all(
-            {"portfolio_id": portfolio.id}
-        )
-        allocated = 0
-
-        for position in positions:
-
-            if position.symbol == portfolio.trading_symbol:
-                continue
-
-            allocated += position.amount * tickers[position.symbol]["bid"]
-
-        current_total_value = allocated + portfolio.unallocated
-        gain = current_total_value - backtest_profile.initial_unallocated
-        return gain / backtest_profile.initial_unallocated * 100
-
-    def get_growth_of_backtest(self, portfolio_id, tickers, backtest_profile):
-        portfolio = self.portfolio_repository.find({"id": portfolio_id})
-        positions = self.position_repository.get_all(
-            {"portfolio_id": portfolio.id}
-        )
-        allocated = 0
-
-        for position in positions:
-
-            if position.symbol == portfolio.trading_symbol:
-                continue
-
-            allocated += position.amount * tickers[position.symbol]["bid"]
-
-        current_total_value = allocated + portfolio.unallocated
-        return current_total_value - backtest_profile.initial_unallocated
-
-    def get_total_net_gain_percentage_of_backtest(self, portfolio_id, backtest_profile):
-        portfolio = self.portfolio_repository.find({"id": portfolio_id})
-        return portfolio.total_net_gain \
-               / backtest_profile.initial_unallocated * 100
-
-    def get_total_value(self, portfolio_id, tickers, backtest_profile):
-        portfolio = self.portfolio_repository.find({"id": portfolio_id})
-        positions = self.position_repository.get_all(
-            {"portfolio_id": portfolio.id}
-        )
-        allocated = 0
-
-        for position in positions:
-
-            if position.symbol == portfolio.trading_symbol:
-                continue
-
-            allocated += position.amount * tickers[position.symbol]["bid"]
-
-        return allocated + portfolio.unallocated
-
-    def get_average_trade_duration(self, portfolio_id):
-        portfolio = self.portfolio_repository.find({"id": portfolio_id})
-        buy_orders = self.order_repository.get_all(
-            {
-                "portfolio_id": portfolio.id,
-                "order_side": OrderSide.BUY.value,
-            }
-        )
-        buy_orders_with_trade_closed = [
-            order for order in buy_orders if order.get_trade_closed_at() != None
-        ]
-
-        if len(buy_orders_with_trade_closed) == 0:
-            return 0
-
-        total_duration = 0
-
-        for order in buy_orders_with_trade_closed:
-            duration = order.get_trade_closed_at() - order.get_created_at()
-            total_duration += duration.total_seconds() / 3600
-
-        return total_duration / len(buy_orders_with_trade_closed)
-
-    def get_average_trade_size(self, portfolio_id):
-        portfolio = self.portfolio_repository.find({"id": portfolio_id})
-        buy_orders = self.order_repository.get_all(
-            {
-                "portfolio_id": portfolio.id,
-                "order_side": OrderSide.BUY.value,
-            }
-        )
-        closed_buy_orders = [
-            order for order in buy_orders
-            if order.get_trade_closed_at() != None
-        ]
-
-        if len(closed_buy_orders) == 0:
-            return 0
-
-        total_size = 0
-
-        for order in closed_buy_orders:
-            total_size += order.get_amount() * order.get_price()
-
-        return total_size / len(closed_buy_orders)