DLE-190516-Impl finish predicted rates

Author: Anh-Duy Le

.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "python.pythonPath": "C:\\Program Files (x86)\\Python37-32\\python.exe"
+}

config.py

@@ -6,7 +6,7 @@
 sys.path.append(os.path.dirname(ROOT_DIR + r'/'))# Add absolute path to current sys.path
 # print('Path: ' + str(sys.path))
 
-from domains.domain_container import DomainContainer
+from domains.domain_factory import DomainFactory
 
 class Configuration():
 
@@ -15,8 +15,8 @@ def __init__(self):
         self.ConfigFileName = "config.json"
         self.ConfigFilePath = Path(ROOT_DIR + r'\\' + self.ConfigFileName)
         self.Platform = self.getOSplatform()
-        self.domain_container = DomainContainer()
-        self.ApiConfigModel = self.domain_container.init_ModelClass('ApiConfigModel')
+        self.domain_factory = DomainFactory()
+        self.ConfigApiModel = self.domain_factory.init_ModelClass('ConfigApiModel')
 
 
     def getOSplatform(self):        
@@ -42,7 +42,7 @@ def getApiConfig(self, apiName):
                     # print(config)  
                     for cf in list(config['configurations']):
                         if(cf['type'] == "api" and cf['api_name'] == apiName):                            
-                            modelApiConfig = self.domain_container.map_JsonToAnDomainClass(self.ApiConfigModel, cf)
+                            modelApiConfig = self.domain_factory.map_JsonToDomainClass(self.ConfigApiModel, cf)
                             return modelApiConfig
 
         except Exception as ex:

core_utils/util_common.py

@@ -1,4 +1,4 @@
-from datetime import datetime
+from datetime import datetime, timedelta, date
 
 
 class Core_UtilityCommon():
@@ -12,7 +12,46 @@ def validateDateFormat(self, date_text):
             if date_text != datetime.strptime(date_text, "%Y-%m-%d").strftime('%Y-%m-%d'):
                 raise ValueError
             return True
-        except ValueError:
+        except ValueError as ex:
+            print('Error: ', ex)
             return False
 
-    
+    def parseStringToDate(self, date_text):
+        try:
+            if(type(date_text) is date or type(date_text) is datetime):                   
+                return date_text
+            
+            date_obj = datetime.strptime(date_text, '%Y-%m-%d')
+            datetime.combine(date_obj, datetime.min.time())
+            # print('Date:', date_obj.date())  
+            return date_obj 
+        except Exception as ex:
+            print('Error: ', ex)
+            return None
+
+    def parseStringToDateTime(self, datetime_text):
+        try:
+            if(type(datetime_text) is date or type(datetime_text) is datetime):              
+                return datetime_text
+            
+            date_time_obj = datetime.strptime(datetime_text, '%Y-%m-%d %H:%M:%S.%f')
+            # print('Date:', date_time_obj.date())  
+            # print('Time:', date_time_obj.time())  
+            # print('Date-time:', date_time_obj)  
+            return date_time_obj
+        except Exception as ex:
+            print('Error: ', ex)
+            return None
+
+    def dateRange(self, start_date, end_date):              
+        try:
+            start_date = (type(start_date) is str) and self.parseStringToDate(start_date) or start_date
+            end_date = (type(end_date) is str) and self.parseStringToDate(end_date) or end_date                
+            
+            for n in range(int ((end_date - start_date).days + 1)):
+                yield start_date + timedelta(n)
+        except Exception as ex:
+            print('Error: ', ex)
+            return None   
+        
+        

domains/analysis_data/ExchangeRateModel.py

@@ -0,0 +1,42 @@
+# Facade Pattern
+"""
+doc: Model class with the decorator
+"""
+class ExchangeRateModel(object):
+    """
+    A data descriptor that sets and returns values normally and optional prints a message logging their access.
+    """
+    def __init__(self):
+        pass
+
+
+    @property
+    def BaseCurrency(self):
+        return self.__BaseCurrency
+    @BaseCurrency.setter
+    def BaseCurrency(self, val):
+        self.__BaseCurrency = val
+
+    @property
+    def ConvertedCurrency(self):
+        return self.__ConvertedCurrency
+    @ConvertedCurrency.setter
+    def ConvertedCurrency(self, val):
+        self.__ConvertedCurrency = val
+
+    @property
+    def OnDate(self):
+        return self.__OnDate
+    @OnDate.setter
+    def OnDate(self, val):
+        self.__OnDate = val
+
+
+    @property
+    def RateValue(self):
+        return self.__RateValue
+    @RateValue.setter
+    def RateValue(self, val):
+        self.__RateValue = val
+
+

domains/analysis_data/linear_model_v1.pkl

@@ -1,4 +1,4 @@
-
+# Facade Pattern
 """
 doc: Model class with the decorator
 """

domains/api/ApiOpenExcRateModel.py

