moved things to a new place !

market_trade/core/CoreDraw.py

@@ -15,7 +15,7 @@ import datetime
 import matplotlib.dates as mdates
 import matplotlib.pyplot as plt
 
-import mplfinance as mpf
+#import mplfinance as mpf
 
 import plotly
 #import plotly.plotly as py
@@ -25,7 +25,7 @@ from plotly.offline import init_notebook_mode, iplot
 from plotly.subplots import make_subplots
 init_notebook_mode()
 
-import market_trade.core.CoreTraidMath
+import CoreTraidMath 
 import plotly.express as px
 
 
@@ -79,9 +79,10 @@ class corePlt():
 
 
 class coreDraw():
-    def __init__(self, data=[],needShow=False):
+    def __init__(self, data=[],needShow=False,subplot_titles={}):
         self.data=self.getPlts(data)
         self.needShow=needShow
+        self.subplot_titles=subplot_titles
         self.ans=self.getAns()
         
         
@@ -156,11 +157,11 @@ class coreDraw():
             rows=maxRow,
             cols=maxCol,
             shared_xaxes=True,
-            vertical_spacing=0.02,
+            vertical_spacing=0.1,
             shared_yaxes=True,
-            horizontal_spacing=0.02,
+            #horizontal_spacing=0.02,
             #column_widths=[]
-        
+            subplot_titles=self.subplot_titles
         )
         
         
@@ -188,7 +189,7 @@ class coreDraw():
                         except:
                             colorType='normal'
                         colors=self.getBarColorList(i.df[j],colorType)
-                        fig.add_trace(go.Bar(x=i.df['date'], y=i.df[j],name=j,marker_color=colors))
+                        fig.add_trace(go.Bar(x=i.df['date'], y=i.df[j],name=j,marker_color=colors),row=i.row, col=i.col)
                 
         
         
@@ -196,4 +197,4 @@ class coreDraw():
         ans=fig
         if self.needShow:
             plotly.offline.iplot(fig)
-        return ans
+        return ans

market_trade/core/CoreTraidMath.py

@@ -1,93 +1,102 @@
+ 
+import pandas as pd
+import datetime
 import numpy as np
+import plotly as pl
+import plotly.graph_objs as go
+import matplotlib.pyplot as plt
+import math
+import scipy
+import random
+import statistics 
+
+
+import datetime 
+
+
+
 
 
 class CoreMath:
-
-    def __init__(self, base_df, params=None):
-        """
-        Этот класс нужен для того, чтобы проводить операции над датафреймами
-        :param base_df: pandas.DataFrame , датафрейм, над которым будут проведены математические операции
-        :param params: словарь, который определяет какие данные пришли в класс, и что с ними нужно делать, и как
-        """
-        if params is None:
-            params = {
-                'dataType': 'ohcl',
-                'action': None,
-                'actionOptions': {}
-            }
-
-        # нужно переопределить индексы, потому что нам ничего не известно об индексации входного файла
-        self.base_df = base_df.reset_index(drop=True)
-
-        self.params = params
-
-        # Эта часть определяет с какой частью данных нужно проводить вычисления
+    
+    def __init__(self, base_df, params={
+        'dataType':'ohcl',
+        'action': None,
+        'actionOptions':{}
+    }
+                ):
+    
+        self.base_df=base_df.reset_index(drop=True)
+        self.params=params
         if self.params['dataType']=='ohcl':
             self.col=self.base_df[self.params['actionOptions']['valueType']]
         elif self.params['dataType']=='series':
             self.col=self.base_df
-
-        # собственно производим вычисления
         self.ans=self.getAns()
-
+        
+    
     def getAns(self):
-        """
-        Эта функция занимается собственно рутингом вычислений, в зависимости от параметров
-        :return: ans, неопределенный тип данных, в заивисимости от action
-        """
         ans=None
-
-        # в зависимости от параметра action производятся соответсвующие действия
+        
         if self.params['action']=='findExt':
             ans = self.getExtremumValue()
         elif self.params['action']=='findMean':
             ans = self.getMeanValue()
         elif self.params['action']=='findSTD':
-            ans = self.getSTD()
-
+            ans=self.getSTD()
+        
+            
         return ans
-
-
+    
+    
     def getExtremumValue(self):
-        """
-        Эта функция возвращает экстремум произвольного типа внутри одного столбца
-        Тип контролируется разделом внутри словаря параметров `self.params` по ключу `actionOptions`:
-            'extremumtype': -- тип экстремума
+        ans=None
+        '''
+        actionOptions:
+            'extremumtype':
                 'min'
                 'max'
-        :return ans, экстремум произвольного типа
-        """
-        ans=None
+            'valueType':
+                'open'
+                'close'
+                'high'
+                'low'
+        '''
         if self.params['actionOptions']['extremumtype']=='max':
             ans=max(self.col)
-
+            
         if self.params['actionOptions']['extremumtype']=='min':
             ans=min(self.col)
 
+            
         return ans
-
+     
+        
     def getMeanValue(self):
-        """
-        Божественный код
-        Эта функция возвращает среднее значение одного из следующих типов.
-        Для определения типа используется словарь `self.params`, по ключу `actionOptions`, релевантные ключи выглядят
-        так:
+        '''
+        actionOptions:
             'MeanType':
