MSTR-Robotics-magerdaniel 0.3.11__tar.gz → 0.3.12__tar.gz

{mstr_robotics_magerdaniel-0.3.11 → mstr_robotics_magerdaniel-0.3.12/MSTR_Robotics_magerdaniel.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: MSTR_Robotics_magerdaniel
-Version: 0.3.11
+Version: 0.3.12
 Summary: MicroStrateg(P)ython
 Home-page: https://github.com/magerdaniel
 Author: Daniel Mager
@@ -24,6 +24,7 @@ Dynamic: classifier
 Dynamic: description
 Dynamic: description-content-type
 Dynamic: home-page
+Dynamic: license-file
 Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary

{mstr_robotics_magerdaniel-0.3.11/MSTR_Robotics_magerdaniel.egg-info → mstr_robotics_magerdaniel-0.3.12}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: MSTR_Robotics_magerdaniel
-Version: 0.3.11
+Version: 0.3.12
 Summary: MicroStrateg(P)ython
 Home-page: https://github.com/magerdaniel
 Author: Daniel Mager
@@ -24,6 +24,7 @@ Dynamic: classifier
 Dynamic: description
 Dynamic: description-content-type
 Dynamic: home-page
+Dynamic: license-file
 Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary

{mstr_robotics_magerdaniel-0.3.11 → mstr_robotics_magerdaniel-0.3.12}/mstr_robotics/_connectors.py

@@ -134,6 +134,12 @@ class mstr_api():
         report_def=conn.get(url)
         return report_def.json()
 
+    def get_cube_all_def(self,conn, cube_id, showExpressionAs="tokens", showFilterTokens="true",
+                         showAdvancedProperties="true"):
+        url = f'{conn.base_url}/api/model/cubes/{cube_id}?showExpressionAs={showExpressionAs}&showFilterTokens={showFilterTokens}&showAdvancedProperties={showAdvancedProperties}'
+        cube_all_def_d = conn.get(url).json()
+        return cube_all_def_d
+
     def get_report_raw(self,conn,report_id,instance_id):
         #normaly I use the report libraries from mstrio
         # to fetch the data. Sometimes they bring back an error. so this one is for trouble

{mstr_robotics_magerdaniel-0.3.11 → mstr_robotics_magerdaniel-0.3.12}/mstr_robotics/_helper.py

@@ -1,5 +1,18 @@
 class str_func:
 
+    def web_base_url(self,base_url):
+        url_start = base_url.split("/")  # Split by backslash
+        web_base_url=f'{url_start[0]+"//"+url_start[2]}/MicroStrategy/servlet/mstrWeb?'
+        return web_base_url
+
+    def get_server_base_url(self,base_url):
+        url_parts = base_url.split("/")
+        server = url_parts[2].split(":")
+        return server[0]
+
+    def get_project_name_base_url(self, project_name):
+        return project_name.replace(" ", "+")
+
     def rem_braket(self, exp):
         if exp[:1] =="(":
             exp = exp.replace("(", "")

{mstr_robotics_magerdaniel-0.3.11 → mstr_robotics_magerdaniel-0.3.12}/mstr_robotics/dossier.py

@@ -106,15 +106,14 @@ class doss_read_out_det():
     def run_read_out_doss_hier_det(self, conn, dossier_l):
         self.visual_list = []
         for dossier_id in dossier_l:
-            instance_id=i_mstr_api.create_dossier_instance(conn,dossier_id)
-            doss_hier = i_mstr_api.get_dossier_def(conn, dossier_id)
-            # print(doss_hier)
-            self.visual_d = {}
-            self.visual_d["dossier_id"] = dossier_id
-            self.visual_d["dossier_name"] = doss_hier["name"]
-            self.visual_d["error_msg"] = ''
             try:
-
+                instance_id=i_mstr_api.create_dossier_instance(conn,dossier_id)
+                doss_hier = i_mstr_api.get_dossier_def(conn, dossier_id)
+                # print(doss_hier)
+                self.visual_d = {}
+                self.visual_d["dossier_id"] = dossier_id
+                self.visual_d["dossier_name"] = doss_hier['name']
+                self.visual_d["error_msg"] = ''
                 for chapter in doss_hier["chapters"]:
                     # print(chapter)
                     self.visual_d["chapter_key"] = chapter["key"]
@@ -122,7 +121,9 @@ class doss_read_out_det():
                     self.read_pages_hier_det(conn=conn,chapter=chapter, instance_id=instance_id)
 
             except Exception as err:
-                print(err)
+                #print(err)
+                self.visual_d["dossier_id"] = dossier_id
+                self.visual_d["dossier_name"] = ""
                 self.visual_d["chapter_key"] = ""
                 self.visual_d["chapter_name"] = ""
                 self.visual_d["page_key"] = ""

{mstr_robotics_magerdaniel-0.3.11 → mstr_robotics_magerdaniel-0.3.12}/mstr_robotics/navigation.py

@@ -183,19 +183,25 @@ class answer_prompts():
                     break
         return prp_ans_l
 
-    def save_AI_rep(self, conn, report_id, prompt_answ, ai_rep_name, ai_rep_folder_id):
+    def save_AI_rep(self, conn, report_id, prompt_answ, ai_rep_name, ai_rep_folder_id, promptOption="static"):
         instance_id = i_rep.open_Instance(conn=conn, report_id=report_id)
         first_draft = i_rep.set_inst_prompt_ans(conn=conn, report_id=report_id, instance_id=instance_id,
                                                 prompt_answ=prompt_answ)
 
+        """
         rep_stat = i_rep.get_open_prp_stat(conn=conn, report_id=report_id, instance_id=instance_id)
 
+
         if rep_stat == 2:
-            prompt_answ = i_rep.close_open_prp(conn=conn, report_id=report_id, instance_id=instance_id,
+            prompt_answ = i_prompts.close_open_prp(conn=conn, report_id=report_id, instance_id=instance_id,
                                          prompt_answ=prompt_answ)
+
+            first_draft = i_rep.set_inst_prompt_ans(conn=conn, report_id=report_id, instance_id=instance_id,
+                                                prompt_answ=prompt_answ)
+        """
         rep_id = i_rep.save_rep_inst(conn=conn, instance_id=instance_id, rep_name=ai_rep_name
                                           , save_mode="OVERWRITE"
-                                          , promptOption="static"
+                                          , promptOption=promptOption
                                           , setCurrentAsDefaultAnswer=True)
 
         return rep_id

{mstr_robotics_magerdaniel-0.3.11 → mstr_robotics_magerdaniel-0.3.12}/mstr_robotics/prepare_AI_data.py

@@ -14,7 +14,7 @@ i_mstr_global=mstr_global()
 i_rep=rep()
 i_mstr_api=mstr_api()
 
-class read_out_cube_att():
+class zzz_read_out_cube_att():
 
     def trans_cbe_el_prp(self, ele_str):
 
@@ -23,27 +23,6 @@ class read_out_cube_att():
         el_ans_d = {"id": ':'.join(el_l[-1 * (len(el_l) - 1):]) + ";" + el_l[0]}
         return el_ans_d
 
-
-    def zzz_read_cube_att_elements(self,conn,cube_list_l ):
-        key_val_l=[]
-
-        for cube_id in cube_list_l:
-            #print(cube_id["id"])
-            cube = OlapCube(connection=conn, id=cube_id["id"])
-            att_ell_l=cube.attr_elements
-            for att in att_ell_l:
-                #print(att["attribute_name"])
-                key_val_d={}
-                key_val_d["attribute_id"]=att["attribute_id"]
-                key_val_d["attribute_name"]=att["attribute_name"]
-                for element in att["elements"]:
-                    #print(element)
-                    key_val_d["element_ans"]=self.trans_cbe_el_prp(ele_str=element["id"])
-                    key_val_d["element_val_key"]=element["formValues"][0]
-                    key_val_l.append(key_val_d.copy())
-
-        return key_val_l
-
     def read_cube_att_forms(self,conn,cube_def, att_name, form_name=None):
         #reads out attorm definitions
         rag_att_form_id_d = {}
@@ -100,31 +79,59 @@ class read_out_cube_att():
             all_cube_element_l.extend(cube_element_l)
         return all_cube_element_l
 
+
+    def zzz_read_cube_att_elements(self,conn,cube_list_l ):
+        key_val_l=[]
+
+        for cube_id in cube_list_l:
+            #print(cube_id["id"])
+            cube = OlapCube(connection=conn, id=cube_id["id"])
+            att_ell_l=cube.attr_elements
+            for att in att_ell_l:
+                #print(att["attribute_name"])
+                key_val_d={}
+                key_val_d["attribute_id"]=att["attribute_id"]
+                key_val_d["attribute_name"]=att["attribute_name"]
+                for element in att["elements"]:
+                    #print(element)
+                    key_val_d["element_ans"]=self.trans_cbe_el_prp(ele_str=element["id"])
+                    key_val_d["element_val_key"]=element["formValues"][0]
+                    key_val_l.append(key_val_d.copy())
+
+        return key_val_l
+
 class map_objects():
 
     def get_doss_rep_prp(self,conn, object_l):
         prp_rep_l = []
+        prp_rep_err_l = []
         for rep_dos in object_l:
-            if rep_dos["type"] == 3:
-                for prp in i_rep.get_rep_prp_l(conn=conn, report_id=rep_dos["id"]):
-                    rep_prp_d = {}
-                    rep_prp_d["project_id"]=conn.project_id
-                    rep_prp_d["rep_dos_id"] = rep_dos["id"]
-                    rep_prp_d["type"] = rep_dos["type"]
-                    rep_prp_d["sub_type"] = rep_dos["sub_type"]
-                    rep_prp_d["prompt_id"] = prp.id
-                    prp_rep_l.append(rep_prp_d.copy())
-            elif rep_dos["type"] == 55:
-                for prp in i_mstr_api.get_dossier_prp_l(conn=conn, dossier_id=rep_dos["id"]):
-                    rep_prp_d = {}
-                    rep_prp_d["project_id"]=conn.project_id
-                    rep_prp_d["rep_dos_id"] = rep_dos["id"]
-                    rep_prp_d["type"] = rep_dos["type"]
-                    rep_prp_d["sub_type"] = rep_dos["sub_type"]
-                    rep_prp_d["prompt_id"] = prp["id"]
-                    prp_rep_l.append(rep_prp_d.copy())
-
-        return prp_rep_l
+            try:
+                if rep_dos["type"] == 3:
+                    for prp in i_rep.get_rep_prp_l(conn=conn, report_id=rep_dos["id"]):
+                        rep_prp_d = {}
+                        rep_prp_d["project_id"]=conn.project_id
+                        rep_prp_d["rep_dos_id"] = rep_dos["id"]
+                        rep_prp_d["type"] = rep_dos["type"]
+                        rep_prp_d["sub_type"] = rep_dos["sub_type"]
+                        rep_prp_d["prompt_id"] = prp.id
+                        prp_rep_l.append(rep_prp_d.copy())
+                elif rep_dos["type"] == 55:
+                    for prp in i_mstr_api.get_dossier_prp_l(conn=conn, dossier_id=rep_dos["id"]):
+                        rep_prp_d = {}
+                        rep_prp_d["project_id"]=conn.project_id
+                        rep_prp_d["rep_dos_id"] = rep_dos["id"]
+                        rep_prp_d["type"] = rep_dos["type"]
+                        rep_prp_d["sub_type"] = rep_dos["sub_type"]
+                        rep_prp_d["prompt_id"] = prp["id"]
+                        prp_rep_l.append(rep_prp_d.copy())
+
+            except Exception as e:
+                prp_rep_err_d = {"rep_dos_id": rep_dos["id"], "rep_dos_type":rep_dos["type"], "err_msg": str(e)}
+                prp_rep_err_l.append(prp_rep_err_d.copy())
+
+        all_rep_prp_d = {"prp_rep_l": prp_rep_l, "prp_rep_err_l": prp_rep_err_l}
+        return all_rep_prp_d
 
     def get_RAG_cube_attribute_id(self,conn, cube_l):
         cube_att_l = []
@@ -138,11 +145,11 @@ class map_objects():
                 cube_att_l.append(cube_att_d.copy())
         return cube_att_l
 
-    def bld_ai_prp_ans(self,conn, cube_id,  rep_dos_id, key_word_l):
+    def bld_ai_prp_ans(self,conn, cube_id,  rep_dos_id, key_word_l,key_val_l = ["key"]):
 
         disp_col_ids_l = []
         attr_elements_l = []
-        key_val_l = ["key"]  #
+          #
         # print(mstr_rag_col_d)
         mstr_rag_col_d=i_cube.get_mtdi_cube_col_id(conn, cube_l=[cube_id])
         for col_name in mstr_rag_col_d[cube_id].keys():

{mstr_robotics_magerdaniel-0.3.11 → mstr_robotics_magerdaniel-0.3.12}/mstr_robotics/read_out_prj_obj.py

@@ -188,70 +188,75 @@ class io_attributes():
     def read_att_form_exp(self,conn,att_id_l,*args,**kwargs):
         all_att_maps_d = self.run_prop_d.copy()
         all_att_maps_l = []
-
+        all_att_err_l = []
         for att_id in att_id_l:
-            #print(att_id)
-            att=self.i_read_att(connection=conn,id=att_id,show_expression_as="tokens").json()
-            key_form_l = self.get_att_key_form_l(att)
-            for form in att["forms"]:
-                if "isFormGroup" not in list(form.keys()):
-                    all_att_maps_d["project_id"] = conn.headers["X-MSTR-ProjectID"]
-                    all_att_maps_d["attribute_id"] = att_id
-                    all_att_maps_d["attribute_name"] =att["name"]
-                    all_att_maps_d["form_id"] = form["id"]
-                    all_att_maps_d["form_name"] = form["name"]
-                    #all_att_maps_d["description"] = form["description"]
-                    all_att_maps_d["form_category"] = form["category"]
-                    all_att_maps_d["form_type"] = form["type"]
-                    all_att_maps_d["displayFormat"] = form["displayFormat"]
-                    all_att_maps_d["form_dataType"] = form["dataType"]["type"]
-                    all_att_maps_d["REST_form_type"] = i_prompts.get_exp_prp_data_type(baseFormType=form["dataType"]["type"])
-                    all_att_maps_d["form_precision"] = form["dataType"]["precision"]
-                    all_att_maps_d["form_scale"] = form["dataType"]["scale"]
-
-                    if form["id"] in key_form_l:
-                        all_att_maps_d["key_form"]=True
-                    else:
-                        all_att_maps_d["key_form"]=False
-
-                    all_att_maps_d["display_form_nr"]=0
-                    display_form_nr=1
-                    for rd_form in att["displays"]["reportDisplays"]:
-                        if form["id"] == rd_form["id"]:
-                            all_att_maps_d["display_form_nr"]=display_form_nr
-                        else:
-                            display_form_nr+=1
-
-
-                    all_att_maps_d["browse_form_nr"] = 0
-                    browse_form_nr = 1
-                    for bd_form in att["displays"]["browseDisplays"]:
-                        if form["id"] == bd_form["id"]:
-                            all_att_maps_d["browse_form_nr"] = browse_form_nr
+            try:
+                att=self.i_read_att(connection=conn,id=att_id,show_expression_as="tokens").json()
+                key_form_l = self.get_att_key_form_l(att)
+                for form in att["forms"]:
+                    if "isFormGroup" not in list(form.keys()):
+                        all_att_maps_d["project_id"] = conn.headers["X-MSTR-ProjectID"]
+                        all_att_maps_d["attribute_id"] = att_id
+                        all_att_maps_d["attribute_name"] =att["name"]
+                        all_att_maps_d["form_id"] = form["id"]
+                        all_att_maps_d["form_name"] = form["name"]
+                        #all_att_maps_d["description"] = form["description"]
+                        all_att_maps_d["form_category"] = form["category"]
+                        all_att_maps_d["form_type"] = form["type"]
+                        all_att_maps_d["displayFormat"] = form["displayFormat"]
+                        all_att_maps_d["form_dataType"] = form["dataType"]["type"]
+                        all_att_maps_d["REST_form_type"] = i_prompts.get_exp_prp_data_type(baseFormType=form["dataType"]["type"])
+                        all_att_maps_d["form_precision"] = form["dataType"]["precision"]
+                        all_att_maps_d["form_scale"] = form["dataType"]["scale"]
+
+                        if form["id"] in key_form_l:
+                            all_att_maps_d["key_form"]=True
                         else:
-                            browse_form_nr += 1
-
-                    for e in form["expressions"]:
-                        # print(e)
-                        all_att_maps_d["form_expressionId"] = e["expressionId"]
-                        all_att_maps_d["form_expressionText"] = e["expression"]["text"]
-                        # all_att_maps_d["expression_text"]=e["expression"]["text"]
-                        for tok in e["expression"]["tokens"]:
-                            if "target" in list(tok.keys()):
-                                if "column" == tok["target"]["subType"]:
-                                    all_att_maps_d["exp_value"] = tok["value"]
-                                    all_att_maps_d["column_id"] = tok["target"]["objectId"]
-                                    all_att_maps_d["column_name"] = tok["target"]["name"]
-                                    all_att_maps_d["column_versionId"] = tok["target"]["versionId"]
-                                    all_att_maps_d["column_dateCreated"] = tok["target"]["dateCreated"]
-                                    all_att_maps_d["column_dateModified"] = tok["target"]["dateModified"]
-                                    all_att_maps_l.append(all_att_maps_d.copy())
-                                    for table in e["tables"]:
-                                        all_att_maps_d["table_id"] = table["objectId"]
-                                        all_att_maps_d["table_subType"] = table["subType"]
+                            all_att_maps_d["key_form"]=False
+
+                        all_att_maps_d["display_form_nr"]=0
+                        display_form_nr=1
+                        for rd_form in att["displays"]["reportDisplays"]:
+                            if form["id"] == rd_form["id"]:
+                                all_att_maps_d["display_form_nr"]=display_form_nr
+                            else:
+                                display_form_nr+=1
+
+
+                        all_att_maps_d["browse_form_nr"] = 0
+                        browse_form_nr = 1
+                        for bd_form in att["displays"]["browseDisplays"]:
+                            if form["id"] == bd_form["id"]:
+                                all_att_maps_d["browse_form_nr"] = browse_form_nr
+                            else:
+                                browse_form_nr += 1
+
+                        for e in form["expressions"]:
+                            # print(e)
+                            all_att_maps_d["form_expressionId"] = e["expressionId"]
+                            all_att_maps_d["form_expressionText"] = e["expression"]["text"]
+                            # all_att_maps_d["expression_text"]=e["expression"]["text"]
+                            for tok in e["expression"]["tokens"]:
+                                if "target" in list(tok.keys()):
+                                    if "column" == tok["target"]["subType"]:
+                                        all_att_maps_d["exp_value"] = tok["value"]
+                                        all_att_maps_d["column_id"] = tok["target"]["objectId"]
+                                        all_att_maps_d["column_name"] = tok["target"]["name"]
+                                        all_att_maps_d["column_versionId"] = tok["target"]["versionId"]
+                                        all_att_maps_d["column_dateCreated"] = tok["target"]["dateCreated"]
+                                        all_att_maps_d["column_dateModified"] = tok["target"]["dateModified"]
                                         all_att_maps_l.append(all_att_maps_d.copy())
+                                        for table in e["tables"]:
+                                            all_att_maps_d["table_id"] = table["objectId"]
+                                            all_att_maps_d["table_subType"] = table["subType"]
+                                            all_att_maps_l.append(all_att_maps_d.copy())
 
-        return all_att_maps_l
+            except Exception as e:
+                all_att_err_d={"attribute_id":att_id , "err_msg":str(e)}
+                all_att_err_l.append(all_att_err_d.copy())
+
+        all_att_d={"all_att_maps_l":all_att_maps_l,"all_att_err_l":all_att_err_l}
+        return all_att_d
 
     def get_att_key_form_l(self,att):
         key_form_l = []
@@ -287,7 +292,7 @@ class read_schema():
         fact_l=i_md_searches.search_for_type_l(conn,obj_l=["13"] )
         fact_id_l=i_msic.get_key_form_dict_l(dict_l=fact_l)
 
-        att_form_exp_l=self.io_attributes.read_att_form_exp(conn=conn,att_id_l=att_id_l)
+        att_form_exp_l=self.io_attributes.read_att_form_exp(conn=conn,att_id_l=att_id_l)["all_att_maps_l"]
         att_form_exp_df=pd.DataFrame.from_dict(att_form_exp_l)
 
         fact_exp_l=self.io_facts.read_fact_exp(conn=conn,fact_id_l=fact_id_l)
@@ -323,7 +328,7 @@ class read_gen():
 
     def get_obj_def(self,conn, object_id, obj_type=None, obj_sub_type=None):
         obj_def = {}
-        print(obj_type)
+        #print(obj_type)
         if str(obj_type) == "12":
 
             obj_def = attributes.get_attribute(connection=conn, id=object_id, show_expression_as="tokens").json()
@@ -454,11 +459,17 @@ class read_prompts():
                 self.prompt_obj_l.append(p_obj_row_d.copy())
 
         else:
-            # print(prompt_def_d)
-            p_obj_row_d["object_id"] = prompt_def_d["question"]["search"]["objectId"]
-            p_obj_row_d["prp_subType"] = prompt_def_d["question"]["search"]["subType"]
-            self.prompt_obj_l.append(p_obj_row_d.copy())
-            self.prp_search_obj_l.append({"id": p_obj_row_d["prompt_id"], "type": 10}.copy())
+            #print(prompt_def_d)
+            if ("expressionType" in prompt_def_d.keys() and
+                prompt_def_d["expressionType"]=="hierarchy" and
+                prompt_def_d["question"]["listAllHierarchies"]==True):
+                    print("allHierPrompt")
+            else:
+
+                p_obj_row_d["object_id"] = prompt_def_d["question"]["search"]["objectId"]
+                p_obj_row_d["prp_subType"] = prompt_def_d["question"]["search"]["subType"]
+                self.prompt_obj_l.append(p_obj_row_d.copy())
+                self.prp_search_obj_l.append({"id": p_obj_row_d["prompt_id"], "type": 10}.copy())
 
     def _add_att_to_obj_l(self,conn,p_row_d):
         p_obj_row_d={}
@@ -632,8 +643,6 @@ class read_report():
         obj_d["form_name"] = ""
         return obj_d
 
-
-
     def read_grid_attribute(self,conn, obj, row_col_fg, row_col_nr):
         att_l=[]
         att_d = self.run_prop_d.copy()
@@ -764,18 +773,24 @@ class read_report():
         rep_def=i_rep.get_report_all_def(conn=conn,report_id=report_id,show_advanced_properties=show_advanced_properties)
         filter_text=""
         report_limit_text=""
-        try:
-            filter_text=str(rep_def["dataSource"]["filter"]["text"])
-        except:
-            pass
-        if "dataTemplate" in rep_def["dataSource"].keys():
-            for u in rep_def["dataSource"]["dataTemplate"]['units']:
-                if u["type"]=="metrics":
-                    try:
-                        report_limit_text=str(u["limit"]["text"])
-                    except:
-                        pass
+        if "errors" in rep_def.keys():
+            filter_text=str(rep_def["errors"])
+        else:
+            try:
 
+                filter_text=str(rep_def["dataSource"]["filter"]["text"])
+            except:
+                pass
+            if "dataTemplate" in rep_def["dataSource"].keys():
+                if "units" in rep_def["dataSource"]["dataTemplate"].keys():
+                    for u in rep_def["dataSource"]["dataTemplate"]['units']:
+                        if u["type"]=="metrics":
+                            try:
+                                report_limit_text=str(u["limit"]["text"])
+                            except:
+                                pass
+                else:
+                    filter_text=str(str(rep_def["dataSource"]["dataTemplate"]))
         rep_head_d=i_mstr_global.get_object_info_d(conn=conn,object_id=report_id,type="3")
         #rep_head_d.rename(columns={'id': 'report_id'}, inplace=True)
         rep_head_d.pop("project_id")
@@ -791,24 +806,33 @@ class read_report():
         rep_head_l=[]
         rep_avail_obj_l=[]
         rep_grid_obj_l=[]
+        rep_def_err_l=[]
         for report_id in report_id_l:
-            load_d["project_id"]=conn.project_id
-            load_d["report_id"]=report_id
-            self.run_prop_d=load_d.copy()
-            rep_def=i_rep.get_report_def(conn=conn,report_id=report_id).json()
-            grid_obj_d=self.read_out_grid(conn=conn,grid_definition=rep_def["definition"]["grid"])
-            pageBy_obj_d=self.read_grid_pageBy(conn=conn,pageBy_l=rep_def["definition"]["grid"]["pageBy"])
-            avail_obj_d=self.read_avail_obj(conn=conn,avail_obj=rep_def["definition"]["availableObjects"])
-
-            rep_grid_obj_l.extend(grid_obj_d)
-            rep_grid_obj_l.extend(pageBy_obj_d)
-            rep_avail_obj_l.extend(avail_obj_d)
-            rep_head_d=self.read_rep_quick_filt(conn=conn,report_id=report_id,show_advanced_properties="false")
-            rep_head_l.append(rep_head_d)
+            try:
+                load_d["project_id"]=conn.project_id
+                load_d["report_id"]=report_id
+                self.run_prop_d=load_d.copy()
+                rep_def=i_rep.get_report_def(conn=conn,report_id=report_id).json()
+                grid_obj_d=self.read_out_grid(conn=conn,grid_definition=rep_def["definition"]["grid"])
+                pageBy_obj_d=self.read_grid_pageBy(conn=conn,pageBy_l=rep_def["definition"]["grid"]["pageBy"])
+                avail_obj_d=self.read_avail_obj(conn=conn,avail_obj=rep_def["definition"]["availableObjects"])
+
+                rep_grid_obj_l.extend(grid_obj_d)
+                rep_grid_obj_l.extend(pageBy_obj_d)
+                rep_avail_obj_l.extend(avail_obj_d)
+                rep_head_d=self.read_rep_quick_filt(conn=conn,report_id=report_id,show_advanced_properties="false")
+                rep_head_l.append(rep_head_d)
+
+            except Exception as e:
+                rep_def_err_d = {"load_d": load_d, "rep_def":rep_def,"grid_obj_d":grid_obj_d,
+                                 "pageBy_obj_d":pageBy_obj_d,"avail_obj_d":avail_obj_d,
+                                 "err_msg": str(e)}
+                rep_def_err_l.append(rep_def_err_d.copy())
 
         rep_def_df= self.bld_rep_def_df(rep_head_l,rep_grid_obj_l=rep_grid_obj_l,rep_avail_obj_l=rep_avail_obj_l)
 
-        return rep_def_df
+        rep_def_d={"rep_def_df":rep_def_df,"rep_def_err_l":rep_def_err_l}
+        return rep_def_d
 
     def bld_rep_def_df(self,rep_head_l, rep_grid_obj_l, rep_avail_obj_l):
 
@@ -839,4 +863,155 @@ class read_report():
                               left_on=['project_id', 'report_id', 'object_id', 'form_id'],
                               right_on=['project_id', 'report_id', 'object_id', 'form_id'], how='left')
         rep_def_df = i_df_helper.clean_double_col(df=rep_def_df)
