azapyGUI 0.0.1__py3-none-any.whl

azapyGUI/AppSettingsPage.py

@@ -0,0 +1,213 @@
+import tkinter as tk
+from tkinter import ttk
+from tkinter import filedialog
+
+from copy import deepcopy
+
+import azapyGUI.configSettings as configSettings
+import azapyGUI.config as config
+import azapyGUI.configMSG as configMSG
+from azapyGUI.serviceMasterUserConfig import _saveMasterUserConfig
+
+class AppSettingsPage(tk.Frame):
+    def __init__(self, master, category, title):
+        self._master = master
+        self._category = category
+        super().__init__(self._master)
+        
+        self._window = self
+        
+        frm = tk.LabelFrame(master=self._window, text=title, font=("Forte", 10))
+        frm.grid(row=0, column=0, padx=5, pady=5, sticky=tk.NSEW)
+        self._window.rowconfigure(0, weight=1)
+        self._window.columnconfigure(0, weight=1)
+        
+        frm_btn = tk.Frame(master=self._window)
+        frm_btn.grid(row=1, column=0, padx=5, pady=5, sticky=tk.EW)
+        
+        # on frm
+        frm_set = tk.Frame(master=frm)
+        frm_set.grid(row=0, column=0, padx=5, pady=5, sticky=tk.NS)
+        frm.rowconfigure(0, weight=1)
+        
+        frm_view = tk.Frame(master=frm, width=150)
+        frm_view.grid(row=0, column=1, padx=5, pady=5, sticky=tk.NSEW)
+        frm.columnconfigure(1, weight=1)
+        
+        # on frm_set
+        self._setDef = configSettings.settings_model[self._category]
+        self.settings = deepcopy(configSettings.MasterApplicationSettings)
+        row = 0
+        self._chk_val = {}
+        self._chk_btn = {}
+        for param, value in self._setDef.items():
+            match value["type"]:
+                case 'ButtonDir':
+                    btn = tk.Button(master=frm_set, text=value['field'], width=18, 
+                                    command=lambda pp=param: self._get_directory_func(pp))
+                    btn.grid(row=row, column=0, padx=5, pady=5, sticky=tk.W)
+                    config.tiptil.bind(btn, value["tip"])
+                    row += 1
+                case 'Checkbutton':
+                    chk_var = tk.BooleanVar(master=frm_set, value=self.settings[param])
+                    chk_btn = tk.Checkbutton(master=frm_set, text=value["field"],
+                                             variable = chk_var, 
+                                             onvalue = True, offvalue = False, 
+                                             height=2, width=18,
+                                             command=lambda pp=param: self._chk_btn_func(pp),
+                                             anchor=tk.W)
+                    chk_btn.grid(row=row, column=0, padx=5, pady=5, sticky=tk.W)
+                    self._chk_val[param] = chk_var
+                    self._chk_btn[param] = chk_btn
+                    config.tiptil.bind(chk_btn, value["tip"])
+                    row += 1
+                case 'MCheckbutton':
+                    frm_chk = tk.LabelFrame(master=frm_set, text=value["field"])
+                    frm_chk.grid(row=row, column=0, padx=5, pady=5, sticky=tk.W)
+                    row += 1
+                    row_chk = 0
+                    self._chk_val[param] = {}
+                    self._chk_btn[param] = {}
+                    for param_chk, value_chk in value["values"].items():
+                        chk_var = tk.BooleanVar(master=frm_chk,
+                            value=True if param_chk in self.settings[param].keys() else False)
+                        chk_btn = tk.Checkbutton(master=frm_chk, text=param_chk,
+                                                 variable = chk_var, 
+                                                 onvalue = True, offvalue = False, 
+                                                 height=2, width=18,
+                                                 command=lambda param=param, pp=param_chk: self._mchk_btn_func(param, pp),
+                                                 anchor=tk.W)
+                        chk_btn.grid(row=row_chk, column=0, padx=5, pady=0, sticky=tk.W)
+                        self._chk_val[param][param_chk] = chk_var
+                        self._chk_btn[param][param_chk] = chk_btn
+                        row_chk += 1
+                case _:
+                    # you should not be here
+                    raise ValueError("Error: Unknown configSetting type")
+
+        # on frm_view
+        self._stv = ttk.Treeview(master=frm_view, selectmode="browse", show="tree")
+        self._stv.pack(padx=0, pady=0, expand=True, side=tk.LEFT, fill=tk.BOTH)
+        self._stv_write()
+                
+        vscrlb = ttk.Scrollbar(master=frm_view, 
+                               orient ="vertical", 
+                               command = self._stv.yview)
+        vscrlb.pack(padx=0, pady=2, side=tk.RIGHT, fill=tk.Y)
+        self._stv.configure(yscrollcommand = vscrlb.set)
+        
+        # on frm_btn
+        btn_cancel = tk.Button(master=frm_btn, text="Cancel/Exit", width=12, 
+                               command=self._btn_cancel_func)
+        btn_cancel.pack(padx=5, pady=5, side=tk.LEFT)
+        
+        btn_save = tk.Button(master=frm_btn, text="Save", width=12, 
+                             command=self._btn_save_func)
+        btn_save.pack(padx=5, pady=5, side=tk.RIGHT)
+        
+        btn_reset = tk.Button(master=frm_btn, text="Default Values", width=12, 
+                              command=self._btn_reset_func)
+        btn_reset.pack(padx=5, pady=5, side=tk.LEFT)
+    
+
+    def _stv_write(self):
+        for kk in self._setDef.keys():
+            val = self.settings[kk]
+            item = self._stv.insert("", tk.END, text=self._setDef[kk]["field"] + ":", open=True)
+            if isinstance(val, dict):
+                for subkk, subval in val.items():
+                    subitem = self._stv.insert(item, tk.END, text=subkk, open=True)
+                    for subsubkk, subsubval in subval.items():
+                        self._stv.insert(subitem, tk.END, text=subsubkk +" = "+ str(subsubval))
+            else:
+                self._stv.insert(item, tk.END, text=str(val))   
+                
+                
+    def _stv_refresh(self):
+        for item in self._stv.get_children():
+            self._stv.delete(item)
+        self._stv_write()
+
+
+    def _get_directory_func(self, param=None):
+        title = self._setDef[param]["title"]
+        folder_selected = filedialog.askdirectory(parent=self._window, title=title)
+        if folder_selected:
+            self.settings[param] = folder_selected
+        self._stv_refresh()
+        
+        
+    def _chk_btn_func(self, param):
+        self.settings[param] = self._chk_val[param].get()
+        self._stv_refresh()
+ 
+        
+    def _mchk_btn_func(self, param, pp):
+        if self._chk_val[param][pp].get():
+            self.settings[param][pp] = {}
+            for kk, vv in self._setDef[param]["values"][pp].items():
+                match vv['type']:
+                    case 'str':
+                        vpar = tk.simpledialog.askstring(pp, vv["field"], 
+                                                         parent=self._window, 
+                                                         initialvalue=vv["default"])
+                        if vpar == '':
+                            vpar = configSettings.get_envkey(pp)
+                            if vpar is None:
+                                msg = (configMSG._validate_provider_key_msg
+                                       +'\n' 
+                                       + configSettings.get_envkey_valriable_name(pp))
+                                tk.messagebox.showwarning(title="Warning", message=msg, parent=self._window)
+                                del self.settings[param][pp]
+                                self._chk_btn[param][pp].deselect()
+                                return
+                        self.settings[param][pp][kk] = vpar
+                    case 'int':
+                        vpar = tk.simpledialog.askinteger(pp, vv["field"], 
+                                                          parent=self._window, 
+                                                          initialvalue=vv["default"], 
+                                                          minvalue=1)
+                        self.settings[param][pp][kk] = vpar
+                    case 'float':
+                        vpar = tk.simpledialog.askfloat(pp, vv["field"], 
+                                                        parent=self._window, 
+                                                        initialvalue=vv["default"], 
+                                                        minvalue=1)
+                        self.settings[param][pp][kk] = vpar
+                    case _:
+                       # you should not be here
+                       raise ValueError("Error: in AppSettingWindow::_chk_bth_func wrong type") 
+        else:
+            del self.settings[param][pp]
+        self._stv_refresh()
+        
+        
+    def _btn_cancel_func(self):
+        if self._master.winfo_exists():
+            self._master.grab_release()
+        self._master.destroy()
+        
+        
+    def _btn_save_func(self):
+        configSettings.MasterApplicationSettings = deepcopy(self.settings)
+        _saveMasterUserConfig(configSettings.MasterApplicationSettings)
+        #self._btn_cancel_func()
+        
+        
+    def _btn_reset_func(self):
+        for kk, vv in self._setDef.items():
+            self.settings[kk] = deepcopy(vv["default"])
+            match vv["type"]:
+                case "Checkbutton":
+                    if self.settings[kk]:
+                        self._chk_btn[kk].select()
+                    else:
+                        self._chk_btn[kk].deselect()
+                case "MCheckbutton":
+                    for ll in self._setDef[kk]["values"].keys():
+                        if ll in self.settings[kk].keys():
+                            self._chk_btn[kk][ll].select()
+                        else:
+                            self._chk_btn[kk][ll].deselect()
+        self._stv_refresh()
+        

