advanced-excel 2.0.0__tar.gz

advanced_excel-2.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Antonio Castellon
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

advanced_excel-2.0.0/PKG-INFO

@@ -0,0 +1,201 @@
+Metadata-Version: 2.4
+Name: advanced-excel
+Version: 2.0.0
+Summary: Advanced Excel data processing and manipulation library for Python
+Author-email: Antonio Castellon <antonio@castellon.ch>
+Maintainer-email: Antonio Castellon <antonio@castellon.ch>
+License: MIT
+Project-URL: Homepage, https://github.com/antonio-castellon/AdvancedExcel
+Project-URL: Repository, https://github.com/antonio-castellon/AdvancedExcel
+Project-URL: Issues, https://github.com/antonio-castellon/AdvancedExcel/issues
+Keywords: excel,pandas,data-processing,xlsx,data-cleaning,openpyxl
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Office/Business :: Financial :: Spreadsheet
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pandas>=2.1.0
+Requires-Dist: openpyxl>=3.1.2
+Requires-Dist: numpy>=1.25.2
+Requires-Dist: pyxlsb>=1.0.10
+Requires-Dist: xlrd>=2.0.1
+Provides-Extra: sspipe
+Requires-Dist: sspipe>=0.1.17; extra == "sspipe"
+Provides-Extra: legacy
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Requires-Dist: pandas-stubs; extra == "dev"
+Dynamic: license-file
+
+## AdvancedExcel: Simplifying Excel Data Processing in Python
+
+**v2.0+ note:** The public API now uses PEP 8 `snake_case` method names (e.g. `get_sheet`, `remove_empty_rows`, `get_dataframe_blocks_by_key_name`). This is a breaking change from v1.x.
+
+The `AdvancedExcel` class provides a powerful and convenient way to interact with Excel files in Python. It streamlines common Excel data processing tasks, from reading and extracting data to cleaning, transforming, and manipulating it using pandas DataFrames. This class aims to reduce the boilerplate code often associated with Excel handling, making your data analysis workflows more efficient and readable.
+
+**Key Strengths:**
+
+* **Effortless Data Extraction:**  Easily read data from Excel sheets, including handling complexities like merged cells, multiple tables within a sheet, and various data types.  Target specific tables using row and column indices or header values.
+* **Comprehensive DataFrame Manipulation:**  A rich set of methods for cleaning, transforming, and manipulating pandas DataFrames.  Perform operations like removing rows/columns based on criteria, filling missing values using various strategies (forward fill, left fill), merging and splitting columns, changing data types, and more.
+* **Flexible Header and Index Management:**  Gain fine-grained control over headers and indices.  Set rows as headers, add headers as rows, reset indices, and drop unnecessary index levels.
+* **Streamlined String and Value Processing:**  Simplify string manipulation with methods for stripping whitespace, replacing values (including using regular expressions), and changing the case of strings (uppercase, lowercase, title case).
+* **Convenient Utility Functions:**  Includes helper functions for common tasks such as transposing DataFrames, merging multiple DataFrames, extracting filenames from paths, and getting sheet names without fully opening the Excel file.
+* **Seamless Integration with `sspipe`:** Designed for smooth integration with the `sspipe` library (https://github.com/sspipe/sspipe). Chain method calls in a readable and functional style, creating elegant and concise data pipelines.
+
+**Why use `AdvancedExcel`?**
+
+Working with Excel files in Python often involves repetitive and verbose code. `AdvancedExcel` encapsulates these common tasks into reusable methods, promoting code reusability, readability, and maintainability.  It handles many of the edge cases and complexities of Excel data, allowing you to focus on the core logic of your data analysis.  The integration with `sspipe` further enhances code clarity by enabling a functional programming paradigm.
+
+# Getting Started
+
+Create a Virtual Environment.
+
+`py -m venv venv`
+
+Activate the virtual environment
+
+`venv\Scripts\activate.bat` (in Linux `source ./venv/bin/activate` )
+
+Update PIP
+
+`py -m pip install -U pip`
+
+
+## Installation
+
+```bash
+pip install advanced-excel
+```
+
+For the functional piping examples using `sspipe`:
+
+```bash
+pip install "advanced-excel[sspipe]"
+```
+
+For development:
+
+```bash
+pip install -e ".[dev,sspipe]"
+```
+
+## Dependencies
+
+Core dependencies (pandas, openpyxl, etc.) are declared in `pyproject.toml`. Optional extras are available for `sspipe` support and development.
+
+## Usage
+
+### Basic usage 
+
+```python
+from advanced_excel import AdvancedExcel
+
+data = AdvancedExcel("simple_excel.xlsx")
+sheet = data.get_sheet("Data")
+result = data.get_next_value(sheet, "Study Number")
+print(result)
+```
+
+> Note: The recommended import is `from advanced_excel import AdvancedExcel` (this is the stable API as of v2.0).
+
+### Example using sspipe for complex chaining (requires `pip install "advanced-excel[sspipe]"`):
+
+```python
+from sspipe import p
+import pandas as pd
+from advanced_excel import AdvancedExcel
+
+excel_processor = AdvancedExcel("complex_excel.xlsx")
+
+raw = excel_processor.get_sheet("Raw data")
+sheet1 = excel_processor.get_sheet("Sheet1")
+sheet2 = excel_processor.get_sheet("Sheet2")
+
+final_df_chained = (
+    raw
+    | p(excel_processor.remove_empty_rows)
+    | p(excel_processor.set_column_to_numeric, columnName="Quantity")
+    | p(pd.merge,
+        sheet1
+        | p(excel_processor.remove_empty_rows)
+        | p(excel_processor.rename_headers, {"OldName": "CategoryName"}),
+        on="ProductID", how="left")
+    | p(pd.merge,
+        sheet2
+        | p(excel_processor.remove_empty_rows)
+        | p(excel_processor.strip_all)
+        | p(excel_processor.remove_duplicates),
+        left_index=True, right_index=True)
+)
+```
+### Another example of usage on a complex Excel (multiple tables per sheet):
+
+```python
+from advanced_excel import AdvancedExcel
+from sspipe import p   # optional, for nice chaining
+
+data = AdvancedExcel("studies_excel.xlsx")
+results = data.get_sheet("Raw data") | p(data.get_dataframe_blocks_by_key_name, "Batch Number")
+
+all_tables = []
+for dblock in results:
+    study_num = data.get_next_value(dblock, "Study No")
+    plan_num = data.get_next_value(dblock, "Plan No")
+
+    table = (
+        dblock
+        | p(data.get_dataframe_blocks_by_key_name, "Batch Number")
+        | (lambda blocks: blocks[0] if blocks else pd.DataFrame())
+        | p(data.replace_nan_strings)
+        | p(data.remove_empty_rows)
+        | p(data.merge_rows, 0, 2)
+        | p(data.set_row_as_header, 0)
+        | p(data.remove_rows_if_unique_value_on_bottom, 2)
+        | p(data.merge_columns, 1, 2, '_', 'SAMPLE_REPLICATE')
+        | p(data.remove_column_by_name, "Sample #_Replicat #")
+    )
+    all_tables.append(table)
+```
+
+```python
+from advanced_excel import AdvancedExcel
+from sspipe import p
+import pandas as pd
+
+data = AdvancedExcel("studies_excel.xlsx")
+
+columns_to_rename = {"PLATEFORM": "PLATFORM"}
+columns_not_to_clean = ["PARAMETER"]
+
+results = (
+    data.get_sheet("data_raw")
+    | p(data.case_headers)
+    | p(data.rename_headers, columns_to_rename)
+    | p(data.strip_all)
+    | p(data.remove_column_by_name, r"^T\d+$")
+    | p(data.remove_column_by_name, r"^T\d+\.\d+$")
+    | p(data.remove_all_crlf, ";")
+    | p(data.replace_nan_strings)
+    | p(data.replace_spaces_by_separator, ";", [], columns_not_to_clean)
+    | p(data.replace_all, ",;", ";", [], columns_not_to_clean)
+    | p(data.replace_all, "tbd", "TBD", [], [])
+    # | p(data.replace_by_dictionary, unit_map, "UNIT")
+    | p(data.case_column_values, "PARAMETER", title=True)
+    # | p(data.replace_by_dictionary, variable_map, "PARAMETER")
+)
+```

advanced_excel-2.0.0/README.md

@@ -0,0 +1,157 @@
+## AdvancedExcel: Simplifying Excel Data Processing in Python
+
+**v2.0+ note:** The public API now uses PEP 8 `snake_case` method names (e.g. `get_sheet`, `remove_empty_rows`, `get_dataframe_blocks_by_key_name`). This is a breaking change from v1.x.
+
+The `AdvancedExcel` class provides a powerful and convenient way to interact with Excel files in Python. It streamlines common Excel data processing tasks, from reading and extracting data to cleaning, transforming, and manipulating it using pandas DataFrames. This class aims to reduce the boilerplate code often associated with Excel handling, making your data analysis workflows more efficient and readable.
+
+**Key Strengths:**
+
+* **Effortless Data Extraction:**  Easily read data from Excel sheets, including handling complexities like merged cells, multiple tables within a sheet, and various data types.  Target specific tables using row and column indices or header values.
+* **Comprehensive DataFrame Manipulation:**  A rich set of methods for cleaning, transforming, and manipulating pandas DataFrames.  Perform operations like removing rows/columns based on criteria, filling missing values using various strategies (forward fill, left fill), merging and splitting columns, changing data types, and more.
+* **Flexible Header and Index Management:**  Gain fine-grained control over headers and indices.  Set rows as headers, add headers as rows, reset indices, and drop unnecessary index levels.
+* **Streamlined String and Value Processing:**  Simplify string manipulation with methods for stripping whitespace, replacing values (including using regular expressions), and changing the case of strings (uppercase, lowercase, title case).
+* **Convenient Utility Functions:**  Includes helper functions for common tasks such as transposing DataFrames, merging multiple DataFrames, extracting filenames from paths, and getting sheet names without fully opening the Excel file.
+* **Seamless Integration with `sspipe`:** Designed for smooth integration with the `sspipe` library (https://github.com/sspipe/sspipe). Chain method calls in a readable and functional style, creating elegant and concise data pipelines.
+
+**Why use `AdvancedExcel`?**
+
+Working with Excel files in Python often involves repetitive and verbose code. `AdvancedExcel` encapsulates these common tasks into reusable methods, promoting code reusability, readability, and maintainability.  It handles many of the edge cases and complexities of Excel data, allowing you to focus on the core logic of your data analysis.  The integration with `sspipe` further enhances code clarity by enabling a functional programming paradigm.
+
+# Getting Started
+
+Create a Virtual Environment.
+
+`py -m venv venv`
+
+Activate the virtual environment
+
+`venv\Scripts\activate.bat` (in Linux `source ./venv/bin/activate` )
+
+Update PIP
+
+`py -m pip install -U pip`
+
+
+## Installation
+
+```bash
+pip install advanced-excel
+```
+
+For the functional piping examples using `sspipe`:
+
+```bash
+pip install "advanced-excel[sspipe]"
+```
+
+For development:
+
+```bash
+pip install -e ".[dev,sspipe]"
+```
+
+## Dependencies
+
+Core dependencies (pandas, openpyxl, etc.) are declared in `pyproject.toml`. Optional extras are available for `sspipe` support and development.
+
+## Usage
+
+### Basic usage 
+
+```python
+from advanced_excel import AdvancedExcel
+
+data = AdvancedExcel("simple_excel.xlsx")
+sheet = data.get_sheet("Data")
+result = data.get_next_value(sheet, "Study Number")
+print(result)
+```
+
+> Note: The recommended import is `from advanced_excel import AdvancedExcel` (this is the stable API as of v2.0).
+
+### Example using sspipe for complex chaining (requires `pip install "advanced-excel[sspipe]"`):
+
+```python
+from sspipe import p
+import pandas as pd
+from advanced_excel import AdvancedExcel
+
+excel_processor = AdvancedExcel("complex_excel.xlsx")
+
+raw = excel_processor.get_sheet("Raw data")
+sheet1 = excel_processor.get_sheet("Sheet1")
+sheet2 = excel_processor.get_sheet("Sheet2")
+
+final_df_chained = (
+    raw
+    | p(excel_processor.remove_empty_rows)
+    | p(excel_processor.set_column_to_numeric, columnName="Quantity")
+    | p(pd.merge,
+        sheet1
+        | p(excel_processor.remove_empty_rows)
+        | p(excel_processor.rename_headers, {"OldName": "CategoryName"}),
+        on="ProductID", how="left")
+    | p(pd.merge,
+        sheet2
+        | p(excel_processor.remove_empty_rows)
+        | p(excel_processor.strip_all)
+        | p(excel_processor.remove_duplicates),
+        left_index=True, right_index=True)
+)
+```
+### Another example of usage on a complex Excel (multiple tables per sheet):
+
+```python
+from advanced_excel import AdvancedExcel
+from sspipe import p   # optional, for nice chaining
+
+data = AdvancedExcel("studies_excel.xlsx")
+results = data.get_sheet("Raw data") | p(data.get_dataframe_blocks_by_key_name, "Batch Number")
+
+all_tables = []
+for dblock in results:
+    study_num = data.get_next_value(dblock, "Study No")
+    plan_num = data.get_next_value(dblock, "Plan No")
+
+    table = (
+        dblock
+        | p(data.get_dataframe_blocks_by_key_name, "Batch Number")
+        | (lambda blocks: blocks[0] if blocks else pd.DataFrame())
+        | p(data.replace_nan_strings)
+        | p(data.remove_empty_rows)
+        | p(data.merge_rows, 0, 2)
+        | p(data.set_row_as_header, 0)
+        | p(data.remove_rows_if_unique_value_on_bottom, 2)
+        | p(data.merge_columns, 1, 2, '_', 'SAMPLE_REPLICATE')
+        | p(data.remove_column_by_name, "Sample #_Replicat #")
+    )
+    all_tables.append(table)
+```
+
+```python
+from advanced_excel import AdvancedExcel
+from sspipe import p
+import pandas as pd
+
+data = AdvancedExcel("studies_excel.xlsx")
+
+columns_to_rename = {"PLATEFORM": "PLATFORM"}
+columns_not_to_clean = ["PARAMETER"]
+
+results = (
+    data.get_sheet("data_raw")
+    | p(data.case_headers)
+    | p(data.rename_headers, columns_to_rename)
+    | p(data.strip_all)
+    | p(data.remove_column_by_name, r"^T\d+$")
+    | p(data.remove_column_by_name, r"^T\d+\.\d+$")
+    | p(data.remove_all_crlf, ";")
+    | p(data.replace_nan_strings)
+    | p(data.replace_spaces_by_separator, ";", [], columns_not_to_clean)
+    | p(data.replace_all, ",;", ";", [], columns_not_to_clean)
+    | p(data.replace_all, "tbd", "TBD", [], [])
+    # | p(data.replace_by_dictionary, unit_map, "UNIT")
+    | p(data.case_column_values, "PARAMETER", title=True)
+    # | p(data.replace_by_dictionary, variable_map, "PARAMETER")
+)
+```

advanced_excel-2.0.0/pyproject.toml

@@ -0,0 +1,90 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "advanced-excel"
+version = "2.0.0"
+description = "Advanced Excel data processing and manipulation library for Python"
+readme = "README.md"
+license = {text = "MIT"}
+authors = [
+    {name = "Antonio Castellon", email = "antonio@castellon.ch"}
+]
+maintainers = [
+    {name = "Antonio Castellon", email = "antonio@castellon.ch"}
+]
+keywords = ["excel", "pandas", "data-processing", "xlsx", "data-cleaning", "openpyxl"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Scientific/Engineering :: Information Analysis",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: Office/Business :: Financial :: Spreadsheet",
+]
+requires-python = ">=3.10"
+dependencies = [
+    "pandas>=2.1.0",
+    "openpyxl>=3.1.2",
+    "numpy>=1.25.2",
+    "pyxlsb>=1.0.10",
+    "xlrd>=2.0.1",
+]
+
+[project.optional-dependencies]
+sspipe = ["sspipe>=0.1.17"]
+legacy = []  # xlrd is already in core for .xls support
+dev = [
+    "pytest>=7.0",
+    "pytest-cov",
+    "ruff",
+    "black",
+    "mypy",
+    "pandas-stubs",
+]
+
+[project.urls]
+Homepage = "https://github.com/antonio-castellon/AdvancedExcel"
+Repository = "https://github.com/antonio-castellon/AdvancedExcel"
+Issues = "https://github.com/antonio-castellon/AdvancedExcel/issues"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+include = ["advanced_excel*"]  # Standard lowercase package name for Python/PyPI compatibility
+
+
+[tool.setuptools.package-data]
+"*" = ["py.typed"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = ["test_*.py"]
+addopts = "-q --tb=short"
+
+[tool.ruff]
+line-length = 100
+target-version = "py310"
+select = ["E", "F", "I", "UP", "B", "SIM", "C4"]
+ignore = ["E501", "B008"]  # allow long lines in some cases, no mutable defaults check over-aggressive
+
+[tool.ruff.format]
+quote-style = "double"
+
+[tool.black]
+line-length = 100
+target-version = ["py310"]
+
+[tool.mypy]
+python_version = "3.10"
+warn_return_any = true
+warn_unused_configs = true
+disallow_untyped_defs = false  # start permissive, tighten later
+ignore_missing_imports = true

advanced_excel-2.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

advanced_excel-2.0.0/setup.py

@@ -0,0 +1,10 @@
+"""
+Minimal setup.py for backward compatibility.
+
+Modern packaging is defined in pyproject.toml.
+This file is kept for tools that still look for setup.py.
+"""
+
+import setuptools
+
+setuptools.setup()

advanced_excel-2.0.0/src/advanced_excel/__init__.py

@@ -0,0 +1,19 @@
+"""
+advanced_excel package (standard Python package name).
+
+This makes the library fully importable and compatible after `pip install -e .`
+or `pip install advanced-excel`.
+
+Recommended import:
+    from advanced_excel import AdvancedExcel
+
+The main class is AdvancedExcel (CamelCase is standard for classes).
+Implementation is in core.py (the thin class + mixin imports) and the various
+*Mixin modules.
+"""
+
+from .core import AdvancedExcel
+from .core import ROW_INDEX, COL_INDEX, DATA, __version__
+
+__all__ = ["AdvancedExcel", "ROW_INDEX", "COL_INDEX", "DATA", "__version__"]
+

advanced_excel-2.0.0/src/advanced_excel/blocks.py

@@ -0,0 +1,171 @@
+class BlockTableMixin:
+    """
+    Mixin for detecting and extracting multiple tables / blocks / entities
+    inside a single sheet (repeated key sections, "Batch Number" style blocks, etc.).
+    This is the core of the "advanced" multi-table Excel handling.
+    """
+
+    def get_all_tables(self, _sheet, mincol=3):
+        """
+        Identifies and extracts table-like structures from a sheet.
+
+        This method searches for contiguous blocks of rows that have at least `mincol`
+        non-NaN values. These blocks are interpreted as tables. It iterates through
+        the rows of the sheet.  When it encounters a row with at least `mincol`
+        valid values, it marks the beginning of a potential table. When it finds a row
+        with fewer than `mincol` valid values, it considers the preceding block of
+        rows as a complete table and extracts it using the `_getTable` method.
+
+        Args:
+            _sheet (pandas.DataFrame): The sheet to search for tables within.
+            mincol (int, optional): The minimum number of non-NaN values required
+                for a row to be considered part of a table. Defaults to 3.
+
+        Returns:
+            list: A list of pandas DataFrames, where each DataFrame represents
+                a table-like structure found in the sheet.  Returns an empty
+                list if no tables are found.
+        """
+
+        allTables = []
+        init_table = -1
+
+        for irow in range(_sheet.shape[0]):
+            if len(_sheet.loc[irow].dropna()) >= mincol:
+                if init_table == -1:
+                    init_table = irow
+            else:
+                if init_table >= 0:
+                    table = self._getTable(_sheet, init_table, irow)
+                    allTables.append(table)
+                    init_table = -1
+
+        if init_table >= 0:
+            table = self._getTable(_sheet, init_table, _sheet.shape[0])
+            allTables.append(table)
+
+        return allTables
+
+    def get_dataframe_blocks_by_key_name(self, df, key_name):
+        """used for sheet that contains different blocks of information,
+        it splits the all data sheet into splited dataframes to be parser later on
+        The Split is using the recognition of the first value on a cell that is repeated at the beginning
+        of each block"""
+
+        allDfBlocks = []
+
+        identified_rows = self.get_all_rows_from_key(df, key_name)
+        list_index_of_rows = list(map(lambda x: x["row_index"], identified_rows))
+
+        for index in range(len(list_index_of_rows)):
+            ini = list_index_of_rows[index]
+            if index + 1 > len(list_index_of_rows) - 1:
+                end = df.shape[0]
+            else:
+                end = list_index_of_rows[index + 1]
+
+            block = df.iloc[ini:end].dropna(axis=1, how="all").dropna(axis=0, how="all")
+
+            block = block.reset_index(drop=True)
+            allDfBlocks.append(block)
+
+        return allDfBlocks
+
+    def get_dataframe_blocks_by_key_column(self, df, key_column):
+        """
+        Splits a DataFrame into blocks based on occurrences of a keyname.
+
+        This method is designed for sheets containing multiple blocks of information,
+        separated by a repeated `key_name` at the beginning of each block. It identifies
+        the rows containing the `key_name` and uses their indices to split the DataFrame
+        into individual blocks. Each block is then cleaned by removing rows and columns
+        that are entirely NaN.
+
+        Args:
+            df (pandas.DataFrame): The DataFrame to split.
+            key_name (str): The keyname that marks the beginning of each block.
+
+        Returns:
+            list: A list of pandas DataFrames, where each DataFrame represents a
+                block of data. Returns an empty list if the `key_name` is not found.
+        """
+
+        allDfBlocks = []
+
+        list_index_of_columns = self._getAllColumnsFromKey(df, key_column)
+
+        for index in range(len(list_index_of_columns)):
+            ini = list_index_of_columns[index]
+            if index + 1 > len(list_index_of_columns) - 1:
+                end = df.shape[1]
+            else:
+                end = list_index_of_columns[index + 1]
+
+            block = df.iloc[:, ini:end].dropna(axis=0, how="all").dropna(axis=1, how="all")
+
+            block = block.reset_index(drop=True)
+            allDfBlocks.append(block)
+
+        return allDfBlocks
+
+    def _getAllColumnsFromKey(self, df, key_column):
+        """
+        Returns a list of indices for columns matching the specified key column name.
+
+        This method searches for columns in the DataFrame whose names match `key_column`
+        and returns a list of their integer indices.
+
+        Args:
+            df (pandas.DataFrame): The DataFrame to search.
+            key_column (str): The name of the column to search for.
+
+        Returns:
+            list: A list of integer indices of the matching columns.  Returns an
+            empty list if no matching columns are found.
+        """
+        key_indices = []
+        for i, column in enumerate(df.columns):
+            if column == key_column:
+                key_indices.append(i)
+        return key_indices
+
+    def _getTable(self, _sheet, init_table, end_table):
+        """
+        Extracts a table (DataFrame) from a sheet within specified row boundaries.
+
+        This method extracts a portion of the input sheet (`_sheet`) between `init_table`
+        and `end_table` (exclusive) as a new DataFrame. It then cleans the table by
+        removing rows and columns that are entirely NaN, sets the first row as the header
+        (after cleaning and formatting it), and resets the index.
+
+        Args:
+            _sheet (pandas.DataFrame): The sheet (DataFrame) to extract the table from.
+            init_table (int): The starting row index (inclusive).
+            end_table (int): The ending row index (exclusive).
+
+        Returns:
+            pandas.DataFrame: A new DataFrame representing the extracted table.
+            A copy of the DataFrame is created, so the original DataFrame is not modified in place.
+        """
+        table = (
+            _sheet.iloc[init_table:end_table].dropna(axis=1, how="all").dropna(axis=0, how="all")
+        )  # Extract and clean
+
+        # Set the header from the first row after cleaning and formatting:
+        table.columns = [str(s).strip().upper().replace(" ", "_") for s in table.iloc[0]]
+        table = table.drop(0).reset_index(
+            drop=True
+        )  # Remove the first row (old header) and reset index
+        return table
+
+    def _headerColumnsAreEmpty(self, columns):
+        """
+        Checks if all column names in a Series start with "Unnamed:".
+
+        Args:
+            columns (pandas.Series): The Series containing the column names.
+
+        Returns:
+            bool: True if all column names start with "Unnamed:", False otherwise.
+        """
+        return columns.str.contains("^Unnamed:").all()