cht_utils 2.0.0__py3-none-any.whl

cht_utils/fileio/deltares_ini.py

@@ -0,0 +1,326 @@
+"""Reader and writer for Deltares-style INI configuration files.
+
+These files consist of ``[Section]`` blocks containing keyword-value pairs
+and optional data tables.
+"""
+
+import datetime
+import re
+from typing import Any, List, Optional
+
+import numpy as np
+import pandas as pd
+
+
+class Section:
+    """A single section within an INI file.
+
+    Parameters
+    ----------
+    name : str or None
+        Section name (text between square brackets).
+    """
+
+    def __init__(self, name: Optional[str] = None) -> None:
+        self.name: Optional[str] = name
+        self.keyword: List["Keyword"] = []
+        self.data: Optional[pd.DataFrame] = None
+
+    def get_value(self, keyword: str) -> Optional[Any]:
+        """Return the value of a keyword in this section.
+
+        Parameters
+        ----------
+        keyword : str
+            Keyword name (case-insensitive).
+
+        Returns
+        -------
+        Any or None
+            The keyword value, or ``None`` if not found.
+        """
+        for kw in self.keyword:
+            if kw.name.lower() == keyword.lower():
+                return kw.value
+        return None
+
+
+class Keyword:
+    """A key-value pair within an INI section.
+
+    Parameters
+    ----------
+    name : str or None
+        Keyword name.
+    value : Any
+        Keyword value.
+    comment : str or None
+        Inline comment.
+    """
+
+    def __init__(
+        self,
+        name: Optional[str] = None,
+        value: Any = None,
+        comment: Optional[str] = None,
+    ) -> None:
+        self.name = name
+        self.value = value
+        self.comment = comment
+
+
+class IniStruct:
+    """Deltares INI file parser and writer.
+
+    Parameters
+    ----------
+    filename : str or None
+        If provided, the file is read immediately on construction.
+    """
+
+    def __init__(self, filename: Optional[str] = None) -> None:
+        self.section: List[Section] = []
+        if filename:
+            self.read(filename)
+
+    def read(self, filename: str) -> None:
+        """Parse an INI file into sections, keywords, and data tables.
+
+        Parameters
+        ----------
+        filename : str
+            Path to the INI file.
+        """
+        self.section = []
+        istart: List[int] = []
+
+        with open(filename, "r") as fid:
+            lines = fid.readlines()
+
+        # Find section starts
+        for i, line in enumerate(lines):
+            ll = line.strip()
+            if len(ll) == 0:
+                continue
+            if ll[0] == "[" and ll[-1] == "]":
+                sec = Section(name=ll[1:-1])
+                istart.append(i)
+                self.section.append(sec)
+
+        # Parse each section
+        for isec in range(len(self.section)):
+            i1 = istart[isec] + 1
+            i2 = istart[isec + 1] - 1 if isec < len(self.section) - 1 else len(lines)
+
+            df = pd.DataFrame()
+
+            for iline in range(i1, i2):
+                ll = lines[iline].strip()
+                if len(ll) == 0 or ll[0] == "#":
+                    continue
+
+                if "=" in ll:
+                    key = Keyword()
+
+                    # Handle embedded # in values (e.g. hex colours)
+                    if "#" in ll:
+                        ipos = [m.start() for m in re.finditer("#", ll)]
+                        if len(ipos) > 1:
+                            ll = (
+                                ll[: ipos[0]]
+                                + ll[ipos[0] + 1 : ipos[1]]
+                                + ll[ipos[1] + 1 :]
+                            )
+
+                    if "#" in ll:
+                        j = ll.index("#")
+                        key.comment = ll[j + 1 :].strip()
+                        ll = ll[:j].strip()
+
+                    tx = ll.split("=")
+                    key.name = tx[0].strip()
+                    key.value = tx[1].strip()
+                    self.section[isec].keyword.append(key)
+                else:
+                    a_list = ll.split()
+                    values = []
+                    for item in a_list:
+                        try:
+                            values.append(float(item))
+                        except ValueError:
+                            values.append(item)
+                    df = pd.concat([df, pd.Series(values)], axis=1)
+
+            if not df.empty:
+                df = df.transpose().set_index([0])
+                self.section[isec].data = df
+
+    def write(self, file_name: str) -> None:
+        """Write the INI structure back to a file.
+
+        Parameters
+        ----------
+        file_name : str
+            Output file path.
+        """
+        try:
+            fid = open(file_name, "w")
+        except OSError:
+            print(f"Warning! Could not create file: {file_name}")
+            return
+
+        try:
+            for section in self.section:
+                fid.write(f"[{section.name}]\n")
+
+                for kw in section.keyword:
+                    valstr = ""
+                    if kw.value is not None:
+                        if isinstance(kw.value, (float, int)):
+                            valstr = str(kw.value)
+                        elif isinstance(kw.value, datetime.date):
+                            valstr = kw.value.strftime("%Y%m%d")
+                        else:
+                            valstr = kw.value
+
+                    kwstr = f"   {kw.name:<20s} = "
+                    valstr = f"{valstr:<30s}"
+                    comstr = f" # {kw.comment}" if kw.comment else ""
+                    fid.write(f"{kwstr}{valstr}{comstr}\n")
+
+                if section.data is not None:
+                    tt = section.data.index.to_numpy()
+                    vv = section.data.array.to_numpy()
+                    for it, v in enumerate(vv):
+                        if np.isnan(v):
+                            v = -999.0
+                        fid.write(f"{tt[it]:12.1f}{v:12.3f}\n")
+
+                fid.write("\n")
+        finally:
+            fid.close()
+
+    def get_value(self, section_name: str, keyword_name: str) -> Optional[Any]:
+        """Get a keyword value from a named section.
+
+        Parameters
+        ----------
+        section_name : str
+            Section name.
+        keyword_name : str
+            Keyword name.
+
+        Returns
+        -------
+        Any or None
+            The keyword value, or ``None`` if not found.
+        """
+        for section in self.section:
+            if section.name == section_name:
+                for kw in section.keyword:
+                    if kw.name == keyword_name:
+                        return kw.value
+        return None
+
+    def set_value(
+        self,
+        section_name: str,
+        keyword_name: str,
+        keyword_value: Any,
+        keyword_comment: Optional[str] = None,
+    ) -> None:
+        """Set a keyword value, creating the section or keyword if needed.
+
+        Parameters
+        ----------
+        section_name : str
+            Section name.
+        keyword_name : str
+            Keyword name.
+        keyword_value : Any
+            New value.
+        keyword_comment : str or None
+            Optional inline comment.
+        """
+        for section in self.section:
+            if section.name == section_name:
+                for kw in section.keyword:
+                    if kw.name == keyword_name:
+                        kw.value = keyword_value
+                        return
+                kw = Keyword(keyword_name, keyword_value, keyword_comment)
+                section.keyword.append(kw)
+                return
+
+        kw = Keyword(keyword_name, keyword_value, keyword_comment)
+        section = Section(section_name)
+        section.keyword.append(kw)
+        self.section.append(section)
+
+    def get_data(
+        self,
+        section_name: str,
+        keyword_list: Optional[List[str]] = None,
+        value_list: Optional[List[str]] = None,
+    ) -> Optional[pd.DataFrame]:
+        """Return the data table from a matching section.
+
+        Parameters
+        ----------
+        section_name : str
+            Section name.
+        keyword_list : List[str] or None
+            Keywords to match for disambiguation.
+        value_list : List[str] or None
+            Values that the keywords must have.
+
+        Returns
+        -------
+        pd.DataFrame or None
+        """
+        for section in self.section:
+            if section.name == section_name:
+                if keyword_list and value_list:
+                    ok = True
+                    for key, val in zip(keyword_list, value_list):
+                        for kw in section.keyword:
+                            if kw.name == key and kw.value != val:
+                                ok = False
+                    if not ok:
+                        continue
+                return section.data
+        return None
+
+    def get_section(
+        self,
+        section_name: str,
+        keyword_list: Optional[List[str]] = None,
+        value_list: Optional[List[str]] = None,
+    ) -> Optional[Section]:
+        """Return the first section matching the given name and filters.
+
+        Parameters
+        ----------
+        section_name : str
+            Section name.
+        keyword_list : List[str] or None
+            Keywords to match for disambiguation.
+        value_list : List[str] or None
+            Values that the keywords must have.
+
+        Returns
+        -------
+        Section or None
+        """
+        for section in self.section:
+            if section.name == section_name:
+                if keyword_list and value_list:
+                    ok = True
+                    for key, val in zip(keyword_list, value_list):
+                        for kw in section.keyword:
+                            if kw.name == key and kw.value != val:
+                                ok = False
+                    if not ok:
+                        continue
+                return section
+        return None

