bedrock-ge 0.2.4__py3-none-any.whl → 0.3.1__py3-none-any.whl

bedrock_ge/gi/validate.py

@@ -1,151 +1,88 @@
-from typing import Dict, Union
-
 import geopandas as gpd  # type: ignore
 import pandas as pd
 
 from bedrock_ge.gi.schemas import (
-    BaseInSitu,
-    BaseLocation,
-    BaseSample,
-    InSitu,
-    Location,
-    Project,
-    Sample,
+    BedrockGIDatabase,
+    BedrockGIGeospatialDatabase,
 )
 
 
-# TODO: rename to check_brgi_geodb
-# TODO: make this check actually work...
-def check_brgi_database(brgi_db: Dict[str, Union[pd.DataFrame, gpd.GeoDataFrame]]):
-    """Validates the structure and relationships of a 'Bedrock Ground Investigation' (BRGI) database (which is a dictionary of DataFrames).
+def check_brgi_geodb(
+    brgi_geodb: BedrockGIGeospatialDatabase,
+):
+    """Validates the structure and relationships of a 'Bedrock Ground Investigation' (BrGI) geospatial database.
 
-    This function checks that all tables in the BRGI database conform to their respective schemas
+    This function checks that all tables in the BrGI geospatialdatabase conform to their respective schemas
     and that all foreign key relationships are properly maintained. It validates the following tables:
     - Project
     - Location
+    - LonLatHeight
+    - All In-Situ test tables
     - Sample
-    - InSitu_TESTX
-    - Lab_TESTY (not yet implemented)
+    - All Lab test tables
 
     Args:
