energy-reports-pkg 0.6.14__py3-none-any.whl

mindsett_energy_reports_pkg/libs/MondayProcessor/MondayProcessorExceptions_/MondayProcessorException/__init__.py

@@ -0,0 +1,4 @@
+
+class MondayProcessorException(Exception):
+    def __init__(self, *args: object) -> None:
+        super().__init__(*args)

mindsett_energy_reports_pkg/libs/MondayProcessor/MondayProcessorExceptions_/MondayProcessorNoColumInBoard/__init__.py

@@ -0,0 +1,5 @@
+from ..MondayProcessorException import MondayProcessorException
+
+class MondayProcessorNoColumInBoard(MondayProcessorException):
+    def __init__(self, *args: object) -> None:
+        super().__init__(*args)

mindsett_energy_reports_pkg/libs/MondayProcessor/MondayProcessorExceptions_/MondayProcessorNoGroupsInBoard/__init__.py

@@ -0,0 +1,5 @@
+from ..MondayProcessorException import MondayProcessorException
+
+class MondayProcessorNoGroupsInBoard(MondayProcessorException):
+    def __init__(self, *args: object) -> None:
+        super().__init__(*args)

mindsett_energy_reports_pkg/libs/MondayProcessor/MondayProcessorExceptions_/MondayProcessorNoItemInGroup/__init__.py

@@ -0,0 +1,6 @@
+
+from ..MondayProcessorException import MondayProcessorException
+        
+class MondayProcessorNoItemInGroup(MondayProcessorException):
+    def __init__(self, *args: object) -> None:
+        super().__init__(*args)

mindsett_energy_reports_pkg/libs/MondayProcessor/MondayProcessorExceptions_/MondayProcessorPageNotSupported/__init__.py

@@ -0,0 +1,7 @@
+
+
+from ..MondayProcessorException import MondayProcessorException
+
+class MondayProcessorPageNotSupported(MondayProcessorException):
+    def __init__(self, *args: object) -> None:
+        super().__init__(*args)

mindsett_energy_reports_pkg/libs/MondayProcessor/MondayProcessorExceptions_/__init__.py

@@ -0,0 +1,8 @@
+
+from .MondayProcessorException import MondayProcessorException
+from .MondayProcessorBoardNotFound import MondayProcessorBoardNotFound
+from .MondayProcessorNoColumInBoard import MondayProcessorNoColumInBoard
+from .MondayProcessorNoGroupsInBoard import MondayProcessorNoGroupsInBoard
+from .MondayProcessorNoItemInGroup import MondayProcessorNoItemInGroup
+from .MondayProcessorBoardColumnNotMatch import MondayProcessorBoardColumnNotMatch
+from .MondayProcessorPageNotSupported import MondayProcessorPageNotSupported

mindsett_energy_reports_pkg/libs/MondayProcessor/__init__.py

@@ -0,0 +1,40 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#author: Xiao Wang 
+# x.wang@cloudfmgroup.com
+# Created: 05/04/2023
+
+from .DataProcessor import DataProcessor
+from monday import MondayClient
+
+class MondayProcessor(DataProcessor):
+
+    from .launchInteractiveProcess import launchInteractiveProcess
+    from ._fetchBoardById import _fetchBoardById
+    from ._fetchBoardLogsById import _fetchBoardLogsById
+    from ._fetchGroups import _fetchGroups
+    from ._fetchPrismConf import _fetchPrismConf
+    from ._fetchPrismConfByBoard import _fetchPrismConfByBoard
+    from ._fetchPrismConfByGroup import _fetchPrismConfByGroup
+    from ._fetchColumnValueByGroup import _fetchColumnValueByGroup
+    from ._searchConfColumnIds import _searchConfColumnIds
+    from ._searchColumnIdsByName import _searchColumnIdsByName
+    from ._searchConfColumnIdsMatch import _searchConfColumnIdsMatch
+    
+    def __init__(self, MONDAY_TOKEN) -> None:
+        super().__init__()
+        self._token = MONDAY_TOKEN
+        self.monday = MondayClient(self._token)
+    
+
+if __name__ == "__main__":
+
+    mp = MondayProcessor()
+    # mp._fetchBoardById(4246692749)
+    # mp._fetchPrismConfByGroup(board_id=4246692749, groupId="topics", columns=["ct_type",  "color",  "prism_channel_no_9", "status1" ])
+    ConfColumnIds = mp._searchConfColumnIds(4246692749)
+    mp._fetchPrismConfByGroup(board_id=4246692749, groupId="topics", columns=ConfColumnIds)
+    # mp._fetchGroups(4246692749)
+    # mp._fetchPrismConf(4246692749)
+    # df = mp.launchInteractiveProcess(4246692749)
+    # print(df)

