investing-algorithm-framework 7.19.14__py3-none-any.whl

investing_algorithm_framework/app/task.py

@@ -0,0 +1,41 @@
+from investing_algorithm_framework.domain import \
+    TimeUnit
+
+
+class Task:
+    time_unit: str = None
+    interval: int = None
+    worker_id: str = None
+    decorated = None
+
+    def __init__(
+        self,
+        time_unit=None,
+        interval=None,
+        worker_id=None,
+        decorated=None
+    ):
+        if time_unit is not None:
+            self.time_unit = TimeUnit.from_value(time_unit)
+
+        if interval is not None:
+            self.interval = interval
+
+        if decorated is not None:
+            self.decorated = decorated
+
+        if worker_id is not None:
+            self.worker_id = worker_id
+        elif self.decorated:
+            self.worker_id = decorated.__name__
+        else:
+            self.worker_id = self.__class__.__name__
+
+    def run(self, context):
+
+        if self.decorated:
+            self.decorated(context=context)
+        else:
+            raise NotImplementedError(
+                "run method must be implemented in the subclass"
+            )

investing_algorithm_framework/app/web/__init__.py

@@ -0,0 +1,5 @@
+from .create_app import create_flask_app
+from .run_strategies import run_strategies
+from .schemas import OrderSerializer
+
+__all__ = ["create_flask_app", "run_strategies", 'OrderSerializer']

investing_algorithm_framework/app/web/controllers/__init__.py

@@ -0,0 +1,13 @@
+from investing_algorithm_framework.app.web.controllers.orders import \
+    blueprint as orders_blueprint
+from investing_algorithm_framework.app.web.controllers.portfolio \
+    import blueprint as portfolio_blueprint
+from investing_algorithm_framework.app.web.controllers.positions import \
+    blueprint as positions_blueprint
+
+
+def setup_blueprints(flask_app):
+    flask_app.register_blueprint(portfolio_blueprint, prefix="/api")
+    flask_app.register_blueprint(orders_blueprint, prefix="/api")
+    flask_app.register_blueprint(positions_blueprint, prefix="/api")
+    return flask_app

investing_algorithm_framework/app/web/controllers/orders.py

@@ -0,0 +1,20 @@
+import logging
+
+from dependency_injector.wiring import inject, Provide
+from flask import Blueprint, request
+
+from investing_algorithm_framework.app.web.responses import create_response
+from investing_algorithm_framework.app.web.schemas import OrderSerializer
+from investing_algorithm_framework.dependency_container import \
+    DependencyContainer
+
+logger = logging.getLogger("investing_algorithm_framework")
+
+blueprint = Blueprint("order-views", __name__)
+
+
+@blueprint.route("/api/orders", methods=["GET"])
+@inject
+def list_orders(order_service=Provide[DependencyContainer.order_service]):
+    orders = order_service.get_all(request.args)
+    return create_response(orders, OrderSerializer())

investing_algorithm_framework/app/web/controllers/portfolio.py

@@ -0,0 +1,20 @@
+import logging
+
+from dependency_injector.wiring import inject, Provide
+from flask import Blueprint, request
+
+from investing_algorithm_framework.app.web.responses import create_response
+from investing_algorithm_framework.app.web.schemas import PortfolioSerializer
+from investing_algorithm_framework.dependency_container import \
+    DependencyContainer
+
+logger = logging.getLogger("investing_algorithm_framework")
+
+blueprint = Blueprint("portfolio-views", __name__)
+
+
+@blueprint.route("/api/portfolios", methods=["GET"])
+@inject
+def retrieve(portfolio_service=Provide[DependencyContainer.portfolio_service]):
+    portfolios = portfolio_service.get_all(request.args)
+    return create_response(portfolios, PortfolioSerializer())

investing_algorithm_framework/app/web/controllers/positions.py