-        brgi_db (Dict[str, Union[pd.DataFrame, gpd.GeoDataFrame]]): A dictionary
-            containing the BRGI database tables, where keys are table names and
-            values are the corresponding data tables (DataFrame or GeoDataFrame).
+        brgi_geodb (BedrockGIGeospatialDatabase): Bedrock GI geospatial database object.
 
     Returns:
         is_valid (bool): True if all tables are valid and relationships are properly maintained.
 
     Example:
         ```python
-        brgi_db = {
-            "Project": project_df,
-            "Location": location_gdf,
-            "Sample": sample_gdf,
-            "InSitu_ISPT": in_situ_ispt_gdf,
-        }
-        check_brgi_database(brgi_db)
+        brgi_geodb = BedrockGIGeospatialDatabase(
+            Project=project_df,
+            Location=location_geodf,
+            LonLatHeight=lon_lat_height_geodf,
+            InSituTests={"ISPT": ispt_geodf},
+            Sample=sample_geodf,
+            LabTests={"LLPL": llpl_df},
+        )
+        check_brgi_geodb(brgi_db)
         ```
     """
-    for table_name, table in brgi_db.items():
-        if table_name == "Project":
-            Project.validate(table)
-            print("'Project' table aligns with Bedrock's 'Project' table schema.")
-        elif table_name == "Location":
-            Location.validate(table)
-            check_foreign_key("project_uid", brgi_db["Project"], table)
-            print("'Location' table aligns with Bedrock's 'Location' table schema.")
-        elif table_name == "Sample":
-            Sample.validate(table)
-            check_foreign_key("project_uid", brgi_db["Project"], table)
-            check_foreign_key("location_uid", brgi_db["Location"], table)
-            print("'Sample' table aligns with Bedrock's 'Sample' table schema.")
-        # ! JG is pretty sure that this doesn't work
-        # ! The line below should be:
-        # ! elif table_name.startswith("InSitu_"):
-        elif table_name == "InSitu":
-            InSitu.validate(table)
-            check_foreign_key("project_uid", brgi_db["Project"], table)
-            check_foreign_key("location_uid", brgi_db["Location"], table)
-            print(
-                f"'{table_name}' table aligns with Bedrock's table schema for In-Situ measurements."
-            )
-        elif table_name.startswith("Lab_"):
-            print(
-                "🚨 !NOT IMPLEMENTED! We haven't come across Lab data yet. !NOT IMPLEMENTED!"
-            )
-
+    # TODO: implement this
     return True
 
 
-# TODO: rename to check_brgi_db
-def check_no_gis_brgi_database(
-    brgi_db: Dict[str, Union[pd.DataFrame, gpd.GeoDataFrame]],
+def check_brgi_db(
+    brgi_db: BedrockGIDatabase,
 ):
-    """Validates the structure and relationships of a 'Bedrock Ground Investigation' (BGI) database without GIS geometry.
+    """Validates the structure and relationships of a 'Bedrock Ground Investigation' (BrGI) database.
 
-    This function performs the same validation as `check_brgi_database` but uses schemas
-    that don't require GIS geometry. It validates the following tables:
-    - Project (never has GIS geometry)
-    - Location (without GIS geometry)
-    - Sample (without GIS geometry)
-    - InSitu_TESTX (without GIS geometry)
-    - Lab_TESTY (not yet implemented)
+    This function performs the same validation as `check_brgi_geodb`, but uses schemas
+    that don't require geospatial geometry. It validates the following tables:
+    - Project (never has geospatial geometry)
+    - Location (without geospatial geometry)
+    - All In-Situ test tables (without geospatial geometry)
+    - Sample (without geospatial geometry)
+    - All Lab test tables (never has geospatial geometry)
 
     Args:
-        brgi_db (Dict[str, Union[pd.DataFrame, gpd.GeoDataFrame]]): A dictionary
-            containing the Bedrock GI database tables, where keys are table names
-            and values are the corresponding data tables (DataFrame or GeoDataFrame).
+        brgi_db (BedrockGIDatabase): A Bedrock GI database object.
 
     Returns:
         bool: True if all tables are valid and relationships are properly maintained.
 
     Example:
         ```python
-        brgi_db = {
-            "Project": projects_df,
-            "Location": locations_df,
-            "Sample": samples_df,
-            "InSitu_measurements": insitu_df,
-        }
-        check_no_gis_brgi_database(brgi_db)
+        brgi_db = BedrockGIDatabase(
+            Project=project_df,
+            Location=location_df,
+            InSituTests={"ISPT": ispt_df},
+            Sample=sample_df,
+            LabTests={"LLPL": llpl_df},
+        )
+        check_brgi_db(brgi_db)
         ```
     """