mindsett_energy_reports_pkg/libs/MondayProcessor/_fetchBoardById.py

@@ -0,0 +1,13 @@
+import requests
+
+def _fetchBoardById(self, board_id:int):
+    headers = {"Authorization": self._token,
+               "API-Version": '2024-01'}
+    data = {"query": f'''query {{
+        boards (ids:{board_id}){{
+            id
+            name
+        }}
+    }}'''}
+    r = requests.post('https://api.monday.com/v2', headers=headers, data=data)
+    return r.json()

mindsett_energy_reports_pkg/libs/MondayProcessor/_fetchBoardLogsById.py

@@ -0,0 +1,33 @@
+import requests
+
+# def _fetchBoardLogsById(self, board_id:int):
+#     headers = {"Authorization": self._token}
+#     data = {"query": f'''query {{
+#         boards (ids:{board_id}){
+#             activity_logs (limit: 10) {
+#             id
+#             name
+#         }}
+#     }}'''}
+#     r = requests.post('https://api.monday.com/v2', headers=headers, data=data)
+#     return r.json()
+
+def _fetchBoardLogsById(self, board_id, limit=1):
+    headers = {"Authorization": self._token,
+               "API-Version": '2024-01'}
+    data = {"query": f'''query {{
+        boards (ids:{board_id}){{
+            activity_logs (limit: {limit}) {{
+            id
+            event
+            created_at
+        }}
+        }}
+    }}'''}
+    r = requests.post('https://api.monday.com/v2', headers=headers, json=data)
+
+    data = r.json()
+    if 'data' not in data:
+        print(data) 
+
+    return data

mindsett_energy_reports_pkg/libs/MondayProcessor/_fetchColumnValueByGroup.py

@@ -0,0 +1,103 @@
+from typing import List
+import requests
+
+
+from .MondayProcessorExceptions_ import (
+    MondayProcessorBoardNotFound,
+    MondayProcessorNoColumInBoard,
+    MondayProcessorNoItemInGroup,
+    MondayProcessorPageNotSupported
+)
+
+def _fetchColumnValueByGroup(self, board_id:int, groupId:str, columns:List[str]):
+        
+    column_ids = []
+    
+    for column_name in columns:
+        for column_id in self._searchColumnIdsByName(board_id, column_name=column_name):
+            column_ids.append(column_id)
+    
+    columns_str = '["' + '","'.join(column_ids) + '"]'
+    # columns_index = ["ct", "phase", "channel", "sn", "powerSupplyPhase"]
+    # columnsDict = dict(zip(columns,columns_index))
+    headers = {"Authorization": self._token,
+               "API-Version": '2024-01'}
+    data = {"query": f'''query {{
+        boards (ids:{board_id}){{
+            id
+            name
+            groups(ids:"{groupId}"){{
+                id
+                items_page(limit:500){{
+                    cursor
+                    items{{
+                        id
+                        name
+                        column_values(ids:{columns_str}){{
+                            column{{
+                                title
+                                }}
+                            type
+                            text
+                            ... on BoardRelationValue {{
+                                display_value
+                            }}
+                            ... on LinkValue {{
+                                url_text
+                            }}
+                            ... on CheckboxValue {{
+                                checked
+                            }}
+                        }}
+                    }}
+                }}
+
+            }}
+        }}
+    }}'''}
+    r = requests.post('https://api.monday.com/v2', headers=headers, json=data)
+    data = r.json()
+    if 'data' not in data:
+        print(data) 
+    # print(data) 
+    boards = data['data']['boards']
+    if(len(boards) <1):
+        raise MondayProcessorBoardNotFound(f"Monday board id ({board_id}) not found when perform MondayProcessor._searchConfColumnIds")
+    groups = boards[0]['groups']
+    if(len(groups) < 1):
+        raise MondayProcessorNoColumInBoard(f"No column in board {board_id}")
+    items_page = groups[0]['items_page']
+    if items_page['cursor'] is not None:
+        raise MondayProcessorPageNotSupported(f"The items on page exceeded the limit 500, board {board_id}, group {groupId}!")
+
+    items = items_page['items']
+    if(len(items) < 1):
+        raise MondayProcessorNoItemInGroup(f"No column in board {board_id}, group {groupId}")
+    
+    ret = []
+    for item in items:
+#             print('item:', item)
+        tmpDict = {}
+        if 'Name' in columns:
+            tmpDict['Name'] = item['name']
+        for v in item["column_values"]:
+
+            if v["type"] == 'board_relation':
+                tmpDict[v['column']["title"]] = v["display_value"]
+            elif v["type"] == "link":
+                tmpDict[v['column']["title"]] = v["url_text"]
+            elif v["type"] == "checkbox":
+                tmpDict[v['column']["title"]] = v["checked"]
+            else:
+                tmpDict[v['column']["title"]] = v["text"]
+#                 key = v["id"]
+#                 ai = v["additional_info"]
+#                 tmpDict[key]= None if ai== None else json.loads(ai)["label"]
+#             try:
+#                 ch = tmpDict["channel"]
+#                 chN = int(ch)
+#                 tmpDict["channel"] = chN
+#             except:
+#                 tmpDict["channel"] = None
+        ret.append(tmpDict)
+    return ret

