Merge branch 'aws' of https://github.com/berlinguyinca/freqtrade into aws

freqtrade/aws/backtesting_lambda.py

@@ -1,8 +1,15 @@
 import logging
 
+import boto3
+import os
+
 from freqtrade.arguments import Arguments
 from freqtrade.configuration import Configuration
 from freqtrade.optimize.backtesting import Backtesting
+import simplejson as json
+from boto3.dynamodb.conditions import Key, Attr
+
+db = boto3.resource('dynamodb')
 
 
 def backtest(event, context):
@@ -29,74 +36,92 @@ def backtest(event, context):
             no return
     """
 
-    name = "TestStrategy"
-    user = "12345678"
-    stake_currency = "USDT"
-    asset = ["ETH", "BTC"]
-    exchange = "binance"
+    if 'body' in event:
+        event['body'] = json.loads(event['body'])
+        name = event['body']['name']
+        user = event['body']['user']
+        stake_currency = event['body']['stake_currency'].upper()
+        asset = event['body']['asset']
+        exchange = event['body']['exchange']
 
-    assets = list(map(lambda x: "{}/{}".format(x, stake_currency).upper(), asset))
+        assets = list(map(lambda x: "{}/{}".format(x, stake_currency).upper(), asset))
 
-    configuration = {
-        "max_open_trades": 1,
-        "stake_currency": stake_currency,
-        "stake_amount": 0.001,
-        "fiat_display_currency": "USD",
-        "unfilledtimeout": 600,
-        "bid_strategy": {
-            "ask_last_balance": 0.0
-        },
-        "exchange": {
-            "name": "bittrex",
-            "enabled": True,
-            "key": "key",
-            "secret": "secret",
-            "pair_whitelist": assets
-        },
-        "telegram": {
-            "enabled": False,
-            "token": "token",
-            "chat_id": "0"
-        },
-        "initial_state": "running",
-        "datadir": ".",
-        "experimental": {
-            "use_sell_signal": True,
-            "sell_profit_only": True
-        },
-        "internals": {
-            "process_throttle_secs": 5
-        },
-        'realistic_simulation': True,
-        "loglevel": logging.DEBUG
+        table = db.Table(os.environ['strategyTable'])
 
-    }
+        response = table.query(
+            KeyConditionExpression=Key('user').eq(user) &
+                                   Key('name').eq(name)
 
-    print("generated configuration")
-    print(configuration)
+        )
 
-    print("initialized backtesting")
-    backtesting = Backtesting(configuration)
-    result = backtesting.start()
-    print("finished test")
+        print(response)
+        if "Items" in response and len(response['Items']) > 0:
 
-    print(result)
-    print("persist data in dynamo")
+            content = response['Items'][0]['content']
+            configuration = {
+                "max_open_trades": 1,
+                "stake_currency": stake_currency,
+                "stake_amount": 1,
+                "fiat_display_currency": "USD",
+                "unfilledtimeout": 600,
+                "bid_strategy": {
+                    "ask_last_balance": 0.0
+                },
+                "exchange": {
+                    "name": exchange,
+                    "enabled": True,
+                    "key": "key",
+                    "secret": "secret",
+                    "pair_whitelist": assets
+                },
+                "telegram": {
+                    "enabled": False,
+                    "token": "token",
+                    "chat_id": "0"
+                },
+                "initial_state": "running",
+                "datadir": ".",
+                "experimental": {
+                    "use_sell_signal": True,
+                    "sell_profit_only": True
+                },
+                "internals": {
+                    "process_throttle_secs": 5
+                },
+                'realistic_simulation': True,
+                "loglevel": logging.DEBUG,
+                "strategy": "{}:{}".format(name, content)
 
-    for index, row in result.iterrows():
-        item = {
-            "id": "{}.{}:{}".format(user, name, row['pair']),
-            "pair": row['pair'],
-            "profit": row['profit'],
-            "loss": row['loss'],
-            "duration": row['avg duration'],
-            "avg profit": row['avg profit %'],
-            "total profit": row['total profit {}'.format(stake_currency)]
+            }
 
-        }
+            print("generated configuration")
+            print(configuration)
 
-        print(item)
-    pass
+            print("initialized backtesting")
+            backtesting = Backtesting(configuration)
+            result = backtesting.start()
+            print("finished test")
+
+            print("persist data in dynamo")
+
+            for index, row in result.iterrows():
+                if row['loss'] > 0 or row['profit'] > 0:
+                    item = {
+                        "id": "{}.{}:{}".format(user, name, row['pair']),
+                        "pair": row['pair'],
+                        "count_profit": row['profit'],
+                        "count_loss": row['loss'],
+                        "avg_duration": row['avg duration'],
+                        "avg profit": row['avg profit %'],
+                        "total profit": row['total profit {}'.format(stake_currency)]
+
+                    }
+
+                print(item)
+        else:
+            raise Exception("sorry we did not find any matching strategy for user {} and name {}".format(user, name))
+    else:
+        raise Exception("no body provided")
 
 
 def submit(event, context):

freqtrade/aws/strategy.py

@@ -9,6 +9,7 @@ from jsonschema import validate
 
 from freqtrade.aws.schemas import __SUBMIT_STRATEGY_SCHEMA__
 from freqtrade.strategy.resolver import StrategyResolver
+import requests
 
 db = boto3.resource('dynamodb')
 
@@ -94,11 +95,6 @@ def code(event, context):
     :return:
     """
 
