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

investing_algorithm_framework/app/algorithm.py

@@ -1,410 +0,0 @@
-import logging
-from typing import List
-
-from investing_algorithm_framework.domain import OrderStatus, OrderFee, \
-    Position, Order, Portfolio, OrderType, OrderSide, ApiException
-
-logger = logging.getLogger(__name__)
-
-
-class Algorithm:
-
-    def __init__(
-        self,
-        portfolio_configuration_service,
-        portfolio_service,
-        position_service,
-        order_service,
-        market_service,
-        market_data_service,
-        strategy_orchestrator_service
-    ):
-        self.portfolio_service = portfolio_service
-        self.position_service = position_service
-        self.order_service = order_service
-        self.market_service = market_service
-        self._config = None
-        self.portfolio_configuration_service = portfolio_configuration_service
-        self.strategy_orchestrator_service = strategy_orchestrator_service
-        self.market_data_service = market_data_service
-
-    def start(self, number_of_iterations=None, stateless=False):
-
-        if not stateless:
-            self.strategy_orchestrator_service.start(
-                algorithm=self,
-                number_of_iterations=number_of_iterations
-            )
-
-    @property
-    def config(self):
-        return self._config
-
-    @config.setter
-    def config(self, config):
-        self._config = config
-
-    @property
-    def running(self) -> bool:
-        return self.strategy_orchestrator_service.running
-
-    def run_jobs(self):
-        self.strategy_orchestrator_service.run_pending_jobs()
-
-    def create_order(
-        self,
-        target_symbol,
-        price,
-        type,
-        side,
-        amount,
-        market=None,
-        execute=True,
-        validate=True,
-        sync=True
-    ):
-        portfolio = self.portfolio_service.find({"market": market})
-        return self.order_service.create(
-            {
-                "target_symbol": target_symbol,
-                "price": price,
-                "amount": amount,
-                "type": type,
-                "side": side,
-                "portfolio_id": portfolio.id,
-                "status": OrderStatus.CREATED.value,
-                "trading_symbol": portfolio.trading_symbol,
-            },
-            execute=execute,
-            validate=validate,
-            sync=sync
-        )
-
-    def create_limit_order(
-        self,
-        target_symbol,
-        price,
-        side,
-        amount=None,
-        percentage_of_portfolio=None,
-        percentage_of_position=None,
-        market=None,
-        execute=True,
-        validate=True,
-        sync=True
-    ):
-        portfolio = self.portfolio_service.find({"market": market})
-
-        if percentage_of_portfolio is not None and OrderSide.BUY.equals(side):
-            size = portfolio.net_size * (percentage_of_portfolio / 100)
-            amount = size / price
-
-        if percentage_of_position is not None and OrderSide.SELL.equals(side):
-            position = self.position_service.find(
-                {
-                    "symbol": target_symbol,
-                    "portfolio": portfolio.id
-                }
-            )
-            amount = position.amount * (percentage_of_position / 100)
-
-        return self.order_service.create(
-            {
-                "target_symbol": target_symbol,
-                "price": price,
-                "amount": amount,
-                "type": OrderType.LIMIT.value,
-                "side": OrderSide.from_value(side).value,
-                "portfolio_id": portfolio.id,
-                "status": OrderStatus.CREATED.value,
-                "trading_symbol": portfolio.trading_symbol,
-            },
-            execute=execute,
-            validate=validate,
-            sync=sync
-        )
-
-    def create_market_order(
-        self,
-        target_symbol,
-        side,
-        amount,
-        market=None,
-        execute=False,
-        validate=False,
-        sync=True
-    ):
-        portfolio = self.portfolio_service.find({"market": market})
-        return self.order_service.create(
-            {
-                "target_symbol": target_symbol,
-                "amount": amount,
-                "type": OrderType.MARKET.value,
-                "side": OrderSide.from_value(side).value,
-                "portfolio_id": portfolio.id,
-                "status": OrderStatus.CREATED.value,
-                "trading_symbol": portfolio.trading_symbol,
-            },
-            execute=execute,
-            validate=validate,
-            sync=sync
-        )
-
-    def get_portfolio(self, market=None) -> Portfolio:
-
-        if market is None:
-            return self.portfolio_service.find({})
-
-        return self.portfolio_service.find({{"market": market}})
-
-    def get_unallocated(self, market=None) -> Position:
-
-        if market:
-            portfolio = self.portfolio_service.find({{"market": market}})
-        else:
-            portfolio = self.portfolio_service.find({})
-
-        trading_symbol = portfolio.trading_symbol
-        return self.position_service.find(
-            {"portfolio": portfolio.id, "symbol": trading_symbol}
-        ).amount
-
-    def reset(self):
-        self._workers = []
-        self._running_workers = []
-
-    def get_order(
-        self,
-        reference_id=None,
-        market=None,
-        target_symbol=None,
-        trading_symbol=None,
-        side=None,
-        type=None
-    ) -> Order:
-        query_params = {}
-
-        if reference_id:
-            query_params["reference_id"] = reference_id
-
-        if target_symbol:
-            query_params["target_symbol"] = target_symbol
-
-        if trading_symbol:
-            query_params["trading_symbol"] = trading_symbol
-
-        if side:
-            query_params["side"] = side
-
-        if type:
-            query_params["type"] = type
-
-        if market:
-            portfolio = self.portfolio_service.find({"market": market})
-            positions = self.position_service.get_all(
-                {"portfolio": portfolio.id}
-            )
-            query_params["position"] = [position.id for position in positions]
-
-        return self.order_service.find(query_params)
-
-    def get_orders(
-            self,
-            target_symbol=None,
-            status=None,
-            type=None,
-            side=None,
-            market=None
-    ) -> List[Order]:
-
-        if market is None:
-            portfolio = self.portfolio_service.get_all()[0]
-        else:
-            portfolio = self.portfolio_service.find({"market": market})
-
-        positions = self.position_service.get_all({"portfolio": portfolio.id})
-        return self.order_service.get_all(
-            {
-                "position": [position.id for position in positions],
-                "target_symbol": target_symbol,
-                "status": status,
-                "type": type,
-                "side": side
-            }
-        )
-
-    def get_order_fee(self, order_id) -> OrderFee:
-        return self.order_service.get_order_fee(order_id)
-
-    def get_positions(self, market=None, identifier=None) -> List[Position]:
-        query_params = {}
-
-        if market is not None:
-            query_params["market"] = market
-
-        if identifier is not None:
-            query_params["identifier"] = identifier
-
-        portfolios = self.portfolio_service.get_all(query_params)
-
-        if not portfolios:
-            raise ApiException("No portfolio found.")
-
-        portfolio = portfolios[0]
-        return self.position_service.get_all(
-            {"portfolio": portfolio.id}
-        )
-
-    def get_position(self, symbol, market=None, identifier=None) -> Position:
-        query_params = {}
-
-        if market is not None:
-            query_params["market"] = market
-
-        if identifier is not None:
-            query_params["identifier"] = identifier
-
-        portfolios = self.portfolio_service.get_all(query_params)
-
-        if not portfolios:
-            raise ApiException("No portfolio found.")
-
-        portfolio = portfolios[0]
-
-        try:
-            return self.position_service.find(
-                {"portfolio": portfolio.id, "symbol": symbol}
-            )
-        except ApiException:
-            return None
-
-    def position_exists(self, symbol, market=None, identifier=None) -> bool:
-        query_params = {}
-
-        if market is not None:
-            query_params["market"] = market
-
-        if identifier is not None:
-            query_params["identifier"] = identifier
-
-        query_params["symbol"] = symbol
-        return self.position_service.exists(query_params)
-
-    def get_position_percentage(
-            self, symbol, market=None, identifier=None
-    ) -> float:
-        query_params = {}
-
-        if market is not None:
-            query_params["market"] = market
-
-        if identifier is not None:
-            query_params["identifier"] = identifier
-
-        portfolios = self.portfolio_service.get_all(query_params)
-
-        if not portfolios:
-            raise ApiException("No portfolio found.")
-
-        portfolio = portfolios[0]
-        position = self.position_service.find(
-            {"portfolio": portfolio.id, "symbol": symbol}
-        )
-        ticker = self.market_service.get_ticker(
-            f"{symbol.upper()}/{portfolio.trading_symbol.upper()}"
-        )
-        return (position.amount * ticker["bid"] /
-                self.get_allocated(identifier=portfolio.identifier)) * 100
-
-    def close_position(self, symbol, market=None, identifier=None):
-        query_params = {}
-
-        if market is not None:
-            query_params["market"] = market
-
-        if identifier is not None:
-            query_params["identifier"] = identifier
-
-        position = self.get_position(symbol, market, identifier)
-
-        if position is None:
-            raise ApiException("No position found.")
-
-        if position.amount == 0:
-            return
-
-        for order in self.order_service\
-                .get_all({
-                    "position": position.id, "status": OrderStatus.OPEN.value
-                }):
-            self.order_service.cancel_order(order.id)
-
-        portfolio = self.portfolio_service.find({"position": position.id})
-        self.market_service.market = portfolio.market
-        ticker = self.market_service.get_ticker(
-            symbol=f"{symbol.upper()}/{portfolio.trading_symbol.upper()}"
-        )
-        self.create_limit_order(
-            target_symbol=position.symbol,
-            amount=position.amount,
-            side=OrderSide.SELL.value,
-            price=ticker["bid"],
-        )
-
-    def add_strategies(self, strategies):
-        self.strategy_orchestrator_service.add_strategies(strategies)
-
-    def add_tasks(self, tasks):
-        self.strategy_orchestrator_service.add_tasks(tasks)
-
-    def get_allocated(self, market=None, identifier=None) -> float:
-
-        if self.portfolio_configuration_service.count() > 1 \
-                and identifier is None and market is None:
-            raise ApiException(
-                "Multiple portfolios found. Please specify a "
-                "portfolio identifier."
-            )
-
-        if market is not None and identifier is not None:
-            portfolio_configurations = self.portfolio_configuration_service\
-                .get_all()
-
-        else:
-            query_params = {
-                "market": market,
-                "identifier": identifier
-            }
-            portfolio_configurations = [self.portfolio_configuration_service
-                                        .find(query_params)]
-
-        portfolios = []
-
-        for portfolio_configuration in portfolio_configurations:
-            portfolio = self.portfolio_service.find(
-                {"identifier": portfolio_configuration.identifier}
-            )
-            portfolio.configuration = portfolio_configuration
-            portfolios.append(portfolio)
-
-        allocated = 0
-
-        for portfolio in portfolios:
-            positions = self.position_service.get_all(
-                {"portfolio": portfolio.id}
-            )
-
-            for position in positions:
-                if portfolio.trading_symbol == position.symbol:
-                    continue
-
-                symbol = f"{position.symbol.upper()}/" \
-                         f"{portfolio.trading_symbol.upper()}"
-                self.market_service.initialize(portfolio.configuration)
-                price = self.market_service.get_ticker(symbol)
-                allocated = allocated + (position.amount * price["bid"])
-
-        return allocated
-
-    def get_portfolio_configurations(self):
-        return self.portfolio_configuration_service.get_all()

