ebm 0.99.5__py3-none-any.whl

ebm/services/calibration_writer.py

@@ -0,0 +1,262 @@
+import typing
+from datetime import datetime
+import os
+
+from loguru import logger
+import pandas as pd
+
+from ebm.model import building_category
+from ebm.model.heating_systems import HeatingSystems
+from ebm.model.energy_purpose import EnergyPurpose
+from ebm.services.excel_loader import access_excel_sheet
+from ebm.services.spreadsheet import SpreadsheetCell
+
+KEY_ERROR_COLOR = 0xC0C0C0
+COLOR_AUTO = -4105
+
+
+class ComCalibrationReader:
+    filename: str
+    sheet_name: str
+    df: pd.DataFrame
+
+    def __init__(self, workbook_name=None, sheet_name=None):
+        wb, sh = os.environ.get('EBM_CALIBRATION_SHEET', '!').split('!')
+        self.workbook_name = wb if workbook_name is None else workbook_name
+        self.sheet_name = sh if sheet_name is None else sheet_name
+
+    def extract(self) -> typing.Tuple:
+        sheet = access_excel_sheet(self.workbook_name, self.sheet_name)
+        used_range = sheet.UsedRange
+
+        values = used_range.Value
+        logger.debug(f'Found {len(values)} rows in {sheet}')
+
+        return used_range.Value
+
+    def transform(self, com_calibration_table: typing.Tuple) -> pd.DataFrame:
+        def replace_building_category(row):
+            unknown_heating_systems = set()
+            for factor_name in row[2].split(' and '):
+                try:
+                    bc = building_category.from_norsk(row[0])
+                except ValueError as value_error:
+                    if row[0].lower() in ('yrksebygg', 'yrkesbygg'):
+                        bc = building_category.NON_RESIDENTIAL
+                    elif row[0].lower() == 'bolig':
+                        bc = building_category.RESIDENTIAL
+                erq = 'energy_requirement' if row[1].lower() == 'energibehov' else 'energy_consumption'
+                variabel = factor_name
+                extra = None
+                if erq == 'energy_requirement':
+                    variabel = EnergyPurpose(factor_name) if factor_name.lower() != 'elspesifikt' else EnergyPurpose.ELECTRICAL_EQUIPMENT
+                else:
+                    variabel = factor_name
+                    extra = row[-1]
+                    if not extra or extra.strip() in ('?', ''):
+                        extra = HeatingSystems.ELECTRICITY
+
+                    if variabel not in [h for h in HeatingSystems]:
+                        unknown_heating_systems.add(variabel)
+                    if extra not in [h for h in HeatingSystems]:
+                        unknown_heating_systems.add(extra)
+                yield bc, erq, variabel, row[3], extra
+            if len(unknown_heating_systems) > 0:
+                unknowns = ','.join([f'"{hs}"' for hs in unknown_heating_systems])
+                msg = f'Unknown heating systems {unknowns}'
+                raise ValueError(msg)
+
+
+        def handle_rows(rows):
+            for row in rows:
+                yield from replace_building_category(row)
+
+        logger.debug(f'Transform {self.sheet_name}')
+        data = com_calibration_table[1:]
+
+        data = list(handle_rows([r for r in data if r[1].lower().replace('_','').replace(' ','') in ('energibehov',
+                                                                                                     'heatingsystem')]))
+
+        df = pd.DataFrame(data, columns=['building_category', 'group', 'variable', 'heating_rv_factor', 'extra'])
+
+        return df
+
+
+class ExcelComCalibrationResultWriter:
+    """
+    A class to handle the extraction, transformation, and loading of a pd.Dataframe to a open Excel spreadsheet.
+    The Dataframe is expected to have two columns in the index. The first index column is used to match the
+    first row of the Excel range. The index second column is used to match the first column in the Excel range. The
+    rest of the range is filled out by the last column in the dataframe.
+
+    Excel range: A1:D4
+
+    XXXXXX | index1 | index2 | index3
+    indexA   value1   value4   value7
+    indexB   value2   value5   value8
+    indexC   value3   value6   value8
+
+    Dataframe:
+
+    clumn1, colmn2, colmn3, colmn4
+    index1, indexA, valueA, value1
+    index1, indexB, valueB, value2
+    index1, indexC, valueC, value3
+    index2, indexA, valueD, value4
+    index2, indexB, valueE, value5
+    index2, indexC, valueF, value6
+    index3, indexA, valueG, value7
+    index3, indexB, valueH, value8
+    index3, indexC, valueI, value9
+
+
+    Attributes
+    ----------
+    workbook : str
+        The name of the workbook.
+    sheet : str
+        The name of the sheet.
+    df : pd.DataFrame
+        The DataFrame containing the data.
+    cells_to_update : typing.List[SpreadsheetCell]
+        List of cells to update.
+    rows : typing.List[SpreadsheetCell]
+        List of row header cells.
+    columns : typing.List[SpreadsheetCell]
+        List of column header cells.
+
+    Methods
+    -------
+    extract() -> typing.Tuple[typing.List[SpreadsheetCell], typing.List[SpreadsheetCell]]
+        Extracts the target cells and initializes row and column headers.
+    transform(df) -> typing.Iterable[SpreadsheetCell]
+        Transforms the DataFrame into a list of SpreadsheetCell objects to update.
+    load()
+        Loads the updated values into the Excel sheet.
+    """
+    workbook: str
+    sheet: str
+    target_cells: str
+    df: pd.DataFrame
+    cells_to_update: typing.List[SpreadsheetCell]
+    rows: typing.List[SpreadsheetCell]
+    columns: typing.List[SpreadsheetCell]
+
+    def __init__(self,
+                 excel_filename=None,
+                 workbook='Kalibreringsark.xlsx',
+                 sheet='Ut',
+                 target_cells=None):
+        """
+        Initializes the HeatingSystemsDistributionWriter with empty lists for cells to update, rows, and columns.
+
+        Parameters
+        ----------
+        excel_filename : str, optional
+            Name of the target spreadsheet. If there is no ! and sheet name in excel_filename, the parameter sheet is
+                used instead
+        workbook : str, optinal
+            Optional name of the spreadsheet to used for reading and writing. (default is 'Kalibreringsark.xlsx')
+        sheet : str, optional
+            Optional name of the sheet used for reading and writing. (default is 'Ut')
+        target_cells : str, optional
+            A range of cells that contain the data to update from the dataframe
+
+
+        """
+
+        self.workbook, self.sheet = os.environ.get('EBM_CALIBRATION_OUT', f'{workbook}!{sheet}').split('!')
+
+        self.workbook = workbook
+        self.sheet = sheet
+        self.target_cells = target_cells
+        if not target_cells:
+            self.target_cells = target_cells = os.environ.get('EBM_CALIBRATION_ENERGY_HEATING_SYSTEMS_DISTRIBUTION')
+
+        if excel_filename:
+            if '!' in excel_filename:
+                self.workbook, self.sheet = excel_filename.split('!')
+            else:
+                self.workbook = excel_filename
+        self.cells_to_update = []
+        self.rows = []
+        self.columns = []
+
+    def extract(self) -> typing.Tuple[
+            typing.Dict[int, SpreadsheetCell],
+            typing.Dict[int, SpreadsheetCell],
+            typing.Iterable[SpreadsheetCell]]:
+        """
+        Extracts the target cells and initializes row and column headers.
+
+        Returns
+        -------
+        typing.Tuple[
+            typing.Dict[int, SpreadsheetCell],
+            typing.Dict[int, SpreadsheetCell],
+            typing.Iterable[SpreadsheetCell]]
+
+            A tuple containing lists of row, column header cells and cells to update.
+        """
+        # Create an instance of the Excel application
+        sheet = access_excel_sheet(self.workbook, self.sheet)
+
+        # Make index of columns and rows
+        first_row = SpreadsheetCell.first_row(self.target_cells)
+        self.columns = {cell.column: cell.replace(value=sheet.Cells(cell.row, cell.column).Value) for cell in first_row[1:]}
+
+        first_column = SpreadsheetCell.first_column(self.target_cells)
+        self.rows = {cell.row: cell.replace(value=sheet.Cells(cell.row, cell.column).Value) for cell in first_column[1:]}
+
+        # Initialize value cells
+        self.values = SpreadsheetCell.submatrix(self.target_cells)
+
+        return self.rows, self.columns, self.values
+
+    def transform(self, df: pd.DataFrame) -> typing.Iterable[SpreadsheetCell]:
+        """
+       Transforms the DataFrame into a list of SpreadsheetCell objects to update.
+
+       Parameters
+       ----------
+       df : pd.DataFrame
+           The DataFrame containing the data.
+
+       Returns
+       -------
+       typing.Iterable[SpreadsheetCell]
+           An iterable of SpreadsheetCell objects to update.
+        """
+        self.cells_to_update = []
+        for cell in self.values:
+            try:
+                row_header = self.columns[cell.column].value
+                column_header = self.rows[cell.row].value
+                if row_header not in df.index:
+                    raise KeyError(f'"{row_header}" not found')
+                elif (row_header, column_header) not in df.index:
+                    raise KeyError(f'"{column_header}" for "{row_header}" not found')
+                column_name = 'heating_system_share' if 'heating_system_share' in df.columns else df.columns[-1]
+                value = df.loc[(row_header, column_header), column_name]
+            except KeyError as ex:
+                logger.warning(f'KeyError {str(ex)} while loading data for cell {cell.spreadsheet_cell()}')
+                value = f'KeyError {str(ex)}'
+            self.cells_to_update.append(SpreadsheetCell(row=cell.row, column=cell.column, value=value))
+
+        return self.cells_to_update
+
+    def load(self):
+        """
+        Loads the updated values into the Excel sheet defined in obj.workbook and obj.sheet.
+        """
+        sheet = access_excel_sheet(self.workbook, self.sheet)
+
+        # Update cells
+        for cell_to_update in self.cells_to_update:
+            cell = sheet.Cells(cell_to_update.row, cell_to_update.column)
+            if isinstance(cell_to_update.value, str) and cell_to_update.value.startswith('KeyError'):
+                cell.Value = 0
+                cell.Font.Color = KEY_ERROR_COLOR
+            else:
+                sheet.Cells(cell_to_update.row, cell_to_update.column).Value = cell_to_update.value
+                cell.Font.ColorIndex = COLOR_AUTO

