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

investing_algorithm_framework/services/portfolio_service.py

@@ -1,164 +0,0 @@
-import logging
-from datetime import datetime
-
-from investing_algorithm_framework.domain import OrderSide, OrderStatus
-from investing_algorithm_framework.services.repository_service \
-    import RepositoryService
-
-logger = logging.getLogger("investing_algorithm_framework")
-
-
-class PortfolioService(RepositoryService):
-
-    def __init__(
-        self,
-        market_service,
-        position_repository,
-        order_service,
-        portfolio_repository,
-        portfolio_configuration_service,
-        portfolio_snapshot_service
-    ):
-        self.market_service = market_service
-        self.position_repository = position_repository
-        self.portfolio_configuration_service = portfolio_configuration_service
-        self.order_service = order_service
-        self.portfolio_snapshot_service = portfolio_snapshot_service
-        super(PortfolioService, self).__init__(portfolio_repository)
-
-    def find(self, query_params):
-        portfolio = self.repository.find(query_params)
-        portfolio_configuration = self.portfolio_configuration_service\
-            .get(portfolio.identifier)
-        portfolio.configuration = portfolio_configuration
-        return portfolio
-
-    def create(self, data):
-        unallocated = data.get("unallocated", 0)
-        portfolio = super(PortfolioService, self).create(data)
-        self.position_repository.create(
-            {
-                "symbol": portfolio.get_trading_symbol(),
-                "amount": unallocated,
-                "portfolio_id": portfolio.id,
-                "cost": unallocated
-            }
-        )
-        self.create_snapshot(portfolio.id, created_at=portfolio.created_at)
-        return portfolio
-
-    def sync_portfolios(self):
-
-        for portfolio in self.get_all():
-            portfolio_configuration = self.portfolio_configuration_service\
-                .get(portfolio.identifier)
-
-            self.market_service.initialize(portfolio_configuration)
-            balances = self.market_service.get_balance()
-
-            for symbol in balances:
-                logger.info(f"Syncing {symbol} balance")
-                logger.info(f"Balance: {balances[symbol]}")
-
-                if "free" in balances[symbol]:
-
-                    if self.position_repository.exists(
-                        {"portfolio_id": portfolio.id, "symbol": symbol}
-                    ):
-                        position = self.position_repository.find(
-                            {
-                                "portfolio_id": portfolio.id,
-                                "symbol": symbol
-                            }
-                        )
-                        self.position_repository.update(
-                            position.id,
-                            {"amount": balances[symbol]["free"]}
-                        )
-                    else:
-                        self.position_repository.create(
-                            {
-                                "symbol": symbol,
-                                "amount": balances[symbol]["free"],
-                                "portfolio_id": portfolio.id
-                            }
-                        )
-
-                    if symbol == portfolio.trading_symbol:
-                        if portfolio.unallocated != balances[symbol]["free"]:
-                            logger.info(
-                                "Updating unallocated balance "
-                                f"from {portfolio.unallocated} "
-                                f"to {balances[symbol]['free']}"
-                            )
-                            difference = balances[symbol]["free"] \
-                                         - portfolio.get_unallocated()
-                            self.update(
-                                portfolio.id,
-                                {
-                                    "unallocated": portfolio.get_unallocated() + difference,
-                                    "net_size": portfolio.get_net_size() + difference
-                                }
-                            )
-
-
-            for position in self.position_repository.get_all(
-                {"portfolio_id": portfolio.id}
-            ):
-                if position.symbol == portfolio.trading_symbol:
-                    continue
-
-                logger.info(f"Syncing {position.symbol} orders")
-
-                external_orders = self.market_service\
-                    .get_orders(
-                        f"{position.symbol}/{portfolio.trading_symbol}",
-                        since=portfolio_configuration.track_from
-                    )
-
-                logger.info(
-                    f"Found {len(external_orders)} external orders "
-                    f"for position {position.symbol}"
-                )
-
-                for external_order in external_orders:
-
-                    if self.order_service.exists(
-                        {"external_id": external_order.external_id}
-                    ):
-                        logger.info("Updating existing order")
-                        order = self.order_service.find(
-                            {"external_id": external_order.external_id}
-                        )
-                        self.order_service.update(
-                            order.id, external_order.to_dict()
-                        )
-                    else:
-                        logger.info(
-                            "Creating new order based on external order"
-                        )
-                        data = external_order.to_dict()
-                        data["position_id"] = position.id
-                        data["portfolio_id"] = portfolio.id
-                        self.order_service.create(
-                            data, execute=False, validate=False, sync=False
-                        )
-
-    def create_snapshot(self, portfolio_id, created_at=None):
-
-        if created_at is None:
-            created_at = datetime.utcnow()
-
-        portfolio = self.get(portfolio_id)
-        pending_orders = self.order_service.get_all(
-            {
-                "order_side": OrderSide.BUY.value,
-                "status": OrderStatus.OPEN.value,
-                "portfolio_id": portfolio.id
-            }
-        )
-        return self.portfolio_snapshot_service.create_snapshot(
-            portfolio,
-            pending_orders=pending_orders,
-            created_at=created_at
-        )

investing_algorithm_framework/services/portfolio_snapshot_service.py

