interoperable-csv 0.2.0__py3-none-any.whl

icsv/__init__.py

@@ -0,0 +1,14 @@
+from .application_profile import append_timepoint, iCSV2DTimeseries
+from .factory import from_smet, read
+from .header import FieldsSection, MetaDataSection
+from .icsv_file import iCSVFile
+
+__all__ = [
+    "iCSVFile",
+    "read",
+    "from_smet",
+    "MetaDataSection",
+    "FieldsSection",
+    "iCSV2DTimeseries",
+    "append_timepoint",
+]

icsv/acdd.py

@@ -0,0 +1,77 @@
+class ACDDMetadata:
+    def __init__(self, strict: bool = False) -> None:
+        self.attributes = {
+            "title": None,
+            "summary": None,
+            "keywords": None,
+            "conventions": None,
+            "id": None,
+            "naming_authority": None,
+            "source": None,
+            "history": None,
+            "comment": None,
+            "date_created": None,
+            "creator_name": None,
+            "creator_url": None,
+            "creator_email": None,
+            "institution": None,
+            "processing_level": None,
+            "project": None,
+            "geospatial_bounds": None,
+            "geospatial_lat_min": None,
+            "geospatial_lat_max": None,
+            "geospatial_lon_min": None,
+            "geospatial_lon_max": None,
+            "geospatial_vertical_min": None,
+            "geospatial_vertical_max": None,
+            "time_coverage_start": None,
+            "time_coverage_end": None,
+            "Wigos ID": None,
+        }
+        self.unknown_attributes = {}
+        self.strict = strict
+
+    def set_attribute(self, attribute_name, value):
+        attribute_name = attribute_name.replace("acdd_", "")
+        if attribute_name in self.attributes:
+            self.attributes[attribute_name] = value
+        else:
+            if self.strict:
+                return False
+            self.unknown_attributes[attribute_name] = value
+        return True
+
+    def get_attribute(self, attribute_name):
+        if attribute_name in self.attributes:
+            return self.attributes[attribute_name]
+        if attribute_name in self.unknown_attributes:
+            return self.unknown_attributes[attribute_name]
+        return None
+
+    @property
+    def adjusted_dict(self):
+        return {
+            **{k: v for k, v in self.attributes.items() if v is not None},
+            **{k: v for k, v in self.unknown_attributes.items() if v is not None},
+        }
+
+    def join(self, other: "ACDDMetadata"):
+        for attr_dict in [other.attributes, other.unknown_attributes]:
+            for attribute, value in attr_dict.items():
+                self_value = self.get_attribute(attribute)
+                if value and self_value is None:
+                    self.set_attribute(attribute, value)
+
+    def __eq__(self, value: object) -> bool:
+        if not isinstance(value, ACDDMetadata):
+            return False
+        for attr in ["attributes", "unknown_attributes"]:
+            self_dict = getattr(self, attr)
+            value_dict = getattr(value, attr)
+            common_keys = self_dict.keys() & value_dict.keys()
+            for key in common_keys:
+                if self_dict[key] is not None and value_dict[key] is not None:
+                    if self_dict[key] != value_dict[key]:
+                        return False
+        return True
+

icsv/application_profile.py