ebm/services/console.py

@@ -0,0 +1,106 @@
+"""
+Convert a pandas.DataFrame object into a rich.Table object for stylized printing in Python.
+From: https://gist.github.com/avi-perl/83e77d069d97edbdde188a4f41a015c4
+
+Also available as pypi package rich-tools
+"""
+import contextlib
+from datetime import datetime
+from typing import Optional
+
+import pandas as pd
+from rich import box
+from rich.console import Console
+from rich.errors import NotRenderableError
+from rich.table import Table
+
+from ebm.services.spreadsheet import iter_cells
+
+console = Console()
+
+
+def rich_display_dataframe(df, title="Dataframe") -> None:
+    """Display dataframe as table using rich library.
+    Args:
+        df (pd.DataFrame): dataframe to display
+        title (str, optional): title of the table. Defaults to "Dataframe".
+    Raises:
+        NotRenderableError: if dataframe cannot be rendered
+    Returns:
+        rich.table.Table: rich table
+    """
+    from rich import print
+    from rich.table import Table
+
+    # ensure dataframe contains only string values
+    df = df.astype(str)
+
+    table = Table(title=title)
+    table.add_column('year')
+    for col in df.columns:
+        table.add_column(col)
+    for row, (year, cell,) in zip(df.values, enumerate(iter_cells(first_column='E', left_padding=' '), 2010), ):
+        with contextlib.suppress(NotRenderableError):
+            the_row = [f'{year}{cell}', *row]
+            table.add_row(*the_row)
+    print(table)
+
+
+def df_to_table(
+    pandas_dataframe: pd.DataFrame,
+    rich_table: Table,
+    show_index: bool = True,
+    index_name: Optional[str] = None,
+) -> Table:
+    """Convert a pandas.DataFrame obj into a rich.Table obj.
+    Args:
+        pandas_dataframe (DataFrame): A Pandas DataFrame to be converted to a rich Table.
+        rich_table (Table): A rich Table that should be populated by the DataFrame values.
+        show_index (bool): Add a column with a row count to the table. Defaults to True.
+        index_name (str, optional): The column name to give to the index column. Defaults to None, showing no value.
+    Returns:
+        Table: The rich Table instance passed, populated with the DataFrame values."""
+
+    if show_index:
+        index_name = str(index_name) if index_name else ""
+        rich_table.add_column(index_name)
+
+    for column in pandas_dataframe.columns:
+        rich_table.add_column(str(column))
+
+    for index, value_list in enumerate(pandas_dataframe.values.tolist()):
+        row = [str(index)] if show_index else []
+        row += [str(x) for x in value_list]
+        rich_table.add_row(*row)
+
+    return rich_table
+
+
+if __name__ == "__main__":
+    sample_data = {
+        "Date": [
+            datetime(year=2019, month=12, day=20),
+            datetime(year=2018, month=5, day=25),
+            datetime(year=2017, month=12, day=15),
+        ],
+        "Title": [
+            "Star Wars: The Rise of Skywalker",
+            "[red]Solo[/red]: A Star Wars Story",
+            "Star Wars Ep. VIII: The Last Jedi",
+        ],
+        "Production Budget": ["$275,000,000", "$275,000,000", "$262,000,000"],
+        "Box Office": ["$375,126,118", "$393,151,347", "$1,332,539,889"],
+    }
+    df = pd.DataFrame(sample_data)
+
+    # Initiate a Table instance to be modified
+    table = Table(show_header=True, header_style="bold magenta")
+
+    # Modify the table instance to have the data from the DataFrame
+    table = df_to_table(df, table)
+
+    # Update the style of the table
+    table.row_styles = ["none", "dim"]
+    table.box = box.SIMPLE_HEAD
+
+    console.print(table)

