tgedr-dataops 0.0.36__py3-none-any.whl → 1.0.1__py3-none-any.whl

tgedr_dataops/store/fs_single_partition_parquet.py

@@ -0,0 +1,331 @@
+"""Filesystem-based single partition Parquet store implementation.
+
+This module provides an abstract base class for storing and retrieving data
+in Parquet format with optional single partition support across different
+filesystem implementations (local, S3, etc.).
+"""
+from abc import ABC, abstractmethod
+import logging
+from pathlib import Path
+from typing import Any
+import pandas as pd
+import pyarrow as pa
+import pyarrow.parquet as pq
+import pyarrow.compute as pc
+
+from tgedr_dataops_abs.store import Store, StoreException
+
+
+logger = logging.getLogger(__name__)
+
+
+def pandas_mapper(arrow_type: pa.DataType) -> pd.api.extensions.ExtensionDtype | None:
+    """Map PyArrow types to pandas nullable types.
+
+    Parameters
+    ----------
+    arrow_type : pa.DataType
+        PyArrow data type to map.
+
+    Returns
+    -------
+    pd.api.extensions.ExtensionDtype or None
+        Corresponding pandas nullable dtype, or None for default behavior.
+    """
+    if pa.types.is_int64(arrow_type):
+        return pd.Int64Dtype()
+    if pa.types.is_float64(arrow_type):
+        return pd.Float64Dtype()
+    if pa.types.is_string(arrow_type):
+        return pd.StringDtype()   # pragma: no cover
+    # suggest default behavior
+    return None
+
+
+class FsSinglePartitionParquetStore(Store, ABC):
+    """Abstract store implementation for Parquet files with optional single partition.
+
+    This class provides persistence on Parquet files with an optional single partition,
+    regardless of the underlying filesystem location (local, S3, etc.).
+    """
+
+    @property
+    @abstractmethod
+    def fs(self) -> Any:
+        """Abstract property providing a filesystem implementation.
+
+        Returns
+        -------
+        Any
+            Filesystem implementation (e.g., LocalFileSystem, S3FileSystem).
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def _rmdir(self, key: str) -> None:
+        """Remove a directory.
+
+        Parameters
+        ----------
+        key : str
+            Directory path to remove.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def _exists(self, key: str) -> bool:
+        """Check if a path exists.
+
+        Parameters
+        ----------
+        key : str
+            Path to check for existence.
+
+        Returns
+        -------
+        bool
+            True if path exists, False otherwise.
+        """
+        raise NotImplementedError
+
+    def __init__(self, config: dict[str, Any] | None = None) -> None:
+        """Initialize the FsSinglePartitionParquetStore.
+
+        Parameters
+        ----------
+        config : dict[str, Any], optional
+            Configuration dictionary.
+        """
+        Store.__init__(self, config)
+        self._fs = None
+
+    def get(
+        self,
+        key: str,
+        filter_func: Any | None = None,
+        filters: list[tuple[str, str, list[str]]] | None = None,
+        schema: pa.Schema | None = None,
+    ) -> pd.DataFrame:
+        """Read a pandas DataFrame from Parquet storage.
+
+        Reads data from the specified location, optionally enforcing a schema
+        and allowing filtering of data.
+
+        Parameters
+        ----------
+        key : str
+            Location/URL/path where data is persisted.
+        filter_func : callable, optional
+            Filter expression (see PyArrow Table.filter documentation).
+        filters : list[tuple[str, str, list[str]]], optional
+            Filter expression for read_table (see PyArrow parquet.read_table documentation).
+        schema : pa.Schema, optional
+            Data schema to enforce while reading.
+
+        Returns
+        -------
+        pd.DataFrame
+            The loaded DataFrame.
+        """
+        schema_msg_segment = "0" if schema is None else str(len(schema))
+        logger.info(f"[get|in] ({key}, {filter_func}, {filters}, schema len:{schema_msg_segment})")
+        logger.debug(f"[get|in] ({key}, {filter_func}, {filters}, {schema})")
+        table = pq.read_table(key, filesystem=self.fs, filters=filters, schema=schema)
+        if filter_func is not None:
+            table = table.filter(filter_func)
+        result = table.to_pandas(types_mapper=pandas_mapper)
+        logger.info(f"[get|out] => {result.shape}")
+        return result
+
+    def delete(
+        self,
+        key: str,
+        partition_field: str | None = None,
+        partition_values: list[str] | None = None,
+        kv_dict: dict[str, list[Any]] | None = None,
+        schema: pa.Schema = None,
+    ) -> None:
+        """Delete partitions or data from Parquet storage.
+
+        Removes partitions (full or partial), deletes specific values, or removes
+        an entire dataset from Parquet storage.
+
+        Parameters
+        ----------
+        key : str
+            Location/URL/path where data is persisted.
+        partition_field : str, optional
+            Name of the partition field in the dataset.
+        partition_values : list[str], optional
+            Partition values to delete.
+        kv_dict : dict[str, list[Any]], optional
+            Key-value map defining fields and array of values for deletion filter.
+        schema : pa.Schema, optional
+            Data schema to enforce if reading is required.
+        """
+        schema_msg_segment = "0" if schema is None else str(len(schema))
+        logger.info(
+            f"[delete|in] ({key}, {partition_field}, {partition_values}, {kv_dict}, schema len:{schema_msg_segment})"
+        )
+        logger.debug(f"[delete|in] ({key}, {partition_field}, {partition_values}, {kv_dict}, {schema})")
+
+        if partition_values is not None and partition_field is not None:
+            self._remove_partitions(key, partition_field=partition_field, partition_values=partition_values)
+        elif kv_dict is not None and partition_field is not None:
+            table = pq.read_table(key, filesystem=self.fs, schema=schema)
+            for k, v in kv_dict.items():
+                filter_condition = ~pc.is_in(pc.field(k), pa.array(v))
+                table = table.filter(filter_condition)
+            self.delete(key, schema=schema)
+            pq.write_to_dataset(
+                table,
+                root_path=key,
+                partition_cols=[partition_field],
+                existing_data_behavior="delete_matching",
+                filesystem=self.fs,
+                schema=schema,
+            )
+        else:
+            self._rmdir(key)
+
+        logger.info("[delete|out]")
+
+    def save(
+        self,
+        df: pd.DataFrame,
+        key: str,
+        partition_field: str | None = None,
+        append: bool = False,
+        replace_partitions: bool = False,
+        schema: Any = None,
+    ) -> None:
+        """Save a pandas DataFrame in Parquet format.
+
+        Saves data to the specified location with optional partitioning,
+        append, or replace behavior.
+
+        Parameters
+        ----------
+        df : pd.DataFrame
+            The DataFrame to be saved.
+        key : str
+            Location/URL/path where data should be persisted.
+        partition_field : str, optional
+            Name of the partition field in the dataset.
+        append : bool, default False
+            If True, data will be appended; otherwise will overwrite.
+        replace_partitions : bool, default False
+            If True, partitions will be replaced, deleting existing data in those partitions.
+        schema : pa.Schema, optional
+            Data schema to enforce while writing.
+
+        Raises
+        ------
+        StoreException
+            If both append and replace_partitions are True.
+        """
+        schema_msg_segment = "0" if schema is None else str(len(schema))
+        logger.info(
+            f"[save|in] ({df.shape}, {key}, {partition_field}, {append}, {replace_partitions}, schema len:{schema_msg_segment})"
+        )
+        logger.debug(f"[save|in] ({df}, {key}, {partition_field}, {append}, {replace_partitions}, {schema})")
+
+        if schema is not None and isinstance(schema, pa.lib.Schema):
+            # we will order the columns based on the schema
+            columns = list(schema.names)
+            df = df[columns]
+
+        if replace_partitions and append:
+            raise StoreException("cannot request for replace_partitions and append at the same time")
+
+        if append:
+            pq.write_to_dataset(
+                pa.Table.from_pandas(df, preserve_index=False),
+                root_path=key,
+                partition_cols=[partition_field],
+                filesystem=self.fs,
+                schema=schema,
+            )
+        elif replace_partitions:
+            partitions = df[partition_field].unique().tolist()
+            self._remove_partitions(key, partition_field, partitions)
+            pq.write_to_dataset(
+                pa.Table.from_pandas(df, preserve_index=False),
+                root_path=key,
+                partition_cols=[partition_field],
+                existing_data_behavior="delete_matching",
+                filesystem=self.fs,
+                schema=schema,
+            )
+        else:
+            self.delete(key)
+            pq.write_to_dataset(
+                pa.Table.from_pandas(df, preserve_index=False),
+                root_path=key,
+                partition_cols=[partition_field],
+                existing_data_behavior="delete_matching",
+                filesystem=self.fs,
+                schema=schema,
+            )
+        logger.info("[save|out]")
+
+    def _remove_partitions(self, key: str, partition_field: str, partition_values: list[str]) -> None:
+        """Remove specific partitions from the dataset.
+
+        Parameters
+        ----------
+        key : str
+            Root path of the dataset.
+        partition_field : str
+            Name of the partition field.
+        partition_values : list[str]
+            List of partition values to remove.
+        """
+        logger.debug(f"[_remove_partitions|in] ({key}, {partition_field}, {partition_values})")
+
+        for partition_value in partition_values:
+            partition_key = f"{partition_field}={partition_value}"
+            partition_path = str(Path(key) / partition_key)
+            self._rmdir(partition_path)
+
+        logger.debug("[_remove_partitions|out]")
+
+    def update(
+        self,
+        df: pd.DataFrame,
+        key: str,
+        key_fields: list[str],
+        partition_field: str | None = None,
+        schema: Any = None,
+    ) -> None:
+        """Update rows in a pandas DataFrame stored in Parquet format.
+
+        Updates matching rows based on key fields by merging with existing data.
+
+        Parameters
+        ----------
+        df : pd.DataFrame
+            The DataFrame containing updates.
+        key : str
+            Location/URL/path where data is persisted.
+        key_fields : list[str]
+            Primary fields used to match rows for updating.
+        partition_field : str, optional
+            Name of the partition field to enforce while saving.
+        schema : pa.Schema, optional
+            Data schema to enforce while reading and saving.
+        """
+        schema_msg_segment = "0" if schema is None else str(len(schema))
+        logger.info(
+            f"[update|in] ({df.shape}, {key}, {key_fields}, {partition_field}, schema len:{schema_msg_segment})"
+        )
+        logger.debug(f"[update|in] ({df}, {key}, {key_fields}, {partition_field}, {schema})")
+
+        df0 = self.get(key, schema=schema)
+        match = pd.merge(df0.reset_index(), df.reset_index(), on=key_fields)
+        index_left = match["index_x"]
+        index_right = match["index_y"]
+        df0.iloc[index_left] = df.iloc[index_right]
+        self.save(df0, key, partition_field=partition_field, schema=schema)
+
+        logger.info("[update|out]")