@@ -0,0 +1,123 @@
+import datetime
+import warnings
+from typing import Optional
+
+import pandas as pd
+import xarray as xr
+
+from .icsv_file import VERSIONS, iCSVFile
+
+FIRSTLINES_2DTIMESERIES = [f"# iCSV {version} UTF-8 2DTIMESERIES" for version in VERSIONS]
+
+
+class iCSV2DTimeseries(iCSVFile):
+    def __init__(self, filename: str = None):
+        self.dates = []
+        self.date_lines = []
+        super().__init__(filename)
+
+    def _parse_comment_line(self, line, section, line_number):
+        if line == "[METADATA]":
+            return "metadata"
+        if line == "[FIELDS]":
+            self.metadata.check_validity()
+            return "fields"
+        if line == "[DATA]":
+            return "data"
+        return self._parse_section_line(line, section, line_number)
+
+    def _parse_section_line(self, line, section, line_number):
+        if not section:
+            raise ValueError("No section specified")
+        line_vals = line.split("=")
+        if len(line_vals) != 2:
+            raise ValueError(f"Invalid {section} line: {line}")
+        if section == "metadata":
+            self.metadata.set_attribute(line_vals[0].strip(), line_vals[1].strip())
+        elif section == "fields":
+            fields_vec = [field.strip() for field in line_vals[1].split(self.metadata.get_attribute("field_delimiter"))]
+            self.fields.set_attribute(line_vals[0].strip(), fields_vec)
+        elif section == "data":
+            if "[DATE=" in line:
+                date_str = line.split("[DATE=")[1].split("]")[0].strip()
+                self.dates.append(datetime.datetime.fromisoformat(date_str))
+                self.date_lines.append(line_number)
+            else:
+                raise ValueError(f"Invalid data line: {line}")
+        return section
+
+    def load_file(self, filename: str = None):
+        self.data = {}
+        if filename:
+            self.filename = filename
+        section = ""
+        with open(self.filename, "r", encoding="utf-8") as file:
+            first_line = file.readline().rstrip()
+            if first_line not in FIRSTLINES_2DTIMESERIES:
+                raise ValueError("Not an iCSV file with the 2D timeseries application profile")
+            line_number = 1
+            for line in file:
+                line_number += 1
+                if line.startswith("#"):
+                    line = line[1:].strip()
+                    section = self._parse_comment_line(line.strip(), section, line_number)
+                elif section != "data":
+                    raise ValueError("Data section was not specified")
+
+        for i, date in enumerate(self.dates):
+            first_data_line = self.date_lines[i]
+            last_data_line = self.date_lines[i + 1] if i + 1 < len(self.dates) else line_number + 1
+            self.data[date] = pd.read_csv(self.filename, skiprows=first_data_line, nrows=last_data_line - first_data_line - 1, header=None, sep=self.metadata.get_attribute("field_delimiter"))
+            self.data[date].columns = self.fields.fields
+
+        self.fields.check_validity(self.data[self.dates[0]].shape[1])
+        self.parse_geometry()
+
+    def to_xarray(self):
+        arrays = []
+        for date in self.dates:
+            df = self.data[date].copy()
+            if "layer_index" in df.columns:
+                df.set_index("layer_index", inplace=True)
+            arrays.append(df.to_xarray())
+        ds = xr.concat(arrays, dim="time")
+        ds = ds.assign_coords(time=self.dates)
+        ds.attrs = self.metadata.metadata
+        return ds
+
+    def setData(self, timestamp: datetime.datetime, data: pd.DataFrame, colnames: Optional[list] = None):
+        if not self.data:
+            self.data = {}
+        self.dates.append(timestamp)
+        self.data[timestamp] = data
+
+    def write(self, filename: str = None):
+        if filename:
+            self.filename = filename
+        self.metadata.check_validity()
+        if "source" not in self.metadata.metadata:
+            warnings.warn("source is a recommended metadata for the 2D timeseries application profile, but could not be found")
+        first_key = self.dates[0]
+        self.fields.check_validity(self.data[first_key].shape[1])
+        if "layer_index" not in self.fields.fields:
+            warnings.warn("layer_index is a recommended field for the 2D timeseries application profile, but could not be found")
+        with open(self.filename, "w", encoding="utf-8") as file:
+            file.write(f"{FIRSTLINES_2DTIMESERIES[-1]}\n")
+            file.write("# [METADATA]\n")
+            for key, val in self.metadata.metadata.items():
+                file.write(f"# {key} = {val}\n")
+            file.write("# [FIELDS]\n")
+            for key, val in self.fields.all_fields.items():
+                fields_string = self.metadata.get_attribute("field_delimiter").join(str(value) for value in val)
+                file.write(f"# {key} = {fields_string}\n")
+            file.write("# [DATA]\n")
+            for date in self.dates:
+                file.write(f"# [DATE={date.isoformat()}]\n")
+                self.data[date].to_csv(file, mode="a", index=False, header=False, sep=self.metadata.get_attribute("field_delimiter"))
+
+
+def append_timepoint(filename: str, timestamp: datetime.datetime, data: pd.DataFrame, field_delimiter: str = ","):
+    with open(filename, "a", encoding="utf-8") as file:
+        file.write(f"# [DATE={timestamp.isoformat()}]\n")
+        data.to_csv(file, mode="a", index=False, header=False, sep=field_delimiter)
+

icsv/factory.py

