MSTR-Robotics-magerdaniel 0.2.10__tar.gz → 0.3.0__tar.gz

{MSTR_Robotics_magerdaniel-0.2.10 → mstr_robotics_magerdaniel-0.3.0/MSTR_Robotics_magerdaniel.egg-info}/PKG-INFO

@@ -1,12 +1,18 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: MSTR_Robotics_magerdaniel
-Version: 0.2.10
+Version: 0.3.0
 Summary: MicroStrateg(P)ython
 Home-page: https://github.com/magerdaniel
 Author: Daniel Mager
 Author-email: "danielmager@gmx.de"
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: summary
 
 Hi,
 

{MSTR_Robotics_magerdaniel-0.2.10 → mstr_robotics_magerdaniel-0.3.0}/MSTR_Robotics_magerdaniel.egg-info/SOURCES.txt

@@ -10,9 +10,11 @@ mstr_robotics/__init__.py
 mstr_robotics/_connectors.py
 mstr_robotics/_helper.py
 mstr_robotics/_lu_data.py
-mstr_robotics/jup_schema_monitor.ipynb
+mstr_robotics/_mod_prj_obj.py
+mstr_robotics/ai_openAi_faisst.py
+mstr_robotics/dossier.py
 mstr_robotics/mstr_classes.py
 mstr_robotics/mstr_pandas.py
+mstr_robotics/prepare_AI_data.py
 mstr_robotics/read_out_prj_obj.py
-mstr_robotics/report.py
-notebooks/jup_schema_monitor.ipynb
+mstr_robotics/report.py

{MSTR_Robotics_magerdaniel-0.2.10/MSTR_Robotics_magerdaniel.egg-info → mstr_robotics_magerdaniel-0.3.0}/PKG-INFO

@@ -1,12 +1,18 @@
-Metadata-Version: 2.1
-Name: MSTR-Robotics-magerdaniel
-Version: 0.2.10
+Metadata-Version: 2.2
+Name: MSTR_Robotics_magerdaniel
+Version: 0.3.0
 Summary: MicroStrateg(P)ython
 Home-page: https://github.com/magerdaniel
 Author: Daniel Mager
 Author-email: "danielmager@gmx.de"
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: summary
 
 Hi,
 

{MSTR_Robotics_magerdaniel-0.2.10 → mstr_robotics_magerdaniel-0.3.0}/mstr_robotics/_connectors.py

@@ -5,6 +5,16 @@ i_msic=msic()
 
 class mstr_api():
 
+    def get_prj_tbl(self,conn):
+        inst_u = f"{conn.base_url}/api/model/tables"
+        r = conn.get(inst_u)
+        return r
+
+    def get_dossier_prp_l(self,conn,dossier_id):
+        endpoint = f'/api/documents/{dossier_id}/prompts'
+        prp_l = conn.get(endpoint=endpoint).json()
+        return prp_l
+
     def get_ele_prp_ans(self,conn,report_id,instance_id,prompt_id,att_form_str=None,offset=0, limit=200):
         #get availeble objects from an element prompt
         #be carefull, this can be an performance issue
@@ -23,6 +33,10 @@ class mstr_api():
             offset += limit
         return all_values
 
+    def create_dossier_instance(self, conn, dossier_id, body=None, error_msg=None):
+        endpoint = f'{conn.base_url}/api/dossiers/{dossier_id}/instances'
+        return conn.post(url=endpoint, json=body).json()["mid"]
+
     def get_prp_ans(self,conn,report_id,instance_id,prompt_id,offset=0, limit=200):
         #get availeble objects from an object prompt
         rest_limit=limit
@@ -30,7 +44,7 @@ class mstr_api():
         while rest_limit>=0:
             inst_u = f'{conn.base_url}/api/reports/{report_id}/instances/{instance_id}/prompts/{prompt_id}/objects?offset={offset}&limit={limit}'
             r = conn.get(inst_u, headers=conn.headers)
-            prp_ans_base_l.append(r.json()["objects"])
+            prp_ans_base_l.extend(r.json()["objects"])
             rest_limit=int(r.headers["x-mstr-total-count"])-offset
             offset +=limit
 
@@ -62,12 +76,12 @@ class mstr_api():
 
         return resp
 