@@ -0,0 +1,18 @@
+import logging
+
+from dependency_injector.wiring import inject, Provide
+from flask import Blueprint, request
+
+from investing_algorithm_framework.app.web.responses import create_response
+from investing_algorithm_framework.app.web.schemas import PositionSerializer
+
+logger = logging.getLogger("investing_algorithm_framework")
+
+blueprint = Blueprint("position-views", __name__)
+
+
+@blueprint.route("/api/positions", methods=["GET"])
+@inject
+def list_positions(position_service=Provide["position_service"]):
+    positions = position_service.get_all(request.args)
+    return create_response(positions, PositionSerializer())

investing_algorithm_framework/app/web/create_app.py

@@ -0,0 +1,20 @@
+from flask import Flask
+
+from investing_algorithm_framework.app.web.controllers import setup_blueprints
+from investing_algorithm_framework.app.web.setup_cors import setup_cors
+from .error_handler import setup_error_handler
+
+
+def create_flask_app(configuration_service):
+    app = Flask(__name__.split('.')[0])
+
+    flask_config = configuration_service.get_flask_config()
+
+    for key, value in flask_config.items():
+        app.config[key] = value
+
+    app = setup_cors(app)
+    app.strict_slashes = False
+    app = setup_blueprints(app)
+    app = setup_error_handler(app)
+    return app

investing_algorithm_framework/app/web/error_handler.py

@@ -0,0 +1,59 @@
+import logging
+from typing import Dict, List
+
+import marshmallow.exceptions as marshmallow_exceptions
+from flask import jsonify
+from werkzeug.exceptions import HTTPException
+
+from investing_algorithm_framework.domain import ApiException
+
+logger = logging.getLogger("investing_algorithm_framework")
+
+
+def setup_error_handler(app) -> None:
+    """
+    Function that will register all the specified error handlers for the app
+    """
+
+    def create_error_response(error_message, status_code: int = 400):
+
+        # Remove the default 404 not found message if it exists
+        if not isinstance(error_message, Dict):
+            error_message = error_message.replace("404 Not Found: ", '')
+
+        response = jsonify({"error_message": error_message})
+        response.status_code = status_code
+        return response
+
+    def format_marshmallow_validation_error(errors: Dict):
+        errors_message = {}
+
+        for key in errors:
+
+            if isinstance(errors[key], Dict):
+                errors_message[key] = \
+                    format_marshmallow_validation_error(errors[key])
+
+            if isinstance(errors[key], List):
+                errors_message[key] = errors[key][0].lower()
+        return errors_message
+
+    def error_handler(error):
+        logger.error("exception of type {} occurred".format(type(error)))
+        logger.exception(error)
+
+        if isinstance(error, HTTPException):
+            return create_error_response(str(error), error.code)
+        elif isinstance(error, ApiException):
+            return create_error_response(
+                error.error_message, error.status_code
+            )
+        elif isinstance(error, marshmallow_exceptions.ValidationError):
+            error_message = format_marshmallow_validation_error(error.messages)
+            return create_error_response(error_message)
+        else:
+            # Internal error happened that was unknown
+            return "Internal server error", 500
+
+    app.errorhandler(Exception)(error_handler)
+    return app

investing_algorithm_framework/app/web/responses.py

@@ -0,0 +1,20 @@
+import inspect
+
+from flask import jsonify
+
+
+def create_response(data, serializer, status_code=200):
+
+    if inspect.isclass(serializer):
+        serializer = serializer()
+
+    if isinstance(data, dict):
+        item_selection = data["items"]
+        data["items"] = serializer.dump(item_selection, many=True)
+        return data, status_code
+    elif isinstance(data, list):
+        data = serializer.dump(data, many=True)
+        return jsonify({"items": data, "total": len(data)}), status_code
+    else:
+        data = serializer.dump(data)
+        return jsonify(data), status_code

investing_algorithm_framework/app/web/run_strategies.py

@@ -0,0 +1,4 @@
+def run_strategies(strategy_orchestration_service):
+
+    if strategy_orchestration_service.running:
+        strategy_orchestration_service.run_pending_jobs()

investing_algorithm_framework/app/web/schemas/__init__.py