@@ -0,0 +1,79 @@
+from typing import Protocol
+
+from .application_profile import FIRSTLINES_2DTIMESERIES, iCSV2DTimeseries
+from .icsv_file import FIRSTLINES, iCSVFile
+
+
+class _SmetLike(Protocol):
+    meta_data: object
+    optional_meta_data: object
+    other_meta_data: dict
+    acdd_meta_data: object
+    data: object
+
+
+def read(filename: str) -> iCSVFile:
+    firstline = open(filename, encoding="utf-8").readline().rstrip()
+    if firstline in FIRSTLINES_2DTIMESERIES:
+        return iCSV2DTimeseries(filename)
+    if firstline in FIRSTLINES:
+        return iCSVFile(filename)
+    raise ValueError("Not an iCSV file")
+
+
+def from_smet(smet: _SmetLike) -> iCSVFile:
+    icsv = iCSVFile()
+    _set_fields_and_location(icsv, smet)
+    _set_metadata(icsv, smet)
+    icsv.data = smet.data
+    _check_validity_and_parse_geometry(icsv, icsv.data.shape[1])
+    return icsv
+
+
+def _set_fields_and_location(icsv, smet):
+    icsv.fields.set_attribute("fields", smet.meta_data.fields)
+    loc = smet.meta_data.location
+    _set_location_attributes(icsv, loc)
+
+
+def _set_location_attributes(icsv, loc):
+    if not loc.epsg and not loc.is_latlon():
+        raise ValueError("EPSG code not provided")
+    elif loc.is_latlon():
+        loc.epsg = 4326
+        x = loc.longitude
+        y = loc.latitude
+    else:
+        x = loc.easting
+        y = loc.northing
+    z = loc.altitude
+    icsv.metadata.set_attribute("geometry", f"POINTZ({x} {y} {z})")
+    icsv.metadata.set_attribute("srid", f"EPSG:{loc.epsg}")
+    icsv.metadata.set_attribute("field_delimiter", ",")
+
+
+def _set_metadata(icsv: iCSVFile, smet: _SmetLike):
+    icsv.metadata.set_attribute("nodata", smet.meta_data.nodata)
+    icsv.metadata.set_attribute("station_id", smet.meta_data.station_id)
+    _set_meta_data_attributes(icsv, smet.optional_meta_data.adjusted_dict)
+    _set_meta_data_attributes(icsv, smet.other_meta_data)
+    for key, value in smet.acdd_meta_data.adjusted_dict.items():
+        icsv.metadata.set_attribute(key, value)
+
+
+def _set_meta_data_attributes(icsv: iCSVFile, meta_data):
+    for key, value in meta_data.items():
+        if value:
+            if isinstance(value, list) and len(value) == len(icsv.fields.fields):
+                icsv.fields.set_attribute(key, value)
+            elif isinstance(value, str) and len(value.split(" ")) == len(icsv.fields.fields):
+                icsv.fields.set_attribute(key, value.split(" "))
+            else:
+                icsv.metadata.set_attribute(key, value)
+
+
+def _check_validity_and_parse_geometry(icsv, ncols: int):
+    icsv.metadata.check_validity()
+    icsv.fields.check_validity(ncols)
+    icsv.parse_geometry()
+

icsv/header.py