mindsett_energy_reports_pkg/libs/MondayProcessor/_fetchGroups.py

@@ -0,0 +1,19 @@
+from typing import List
+
+from .MondayProcessorExceptions_ import (
+    MondayProcessorBoardNotFound,
+    MondayProcessorNoColumInBoard
+)
+
+def _fetchGroups(self, board_id:int) -> List[str]:
+    data = self.monday.groups.get_groups_by_board(board_ids=board_id)
+    boards = data['data']['boards']
+    if(len(boards) <1):
+        raise MondayProcessorBoardNotFound(f"Monday board id ({board_id}) not found when perform MondayProcessor._searchConfColumnIds")
+    groups = boards[0]['groups']
+    if(len(groups) < 1):
+        raise MondayProcessorNoColumInBoard(f"No column in board {board_id}")
+    ret = {x["id"]:x["title"] for x in groups}
+#         print(groups)
+    # print(ret)
+    return ret

mindsett_energy_reports_pkg/libs/MondayProcessor/_fetchPrismConf.py

@@ -0,0 +1,10 @@
+from typing import List
+
+def _fetchPrismConf(self, board_id:int)->List[dict]:
+    confColumnIds = self._searchConfColumnIds(board_id=board_id)
+    groupIds = self._fetchGroups(board_id=board_id)
+    ret = []
+    for gId in groupIds:
+        items = self._fetchPrismConfByGroup(board_id=board_id, groupId=gId, columns=confColumnIds)
+        ret.extend(items)
+    return ret

mindsett_energy_reports_pkg/libs/MondayProcessor/_fetchPrismConfByBoard.py

@@ -0,0 +1,83 @@
+
+from typing import List
+import requests
+
+from .MondayProcessorExceptions_ import (
+    MondayProcessorBoardNotFound,
+    MondayProcessorNoColumInBoard,
+    MondayProcessorNoItemInGroup
+)
+
+
+def _fetchPrismConfByBoard(self, board_id:int, columns:List[str]):
+        
+    column_ids = []
+    
+    for column_name in columns:
+        for column_id in self._searchColumnIdsByName(board_id, column_name=column_name):
+            column_ids.append(column_id)
+    
+    columns_str = '["' + '","'.join(column_ids) + '"]'
+    columns_index = ["ct", "phase", "channel", "sn", "powerSupplyPhase"]
+    columnsDict = dict(zip(columns,columns_index))
+    headers = {"Authorization": self._token,
+               "API-Version": '2024-01'}
+    data = {"query": f'''query {{
+        boards (ids:{board_id}){{
+            id
+            name
+            groups(){{
+                id
+                title
+                items_page(limit:500) {{
+                    cursor
+                    items{{
+                        id
+                        name
+                        column_values(ids:{columns_str}){{
+                            column{{title}}
+                            text
+                        }}
+                }}
+                }}
+                
+            }}
+        }}
+    }}'''}
+    r = requests.post('https://api.monday.com/v2', headers=headers, json=data)
+    data = r.json()
+    if 'data' not in data:
+        print(data)
+    boards = data['data']['boards']
+    if(len(boards) <1):
+        raise MondayProcessorBoardNotFound(f"Monday board id ({board_id}) not found when perform MondayProcessor._searchConfColumnIds")
+    groups = boards[0]['groups']
+    if(len(groups) < 1):
+        raise MondayProcessorNoColumInBoard(f"No column in board {board_id}")
+    
+    ret = []
+    for group in groups:
+        groupId = group['id']
+        items = group['items_page']['items']
+        if(len(items) < 1):
+            raise MondayProcessorNoItemInGroup(f"No column in board {board_id}, group {groupId}")
+
+        for item in items:
+            print('item:', item)
+            tmpDict = {}
+            if 'Name' in columns:
+                tmpDict['Name'] = item['name']
+            tmpDict['building_name'] = group["title"]
+            for v in item["column_values"]:
+                tmpDict[v["column"]["title"]] = v["text"]
+#                 key = v["id"]
+#                 ai = v["additional_info"]
+#                 tmpDict[key]= None if ai== None else json.loads(ai)["label"]
+#             try:
+#                 ch = tmpDict["channel"]
+#                 chN = int(ch)
+#                 tmpDict["channel"] = chN
+#             except:
+#                 tmpDict["channel"] = None
+            ret.append(tmpDict)
+    return ret