-    def get_project_name(self, conn):
+    def get_project_name(self, conn,project_id):
         #provides a readable project name for humans
         project_resp = conn.get(f'{conn.base_url}/api/projects')
         project_name=""
         for p in project_resp.json():
-            if p["id"] == conn.headers["X-MSTR-ProjectID"]:
+            if p["id"] == project_id:
                 project_name= p["name"]
 
         if project_name!="":
@@ -80,6 +94,16 @@ class mstr_api():
         r = conn.get(inst_u, headers=conn.headers)
         return r.json()
 
+    def get_custom_group(self,conn, custom_group_id, show_expression_as="tokens"):
+        url = f'{conn.base_url}/api/model/customGroups/{custom_group_id}?showExpressionAs={show_expression_as}'
+        custom_group_def = conn.get(url)
+        return custom_group_def.json()
+
+    def get_consolidation(self,conn, consolidation_id):
+        url = f'{conn.base_url}/api/model/consolidations/{consolidation_id}'
+        consolidation_def = conn.get(url)
+        return consolidation_def.json()
+
     def get_hier_att(self,conn,hier_id,displayForms="All",offset=0, limit=200):
         #Available displayForms: all, browseForms, reportDisplayForms, customForms, unknown
         #I develope initially to get the form_ids for attribute qualification prompts
@@ -104,6 +128,12 @@ class mstr_api():
         rep_sql=conn.get(url)
         return rep_sql
 
+    def get_report_all_def(self,conn,report_id, show_expression_as="tokens",show_filter_tokens="true",show_advanced_properties="true"):
+        url=f'{conn.base_url}/api/model/reports/{report_id}?showExpressionAs={show_expression_as}&showFilterTokens={show_filter_tokens}&showAdvancedProperties={show_advanced_properties}'
+        #print(url)
+        report_def=conn.get(url)
+        return report_def.json()
+
     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
@@ -149,6 +179,18 @@ class mstr_api():
 
         return {"metric_val_l":raw_val_l,"metric_guid_l":regam_job_metric_guid_l}
 
+    def get_dossier_def(self,conn,dossier_id):
+        url = f'{conn.base_url}/api/v2/dossiers/{dossier_id}/definition'
+        doss_hier = conn.get(url)
+        return doss_hier.json()
+
+    def get_dossier_detail(self, conn, dossier_id, instance_id, chapter_key, vis_id):
+        url = f"{conn.base_url}/api/v2/dossiers/{dossier_id}/instances/"
+        url += f"{instance_id}/chapters/{chapter_key}/visualizations/{vis_id}?offset=0&limit=1000"
+        return conn.get(url).json()
+
+
+
     def ZZZ_get_cube_data(self,conn,cube_id,instance_id,offset,limit) :
         inst_u = f'{conn.base_url}/api/v2/cubes/{cube_id}/instances/{instance_id}?offset={offset}&limit={limit}'
         cube_ds = conn.get(inst_u, headers=conn.headers)

{MSTR_Robotics_magerdaniel-0.2.10 → mstr_robotics_magerdaniel-0.3.0}/mstr_robotics/_helper.py

@@ -91,7 +91,22 @@ class msic():
         return key_l
 
     def get_comon_val_l(self,list_1,list_2):
-       return list(set(list_1).intersection(list_2))
+       #return list(set(list_1).intersection(list_2))
+        matches = []
+        for item in list_1:
+           if item in list_2:
+               matches.append(item)
+        return matches
+
+    def keep_cols_from_dict_l(self,list_l,keep_cols):
+        clean_l = []
+        for e in list_l:
+            new_d = {}
+            for m in self.get_comon_val_l(keep_cols, list_2=e.keys()):
+                new_d[m] = e[m]
+
+            clean_l.append(new_d.copy())
+        return clean_l
 
     def list_to_dict(self,list_in_l, col_l):
         #merge do lists into one dict
@@ -108,43 +123,41 @@ class msic():
             dict_l.append(dict_d.copy())
         return dict_l
 
-    def add_prefix_to_dict_keys(self,dict, dpn_prefix):
+    def add_prefix_to_dict_keys(self,dict, dpn_prefix, dict_cols= []):
         #adds a prefix to the keys of a dict
         # use case here is to distinct i.e. between the object_id and the depn_object_id
         new_dict = {}