investing_algorithm_framework/domain/models/market_data/__init__.py

@@ -1,11 +0,0 @@
-from .order_book import OrderBook
-from .ticker import Ticker
-from .ohlcv import OHLCV
-from .asset_price import AssetPrice
-
-__all__ = [
-    "Ticker",
-    "OrderBook",
-    "OHLCV",
-    "AssetPrice"
-]

investing_algorithm_framework/domain/models/market_data/asset_price.py

@@ -1,50 +0,0 @@
-from datetime import datetime
-
-
-class AssetPrice:
-
-    def __init__(self, symbol, price, datetime):
-        self.symbol = symbol
-        self.price = price
-        self.datetime = datetime
-
-    def get_symbol(self):
-        return self.symbol
-
-    def get_price(self):
-
-        if self.price is None:
-            return 0
-
-        return self.price
-
-    def get_datetime(self):
-
-        if self.datetime is None:
-            return datetime.utcnow()
-
-        return self.datetime
-
-    def repr(self, **fields) -> str:
-        """
-        Helper for __repr__
-        """
-
-        field_strings = []
-        at_least_one_attached_attribute = False
-
-        for key, field in fields.items():
-            field_strings.append(f'{key}={field!r}')
-            at_least_one_attached_attribute = True
-
-        if at_least_one_attached_attribute:
-            return f"<{self.__class__.__name__}({','.join(field_strings)})>"
-
-        return f"<{self.__class__.__name__} {id(self)}>"
-
-    def __repr__(self):
-        return self.repr(
-            symbol=self.get_symbol(),
-            price=self.price,
-            datetime=self.datetime
-        )