azapyGUI/AppSettingsPageMisc.py

@@ -0,0 +1,101 @@
+import tkinter as tk
+from copy import deepcopy
+
+import azapyGUI.config as config
+import azapyGUI.configSettings as configSettings
+from azapyGUI.serviceMasterUserConfig import _saveMasterUserConfig
+
+class AppSettingsPageMisc(tk.Frame):
+    def __init__(self, master):
+        self._master = master
+        super().__init__(self._master)
+        
+        self._window = self
+        self._category = "Miscellaneous"
+        
+        title = "Miscellaneous"
+        frm_set = tk.LabelFrame(master=self._window, text=title, font=("Forte", 10))
+        frm_set.grid(row=0, column=0, padx=5, pady=5, sticky=tk.NSEW)
+        self._window.rowconfigure(0, weight=1)
+        self._window.columnconfigure(0, weight=1)
+        frm_set.columnconfigure(0, weight=1)
+        frm_set.columnconfigure(1, weight=1)
+        
+        frm_btn = tk.Frame(master=self._window)
+        frm_btn.grid(row=1, column=0, padx=5, pady=5, sticky=tk.EW)
+        
+        # on frm
+        self._setDef = configSettings.settings_model[self._category]
+        self.settings = deepcopy(configSettings.MasterApplicationSettings)
+        row = 0
+        self._chk_val = {}
+        self._chk_btn = {}
+        for param, value in self._setDef.items():
+            match value["type"]:
+                case 'Checkbutton':
+                    lbl = tk.Label(master=frm_set, text=value["field"], anchor=tk.W)
+                    lbl.grid(row=row, column=0, padx=5, pady=5, sticky=tk.EW)
+                    chk_var = tk.BooleanVar(master=frm_set, value=self.settings[param])
+                    chk_btn = tk.Checkbutton(master=frm_set, variable = chk_var, 
+                                             onvalue = True, offvalue = False, 
+                                             height=2, width=18, anchor=tk.W)
+                    chk_btn.grid(row=row, column=1, padx=5, pady=5, sticky=tk.W)
+                    self._chk_val[param] = chk_var
+                    self._chk_btn[param] = chk_btn
+                    config.tiptil.bind(chk_btn, value["tip"])
+                    row += 1
+                case 'Entry':
+                    lbl = tk.Label(master=frm_set, text=value["field"], anchor=tk.W)
+                    lbl.grid(row=row, column=0, padx=5, pady=5, sticky=tk.W)
+                    ent_var = tk.StringVar(master=frm_set, value=self.settings[param])
+                    ent = tk.Entry(master=frm_set, textvariable=ent_var, validate='key', width=10)
+                    ent['validatecommand'] = (ent.register(value["validate"]),'%S','%d','%P')
+                    ent.grid(row=row, column=1, padx=5, pady=5, sticky=tk.W)
+                    self._chk_val[param] = ent_var
+                    config.tiptil.bind(ent, value["tip"])
+                    row += 1
+                case _:
+                    # you should not be here
+                    raise ValueError("Error: Unknown configSetting type")
+                    
+        # on frm_btn
+        btn_cancel = tk.Button(master=frm_btn, text="Cancel/Exit", width=12, 
+                               command=self._btn_cancel_func)
+        btn_cancel.pack(padx=5, pady=5, side=tk.LEFT)
+        
+        btn_save = tk.Button(master=frm_btn, text="Save", width=12, 
+                             command=self._btn_save_func)
+        btn_save.pack(padx=5, pady=5, side=tk.RIGHT)
+        
+        btn_reset = tk.Button(master=frm_btn, text="Default Values", width=12, 
+                              command=self._btn_reset_func)
+        btn_reset.pack(padx=5, pady=5, side=tk.LEFT)
+        
+        
+    def _btn_cancel_func(self):
+        if self._master.winfo_exists():
+            self._master.grab_release()
+        self._master.destroy()
+        
+        
+    def _btn_reset_func(self):
+        for kk, vv in self._setDef.items():
+            self.settings[kk] = deepcopy(vv["default"])
+            match vv["type"]:
+                case "Checkbutton":
+                    if self.settings[kk]:
+                        self._chk_btn[kk].select()
+                    else:
+                        self._chk_btn[kk].deselect()
+                case "Entry":
+                    self._chk_val[kk].set(self.settings[kk])
+        
+        
+    def _btn_save_func(self):
+        for param in self._chk_val.keys():
+            self.settings[param] = self._chk_val[param].get()
+        configSettings.MasterApplicationSettings = deepcopy(self.settings)
+        _saveMasterUserConfig(configSettings.MasterApplicationSettings)
+        config.tiptil.turned(on=configSettings.MasterApplicationSettings["ShowTips"])
+
+                    