-                'MA' -- среднее по всему столбцу
-                'SMA'  -- скользящее среднее
-                'EMA' -- экспоненциальное скользящее среднее
-                'WMA' -- взвешенное скользящее среднее
-            'window' -- размер окна
-            'span' -- >=1 , аналог окна для экспоненциального среднего, чем он больше тем меньше коэффициент сглаживания
-            'weights' -- numpy.ndarray, список размером в параметр `window`, конкретные веса для каждого элемента
-        """
-
+                'MA'
+                'SMA'
+                'EMA'
+                'WMA'
+                --'SMMA'
+            'valueType':
+                'open'
+                'close'
+                'high'
+                'low'
+            'window'
+            'span'
+            'weights'
+        '''
         ans=None
-
         if self.params['actionOptions']['MeanType']=='MA':
             ans = self.col.mean()
         if self.params['actionOptions']['MeanType']=='SMA':
             ans=np.convolve(self.col, np.ones(self.params['actionOptions']['window']), 'valid') / self.params['actionOptions']['window']
+            #ans=self.col.rolling(window=self.params['actionOptions']['window']).mean().to_list()
+            
         if self.params['actionOptions']['MeanType']=='EMA':
             ans=self.col.ewm(span=self.params['actionOptions']['span'], adjust=False).mean().to_list()
         if self.params['actionOptions']['MeanType']=='WMA':
@@ -97,8 +106,10 @@ class CoreMath:
                 weights=np.arange(1,self.params['actionOptions']['window']+1)
             ans=self.col.rolling(window=self.params['actionOptions']['window']).apply(lambda x: np.sum(weights*x) / weights.sum(), raw=False).to_list()
 
-        return ans
-
+        
+        
+        return(ans)
+    
     def getSTD(self):
         '''
         actionOptions:
@@ -109,7 +120,7 @@ class CoreMath:
         
         
         '''
-
+        
         ans=None
 
 
@@ -117,11 +128,11 @@ class CoreMath:
             window=self.params['actionOptions']['window']
             ans=np.asarray([])
             for i in range(len(self.col)-window+1):
-                ans=np.append(ans, np.std(self.col[i:i+window], ddof=1))
-
+                ans=np.append(ans,np.std(self.col[i:i+window], ddof=1))
+            
         except:
             #window = len(self.col)
             ans=np.std(self.col, ddof=1)
 
         return ans
-
+        

market_trade/core/dealManager.py

@@ -0,0 +1,49 @@
+import pandas as pd
+import datetime
+import numpy as np
+import uuid 
+
+class DealManager():
+    
+    def __init__(self):
+        #self.commission=0.04
+        self.columns=['uuid','figi','amount','startPrice']
+        self.deals = pd.DataFrame(columns=self.columns)
+        self.deals = self.deals.set_index('uuid')
+        
+    def findDealByPriceAndFig(self,price,figi):
+        ans=None
+        for i in range(self.deals.shape[0]):
+            if self.deals.iloc[i].startPrice == price and self.deals.iloc[i].figi == figi:
+                ans = self.deals.iloc[i].name
+                break
+        return ans
+
+    def openDeal(self,figi,startPrice,amount=1):
+        desiredDeal=self.findDealByPriceAndFig(startPrice,figi)
+        if desiredDeal == None:
+            newDealDict={
+                'uuid':[str(uuid.uuid4())],
+                'figi':[figi],
+                'startPrice':[startPrice],
+                'amount':[amount]
+            }
+
+            #newDealDict['profit']=[startPrice*pow(1+self.commission,2)]
+
+
+
+            newDeal=pd.DataFrame.from_dict(newDealDict).set_index('uuid')
+            self.deals=pd.concat([self.deals, newDeal])
+        else:
+            self.deals.at[desiredDeal,'amount'] += amount
+
+    def closeDeal(self,uuid,amount):
+        
+        desiredDeal=self.deals.loc[uuid]
+        if desiredDeal.amount - amount == 0:
+            self.deals = self.deals.drop(labels = [uuid],axis = 0)
+        else:
+            self.deals.at[uuid,'amount'] -= amount
+            #self.deals.loc[uuid].amount = desiredDeal.amount - amount
+        

market_trade/core/decisionManager.py

@@ -0,0 +1,116 @@
+import pandas as pd
+import datetime
+import numpy as np
+
+import pickle
+from signals import *
+from dealManager import *
+from trandeVoter import *
+from riskManager import riskManager
+
+
+class decsionManager():
+
+    
+    def __init__(self,name):
+        self.name = name
+        self.RM = riskManager()
+        self.DM = DealManager()
+        self.TV = trandeVoter(name)
+        self.SA = signalAgrigator()
+        pass
+    
+    #вытащенный из signalAgrigator метод теста для сигналов
+    def getSignalTest(self,data: pd.DataFrame(),reqSig: dict, batchSize=30, dataType='candel') -> dict:
+        
+        self.SA.mode = 'retroFast'
+        t.SA.createSingnalInstances(
+            data = data,
+            dictAgrigSignal = reqSig,
+            dataType='candel',
+            batchSize=30
+        )
+        ans = t.SA.getAns(data)
+        return ans
+    
+    #метод для генерации матрицы вероятностей.
+    def generateMatrixProbability(self, 
+                                  data: pd.DataFrame(),
+                                  reqSig: dict, 
+                                  target: str, 
+                                  batchSize=30, 
+                                  #dataType='candel'
+                                 ):
+        data=data.reset_index(drop=True)
+        
+        t.SA.createSingnalInstances(
+            data = data,
+            dictAgrigSignal = reqSig,
+            dataType='candel',
+            batchSize=batchSize
+        )
+        self.TV.createMatrixAmounts(reqSig.keys())
+        for i in range(data.shape[0]-batchSize-1):
+            sigAns=self.SA.getAns(data[i:i+batchSize])
+            rightAns=self.getRetroStepAns(data[target][i],data[target][i+1])
+            self.TV.setDecisionBySignals(self.KostilEbaniy(sigAns),rightAns)
+        self.TV.generateMatrixProbability()
+    
+    #без коментариев блять
+    def KostilEbaniy(self,d):
+        ans={}
+        for i in d.keys():
+            if d[i] == 0:
+                ans[i] = 'none'
+            elif d[i] == 1:
+                ans[i] = 'up'
+            elif d[i] == -1:
+                ans[i] = 'down'
+        return ans
+    
+    #тож понятная хуита
+    def getRetroStepAns(self, value1,value2):
+        
+        if value1 == value2:
+            ans = 'none'
+        elif value1 < value2:
+            ans = 'up'
+        else:
+            ans = 'down'
+        return ans
+        
+    #метод для онлай получения решения по сигналу
+    def getSignal(self,data: pd.DataFrame(),reqSig: dict, dataType='candel') -> dict:
+        data=data.reset_index(drop=True)
+        self.SA.mode = 'online'
+        t.SA.createSingnalInstances(
+            data = data,
+            dictAgrigSignal = reqSig,
+            dataType='candel',
+            batchSize=30
+        )
+        ans = t.SA.getAns(data)
+        return ans        
+    
+    
+    #Создание сигналов. Вызывать перед getOnlineAns
+    def crateSignals(self,data: pd.DataFrame(),reqSig: dict, dataType='candel'):
+        data=data.reset_index(drop=True)
+        self.SA.mode = 'online'
+        t.SA.createSingnalInstances(
+            data = data,
+            dictAgrigSignal = reqSig,
+            dataType='candel',
+            batchSize=30
+        )
+        
+    
+    def getOnlineAns(self,data: pd.DataFrame(),price):
+        sigAns = self.SA.getAns(data)
+        prob = self.TV.getDecisionBySignals(sigAns)
+        ans = self.RM.getDecision(sigAns,prob,price)
+        return ans
+        
+        
+        
+        

market_trade/core/decisionManager_v2.py

@@ -0,0 +1,161 @@
+import os
+
+import pandas as pd
+import datetime
+import numpy as np
+
+from tqdm import tqdm
+
+from indicators_v2 import *
+from signals_v2 import *
+from dealManager import *
+from trandeVoter import *
+from riskManager import *
+import pickle
+
+
+class decsionManager:
+    '''
+sigAgrReq = {
+    'sig_BB':{
+        'className':sig_BB,
+        'params':{'source':'close','target':'close'},
+        'indicators':{
+            'ind_BB':{
+                'className':ind_BB,
+                'params':{'MeanType':'SMA','window':30,'valueType':'close','kDev':2.5}
+            }            
+        }
+    },
+    'sig_BB_2':{
+        'className':sig_BB,
+        'params':{'source':'close','target':'close'},
+        'indicators':{
+            'ind_BB':{
+                'className':ind_BB,
+                'params':{'MeanType':'SMA','window':30,'valueType':'close','kDev':2}
+            }            
+        }
+    }
+}
+
+sigAgrData = {
+    'sig_BB':{
+        'signalData': df_candle[990:1000],
+        'indicatorData' :{'ind_BB': df_candle[:1000]}
+    },
+    'sig_BB_2':{
+        'signalData': df_candle[990:1000],
+        'indicatorData' :{'ind_BB': df_candle[:1000]}
+    }    
+}
+
+
+sigAgrRetroTemplate = {
+    'sig_BB':{
+        'signalData': None,
+        'indicatorData' :{'ind_BB': None}
+    },
+    'sig_BB_2':{
+        'signalData': None,
+        'indicatorData' :{'ind_BB': None}
+    }     
+}    
+    
+    
+    
+    
+    
+    
+    '''
+    
+    
+    
+    
+    def __init__(self,name, sigDict: dict):
+        self.RM = riskManager()
+        self.DM = DealManager()
+        self.TV = trandeVoter(name)
+        self.SA = signalsAgrigator(sigDict)
+        self.sigDict = sigDict
+        
+        
+    def getOnlineAns(self, signalsAns: dict, price: float) -> dict:
+        probabilityDecsion = self.TV.getDecisionBySignals(self.getSignalsAns(signalsAns))
+        RMD = self.RM.getDecision(probabilityDecision=probabilityDecsion, price=price, deals = self.DM.deals)
+        return RMD
+        
+    def getSignalsAns(self, signalsDataDict: dict) -> dict:
+        return self.SA.getAns(signalsDataDict)
+    
+    def getRightAns(self,value_1, value_2):
+        
+        ans=''
+        
+        if value_1 > value_2:
+            ans = 'down'
+        elif value_1 < value_2:
+            ans = 'up'
+        else:
+            ans = 'none'
+        
+        return ans
+        
+    def getRetroTrendAns(self, retroTemplateDict: dict, data: pd.DataFrame(), window: int) -> list:
+        
+        reqSig={} 
+        ans = {
+            'signalsAns':[],
+            'rightAns':[]
+            
+        }
+        target = ''
+        
+        
+        for k in tqdm(range(data.shape[0]-window-1)):
+            for i in retroTemplateDict.keys():
+                reqSig[i] = {'signalData': data[k:k+window], 'indicatorData':{}}
+                target = self.SA.signals[i].params['target']
+                for j in retroTemplateDict[i]['indicatorData'].keys():
+                    reqSig[i]['indicatorData'][j] = data[k:k+window]
+                    
+            sigAns = self.getSignalsAns(reqSig)
+            rightAns = self.getRightAns(data[target][k], data[target][k+1])
+
+            ans['signalsAns'].append(sigAns)
+            ans['rightAns'].append(rightAns)
+
+        return ans
+ 
+
+    def generateMatrixProbabilityFromDict(self, dictSignals: dict) -> dict:
+        self.TV.createMatrixAmounts(dictSignals['signalsAns'][0].keys())
+        for i in range(len(dictSignals['signalsAns'])):
+            self.TV.setDecisionBySignals(signalDecisions = dictSignals['signalsAns'][i],
+                                        trande = dictSignals['rightAns'][i])
+        self.TV.generateMatrixProbability()
+        
+    def createDump(self,postfix='') -> str:
+        dataDict = {
+            'RM':self.RM,
+            'DM':self.DM,
+            'TV':self.TV,
+            'SA':self.SA,
+            'sigDict':self.sigDict
+        }
+        fileName='data_'+postfix+'.pickle'
+        with open(fileName, 'wb') as f:
+            pickle.dump(dataDict, f)
+            
+        return os.path.abspath(fileName)
+    
+    def loadDump(self,path: str) -> None:
+        
+        with open(path, 'rb') as f:
+            dataDict = pickle.load(f)
+        
+        self.RM = dataDict['RM']
+        self.DM = dataDict['DM']
+        self.TV = dataDict['TV']
+        self.SA = dataDict['SA']
+        self.sigDict = dataDict['sigDict']

market_trade/core/indicators.py

@@ -2,8 +2,8 @@ import pandas as pd
 import datetime
 import numpy as np
 
-import market_trade.core.CoreTraidMath as CoreTraidMath
-import market_trade.core.CoreDraw as CoreDraw
+import CoreTraidMath 
+import CoreDraw
 
 class coreIndicator():
     def __init__(self,

market_trade/core/indicators_v2.py

@@ -0,0 +1,89 @@
+import pandas as pd
+import datetime
+import numpy as np
+
+import CoreTraidMath 
+
+class coreIndicator():
+    
+    def __init__(self,options: dict, dataType: str = None, predictType: str = None, name: str = None):
+        self.options = options
+        self.dataType = dataType #ochl
+        self.predictType = predictType #trend
+        
+    
+    def getAns(self, data: pd.DataFrame() ):
+        return "ERROR"
+    
+class indicatorsAgrigator:
+    """
+    indicators = {
+        'ind_BB':{
+            'className':ind_BB,
+            'params':{'MeanType':'SMA','window':15,'valueType':'close','kDev':2.5}
+        }
+    }
+    dataDic={
+        'ind_BB':df_candle[:1000]
+    }        
+    
+    
+    """
+    
+    def __init__ (self,indDict={}):
+        self.indDict = indDict
+        self.indInst = {}
+        self.ans={}
+        self.createIndicatorsInstance()
+    
+    def createIndicatorsInstance(self):
+        for i in self.indDict.keys():
+            self.indInst[i]=self.indDict[i]['className'](self.indDict[i]['params'])
+            
+    def getAns(self,dataDict={}):
+        ans={}
+        for i in dataDict.keys():
+            ans[i] = self.indInst[i].getAns(dataDict[i])
+        return ans
+    
+class ind_BB(coreIndicator):
+    """
+    options
+        MeanType -> SMA
+        window -> int
+        valueType -> str: low, high, open, close
+        kDev -> float
+    
+    """
+    
+    def __init__(self,options: dict,name = None):
+        super().__init__(
+            options = options,
+            dataType = 'ochl',
+            predictType = 'trend',
+            name = name
+        )
+    
+    def getAns(self, data: pd.DataFrame()):
+        data=data.reset_index(drop=True)
+        ans={}
+        opMA={'dataType':'ohcl',
+            'action':'findMean',
+            'actionOptions':{
+                'MeanType':self.options['MeanType'],
+                'valueType':self.options['valueType'],
+                'window':self.options['window']
+            }
+        }
+        ans['BB']=CoreTraidMath.CoreMath(data,opMA).ans
+        opSTD={'dataType':'ohcl',
+            'action':'findSTD',
+            'actionOptions':{'valueType':self.options['valueType'],'window':self.options['window']}
+        }
+        ans['STD']=CoreTraidMath.CoreMath(data,opSTD).ans
+        ans['pSTD']=ans['BB']+ans['STD']*self.options['kDev']
+        ans['mSTD']=ans['BB']-ans['STD']*self.options['kDev']
+        ans['x']=np.array(data['date'][self.options['window']-1:].to_list())
+        self.ans= ans
+        return ans
+    

market_trade/core/riskManager.py

@@ -0,0 +1,29 @@
+import pandas as pd
+import datetime
+import numpy as np
+import random
+
+class riskManager:
+    
+    def __init__(self,commision=0.04):
+        self.commision = commision
+        pass
+    def getDecision(self,probabilityDecision, price, deals=None) -> dict:
+        ans = {}
+        ans['decision'] = 'none'
+        if probabilityDecision['trande'] == 'up':
+            ans['decision'] = 'buy'
+            ans['amount'] = 1
+        elif probabilityDecision['trande'] == 'none':
+            ans['decision'] = 'none'
+        elif probabilityDecision['trande'] == 'down': 
+            for i in range(deals.shape[0]):
+                ans['decision'] = 'None'
+                ans['deals'] = []
+                row = deals.iloc[i]
+                if row.startPrice < price*pow(1+self.commission,2):
+                    ans['decision'] = 'sell'
+                    ans['deals'].append(row.name)
+        return ans
+        
+    

market_trade/core/signals.py

@@ -2,12 +2,11 @@ import pandas as pd
 import datetime
 import numpy as np
 
-import market_trade.core.CoreTraidMath as CoreTraidMath
-import market_trade.core.CoreDraw as CoreDraw
+import CoreTraidMath 
+import CoreDraw
 from tqdm import tqdm
 
-from market_trade.core.indicators import *
-
+from indicators import *
 
 class coreSignalTrande():
     def __init__(self,
@@ -17,140 +16,133 @@ class coreSignalTrande():
                  batchSize=None,
                  indParams=None,
                  signalParams=None,
-                 # needFig=False,
-                 # showOnlyIndex=False,
-                 # drawFig=False,
-                 # equalityGap=0
-                 ):
-
-        self.data = data.reset_index(drop=True)
-        self.onlineData = data.reset_index(drop=True)
-        self.dataType = dataType
-        self.mode = mode
-        self.ans = None
-        self.softAnalizList = np.asarray([])
-        self.hardAnalizList = np.asarray([])
-        self.analizMetrics = {}
-        self.indParams = indParams
-        self.signalParams = signalParams
-        self.batchSize = batchSize
-        # self.needFig=needFig
-        # self.showOnlyIndex=showOnlyIndex
-        # self.drawFig=drawFig
-        # self.equalityGap=equalityGap
-
-    # Роутер получения ответа
-    def getAns(self, data):
-        # ans='Error: unknown Mode!'
-        ans = None
+                 #needFig=False,
+                 #showOnlyIndex=False,
+                 #drawFig=False,
+                 #equalityGap=0
+                ):
+        
+        self.data=data.reset_index(drop=True)
+        self.onlineData=data.reset_index(drop=True)
+        self.dataType=dataType
+        self.mode=mode
+        self.ans=None
+        self.softAnalizList=np.asarray([])
+        self.hardAnalizList=np.asarray([])
+        self.analizMetrics={}
+        self.indParams=indParams
+        self.signalParams=signalParams
+        self.batchSize=batchSize
+        #self.needFig=needFig
+        #self.showOnlyIndex=showOnlyIndex
+        #self.drawFig=drawFig
+        #self.equalityGap=equalityGap
+    #Роутер получения ответа
+    def getAns(self,data):
+        #ans='Error: unknown Mode!'
+        ans=None
         print("Start processing...")
         if self.mode == 'online':
-            ans = self.getOnlineAns(data.reset_index(drop=True))
+            ans=self.getOnlineAns(data.reset_index(drop=True))
         elif self.mode == 'retro':
-            ans = self.getRetroAns(data)
+            ans=self.getRetroAns(data)
         elif self.mode == 'retroFast':
-            ans = self.getRetroFastAns(data)
+            ans=self.getRetroFastAns(data)
         print("Processing DONE!")
         return ans
-
-    # Ретро режим, где расширяется окно добавлением новых элементов
-    def getRetroAns(self, data):
-        ans = np.asarray([])
-        for i in tqdm(range(self.batchSize, len(data) - 1)):
-            # self.onlineData=self.data[0:i]
+    #Ретро режим, где расширяется окно добавлением новых элементов
+    def getRetroAns(self,data):
+        ans=np.asarray([])
+        for i in tqdm(range(self.batchSize,len(data)-1)):
+            #self.onlineData=self.data[0:i]
             window_data = data[0:i]
             window_data.reset_index(drop=True)
-            ans = np.append(ans, (self.getOnlineAns(window_data)))
-        self.ans = ans
+            ans=np.append(ans,(self.getOnlineAns(window_data)))
+        self.ans=ans
         self.getAnaliz()
         self.getMetrix()
         return ans
-
-    # Ретро режим, где двигается окно
-    def getRetroFastAns(self, data):
-        # print('d - ',data)
-        ans = np.asarray([])
-        for i in tqdm(range(len(data) - 1 - self.batchSize)):
-            # self.onlineData=self.data[i:i+self.batchSize]
-            window_data = data[i:i + self.batchSize]
-            # print('win - ',window_data)
+    #Ретро режим, где двигается окно
+    def getRetroFastAns(self,data):
+        #print('d - ',data)
+        ans=np.asarray([])
+        for i in tqdm(range(len(data)-1-self.batchSize)):
+            #self.onlineData=self.data[i:i+self.batchSize]
+            window_data = data[i:i+self.batchSize]
+            #print('win - ',window_data)
             window_data.reset_index(drop=True)
-            # print('win - ',window_data)
-            ans = np.append(ans, (self.getOnlineAns(window_data)))
-        self.ans = ans
+            #print('win - ',window_data)
+            ans=np.append(ans,(self.getOnlineAns(window_data)))
+        self.ans=ans
         self.getAnaliz()
         self.getMetrix()
         return ans
-
-    # Метод, который будет переопределять каждый дочерний класс
+    #Метод, который будет переопределять каждый дочерний класс
     def getOnlineAns(self):
         return 'Error'
-
     def getAnaliz(self):
         print("Start analiz...")
         for i in (range(len(self.ans))):
-            sourceValue = self.data[self.signalParams['source']][i + self.batchSize]
-            targetValue = self.data[self.signalParams['target']][i + self.batchSize + 1]
-            if (targetValue) > sourceValue:
-                if self.ans[i] == 1:
-                    self.softAnalizList = np.append(self.softAnalizList, 1)
-                    self.hardAnalizList = np.append(self.hardAnalizList, 1)
-                elif self.ans[i] == -1:
-                    self.softAnalizList = np.append(self.softAnalizList, -1)
-                    self.hardAnalizList = np.append(self.hardAnalizList, -1)
+            sourceValue=self.data[self.signalParams['source']][i+self.batchSize]
+            targetValue=self.data[self.signalParams['target']][i+self.batchSize + 1]
+            if (targetValue)>sourceValue:
+                if self.ans[i]==1:
+                    self.softAnalizList=np.append(self.softAnalizList,1)
+                    self.hardAnalizList=np.append(self.hardAnalizList,1)
+                elif self.ans[i]==-1:
+                    self.softAnalizList=np.append(self.softAnalizList,-1)
+                    self.hardAnalizList=np.append(self.hardAnalizList,-1)
                 else:
-                    self.softAnalizList = np.append(self.softAnalizList, 0)
-                    self.hardAnalizList = np.append(self.hardAnalizList, -1)
-
-            elif (targetValue) < sourceValue:
-                if self.ans[i] == 1:
-                    self.softAnalizList = np.append(self.softAnalizList, -1)
-                    self.hardAnalizList = np.append(self.hardAnalizList, -1)
-                elif self.ans[i] == -1:
-                    self.softAnalizList = np.append(self.softAnalizList, 1)
-                    self.hardAnalizList = np.append(self.hardAnalizList, 1)
+                    self.softAnalizList=np.append(self.softAnalizList,0)
+                    self.hardAnalizList=np.append(self.hardAnalizList,-1)
+            
+            elif (targetValue)<sourceValue:
+                if self.ans[i]==1:
+                    self.softAnalizList=np.append(self.softAnalizList,-1)
+                    self.hardAnalizList=np.append(self.hardAnalizList,-1)
+                elif self.ans[i]==-1:
+                    self.softAnalizList=np.append(self.softAnalizList,1)
+                    self.hardAnalizList=np.append(self.hardAnalizList,1)
                 else:
-                    self.softAnalizList = np.append(self.softAnalizList, 0)
-                    self.hardAnalizList = np.append(self.hardAnalizList, -1)
+                    self.softAnalizList=np.append(self.softAnalizList,0)
+                    self.hardAnalizList=np.append(self.hardAnalizList,-1)
             else:
-                if self.ans[i] == 1:
-                    self.softAnalizList = np.append(self.softAnalizList, -1)
-                    self.hardAnalizList = np.append(self.hardAnalizList, -1)
-                elif self.ans[i] == -1:
-                    self.softAnalizList = np.append(self.softAnalizList, -1)
-                    self.hardAnalizList = np.append(self.hardAnalizList, -1)
+                if self.ans[i]==1:
+                    self.softAnalizList=np.append(self.softAnalizList,-1)
+                    self.hardAnalizList=np.append(self.hardAnalizList,-1)
+                elif self.ans[i]==-1:
+                    self.softAnalizList=np.append(self.softAnalizList,-1)
+                    self.hardAnalizList=np.append(self.hardAnalizList,-1)
                 else:
-                    self.softAnalizList = np.append(self.softAnalizList, 0)
-                    self.hardAnalizList = np.append(self.hardAnalizList, 1)
+                    self.softAnalizList=np.append(self.softAnalizList,0)
+                    self.hardAnalizList=np.append(self.hardAnalizList,1)   
         print("Analiz DONE!")
         return 0
-
-    def getMeteixDict(self, d):
+    def getMeteixDict(self,d):
         '''
         1 - (сбывшиеся + несбывшиеся) \ (сбывшиеся + несбывшиеся +0)
         2 - (сбывшиеся - несбывшиеся) \ (сбывшиеся + несбывшиеся +0)
         '''
         return {
-
-            '1': (d['1'] + d['-1']) / (d['1'] + d['-1'] + d['0']),
-            '2': (d['1'] - d['-1']) / (d['1'] + d['-1'] + d['0']),
-
+ 
+            '1':(d['1'] + d['-1']) / (d['1'] + d['-1'] + d['0']),
+            '2':(d['1'] - d['-1']) / (d['1'] + d['-1'] + d['0']),
+            
         }
-
+        
     def getMetrix(self):
 
-        softAnalizCount = {'-1': 0, '0': 0, '1': 0}
-        hardAnalizCount = {'-1': 0, '0': 0, '1': 0}
+        softAnalizCount = {'-1':0,'0':0,'1':0}
+        hardAnalizCount = {'-1':0,'0':0,'1':0}
         for i in range(len(self.softAnalizList)):
-            softAnalizCount[str(int(self.softAnalizList[i]))] += 1
-            hardAnalizCount[str(int(self.hardAnalizList[i]))] += 1
-        self.analizMetrics = {'softAnaliz': self.getMeteixDict(softAnalizCount),
-                              'hardAnaliz': self.getMeteixDict(hardAnalizCount)
-                              }
-
+            softAnalizCount[str(int(self.softAnalizList[i]))]+=1
+            hardAnalizCount[str(int(self.hardAnalizList[i]))]+=1
+        self.analizMetrics = {'softAnaliz':self.getMeteixDict(softAnalizCount),
+                              'hardAnaliz':self.getMeteixDict(hardAnalizCount)
+                             }
 
 class signal_BB(coreSignalTrande):
-
+    
     def __init__(self,
                  data=pd.DataFrame(),
                  dataType='candel',
@@ -158,37 +150,101 @@ class signal_BB(coreSignalTrande):
                  batchSize=None,
                  indParams=None,
                  signalParams=None,
-                 ):
+                ):
         super().__init__(
-            data=data,
-            dataType=dataType,
-            mode=mode,
-            batchSize=batchSize,
-            indParams=indParams,
-            signalParams=signalParams,
-        )
-
+                 data=data,
+                 dataType=dataType,
+                 mode=mode,
+                 batchSize=batchSize,
+                 indParams=indParams,
+                 signalParams=signalParams,
+                )
+        
         if self.indParams == None:
-            indParams = {'MeanType': 'SMA', 'window': 15, 'valueType': 'low', 'kDev': 2}
+            indParams={'MeanType':'SMA','window':15,'valueType':'low','kDev':2}
         else:
-            indParams = self.indParams
-        self.BB = ind_BB(
+            indParams=self.indParams
+        self.BB=ind_BB(
             data=data,
             options=indParams,
         )
-
-    def getOnlineAns(self, data):
-        ans = 0
-        # print(data)
+        
+    
+    def getOnlineAns(self,data):
+        ans=0
+        #print(data)
 
         self.BB.getAns(data)
-        # print(BB)
-        lastValue = data[self.signalParams['source']].to_list()[-1]
-        if lastValue > self.BB.ans['pSTD'][-1]:
-            ans = -1
-        elif lastValue < self.BB.ans['mSTD'][-1]:
-            ans = +1
+        #print(BB)
+        lastValue=data[self.signalParams['source']].to_list()[-1]
+        if lastValue>self.BB.ans['pSTD'][-1]:
+            ans=-1
+        elif lastValue<self.BB.ans['mSTD'][-1]:
+            ans=+1
         else:
-            ans = 0
-
+            ans=0
+        
         return ans
+    
+class signalAgrigator:
+    """
+    dictAgrigSignal
+        key - name str
+        value - dict
+            className - class
+            indParams - dict
+            signalParams - dict
+            batchSize - int
+        
+    
+    """
+    def __init__(self,
+                 data=pd.DataFrame(),
+                 dictAgrigSignal={},
+                 mode='online',
+                 dataType='candel',
+                 batchSize=None
+                ):
+        self.createSingnalInstances(
+            data,
+            dictAgrigSignal,
+            dataType,
+            batchSize
+        )
+        self.mode=mode
+         
+         
+
+    def createSingnalInstances(
+        self,
+        data,
+        dictAgrigSignal,
+        dataType,
+        batchSize
+        ):
+        
+        ans={}
+        
+        for i in dictAgrigSignal:
+            ans[i]=dictAgrigSignal[i]['className'](
+                data=data,
+                dataType=dataType,
+                batchSize=batchSize,
+                indParams=dictAgrigSignal[i]['indParams'],
+                signalParams=dictAgrigSignal[i]['signalParams'],
+                mode=self.mode
+            )
+        self.signalsInstances = ans
+        return ans
+    
+    def getAns(self, data):
+        ans={}
+        
+        if self.mode == 'online':
+            for i in self.signalsInstances:
+                ans[i]=(self.signalsInstances[i].getAns(data))
+        elif self.mode == 'retroFast' or self.mode == 'retro':
+            for i in self.signalsInstances:
+                self.signalsInstances[i].getAns(data)
+                ans[i]=self.signalsInstances[i].analizMetrics
+        return ans

market_trade/core/signals_v2.py

@@ -0,0 +1,112 @@
+import pandas as pd
+import datetime
+import numpy as np
+
+import CoreTraidMath 
+#import CoreDraw
+from tqdm import tqdm
+
+from indicators_v2 import *
+
+
+
+class coreSignalTrande:
+    
+    def __init__(self, name: str, req: dict, dataType: str):
+        self.name = name
+        self.agrigateInds = self.createIndicatorsInstance(req)
+        self.params = req['params']
+        self.dataType = dataType
+        
+    
+    def createIndicatorsInstance(self,req: dict) -> dict:
+        return indicatorsAgrigator(req['indicators'])
+    
+    def getIndAns(self, dataDict: dict) -> dict:
+        return self.agrigateInds.getAns(dataDict)
+    
+    def getAns(self, data: pd.DataFrame(), indDataDict: dict) -> dict:
+        return self.getSigAns(data, self.getIndAns(indDataDict)) 
+        
+    
+    
+class sig_BB(coreSignalTrande):
+    """
+    ind keys:
+        ind_BB
+    """
+    
+    def __init__(self, name: str, req:dict):
+        super().__init__(name, req, 'ochl')
+    
+    def getSigAns(self, data: pd.DataFrame(), indAnsDict: dict) -> dict:
+
+        lastValue = data[self.params['source']].to_list()[-1]
+        if lastValue>indAnsDict['ind_BB']['pSTD'][-1]:
+            ans='down'
+        elif lastValue<indAnsDict['ind_BB']['mSTD'][-1]:
+            ans='up'
+        else:
+            ans='none'
+        
+        return ans
+        
+        
+class signalsAgrigator:
+    
+    """
+    sigAgrReq = {
+        'sig_BB':{
+            'className':sig_BB,
+            'params':{'source':'close','target':'close'},
+            'indicators':{
+                'ind_BB':{
+                    'className':ind_BB,
+                    'params':{'MeanType':'SMA','window':15,'valueType':'close','kDev':2.5}
+                }            
+            }
+        },
+        'sig_BB_2':{
+            'className':sig_BB,
+            'params':{'source':'close','target':'close'},
+            'indicators':{
+                'ind_BB':{
+                    'className':ind_BB,
+                    'params':{'MeanType':'SMA','window':30,'valueType':'close','kDev':2}
+                }            
+            }
+        }
+    }
+
+    sigAgrData = {
+        'sig_BB':{
+            'signalData': df_candle[990:1000],
+            'indicatorData' :{'ind_BB': df_candle[:1000]}
+        },
+        'sig_BB_2':{
+            'signalData': df_candle[990:1000],
+            'indicatorData' :{'ind_BB': df_candle[:1000]}
+        }    
+    }    
+
+
+
+
+
+    """
+    
+    def __init__ (self,req:dict):
+        self.signals = self.createSignalsInstance(req)
+        
+    def createSignalsInstance(self, siganlsDict: dict) -> dict:
+        ans = {}
+        for i in siganlsDict.keys():
+            ans[i]=siganlsDict[i]['className'](name = i, req = siganlsDict[i])
+        return ans
+    
+    def getAns(self, dataDict: dict) -> dict:
+        ans = {}
+        for i in dataDict.keys():
+            ans[i] = self.signals[i].getAns(data = dataDict[i]['signalData'], 
+                                   indDataDict = dataDict[i]['indicatorData'])
+        return ans

market_trade/core/trandeVoter.py

@@ -0,0 +1,83 @@
+import pandas as pd
+import datetime
+import numpy as np
+#import random
+
+class trandeVoter():
+    
+    def __init__(self,name):
+       
+        self.name = name # просто имя
+        self.trandeValuesList = ['up','none','down'] #словарь трегдов
+        self.matrixAmounts = None # матрица сумм
+        self.keysMatrixAmounts = None #ключи матрицы сумм, техническое поле
+        self.matrixProbability = None # матрица вероятностей
+        
+    
+    #функция которая создает df с заданным набором колонок и индексов. индексы - уникальные соотношения 
+    def createDFbyNames(self, namesIndex, namesColoms,defaultValue=0.0):
+        df = pd.DataFrame(dict.fromkeys(namesColoms, [defaultValue]*pow(3,len(namesIndex))),
+                          index=pd.MultiIndex.from_product([self.trandeValuesList]*len(namesIndex), names=namesIndex)
+                            #,columns=namesColoms
+                        )
+        return(df)
+    
+    #создание матрицы сумм с дефолтным значением
+    def createMatrixAmounts(self,namesIndex: list) -> pd.DataFrame():
+        self.matrixAmounts = self.createDFbyNames(namesIndex,self.trandeValuesList,0)
+        self.keysMatrixAmounts = self.matrixAmounts.to_dict('tight')['index_names']
+        self.createMatrixProbability(namesIndex)
+        return(self.matrixAmounts)
+    
+    #создание матрицы вероятностей с дефолтным значением
+    def createMatrixProbability(self,namesIndex: list) -> pd.DataFrame():
+        self.matrixProbability = self.createDFbyNames(namesIndex,self.trandeValuesList)
+        return(self.matrixProbability)
+    
+    #установка значений в матрицы сумм. signalDecisions - значения индикаторов key:value; trande - реальное значение
+    def setDecisionBySignals(self,signalDecisions: dict,trande: str) -> None:
+        buff=[]
+        for i in self.keysMatrixAmounts:
+            buff.append(signalDecisions[i])
+        self.matrixAmounts.loc[tuple(buff),trande] += 1
+        
+    #заполнение матрицы вероятностей вычисляемыми значениями из матрицы сумм
+    def generateMatrixProbability(self) -> None:
+        for i in range(self.matrixAmounts.shape[0]):
+            rowSum=sum(self.matrixAmounts.iloc[i])
+            self.matrixProbability.iloc[i]['up'] = (self.matrixAmounts.iloc[i]['up'] / rowSum)
+            self.matrixProbability.iloc[i]['none'] = self.matrixAmounts.iloc[i]['none'] / rowSum
+            self.matrixProbability.iloc[i]['down'] = self.matrixAmounts.iloc[i]['down'] / rowSum
+
+    #получение рещения из матрицы вероятностей по заданным значениям сигналов
+    def getDecisionBySignals(self,signalDecisions: dict) -> dict:
+        ans = {}
+        spliceSearch =self.matrixProbability.xs(tuple(signalDecisions.values()),
+                                                       level=list(signalDecisions.keys())
+                                                      ) 
+        ans['probability'] = spliceSearch.to_dict('records')[0]
+        ans['trande'] = spliceSearch.iloc[0].idxmax()
+        return ans
+    
+    #получение матриц вероятностей и суммы в видей словарей
+    def getMatrixDict(self) -> dict:
+        ans={}
+        ans['amounts'] = self.matrixAmounts.to_dict('tight')
+        ans['probability'] = self.matrixProbability.to_dict('tight')
+        return ans
+    
+    #установка матриц вероятностей и суммы в видей словарей
+    def setMatrixDict(self,matrixDict: dict) -> dict:
+        if matrixDict['amounts'] != None:
+            self.matrixAmounts = pd.DataFrame.from_dict(y['amounts'], orient='tight')
+        if matrixDict['probability'] != None:
+            self.matrixProbability = pd.DataFrame.from_dict(y['probability'], orient='tight') 
+        
+        
+
+    
+    
+    
+    
+
+        

market_trade/tests/test.py

@@ -4,7 +4,7 @@ import pandas as pd
 
 
 if __name__ == '__main__':
-    df_candle = pd.read_csv(market_trade.src.constants.TEST_CANDLESTICKS_PATH)
+    df_candle = pd.read_csv(market_trade.constants.TEST_CANDLESTICKS_PATH)
     df_candle.rename(columns={'timestamp': 'date'}, inplace=True)
     ind_params = {'MeanType': 'SMA', 'window': 15, 'valueType': 'close', 'kDev': 2.5}
     signalParams = {'source': 'close', 'target': 'close'}

market_trade/tests/test_dataloader.py

@@ -3,11 +3,11 @@ import market_trade.constants
 
 
 def test_dataloader(data_path):
-    duka_interface = (market_trade.src.dataloader.DukaMTInterface(data_path))
+    duka_interface = (market_trade.data.dataloader.DukaMTInterface(data_path))
     print(duka_interface.ask_candlesticks)
 
 
 if __name__ == '__main__':
-    candlesticks_filepaths = [filepath for filepath in market_trade.src.constants.CANDLESTICK_DATASETS_PATH.iterdir()]
+    candlesticks_filepaths = [filepath for filepath in market_trade.constants.CANDLESTICK_DATASETS_PATH.iterdir()]
     candlesticks_filepath = candlesticks_filepaths[0]
     test_dataloader(candlesticks_filepath)

market_trade/tests/test_decision.py

@@ -0,0 +1 @@
+im