investing_algorithm_framework/domain/models/market_data/ohlcv.py

@@ -1,76 +0,0 @@
-from datetime import datetime
-
-import pandas as pd
-
-
-class OHLCV:
-    DEFAULT_DATETIME_STRING = "%Y-%m-%dT%H:%M:%S.%f%z"
-    COLUMNS = ["open", "high", "low", "close", "volume"]
-
-    def __init__(self, symbol, data):
-        self.symbol = symbol
-        self.target_symbol = symbol.split("/")[0]
-        self.trading_symbol = symbol.split("/")[1]
-        self.data = data
-
-    def get_symbol(self):
-        return self.symbol
-
-    def get_target_symbol(self):
-        return self.target_symbol
-
-    def get_trading_symbol(self):
-        return self.trading_symbol
-
-    def get_data(self):
-        return self.data
-
-    def to_dict(self, date_format="%Y-%m-%d-%H:%M:%S"):
-        dict_data = {}
-
-        for column in self.COLUMNS:
-            dict_data[column] = []
-
-        for row in self.get_data():
-            date = datetime.strptime(row[0], self.DEFAULT_DATETIME_STRING)
-            date = date.strftime(date_format)
-            dict_data["open"].append(date)
-            dict_data["high"].append(row[1])
-            dict_data["low"].append(row[2])
-            dict_data["close"].append(row[3])
-            dict_data["volume"].append(row[4])
-
-        return dict_data
-
-    @staticmethod
-    def from_dict(data):
-        return OHLCV(
-            symbol=data.get("symbol"),
-            data=data.get("data"),
-        )
-
-    def repr(self, **fields) -> str:
-        """
-        Helper for __repr__
-        """
-
-        field_strings = []
-        at_least_one_attached_attribute = False
-
-        for key, field in fields.items():
-            field_strings.append(f'{key}={field!r}')
-            at_least_one_attached_attribute = True
-
-        if at_least_one_attached_attribute:
-            return f"<{self.__class__.__name__}({','.join(field_strings)})>"
-
-        return f"<{self.__class__.__name__} {id(self)}>"
-
-    def __repr__(self):
-        return self.repr(
-            symbol=self.get_symbol(),
-            data=self.get_data()
-        )
-
-    def to_df(self):
-        return pd.DataFrame(self.get_data(), columns=self.COLUMNS)