@@ -1,8 +1,8 @@
-
+# Facade Pattern
 """
 doc: Model class with the decorator
 """
-class ApiConfigModel(object):
+class ConfigApiModel(object):
     """
     A data descriptor that sets and returns values normally and optional prints a message logging their access.
     """

domains/config/ApiConfigModel.py renamed to domains/config/ConfigApiModel.py

@@ -1,8 +1,8 @@
-
+# Facade Pattern
 """
 doc: Model class with the decorator
 """
-class ApiParamConfigModel(object):
+class ConfigApiParamModel(object):
     """
     A data descriptor that sets and returns values normally and optional prints a message logging their access.
     """

domains/config/ApiParamConfigModel.py renamed to domains/config/ConfigApiParamModel.py

@@ -1,23 +1,24 @@
 import inspect
 import sys
 
-
+from domains.analysis_data.ExchangeRateModel import ExchangeRateModel
 from domains.api.ApiOpenExcRateModel import ApiOpenExcRateModel
-from domains.config.ApiConfigModel import ApiConfigModel
-from domains.config.ApiParamConfigModel import ApiParamConfigModel
+from domains.config.ConfigApiModel import ConfigApiModel
+from domains.config.ConfigApiParamModel import ConfigApiParamModel
 
+#Factory Pattern
 """
 doc: Container to declare all entities model
 """
-class DomainContainer():
+class DomainFactory():
 
     def __init__(self):
         pass
 
 
     def get_allDomainClassRegistered(self):
 
-        container = [(name, obj) for name, obj in list(inspect.getmembers(sys.modules[__name__], inspect.isclass)) if name not in DomainContainer.__name__]
+        container = [(name, obj) for name, obj in list(inspect.getmembers(sys.modules[__name__], inspect.isclass)) if name not in DomainFactory.__name__]
         return container
 
 
@@ -29,27 +30,15 @@ def init_ModelClass(self, className):
                 return obj
 
 
-    # def print_ValueDomainClass(self, model):
-
-    #     if(model is not None and inspect.isclass(type(model))):
-    #         attrs = [ (key, value) for key, value in inspect.getmembers(model) 
-    #             if (key not in dir(type('dummy', (object,), {}))) 
-    #             and not (key.startswith('_') or key.endswith('_')) 
-    #         ]
-
-    #         for key, value in attrs:
-    #             print(str(key) + ': ' + str(value))
-
+    def init_ObjectClass(self, className):
 
-    # def print_ValueListDomainClass(self, listmodel):
-
-    #     if(listmodel is not None):
-    #         for item in listmodel:
-    #             print('#'*40)
-    #             self.print_ValueDomainClass(item)
+        clsmembers = self.get_allDomainClassRegistered()
+        for name, obj in clsmembers:
+            if name in className:
+                return obj()
 
 
-    def map_JsonToAnDomainClass(self, modelClass, obj):
+    def map_JsonToDomainClass(self, modelClass, obj):
 
         if modelClass is None or obj is None:
             return None

domains/domain_container.py renamed to domains/domain_factory.py

@@ -1,5 +1,12 @@
 import os, sys
 import inspect, types
+from datetime import timedelta, date, datetime
+
+import matplotlib.pyplot as plt
+
+from sklearn.linear_model import LinearRegression
+from sklearn.model_selection import train_test_split
+import joblib
 
 ROOT_DIR = os.getcwd()  # Get root directory
 sys.path.append(os.path.dirname(ROOT_DIR + r'/'))# Add abase_serviceolute path to current sys.path