tgedr_dataops/store/local_fs_single_partition_parquet.py

@@ -0,0 +1,56 @@
+"""Local filesystem implementation for single partition Parquet storage.
+
+This module provides LocalFsSinglePartitionParquetStore, which implements
+single partition Parquet storage using the local file system.
+"""
+import logging
+from typing import Any
+from pyarrow import fs
+
+from tgedr_dataops.store.fs_single_partition_parquet import FsSinglePartitionParquetStore
+
+
+logger = logging.getLogger(__name__)
+
+
+class LocalFsSinglePartitionParquetStore(FsSinglePartitionParquetStore):
+    """FsSinglePartitionParquetStore implementation using local file system."""
+
+    @property
+    def fs(self) -> Any:
+        """Get the PyArrow local filesystem instance.
+
+        Returns
+        -------
+        Any
+            The filesystem instance for local file operations.
+        """
+        if self._fs is None:
+            self._fs = fs.LocalFileSystem()
+        return self._fs
+
+    def _rmdir(self, key: str) -> None:
+        """Remove a directory recursively.
+
+        Parameters
+        ----------
+        key : str
+            Path to the directory to delete.
+        """
+        if self.fs.get_file_info(key).type.name == "Directory":
+            self.fs.delete_dir(key)
+
+    def _exists(self, key: str) -> bool:
+        """Check if a path exists on the local filesystem.
+
+        Parameters
+        ----------
+        key : str
+            Path to check for existence.
+
+        Returns
+        -------
+        bool
+            True if path exists, False otherwise.
+        """
+        return self.fs.get_file_info(key).type.name != "NotFound"