azapyGUI/AppSettingsWindow.py

@@ -0,0 +1,52 @@
+import tkinter as tk 
+from tkinter import ttk
+import webbrowser
+
+import azapyGUI.configSettings as configSettings
+import azapyGUI.configHelps as configHelps
+from azapyGUI.AppSettingsPage import AppSettingsPage
+from azapyGUI.AppSettingsPageMisc import AppSettingsPageMisc
+
+class AppSettingsWindow:
+    def __init__(self, master):
+        self._master = master
+        
+        self._window = tk.Toplevel()
+        title = f"User Default Settings v.{configSettings.Version}"
+        self._window.title(title)
+        self._window.focus_set()
+        self._window.grab_set()
+        self._window.protocol("WM_DELETE_WINDOW", self._on_exit)
+
+        menubar = tk.Menu(self._window)
+        filemenu = tk.Menu(menubar, tearoff=0)
+        filemenu.add_command(label='Help', command=self._menu_help_func)
+        menubar.add_cascade(label='Help', menu=filemenu)
+        self._window.config(menu=menubar)
+        
+        ntb = ttk.Notebook(master=self._window)
+        ntb.pack(expand=True, fill=tk.BOTH)
+        
+        category = "Directors"
+        title = "Default Directories"
+        pg_dirctor = AppSettingsPage(master=self._window, category=category, title=title)
+        ntb.add(pg_dirctor, text="Directories")
+        
+        category = "MkTData"
+        title = "Market Data"
+        pg_mktdata = AppSettingsPage(master=self._window, category=category, title=title)
+        ntb.add(pg_mktdata, text="Market Data")
+        
+        pg_misc = AppSettingsPageMisc(master=self._window)
+        ntb.add(pg_misc, text="Miscellaneous")
+
+        
+    def _on_exit(self):
+        self._window.grab_release()
+        if self._master.winfo_exists():
+            self._master.focus_set()
+        self._window.destroy()
+
+    
+    def _menu_help_func(self):
+        webbrowser.open_new_tab(configHelps._Settings_panel_help)