+        include=0
         if dpn_prefix==None:
             return dict
         for key, value in dict.items():
-            new_key = dpn_prefix + key
-            new_dict[new_key] = value
+            if dict_cols==[]:
+                include=1
+
+            if key in dict_cols:
+                include = 1
+
+            if include==1:
+               new_key = dpn_prefix + key
+               new_dict[new_key] = value
+
         return new_dict
 
-"""
-class sql_server_obj():
-    pass
+    def rem_dbl_dict_in_l (self,dict_l):
+
+        tuple_l = set(tuple(sorted(d.items())) for d in dict_l)
 
+        #tuple_l =list(set(tuple(keys) for keys in dict_l))
+        # Convert tuples back to dictionaries
+        unique_dict_l = [dict(t) for t in tuple_l]
 
-class ZZZ_df_helper():
+        return unique_dict_l
 
-    def clean_double_col(self, df, postfix_left="_x", postfix_right="_y"):
-        # postfix_left gets removed
-        # postfix_right gets deleted
-        doubles_y = [col for col in df.columns if col.endswith(postfix_right)]
-        df.drop(columns=doubles_y, inplace=True)
-        df.columns = [col.replace(postfix_left, '') for col in df.columns]
-        return df
+    def rem_dbl_in_l(self,list_l):
+        list_l = list(set(list_l))
+        return list_l
 
-    def rem_att_id_forms(self,df,postfix="@ID"):
-        df.columns = [col.replace(postfix, '') for col in df.columns]
-        return df
+    def sort_dict_by_key_in_l(self,dict_l,sort_key, reverse=False):
+        return sorted(dict_l, key=lambda x: x.get(sort_key, None), reverse=reverse)
 
 
-    def flag_folder_df(self,flag_path_d_l, obj_df, obj_path="path", flag_path="flag_path"):
-        flag_path_df = pd.DataFrame.from_dict(flag_path_d_l)
-        unique_str = flag_path_df[flag_path].unique()
-        matching_rows_df = obj_df[obj_df['path'].str.contains('|'.join(unique_str))]
-        flaged_obj_df = pd.merge(matching_rows_df, flag_path_df, left_on=matching_rows_df['path']
-                                 .str.extract(f'({"|".join(unique_str)})')[0],
-                                 right_on='flag_path')
-        return flaged_obj_df
-"""

mstr_robotics_magerdaniel-0.3.0/mstr_robotics/_lu_data.py

