investing-algorithm-framework 3.7.0__py3-none-any.whl → 7.19.15__py3-none-any.whl

investing_algorithm_framework/services/market_data_source_service/market_data_source_service.py

@@ -1,189 +0,0 @@
-from typing import List
-
-from investing_algorithm_framework.domain import MarketService, \
-    MarketDataSource, OHLCVMarketDataSource, TickerMarketDataSource, \
-    OrderBookMarketDataSource, TimeFrame
-from investing_algorithm_framework.services.market_credential_service \
-    import MarketCredentialService
-
-
-class MarketDataSourceService:
-    """
-    This class is responsible for managing the market data sources.
-
-    It is used by the algorithm to get market data from different sources.
-    The MarketDataSourceService will first check if there is a market data
-    source that matches the symbol, market and time frame provided by the user.
-    If there is, it will use that market data source to get the data. If there
-    is not, it will use the MarketService to get the data.
-    """
-    _market_data_sources: List[MarketDataSource] = []
-
-    def __init__(
-        self,
-        market_service: MarketService,
-        market_credential_service: MarketCredentialService,
-        market_data_sources: List[MarketDataSource] = None,
-    ):
-
-        if market_data_sources is not None:
-            self._market_data_sources: List[MarketDataSource] \
-                = market_data_sources
-
-        self._market_service: MarketService = market_service
-        self._market_credential_service: MarketCredentialService = \
-            market_credential_service
-
-    def get_ticker(self, symbol, market=None):
-        ticker_market_data_source = self.get_ticker_market_data_source(
-            symbol=symbol, market=market
-        )
-
-        if ticker_market_data_source is not None:
-            return ticker_market_data_source.get_data(
-                market_credential_service=self._market_credential_service
-            )
-        return self._market_service.get_ticker(symbol, market)
-
-    def get_order_book(self, symbol, market=None):
-        order_book_market_data_source = self.get_order_book_market_data_source(
-            symbol=symbol, market=market
-        )
-
-        if order_book_market_data_source is not None:
-            return order_book_market_data_source.get_data(
-                market_credential_service=self._market_credential_service
-            )
-
-        return self._market_service.get_order_book(symbol, market)
-
-    def get_ohlcv(
-        self,
-        symbol,
-        from_timestamp,
-        time_frame,
-        market=None,
-        to_timestamp=None
-    ):
-        ohlcv_market_data_source = self.get_ohlcv_market_data_source(
-            symbol=symbol, market=market, time_frame=time_frame
-        )
-
-        if ohlcv_market_data_source is not None:
-            return ohlcv_market_data_source.get_data(
-                from_timestamp=from_timestamp,
-                to_timestamp=to_timestamp,
-                market_credential_service=self._market_credential_service
-            )
-
-        return self._market_service.get_ohlcv(
-            symbol=symbol,
-            time_frame=time_frame,
-            from_timestamp=from_timestamp,
-            market=market,
-            to_timestamp=to_timestamp
-        )
-
-    def get_data(self, identifier):
-        for market_data_source in self._market_data_sources:
-            if market_data_source.get_identifier() == identifier:
-                return market_data_source.get_data(
-                    market_credential_service=self._market_credential_service
-                )
-
-    def get_ticker_market_data_source(self, symbol, market=None):
-
-        if self.market_data_sources is not None:
-            for market_data_source in self._market_data_sources:
-                if isinstance(market_data_source, TickerMarketDataSource):
-
-                    if market is not None:
-                        if market_data_source.market.lower() == market.lower()\
-                                and market_data_source.symbol.lower() \
-                                == symbol.lower():
-                            return market_data_source
-                    else:
-                        if market_data_source.symbol.lower() \
-                                == symbol.lower():
-                            return market_data_source
-
-        return None
-
-    def get_ohlcv_market_data_source(
-        self, symbol, time_frame=None, market=None
-    ):
-
-        if time_frame is not None:
-            time_frame = TimeFrame.from_value(time_frame)
-
-        if self.market_data_sources is not None:
-
-            for market_data_source in self._market_data_sources:
-                if isinstance(market_data_source, OHLCVMarketDataSource):
-
-                    if market is not None and time_frame is not None:
-
-                        if market_data_source.market.lower() == market.lower()\
-                                and market_data_source.symbol.lower() \
-                                == symbol.lower() and \
-                                market_data_source.timeframe == time_frame:
-                            return market_data_source
-                    elif market is not None:
-                        if market_data_source.market.lower() == market.lower()\
-                                and market_data_source.symbol.lower() \
-                                == symbol.lower():
-                            return market_data_source
-                    elif time_frame is not None:
-                        if market_data_source.symbol.lower() \
-                                == symbol.lower() and \
-                                market_data_source.timeframe == time_frame:
-                            return market_data_source
-                    else:
-                        if market_data_source.symbol.lower() \
-                                == symbol.lower():
-                            return market_data_source
-
-        return None
-
-    def get_order_book_market_data_source(self, symbol, market=None):
-
-        if self.market_data_sources is not None:
-            for market_data_source in self._market_data_sources:
-                if isinstance(market_data_source, OrderBookMarketDataSource):
-
-                    if market is not None:
-                        if market_data_source.market.lower() == market.lower()\
-                                and market_data_source.symbol.lower() \
-                                == symbol.lower():
-                            return market_data_source
-                    else:
-                        if market_data_source.symbol.lower() \
-                                == symbol.lower():
-                            return market_data_source
-
-        return None
-
-    @property
-    def market_data_sources(self):
-        return self._market_data_sources
-
-    @market_data_sources.setter
-    def market_data_sources(self, market_data_sources):
-        self._market_data_sources = market_data_sources
-
-    def add(self, market_data_source):
-
-        # Check if there is already a market data source with the same
-        # identifier
-        for existing_market_data_source in self._market_data_sources:
-            if existing_market_data_source.get_identifier() == \
-                    market_data_source.get_identifier():
-                return
-
-        self._market_data_sources.append(market_data_source)
-
-    def get_market_data_sources(self):
-        return self._market_data_sources
-
-    def has_ticker_market_data_source(self, symbol, market=None):
-        return self.get_ticker_market_data_source(symbol, market) is not None