@@ -0,0 +1,12 @@
+from investing_algorithm_framework.app.web.schemas.order import \
+    OrderSerializer
+from investing_algorithm_framework.app.web.schemas.portfolio import\
+    PortfolioSerializer
+from investing_algorithm_framework.app.web.schemas.position import \
+    PositionSerializer
+
+__all__ = [
+    "OrderSerializer",
+    "PositionSerializer",
+    "PortfolioSerializer"
+]

investing_algorithm_framework/app/web/schemas/order.py

@@ -0,0 +1,12 @@
+from marshmallow import Schema, fields
+
+
+class OrderSerializer(Schema):
+    reference_id = fields.String(dump_only=True)
+    target_symbol = fields.String(dump_only=True)
+    trading_symbol = fields.String(dump_only=True)
+    price = fields.Float(dump_only=True)
+    amount = fields.Float(dump_only=True)
+    status = fields.String(dump_only=True)
+    order_type = fields.String(dump_only=True)
+    order_side = fields.String(dump_only=True)

investing_algorithm_framework/app/web/schemas/portfolio.py

@@ -0,0 +1,22 @@
+from marshmallow import Schema, fields
+
+from investing_algorithm_framework.dependency_container \
+    import DependencyContainer
+
+
+class PortfolioSerializer(Schema):
+    identifier = fields.String(dump_only=True)
+    trading_symbol = fields.String(dump_only=True)
+    unallocated = fields.Float(dump_only=True)
+    orders = fields.Method("get_orders")
+    positions = fields.Method("get_positions")
+
+    @staticmethod
+    def get_orders(obj):
+        order_service = DependencyContainer.order_service()
+        return order_service.count({"portfolio": obj.identifier})
+
+    @staticmethod
+    def get_positions(obj):
+        position_service = DependencyContainer.position_service()
+        return position_service.count({"portfolio": obj.id})

investing_algorithm_framework/app/web/schemas/position.py

@@ -0,0 +1,15 @@
+from marshmallow import Schema, fields
+
+from investing_algorithm_framework.dependency_container import \
+    DependencyContainer
+
+
+class PositionSerializer(Schema):
+    symbol = fields.String()
+    amount = fields.Float(dump_only=True)
+    orders = fields.Method("get_orders")
+
+    @staticmethod
+    def get_orders(obj):
+        order_service = DependencyContainer.order_service()
+        return order_service.count({"position": obj.id})

investing_algorithm_framework/app/web/setup_cors.py

@@ -0,0 +1,6 @@
+from flask_cors import CORS
+
+
+def setup_cors(app):
+    CORS(app)
+    return app

investing_algorithm_framework/cli/cli.py