investing_algorithm_framework/domain/models/market_data/order_book.py

@@ -1,63 +0,0 @@
-from datetime import datetime
-from typing import List
-
-
-class OrderBook:
-
-    def __init__(self, symbol, bids: List, asks: List, creation_date=None):
-        self.symbol = symbol
-        self.bids = bids
-        self.asks = asks
-
-        if creation_date is None:
-            self.creation_date = datetime.now()
-
-    def get_bids(self):
-        return self.bids
-
-    def get_asks(self):
-        return self.asks
-
-    def get_symbol(self):
-        return self.symbol
-
-    def to_dict(self):
-
-        return {
-            "symbol": self.symbol,
-            "bids": self.bids,
-            "asks": self.asks
-        }
-
-    @staticmethod
-    def from_dict(data):
-        return OrderBook(
-            data.get("symbol"),
-            data.get("bids"),
-            data.get("asks"),
-            data.get("creation_date")
-        )
-
-    def repr(self, **fields) -> str:
-        """
-        Helper for __repr__
-        """
-
-        field_strings = []
-        at_least_one_attached_attribute = False
-
-        for key, field in fields.items():
-            field_strings.append(f'{key}={field!r}')
-            at_least_one_attached_attribute = True
-
-        if at_least_one_attached_attribute:
-            return f"<{self.__class__.__name__}({','.join(field_strings)})>"
-
-        return f"<{self.__class__.__name__} {id(self)}>"
-
-    def __repr__(self):
-        return self.repr(
-            symbol=self.symbol,
-            bids=self.bids,
-            asks=self.asks
-        )