mindsett_energy_reports_pkg/libs/MondayProcessor/_fetchPrismConfByGroup.py

@@ -0,0 +1,89 @@
+from typing import List
+import requests
+
+
+from .MondayProcessorExceptions_ import (
+    MondayProcessorBoardNotFound,
+    MondayProcessorNoColumInBoard,
+    MondayProcessorNoItemInGroup,
+    MondayProcessorPageNotSupported
+)
+
+def _fetchPrismConfByGroup(self, board_id:int, groupId:str, columns:List[str]):
+        
+    column_ids = []
+    
+    for column_name in columns:
+        for column_id in self._searchColumnIdsByName(board_id, column_name=column_name):
+            column_ids.append(column_id)
+    
+    columns_str = '["' + '","'.join(column_ids) + '"]'
+    columns_index = ["ct", "phase", "channel", "sn", "powerSupplyPhase"]
+    columnsDict = dict(zip(columns,columns_index))
+    headers = {"Authorization": self._token,
+            #    "Content-Type": 'application/json',
+               "API-Version": '2024-01'}
+    
+    graphql_query = f'''query {{
+                            boards (ids:{board_id}){{
+                                id
+                                name
+                                groups(ids:"{groupId}"){{
+                                    id
+                                    items_page(limit:500){{
+                                        cursor
+                                        items{{
+                                            id
+                                            name
+                                            column_values(ids:{columns_str}){{
+                                                column{{
+                                                    title
+                                                    }}
+                                                text
+                                            }}
+                                        }}
+                                    }}
+
+                                }}
+                            }}
+                        }}'''
+    
+    data = {"query": graphql_query}
+
+    r = requests.post('https://api.monday.com/v2', headers=headers, json=data)
+    data = r.json()
+    if 'data' not in data:
+        print(data) 
+    boards = data['data']['boards']
+    if(len(boards) <1):
+        raise MondayProcessorBoardNotFound(f"Monday board id ({board_id}) not found when perform MondayProcessor._searchConfColumnIds")
+    groups = boards[0]['groups']
+    if(len(groups) < 1):
+        raise MondayProcessorNoColumInBoard(f"No column in board {board_id}")
+    items_page = groups[0]['items_page']
+    if items_page['cursor'] is not None:
+        raise MondayProcessorPageNotSupported(f"The items on page exceeded the limit 500, board {board_id}, group {groupId}!")
+
+    items = items_page['items']
+    if(len(items) < 1):
+        raise MondayProcessorNoItemInGroup(f"No column in board {board_id}, group {groupId}")
+    
+    ret = []
+    for item in items:
+#             print('item:', item)
+        tmpDict = {}
+        if 'Name' in columns:
+            tmpDict['Name'] = item['name']
+        for v in item["column_values"]:
+            tmpDict[v['column']["title"]] = v["text"]
+#                 key = v["id"]
+#                 ai = v["additional_info"]
+#                 tmpDict[key]= None if ai== None else json.loads(ai)["label"]
+#             try:
+#                 ch = tmpDict["channel"]
+#                 chN = int(ch)
+#                 tmpDict["channel"] = chN
+#             except:
+#                 tmpDict["channel"] = None
+        ret.append(tmpDict)
+    return ret

mindsett_energy_reports_pkg/libs/MondayProcessor/_searchColumnIdsByName.py

