Merge pull request #386 from CryptoSignal/code-format

Code format

Author: laliux

app/analysis.py

@@ -4,13 +4,14 @@
 import math
 from datetime import datetime
 
-import structlog
 import pandas
+import structlog
 from talib import abstract
 
+from analyzers import *
 from analyzers.indicators import *
 from analyzers.informants import *
-from analyzers import *
+
 
 class StrategyAnalyzer():
     """Contains all the methods required for analyzing strategies.
@@ -20,7 +21,6 @@ def __init__(self):
         """Initializes StrategyAnalyzer class """
         self.logger = structlog.get_logger()
 
-
     def indicator_dispatcher(self):
         """Returns a dictionary for dynamic anaylsis selector
 
@@ -49,7 +49,6 @@ def indicator_dispatcher(self):
 
         return dispatcher
 
-
     def informant_dispatcher(self):
         """Returns a dictionary for dynamic informant selector
 
@@ -68,7 +67,6 @@ def informant_dispatcher(self):
 
         return dispatcher
 
-
     def crossover_dispatcher(self):
         """Returns a pandas.DataFrame for dynamic crossover selector
 

app/analyzers/indicators/adx.py

@@ -3,8 +3,8 @@
 Average Directional Index indicator
 """
 
-import pandas
 import numpy
+import pandas
 
 from analyzers.utils import IndicatorUtils
 
@@ -84,7 +84,6 @@ def analyze(self, historical_data, signal=["adx"], period_count=14, hot_thresh=N
 
         return adx_values
 
-
     def TR(self, high, low, close, tr):
         """
         Calculates TR (True Range)
@@ -104,7 +103,6 @@ def TR(self, high, low, close, tr):
 
         return tr
 
-
     def DM(self, high, low, pdm, ndm):
         """
         Calculates DM (Directional Movement)
@@ -130,7 +128,6 @@ def DM(self, high, low, pdm, ndm):
 
         return pdm, ndm
 
-
     def DMsmooth(self, pdm, ndm, pdm_smooth, ndm_smooth, period_count):
         """
         Smoothing positive and negative directional movement
@@ -145,12 +142,13 @@ def DMsmooth(self, pdm, ndm, pdm_smooth, ndm_smooth, period_count):
         pdm_smooth[period_count-1] = pdm[0:period_count].sum() / period_count
         ndm_smooth[period_count - 1] = ndm[0:period_count].sum() / period_count
         for index in range(period_count, pdm.shape[0]):
-            pdm_smooth[index] = (pdm[index-1] - (pdm_smooth[index-1]/period_count)) + pdm_smooth[index-1]
-            ndm_smooth[index] = (ndm[index - 1] - (ndm_smooth[index-1] / period_count)) + ndm_smooth[index-1]
+            pdm_smooth[index] = (
+                pdm[index-1] - (pdm_smooth[index-1]/period_count)) + pdm_smooth[index-1]
+            ndm_smooth[index] = (
+                ndm[index - 1] - (ndm_smooth[index-1] / period_count)) + ndm_smooth[index-1]
 
         return pdm_smooth, ndm_smooth
 
-
     def DI(self, pdm_smooth, ndm_smooth, tr, pdi, ndi):
         """
         Calculates DI (Directional Movement Indicator)
@@ -168,7 +166,6 @@ def DI(self, pdm_smooth, ndm_smooth, tr, pdi, ndi):
 
         return pdi, ndi
 
-
     def ATR(self, tr, atr, period_count):
         """
         Calculates ATR (Average True Range)
@@ -183,11 +180,11 @@ def ATR(self, tr, atr, period_count):
 
         atr[period_count-1] = tr[0:period_count].sum() / period_count
         for index in range(period_count, tr.shape[0]):
-            atr[index] = ((atr[index-1] * (period_count - 1)) + tr[index]) / period_count
+            atr[index] = ((atr[index-1] * (period_count - 1)) +
+                          tr[index]) / period_count
 
         return atr
 
-
     def ADX(self, pdi, ndi, dx, adx, period_count):
         """
         Calculates DX (Directional index) and ADX (Average Directional Index)
@@ -200,11 +197,14 @@ def ADX(self, pdi, ndi, dx, adx, period_count):
         """
 
         for index in range(0, pdi.shape[0]):
-            dx[index] = ((abs(pdi[index] - ndi[index])) / (abs(pdi[index] + ndi[index]))) * 100
+            dx[index] = ((abs(pdi[index] - ndi[index])) /
+                         (abs(pdi[index] + ndi[index]))) * 100
 
         period_count2 = period_count*2