-    for table_name, table in brgi_db.items():
-        if table_name == "Project":
-            Project.validate(table)
-            print("'Project' table aligns with Bedrock's 'Project' table schema.")
-        elif table_name == "Location":
-            BaseLocation.validate(table)
-            check_foreign_key("project_uid", brgi_db["Project"], table)
-            print(
-                "'Location' table aligns with Bedrock's 'Location' table schema without GIS geometry."
-            )
-        elif table_name == "Sample":
-            BaseSample.validate(table)
-            check_foreign_key("project_uid", brgi_db["Project"], table)
-            check_foreign_key("location_uid", brgi_db["Location"], table)
-            print(
-                "'Sample' table aligns with Bedrock's 'Sample' table schema without GIS geometry."
-            )
-        elif table_name.startswith("InSitu_"):
-            BaseInSitu.validate(table)
-            check_foreign_key("project_uid", brgi_db["Project"], table)
-            check_foreign_key("location_uid", brgi_db["Location"], table)
-            print(
-                f"'{table_name}' table aligns with Bedrock's '{table_name}' table schema without GIS geometry."
-            )
-        elif table_name.startswith("Lab_"):
-            print(
-                "🚨 !NOT IMPLEMENTED! We haven't come across Lab data yet. !NOT IMPLEMENTED!"
-            )
-
+    # TODO: implement this
     return True
 
 
 def check_foreign_key(
     foreign_key: str,
-    parent_table: Union[pd.DataFrame, gpd.GeoDataFrame],
-    table_with_foreign_key: Union[pd.DataFrame, gpd.GeoDataFrame],
+    parent_table: pd.DataFrame | gpd.GeoDataFrame,
+    table_with_foreign_key: pd.DataFrame | gpd.GeoDataFrame,
 ) -> bool:
     """Validates referential integrity between two tables by checking foreign key relationships.
 
@@ -154,8 +91,8 @@ def check_foreign_key(
 
     Args:
         foreign_key (str): The name of the column that serves as the foreign key.
-        parent_table (Union[pd.DataFrame, gpd.GeoDataFrame]): The parent table containing the primary keys.
-        table_with_foreign_key (Union[pd.DataFrame, gpd.GeoDataFrame]): The child table containing the foreign keys.
+        parent_table (pd.DataFrame| gpd.GeoDataFrame): The parent table containing the primary keys.
+        table_with_foreign_key (pd.DataFrame| gpd.GeoDataFrame): The child table containing the foreign keys.
 
     Returns:
         bool: True if all foreign keys exist in the parent table.

bedrock_ge/gi/write.py

@@ -1,13 +1,44 @@
 from pathlib import Path
-from typing import Dict, Union
+from typing import Literal
 
 import geopandas as gpd
 import pandas as pd
 
+from bedrock_ge.gi.io_utils import brgi_db_to_dfs, geodf_to_df
+from bedrock_ge.gi.schemas import BedrockGIDatabase, BedrockGIGeospatialDatabase
+
+
+# ? Should this function be made a to_file(s) method of BedrockGIDatabase?
+def write_brgi_db_to_file(
+    brgi_db: BedrockGIDatabase | BedrockGIGeospatialDatabase,
+    path: str | Path,
+    driver: Literal["EXCEL", "GPKG"] = "GPKG",
+) -> None:
+    """Writes a Bedrock GI (geospatial) database to a file.
+
+    Writes a Bedrock GI (geospatial) database to a file. The file type is
+    determined by the `driver` argument. Possible values are "GPKG" and "EXCEL".
+
+    Args:
+        brgi_db (BedrockGIDatabase | BedrockGIGeospatialDatabase): The Bedrock GI (geospatial) database.
+        path (str | Path): The path of the output file.
+        driver (str): The type of the output file. Possible values are "GPKG" and "EXCEL".
+
+    Returns:
+        None
+    """
+    dict_of_dfs = brgi_db_to_dfs(brgi_db)
+    if driver.upper() == "GPKG":
+        write_gi_db_to_gpkg(dict_of_dfs, path)
+    elif driver.upper() == "EXCEL":
+        write_gi_db_to_excel(dict_of_dfs, path)
+    else:
+        raise ValueError(f"Invalid driver: {driver}")
+
 
 def write_gi_db_to_gpkg(
-    brgi_db: Dict[str, gpd.GeoDataFrame],
-    gpkg_path: Union[str, Path],
+    dict_of_dfs: dict[str, pd.DataFrame | gpd.GeoDataFrame],
+    gpkg_path: str | Path,
 ) -> None:
     """Writes a database with Bedrock Ground Investigation data to a GeoPackage file.
 