investing_algorithm_framework/services/position_service.py

@@ -1,31 +0,0 @@
-from investing_algorithm_framework.domain import MarketService
-from investing_algorithm_framework.services.repository_service import \
-    RepositoryService
-
-
-class PositionService(RepositoryService):
-
-    def __init__(
-        self,
-        repository,
-        order_repository,
-        market_service: MarketService,
-        market_credential_service
-    ):
-        super().__init__(repository)
-        self._market_service: MarketService = market_service
-        self._market_credentials_service = market_credential_service
-        self._order_repository = order_repository
-
-    def close_position(self, position_id, portfolio):
-        self._market_service.market_data_credentials = \
-            self._market_credentials_service.get_all()
-        position = self.get(position_id)
-
-        if position.amount > 0:
-            self._market_service.create_market_sell_order(
-                position.symbol,
-                portfolio.get_trading_symbol(),
-                position.amount,
-                market=portfolio.get_market(),
-            )

investing_algorithm_framework/services/strategy_orchestrator_service.py

@@ -1,264 +0,0 @@
-import logging
-from datetime import datetime
-
-import schedule
-
-from investing_algorithm_framework.domain import StoppableThread, TimeUnit, \
-    OperationalException, MarketDataSource
-from investing_algorithm_framework.services.market_data_source_service \
-    import MarketDataSourceService
-
-logger = logging.getLogger("investing_algorithm_framework")
-
-
-class StrategyOrchestratorService:
-    """
-    Service that orchestrates the execution of strategies and tasks
-
-    Attributes:
-    - history: dict
-        A dictionary that keeps track of the last time a strategy or task was
-        run
-    - _strategies: list
-        A list of strategies
-    - _tasks: list
-        A list of tasks
-    - threads: list
-        A list of threads that are currently running
-    - iterations: int
-        The number of iterations that have been run
-    - max_iterations: int
-        The maximum number of iterations that can be run
-    - market_data_source_service: MarketDataSourceService
-        The service that provides market data
-    """
-
-    def __init__(self, market_data_source_service: MarketDataSourceService):
-        self.history = {}
-        self._strategies = []
-        self._tasks = []
-        self.threads = []
-        self.iterations = 0
-        self.max_iterations = -1
-        self.clear()
-        self.market_data_source_service: MarketDataSourceService \
-            = market_data_source_service
-
-    def cleanup_threads(self):
-
-        for stoppable in self.threads:
-            if not stoppable.is_alive():
-                # get results from thread
-                stoppable.done = True
-        self.threads = [t for t in self.threads if not t.done]
-
-    def run_strategy(self, strategy, algorithm, sync=False):
-        self.cleanup_threads()
-        matching_thread = next(
-            (t for t in self.threads if t.name == strategy.worker_id),
-            None
-        )
-
-        # Don't run a strategy that is already running
-        if matching_thread:
-            return
-
-        market_data = {}
-
-        if strategy.market_data_sources is not None \
-                and len(strategy.market_data_sources) > 0:
-
-            for data_id in strategy.market_data_sources:
-
-                if isinstance(data_id, MarketDataSource):
-                    market_data[data_id.get_identifier()] = \
-                        self.market_data_source_service\
-                            .get_data(identifier=data_id.get_identifier())
-                else:
-                    market_data[data_id] = \
-                        self.market_data_source_service \
-                            .get_data(identifier=data_id)
-
-        logger.info(f"Running strategy {strategy.worker_id}")
-
-        if sync:
-            strategy.run_strategy(
-                market_data=market_data, algorithm=algorithm
-            )
-        else:
-            self.iterations += 1
-            thread = StoppableThread(
-                target=strategy.run_strategy,
-                kwargs={
-                    "market_data": market_data,
-                    "algorithm": algorithm
-                }
-            )
-            thread.name = strategy.worker_id
-            thread.start()
-            self.threads.append(thread)
-
-        self.history[strategy.worker_id] = {"last_run": datetime.utcnow()}
-
-    def run_task(self, task, algorithm, sync=False):
-        self.cleanup_threads()
-
-        matching_thread = next(
-            (t for t in self.threads if t.name == task.worker_id),
-            None
-        )
-
-        # Don't run a strategy that is already running
-        if matching_thread:
-            return
-
-        logger.info(f"Running task {task.worker_id}")
-
-        if sync:
-            task.run(algorithm=algorithm)
-        else:
-            self.iterations += 1
-            thread = StoppableThread(
-                target=task.run,
-                kwargs={"algorithm": algorithm}
-            )
-            thread.name = task.worker_id
-            thread.start()
-            self.threads.append(thread)
-
-        self.history[task.worker_id] = {"last_run": datetime.utcnow()}
-
-    def start(self, algorithm, number_of_iterations=None):
-        """
-        F
-
-        """
-        self.max_iterations = number_of_iterations
-
-        for strategy in self.strategies:
-            if TimeUnit.SECOND.equals(strategy.time_unit):
-                schedule.every(strategy.interval)\
-                    .seconds.do(self.run_strategy, strategy, algorithm)
-            elif TimeUnit.MINUTE.equals(strategy.time_unit):
-                schedule.every(strategy.interval)\
-                    .minutes.do(self.run_strategy, strategy, algorithm)
-            elif TimeUnit.HOUR.equals(strategy.time_unit):
-                schedule.every(strategy.interval)\
-                    .hours.do(self.run_strategy, strategy, algorithm)
-
-        for task in self.tasks:
-            if TimeUnit.SECOND.equals(task.time_unit):
-                schedule.every(task.interval)\
-                    .seconds.do(self.run_task, task, algorithm)
-            elif TimeUnit.MINUTE.equals(task.time_unit):
-                schedule.every(task.interval)\
-                    .minutes.do(self.run_task, task, algorithm)
-            elif TimeUnit.HOUR.equals(task.time_unit):
-                schedule.every(task.interval)\
-                    .hours.do(self.run_task, task, algorithm)
-
-    def stop(self):
-        for thread in self.threads:
-            thread.stop()
-
-        schedule.clear()
-
-    def clear(self):
-        self.threads = []
-        schedule.clear()
-
-    def get_strategies(self, identifiers=None):
-        if identifiers is None:
-            return self.strategies
-
-        strategies = []
-        for strategy in self.strategies:
-            if strategy.worker_id in identifiers:
-                strategies.append(strategy)
-
-        return strategies
-
-    def get_tasks(self):
-        return self._tasks
-
-    def get_jobs(self):
-        return schedule.jobs
-
-    def run_pending_jobs(self):
-        if self.max_iterations is not None and \
-                self.max_iterations != -1 and \
-                self.iterations >= self.max_iterations:
-            self.clear()
-        else:
-            schedule.run_pending()
-
-    def add_strategy(self, strategy):
-
-        if strategy.worker_id not in self._strategies:
-            self._strategies.append(strategy)
-        else:
-            raise OperationalException(
-                "Strategy already exists with the same name"
-            )
-
-    def add_strategies(self, strategies):
-        has_duplicates = False
-
-        for i in range(len(strategies)):
-            for j in range(i + 1, len(strategies)):
-                if strategies[i].worker_id == strategies[j].worker_id:
-                    has_duplicates = True
-                    break
-
-        if has_duplicates:
-            raise OperationalException(
-                "There are duplicate strategies with the same name"
-            )
-
-        self.strategies = strategies
-
-    def add_tasks(self, tasks):
-        has_duplicates = False
-
-        for i in range(len(tasks)):
-            for j in range(i + 1, len(tasks)):
-                if tasks[i].worker_id == tasks[j].worker_id:
-                    has_duplicates = True
-                    break
-
-        if has_duplicates:
-            raise OperationalException(
-                "There are duplicate tasks with the same name"
-            )
-
-        self.tasks = tasks
-
-    @property
-    def strategies(self):
-        return self._strategies
-
-    @strategies.setter
-    def strategies(self, strategies):
-        self._strategies = strategies
-
-    @property
-    def tasks(self):
-        return self._tasks
-
-    @tasks.setter
-    def tasks(self, tasks):
-        self._tasks = tasks
-
-    @property
-    def running(self):
-        if len(self.strategies) == 0 and len(self.tasks) == 0:
-            return False
-
-        if self.max_iterations == -1:
-            return True
-
-        return self.max_iterations is None \
-            or self.iterations < self.max_iterations
-
-    def has_run(self, worker_id):
-        return worker_id in self.history