ebm/services/excel_loader.py

@@ -0,0 +1,66 @@
+import logging
+
+import win32com.client
+from loguru import logger
+from win32com.universal import com_error
+
+
+def access_excel_sheet(workbook_name: str, sheet_name: str) -> win32com.client.CDispatch:
+    """
+   Opens the specified sheet in the specified workbook using COM.
+
+   Parameters
+   ----------
+   workbook_name : str
+       The name of the workbook.
+   sheet_name : str
+       The name of the sheet.
+
+   Returns
+   -------
+   win32com.client.CDispatch
+       The specified sheet object.
+    """
+    logging.debug(f'Opening sheet {sheet_name} in {workbook_name}')
+    workbooks = []
+    try:
+        excel = win32com.client.Dispatch("Excel.Application")
+        # Get the currently open workbooks
+        workbooks = excel.Workbooks
+    except AttributeError as attr_err:
+        logger.exception(attr_err)
+        msg = f'Got an AttributeError while opening  {workbook_name} !{sheet_name}. Is the spreadsheet busy?'
+        raise IOError(msg)
+        # raise attr_err
+
+    for workbook in workbooks:
+        logger.debug(f"Found open Workbook: {workbook.Name}")
+    logger.debug(f'Using {workbook_name} {sheet_name}')
+    # Access a specific workbook by name
+    try:
+        if workbook_name not in [n.Name for n in workbooks]:
+            ex_msg = f'No open workbook named: \'{workbook_name}\''
+            raise IOError(ex_msg)
+        workbook = workbooks[workbook_name]
+    except com_error as ex:
+        logger.error(f'Error opening {workbook_name}')
+        if not workbooks:
+            logger.error('No open workbooks')
+        else:
+            logger.info('Open workbooks: ')
+            for wb in workbooks:
+                logger.info(f'Found workbook {wb.Name}')
+        raise ex
+    # Now you can interact with the workbook, for example, read a cell value
+    sheet = []
+    try:
+        if sheet_name not in [n.Name for n in workbook.Sheets]:
+            ex_msg = f'{workbook_name} exists and is open, but there is no sheet named: \'{sheet_name}\''
+            raise IOError(ex_msg)
+        sheet = workbook.Sheets(sheet_name)
+    except com_error as ex:
+        logger.error(f'Error opening {sheet_name}')
+        for s in workbook.Sheets:
+            logger.error(f'Found sheet {s.Name}')
+        raise ex
+    return sheet

ebm/services/files.py

@@ -0,0 +1,38 @@
+import os
+import pathlib
+
+from loguru import logger
+
+def make_unique_path(path: pathlib.Path):
+    path = pathlib.Path(path)
+    counter = 1
+    new_path = path
+
+    while new_path.exists():
+        new_path = path.with_stem(f"{path.stem}_{counter}")
+        counter += 1
+
+    return new_path
+
+
+def file_is_writable(output_file: pathlib.Path) -> bool:
+    if not output_file.is_file():
+        # If the parent directory is writable we should be good to go
+        return os.access(output_file.parent, os.W_OK)
+
+    access = os.access(output_file, os.W_OK)
+    if not access:
+        logger.error(f'Permission denied: {output_file}. The file is not writable.')
+        return False
+
+    # It is not enough to check that the file is writable in Windows. We must also check that it is possible to open
+    # the file
+    try:
+        with output_file.open('a'):
+            pass
+    except PermissionError as ex:
+        # Unable to open a file that is reported as writable by the operating system. In that case it is a good chance
+        # that the file is already open. Error log our assumption and return False
+        logger.error(str(ex) + '. Is the file already open?')
+        return False
+    return True