@@ -0,0 +1,53 @@
+
+class lu_mstr_md:
+
+    def lu_object_type(self):
+        return [
+            {'PA_OBJ_TYPE_ID': '6', 'PA_OBJ_TYPE_DESC': 'Custom Group', 'MD_OBJ_TYPE_ID': '1',
+             'MD_OBJ_TYPE_BEZ': 'Filter'},
+            {'PA_OBJ_TYPE_ID': '8', 'PA_OBJ_TYPE_DESC': 'Data Import Cube', 'MD_OBJ_TYPE_ID': '3',
+             'MD_OBJ_TYPE_BEZ': 'Report'},
+            {'PA_OBJ_TYPE_ID': '16', 'PA_OBJ_TYPE_DESC': 'Filter', 'MD_OBJ_TYPE_ID': '1', 'MD_OBJ_TYPE_BEZ': 'Filter'},
+            {'PA_OBJ_TYPE_ID': '40', 'PA_OBJ_TYPE_DESC': 'Template', 'MD_OBJ_TYPE_ID': '2',
+             'MD_OBJ_TYPE_BEZ': 'Template'},
+            {'PA_OBJ_TYPE_ID': '31', 'PA_OBJ_TYPE_DESC': 'SQL Report', 'MD_OBJ_TYPE_ID': '3',
+             'MD_OBJ_TYPE_BEZ': 'Report'},
+            {'PA_OBJ_TYPE_ID': '19', 'PA_OBJ_TYPE_DESC': 'SQL Report', 'MD_OBJ_TYPE_ID': '3',
+             'MD_OBJ_TYPE_BEZ': 'Report'},
+            {'PA_OBJ_TYPE_ID': '23', 'PA_OBJ_TYPE_DESC': 'Metric', 'MD_OBJ_TYPE_ID': '4', 'MD_OBJ_TYPE_BEZ': 'Metric'},
+            {'PA_OBJ_TYPE_ID': '107', 'PA_OBJ_TYPE_DESC': 'User Folder', 'MD_OBJ_TYPE_ID': '8',
+             'MD_OBJ_TYPE_BEZ': 'Folder'},
+            {'PA_OBJ_TYPE_ID': '2', 'PA_OBJ_TYPE_DESC': 'Attribute Element Prompt', 'MD_OBJ_TYPE_ID': '10',
+             'MD_OBJ_TYPE_BEZ': 'Prompt'},
+            {'PA_OBJ_TYPE_ID': '37', 'PA_OBJ_TYPE_DESC': 'Embedded Prompt', 'MD_OBJ_TYPE_ID': '10',
+             'MD_OBJ_TYPE_BEZ': 'Prompt'},
+            {'PA_OBJ_TYPE_ID': '58', 'PA_OBJ_TYPE_DESC': 'Level prompt', 'MD_OBJ_TYPE_ID': '10',
+             'MD_OBJ_TYPE_BEZ': 'Prompt'},
+            {'PA_OBJ_TYPE_ID': '24', 'PA_OBJ_TYPE_DESC': 'Object Prompt', 'MD_OBJ_TYPE_ID': '10',
+             'MD_OBJ_TYPE_BEZ': 'Prompt'},
+            {'PA_OBJ_TYPE_ID': '28', 'PA_OBJ_TYPE_DESC': 'Prompt', 'MD_OBJ_TYPE_ID': '10', 'MD_OBJ_TYPE_BEZ': 'Prompt'},
+            {'PA_OBJ_TYPE_ID': '57', 'PA_OBJ_TYPE_DESC': 'Prompt Expression Draft', 'MD_OBJ_TYPE_ID': '10',
+             'MD_OBJ_TYPE_BEZ': 'Prompt'},
+            {'PA_OBJ_TYPE_ID': '36', 'PA_OBJ_TYPE_DESC': 'Value Prompt', 'MD_OBJ_TYPE_ID': '10',
+             'MD_OBJ_TYPE_BEZ': 'Prompt'},
+            {'PA_OBJ_TYPE_ID': '1', 'PA_OBJ_TYPE_DESC': 'Attribute', 'MD_OBJ_TYPE_ID': '12',
+             'MD_OBJ_TYPE_BEZ': 'Attribute'},
+            {'PA_OBJ_TYPE_ID': '15', 'PA_OBJ_TYPE_DESC': 'Fact', 'MD_OBJ_TYPE_ID': '13', 'MD_OBJ_TYPE_BEZ': 'Fact'},
+            {'PA_OBJ_TYPE_ID': '102', 'PA_OBJ_TYPE_DESC': 'System Hierarchy', 'MD_OBJ_TYPE_ID': '14',
+             'MD_OBJ_TYPE_BEZ': 'Dimension'},
+            {'PA_OBJ_TYPE_ID': '103', 'PA_OBJ_TYPE_DESC': 'User Hierarchy', 'MD_OBJ_TYPE_ID': '14',
+             'MD_OBJ_TYPE_BEZ': 'Dimension'},
+            {'PA_OBJ_TYPE_ID': '35', 'PA_OBJ_TYPE_DESC': 'Transformation', 'MD_OBJ_TYPE_ID': '43',
+             'MD_OBJ_TYPE_BEZ': 'Role'},
+            {'PA_OBJ_TYPE_ID': '5', 'PA_OBJ_TYPE_DESC': 'Consolidation', 'MD_OBJ_TYPE_ID': '47',
+             'MD_OBJ_TYPE_BEZ': 'Consolidation'},
+            {'PA_OBJ_TYPE_ID': '7', 'PA_OBJ_TYPE_DESC': 'Document', 'MD_OBJ_TYPE_ID': '55',
+             'MD_OBJ_TYPE_BEZ': 'DocumentDefinition'},
+            {'PA_OBJ_TYPE_ID': '14', 'PA_OBJ_TYPE_DESC': 'Dossier', 'MD_OBJ_TYPE_ID': '55',
+             'MD_OBJ_TYPE_BEZ': 'DocumentDefinition'},
+            {'PA_OBJ_TYPE_ID': '110', 'PA_OBJ_TYPE_DESC': 'Security Filter', 'MD_OBJ_TYPE_ID': '58',
+             'MD_OBJ_TYPE_BEZ': 'Security Filter'},
+            {'PA_OBJ_TYPE_ID': '-1', 'PA_OBJ_TYPE_DESC': 'Search', 'MD_OBJ_TYPE_ID': '39', 'MD_OBJ_TYPE_BEZ': 'Search'},
+            {'PA_OBJ_TYPE_ID': '-2', 'PA_OBJ_TYPE_DESC': 'Shortcut', 'MD_OBJ_TYPE_ID': '18',
+             'MD_OBJ_TYPE_BEZ': 'Shortcut'},
+        ]