-        return rep_def_df
+        return rep_def_df
+
+class read_cube():
+
+    def read_cube_model_header(self,conn, cube_id, cube_head_d=None):
+        cube_all_def_d = i_mstr_api.get_cube_all_def(conn=conn, cube_id=cube_id,)
+        cbe_all_info = cube_all_def_d["information"]
+        cbe_opt = cube_all_def_d["options"]
+        cbe_sourceType = cube_all_def_d["sourceType"]
+        cbe_timeBased = cube_all_def_d["timeBased"]
+        cbe_filt = cube_all_def_d["filter"]
+
+        # cbe_def=cubes.cube_definition(connection= conn, id= cube_id).json()
+
+        if cube_head_d == None:
+            cube_head_d = {}
+            cube_head_d["project_id"] = conn.project_id
+            cube_head_d["cube_id"] = cbe_all_info["id"]
+
+        cube_head_d["cube_name"] = cbe_all_info["name"]
+        cube_head_d["primaryLocale"] = cbe_all_info["primaryLocale"]
+        cube_head_d["subType"] = cbe_all_info["subType"]
+        cube_head_d["create_date"] = cbe_all_info["dateCreated"]
+        cube_head_d["mod_date"] = cbe_all_info["dateModified"]
+        cube_head_d["language_d"] = str(cbe_opt["dataLanguages"])
+        cube_head_d["refresch_type"] = str(cbe_opt["dataRefresh"])
+        cube_head_d["paration_by_d"] = str(cbe_opt["dataPartition"]["partitionAttribute"])
+        cube_head_d["number_of_partions"] = str(cbe_opt["dataPartition"]["numberOfPartitions"])
+        cube_head_d["fetch_parallel"] = str(cbe_opt["dataPartition"]["fetchDataSlicesInParallel"])
+        cube_head_d["source_type"] = str(cbe_sourceType)
+        cube_head_d["timezone"] = cbe_timeBased["timezone"]
+        cube_head_d["calendar"] = cbe_timeBased["calendar"]
+        cube_head_d["enableTimezoneAndCalendarReporting"] = cbe_timeBased["enableTimezoneAndCalendarReporting"]
+        if "text" in cbe_filt.keys():
+            cube_head_d["filter_text"] = cbe_filt["text"]
+        else:
+            cube_head_d["filter_text"] = ""
+        return cube_head_d
+
+    def read_cube_load_info(self,conn, cube_id):
+        cbe_head_d = cubes.cube_info(connection=conn, id=cube_id).json()["cubesInfos"][0]
+        # print(cbe_head_d.keys())
+        cube_head_d = {}
+        cube_head_d["project_id"] = conn.project_id
+        cube_head_d["cube_id"] = cbe_head_d["cubeId"]
+        cube_head_d["cube_name"] = cbe_head_d["cubeName"]
+        cube_head_d["path"] = cbe_head_d["path"]
+        cube_head_d["modificationTime"] = cbe_head_d["modificationTime"]
+        cube_head_d["server_mode"] = cbe_head_d["serverMode"]
+        cube_head_d["cube_size"] = cbe_head_d["size"]
+        cube_head_d["cube_status"] = cbe_head_d["status"]
+        return cube_head_d
+
+    def read_cube(self,conn, cube_id):
+        cube_head_d = self.read_cube_load_info(conn, cube_id)
+        cube_head_d = self.read_cube_model_header(conn, cube_id, cube_head_d)
+        cube_def = cubes.cube_definition(connection=conn, id=cube_id).json()
+        cube_att_d = self.read_cube_att_forms(conn, cube_def)
+        cube_met_d = self.read_cube_metrics(conn, cube_def)
+        cube_d = {"cube_head_d": cube_head_d, "cube_att_d": cube_att_d, "cube_met_d": cube_met_d}
+        return cube_d
+
+    # ['information', 'template', 'filter', 'options', 'timeBased', 'sourceType', 'advancedProperties']
+
+    def read_all_olap_cubes(self,conn, cube_l):
+
+        cube_head_d_l = []
+        cube_att_d_l = []
+        cube_met_d_l = []
+        for cube_id in cube_l:
+            cube_d = self.read_cube(conn=conn, cube_id=cube_id)
+            cube_head_d_l.append(cube_d["cube_head_d"])
+            cube_att_d_l.extend(cube_d["cube_att_d"])
+            cube_met_d_l.extend(cube_d["cube_met_d"])
+        cube_l_d = {"cube_head_d_l": cube_head_d_l, "cube_att_d_l": cube_att_d_l, "cube_met_d_l": cube_met_d_l}
+        return cube_l_d
+
+    def trans_cbe_el_prp(self, ele_str):
+
+        el_l = ele_str.split(":")
+        el_ans_str = "h" + ':'.join(el_l[-1 * (len(el_l) - 1):])
+        el_ans_d = {"id": ':'.join(el_l[-1 * (len(el_l) - 1):]) + ";" + el_l[0]}
+        return el_ans_d
+
+    def read_cube_att_forms(self,conn,cube_def):
+        #reads out attorm definitions
+        rag_att_form_d_l=[]
+        for att in cube_def["definition"]["availableObjects"]["attributes"]:
+            for form in att["forms"]:
+                #print(att)
+                #print(form)
+                rag_att_form_d = {}
+                rag_att_form_d["project_id"] = conn.project_id
+                rag_att_form_d["cube_id"] = cube_def["id"]
+                rag_att_form_d["attribute_id"] = att["id"]
+                rag_att_form_d["attribute_name"] = att["name"]
+                rag_att_form_d["form_id"] = form["id"]
+                rag_att_form_d["form_name"] = form["name"]
+                if "dataType" in form.keys():
+                    rag_att_form_d["form_dataType"] = i_prompts.get_exp_prp_data_type(form["dataType"])
+                else:
+                    rag_att_form_d["form_dataType"] = i_prompts.get_exp_prp_data_type(form["baseFormType"])
+                rag_att_form_d_l.append(rag_att_form_d.copy())
+
+        return rag_att_form_d_l
+
+    def read_cube_metrics(self,conn, cube_def):
+        metric_def_d_l=[]
+        for m in cube_def["definition"]["availableObjects"]["metrics"]:
+            m_def_d={}
+            m_def_d["project_id"] = conn.project_id
+            m_def_d["cube_id"] = cube_def["id"]
+            m_def_d["metric_id"]=m["id"]
+            m_def_d["metric_name"] = m["name"]
+            m_def_d["metric_data_type"] = m["dataType"]
+            metric_def_d_l.append(m_def_d.copy())
+        return metric_def_d_l
+
+    def fetch_cube_elements(self, conn, cube_id,limit_val=10000,*args,**kwargs):
+        rag_att_form_l = []
+        offset_val = 0
+        row_count = 1
+        while row_count > 0:
+            resp=i_mstr_api.get_v2_cube_instance(conn=conn, cube_id=cube_id, offset_val=offset_val,limit_val=limit_val,*args,**kwargs)
+            #url = f'{conn.base_url}/api/v2/cubes/{cube_id}/instances?offset={offset_val}&limit={limit_val}'
+            #resp = conn.post(url)
+            cube_def= resp.json()
+            for att in cube_def["definition"]["grid"]["rows"]:
+                form_nr = 0
+                rag_att_form_d = {}
+                rag_att_form_d["project_id"] = conn.project_id
+                rag_att_form_d["attribute_id"] = att["id"]
+                rag_att_form_d["attribute_name"] = att["name"]
+                row_count = len(att["elements"])
+                for form in att["forms"]:
+                    rag_att_form_d["form_id"] = form["id"]
+                    rag_att_form_d["form_name"] = form["name"]
+                    rag_att_form_d["form_dataType"] = i_prompts.get_exp_prp_data_type(form["dataType"])
+                    for element in att["elements"]:
+                        rag_att_form_d["key"] = element["formValues"][form_nr]
+                        rag_att_form_d["ele_prp_ans"] = element["id"]
+                        rag_att_form_l.append(rag_att_form_d.copy())
+            offset_val += limit_val
+            resp.close()
+        return rag_att_form_l
+
+    def read_cube_att_form_exp_val_l(self, conn, cube_list_l,*args,**kwargs):
+        all_cube_element_l=[]
+        for cube in cube_list_l:
+            cube_element_l=self.fetch_cube_elements(conn=conn,cube_id=cube["id"],*args,**kwargs)
+            all_cube_element_l.extend(cube_element_l)
+        return all_cube_element_l