cht_utils/fileio/json_js.py

@@ -0,0 +1,72 @@
+"""I/O for JavaScript-wrapped JSON and CSV files.
+
+These formats prepend a JavaScript variable declaration line before the actual
+JSON or CSV payload.
+"""
+
+import json
+import os
+from typing import Any, Union
+
+
+def read_json_js(file_name: str) -> Any:
+    """Read a JavaScript-wrapped JSON file (skips the first line).
+
+    Parameters
+    ----------
+    file_name : str
+        Input file path.
+
+    Returns
+    -------
+    Any
+        Parsed JSON object.
+    """
+    with open(file_name, "r") as f:
+        lines = f.readlines()
+    jsn_string = "".join(line.strip() for line in lines[1:])
+    return json.loads(jsn_string)
+
+
+def write_json_js(file_name: str, jsn: Union[list, dict], first_line: str) -> None:
+    """Write a JSON object to a JavaScript-wrapped file.
+
+    Parameters
+    ----------
+    file_name : str
+        Output file path.
+    jsn : list or dict
+        JSON-serializable data.
+    first_line : str
+        JavaScript variable declaration line (e.g. ``"var data ="``)
+    """
+    with open(file_name, "w") as f:
+        f.write(first_line + "\n")
+        if isinstance(jsn, list):
+            f.write("[\n")
+            for ix, item in enumerate(jsn):
+                sep = "," if ix < len(jsn) - 1 else ""
+                f.write(json.dumps(item) + sep + "\n")
+            f.write("]\n")
+        else:
+            f.write(json.dumps(jsn) + "\n")
+
+
+def write_csv_js(file_name: str, csv_string: str, first_line: str) -> None:
+    """Write a CSV string to a JavaScript-wrapped file.
+
+    Parameters
+    ----------
+    file_name : str
+        Output file path.
+    csv_string : str
+        CSV content.
+    first_line : str
+        JavaScript variable declaration line.
+    """
+    os.makedirs(os.path.dirname(file_name), exist_ok=True)
+    csv_string = csv_string.replace(chr(13), "")
+    with open(file_name, "w") as f:
+        f.write(first_line + "\n")
+        f.write(csv_string)
+        f.write("`;")