@@ -0,0 +1,207 @@
+import click
+
+from .deploy_to_aws_lambda import command as deploy_to_aws_lambda_command
+from .deploy_to_azure_function import command as \
+    deploy_to_azure_function_command
+from .initialize_app import command as initialize_app_command
+
+"""
+CLI for Investing Algorithm Framework
+
+This module provides a command-line interface (CLI) for the
+Investing Algorithm Framework.
+"""
+
+
+@click.group()
+def cli():
+    """CLI for Investing Algorithm Framework"""
+    pass
+
+
+@click.command()
+@click.option(
+    '--type',
+    default="default",
+    help="Type of app to create. "
+    "Options are: 'default', 'default_web', 'azure_function', 'aws_lambda'."
+)
+@click.option(
+    '--path', default=None, help="Path to directory to initialize the app in"
+)
+@click.option(
+    '--replace',
+    is_flag=True,
+    default=False,
+    help="If True, duplicate files will be replaced."
+    "If False, files will not be replaced."
+)
+def init(type, path, replace):
+    """
+    Command-line tool for creating an app skeleton.
+
+    Args:
+        type (str): Type of app to create. Options are: 'default',
+            'default-web', 'azure-function'.
+        path (str): Path to directory to initialize the app in
+        replace (bool): If True, existing files will be replaced.
+            If False, existing files will not be replaced.
+
+    Returns:
+        None
+    """
+    initialize_app_command(path=path, app_type=type, replace=replace)
+
+
+@click.command()
+@click.option(
+    '--resource_group',
+    required=True,
+    help='The name of the resource group.',
+)
+@click.option(
+    '--subscription_id',
+    required=False,
+    help='The subscription ID. If not provided, the default will be used.'
+)
+@click.option(
+    '--storage_account_name',
+    required=False,
+    help='The name of the storage account.',
+)
+@click.option(
+    '--container_name',
+    required=False,
+    help='The name of the blob container.',
+    default='iafcontainer'
+)
+@click.option(
+    '--deployment_name',
+    required=True,
+    help='The name of the deployment. This will be" + \
+        "used as the name of the Function App.'
+)
+@click.option(
+    '--region',
+    required=True,
+    help='The Azure region for the resources.'
+)
+@click.option(
+    '--create_resource_group_if_not_exists',
+    is_flag=True,
+    help='Flag to create the resource group if it does not exist.'
+)
+@click.option(
+    '--skip_login',
+    is_flag=True,
+    help='Flag to create the resource group if it does not exist.',
+    default=False
+)
+def deploy_azure_function(
+    resource_group,
+    subscription_id,
+    storage_account_name,
+    container_name,
+    deployment_name,
+    region,
+    create_resource_group_if_not_exists,
+    skip_login
+):
+    """
+    Command-line tool for deploying a trading bot to Azure Function.
+
+    Args:
+        path (str): Path to directory to initialize the app in
+        resource_group (str): The name of the resource group.
+        subscription_id (str): The subscription ID. If not provided,
+            the default will be used.
+        storage_account_name (str): The name of the storage account.
+        container_name (str): The name of the blob container.
+        deployment_name (str): The name of the deployment. This will be
+            used as the name of the Function App.
+        region (str): The Azure region for the resources.
+        create_resource_group_if_not_exists (bool): Flag to create the
+            resource group if it does not exist.
+        skip_login (bool): Flag to skip the login process. This is
+            useful for CI/CD pipelines where the login is handled
+            separately.
+        region (str): The Azure region for the resources.
+        create_resource_group_if_not_exists (bool): Flag to create the
+            resource group if it does not exist.
+        skip_login (bool): Flag to skip the login process. This is
+            useful for CI/CD pipelines where the login is handled
+            separately.
+
+    Returns:
+        None
+    """
+    crg = create_resource_group_if_not_exists
+    deploy_to_azure_function_command(
+        resource_group=resource_group,
+        subscription_id=subscription_id,
+        storage_account_name=storage_account_name,
+        container_name=container_name,
+        deployment_name=deployment_name,
+        region=region,
+        create_resource_group_if_not_exists=crg,
+        skip_login=skip_login
+    )
+
+
+@click.command()
+@click.option(
+    '--lambda_function_name',
+    required=True,
+    help='The name of the AWS Lambda function to deploy.'
+)
+@click.option(
+    '--region',
+    required=True,
+    help='The AWS region where the Lambda function will be deployed.'
+)
+@click.option(
+    '--project_dir',
+    default=None,
+    help='The path to the project directory containing '
+         'the Lambda function code.'
+)
+@click.option(
+    '--memory_size',
+    default=3000,
+    type=int,
+    help='The memory size for the Lambda function in MB. Default is 3000 MB.'
+)
+def deploy_aws_lambda(
+    lambda_function_name,
+    region,
+    project_dir=None,
+    memory_size=3000
+):
+    """
+    Command-line tool for deploying a trading bot to AWS lambda
+
+    Args:
+        lambda_function_name (str): The name of the AWS Lambda function
+            to deploy.
+        region (str): The AWS region where the Lambda function will
+            be deployed.
+        project_dir (str): The path to the project directory containing the
+            Lambda function code. If not provided, it defaults to
+            the current directory.
+        memory_size (int): The memory size for the Lambda function in MB.
+            Default is 3000 MB.
+
+    Returns:
+        None
+    """
+    deploy_to_aws_lambda_command(
+        lambda_function_name=lambda_function_name,
+        region=region,
+        project_dir=project_dir,
+        memory_size=memory_size
+    )
+
+
+cli.add_command(init)
+cli.add_command(deploy_azure_function)
+cli.add_command(deploy_aws_lambda)