investing_algorithm_framework/domain/models/market_data/ticker.py

@@ -1,92 +0,0 @@
-from datetime import datetime
-
-
-class Ticker:
-
-    def __init__(
-            self,
-            symbol,
-            price,
-            ask_price=None,
-            ask_volume=None,
-            bid_price=None,
-            bid_volume=None,
-            high_price=None,
-            low_price=None,
-            creation_date=None
-    ):
-        self.symbol = symbol
-        self.price = price
-        self.ask_price = ask_price
-        self.ask_volume = ask_volume
-        self.bid_price = bid_price
-        self.bid_volume = bid_volume
-        self.high_price = high_price
-        self.low_price = low_price
-
-        if creation_date is None:
-            self.creation_date = datetime.now()
-
-    def get_price(self):
-        return self.price
-
-    def get_creation_date(self):
-        return self.creation_date
-
-    def get_symbol(self):
-        return self.symbol
-
-    def to_dict(self):
-        return {
-            "symbol": self.symbol,
-            "price": self.price,
-            "ask_price": self.ask_price,
-            "ask_volume": self.ask_volume,
-            "bid_price": self.bid_price,
-            "bid_volume": self.bid_volume,
-            "high_price": self.high_price,
-            "low_price": self.low_price
-        }
-
-    @staticmethod
-    def from_dict(data):
-        return Ticker(
-            symbol=data.get("symbol"),
-            price=data.get("price"),
-            ask_price=data.get("ask_price"),
-            ask_volume=data.get("ask_volume"),
-            bid_price=data.get("bid_price"),
-            bid_volume=data.get("bid_volume"),
-            high_price=data.get("high_price"),
-            low_price=data.get("low_price"),
-            creation_date=data.get("creation_date")
-        )
-
-    def repr(self, **fields) -> str:
-        """
-        Helper for __repr__
-        """
-
-        field_strings = []
-        at_least_one_attached_attribute = False
-
-        for key, field in fields.items():
-            field_strings.append(f'{key}={field!r}')
-            at_least_one_attached_attribute = True
-
-        if at_least_one_attached_attribute:
-            return f"<{self.__class__.__name__}({','.join(field_strings)})>"
-
-        return f"<{self.__class__.__name__} {id(self)}>"
-
-    def __repr__(self):
-        return self.repr(
-            symbol=self.symbol,
-            price=self.price,
-            ask_price=self.ask_price,
-            ask_volume=self.ask_volume,
-            bid_price=self.bid_price,
-            bid_volume=self.bid_volume,
-            high_price=self.high_price,
-            low_price=self.low_price
-        )