-        adx[period_count2-1] = dx[period_count:period_count2].sum() / period_count
+        adx[period_count2-1] = dx[period_count:period_count2].sum() / \
+            period_count
         for index in range(period_count2, dx.shape[0]):
-            adx[index] = ((adx[index-1] * (period_count - 1)) + dx[index]) / period_count
+            adx[index] = ((adx[index-1] * (period_count - 1)) +
+                          dx[index]) / period_count
 
         return dx, adx

app/analyzers/indicators/aroon_oscillator.py

@@ -3,8 +3,8 @@
 Aroon Oscillator
 """
 
-import pandas
 import numpy
+import pandas
 
 from analyzers.utils import IndicatorUtils
 
@@ -36,8 +36,8 @@ def analyze(self, historical_data, sma_vol_period, period_count=25, signal=["aro
         }
 
         aroon_values = pandas.DataFrame(aroon_columns,
-                                      index=dataframe.index
-                                      )
+                                        index=dataframe.index
+                                        )
 
         for index in range(0, dataframe.shape[0]-24):
             id = dataframe.shape[0]-index
@@ -47,16 +47,20 @@ def analyze(self, historical_data, sma_vol_period, period_count=25, signal=["aro
 
             periods_since_high = id - dataframe.index.get_loc(high_date) - 1
             periods_since_low = id - dataframe.index.get_loc(low_date) - 1
-            aroon_values['aroon_up'][id-1] = 100 * ((25 - periods_since_high) / 25)
+            aroon_values['aroon_up'][id-1] = 100 * \
+                ((25 - periods_since_high) / 25)
 
-            aroon_values['aroon_down'][id-1] = 100 * ((25 - periods_since_low) / 25)
+            aroon_values['aroon_down'][id-1] = 100 * \
+                ((25 - periods_since_low) / 25)
 
-        aroon_values['aroon'] = aroon_values['aroon_up'] - aroon_values['aroon_down']
+        aroon_values['aroon'] = aroon_values['aroon_up'] - \
+            aroon_values['aroon_down']
 
         aroon_values['is_hot'] = False
         aroon_values['is_cold'] = False
 
-        aroon_values['sma_volume'] = dataframe.volume.rolling(sma_vol_period).mean()
+        aroon_values['sma_volume'] = dataframe.volume.rolling(
+            sma_vol_period).mean()
         aroon = aroon_values['aroon'].iloc[-1]
         volume = dataframe['volume'].iloc[-1]
         volume_sma = aroon_values['sma_volume'].iloc[-1]

app/analyzers/indicators/bbp.py

@@ -3,11 +3,10 @@
 Bollinger Bands indicator
 """
 
-from talib import BBANDS
-from talib import abstract
+import math
 
 import pandas
-import math
+from talib import BBANDS, abstract
 
 from analyzers.utils import IndicatorUtils
 
