Utils excel

def __getattr__(self, attr):
    return getattr(self._innerWrapper, attr) if attr != "_innerWrapper" else getattr(self, attr)

def __getitem__(self, idx: Union[int, str]):
    return self._innerWrapper.__getitem__(idx)  # type: ignore

def __setattr__(self, attr, value):
    setattr(self._innerWrapper, attr, value) if attr != "_innerWrapper" else super().__setattr__(attr, value)

def __getattr__(self, attr) -> Any:

    # getattr for "pythonized" caller names
    # a) wrapper class methods
    # b) wrapped object methods and wrapped object methods for get
    # NOTE: directly available attributes/methods in wrapper class are caught via __getattribute__
    attr_lower = attr.lower()
    attr_desnaked = attr_lower.replace("_", "")
    if attr_lower in self.__class__._cls_attrmap:
        retval = getattr(self, self.__class__._cls_attrmap[attr_lower])
    elif attr_desnaked in self.__class__._cls_attrmap:
        retval = getattr(self, self.__class__._cls_attrmap[attr_desnaked])
    elif attr.lower() in self.__class__._cls_attrmap_wrapped_get:
        retval = getattr(self._xlWrapped, self.__class__._cls_attrmap_wrapped_get[attr_lower])
    elif attr_desnaked in self.__class__._cls_attrmap_wrapped_get:
        retval = getattr(self._xlWrapped, self.__class__._cls_attrmap_wrapped_get[attr_desnaked])
    elif attr.lower() in self.__class__._cls_attrmap_wrapped_method:
        retval = functools.partial(UtilsOffice.callwrapper_COMmethod, self._xlWrapped, self.__class__._cls_attrmap_wrapped_method[attr_lower], self._wrap_retval)
    elif attr_desnaked in self.__class__._cls_attrmap_wrapped_method:
        retval = functools.partial(UtilsOffice.callwrapper_COMmethod, self._xlWrapped, self.__class__._cls_attrmap_wrapped_method[attr_desnaked], self._wrap_retval)
    elif hasattr(self._xlWrapped, attr):
        if attr not in self.__class__._cls_attrmap_wrapped_method.values():
            retval = getattr(self._xlWrapped, attr)
        else:
            retval = functools.partial(UtilsOffice.callwrapper_COMmethod, self._xlWrapped, attr, self._wrap_retval)
    else:
        err_msg = f"'{self!r}' object has no attribute '{attr}'"
        raise AttributeError(err_msg)

    return self._wrap_retval(retval)

def __setattr__(self, attr, value) -> Any:

    # setattr for "pythonized" caller names - private wrapper attributes and
    # wrapped object methods for set
    # old assumption: wrapper class has no attributes to be set externally / properties
    # but re-activated
    attr_lower = attr.lower()
    attr_desnaked = attr_lower.replace("_", "")
    if attr.lower() in self.__class__._cls_attrmap:
        super().__setattr__(self.__class__._cls_attrmap[attr_lower], value)
    elif attr_desnaked in self.__class__._cls_attrmap:
        super().__setattr__(self.__class__._cls_attrmap[attr_desnaked], value)
    if attr == "_xlWrapped" or attr[0:1] == "_":
        super().__setattr__(attr, value)
    elif attr_lower in self.__class__._cls_attrmap_wrapped_put:
        setattr(self._xlWrapped, self.__class__._cls_attrmap_wrapped_put[attr_lower], value)
    elif attr_desnaked in self.__class__._cls_attrmap_wrapped_put:
        setattr(self._xlWrapped, self.__class__._cls_attrmap_wrapped_put[attr_desnaked], value)
    # setattr must consider own class but not call hasattr / __getattr__ (avoid recursion)
    elif attr in self.__class__._cls_attrmap_wrapped_put.values():  # equivalent to hasattr(self._xlWrapped, attr)
        # __setattr__ must not call hasattr / __getattr__ (avoid recursion)
        setattr(self._xlWrapped, attr, value)
    else:
        err_msg = f"'{self!r}' object has no attribute '{attr}'"
        raise AttributeError(err_msg)

