finterion-investing-algorithm-framework 0.20.0__tar.gz → 0.22.0__tar.gz

finterion_investing_algorithm_framework-0.22.0/PKG-INFO

@@ -0,0 +1,61 @@
+Metadata-Version: 2.1
+Name: finterion-investing-algorithm-framework
+Version: 0.22.0
+Summary: This is the official finterion plugin for the investing algorithm framework open source project.
+Author: Marc van Duyn
+Author-email: marc@finterion.com
+Requires-Python: >=3.10,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: finterion (>=0.8.8,<0.9.0)
+Requires-Dist: investing-algorithm-framework (>=6.5.2)
+Description-Content-Type: text/markdown
+
+# Finterion Investing Algorithm Framework Plugin
+This is the official plugin for the [investing algorithm framework](https://investing-algorithm-framework.com) open source project.
+
+## Installation
+You can install the plugin with pip.
+```shell
+pip install finterion-investing-algorithm-framework
+```
+
+## Usage 
+In order to use the plugin you must register the following components in your investing algorithm framework application:
+- **FinterionOrderExecutor**: This component is responsible for executing orders on the finterion platform.
+- **FinterionPortfolioProvider**: This component is responsible for connecting the portfolio and syncing positions.
+- **FinterionPingHook**: This component is responsible for pinging the finterion platform.
+
+> **Note:** You must provide the API key of your algorithm in order to use 
+> the plugin. You can find your API keys in the developer dashboard of
+> your algorithm on the finterion platform.
+
+## Example
+```python
+import logging.config
+from dotenv import load_dotenv
+
+from investing_algorithm_framework import create_app, DEFAULT_LOGGING_CONFIG
+
+from finterion_investing_algorithm_framework import \
+    FinterionPortfolioProvider, FinterionOrderExecutor, FinterionPingAction
+
+
+load_dotenv()
+logging.config.dictConfig(DEFAULT_LOGGING_CONFIG)
+
+app = create_app()
+app.on_strategy_run(FinterionPingAction)
+app.add_order_executor(FinterionOrderExecutor)
+app.add_portfolio_provider(FinterionPortfolioProvider)
+app.add_market(
+    market="Finterion",
+    api_key="<FINTERION_API_KEY>", # Or set the environment variable FINTERION_API_KEY
+    trading_symbol="EUR",
+)
+```
+
+## Documentation
+You can find the official documentation at our [documentation website](https://docs.finterion.com/)

finterion_investing_algorithm_framework-0.22.0/README.md

@@ -0,0 +1,46 @@
+# Finterion Investing Algorithm Framework Plugin
+This is the official plugin for the [investing algorithm framework](https://investing-algorithm-framework.com) open source project.
+
+## Installation
+You can install the plugin with pip.
+```shell
+pip install finterion-investing-algorithm-framework
+```
+
+## Usage 
+In order to use the plugin you must register the following components in your investing algorithm framework application:
+- **FinterionOrderExecutor**: This component is responsible for executing orders on the finterion platform.
+- **FinterionPortfolioProvider**: This component is responsible for connecting the portfolio and syncing positions.
+- **FinterionPingHook**: This component is responsible for pinging the finterion platform.
+
+> **Note:** You must provide the API key of your algorithm in order to use 
+> the plugin. You can find your API keys in the developer dashboard of
+> your algorithm on the finterion platform.
+
+## Example
+```python
+import logging.config
+from dotenv import load_dotenv
+
+from investing_algorithm_framework import create_app, DEFAULT_LOGGING_CONFIG
+
+from finterion_investing_algorithm_framework import \
+    FinterionPortfolioProvider, FinterionOrderExecutor, FinterionPingAction
+
+
+load_dotenv()
+logging.config.dictConfig(DEFAULT_LOGGING_CONFIG)
+
+app = create_app()
+app.on_strategy_run(FinterionPingAction)
+app.add_order_executor(FinterionOrderExecutor)
+app.add_portfolio_provider(FinterionPortfolioProvider)
+app.add_market(
+    market="Finterion",
+    api_key="<FINTERION_API_KEY>", # Or set the environment variable FINTERION_API_KEY
+    trading_symbol="EUR",
+)
+```
+
+## Documentation
+You can find the official documentation at our [documentation website](https://docs.finterion.com/)

finterion_investing_algorithm_framework-0.22.0/finterion_investing_algorithm_framework/__init__.py

@@ -0,0 +1,9 @@
+from .order_executor import FinterionOrderExecutor
+from .portfolio_provider import FinterionPortfolioProvider
+from .ping_hook import FinterionPingAction
+
+__all__ = [
+    "FinterionOrderExecutor",
+    "FinterionPortfolioProvider",
+    "FinterionPingAction"
+]

finterion_investing_algorithm_framework-0.22.0/finterion_investing_algorithm_framework/order_executor.py

@@ -0,0 +1,112 @@
+from logging import getLogger
+
+from investing_algorithm_framework import OrderExecutor, OrderType, \
+    OrderSide, Order, OperationalException
+from finterion import Finterion
+
+from .utils import convert_finterion_order_to_order
+
+logger = getLogger("investing_algorithm_framework")
+
+
+class FinterionOrderExecutor(OrderExecutor):
+    """
+    FinterionOrderExecutor is a class that implements the OrderExecutor
+    interface for executing and canceling orders using the Finterion API.
+    """
+
+    def execute_order(self, portfolio, order, market_credential) -> Order:
+        """
+        Executes an order for a given portfolio on Finterion.
+
+        Args:
+            order: The order to be executed
+            portfolio: The portfolio in which the order will be executed
+            market_credential: The market credential to use for the order
+
+        Returns:
+            Order: Instance of the executed order. The order instance
+            should copy the id of the order that has been provided as a
+        """
+        finterion_client = self.initialize(market_credential)
+        target_symbol = order.get_target_symbol()
+        amount = order.get_amount()
+        price = order.get_price()
+        order_type = order.get_order_type()
+        order_side = order.get_order_side()
+
+        try:
+            if OrderType.LIMIT.equals(order_type):
+                if OrderSide.BUY.equals(order_side):
+                    external_order = finterion_client.create_limit_order(
+                        order_side="buy",
+                        amount=str(amount),
+                        target_symbol=target_symbol,
+                        price=price
+                    )
+                    external_order = (
+                        convert_finterion_order_to_order(external_order)
+                    )
+                else:
+                    external_order = finterion_client.create_limit_order(
+                        order_side="sell",
+                        amount=str(amount),
+                        target_symbol=target_symbol,
+                        price=price
+                    )
+                    external_order = (
+                        convert_finterion_order_to_order(external_order)
+                    )
+            else:
+                raise OperationalException(
+                    f"Order type {order_type} not supported "
+                    f"by CCXT OrderExecutor"
+                )
+
+            external_order.id = order.id
+            return external_order
+        except Exception as e:
+            logger.exception(e)
+            raise OperationalException("Could not create finterion order")
+
+    def cancel_order(self, portfolio, order, market_credential) -> Order:
+        """
+        Cancels an order for a given portfolio on a CCXT exchange.
+
+        Args:
+            order: The order to be canceled
+            portfolio: The portfolio in which the order was executed
+            market_credential: The market credential to use for the order
+
+        Returns:
+            Order: Instance of the canceled order.
+        """
+        raise OperationalException("Cancel order not supported")
+
+    @staticmethod
+    def initialize(market_credential) -> Finterion:
+        """
+        Function to initialize the finterion api client.
+
+        Args:
+            market_credential (MarketCredential): The market credential to use
+                with the finterion api client
+
+        Returns:
+            Finterion: Instance of the Finterion API client
+        """
+        api_key = market_credential.api_key
+        return Finterion(api_key)
+
+    def supports_market(self, market):
+        """
+        Function to check if the market is supported by the portfolio
+        provider.
+
+        Args:
+            market: Market object
+
+        Returns:
+            bool: True if the market is supported, False otherwise
+        """
+        return market.lower() == "finterion"

finterion_investing_algorithm_framework-0.22.0/finterion_investing_algorithm_framework/ping_hook.py

@@ -0,0 +1,39 @@
+from logging import getLogger
+from investing_algorithm_framework import AppHook
+from finterion import Finterion
+
+logger = getLogger("investing_algorithm_framework")
+
+
+class FinterionPingAction(AppHook):
+    """
+    A class that implements the AppHook interface to perform a ping action
+    on the Finterion API.
+    """
+    def on_run(self, context):
+        """
+        Method to be called when the algorithm is run.
+        It pings the Finterion API and prints the response.
+
+        Args:
+            context: The context of the framework
+        """
+        logger.info("Pinging Finterion")
+        market_credential = context.get_market_credential("finterion")
+        finterion_client = self.initialize(market_credential)
+        finterion_client.ping()
+
+    @staticmethod
+    def initialize(market_credential) -> Finterion:
+        """
+        Function to initialize the finterion api client.
+
+        Args:
+            market_credential (MarketCredential): The market credential to use
+                with the finterion api client
+
+        Returns:
+            Finterion: Instance of the Finterion API client
+        """
+        api_key = market_credential.api_key
+        return Finterion(api_key)

finterion_investing_algorithm_framework-0.22.0/finterion_investing_algorithm_framework/portfolio_provider.py

@@ -0,0 +1,123 @@
+from logging import getLogger
+from typing import Union
+
+from investing_algorithm_framework.domain import PortfolioProvider, \
+    OperationalException, Order, Position
+from finterion import Finterion
+
+from .utils import convert_finterion_order_to_order, \
+    convert_finterion_position_to_position
+
+logger = getLogger("investing_algorithm_framework")
+
+
+class FinterionPortfolioProvider(PortfolioProvider):
+    """
+    Implementation of Portfolio Provider for Finterion.
+    """
+
+    def get_order(
+        self, portfolio, order, market_credential
+    ) -> Union[Order, None]:
+        """
+        Method to check if there are any pending orders for the portfolio.
+        This method will retrieve the open orders from the exchange and
+        check if there are any pending orders for the portfolio.
+
+        !IMPORTANT: This function should return None if the order is
+        not found or if the order is not available on the
+        exchange or broker. Please do not throw an exception if the
+        order is not found.
+
+        Args:
+            portfolio: Portfolio object
+            order: Order object from the database
+            market_credential: Market credential object
+
+        Returns:
+            None
+        """
+        finterion_client = self.initialize(market_credential)
+
+        try:
+            external_order = finterion_client.get_order(
+                order.get_external_id()
+            )
+            external_order = (
+                convert_finterion_order_to_order(external_order)
+            )
+            external_order.id = order.id
+            return external_order
+        except Exception as e:
+            logger.exception(e)
+            raise OperationalException(
+                "Could not retrieve order from Finterion"
+            )
+
+    def get_position(
+        self, portfolio, symbol, market_credential
+    ) -> Union[Position, None]:
+        """
+        Function to get the position for a given symbol in the portfolio.
+        The returned position should be an object that reflects the current
+        state of the position on the exchange or broker.
+
+        !IMPORTANT: This function should return None if the position is
+        not found or if the position is not available on the
+        exchange or broker. Please do not throw an exception if the
+        position is not found.
+
+        Args:
+            portfolio (Portfolio): Portfolio object
+            symbol (str): Symbol object
+            market_credential (MarketCredential): MarketCredential object
+
+        Returns:
+            Position: Position for the given symbol in the portfolio
+        """
+
+        finterion_client = self.initialize(market_credential)
+        symbol = symbol
+
+        try:
+            external_positions = finterion_client.get_positions(
+                symbol=symbol
+            )
+            external_position = (
+                convert_finterion_position_to_position(external_positions[0])
+            )
+            external_position.portfolio_id = portfolio.id
+            return external_position
+        except Exception as e:
+            logger.exception(e)
+            raise OperationalException(
+                "Could not retrieve position from Finterion"
+            )
+
+    @staticmethod
+    def initialize(market_credential) -> Finterion:
+        """
+        Function to initialize the finterion api client.
+
+        Args:
+            market_credential (MarketCredential): The market credential to use
+                with the finterion api client
+
+        Returns:
+            Finterion: Instance of the Finterion API client
+        """
+        api_key = market_credential.api_key
+        return Finterion(api_key)
+
+    def supports_market(self, market):
+        """
+        Function to check if the market is supported by the portfolio
+        provider.
+
+        Args:
+            market: Market object
+
+        Returns:
+            bool: True if the market is supported, False otherwise
+        """
+        return market.lower() == "finterion"

finterion_investing_algorithm_framework-0.22.0/finterion_investing_algorithm_framework/utils.py

@@ -0,0 +1,56 @@
+from dateutil import parser
+from investing_algorithm_framework import Order, Position
+
+
+def convert_finterion_order_to_order(finterion_order):
+    """
+    Convert a Finterion order to an Order object from the
+    investing_algorithm_framework.
+
+    Args:
+        finterion_order (dict): The Finterion order data.
+
+    Returns:
+        Order: An Order object populated with the data
+        from the Finterion order.
+    """
+    order = Order(
+        external_id=finterion_order.get("id"),
+        order_type=finterion_order.get("order_type"),
+        order_side=finterion_order.get("order_side"),
+        status=finterion_order.get("status"),
+        amount=float(finterion_order.get("amount")),
+        target_symbol=finterion_order.get("target_symbol"),
+        trading_symbol=finterion_order.get("trading_symbol"),
+        price=float(finterion_order.get("price")),
+        filled=float(finterion_order.get("filled")),
+        remaining=float(finterion_order.get("remaining")),
+        cost=float(finterion_order.get("cost")),
+    )
+
+    if finterion_order.get("created_at") is not None:
+        order.created_at = parser.parse(finterion_order.get("created_at"))
+
+    if finterion_order.get("updated_at") is not None:
+        order.updated_at = parser.parse(finterion_order.get("updated_at"))
+
+    return order
+
+
+def convert_finterion_position_to_position(finterion_position) -> Position:
+    """
+    Convert a Finterion position to a Position object from the
+    investing_algorithm_framework.
+
+    Args:
+        finterion_position (dict): The Finterion position data.
+
+    Returns:
+        Position: An Position object populated with the data
+        from the Finterion position.
+    """
+    return Position(
+        symbol=finterion_position.get("symbol"),
+        amount=float(finterion_position.get("amount")),
+        cost=float(finterion_position.get("cost")),
+    )

{finterion_investing_algorithm_framework-0.20.0 → finterion_investing_algorithm_framework-0.22.0}/pyproject.toml

@@ -1,13 +1,13 @@
 [tool.poetry]
 name = "finterion-investing-algorithm-framework"
-version = "v0.20.0"
+version = "v0.22.0"
 description = "This is the official finterion plugin for the investing algorithm framework open source project."
 authors = ["Marc van Duyn <marc@finterion.com>"]
 readme = "README.md"
 
 [tool.poetry.dependencies]
-python = "^3.8.1"
-investing-algorithm-framework = "^3.5.1"
+python = "^3.10"
+investing-algorithm-framework = ">=6.5.2"
 finterion = "^0.8.8"
 
 [tool.poetry.group.test.dependencies]

finterion_investing_algorithm_framework-0.20.0/PKG-INFO

@@ -1,51 +0,0 @@
-Metadata-Version: 2.1
-Name: finterion-investing-algorithm-framework
-Version: 0.20.0
-Summary: This is the official finterion plugin for the investing algorithm framework open source project.
-Author: Marc van Duyn
-Author-email: marc@finterion.com
-Requires-Python: >=3.8.1,<4.0.0
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Requires-Dist: finterion (>=0.8.8,<0.9.0)
-Requires-Dist: investing-algorithm-framework (>=3.5.1,<4.0.0)
-Description-Content-Type: text/markdown
-
-# Finterion Investing Algorithm Framework Plugin
-This is the official plugin for the [investing algorithm framework](https://investing-algorithm-framework.com) open source project.
-
-## Installation
-You can install the plugin with pip.
-```shell
-pip install finterion-investing-algorithm-framework
-```
-
-## Usage 
-In order to use the plugin you must use the 'create_app' function provided 
-by the plugin. This function will return an instance of the investing 
-algorithm framework configured with the finterion platform.
-
-> **Note:** You must provide the API key of your algorithm in order to use 
-> the plugin. You can find your API keys in the developer dashboard of
-> your algorithm on the finterion platform.
-
-```python
-from finterion_investing_algorithm_framework import create_app
-
-app = create_app(api_key="<YOUR_TRADING_BOT_FINTERION_API_KEY>")
-
-# Add your investing algorithm framework market data sources
-# ..... 
-
-# Add your investing algorithm framework trading strategies
-# ....
-
-if __name__ == "__main__":
-    app.run()
-```
-
-## Documentation
-You can find the official documentation at our [documentation website](https://docs.finterion.com/)

finterion_investing_algorithm_framework-0.20.0/README.md

@@ -1,35 +0,0 @@
-# Finterion Investing Algorithm Framework Plugin
-This is the official plugin for the [investing algorithm framework](https://investing-algorithm-framework.com) open source project.
-
-## Installation
-You can install the plugin with pip.
-```shell
-pip install finterion-investing-algorithm-framework
-```
-
-## Usage 
-In order to use the plugin you must use the 'create_app' function provided 
-by the plugin. This function will return an instance of the investing 
-algorithm framework configured with the finterion platform.
-
-> **Note:** You must provide the API key of your algorithm in order to use 
-> the plugin. You can find your API keys in the developer dashboard of
-> your algorithm on the finterion platform.
-
-```python
-from finterion_investing_algorithm_framework import create_app
-
-app = create_app(api_key="<YOUR_TRADING_BOT_FINTERION_API_KEY>")
-
-# Add your investing algorithm framework market data sources
-# ..... 
-
-# Add your investing algorithm framework trading strategies
-# ....
-
-if __name__ == "__main__":
-    app.run()
-```
-
-## Documentation
-You can find the official documentation at our [documentation website](https://docs.finterion.com/)

finterion_investing_algorithm_framework-0.20.0/finterion_investing_algorithm_framework/__init__.py

@@ -1,5 +0,0 @@
-from finterion_investing_algorithm_framework.create_app import create_app
-
-__all__ = [
-    "create_app",
-]

finterion_investing_algorithm_framework-0.20.0/finterion_investing_algorithm_framework/configuration/__init__.py

@@ -1,3 +0,0 @@
-import constants
-
-__all__ = ["constants"]

finterion_investing_algorithm_framework-0.20.0/finterion_investing_algorithm_framework/configuration/constants.py

@@ -1,2 +0,0 @@
-LOGICFUNDS_API_KEY = "LOGICFUNDS_API_KEY"
-LOGICFUNDS_URL = "https://api.logicfunds.io/algs/"

finterion_investing_algorithm_framework-0.20.0/finterion_investing_algorithm_framework/create_app.py

@@ -1,68 +0,0 @@
-import logging
-
-from finterion import Finterion
-from investing_algorithm_framework import create_app as framework_create_app, \
-    Task, TimeUnit, App, MarketCredential, AppHook, Algorithm
-
-from finterion_investing_algorithm_framework.market_service import \
-    FinterionMarketService
-from finterion_investing_algorithm_framework.models.portfolio_configuration \
-    import FinterionPortfolioConfiguration
-from .validation import check_portfolio_active
-
-logger = logging.getLogger("finterion_investing_algorithm_framework_plugin")
-
-
-def create_app(
-    api_key,
-    config={},
-    stateless=False,
-    web=False,
-    base_url=None,
-) -> App:
-    client = Finterion(api_key=api_key, base_url=base_url)
-    client.ping()
-    model = client.get_algorithm_model()
-
-    # Check that the portfolio is active
-    check_portfolio_active(client)
-
-    # Add a finterion portfolio configuration
-    portfolio_configuration = FinterionPortfolioConfiguration(
-        trading_symbol=model['profile']['trading_symbol'],
-        market_data_markets=model['profile']['markets'],
-    )
-    app = framework_create_app(config=config, web=web, stateless=stateless)
-    app.add_market_credential(
-        MarketCredential(
-            market="finterion",
-            api_key=api_key,
-            secret_key=None,
-        )
-    )
-    market_credential_service = app.container.market_credential_service()
-    app.container.market_service.override(
-        FinterionMarketService(
-            api_key=api_key,
-            base_url=base_url,
-            market_credential_service=market_credential_service
-        )
-    )
-    app.add_portfolio_configuration(portfolio_configuration)
-
-    class PingTask(Task):
-        interval = 30
-        time_unit = TimeUnit.MINUTE
-
-        def run(self, algorithm):
-            logger.debug("Pinging Finterion platform")
-            client.ping()
-
-    class PingAppHook(AppHook):
-
-        def on_run(self, app, algorithm: Algorithm):
-            algorithm.add_task(PingTask)
-
-    # Register the ping task to the algorithm
-    app.after_initialize(PingAppHook())
-    return app

finterion_investing_algorithm_framework-0.20.0/finterion_investing_algorithm_framework/exceptions.py

@@ -1,5 +0,0 @@
-class FinterionInvestingAlgorithmFrameworkException(Exception):
-
-    def __init__(self, message):
-        super(FinterionInvestingAlgorithmFrameworkException, self)\
-            .__init__(message)

finterion_investing_algorithm_framework-0.20.0/finterion_investing_algorithm_framework/market_service.py

@@ -1,183 +0,0 @@
-from datetime import datetime
-
-from dateutil import parser
-from finterion import Finterion
-from investing_algorithm_framework import Order
-from investing_algorithm_framework.infrastructure import CCXTMarketService
-from finterion_investing_algorithm_framework.exceptions import \
-    FinterionInvestingAlgorithmFrameworkException
-
-
-class FinterionMarketService(CCXTMarketService):
-    """
-    Finterion market service implementation.
-    """
-    def cancel_order(self, order, market):
-        pass
-
-    def get_open_orders(
-        self, market, target_symbol: str = None, trading_symbol: str = None
-    ):
-        pass
-
-    def get_closed_orders(
-        self, market, target_symbol: str = None, trading_symbol: str = None
-    ):
-        pass
-
-    def get_ticker(self, symbol, market):
-        """
-        Finterion does not support get_ticker, please specify a ticker market
-        data source for symbol {symbol}. Finterion can't provide this data.
-
-        Users should register their own ticker data sources to obtain ticker
-        data.
-        """
-        raise FinterionInvestingAlgorithmFrameworkException(
-            f"Finterion does not support get_ticker, please specify "
-            f"a ticker market data source for symbol {symbol}. Finterion "
-            f"can't provide this data."
-        )
-
-    def get_order_book(self, symbol, market):
-        raise FinterionInvestingAlgorithmFrameworkException(
-            f"Finterion does not support get_order_book, please specify "
-            f"an order book market data source for symbol {symbol}. Finterion "
-            f"can't provide this data."
-        )
-
-    def get_ohlcv(
-        self,
-        symbol,
-        time_frame,
-        from_timestamp,
-        market,
-        to_timestamp=None
-    ):
-        raise FinterionInvestingAlgorithmFrameworkException(
-            f"Finterion does not support get_ohlcv, please specify "
-            f"an ohlcv market data source for symbol {symbol}. Finterion "
-            f"can't provide this data."
-        )
-
-    def __init__(
-        self,
-        api_key,
-        market_credential_service,
-        base_url=None,
-        initialize=True
-    ):
-        super().__init__(market_credential_service)
-        self._api_key = api_key
-        self._market = "finterion"
-
-        if initialize:
-            if base_url is not None:
-                self._finterion = Finterion(api_key, base_url=base_url)
-            else:
-                self._finterion = Finterion(api_key)
-
-    def initialize(self, portfolio_configuration):
-        pass
-
-    def get_order(self, order, market):
-        order = self._finterion.get_order(order.get_external_id())
-        return self._convert_order(order)
-
-    def get_orders(self, symbol, market, since: datetime = None):
-        orders = self._finterion.get_orders(target_symbol=symbol.split("/")[0])
-        return [self._convert_order(order) for order in orders]
-
-    def get_balance(self, market):
-        """
-        Finterion implementation of get_balance.
-        """
-        positions = self._finterion.get_positions()
-        entries = {}
-
-        for position in positions:
-            entries[position["symbol"]] = float(position["amount"])
-
-        return entries
-
-    def create_market_sell_order(
-        self,
-        target_symbol: str,
-        trading_symbol: str,
-        amount: float,
-        market
-    ):
-        order = self._finterion.create_market_order(
-            order_side="sell",
-            amount=str(amount),
-            target_symbol=target_symbol,
-        )
-        return self._convert_order(order)
-
-    def create_limit_sell_order(
-        self,
-        target_symbol: str,
-        trading_symbol: str,
-        amount,
-        price,
-        market
-    ):
-        order = self._finterion.create_limit_order(
-            order_side="sell",
-            amount=str(amount),
-            target_symbol=target_symbol,
-            price=price
-        )
-        return self._convert_order(order)
-
-    def create_limit_buy_order(
-        self,
-        target_symbol: str,
-        trading_symbol: str,
-        amount: float,
-        price: float,
-        market
-    ):
-        order = self._finterion.create_limit_order(
-            order_side="buy",
-            amount=str(amount),
-            target_symbol=target_symbol,
-            price=str(price)
-        )
-        return self._convert_order(order)
-
-    def _convert_order(self, finterion_order):
-        order = Order(
-            external_id=finterion_order.get("id"),
-            order_type=finterion_order.get("order_type"),
-            order_side=finterion_order.get("order_side"),
-            status=finterion_order.get("status"),
-            amount=finterion_order.get("amount"),
-            target_symbol=finterion_order.get("target_symbol"),
-            trading_symbol=finterion_order.get("trading_symbol"),
-            price=finterion_order.get("price"),
-            trade_closed_price=finterion_order.get("trade_closed_price", None),
-            trade_closed_at=finterion_order.get("trade_closed_at", None),
-            trade_closed_amount=finterion_order.get(
-                "trade_closed_amount", None
-            ),
-            filled=finterion_order.get("filled"),
-            remaining=finterion_order.get("remaining"),
-            cost=finterion_order.get("cost"),
-        )
-
-        if finterion_order.get("trade_closed_at") is not None:
-            order.trade_closed_at = parser.parse(
-                finterion_order.get("trade_closed_at")
-            )
-
-        if finterion_order.get("created_at") is not None:
-            order.created_at = parser.parse(finterion_order.get("created_at"))
-
-        if finterion_order.get("updated_at") is not None:
-            order.updated_at = parser.parse(finterion_order.get("updated_at"))
-
-        return order
-
-    def get_symbols(self, market):
-        return self._finterion.get_supported_symbols()

finterion_investing_algorithm_framework-0.20.0/finterion_investing_algorithm_framework/models/__init__.py

@@ -1,6 +0,0 @@
-from finterion_investing_algorithm_framework.models.portfolio_configuration \
-    import FinterionPortfolioConfiguration
-
-__all__ = [
-    'FinterionPortfolioConfiguration',
-]

finterion_investing_algorithm_framework-0.20.0/finterion_investing_algorithm_framework/models/portfolio_configuration.py

@@ -1,24 +0,0 @@
-from investing_algorithm_framework import PortfolioConfiguration
-from investing_algorithm_framework.domain import ImproperlyConfigured
-
-
-class FinterionPortfolioConfiguration(PortfolioConfiguration):
-
-    def __init__(self, trading_symbol, market_data_markets):
-        try:
-            super().__init__(
-                market="finterion",
-                trading_symbol=trading_symbol,
-            )
-        except ImproperlyConfigured:
-            pass
-
-        if market_data_markets is None:
-            raise ImproperlyConfigured(
-                "Your algorithm has no markets configured. Please add at "
-                "least one market to your algorithm on the finterion platform."
-            )
-
-    @property
-    def identifier(self):
-        return "finterion"

finterion_investing_algorithm_framework-0.20.0/finterion_investing_algorithm_framework/validation.py

@@ -1,14 +0,0 @@
-from finterion import Finterion
-from finterion_investing_algorithm_framework.exceptions import \
-    FinterionInvestingAlgorithmFrameworkException
-
-
-def check_portfolio_active(finterion_client: Finterion):
-    portfolio = finterion_client\
-        .get_portfolio(query_params={"ShowMetrics": "False"})
-
-    if portfolio['active'] is False:
-        raise FinterionInvestingAlgorithmFrameworkException(
-            "Cannot run on in-active portfolio, "
-            "please activate your portfolio"
-        )