tgedr_dataops/store/s3_single_partition_parquet.py

@@ -0,0 +1,193 @@
+"""S3 implementation of single partition parquet store."""
+import logging
+import s3fs
+from typing import Any
+import pandas as pd
+import pyarrow as pa
+
+from tgedr_dataops.store.fs_single_partition_parquet import FsSinglePartitionParquetStore
+from tgedr_dataops.commons.utils_fs import remove_s3_protocol
+
+
+logger = logging.getLogger(__name__)
+
+
+class S3FsSinglePartitionParquetStore(FsSinglePartitionParquetStore):  # pragma: no cover
+    """FsSinglePartitionParquetStore implementation using aws s3 file system."""
+
+    CONFIG_KEY_AWS_ACCESS_KEY_ID: str = "aws_access_key_id"
+    CONFIG_KEY_AWS_SECRET_ACCESS_KEY: str = "aws_secret_access_key"  # noqa: S105
+    CONFIG_KEY_AWS_SESSION_TOKEN: str = "aws_session_token"  # noqa: S105
+
+    @property
+    def fs(self) -> Any:
+        """Get the S3 filesystem instance.
+
+        Returns
+        -------
+        Any
+            The s3fs.S3FileSystem instance for S3 operations.
+        """
+        if self._fs is None:
+            if (self._config is not None) and all(
+                element in list(self._config.keys())
+                for element in [
+                    self.CONFIG_KEY_AWS_ACCESS_KEY_ID,
+                    self.CONFIG_KEY_AWS_SECRET_ACCESS_KEY,
+                    self.CONFIG_KEY_AWS_SESSION_TOKEN,
+                ]
+            ):
+                self._fs = s3fs.S3FileSystem(
+                    key=self._config[self.CONFIG_KEY_AWS_ACCESS_KEY_ID],
+                    secret=self._config[self.CONFIG_KEY_AWS_SECRET_ACCESS_KEY],
+                    token=self._config[self.CONFIG_KEY_AWS_SESSION_TOKEN],
+                )
+            else:
+                self._fs = s3fs.S3FileSystem()
+        return self._fs
+
+    def _rmdir(self, key: str) -> None:
+        """Remove a directory (prefix) from S3.
+
+        Parameters
+        ----------
+        key : str
+            S3 path/prefix to delete.
+        """
+        if self.fs.isdir(key):
+            self.fs.delete(key, recursive=True)
+
+    def _exists(self, key: str) -> bool:
+        """Check if a path exists in S3.
+
+        Parameters
+        ----------
+        key : str
+            S3 path to check for existence.
+
+        Returns
+        -------
+        bool
+            True if path exists in S3, False otherwise.
+        """
+        return self.fs.get_file_info(key).type.name != "NotFound"
+
+    def get(
+        self,
+        key: str,
+        filter_func: callable | None = None,
+        filters: list[tuple[str, str, list[str]]] | None = None,
+        schema: pa.Schema = None,
+    ) -> pd.DataFrame:
+        """Retrieve data from S3 parquet store.
+
+        Parameters
+        ----------
+        key : str
+            S3 path to the parquet data (s3:// protocol will be removed).
+        filter_func : callable, optional
+            Row filter function.
+        filters : list[tuple[str, str, list[str]]], optional
+            Partition filters.
+        schema : pa.Schema, optional
+            PyArrow schema for reading.
+
+        Returns
+        -------
+        pd.DataFrame
+            The loaded DataFrame.
+        """
+        return super().get(key=remove_s3_protocol(key), filter_func=filter_func, filters=filters, schema=schema)
+
+    def delete(
+        self,
+        key: str,
+        partition_field: str | None = None,
+        partition_values: list[str] | None = None,
+        kv_dict: dict[str, list[Any]] | None = None,
+        schema: pa.Schema = None,
+    ) -> None:
+        """Delete data from S3 parquet store.
+
+        Parameters
+        ----------
+        key : str
+            S3 path to the parquet data (s3:// protocol will be removed).
+        partition_field : str, optional
+            Field used for partitioning.
+        partition_values : list[str], optional
+            List of partition values to delete.
+        kv_dict : dict[str, list[Any]], optional
+            Dictionary of key-value filters for deletion.
+        schema : pa.Schema, optional
+            PyArrow schema.
+        """
+        super().delete(
+            key=remove_s3_protocol(key),
+            partition_field=partition_field,
+            partition_values=partition_values,
+            kv_dict=kv_dict,
+            schema=schema,
+        )
+
+    def save(
+        self,
+        df: pd.DataFrame,
+        key: str,
+        partition_field: str | None = None,
+        append: bool = False,
+        replace_partitions: bool = False,
+        schema: Any = None,
+    ) -> None:
+        """Save DataFrame to S3 parquet store.
+
+        Parameters
+        ----------
+        df : pd.DataFrame
+            The DataFrame to save.
+        key : str
+            S3 path to save the parquet data (s3:// protocol will be removed).
+        partition_field : str, optional
+            Field to partition by.
+        append : bool, default False
+            If True, append to existing data.
+        replace_partitions : bool, default False
+            If True, replace existing partitions.
+        schema : Any, optional
+            Schema for the data.
+        """
+        super().save(
+            df=df,
+            key=remove_s3_protocol(key),
+            partition_field=partition_field,
+            append=append,
+            replace_partitions=replace_partitions,
+            schema=schema,
+        )
+
+    def update(
+        self,
+        df: pd.DataFrame,
+        key: str,
+        key_fields: list[str],
+        partition_field: str | None = None,
+        schema: Any = None,
+    ) -> None:
+        """Update data in S3 parquet store.
+
+        Parameters
+        ----------
+        df : pd.DataFrame
+            The DataFrame with updated data.
+        key : str
+            S3 path to the parquet data (s3:// protocol will be removed).
+        key_fields : list[str]
+            List of fields to use as keys for matching records.
+        partition_field : str, optional
+            Field used for partitioning.
+        schema : Any, optional
+            Schema for the data.
+        """
+        super().update(
+            df=df, key=remove_s3_protocol(key), key_fields=key_fields, partition_field=partition_field, schema=schema
+        )