@@ -0,0 +1,174 @@
+from dataclasses import dataclass as dat
+
+from .acdd import ACDDMetadata
+from .utility import is_number
+
+
+class MetaDataSection:
+    def __init__(self):
+        self.required_attributes = {
+            "field_delimiter": None,
+            "geometry": None,
+            "srid": None,
+        }
+        self.recommended_attributes = {
+            "station_id": None,
+            "nodata": None,
+            "timezone": None,
+            "doi": None,
+            "timestamp_meaning": None,
+        }
+        self.acdd_metadata = ACDDMetadata()
+        self.other_metadata = {}
+
+    def __eq__(self, value: object) -> bool:
+        if not isinstance(value, MetaDataSection):
+            return False
+        for attr in ["required_attributes", "recommended_attributes", "other_metadata"]:
+            self_dict = getattr(self, attr)
+            value_dict = getattr(value, attr)
+            common_keys = self_dict.keys() & value_dict.keys()
+            for key in common_keys:
+                if self_dict[key] is not None and value_dict[key] is not None:
+                    if self_dict[key] != value_dict[key]:
+                        return False
+        return self.acdd_metadata == value.acdd_metadata
+
+    def check_validity(self):
+        for key, value in self.required_attributes.items():
+            if value is None:
+                raise ValueError(f"Required attribute {key} is missing")
+
+    def set_attribute(self, attribute_name, value):
+        if is_number(value):
+            value = float(value)
+        if attribute_name in self.required_attributes:
+            self.required_attributes[attribute_name] = value
+        elif attribute_name in self.recommended_attributes:
+            self.recommended_attributes[attribute_name] = value
+        if not self.acdd_metadata.set_attribute(attribute_name, value):
+            self.other_metadata[attribute_name] = value
+
+    def get_attribute(self, attribute_name):
+        if attribute_name in self.required_attributes:
+            return self.required_attributes[attribute_name]
+        if attribute_name in self.recommended_attributes:
+            return self.recommended_attributes[attribute_name]
+        value = self.acdd_metadata.get_attribute(attribute_name)
+        if value is not None:
+            return value
+        return self.other_metadata.get(attribute_name)
+
+    @property
+    def metadata(self) -> dict:
+        return {
+            **self.required_attributes,
+            **{k: v for k, v in self.recommended_attributes.items() if v},
+            **{k: v for k, v in self.other_metadata.items() if v},
+            **self.acdd_metadata.adjusted_dict,
+        }
+
+
+class FieldsSection:
+    def __init__(self):
+        self.fields = []
+        self.recommended_fields = {
+            "units_multiplier": [],
+            "units": [],
+            "long_name": [],
+            "standard_name": [],
+        }
+        self.other_fields = {}
+
+    def __eq__(self, value: object) -> bool:
+        if not isinstance(value, FieldsSection):
+            return False
+        for attr in ["fields", "recommended_fields", "other_fields"]:
+            if getattr(self, attr) != getattr(value, attr):
+                return False
+        return True
+
+    def check_validity(self, n_cols: int):
+        if not self.fields:
+            raise ValueError("No fields provided")
+        if len(self.fields) != n_cols:
+            raise ValueError("Number of fields does not match the number of columns")
+        for key, val in self.recommended_fields.items():
+            if val and len(self.recommended_fields[key]) != n_cols:
+                raise ValueError(f"Number of {key} does not match the number of columns")
+        for key, val in self.other_fields.items():
+            if val and len(self.other_fields[key]) != n_cols:
+                raise ValueError(f"Number of {key} does not match the number of columns")
+
+    def set_attribute(self, attribute_name, value):
+        value = [float(val) if is_number(val) else val for val in value]
+        if attribute_name == "fields":
+            self.fields = value
+        elif attribute_name in self.recommended_fields:
+            self.recommended_fields[attribute_name] = value
+        else:
+            self.other_fields[attribute_name] = value
+
+    def get_attribute(self, attribute_name):
+        if attribute_name == "fields":
+            return self.fields
+        if attribute_name in self.recommended_fields:
+            return self.recommended_fields[attribute_name]
+        return self.other_fields.get(attribute_name)
+
+    @property
+    def all_fields(self):
+        return {
+            "fields": self.fields,
+            **{k: v for k, v in self.recommended_fields.items() if v},
+            **{k: v for k, v in self.other_fields.items() if v},
+        }
+
+    @property
+    def miscalleneous_fields(self):
+        return {
+            **{k: v for k, v in self.recommended_fields.items() if v},
+            **{k: v for k, v in self.other_fields.items() if v},
+        }
+
+
+@dat
+class Loc:
+    x: float = None
+    y: float = None
+    z: float = None
+    epsg: int = None
+
+
+class Geometry:
+    def __init__(self):
+        self.geometry = None
+        self.srid = None
+        self.column_name = None
+        self.location = Loc()
+
+    def __eq__(self, value: object) -> bool:
+        if not isinstance(value, Geometry):
+            return False
+        return self.geometry == value.geometry and self.srid == value.srid
+
+    def set_location(self):
+        if "POINTZ" in self.geometry:
+            content = self.geometry.split("(")[1].split(")")[0]
+            vals = content.split(" ")
+            if len(vals) != 3:
+                raise ValueError("Invalid POINTZ geometry")
+            self.location.x = float(vals[0])
+            self.location.y = float(vals[1])
+            self.location.z = float(vals[2])
+        elif "POINT" in self.geometry:
+            content = self.geometry.split("(")[1].split(")")[0]
+            vals = content.split(" ")
+            if len(vals) != 2:
+                raise ValueError("Invalid POINT geometry")
+            self.location.x = float(vals[0])
+            self.location.y = float(vals[1])
+        else:
+            raise ValueError("Unsupported geometry type")
+        self.location.epsg = self.srid.split(":")[1]
+

icsv/icsv_file.py