@@ -0,0 +1,23 @@
+from typing import List
+
+from .MondayProcessorExceptions_ import (
+    MondayProcessorBoardNotFound,
+    MondayProcessorNoColumInBoard,
+    MondayProcessorBoardColumnNotMatch
+)
+
+def _searchColumnIdsByName(self, board_id:int, column_name:str) -> List[str]:
+    data = self.monday.boards.fetch_columns_by_board_id(board_ids=board_id)
+    boards = data['data']['boards']
+    if(len(boards) <1):
+        raise MondayProcessorBoardNotFound(f"Monday board id ({board_id}) not found when perform MondayProcessor._searchConfColumnIds")
+    columns = boards[0]['columns']
+    if(len(columns) < 1):
+        raise MondayProcessorNoColumInBoard(f"No column in board {board_id}")
+    #  = boards[0][groups]
+    # print("columns: ", columns)
+    ColumnId = self._searchConfColumnIdsMatch(columns=columns,includeList=[column_name])
+    if (ColumnId == None): raise MondayProcessorBoardColumnNotMatch("cannot find a column with this name")
+
+    ret = [ColumnId]
+    return ret

mindsett_energy_reports_pkg/libs/MondayProcessor/_searchConfColumnIds.py

@@ -0,0 +1,30 @@
+from typing import List
+
+from .MondayProcessorExceptions_ import (
+    MondayProcessorBoardNotFound,
+    MondayProcessorNoColumInBoard,
+    MondayProcessorBoardColumnNotMatch
+)
+
+def _searchConfColumnIds(self, board_id:int) -> List[str]:
+    data = self.monday.boards.fetch_columns_by_board_id(board_ids=board_id)
+    boards = data['data']['boards']
+    if(len(boards) <1):
+        raise MondayProcessorBoardNotFound(f"Monday board id ({board_id}) not found when perform MondayProcessor._searchConfColumnIds")
+    columns = boards[0]['columns']
+    if(len(columns) < 1):
+        raise MondayProcessorNoColumInBoard(f"No column in board {board_id}")
+    #  = boards[0][groups]
+    ctColumnId = self._searchConfColumnIdsMatch(columns=columns,includeList=["ct","type"])
+    if (ctColumnId == None): raise MondayProcessorBoardColumnNotMatch("cannot find CT type column")
+    phaseColumnId = self._searchConfColumnIdsMatch(columns=columns,includeList=["L1","L2","L3"], excludeList=["supply"])
+    if (phaseColumnId == None): raise MondayProcessorBoardColumnNotMatch("cannot find circuit phase column")
+    channelColumnId = self._searchConfColumnIdsMatch(columns=columns,includeList=["channel","no"])
+    if (channelColumnId == None): raise MondayProcessorBoardColumnNotMatch("cannot find PRISM channel column")
+    snColumnId = self._searchConfColumnIdsMatch(columns=columns,includeList=["ID","PRISM"])
+    if (snColumnId == None): raise MondayProcessorBoardColumnNotMatch("cannot find PRISM SN column")
+    powerSupplyPhaseColumnId = self._searchConfColumnIdsMatch(columns=columns,includeList=["PRISM","supply","phase"])
+    if (powerSupplyPhaseColumnId == None): raise MondayProcessorBoardColumnNotMatch("cannot find PRISM power supply phase column")
+
+    ret = [ctColumnId, phaseColumnId, channelColumnId, snColumnId, powerSupplyPhaseColumnId]
+    return ret

mindsett_energy_reports_pkg/libs/MondayProcessor/_searchConfColumnIdsMatch.py

@@ -0,0 +1,20 @@
+from typing import List, Union
+
+def _searchConfColumnIdsMatch(self, columns, includeList:List[str], excludeList:List[str] = [])-> Union[str,None]:
+    for c in columns:
+        title:str = c["title"]
+        id = c["id"]
+        flag = True
+        for item in includeList:
+            if item.lower() not in title.lower():
+                flag = False
+                break
+        if(not flag): continue
+        flag = True
+        for item in excludeList:
+            if item.lower() in title.lower():
+                flag = False
+                break
+        if(not flag): continue
+        return id
+    return None

mindsett_energy_reports_pkg/libs/MondayProcessor/dev/graphql_query/__init__.py

@@ -0,0 +1,11 @@
+
+from .boards import boards
+
+def graphql_query(board_id, group_id, column_values_ids):
+
+    graphql_query = f'''query {{
+            {boards(board_id, group_id, column_values_ids)} 
+        }}'''
+    
+    return graphql_query
+    