-    print("event")
-    print(event)
-    print("context")
-    print(context)
-
     user = ""
     name = ""
 
@@ -164,29 +160,41 @@ def submit(event, context):
     # validate that the user is an Isaac User
     # ToDo
 
-    strategy = urlsafe_b64decode(data['content']).decode('utf-8')
-
-    # print("loaded strategy")
-    # print(strategy)
-    # try to load the strategy
-    StrategyResolver().compile(data['name'], strategy)
-
-    data['time'] = int(time.time() * 1000)
-    data['type'] = "strategy"
-
-    # force serialization to deal with decimal number
-    data = json.dumps(data, use_decimal=True)
-    data = json.loads(data, use_decimal=True)
-
-    table = db.Table(os.environ['strategyTable'])
-
-    result = table.put_item(Item=data)
+    result = __evaluate(data)
     return {
         "statusCode": result['ResponseMetadata']['HTTPStatusCode'],
         "body": json.dumps(result)
     }
 
 
+def __evaluate(data):
+    """
+        evaluates the given data object and submits it to the system
+        for persistence
+        0
+    :param data:
+    :return:
+    """
+
+    strategy = urlsafe_b64decode(data['content']).decode('utf-8')
+    # print("loaded strategy")
+    # print(strategy)
+    # try to load the strategy
+    strat = StrategyResolver().compile(data['name'], strategy)
+    data['time'] = int(time.time() * 1000)
+    data['type'] = "strategy"
+    data['roi'] = strat.minimal_roi
+    data['stoploss'] = strat.stoploss
+    data['ticker'] = strat.ticker_interval
+
+    # force serialization to deal with decimal number
+    data = json.dumps(data, use_decimal=True)
+    data = json.loads(data, use_decimal=True)
+    table = db.Table(os.environ['strategyTable'])
+    result = table.put_item(Item=data)
+    return result
+
+
 def submit_github(event, context):
     """
         there has been a push to our github repository, so let's
@@ -199,4 +207,33 @@ def submit_github(event, context):
     :return:
     """
 
-    print(event)
+    print("download all strategies and updating the system")
+    result = requests.get(
+        "https://api.github.com/repos/berlinguyinca/freqtrade-trading-strategies/git/trees/master?recursive=1").json()
+
+    if 'tree' in result:
+        strategies = 0
+        for x in result['tree']:
+            if x['path'].endswith(".py") and x['type'] == 'blob':
+                file = requests.get(x['url']).json()
+
+                if "content" in file:
+                    # assemble submit object
+
+                    # generate simple id
+
+                    # submit it
+                    try:
+                        __evaluate({
+                            "name": x['path'].split("/")[-1].split(".py")[0],
+                            "content": file['content'],
+                            "user": "GBPAQEFGGWCMWVFU34PMVGS4P2NJR4IDFNVI4LTCZAKJAD3JCXUMBI4J",
+                            "public": True,
+                            "description": "imported from github repository: berlinguyinca/freqtrade-trading-strategies"
+                        })
+                        strategies = strategies + 1
+                    except ImportError as e:
+                        print("error: {}".format(e))
+        print("imported/updated: {} strategies".format(strategies))
+    else:
+        print("invalid response received \n{}\n".format(result))