{mstr_robotics_magerdaniel-0.3.11 → mstr_robotics_magerdaniel-0.3.12}/mstr_robotics/report.py

@@ -8,11 +8,12 @@ from mstrio.project_objects.report import Report
 from mstrio.api.cubes import cube_definition
 import pandas as pd
 from mstr_robotics.mstr_pandas import df_helper
-from mstr_robotics._helper import msic
+from mstr_robotics._helper import msic,str_func
 import json
 
 i_mstr_api=mstr_api()
 i_msic=msic()
+i_str_func=str_func()
 
 class rep:
 
@@ -21,6 +22,7 @@ class rep:
         self.i_parser = parser
         self.i_df_helper=df_helper()
 
+
     def open_Instance(self, conn, report_id):
         rep_instance = self.i_reports.report_instance(connection=conn, report_id=report_id)
         return rep_instance.json()["instanceId"]
@@ -139,6 +141,16 @@ class rep:
         html_link = f'<a href={rep_url} target="_blank">Jump to MSTR Library</a>'
         return html_link
 
+    def web_base_url(self,conn, report_id):
+        web_base_url=i_str_func.web_base_url(base_url=conn.base_url)
+        server=i_str_func.get_server_base_url(base_url=conn.base_url)
+        project_name=i_str_func.get_project_name_base_url(project_name=conn.project_name)
+        rep_url=f'{web_base_url}Server={server}&Project={project_name}&evt=4001&src=mstrWeb.4001&reportViewMode=1&reportID={report_id}&currentViewMedia=2'
+        print(rep_url)
+        #rep_url = f'{conn.base_url}/app/{conn.project_id}/{report_id}/share'
+        html_link = f'<a href={rep_url} target="_blank">Jump to MSTR Web</a>'
+        return html_link
+
     def bld_free_form_rep_df(self,conn, report_id,prp_answ_d=None):
         #historically needed to adjust column names
         #can probally be deleted