@@ -35,20 +34,21 @@ def analyze(self, historical_data, signal=['bbp'], hot_thresh=0, cold_thresh=0.8
 
         mfi = abstract.MFI(dataframe, period_count=14)
 
-        #Required to avoid getting same values for low, middle, up
+        # Required to avoid getting same values for low, middle, up
         dataframe['close_10k'] = dataframe['close'] * 10000
-        
-        up_band, mid_band, low_band = BBANDS(dataframe['close_10k'], timeperiod=period_count, nbdevup=std_dev, nbdevdn=std_dev, matype=0)
+
+        up_band, mid_band, low_band = BBANDS(
+            dataframe['close_10k'], timeperiod=period_count, nbdevup=std_dev, nbdevdn=std_dev, matype=0)
 
         bbp = (dataframe['close_10k'] - low_band) / (up_band - low_band)
 
         bollinger = pandas.concat([dataframe, bbp, mfi], axis=1)
         bollinger.rename(columns={0: 'bbp', 1: 'mfi'}, inplace=True)
 
-        bollinger['is_hot']  = False
+        bollinger['is_hot'] = False
         bollinger['is_cold'] = False
 
-        bollinger['is_hot'].iloc[-1]  = bollinger['bbp'].iloc[-2] <= hot_thresh and bollinger['bbp'].iloc[-2] < bollinger['bbp'].iloc[-1]
+        bollinger['is_hot'].iloc[-1] = bollinger['bbp'].iloc[-2] <= hot_thresh and bollinger['bbp'].iloc[-2] < bollinger['bbp'].iloc[-1]
         bollinger['is_cold'].iloc[-1] = bollinger['bbp'].iloc[-1] >= cold_thresh
 
-        return bollinger
+        return bollinger

app/analyzers/indicators/bollinger.py

@@ -3,10 +3,11 @@
 Bollinger Bands indicator
 """
 
-from talib import BBANDS
-import pandas
 import math
 
+import pandas
+from talib import BBANDS
+
 from analyzers.utils import IndicatorUtils
 
 
@@ -27,28 +28,31 @@ def analyze(self, historical_data, signal=['close'], hot_thresh=None, cold_thres
 
         dataframe = self.convert_to_dataframe(historical_data)
 
-        #Required to avoid getting same values for low, middle, up
+        # Required to avoid getting same values for low, middle, up
         dataframe['close_10k'] = dataframe['close'] * 10000
-        
-        up_band, mid_band, low_band = BBANDS(dataframe['close_10k'], timeperiod=period_count, nbdevup=std_dev, nbdevdn=std_dev, matype=0)
 
-        bollinger = pandas.concat([dataframe, up_band, mid_band, low_band], axis=1)
-        bollinger.rename(columns={0: 'up_band', 1: 'mid_band', 2: 'low_band'}, inplace=True)
+        up_band, mid_band, low_band = BBANDS(
+            dataframe['close_10k'], timeperiod=period_count, nbdevup=std_dev, nbdevdn=std_dev, matype=0)
+
+        bollinger = pandas.concat(
+            [dataframe, up_band, mid_band, low_band], axis=1)
+        bollinger.rename(
+            columns={0: 'up_band', 1: 'mid_band', 2: 'low_band'}, inplace=True)
 
-        old_up, old_low = bollinger.iloc[-2]['up_band'] , bollinger.iloc[-2]['low_band']
-        cur_up, cur_low = bollinger.iloc[-1]['up_band'] , bollinger.iloc[-1]['low_band']
+        old_up, old_low = bollinger.iloc[-2]['up_band'], bollinger.iloc[-2]['low_band']
+        cur_up, cur_low = bollinger.iloc[-1]['up_band'], bollinger.iloc[-1]['low_band']
 
         old_close = bollinger.iloc[-2]['close_10k']
         cur_close = bollinger.iloc[-1]['close_10k']
 
-        bollinger['is_hot']  = False
+        bollinger['is_hot'] = False
         bollinger['is_cold'] = False
 
-        bollinger['is_hot'].iloc[-1]  = old_low < old_close and cur_low > cur_close
+        bollinger['is_hot'].iloc[-1] = old_low < old_close and cur_low > cur_close
         bollinger['is_cold'].iloc[-1] = old_up > old_close and cur_up < cur_close
 
         bollinger['up_band'] = bollinger['up_band'] / 10000
         bollinger['mid_band'] = bollinger['mid_band'] / 10000
         bollinger['low_band'] = bollinger['low_band'] / 10000
 
-        return bollinger
+        return bollinger

app/analyzers/indicators/candle_recognition.py

@@ -1,7 +1,7 @@
 
-import talib
 import numpy
 import pandas
+import talib
 
 from analyzers.utils import IndicatorUtils
 
@@ -28,7 +28,7 @@ def analyze(self, historical_data, signal, notification='hot', candle_check=1, h
         low = dataframe['low']
         close = dataframe['close']
 
-        candle_functions= {
+        candle_functions = {
             'two_crows': talib.CDLTRISTAR,
             'three_black_crows': talib.CDL3BLACKCROWS,
             'three_inside_up_down': talib.CDL3INSIDE,
@@ -95,13 +95,12 @@ def analyze(self, historical_data, signal, notification='hot', candle_check=1, h
         candle_args = {'open': open, 'high': high, 'low': low, 'close': close}
         for candle in signal:
             if candle in candle_functions.keys():
-                candles_values[candle] = candle_functions[candle](**candle_args)
-
+                candles_values[candle] = candle_functions[candle](
+                    **candle_args)
 
         candles_values['is_hot'] = False
         candles_values['is_cold'] = False
 
-
         to_check = 0 - candle_check
         for candle in signal:
             if len(set(candles_values[candle].iloc[to_check:])) != 1:
@@ -114,4 +113,3 @@ def analyze(self, historical_data, signal, notification='hot', candle_check=1, h
             candles_values[candle] = candles_values[candle].astype(float)
 
         return candles_values
-

app/analyzers/indicators/ichimoku.py

@@ -11,7 +11,7 @@
 
 
 class Ichimoku(IndicatorUtils):
-    def analyze(self, historical_data, tenkansen_period, kijunsen_period , senkou_span_b_period, 
+    def analyze(self, historical_data, tenkansen_period, kijunsen_period, senkou_span_b_period,
                 signal=['leading_span_a', 'leading_span_b'], hot_thresh=None, cold_thresh=None, chart=None):
         """Performs an ichimoku cloud analysis on the historical data
 
@@ -44,17 +44,21 @@ def analyze(self, historical_data, tenkansen_period, kijunsen_period , senkou_sp
                                            index=dataframe.index
                                            )
         # value calculations
-        low_tenkansen   = dataframe['low'].rolling(window=tenkansen_period).min()
-        low_kijunsen    = dataframe['low'].rolling(window=kijunsen_period).min()
-        low_senkou      = dataframe['low'].rolling(window=senkou_span_b_period).min()
-        high_tenkansen  = dataframe['high'].rolling(window=tenkansen_period).max()
-        high_kijunsen   = dataframe['high'].rolling(window=kijunsen_period).max()
-        high_senkou     = dataframe['high'].rolling(window=senkou_span_b_period).max()
-
-        ichimoku_values['tenkansen']        = (low_tenkansen + high_tenkansen) / 2
-        ichimoku_values['kijunsen']         = (low_kijunsen + high_kijunsen) / 2
-        ichimoku_values['leading_span_a']   = ((ichimoku_values['tenkansen'] + ichimoku_values['kijunsen']) / 2)
-        ichimoku_values['leading_span_b']   = (high_senkou    + low_senkou) / 2
+        low_tenkansen = dataframe['low'].rolling(window=tenkansen_period).min()
+        low_kijunsen = dataframe['low'].rolling(window=kijunsen_period).min()
+        low_senkou = dataframe['low'].rolling(
+            window=senkou_span_b_period).min()
+        high_tenkansen = dataframe['high'].rolling(
+            window=tenkansen_period).max()
+        high_kijunsen = dataframe['high'].rolling(window=kijunsen_period).max()
+        high_senkou = dataframe['high'].rolling(
+            window=senkou_span_b_period).max()
+
+        ichimoku_values['tenkansen'] = (low_tenkansen + high_tenkansen) / 2
+        ichimoku_values['kijunsen'] = (low_kijunsen + high_kijunsen) / 2
+        ichimoku_values['leading_span_a'] = (
+            (ichimoku_values['tenkansen'] + ichimoku_values['kijunsen']) / 2)
+        ichimoku_values['leading_span_b'] = (high_senkou + low_senkou) / 2
 
         # add time period for cloud offset
         ## if cloud discplacement changed the ichimuko plot will be off ##
@@ -64,10 +68,13 @@ def analyze(self, historical_data, tenkansen_period, kijunsen_period , senkou_sp
         newindex = pandas.DatetimeIndex(start=last_time + timedelta,
                                         freq=timedelta,
                                         periods=cloud_displacement)
-        ichimoku_values = ichimoku_values.append(pandas.DataFrame(index=newindex))
+        ichimoku_values = ichimoku_values.append(
+            pandas.DataFrame(index=newindex))
         # cloud offset
-        ichimoku_values['leading_span_a'] = ichimoku_values['leading_span_a'].shift(cloud_displacement)
-        ichimoku_values['leading_span_b'] = ichimoku_values['leading_span_b'].shift(cloud_displacement)
+        ichimoku_values['leading_span_a'] = ichimoku_values['leading_span_a'].shift(
+            cloud_displacement)
+        ichimoku_values['leading_span_b'] = ichimoku_values['leading_span_b'].shift(
+            cloud_displacement)
 
         ichimoku_values['is_hot'] = False
         ichimoku_values['is_cold'] = False
@@ -80,11 +87,13 @@ def analyze(self, historical_data, tenkansen_period, kijunsen_period , senkou_sp
                     span_hot = ichimoku_values['leading_span_a'][date] > ichimoku_values['leading_span_b'][date]
                     close_hot = dataframe['close'][date] > ichimoku_values['leading_span_a'][date]
                     if hot_thresh:
-                        ichimoku_values.at[date, 'is_hot'] = span_hot and close_hot
+                        ichimoku_values.at[date,
+                                           'is_hot'] = span_hot and close_hot
                     span_cold = ichimoku_values['leading_span_a'][date] < ichimoku_values['leading_span_b'][date]
                     close_cold = dataframe['close'][date] < ichimoku_values['leading_span_a'][date]
                     if cold_thresh:
-                        ichimoku_values.at[date, 'is_cold'] = span_cold and close_cold
+                        ichimoku_values.at[date,
+                                           'is_cold'] = span_cold and close_cold
                 else:
                     pass
 
@@ -94,4 +103,4 @@ def analyze(self, historical_data, tenkansen_period, kijunsen_period , senkou_sp
         if chart == None:
             ichimoku_values.dropna(how='any', inplace=True)
 
-        return ichimoku_values
+        return ichimoku_values