cht_utils/fileio/pli_file.py

@@ -0,0 +1,233 @@
+"""Read and write Deltares PLI/POL files (polyline and polygon data).
+
+PLI files store polylines; POL files store polygons. Both use the Tekal
+block format internally.
+"""
+
+from typing import Optional
+
+import geopandas as gpd
+import pandas as pd
+import shapely.geometry
+
+import cht_utils.fileio.tekal as tek
+
+
+class Polyline:
+    """Simple polyline wrapper with x/y coordinate arrays.
+
+    Parameters
+    ----------
+    x : array-like
+        X-coordinates.
+    y : array-like
+        Y-coordinates.
+    """
+
+    def __init__(self, x, y) -> None:
+        self.x = x
+        self.y = y
+
+
+def read_pli_file(file_name: str) -> list:
+    """Read all polylines from a PLI file.
+
+    Parameters
+    ----------
+    file_name : str
+        Path to the PLI file.
+
+    Returns
+    -------
+    list of Polyline
+        List of polyline objects.
+    """
+    polylines = []
+    D = tek.tekal(file_name)
+    D.info()
+    for j in range(len(D.blocks)):
+        m = D.read(j)
+        polylines.append(Polyline(m[0, :, 0], m[1, :, 0]))
+    return polylines
+
+
+def pli2gdf(
+    file_name: str,
+    crs: Optional[int] = None,
+    name_string: str = "name",
+) -> gpd.GeoDataFrame:
+    """Convert a PLI file to a GeoDataFrame of LineStrings.
+
+    Parameters
+    ----------
+    file_name : str
+        Path to the PLI file.
+    crs : int or None
+        Coordinate reference system (EPSG code).
+    name_string : str
+        Column name for the polyline name attribute.
+
+    Returns
+    -------
+    gpd.GeoDataFrame
+    """
+    D = tek.tekal(file_name)
+    D.info()
+    gdf_list = []
+    for j in range(len(D.blocks)):
+        name = D.blocks[j].name
+        if isinstance(name, bytes):
+            name = name.decode("utf-8")
+        m = D.read(j)
+        x, y = m[0, :, 0], m[1, :, 0]
+        line = shapely.geometry.LineString(list(zip(x, y)))
+        gdf_list.append({name_string: name, "geometry": line})
+    return gpd.GeoDataFrame(gdf_list, crs=crs)
+
+
+def pli2geojson(
+    file_name_in: str,
+    file_name_out: str,
+    crs: Optional[int] = None,
+) -> None:
+    """Convert a PLI file to GeoJSON.
+
+    Parameters
+    ----------
+    file_name_in : str
+        Input PLI file path.
+    file_name_out : str
+        Output GeoJSON file path.
+    crs : int or None
+        Coordinate reference system (EPSG code).
+    """
+    gdf = pli2gdf(file_name_in, crs=crs)
+    gdf.to_file(file_name_out, driver="GeoJSON")
+
+
+def pol2gdf(
+    file_name: str,
+    crs: Optional[int] = None,
+    header: bool = True,
+) -> gpd.GeoDataFrame:
+    """Convert a POL file to a GeoDataFrame of Polygons.
+
+    Parameters
+    ----------
+    file_name : str
+        Path to the POL file.
+    crs : int or None
+        Coordinate reference system (EPSG code).
+    header : bool
+        If ``False``, read as plain whitespace-separated x/y columns.
+
+    Returns
+    -------
+    gpd.GeoDataFrame
+    """
+    gdf_list = []
+    if not header:
+        df = pd.read_csv(
+            file_name,
+            index_col=False,
+            header=None,
+            delim_whitespace=True,
+            names=["x", "y"],
+        )
+        poly = shapely.geometry.Polygon(list(zip(df.x.values, df.y.values)))
+        gdf_list.append({"geometry": poly})
+    else:
+        D = tek.tekal(file_name)
+        D.info()
+        for j in range(len(D.blocks)):
+            m = D.read(j)
+            x, y = m[0, :, 0], m[1, :, 0]
+            poly = shapely.geometry.Polygon(list(zip(x, y)))
+            gdf_list.append({"geometry": poly})
+    return gpd.GeoDataFrame(gdf_list, crs=crs)
+
+
+def pol2geojson(
+    file_name_in: str,
+    file_name_out: str,
+    crs: Optional[int] = None,
+) -> None:
+    """Convert a POL file to GeoJSON.
+
+    Parameters
+    ----------
+    file_name_in : str
+        Input POL file path.
+    file_name_out : str
+        Output GeoJSON file path.
+    crs : int or None
+        Coordinate reference system (EPSG code).
+    """
+    gdf = pol2gdf(file_name_in, crs=crs)
+    gdf.to_file(file_name_out, driver="GeoJSON")
+
+
+def gdf2pli(
+    gdf: gpd.GeoDataFrame,
+    file_name: str,
+    header: bool = True,
+    name_string: str = "name",
+    add_point_name: bool = False,
+) -> None:
+    """Write a GeoDataFrame of LineStrings to a PLI file.
+
+    Parameters
+    ----------
+    gdf : gpd.GeoDataFrame
+        GeoDataFrame with LineString geometries.
+    file_name : str
+        Output PLI file path.
+    header : bool
+        Write Tekal block headers.
+    name_string : str
+        Column containing the polyline name.
+    add_point_name : bool
+        Append vertex names (``NAME_0001``, etc.) to each coordinate line.
+    """
+    fmt = "{:12.6f}" if gdf.crs.is_geographic else "{:12.1f}"
+
+    with open(file_name, "w") as fid:
+        for index, row in gdf.iterrows():
+            coords = list(row["geometry"].coords)
+            nrp = len(coords)
+            if header:
+                hdr = row.get(name_string, f"BL{index + 1:04d}")
+                fid.write(f"{hdr}\n{nrp} 2\n")
+            for ip, (x, y) in enumerate(coords):
+                line = fmt.format(x) + fmt.format(y)
+                if add_point_name:
+                    line += f" {hdr}_{ip + 1:04d}"
+                fid.write(line + "\n")
+
+
+def gdf2pol(
+    gdf: gpd.GeoDataFrame,
+    file_name: str,
+    header: bool = True,
+) -> None:
+    """Write a GeoDataFrame of Polygons to a POL file.
+
+    Parameters
+    ----------
+    gdf : gpd.GeoDataFrame
+        GeoDataFrame with Polygon geometries.
+    file_name : str
+        Output POL file path.
+    header : bool
+        Write Tekal block headers.
+    """
+    fmt = "{:12.6f}" if gdf.crs.is_geographic else "{:12.1f}"
+
+    with open(file_name, "w") as fid:
+        for index, row in gdf.iterrows():
+            coords = list(row["geometry"].exterior.coords)
+            nrp = len(coords)
+            if header:
+                fid.write(f"BL{index + 1:04d}\n{nrp} 2\n")
+            for x, y in coords:
+                fid.write(fmt.format(x) + fmt.format(y) + "\n")