@@ -333,13 +345,13 @@ class prompts():
         if baseFormType in ["fixed_length_string","n_var_char","Char","varChar"]:
             exp_prp_data_type="Char"
 
-        if baseFormType in ["integer","double","numeric","decimal","int64","float"]:
+        if baseFormType in ["integer","double","numeric","number","decimal","int64","float"]:
             exp_prp_data_type="Numeric"
 
         if baseFormType in ["big_decimal","bigDecimal"]:
             exp_prp_data_type="BigDecimal"
 
-        if baseFormType in ["time_stamp","date"]:
+        if baseFormType in ["time_stamp","date","dateTime","timeStamp"]:
             exp_prp_data_type="DateTime"
 
         if exp_prp_data_type == "":
@@ -374,32 +386,37 @@ class prompts():
 
     def close_open_prp(self,conn, report_id, instance_id, prompt_answ):
         # checks the answered prp
-        prompt_answ_d = json.loads(prompt_answ)
-        prp_ans_d_l = prompt_answ_d["prompts"]
-        prp_ans_id_l = i_msic.keep_cols_from_dict_l(list_l=prp_ans_d_l, keep_cols=["id"])
-
-        # checks the all prp in report / dashboard
-        rep_open_prp_d_l = rep().get_open_prompts(conn=conn, report_id=report_id, instance_id=instance_id)
-        rep_open_prp_id_l = i_msic.keep_cols_from_dict_l(list_l=rep_open_prp_d_l, keep_cols=["id"])
-
-        # checks the prp not answered jet
-        open_prp_l = [x for x in rep_open_prp_id_l if x not in prp_ans_id_l]
-        open_prp_l = i_msic.get_vals_from_dict_l(dict_l=open_prp_l)
-
-        for prp in rep_open_prp_d_l:
-            print(prp["id"])
-            if prp["id"] in open_prp_l:
-                print(prp)
-                open_prp_d = {}
-                open_prp_d["id"] = prp["id"]
-                open_prp_d["type"] = prp["type"]
-                if prp["type"] in ["OBJECTS", "ELEMENTS"]:
-                    open_prp_d["answers"] = []
-                else:
-                    open_prp_d["answers"] = {}
-                rep_open_prp_d_l.append(open_prp_d.copy())
-        prompt_answ = self.frame_prp(prp_ans=rep_open_prp_d_l)
-        return prompt_answ
+        rep_stat = rep().get_open_prp_stat(conn=conn, report_id=report_id, instance_id=instance_id)
+
+        if rep_stat == 2:
+            prompt_answ_d = json.loads(prompt_answ)
+            prp_ans_d_l = prompt_answ_d["prompts"]
+            prp_ans_id_l = i_msic.keep_cols_from_dict_l(list_l=prp_ans_d_l, keep_cols=["id"])
+
+            # checks the all prp in report / dashboard
+            rep_open_prp_d_l = rep().get_open_prompts(conn=conn, report_id=report_id, instance_id=instance_id)
+            rep_open_prp_id_l = i_msic.keep_cols_from_dict_l(list_l=rep_open_prp_d_l, keep_cols=["id"])
+
+            # checks the prp not answered jet
+            open_prp_l = [x for x in rep_open_prp_id_l if x not in prp_ans_id_l]
+            open_prp_l = i_msic.get_vals_from_dict_l(dict_l=open_prp_l)
+
+            for prp in rep_open_prp_d_l:
+                print(prp["id"])
+                if prp["id"] in open_prp_l:
+                    print(prp)
+                    open_prp_d = {}
+                    open_prp_d["id"] = prp["id"]
+                    open_prp_d["type"] = prp["type"]
+                    if prp["type"] in ["OBJECTS", "ELEMENTS"]:
+                        open_prp_d["answers"] = []
+                    else:
+                        open_prp_d["answers"] = {}
+                    rep_open_prp_d_l.append(open_prp_d.copy())
+            prompt_answ = self.frame_prp(prp_ans=rep_open_prp_d_l)
+            rep().set_inst_prompt_ans(conn=conn, report_id=report_id, instance_id=instance_id,
+                                                prompt_answ=prompt_answ)
+        return
 
     def zzz_loop_att_exp_prp(self,prp_job_ans_l):
         expr_JSON_l = []