def Dims(self) -> tuple:
    """
    Dims - return dimensions of range object
    """
    return self._xlWrapped.Rows.Count, self._xlWrapped.Columns.Count

def Range(self, *range: list[Union[str, tuple[int, int], tuple[tuple[int, int], tuple[int, int]]]]) -> xlRangeWrapper:  # docsig disable=SIG203
    """
    Range - create Range object for provided identifier

    Args:
        *range (list[Union[str, tuple[int, int], tuple[tuple[int, int], tuple[int, int]]]]): range identifier

    Returns:
        xlRangeWrapper: wrapped range object
    """

    if isinstance(range[0], str) and len(range) == 1:
        return xlRangeWrapper(self._xlWrapped.Range(range[0]))
    elif isinstance(range[0], int):
        if len(range) == 2:  # noqa: PLR2004
            if isinstance(range[1], int):
                return xlRangeWrapper(self._xlWrapped.Cells(range[0], range[1]))
    elif isinstance(range[0], tuple):
        if len(range) == 2:  # noqa: PLR2004
            return xlRangeWrapper(
                self._xlWrapped.Range(
                    self._xlWrapped.Cells(range[0][0], range[0][1]),
                    self._xlWrapped.Cells(range[1][0], range[1][1])
                )
            )
    raise RuntimeError

def Range2PandasDF(self) -> pandas.DataFrame:
    """
    Range2PandasDF - copy range to dataframe (without header)

    Returns:
        pandas.DataFrame: data frame with range values
    """
    return pandas.DataFrame(list(self._xlWrapped.Value))

def Range2PandasDFheader(self) -> pandas.DataFrame:
    """
    Range2PandasDFheader - copy range to dataframe using first row as header line

    Returns:
        pandas.DataFrame: data frame with range values
    """
    return pandas.DataFrame(self._xlWrapped.Value.Value[1:], columns=self._xlWrapped.Value.Rows(1).Value[0])

def Sort(self, *args: Any, **kwargs: Any):
    """
    sort - wrapper object method calling sort method for range
    """
    sortRange(self._xlWrapped, *args, **kwargs)

def Values2Range(self, values, autoadjust: bool = False, header: bool = True) -> None:
    """
    values2range - wrapper object method calling function to copy values to Excel range object

    Args:
        values (_type_): source values to be copied to target range
        autoadjust (bool, optional): Flag to control adjustment of target range according to source data. Defaults to False.
        header (bool, optional): Flag if header form source dataframe should be transferred. Defaults to True.
    """
    values2range(self._xlWrapped, values, autoadjust, header)

@multimethod.multimethod  # type: ignore
def __call__(self, corner1: tuple[int, int], corner2: tuple[int, int]):  # noqa: F811
    return xlRangeWrapper(
        self._xlWrapped.Range(
            self._xlWrapped.Cells(corner1[0], corner1[1]),
            self._xlWrapped.Cells(corner2[0], corner2[1])
        )
    )

def __eq__(self, other: object) -> bool:
    """
    __eq__ - check if two range objects are the same via Excel object attributes
    """
    if not isinstance(other, xlRangeWrapper):  # type: ignore[misc]
        return NotImplemented
    return \
        (self._xlwrapped.Parent.Parent.FullName == other._xlwrapped.Parent.Parent.FullName) and \
        (self._xlwrapped.Parent.FullName == other._xlwrapped.Parent.Name) and \
        ((self._xlwrapped.Name == other._xlwrapped.Name) or (self._xlwrapped.Address == other._xlwrapped.Address))

def __getitem__(self, *args):

    if len(args) == 0:
        return self
    elif isinstance(args[0], str) and len(range) == 1:
        return xlRangeWrapper(self._xlWrapped.Range(args[0]))
    elif isinstance(args[0], tuple):
        if len(args) == 1 and len(args[0]) == 2:  # noqa: PLR2004
            if isinstance(args[0][0], int) and isinstance(args[0][1], int):
                return xlRangeWrapper(self._xlWrapped.Cells(args[0][0], args[0][1]))
    raise RuntimeError