mstr_robotics_magerdaniel-0.3.0/mstr_robotics/_mod_prj_obj.py

@@ -0,0 +1,67 @@
+from mstr_robotics.mstr_classes import mstr_global
+from mstr_robotics._connectors import mstr_api
+from mstr_robotics._helper import str_func
+
+class bld_short_cuts:
+
+    def __init__(self):
+        self.str= str_func()
+        #self.rep = rep
+        self.glob = mstr_global()
+        self.mstr_api = mstr_api()
+
+    def bld_short_cut(self,conn,folder_id,object_id,
+                      object_type,new_name,object_desc):
+        #In Version 11 update 7, it's not possible to define a free name and description
+        # when creating a short cut. Thus I create the shurt cut first and rename it later
+        short_cut_obj_rep = self.mstr_api.cr_short_cut(conn=conn,object_id=object_id,object_type=object_type,folder_id=folder_id)
+        self.mstr_api.rename_object(conn=conn, object_id=short_cut_obj_rep.json()["id"], object_type=18, new_name=new_name, desc_str=object_desc)
+
+    def run_short_cut_build(self, conn,project_id,short_cut_df,folder_id,df_key_cols_d=None):
+        #requiers as imput a pandas data frame with 4 colmuns
+        # object_id, object_type, object_name, object_desc
+        conn.select_project(project_id)
+        if not df_key_cols_d:
+            df_key_cols_d={"object_id":"Object@GUID",
+                           "object_type":"OBJECT_TYPE_ID",
+                           "object_name":"Object@Name",
+                           "object_desc":"OBJECT_DESC"}
+
+        #before adding new short cuts to the shortcut folder, all shortcuts gonna be deleted
+        self.clean_shortcut_folder(conn=conn,folder_id=folder_id)
+        short_cut_folder_j = f'{{"folderId": "{folder_id}"}}'
+        #iterrating throuh all the objects in the list
+        short_cut_df.reset_index()
+        for index, obj in short_cut_df.iterrows():
+            #short_cut_url = f'{conn.base_url}/objects/{obj[2]}/type/{str(obj[4])}/shortcuts'
+            try:
+                if obj[df_key_cols_d["object_type"]]!=str(18):
+                    print(obj[df_key_cols_d["object_id"]] +"____"+ str(obj[df_key_cols_d["object_type"]]))
+                    print("Create short: "+obj[df_key_cols_d["object_name"]]+" of type: "+str(obj[df_key_cols_d["object_type"]]) )
+                    self.bld_short_cut(conn=conn
+                                       ,folder_id=folder_id
+                                       ,object_id=obj[df_key_cols_d["object_id"]]
+                                       ,object_type=obj[df_key_cols_d["object_type"]]
+                                       ,new_name=obj[df_key_cols_d["object_name"]]
+                                       #max lentgh of descriptions in MSTR
+                                       ,object_desc=self.str._get_first_x_chars(str_=str(obj[df_key_cols_d["object_desc"]]),i=249)
+                                       )
+                else:
+                    print(f'Obect: {obj[2]} is a shortcut. MSTR does not allow short cuts o short cuts,'
+                          f' thus they are not supported'  )
+            except Exception as  err:
+                print(f'Obect: {obj[2]} hasn not been created. The error is {err}')
+
+        return
+    #@logger
+    def clean_shortcut_folder(self,conn,folder_id):
+        existing_obj_l = self.glob.get_folder_obj_l(conn=conn, folder_id=folder_id)
+        obj_l = self._get_col_from_obj_l(dict_l=existing_obj_l, key_col="id")
+        self.glob._delete_object(conn=conn,existing_obj_l=existing_obj_l)
+
+    #@logger
+    def _get_col_from_obj_l(self, dict_l=None, key_col=None):
+        key_val_l = []
+        for o in dict_l:
+            key_val_l.append(o[key_col])
+        return key_val_l