@@ -12,16 +19,20 @@
 """
 class ExchangeRateService():
 
+
+
     def __init__(self):
         self.base_service = BaseService()        
-        self.domain_container = self.base_service.DomainContainer()
+        self.domain_factory = self.base_service.DomainFactory()
         self.util_common = self.base_service.UtilCommon()
-        self.util_data = self.base_service.UtilData()
-        self.ApiConfigModel = self.domain_container.init_ModelClass('ApiConfigModel')
-        self.ApiParamConfigModel = self.domain_container.init_ModelClass('ApiParamConfigModel')
-        self.ApiOpenExcRateModel = self.domain_container.init_ModelClass('ApiOpenExcRateModel')
+        self.util_data = self.base_service.UtilData()        
         self.ApiConfig1 = self.base_service.Config.getApiConfig("openexchangerates_exchange_rates")
 
+        self.ConfigApiModel = self.domain_factory.init_ModelClass('ConfigApiModel')
+        self.ConfigApiParamModel = self.domain_factory.init_ModelClass('ConfigApiParamModel')
+        self.ApiOpenExcRateModel = self.domain_factory.init_ModelClass('ApiOpenExcRateModel')
+        self.ExchangeRateModel = self.domain_factory.init_ModelClass('ExchangeRateModel')
+        
 
     def __init_apiUrl(self):        
         if self.ApiConfig1:
@@ -31,7 +42,7 @@ def __init_apiUrl(self):
 
     def __init_apiParamsString(self):
         if self.ApiConfig1:
-            lstApiParam = self.domain_container.map_ListJsonToListDomainClass(self.ApiParamConfigModel, self.ApiConfig1.api_params)
+            lstApiParam = self.domain_factory.map_ListJsonToListDomainClass(self.ConfigApiParamModel, self.ApiConfig1.api_params)
             apiStr = ""
             for idx, para in enumerate(lstApiParam):
                 singleParam = "{0}={1}".format(para.param_name, para.default_value)
@@ -55,7 +66,7 @@ def get_exrate_byDate(self, dateReport, baseCurrency):
     def get_specific_exrate_byDate(self, dateReport, baseCurrency, toCurrency):
         data = self.get_exrate_byDate(dateReport, baseCurrency)
         for key, value in data.items():
-            print(key + ' - ' + str(value))
+            # print(key + ' - ' + str(value))
             if(isinstance(value, dict) and key == "rates"):
                 for cur, rate in value.items():
                     if(cur == toCurrency):
@@ -67,23 +78,67 @@ def get_specific_exrate_byDate(self, dateReport, baseCurrency, toCurrency):
         return None       
 
 
-    def get_specific_exrate_byDateRange(self, fromDate, toDate, baseCurrency, toCurrency):
-        from datetime import timedelta, date
-
-        def daterange(start_date, end_date):
-            for n in range(int ((end_date - start_date).days)):
-                yield start_date + timedelta(n)
+    def get_specific_exrate_byDateRange(self, fromDate, toDate, checkedDate, baseCurrency, toCurrency):        
+        # print('Checked Date: Exchange Rates')  
+        lstExcRates = []
+        for single_date in self.util_common.dateRange(fromDate, toDate):
+            if any(da == single_date.day for da in checkedDate):
+            # if(single_date.day == checkedDate):                
+                data = self.get_specific_exrate_byDate(single_date.strftime("%Y-%m-%d"), baseCurrency, toCurrency)  
+                # print(single_date.strftime("%Y-%m-%d") + ': ' + str(data.RateValue))         
+
+                model = self.ExchangeRateModel()
+                model.BaseCurrency = baseCurrency
+                model.ConvertedCurrency = toCurrency
+                model.OnDate = single_date.month#datetime.timestamp(single_date)#convert datetime to timestamp
+                model.RateValue = data.RateValue
+
+                lstExcRates.append(model)
+
+        return len(lstExcRates) > 0 and lstExcRates or None
+
+    def display_graph(self, listdata):       
+
+        date = [x.OnDate for x in listdata]
+        rate = [x.RateValue for x in listdata]
+
+        plt.scatter(
+            date,
+            rate,
+            c='black'
+        )
+        plt.xlabel("Date")
+        plt.ylabel("Rates")
+        plt.show()
+
+    def training_model(self, listdata):
+        date = [[x.OnDate] for x in listdata]
+        rate = [[x.RateValue] for x in listdata]
+
+        #Use 70% of data as training, rest 30% to Test model
+        x_train, x_test, y_train, y_test = train_test_split(date, rate, test_size=0.3)
+        # training model
+        linear = LinearRegression()
+        linear.fit(x_train, y_train)
+
+        # evaluating model
+        score_trained = linear.score(x_test, y_test)
+        print("Model scored:", score_trained)
+
+        # saving model
+        joblib.dump(linear, ROOT_DIR + r'/domains/analysis_data/linear_model_v1.pkl')
+
+        # loading model
+        clf = joblib.load(ROOT_DIR + r'/domains/analysis_data/linear_model_v1.pkl')
+        predicted = clf.predict(x_test)#linear.predict(x_test)
+        print("Predicted Max:", predicted.max())
+        print("Predicted Min:", predicted.min())
+        print("Predicted: ", predicted)
+    
 
-        start_date = date(2013, 1, 1)
-        end_date = date(2015, 6, 2)
-        for single_date in daterange(start_date, end_date):
-            print(single_date.strftime("%Y-%m-%d"))
-        
-        # data = self.get_specific_exrate_byDate()
-        
-        
 
-        return None                   
+    
+     
 
 
 

service/banking/exchangerate_service.py

@@ -9,7 +9,7 @@
 from core_utils.util_common import Core_UtilityCommon
 from core_utils.util_data import Core_UtilityData
 
-from domains.domain_container import DomainContainer
+from domains.domain_factory import DomainFactory
 from config import Configuration
 
 """
@@ -22,8 +22,8 @@ class BaseService():
     def __init__(self):
         pass
 
-    def DomainContainer(self):
-        return DomainContainer()
+    def DomainFactory(self):
+        return DomainFactory()
 
     def UtilCommon(self):
         return Core_UtilityCommon()