tgedr_dataops-1.0.1.dist-info/METADATA

@@ -0,0 +1,72 @@
+Metadata-Version: 2.4
+Name: tgedr-dataops
+Version: 1.0.1
+Summary: data operations related code
+Author-email: joao tiago viegas <3536754+jtviegas@users.noreply.github.com>
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: tgedr-dataops-abs==0.0.3
+Requires-Dist: s3fs==2024.5.0
+Requires-Dist: boto3==1.34.106
+Requires-Dist: openpyxl==3.1.2
+Requires-Dist: pyarrow>=23.0.0
+Requires-Dist: moto>=5.1.20
+Dynamic: license-file
+
+# data-ops
+
+![Coverage](./coverage.svg)
+[![PyPI](https://img.shields.io/pypi/v/tgedr-dataops)](https://pypi.org/project/tgedr-dataops/)
+
+
+
+data operations related code
+
+## motivation
+*data-ops* is a library with tested and used code aligning on some standards regarding code structure and quality and to avoid reinventing the wheel
+
+## installation
+        `pip install tgedr-dataops`
+
+## package namespaces and its contents
+
+#### commons
+- __S3Connector__: base class to be extended, providing a connection session with aws s3 resources
+- __utils_fs__: utility module with file system related functions ([example](tests/tgedr_dataops/commons/test_utils_fs.py))
+
+#### quality
+- __PandasValidation__ : __GreatExpectationsValidation__ implementation to validate pandas dataframes with Great Expectations library ([example](tests/tgedr_dataops/quality/test_pandas_validation.py))
+
+
+#### sink
+- __LocalFsFileSink__: __Sink__ implementation class used to save/persist an object/file to a local fs location ([example](tests/tgedr_dataops/sink/test_localfs_file_sink.py))
+- __S3FileSink__: __Sink__ implementation class used to save/persist a local object/file to an s3 bucket ([example](tests/tgedr_dataops/sink/test_s3_file_sink.py))
+
+#### source
+- __AbstractS3FileSource__: abstract __Source__ class used to retrieve objects/files from s3 bucket to local fs location circumventing some formats download limitation
+- __LocalFsFileSource__: __Source__ implementation class used to retrieve local objects/files to another local fs location ([example](tests/tgedr_dataops/source/test_localfs_file_source.py))
+- __PdDfS3Source__: __Source__ implementation class used to read a pandas dataframe from s3, whether a csv or an excel (xslx) file ([example csv](tests/tgedr_dataops/source/test_pd_df_s3_source_csv.py), [example excel](tests/tgedr_dataops/source/test_pd_df_s3_source_excel.py))
+- __S3FileCopy__: __Source__ implementation class used to copy objects/files from an s3 bucket to another s3 bucket ([example](tests/tgedr_dataops/source/test_s3_copy.py))
+- __S3FileExtendedSource__: __Source__ implementation class used to retrieve objects/files from s3 bucket to local fs location with the extra method `get_metadata` providing sile metadata ("LastModified", "ContentLength", "ETag", "VersionId", "ContentType")([example](tests/tgedr_dataops/source/test_s3_file_extended_source.py))
+- __S3FileSource__: __Source__ implementation class used to retrieve objects/files from s3 bucket to local fs location ([example](tests/tgedr_dataops/source/test_s3_file_source.py))
+
+#### store
+- __FsSinglePartitionParquetStore__ : abstract __Store__ implementation defining persistence on parquet files with an optional single partition, regardless of the location it should persist
+- __LocalFsSinglePartitionParquetStore__ : __FsSinglePartitionParquetStore__ implementation using local file system ([example](tests/tgedr_dataops/store/test_local_fs_single_partition_parquet.py))
+- __S3FsSinglePartitionParquetStore__ : __FsSinglePartitionParquetStore__ implementation using aws s3 file system ([example](tests/tgedr_dataops/store/MANUAL_test_s3_single_partition_parquet.py))
+
+
+## development
+- main requirements:
+  - _uv_  
+  - _bash_
+- Clone the repository like this:
+
+  ``` bash
+  git clone git@github.com:tgedr/pycommons
+  ```
+- cd into the folder: `cd pycommons`
+- install requirements: `./helper.sh reqs`
+
+

tgedr_dataops-1.0.1.dist-info/RECORD

@@ -0,0 +1,22 @@
+tgedr_dataops/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tgedr_dataops/commons/s3_connector.py,sha256=Tf1Cc2CPE5uRl3oW_yTu59Ge2ukQmsncqM6HdG90sck,1993
+tgedr_dataops/commons/utils_fs.py,sha256=ZFZG-aG-liq-s3CnEDggvLJgJ1zsoKsqYMQU7bMbxiY,4888
+tgedr_dataops/quality/pandas_validation.py,sha256=WLHiL0b0Nm4ldO_1t55nFQ-F6UwxouYvbnP7bONrBp8,817
+tgedr_dataops/sink/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tgedr_dataops/sink/local_fs_file_sink.py,sha256=5gM4dOXiGRtPLvYFHAvwijQbXRNltpUdS06kIGhOwj4,2353
+tgedr_dataops/sink/s3_file_sink.py,sha256=5p591g89UjCpoRuKlaf7UAOzF7Ac0UyWEhSPZX7_O-E,3344
+tgedr_dataops/source/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tgedr_dataops/source/abstract_s3_file_source.py,sha256=XqUGDLz6qXJnydoyE3rQJcDOKwD_nuSzO2tElOfEM1w,2230
+tgedr_dataops/source/local_fs_file_source.py,sha256=GheAp2QaugxDc4REMqJ_435seUmEv-Marnv4LwGXUjw,3553
+tgedr_dataops/source/pd_df_s3_source.py,sha256=rL7eEEkwXate5aVNDC_LvU80apKphff2ViI65vB6TpI,4566
+tgedr_dataops/source/s3_file_copy.py,sha256=rV-N2pwH12LrsXYl2aINBcHwBcHTP3xTF0aS8-oqZEQ,4899
+tgedr_dataops/source/s3_file_extended_source.py,sha256=8LLNJmBUtrAEUSFE2Pl5rKa7TKEFinXQ0q6T9jJHS5E,2264
+tgedr_dataops/source/s3_file_source.py,sha256=Ntfgn7r_Hy74CuO-UM5XqAnN_PZMiLipDxMsF2Es88s,4563
+tgedr_dataops/store/fs_single_partition_parquet.py,sha256=tGcknJ0igaRrpURP-3nJoAyR1Hd_KbONjcyVADmRzwY,11705
+tgedr_dataops/store/local_fs_single_partition_parquet.py,sha256=_0n2qUDABm0WRat4-V7gKoxz3JZVyomQbC_OCLmHxbg,1542
+tgedr_dataops/store/s3_single_partition_parquet.py,sha256=dxmYY4h7Y9FfOKVjPgNEU812FH_5MeAQihRrdeHZd7U,6070
+tgedr_dataops-1.0.1.dist-info/licenses/LICENSE,sha256=awOCsWJ58m_2kBQwBUGWejVqZm6wuRtCL2hi9rfa0X4,1211
+tgedr_dataops-1.0.1.dist-info/METADATA,sha256=Rfg1g1oAZQ9ajQq03tzbWhjCybZpJY4rDz9txCkrlrY,3865
+tgedr_dataops-1.0.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+tgedr_dataops-1.0.1.dist-info/top_level.txt,sha256=O-CCFyLA9TzzhSdYShs9EcoZzpu_TzEr_rHGZiN-YBg,14
+tgedr_dataops-1.0.1.dist-info/RECORD,,

{tgedr_dataops-0.0.36.dist-info → tgedr_dataops-1.0.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.43.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

tgedr_dataops-1.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+tgedr_dataops