{mstr_robotics_magerdaniel-0.3.11 → mstr_robotics_magerdaniel-0.3.12}/mstr_robotics/user_RAG.py

@@ -1,4 +1,5 @@
 import json
+import ast
 from openai import OpenAI
 from flashtext import KeywordProcessor
 from langchain.vectorstores import FAISS
@@ -19,9 +20,15 @@ class keyword_processor():
         return keywords_l
 
     def check_keyword(self,filt_obj_str):
+        print(filt_obj_str)
         keywords_l = self.KeywordProcessor.extract_keywords(filt_obj_str)
         return keywords_l[0]
 
+    def check_keyword_all(self,filt_obj_str):
+        print(filt_obj_str)
+        keywords_l = self.KeywordProcessor.extract_keywords(filt_obj_str)
+        return keywords_l
+
 class vectorDB_faisst():
 
     def __init__(self,sKey):
@@ -41,9 +48,10 @@ class vectorDB_faisst():
 
 class mstr_openAI():
 
-    def __init__(self,sKey):
+    def __init__(self):
+        pass
         #self.sKey=sKey
-        self.i_embeddings = OpenAIEmbeddings(openai_api_key=sKey)
+        #self.i_embeddings = OpenAIEmbeddings(openai_api_key=sKey)
 
 
     def check_trans_chatGPT(self,sKey,messages,*args,**kwargs):