def __hash__(self):
    return hash(self._xlwrapped.Parent.Parent.FullName + self._xlwrapped.Parent.FullName + self._xlwrapped.Name + self._xlwrapped.Address)

def setDate(self, datevalue: datetime.datetime) -> None:
    """
    setDate - wrapper object method calling function to set date overcoming timezone==None issue
    """
    setDate(self._xlWrapped, datevalue)

def __eq__(self, other: object) -> bool:
    """
    __eq__ - check if two workbook objects are the same via Excel object attributes
    """
    if not isinstance(other, xlWorkbookWrapper):  # type: ignore
        return NotImplemented
    return self._xlwrapped.FullName == other._xlwrapped.FullName

def __getitem__(self, idx: Union[int, str]):
    return xlWorksheetWrapper(self._xlWrapped.Worksheets(idx))

def __hash__(self):
    return hash(self._xlwrapped.FullName)

def containsWorksheet(self, wsname: str) -> bool:
    """
    containsWorksheet - wrapper object method calling function to check if worksheet 'wsname' exists

    Args:
        wsname (str): name of worksheet

    Returns:
        bool: flag if worksheet 'wsname' exist in workbook
    """
    return self.sheet_exists(wsname)

def deleteWorksheet(self, wsname: str) -> None:
    """
    deleteWorksheet - wrapper object method calling function to delete worksheet 'wsname' from workbook

    Args:
        wsname (str): name of worksheet
    """
    deleteWorksheet(self._xlWrapped, wsname)

def minimizeWindows(self) -> None:
    """
    minimizeWindows - wrapper object method calling function to minimize windows of workbook
    """
    minimizeWindows(self._xlWrapped)

def sheet_exists(self, wsname: str) -> bool:
    """
    sheet_exists - wrapper object method calling function to check if worksheet 'wsname' exists

    Args:
        wsname (str): name of worksheet

    Returns:
        bool: flag if worksheet 'wsname' exist in workbook
    """
    return sheet_exists(self._xlWrapped, wsname)

def __call__(self, idx: Union[int, str]):

    if isinstance(idx, (int, str)):
        return xlWorkbookWrapper(self._xlWrapped.Item(idx))
    else:
        return self._xlWrapped

def __getitem__(self, idx: Union[int, str]):

    if isinstance(idx, (int, str)):
        return xlWorkbookWrapper(self._xlWrapped.Item(idx))
    else:
        return self._xlWrapped

def __iter__(self):
    return self._xlWorkbooksIterator(self._xlWrapped)

def isWorkbookOpen(self, wbname: str) -> bool:
    """
    isWorkbookOpen - wrapper object method calling function to check if workbook is open

    Args:
        wbname (str): workbook name

    Returns:
        bool: boolean value indicating if workbook with name 'wbname' is open
    """
    return xlAppWrapper(self._xlWrapped.Parent).isWorkbookOpen(wbname)

def isWorkbookOpenFullname(self, wbname: str) -> bool:
    """
    isWorkbookOpenFullname - wrapper object method calling function to check if workbook is open

    Args:
        wbname (str): workbook name

    Returns:
        bool: boolean value indicating if workbook with fullname 'wbname' is open
    """
    return xlAppWrapper(self._xlWrapped.Parent).isWorkbookOpenFullname(wbname)

def openText(self, filename: str, *args: Any, **kwargs: Any) -> Union[xlWorkbookWrapper, None]:  # docsig: disable=SIG203
    """
    openText - wrapper object method calling function to open workbook

    Args:
        filename (str): filename of textfile

    Returns:
        bool: boolean value indicating if 'filename' was opened as textfile
    """
    return xlAppWrapper(self._xlWrapped.Parent).openText(filename, *args, **kwargs)