azapyGUI/BacktestComputation.py

@@ -0,0 +1,166 @@
+import tkinter as tk 
+import time
+import azapy as az 
+
+import azapyGUI.config as config
+import azapyGUI.configModels as configModels
+from azapyGUI.GetMktData import GetMktData
+
+
+class BacktestComputation:
+    def __init__(self, master, pnames, sdate, edate, noffset, fixoffset, 
+                 capital, nsh_round, provider, force):
+        self._master = master
+        self._pnames = pnames
+        self._sdate = sdate
+        self._edate = edate
+        self._noffset = noffset
+        self._fixoffset = fixoffset
+        self._capital = capital
+        self._nsh_round = nsh_round
+        self._provider = provider
+        self._force = force
+        
+        self.backtest = {}
+        self.backtest_error = []
+        
+    def collectMktData(self):
+        symbols = set()
+        for pname in self._pnames:
+            port = config.PortDataDict[pname]
+            symbols.update(port.symbols)
+
+        gmd = GetMktData(self._provider, self._force)
+        gmd.getMkTDataSymb(list(symbols), self._sdate, self._edate)
+        self.symbols = gmd.symbols
+        errorsymb = set(gmd.errorsymb)
+        
+        if len(errorsymb) == 0: return True
+        porterror = []
+        for pname in self._pnames:
+            port = config.PortDataDict[pname]
+            res = errorsymb.intersection(port.symbols)
+            if len(res) > 0:
+                porterror.append(pname)
+                config.PortDataDict[pname].status = 'Unset'
+        port = set(self._pnames).intersection(porterror)
+        msg = (f"The following symbols, {errorsymb},\n"
+               f"cannot be retrieved from the provider {self._provider}\n"
+               f"Abort the backtesting for portfolios {porterror}.")
+        if len(port) == 0:
+            msg += "Abort backtesting!"
+            tk.messagebox.showwarning("Warning", message=msg, parent=self._master)
+            return False
+        
+        msg += ("Do you want to continue with the \n"
+                f"backtesting for {port}?")
+        ask = tk.messagebox.askyesno("Warning", message=msg)
+        if ask == 'yes':
+            self._pnames = list[port]
+            return True
+        
+        return False
+    
+    
+    def compute(self, time_port):
+        for pname in self._pnames:
+            
+            tic = time.perf_counter()
+            res = self._computePort(pname)
+            toc = time.perf_counter()
+            
+            msg = str(round(toc - tic, 4)) + 's' if res else 'error'
+            time_port[pname].set(msg)
+            self._master.update()
+            
+            if not res:
+                self.backtest_error.append(pname)
+            else:
+                self.backtest[pname] = self._btest
+        
+        return len(self.backtest_error) == 0
+    
+    
+    def _computePort(self, pname):
+        optname = list(config.PortDataDict[pname].optimizer.keys())[0]
+        if configModels.get_comptype(optname) == 'pipe':
+            return self._computePort_pipe(pname)
+        else:
+            return self._computePort_standalone(pname)
+        
+        
+    def _computePort_standalone(self, pname):
+        portdata = config.PortDataDict[pname]
+        mktdata = {symb: config.MktDataDict[symb].get_mktdata().copy() for symb in portdata.symbols}
+        
+        optname = list(config.PortDataDict[pname].optimizer.keys())[0]
+        fmname = configModels.get_model_family(optname)
+        mname = configModels.portfolio_model_family[fmname][optname]['azapy'][1]
+        param = portdata.optimizer[optname]['param']
+        freq = param['freq']
+        hlength = 0
+        pp = getattr(az, mname)(mktdata=mktdata, 
+                                sdate=self._sdate,
+                                edate=self._edate,
+                                pname=pname,
+                                pcolname='close',
+                                capital=self._capital,
+                                freq=freq, 
+                                noffset=self._noffset,
+                                fixoffset=self._fixoffset, 
+                                histoffset=hlength,
+                                calendar=config.calendar,
+                                nsh_round=self._nsh_round,
+                                )
+        pp.set_model(**param)
+        self._btest = pp
+        return (pp.status == 0)
+    
+    
+    def _computePort_pipe(self, pname):
+        portdata = config.PortDataDict[pname]
+        mktdata = {symb: config.MktDataDict[symb].mktdata.copy() for symb in portdata.symbols}
+        model = []
+        hlength = 0
+        
+        sel_list = [None] * len(portdata.selectors.keys())
+        for name, vv in portdata.selectors.items():
+            sel_list[vv['index']] = vv
+        for vv in sel_list:           
+            mname = configModels.selector_models[vv['name']]['azapy']
+            oo = getattr(az, mname)
+            moo = oo(**vv['param'])
+            model.append(moo)
+            if 'hlength' in vv['param'].keys():
+                hlength = max(hlength, vv['param']['hlength'])
+            
+        for mopt, vv in portdata.optimizer.items():
+            fmname = configModels.get_model_family(vv['name'])
+            mname = configModels.portfolio_model_family[fmname][vv['name']]['azapy']
+            if mname == 'EWPEngine':
+                model.append('EWP')
+            else:
+                oo = getattr(az, mname)
+                moo = oo(**vv['param'])
+                model.append(moo)
+                hlength = max(hlength, vv['param']['hlength'])
+            freq = vv['param']['freq']
+   
+        pipe = az.ModelPipeline(model)
+        
+        pp = az.Port_Generator(mktdata=mktdata, 
+                               sdate=self._sdate,
+                               edate=self._edate,
+                               pname=pname,
+                               pcolname='close',
+                               capital=self._capital,
+                               freq=freq, 
+                               noffset=self._noffset,
+                               fixoffset=self._fixoffset, 
+                               histoffset=hlength,
+                               calendar=config.calendar,
+                               nsh_round=self._nsh_round,
+                               )
+        pp.set_model(pipe)
+        self._btest = pp
+        return (pp.status == 0)