@@ -1,68 +0,0 @@
-from datetime import datetime
-
-from investing_algorithm_framework.services.repository_service import \
-    RepositoryService
-from investing_algorithm_framework.domain import parse_decimal_to_string
-
-
-class PortfolioSnapshotService(RepositoryService):
-
-    def __init__(
-        self,
-        repository,
-        position_repository,
-        position_snapshot_service
-    ):
-        self.position_snapshot_service = position_snapshot_service
-        self.position_repository = position_repository
-        super(PortfolioSnapshotService, self).__init__(repository)
-
-    def create_snapshot(
-        self,
-        portfolio,
-        pending_orders=None,
-        created_orders=None,
-        created_at=None,
-        cash_flow=0
-    ):
-        pending_value = 0
-
-        if created_orders is not None:
-            for order in created_orders:
-                pending_value += order.get_price() * order.get_amount()
-
-        if pending_orders is not None:
-            for order in pending_orders:
-                pending_value += order.get_price() * order.get_remaining()
-
-        if created_at is None:
-            created_at = datetime.now()
-
-        data = {
-            "portfolio_id": portfolio.id,
-            "trading_symbol": portfolio.trading_symbol,
-            "pending_value": pending_value,
-            "unallocated": portfolio.unallocated,
-            "total_net_gain": portfolio.total_net_gain,
-            "total_revenue": portfolio.total_revenue,
-            "total_cost": portfolio.total_cost,
-            "cash_flow": cash_flow,
-            "created_at": created_at,
-        }
-        snapshot = self.create(data)
-        positions = self.position_repository.get_all(
-            {"portfolio": portfolio.id}
-        )
-
-        for position in positions:
-            self.position_snapshot_service.create_snapshot(
-                snapshot.id, position
-            )
-
-        return snapshot
-
-    def get_latest_snapshot(self, portfolio_id):
-        pass
-
-    def get_snapshots(self, portfolio_id, start_date=None, end_date=None):
-        pass

investing_algorithm_framework/services/position_cost_service.py

@@ -1,5 +0,0 @@
-from .portfolio_service import RepositoryService
-
-
-class PositionCostService(RepositoryService):
-    pass

investing_algorithm_framework/services/position_service.py

@@ -1,63 +0,0 @@
-from investing_algorithm_framework.services.repository_service import \
-    RepositoryService
-
-
-class PositionService(RepositoryService):
-
-    def __init__(self, repository, order_repository, market_service):
-        super().__init__(repository)
-        self.market_service = market_service
-        self.order_repository = order_repository
-
-    def sync_positions(self, portfolio, market_service):
-        self.market_service.initialize(portfolio.portfolio_configuration)
-        balances = self.market_service.balances()
-
-        # Get trading symbol position
-        trading_symbol_position = balances[portfolio.get_trading_symbol()]
-
-        if portfolio.portfolio_configuration.has_unallocated_limit \
-                and trading_symbol_position["free"] > \
-                portfolio.portfolio_configuration.max_unallocated:
-            self._sync_position(
-                portfolio.portfolio_configuration.max_unallocated,
-                portfolio.id,
-                portfolio.get_trading_symbol(),
-            )
-        else:
-            self._sync_position(
-                trading_symbol_position["free"],
-                portfolio.id,
-                portfolio.get_trading_symbol(),
-            )
-
-        for balance_entry in balances:
-            symbol = balance_entry
-
-            if symbol == portfolio.get_trading_symbol():
-                continue
-
-            if "free" in balances[symbol]:
-                self._sync_position(
-                    balances[symbol]["free"],
-                    portfolio.id,
-                    symbol,
-                )
-
-    def _sync_position(self, synced_amount, portfolio_id, symbol):
-        position = self.find({"symbol": symbol, "portfolio": portfolio_id})
-
-        if position.amount != synced_amount:
-            self.update(position.id, {"amount": synced_amount})
-
-    def close_position(self, position_id, portfolio):
-        self.market_service.initialize(portfolio.portfolio_configuration)
-        position = self.get(position_id)
-
-        if position.amount > 0:
-            self.market_service.create_market_sell_order(
-                position.symbol,
-                portfolio.get_trading_symbol(),
-                position.amount,
-            )
-

investing_algorithm_framework/services/strategy_orchestrator_service.py

@@ -1,225 +0,0 @@
-import logging
-import schedule
-from datetime import datetime
-from investing_algorithm_framework.domain import StoppableThread, TimeUnit, \
-    OperationalException
-
-logger = logging.getLogger("investing_algorithm_framework")
-
-
-class StrategyOrchestratorService:
-
-    def __init__(self, market_data_service):
-        self.history = {}
-        self._strategies = []
-        self._tasks = []
-        self.threads = []
-        self.iterations = 0
-        self.max_iterations = -1
-        self.clear()
-        self.market_data_service = market_data_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 = self.market_data_service.get_data_for_strategy(strategy)
-
-        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):
-        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

investing_algorithm_framework-1.5.dist-info/AUTHORS.md

@@ -1,8 +0,0 @@
-# Marc van Duyn | Mod and Contributor
-<a href="https://linkedin.com/in/marc-van-duyn">
-  <img src="https://img.shields.io/badge/LinkedIn-0077B5?style=for-the-badge&logo=linkedin&logoColor=white" width="200px" />
-</a>
-<br/>
-<a href="https://github.com/MDUYN">
-  <img src="https://img.shields.io/badge/GitHub-100000?style=for-the-badge&logo=github&logoColor=white" width="200px" />
-</a>