mindsett_energy_reports_pkg/libs/MondayProcessor/dev/graphql_query/boards/__init__.py

@@ -0,0 +1,12 @@
+
+from .groups import groups
+
+def boards(id, group_id, column_values_ids):
+    boards = f'''
+    boards (ids:{id}){{
+                id
+                name
+                {groups(group_id, column_values_ids)}
+            }}
+    '''
+    return boards

mindsett_energy_reports_pkg/libs/MondayProcessor/dev/graphql_query/boards/groups/__init__.py

@@ -0,0 +1,11 @@
+from .items_page import items_page
+
+def groups(id, column_values_ids):
+    groups = f'''
+            groups(ids:"{id}"){{
+                            id
+                            {items_page(column_values_ids)}
+
+                        }}
+            '''
+    return groups

mindsett_energy_reports_pkg/libs/MondayProcessor/dev/graphql_query/boards/groups/items_page/__init__.py

@@ -0,0 +1,10 @@
+from .items import items
+
+def items_page(column_values_ids):
+    items_page = f"""
+            items_page(limit:500){{
+                                cursor
+                                {items(column_values_ids)}
+                            }}
+            """
+    return items_page

mindsett_energy_reports_pkg/libs/MondayProcessor/dev/graphql_query/boards/groups/items_page/items/__init__.py

@@ -0,0 +1,12 @@
+
+from .column_values import column_values
+
+def items(column_values_ids):
+    items = f"""
+                items{{
+                        id
+                        name
+                        {column_values(column_values_ids)}
+                        }}
+            """
+    return items

mindsett_energy_reports_pkg/libs/MondayProcessor/dev/graphql_query/boards/groups/items_page/items/column_values/__init__.py

@@ -0,0 +1,10 @@
+from .column import column
+
+def column_values(ids):
+    column_values = f"""
+                column_values (ids:{ids}) {{
+                            {column}
+                            text
+                        }}
+                        """
+    return column_values

mindsett_energy_reports_pkg/libs/MondayProcessor/dev/graphql_query/boards/groups/items_page/items/column_values/column/__init__.py

@@ -0,0 +1,2 @@
+
+column = """column{{ title }}"""

mindsett_energy_reports_pkg/libs/MondayProcessor/launchInteractiveProcess.py

@@ -0,0 +1,7 @@
+import pandas as pd 
+
+def launchInteractiveProcess(self, board_id:int) -> pd.DataFrame:
+    data = self._fetchPrismConf(board_id)
+    df = pd.DataFrame.from_records(data)
+    # print(df.head(10))
+    return df

mindsett_energy_reports_pkg/libs/__init__.py

@@ -0,0 +1,4 @@
+import os.path, sys
+file_path = os.path.realpath(__file__)
+dir_path = os.path.dirname(file_path)
+sys.path.append(dir_path)

mindsett_energy_reports_pkg/libs/cache_return/__init__.py

@@ -0,0 +1,47 @@
+
+import functools
+import pandas as pd
+import os
+import pickle
+
+# note: this function require the cached module function names to be unique
+# note: this function can be only applied to functions returning dataframe now 
+
+def cache_return(_func=None):
+    def decorator(func):
+        func_name = func.__name__
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+
+            caching = kwargs.pop('caching', False)
+            flushing = kwargs.pop('flushing', False)
+            cache_path = kwargs.pop('cache_path', './_cache_')
+
+            if caching:
+                if not os.path.exists(cache_path):
+                    os.makedirs(cache_path)
+
+                # dir_path = os.path.dirname(os.path.realpath(__file__))
+                pkl_path = f'{cache_path}/{func_name}.pkl'
+                if os.path.exists(pkl_path) and not flushing:
+                    with open(pkl_path, 'rb') as file:
+                        df_value = pd.compat.pickle_compat.load(file)
+                        # df_value = pickle.load(file)
+
+                    print(f'[INFO]: the value of function [{func_name}] has been obtained from {cache_path}!')
+                    return df_value
+            
+            df_value = func(*args, **kwargs)
+            
+            if caching:
+                with open(pkl_path, 'wb') as file:
+                    pickle.dump(df_value, file)
+                print(f'[INFO]: the value of function [{func_name}] has been cached under {cache_path}!')
+            
+            return df_value
+        return wrapper
+
+    if _func is None:
+        return decorator
+    else:
+        return decorator(_func)