@@ -0,0 +1,173 @@
+from typing import Optional
+
+import pandas as pd
+import xarray as xr
+
+from .header import FieldsSection, Geometry, MetaDataSection
+
+VERSIONS = ["1.0"]
+FIRSTLINES = [f"# iCSV {version} UTF-8" for version in VERSIONS]
+
+
+class iCSVFile:
+    def __init__(self, filename: str = None):
+        self.metadata = MetaDataSection()
+        self.fields = FieldsSection()
+        self.geometry = Geometry()
+        self.data = None
+        self.filename = filename
+        self.skip_lines = 0
+        if self.filename:
+            self.load_file()
+
+    def __eq__(self, value: object) -> bool:
+        try:
+            for attr in ["metadata", "fields", "geometry"]:
+                if getattr(self, attr) != getattr(value, attr):
+                    return False
+            return True
+        except AttributeError:
+            return False
+
+    def set_metadata(self, attribute_name, value):
+        self.metadata.set_attribute(attribute_name, value)
+
+    def set_fields(self, attribute_name, value):
+        self.fields.set_attribute(attribute_name, value)
+
+    def get_metadata(self, attribute_name):
+        return self.metadata.get_attribute(attribute_name)
+
+    def get_field(self, attribute_name):
+        return self.fields.get_attribute(attribute_name)
+
+    def _parse_comment_line(self, line, section):
+        if line == "[METADATA]":
+            return "metadata"
+        if line == "[FIELDS]":
+            self.metadata.check_validity()
+            return "fields"
+        if line == "[DATA]":
+            return "data"
+        return self._parse_section_line(line, section)
+
+    def _parse_section_line(self, line, section):
+        if not section:
+            raise ValueError("No section specified")
+        line_vals = line.split("=")
+        if len(line_vals) != 2:
+            raise ValueError(f"Invalid {section} line: {line}")
+        if section == "metadata":
+            self.metadata.set_attribute(line_vals[0].strip(), line_vals[1].strip())
+        elif section == "fields":
+            fields_vec = [
+                field.strip()
+                for field in line_vals[1].split(
+                    self.metadata.get_attribute("field_delimiter")
+                )
+            ]
+            self.fields.set_attribute(line_vals[0].strip(), fields_vec)
+        elif section == "data":
+            raise TypeError("Data section should not contain any comments")
+        return section
+
+    def _update_columns(self):
+        self.data.columns = self.fields.fields
+        for field in ["time", "timestamp"]:
+            if field in self.fields.fields:
+                self.data[field] = pd.to_datetime(self.data[field])
+
+    def load_file(self, filename: str = None):
+        if filename:
+            self.filename = filename
+        section = ""
+        with open(self.filename, "r", encoding="utf-8") as file:
+            first_line = file.readline().rstrip()
+            if first_line not in FIRSTLINES:
+                raise ValueError("Not an iCSV file")
+            line_number = 1
+            for line in file:
+                if line.startswith("#"):
+                    line_number += 1
+                    line = line[1:].strip()
+                    section = self._parse_comment_line(line.strip(), section)
+                else:
+                    if section != "data":
+                        raise ValueError("Data section was not specified")
+                    self.skip_lines = line_number
+                    break
+        self.data = pd.read_csv(
+            self.filename,
+            skiprows=self.skip_lines,
+            header=None,
+            sep=self.metadata.get_attribute("field_delimiter"),
+        )
+        self.fields.check_validity(self.data.shape[1])
+        self._update_columns()
+        self.parse_geometry()
+
+    def parse_geometry(self):
+        self.geometry.geometry = self.metadata.get_attribute("geometry")
+        self.geometry.srid = self.metadata.get_attribute("srid")
+        if self.metadata.get_attribute("geometry") in self.fields.get_attribute(
+            "fields"
+        ):
+            self.geometry.column_name = self.metadata.get_attribute("column_name")
+        else:
+            self.geometry.set_location()
+
+    def to_xarray(self) -> xr.Dataset:
+        arr = self.data.to_xarray()
+        arr.attrs = self.metadata.metadata
+        for i, var in enumerate(arr.data_vars):
+            for _, vec in self.fields.miscalleneous_fields.items():
+                arr[var].attrs = vec[i]
+        return arr
+
+    def setData(self, data: pd.DataFrame, colnames: Optional[list] = None):
+        self.data = data
+        if colnames:
+            if len(colnames) != self.data.shape[1]:
+                raise ValueError(
+                    "Number of columns in data does not match the number of column names"
+                )
+            self.fields.set_attribute("fields", colnames)
+        else:
+            colnames = self.data.columns.to_list()
+            if colnames[0] == "0" or colnames[0] == 0:
+                raise ValueError("Column names are not provided")
+            self.fields.set_attribute("fields", colnames)
+        if "timestamp" in self.data.columns:
+            cols = self.data.columns.tolist()
+            if cols[0] != "timestamp":
+                cols.insert(0, cols.pop(cols.index("timestamp")))
+                self.data = self.data[cols]
+            self.fields.set_attribute("fields", self.data.columns)
+
+    def write(self, filename: str = None):
+        if filename:
+            self.filename = filename
+        self.metadata.check_validity()
+        self.fields.check_validity(self.data.shape[1])
+        nodata = self.metadata.get_attribute("nodata")
+        nodata = "-999.0" if nodata is None else str(nodata)
+        with open(self.filename, "w", encoding="utf-8") as file:
+            file.write(f"{FIRSTLINES[-1]}\n")
+            file.write("# [METADATA]\n")
+            for key, val in self.metadata.metadata.items():
+                file.write(f"# {key} = {val}\n")
+            file.write("# [FIELDS]\n")
+            for key, val in self.fields.all_fields.items():
+                fields_string = self.metadata.get_attribute("field_delimiter").join(
+                    str(value) for value in val
+                )
+                file.write(f"# {key} = {fields_string}\n")
+            file.write("# [DATA]\n")
+        self.data.to_csv(
+            self.filename,
+            mode="a",
+            index=False,
+            header=False,
+            sep=self.metadata.get_attribute("field_delimiter"),
+            na_rep=nodata,
+        )