def openWorkbook(self, filename: str, *args: Any, **kwargs: Any) -> Union[xlWorkbookWrapper, None]:  # docsig: disable=SIG203
    """
    openWorkbook - wrapper object method calling function to open workbook

    Args:
        filename (str): filename of workbook

    Returns:
        bool: boolean value indicating if 'filename' was opened as workbook
    """
    return xlAppWrapper(self._xlWrapped.Parent).openWorkbook(filename, *args, **kwargs)

def Columns(self, column: int) -> xlRangeWrapper:
    """
    Columns - create range object for worksheet column

    Args:
        column (int): column number

    Returns:
        xlRangeWrapper: wrapped range object
    """
    return xlRangeWrapper(self._xlWrapped.Columns(column))

def Range(self, *range: list[Union[str, tuple[int, int], tuple[tuple[int, int], tuple[int, int]]]]) -> xlRangeWrapper:  # docsig: disable=SIG203
    """
    Range - create Range object for provided identifier

    Args:
        *range (list[Union[str, tuple[int, int], tuple[tuple[int, int], tuple[int, int]]]]): range identifier

    Returns:
        xlRangeWrapper: wrapped range object
    """

    if isinstance(range[0], str) and len(range) == 1:
        return xlRangeWrapper(self._xlWrapped.Range(range[0]))
    elif isinstance(range[0], int):
        if len(range) == 2:  # noqa: PLR2004
            if isinstance(range[1], int):
                return xlRangeWrapper(self._xlWrapped.Cells(range[0], range[1]))
    elif isinstance(range[0], tuple):
        if len(range) == 2:  # noqa: PLR2004
            return xlRangeWrapper(
                self._xlWrapped.Range(
                    self._xlWrapped.Cells(range[0][0], range[0][1]),
                    self._xlWrapped.Cells(range[1][0], range[1][1])
                )
            )
    raise RuntimeError

def Rows(self, row: int) -> xlRangeWrapper:
    """
    Rows - create range object for worksheet row

    Args:
        row (int): row number

    Returns:
        xlRangeWrapper: wrapped range object
    """
    return xlRangeWrapper(self._xlWrapped.Rows(row))

def __eq__(self, other: object) -> bool:
    """
    __eq__ - check if two worksheet objects are the same via Excel object attributes
    """
    if not isinstance(other, xlWorksheetWrapper):
        return NotImplemented
    return \
        (self._xlwrapped.Parent.FullName == other._xlwrapped.Parent.FullName) and \
        (self._xlwrapped.Name == other._xlwrapped.Name)

def __getitem__(self, *args):
    """
    __getitem__ - read cell directly via address in Excel A1 or R1C1 notation
    """
    if len(args) == 0:
        return self
    else:
        if isinstance(*args, tuple):
            return self.Range(args[0][0], args[0][1])
        else:
            return self.Range(*args)

def __setitem__(self, *args):
    """
    __setitem__ - write cell directly via address in Excel A1 or R1C1 notation
    """
    if len(args) == 2:  # noqa: PLR2004
        if isinstance(args[0], str):
            tmp_range = self._xlWrapped.Range(args[0])
            tmp_range.Value = args[1]
        elif isinstance(args[0], tuple):
            tmp_range = self._xlWrapped.Cells(args[0][0], args[0][1])
            tmp_range.Value = args[1]
    else:
        raise RuntimeError

def exportWorksheet(self, filename: str = "", format: str = ".csv") -> None:
    """
    exportWorksheet - wrapper object method calling function to export worksheet

    Args:
        filename (str, optional): file name for worksheet export. Defaults to "".
        format (str, optional): file format for worksheet export. Defaults to ".csv".
    """
    exportWorksheet(self._xlWrapped, filename)

def lastfilledRow(self, check_cols: Optional[list[int]] = None, rowstart: int = 1) -> int:
    """
    lastfilledRow - wrapper object method calling function to determine last filled row

    Args:
        check_cols (Optional[list[int]], optional): cols to be checked. Defaults to None.
        rowstart (int, optional): optional start row. Defaults to 1.

    Returns:
        int: last filled row with 'check_cols' not empty
    """
    if check_cols is None:
        check_cols = [1]
    return lastfilledRow(self._xlWrapped, check_cols, rowstart)