@@ -54,7 +62,6 @@ class mstr_openAI():
     def call_open_AI(self, sKey, messages, max_tokens=1000, temperature=0.3, model="gpt-4o-mini"):
         # This is the default and can be omitted
         client = OpenAI(api_key=sKey)
-
         chat_completion = client.chat.completions.create(
             messages=messages,
             # model="gpt-3.5-turbo",
@@ -65,8 +72,26 @@ class mstr_openAI():
         js = json.loads(chat_completion.json())
         return js
 
-class chat_bot_RAG():
+class chat_bot():
+
+    def run_chat_msg(self,msg_t,sKey,model,vector_store,max_tokens,temperature):
+        key_word_l = vector_store.check_keyword_all( filt_obj_str=msg_t)
+        rag_rep_prp_l = []
+
+        # rag_rep_prp_filt_d=get_rag_rep_prp_d(conn=conn,cube_id=cube_RAG_form_val_ans_id, mstr_rag_col_d=mstr_rag_col_d,rep_dos_id=rep_dos_id,key_word_l=key_word_l)
+
+        messages = self.split_AI_msg(msg_t, key_word_l)
 
+        json_t = mstr_openAI().call_open_AI(sKey=sKey, messages=messages, max_tokens=max_tokens, temperature=temperature, model=model)
+        json_t_d = json.loads(json_t["choices"][0]["message"]["content"])
+        msg_filter_t = json_t_d["filter"]
+        messages = self.filter_RAG_l(msg_t=msg_t, key_word_l=key_word_l, msg_filter_t=msg_filter_t)
+        json_f = mstr_openAI().call_open_AI(sKey=sKey, messages=messages, max_tokens=max_tokens, temperature=temperature, model=model)
+        json_f = json_f["choices"][0]["message"]["content"]
+        filter_d = ast.literal_eval(json_f)
+        json_fin = json_t_d.copy()
+        json_fin["filter"] = filter_d
+        return json_fin
     def filter_RAG_l(self,msg_t, key_word_l, msg_filter_t):
         messages = [
             {

{mstr_robotics_magerdaniel-0.3.11 → mstr_robotics_magerdaniel-0.3.12}/setup.py

@@ -7,7 +7,7 @@ long_description = (this_directory / "README.md").read_text()
 
 setup(
     name="MSTR_Robotics_magerdaniel",
-    version="0.3.11",
+    version="0.3.12",
     description="MicroStrateg(P)ython",
     author="Daniel Mager",
     author_email="danielmager@gmx.de",