icsv/utility.py

@@ -0,0 +1,7 @@
+def is_number(s):
+    try:
+        float(s)
+        return True
+    except ValueError:
+        return False
+

interoperable_csv-0.2.0.dist-info/METADATA

@@ -0,0 +1,44 @@
+Metadata-Version: 2.1
+Name: interoperable-csv
+Version: 0.2.0
+Summary: Read, write, and transform iCSV files.
+License: GPL-3.0-only
+Keywords: icsv,snow,timeseries,geospatial,climate
+Author: Patrick Leibersperger
+Author-email: patrick.leibersperger@slf.ch
+Requires-Python: >=3.9,<4.0
+Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: pandas (>=2.0,<3.0)
+Requires-Dist: xarray (>=2024.3.0,<2025.0.0)
+Description-Content-Type: text/markdown
+
+# icsv
+
+Standalone Python package for reading, writing, and transforming iCSV files.
+
+## Installation
+
+```bash
+pip install icsv
+```
+
+## Quickstart
+
+```python
+import icsv
+
+f = icsv.read("input.icsv")
+print(f.fields.get_attribute("fields"))
+f.write("copy.icsv")
+```
+
+## Documentation
+
+Project documentation is built with MkDocs and deployed through the CI pages pipeline.
+
+

interoperable_csv-0.2.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+icsv/__init__.py,sha256=PdyYOdmIg3aDIs4pcBDINzWxlOiVN_ksOYQ6--oT1DM,340
+icsv/acdd.py,sha256=eHPcX86V5XuxZAknV2fkRTaOMcdlqUNJVzfSaH42gJI,2844
+icsv/application_profile.py,sha256=6HMXQ9iUftuqL2i8IuOp21XiVpDEe_logGGk98JqWoc,5466
+icsv/factory.py,sha256=yOypwMjU02-0j9qK1ABdjQCW8U9-wRpfTaeUYW3Rv1Y,2619
+icsv/header.py,sha256=ZPRpfe2GrcC3BGsDADuH49UBH1o-fsYnP4ToGLtaGRY,6285
+icsv/icsv_file.py,sha256=PvFxJFoOFbmWL-beHq3j1L3pU075Edf9Bzmv1STe0to,6546
+icsv/utility.py,sha256=hTRKg8NyqnX0_TaASSudIq304g3vJTZyicHyJe-vevM,109
+interoperable_csv-0.2.0.dist-info/METADATA,sha256=wyKA_RP8skst_AURFx9Llquv9HelsnOhPf0CvRleefg,1103
+interoperable_csv-0.2.0.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+interoperable_csv-0.2.0.dist-info/RECORD,,

interoperable_csv-0.2.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 1.8.1
+Root-Is-Purelib: true
+Tag: py3-none-any