mstr_robotics_magerdaniel-0.3.0/mstr_robotics/ai_openAi_faisst.py

@@ -0,0 +1,250 @@
+import os
+import pandas as pd
+from langchain.vectorstores import FAISS
+from langchain.embeddings import OpenAIEmbeddings
+from openai import OpenAI
+from flashtext import KeywordProcessor
+from itertools import chain
+from mstr_robotics.report import prompts,cube,rep
+from mstr_robotics.mstr_pandas import df_helper
+from mstr_robotics._helper import msic
+from mstr_robotics.prepare_AI_data import map_objects
+import json
+
+i_KeywordProcessor = KeywordProcessor()
+i_chain=chain()
+i_rep=rep()
+i_prompts=prompts()
+i_df_helper=df_helper()
+i_cube=cube()
+i_map_objects=map_objects()
+i_msic=msic()
+
+class vectorDB_faisst():
+
+    def __init__(self,sKey):
+        #self.sKey=sKey
+        os.environ["OPENAI_API_KEY"] = sKey
+        self.i_embeddings = OpenAIEmbeddings()
+
+    def load_vector_store(self,key_l):
+        # Flatten and ensure all items are strings
+        # Create FAISS vector store
+        vector_store = FAISS.from_texts(key_l, self.i_embeddings)
+
+        return vector_store
+
+    def load_keyword_processor(self,key_l):
+        for val in key_l:
+            i_KeywordProcessor.add_keyword(val)
+        return i_KeywordProcessor
+
+    def extract_keywords(self,msg_t):
+        keywords_l = i_KeywordProcessor.extract_keywords(msg_t)
+        return keywords_l
+
+class run_chat_request():
+
+    def __init__(self,cube_obj_prp_rel_id
+                 ,cube_RAG_form_val_ans_id
+                 ,cube_att_form_def_id
+                 ,rep_dos_id
+                 ,mstr_rag_col_d):
+
+        self.cube_obj_prp_rel_id=cube_obj_prp_rel_id
+        self.cube_RAG_form_val_ans_id=cube_RAG_form_val_ans_id
+        self.rep_dos_id=rep_dos_id
+        self.mstr_rag_col_d=mstr_rag_col_d
+        self.cube_att_form_def_id=cube_att_form_def_id
+
+
+    def bld_AI_filt_prp_ans(self,conn,vector_store,filter_d):
+        # print(json_f)
+        # v_andOr_s="And"
+        # att_filt_prp_id="1F21042E4FC08886A9D7E4920CA4EC59"
+        # met_filt_prp_id="14B57F1F46127BC6E6F746888BC3C7CB"
+        prp_ans_d_l = []
+
+        # ={}
+        last_p_ans_d_j = {}
+
+        for f in list(filter_d.keys()):
+            print(f)
+            results = vector_store.similarity_search_with_score(query=f, top_k=1)
+
+            filter_obj_name = results[0][0].page_content
+            #print(filter_obj_name)
+            #print(self.mstr_rag_col_d)
+            filt_obj_rag_df = i_map_objects.get_rag_rep_prp_df(conn, cube_id=self.cube_obj_prp_rel_id, rep_dos_id=self.rep_dos_id,
+                                                 key_word_l=[filter_obj_name],mstr_rag_col_d=self.mstr_rag_col_d)
+
+            filt_obj_rag_df = filt_obj_rag_df[filt_obj_rag_df['prp_subType'].isin(['prompt_expression'])]
+
+            operator = next(iter(filter_d[f]))
+            filter_val_l = filter_d[f][operator]
+            #print("DDDDDDDDDDDDDDDDD")
+            #print(filt_obj_rag_df)
+            d_prp_ans_d = {}
+            for index, obj in filt_obj_rag_df.iterrows():
+                d_prp_ans_d["prompt_id"] = obj["prompt_id"]
+                d_prp_ans_d["prp_subType"] = obj["prp_subType"]
+                d_prp_ans_d["object_id"] = obj["object_id"]
+                d_prp_ans_d["obj_type"] = obj["obj_type"]
+                d_prp_ans_d["operator"] = operator
+                if obj["obj_type"] == "attribute":
+                    if operator in ("In", "notIn"):
+
+                        filter_val_df = i_map_objects.get_rag_rep_prp_df(conn, cube_id=self.cube_RAG_form_val_ans_id,
+                                                           rep_dos_id=self.rep_dos_id, key_word_l=filter_val_l,mstr_rag_col_d=self.mstr_rag_col_d)
+                        filt_df = pd.merge(filt_obj_rag_df[["prompt_id", "prp_subType", "object_id", "obj_type"]],
+                                           filter_val_df[
+                                               ["prompt_id", "prp_subType", "attribute_id", "attribute_name", "form_id",
+                                                "form_name", "form_dataType", "key"]],
+                                           left_on=['object_id'], right_on=['attribute_id'], how='inner')
+                        filt_df = i_df_helper.clean_double_col(df=filt_df)
+                        #print(filt_df)
+                        filter_val_l = []
+                        for index, f_form_ele in filt_df.iterrows():
+                            form_id = f_form_ele["form_id"]
+                            form_dataType = f_form_ele["form_dataType"]
+                            filter_val_l.append(f_form_ele["key"])
+
+                        att_exp_ans_d = {"att_id": d_prp_ans_d["object_id"], "att_form_id": form_id,
+                                         "form_data_type": form_dataType, "operator": operator,
+                                         "filter_val_l": filter_val_l}
+
+                        att_exp_ans_d = i_prompts.bld_att_exp_prp_l(prp_job_ans_d=att_exp_ans_d)
+                        d_prp_ans_d["prp_ans_d"] = att_exp_ans_d
+                        prp_ans_d_l.append(d_prp_ans_d.copy())
+                        #print(d_prp_ans_d)
+
+                    else:
+                        col_id = i_cube.get_RAG_cube_col_mstr_id(cube_id=self.cube_att_form_def_id, col_name="attribute_id",mstr_rag_col_d=self.mstr_rag_col_d)
+                        attr_elements = col_id + ":" + obj["object_id"]
+                        df = i_cube.quick_query_cube(conn, cube_id=self.cube_att_form_def_id, attribute_l=None, metric_l=None,
+                                              attr_elements=attr_elements)
+
+                        for index, form in df.iterrows():
+                            if int(form["display_form_nr"]) > 0:
+                                att_exp_ans_d = {"att_id": form["attribute_id"], "att_form_id": form["form_id"],
+                                                 "form_data_type": form["REST_form_type"], "operator": operator,
+                                                 "filter_val_l": filter_val_l}
+
+                                att_exp_ans_d = i_prompts.bld_att_exp_prp(prp_job_ans_d=att_exp_ans_d)
+                                d_prp_ans_d["prp_ans_d"] = att_exp_ans_d
+                                prp_ans_d_l.append(d_prp_ans_d.copy())
+                                #print(d_prp_ans_d)
+
+                if obj["obj_type"] == "metric":
+                    metric_exp_prp = {}
+                    metric_exp_prp["met_id"] = obj["object_id"]
+                    metric_exp_prp["data_type"] = "Real"
+                    metric_exp_prp["operator"] = operator
+                    metric_exp_prp["filter_val_l"] = filter_val_l
+                    metric_exp_prp["level"] = "default"
+                    d_prp_ans_d["prp_ans_d"] = i_prompts.bld_metric_exp_prp(metric_exp_prp=metric_exp_prp.copy())
+                    prp_ans_d_l.append(d_prp_ans_d.copy())
+                    #print(print(d_prp_ans_d))
+
+            # prp_ans_d_l.append(last_p_ans_d_j.copy())
+        return prp_ans_d_l
+
+    def bld_ai_obj_ans_prp(self,conn,json_t_d):
+        key_l = []
+        col_id = i_cube.get_RAG_cube_col_mstr_id(cube_id=self.cube_obj_prp_rel_id, col_name="object_id",mstr_rag_col_d=self.mstr_rag_col_d)
+        obj_l = []
+        template_obj_d = {}
+
+        for obj_type in json_t_d["template"].keys():
+            for obj in json_t_d["template"][obj_type]:
+                template_obj_d = {"obj_type": obj_type, "obj": obj}
+                obj_l.append(template_obj_d.copy())
+
+        for obj in obj_l:
+            key_l.append(obj["obj"])
+
+        template_obj_rag_df = i_map_objects.get_rag_rep_prp_df(conn, cube_id=self.cube_obj_prp_rel_id, rep_dos_id=self.rep_dos_id,
+                                                 key_word_l=key_l,mstr_rag_col_d=self.mstr_rag_col_d)
+        template_obj_rag_df = template_obj_rag_df[template_obj_rag_df['prp_subType'].isin(['prompt_objects'])]
+        template_obj_rag_df = template_obj_rag_df[['prompt_id', 'prp_subType', "object_id", "obj_type"]]
+
+        template_obj_rag_df.rename(columns={'object_id': 'id', 'obj_type': 'type'}, inplace=True)
+        prp_ans_d_l = template_obj_rag_df.groupby(['prompt_id']).apply(
+            lambda x: x[['id', 'type']].to_dict(orient='records')).to_dict()
+        obj_prp_ans_l = []
+        for prp in prp_ans_d_l:
+            obj_prp_ans_d = {}
+            obj_prp_ans_d["id"] = prp
+            obj_prp_ans_d["type"] = "OBJECTS"
+            obj_prp_ans_d["answers"] = prp_ans_d_l[prp]
+            obj_prp_ans_l.append(obj_prp_ans_d)
+
+        return obj_prp_ans_l
+
+    def merge_exp_prp_ans_l(self,ai_prp_filt_ans_d):
+        prp_ans_l = []
+        prp_id_l = i_msic.get_key_form_dict_l(dict_l=ai_prp_filt_ans_d, key="prompt_id")
+        prp_ans_d_all = {}
+        operand_X = "AND"
+        for prp_id in prp_id_l:
+            prp_ans_d_all[prp_id] = []
+
+        for prp_ans in ai_prp_filt_ans_d:
+            for prp_id in prp_ans_d_all.keys():
+                if prp_ans["prompt_id"] == prp_id:
+                    prp_ans_d_all[prp_id].append(prp_ans["prp_ans_d"])
+
+        for prp_id in prp_ans_d_all:
+            # print(prp_ans_d_all[prp_id])
+            prp_ans_d_all[prp_id] = i_prompts.bld_exp_operands_d(p_ans_d_d_l=prp_ans_d_all[prp_id], operator="AND")
+
+        for prp_ans_id in prp_ans_d_all:
+            for prp in ai_prp_filt_ans_d:
+                if prp_ans_id == prp["prompt_id"]:
+                    if prp["prp_subType"] == "prompt_expression" and prp["obj_type"] == "attribute":
+                        prp_ans_l.append(i_prompts.bld_prp_exp_d(prompt_id=prp_ans_id,
+                                                       p_ans_d_j=prp_ans_d_all[prp_ans_id], operator="And"))
+
+                    if prp["prp_subType"] == "prompt_expression" and prp["obj_type"] == "metric":
+                        prp_ans_l.append(i_prompts.frame_metric_exp_prp(prompt_id=prp_ans_id, p_ans_d_j=prp_ans_d_all[prp_ans_id]))
+                    break
+        return prp_ans_l
+
+    def save_AI_rep(self, conn, rep_wizzard_id, prompt_answ, ai_rep_name, ai_rep_folder_id):
+        instance_id = i_rep.open_Instance(conn=conn, report_id=rep_wizzard_id)
+        first_draft = i_rep.set_inst_prompt_ans(conn=conn, report_id=rep_wizzard_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"
+                                          , setCurrentAsDefaultAnswer=True)
+
+        return rep_id
+
+
+class openAI():
+
+    def __init__(self,sKey):
+        #self.sKey=sKey
+        os.environ["OPENAI_API_KEY"] = sKey
+        self.i_embeddings = OpenAIEmbeddings()
+
+    def check_trans_chatGPT(self,sKey,messages,*args,**kwargs):
+        chat_completion = self.call_open_AI(sKey=sKey,messages=messages,*args,**kwargs)
+        js = json.loads(chat_completion.json())
+        return js
+
+    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",
+            model=model,
+            max_tokens=max_tokens,
+            temperature=temperature
+        )
+        js = json.loads(chat_completion.json())
+        return js
+