@@ -16,32 +47,28 @@ def write_gi_db_to_gpkg(
     separate table named by the keys of the dictionary.
 
     Args:
-        brgi_db (Dict[str, Union[pd.DataFrame, gpd.GeoDataFrame]]): A dictionary where
+        dict_of_dfs (dict[str, pd.DataFrame | gpd.GeoDataFrame]): A dictionary where
             keys are brgi table names and values are pandas DataFrames or GeoDataFrames
             with brgi data.
-        gpkg_path (str): The name of the output GeoPackage file.
+        gpkg_path (str | Path): The name of the output GeoPackage file.
 
     Returns:
         None
     """
     # Create a GeoDataFrame from the dictionary of DataFrames
-    for sheet_name, brgi_table in brgi_db.items():
-        sanitized_table_name = sanitize_table_name(sheet_name)
-
-        if isinstance(brgi_table, pd.DataFrame):
-            brgi_table = gpd.GeoDataFrame(brgi_table)
+    for table_name, df in dict_of_dfs.items():
+        sanitized_table_name = sanitize_table_name(table_name)
+        if isinstance(df, pd.DataFrame):
+            df = gpd.GeoDataFrame(df)
 
-        if isinstance(brgi_table, gpd.GeoDataFrame):
-            brgi_table.to_file(
-                gpkg_path, driver="GPKG", layer=sanitized_table_name, overwrite=True
-            )
+        df.to_file(gpkg_path, driver="GPKG", layer=sanitized_table_name, overwrite=True)
 
     print(f"Ground Investigation data has been written to '{gpkg_path}'.")
 
 
 def write_gi_db_to_excel(
-    gi_dfs: Dict[str, Union[pd.DataFrame, gpd.GeoDataFrame]],
-    excel_path: Union[str, Path],
+    dict_of_dfs: dict[str, pd.DataFrame | gpd.GeoDataFrame],
+    excel_path: str | Path,
 ) -> None:
     """Writes a database with Ground Investigation data to an Excel file.
 
@@ -50,27 +77,27 @@ def write_gi_db_to_excel(
     AGS, Bedrock, or another format.
 
     Args:
-        gi_dfs (Dict[str, Union[pd.DataFrame, gpd.GeoDataFrame]]): A dictionary where
+        dict_of_dfs (dict[str, pd.DataFrame | gpd.GeoDataFrame]): A dictionary where
             keys are GI table names and values are DataFrames with GI data.
-        excel_path (Union[str, Path]): Path to the output Excel file. Can be provided as a
+        excel_path (str | Path): Path to the output Excel file. Can be provided as a
             string or Path object.
 
     Returns:
         None
     """
-    # Create an Excel writer object
     with pd.ExcelWriter(excel_path, engine="openpyxl") as writer:
-        for sheet_name, df in gi_dfs.items():
-            sanitized_sheet_name = sanitize_table_name(sheet_name)
-            if isinstance(df, pd.DataFrame) or isinstance(df, gpd.GeoDataFrame):
-                df.to_excel(writer, sheet_name=sanitized_sheet_name, index=False)
+        for sheet_name, df in dict_of_dfs.items():
+            sanitized_sheet_name = sanitize_table_name(sheet_name)[:31]
+            if isinstance(df, gpd.GeoDataFrame):
+                df = geodf_to_df(df)
+
+            df.to_excel(writer, sheet_name=sanitized_sheet_name, index=False)
 
     print(f"Ground Investigation data has been written to '{excel_path}'.")
 
 
-# TODO: Make the 31 character table name length truncation a separate function. Only necessary for Excel.
 def sanitize_table_name(sheet_name):
-    """Replaces invalid characters and spaces in GI table names with underscores and truncates to 31 characters.
+    """Replaces invalid characters and spaces in GI table names with underscores.
 
     Makes table names consistent with SQL, GeoPackage and Excel naming conventions by
     replacing invalid characters and spaces with underscores.
@@ -81,12 +108,8 @@ def sanitize_table_name(sheet_name):
     Returns:
         sanitized_name (str): A sanitized sheet name with invalid characters and spaces replaced.
     """
-    # Trim to a maximum length of 31 characters
-    trimmed_name = sheet_name.strip()[:31]
-
-    # Define invalid characters and replace with underscores
     invalid_chars = [":", "/", "\\", "?", "*", "[", "]"]
-    sanitized_name = trimmed_name
+    sanitized_name = sheet_name.strip()
     for char in invalid_chars:
         sanitized_name = sanitized_name.replace(char, "_")
 
@@ -96,16 +119,10 @@ def sanitize_table_name(sheet_name):
     # Collapse multiple underscores to one
     sanitized_name = "_".join(filter(None, sanitized_name.split("_")))
 
-    if trimmed_name != sanitized_name:
+    if sheet_name != sanitized_name:
         print(
             f"Table names shouldn't contain {invalid_chars} or spaces and shouldn't be longer than 31 characters.\n",
             f"Replaced '{sheet_name}' with '{sanitized_name}'.",
         )
 
-    # Ensure name isn't empty after sanitization
-    # ! "Table1" doesn't make a lot of sense?!? It could be that there are more than 1 table without a name...
-    if not sanitized_name:
-        sanitized_name = "Table1"
-        print("The table name was completely invalid or empty. Replaced with 'Table1'.")
-
     return sanitized_name

{bedrock_ge-0.2.4.dist-info → bedrock_ge-0.3.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bedrock-ge
-Version: 0.2.4
+Version: 0.3.1
 Summary: Bedrock's Python library for geotechnical engineering.
 Project-URL: Homepage, https://bedrock.engineer/
 Project-URL: Source, https://github.com/bedrock-engineer/bedrock-ge
@@ -17,14 +17,14 @@ Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: 3.9
 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
 Classifier: Topic :: Scientific/Engineering :: GIS
-Requires-Python: >=3.9
+Requires-Python: >=3.10
+Requires-Dist: chardet>=5.2.0
 Requires-Dist: geopandas~=1.0
 Requires-Dist: openpyxl~=3.0
 Requires-Dist: pandera>=0.23.0

bedrock_ge-0.3.1.dist-info/RECORD

@@ -0,0 +1,22 @@
+bedrock_ge/__init__.py,sha256=_SKQpwL2hyrtdWQOcbHmo86vQEJbICRTU-Delt085g4,89
+bedrock_ge/plot.py,sha256=C95aj8CXjFVZRGYYBssJMm5MyljLbdt_TKyvmQyWZBE,149
+bedrock_ge/gi/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bedrock_ge/gi/ags.py,sha256=k2ZotuEt08hGvLAjKCDFR_HLFCRHVuMej1dnw-T6WI4,4388
+bedrock_ge/gi/ags3.py,sha256=HNdX1avwzzZsrkTm54aqs9neUrTXa2e784Q8mSy6Zso,10161
+bedrock_ge/gi/ags3_data_dictionary.json,sha256=Wx20_oJRdAlzEo-cKD6FgN9B9zOMDTcsp5dgc8QWofI,188588
+bedrock_ge/gi/ags4.py,sha256=pDKf-l1jheeQAU2bHkiJiIgjUGvD3Iv8of77rYDwUQA,916
+bedrock_ge/gi/ags4_data_dictionary.json,sha256=XE5XJNo8GBPZTUPgvVr3QgO1UfEIAxzlSeXi-P1VLTs,609670
+bedrock_ge/gi/ags_schemas.py,sha256=R5yubnRacAlQBqb7W7Rj_Y4canhg6Tls38e66xXQNRA,8065
+bedrock_ge/gi/db_operations.py,sha256=Pjtslv9syB-_xumH38F2XWt6XLsvrT8MHLgwAGCYEw0,5153
+bedrock_ge/gi/geospatial.py,sha256=w9sP3SIZZceSW98z3LQT_aJKqs0rSd4DDunTFFSJygY,13739
+bedrock_ge/gi/io_utils.py,sha256=Yd1RGEo_DbYoOklJbEKWdaeTw7KckkHDfKZrr91fu1o,9456
+bedrock_ge/gi/mapper.py,sha256=8vFVPlgLY37iNw_5pkSyze6zOmeQjlBHGY4OAFdx5B0,8665
+bedrock_ge/gi/mapping_models.py,sha256=cvepeKwqwdmVqbNBORkgIDgHq0eOPiRIERjO4RYeAQo,1876
+bedrock_ge/gi/schemas.py,sha256=w0tb3c6YBTXdvpdFWWIGmlE7CYsJfo352nWnD9bmXfM,6883
+bedrock_ge/gi/sqlmodels.py,sha256=_h3H9UP91I_1Ya_SZuL6gZbqL7uNCd5Y-u-yTf7CNto,2253
+bedrock_ge/gi/validate.py,sha256=hgT5qZHLeeXR_cgXf1bhzJnJ-wMhE0_0if_H1rtwsiM,3918
+bedrock_ge/gi/write.py,sha256=N8i1oerOaR7-XJnycmN9gXLkpjMdT5PFFB3GduogyKs,4749
+bedrock_ge-0.3.1.dist-info/METADATA,sha256=bCB5WqqWu_BLYMTsYxb5ZHrRtSqYXoKKnk9S_Ykkzi4,11708
+bedrock_ge-0.3.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+bedrock_ge-0.3.1.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+bedrock_ge-0.3.1.dist-info/RECORD,,

bedrock_ge/gi/ags/read.py

@@ -1,192 +0,0 @@
-import io
-from typing import Any, Dict, List, Union
-
-import pandas as pd
-from python_ags4 import AGS4
-
-from bedrock_ge.gi.ags.validate import check_ags_proj_group
-
-
-def ags_to_dfs(ags_data: str) -> Dict[str, pd.DataFrame]:
-    """Converts AGS 3 or AGS 4 data to a dictionary of pandas DataFrames.
-
-    Args:
-        ags_data (str): The AGS data as a string.
-
-    Raises:
-        ValueError: If the data does not match AGS 3 or AGS 4 format.
-
-    Returns:
-        Dict[str, pd.DataFrame]]: A dictionary where keys represent AGS group
-            names with corresponding DataFrames for the corresponding group data.
-    """
-    # Process each line to find the AGS version and delegate parsing
-    for line in ags_data.splitlines():
-        stripped_line = line.strip()  # Remove leading/trailing whitespace
-        if stripped_line:  # Skip empty lines at the start of the file
-            if stripped_line.startswith('"**'):
-                ags_version = 3
-                ags_dfs = ags3_to_dfs(ags_data)
-                break
-            elif stripped_line.startswith('"GROUP"'):
-                ags_version = 4
-                ags_dfs = ags4_to_dfs(ags_data)
-                break
-            else:
-                # If first non-empty line doesn't match AGS 3 or AGS 4 format
-                raise ValueError("The data provided is not valid AGS 3 or AGS 4 data.")
-
-    is_proj_group_correct = check_ags_proj_group(ags_dfs["PROJ"])
-    if is_proj_group_correct:
-        project_id = ags_dfs["PROJ"]["PROJ_ID"].iloc[0]
-        print(
-            f"AGS {ags_version} data was read for Project {project_id}",
-            "This Ground Investigation data contains groups:",
-            list(ags_dfs.keys()),
-            sep="\n",
-            end="\n\n",
-        )
-
-    return ags_dfs
-
-
-def ags3_to_dfs(ags3_data: str) -> Dict[str, pd.DataFrame]:
-    """Converts AGS 3 data to a dictionary of pandas DataFrames.
-
-    Args:
-        ags3_data (str): The AGS 3 data as a string.
-
-    Returns:
-        Dict[str, pd.DataFrame]: A dictionary of pandas DataFrames, where each key
-            represents a group name from AGS 3 data, and the corresponding value is a
-            pandas DataFrame containing the data for that group.
-    """
-    # Initialize dictionary and variables used in the AGS 3 read loop
-    ags3_dfs = {}
-    line_type = "line_0"
-    group = ""
-    headers: List[str] = ["", "", ""]
-    group_data: List[List[Any]] = [[], [], []]
-
-    for i, line in enumerate(ags3_data.splitlines()):
-        last_line_type = line_type
-
-        # In AGS 3.1 group names are prefixed with **
-        if line.startswith('"**'):
-            line_type = "group_name"
-            if group:
-                ags3_dfs[group] = pd.DataFrame(group_data, columns=headers)
-
-            group = line.strip(' ,"*')
-            group_data = []
-
-        # In AGS 3 header names are prefixed with "*
-        elif line.startswith('"*'):
-            line_type = "headers"
-            new_headers = line.split('","')
-            new_headers = [h.strip(' ,"*') for h in new_headers]
-
-            # Some groups have so many headers that they span multiple lines.
-            # Therefore we need to check whether the new headers are
-            # a continuation of the previous headers from the last line.
-            if line_type == last_line_type:
-                headers = headers + new_headers
-            else:
-                headers = new_headers
-
-        # Skip lines where group units are defined, these are defined in the AGS 3 data dictionary.
-        elif line.startswith('"<UNITS>"'):
-            line_type = "units"
-            continue
-
-        # The rest of the lines contain:
-        # 1. GI data
-        # 2. a continuation of the previous line. These lines contain "<CONT>" in the first column.
-        # 3. are empty or contain worthless data
-        else:
-            line_type = "data_row"
-            data_row = line.split('","')
-            if len("".join(data_row)) == 0:
-                # print(f"Line {i} is empty. Last Group: {group}")
-                continue
-            elif len(data_row) != len(headers):
-                print(
-                    f"\n🚨 CAUTION: The number of columns on line {i + 1} ({len(data_row)}) doesn't match the number of columns of group {group} ({len(headers)})!",
-                    f"{group} headers: {headers}",
-                    f"Line {i + 1}:      {data_row}",
-                    sep="\n",
-                    end="\n\n",
-                )
-                continue
-            # Append continued lines (<CONT>) to the last data_row
-            elif data_row[0] == '"<CONT>':
-                last_data_row = group_data[-1]
-                for j, data in enumerate(data_row):
-                    data = data.strip(' "')
-                    if data and data != "<CONT>":
-                        if last_data_row[j] is None:
-                            # Last data row didn't contain data for this column
-                            last_data_row[j] = coerce_string(data)
-                        else:
-                            # Last data row already contains data for this column
-                            last_data_row[j] = str(last_data_row[j]) + data
-            # Lines that are assumed to contain valid data are added to the group data
-            else:
-                cleaned_data_row = []
-                for data in data_row:
-                    cleaned_data_row.append(coerce_string(data.strip(' "')))
-                group_data.append(cleaned_data_row)
-
-    # Also add the last group's df to the dictionary of AGS dfs
-    ags3_dfs[group] = pd.DataFrame(group_data, columns=headers).dropna(
-        axis=1, how="all"
-    )
-
-    if not group:
-        print(
-            '🚨 ERROR: The provided AGS 3 data does not contain any groups, i.e. lines starting with "**'
-        )
-
-    return ags3_dfs
-
-
-def ags4_to_dfs(ags4_data: str) -> Dict[str, pd.DataFrame]:
-    """Converts AGS 4 data to a dictionary of pandas DataFrames.
-
-    Args:
-        ags4_data (str): The AGS 4 data as a string.
-
-    Returns:
-        Dict[str, pd.DataFrame]: A dictionary of pandas DataFrames, where each key 
-            represents a group name from AGS 4 data, and the corresponding value is a
-            pandas DataFrame containing the data for that group.
-    """
-    # AGS4.AGS4_to_dataframe accepts the file, not the data string
-    ags4_file = io.StringIO(ags4_data)
-
-    ags4_tups = AGS4.AGS4_to_dataframe(ags4_file)
-
-    ags4_dfs = {}
-    for group, df in ags4_tups[0].items():
-        df = df.loc[2:].drop(columns=["HEADING"]).reset_index(drop=True)
-        ags4_dfs[group] = df
-
-    return ags4_dfs
-
-
-def coerce_string(string: str) -> Union[None, bool, float, str]:
-    if string.lower() in {"none", "null", ""}:
-        return None
-    elif string.lower() == "true":
-        return True
-    elif string.lower() == "false":
-        return False
-    else:
-        try:
-            value = float(string)
-            if value.is_integer():
-                return int(value)
-            else:
-                return value
-        except ValueError:
-            return string