floe-python 0.8.8__py3-none-any.whl → 0.8.9__py3-none-any.whl

floe/checks/unique.py

@@ -17,7 +17,6 @@ from floe.checks.rows import RowCheck
 
 SAMPLE_LIMIT = 5
 _SEEN = "__floe_seen"
-_DEBUG = "__floe_debug"
 _COUNT = "__floe_count"
 _BITS = "_bits"  # suffix of the bit-pattern column that keys a float column
 
@@ -56,45 +55,11 @@ def resolve_unique_keys(
     return resolved
 
 
-# `str` Debug; ponytail: non-ASCII non-printable characters (Rust `\\u{..}`) are left raw
-_STR_ESCAPES = {
-    "\\": "\\\\",
-    '"': '\\"',
-    "\n": "\\n",
-    "\r": "\\r",
-    "\t": "\\t",
-    "\0": "\\0",
-    **{chr(i): f"\\u{{{i:x}}}" for i in [*range(1, 32), 127] if chr(i) not in "\n\r\t"},
-}
-
-
 def _float_bits(s: pl.Series) -> pl.Series:
     """Rust's `to_bits()`: Polars cannot reinterpret a float, so view the Arrow buffer."""
     return pl.Series(s.cast(pl.Float64).to_arrow().view(pa.uint64()))
 
 
-def _debug(name: str, dtype: pl.DataType) -> pl.Expr:
-    """Rust's `{:?}` of the `UniqueKey` variant: the sample tie-break sorts on these strings."""
-    c = pl.col(name)
-    if dtype == pl.String:
-        escaped = c
-        for raw, esc in _STR_ESCAPES.items():
-            escaped = escaped.str.replace_all(raw, esc, literal=True)
-        return pl.format('String("{}")', escaped)
-    if dtype == pl.Boolean:
-        return pl.format("Bool({})", c.cast(pl.String))
-    if dtype.is_signed_integer():
-        return pl.format("I64({})", c.cast(pl.String))
-    if dtype.is_unsigned_integer():
-        return pl.format("U64({})", c.cast(pl.String))
-    if dtype.is_float():
-        return pl.format("F64({})", pl.col(name + _BITS).cast(pl.String))
-    if isinstance(dtype, pl.Datetime):  # chrono prints the fraction only when not zero
-        return pl.format('Other("{}")', c.dt.to_string("%Y-%m-%d %H:%M:%S%.f"))
-    # ponytail: date keys use `Other(display)`, unverified against Rust; ties may order differently
-    return pl.format('Other("{}")', c.cast(pl.String))
-
-
 def _text(value: object) -> str:
     """Rust's `to_string` of a key value."""
     if isinstance(value, bool):
@@ -221,7 +186,7 @@ class UniqueTracker:
         return RowCheck("unique", name, message, dup)
 
     def results(self) -> list[UniqueResult]:
-        """Per constraint, the top `SAMPLE_LIMIT` keys by count, ties by Rust's Debug string."""
+        """Per constraint, the top `SAMPLE_LIMIT` keys by count, ties by the key values (numbers numerically, strings by code point)."""
         return [self._result(c) for c in self._constraints]
 
     def _result(self, c: _Constraint) -> UniqueResult:
@@ -229,14 +194,9 @@ class UniqueTracker:
             return UniqueResult(c.columns, 0, [])
         parts = pl.concat(c.dup_counts)
         counts = parts.group_by(parts.columns[:-1]).agg(pl.col(_COUNT).sum())
-        debug = pl.format(
-            "CompositeKey([{}])",
-            pl.concat_str([_debug(k, counts.schema[k]) for k in c.ids], separator=", "),
-        )
-        top = (
-            counts.with_columns(debug.alias(_DEBUG))
-            .sort([_COUNT, _DEBUG], descending=[True, False])
-            .head(SAMPLE_LIMIT)
+        by = [_COUNT, *counts.columns[:-1]]
+        top = counts.sort(by, descending=[True] + [False] * (len(by) - 1)).head(
+            SAMPLE_LIMIT
         )
         samples = [  # at most SAMPLE_LIMIT rows
             UniqueSample(

floe/iceberg/catalog.py

@@ -12,7 +12,11 @@ from urllib.parse import urlsplit
 
 import duckdb
 from pyiceberg.catalog import Catalog, load_catalog
-from pyiceberg.exceptions import NamespaceAlreadyExistsError
+from pyiceberg.exceptions import (
+    NamespaceAlreadyExistsError,
+    NoSuchNamespaceError,
+    NoSuchTableError,
+)
 from pyiceberg.partitioning import PartitionField, PartitionSpec
 from pyiceberg.schema import Schema
 from pyiceberg.table import Table
@@ -345,55 +349,59 @@ def ensure_table(
 
     With `add_columns`, columns new in `schema` are added as optional (D13) and returned by name; partition changes stay rejected.
     """
-    ident = (namespace,)
-    with run_error("rest catalog namespace_exists check failed"):
-        namespace_exists = catalog.namespace_exists(ident)
-    if not namespace_exists:
-        if not create_namespace:
-            raise FloeRunError(f"entity.name={entity} iceberg namespace {namespace} does not exist and create_database_if_missing is false")  # fmt: skip
-        with (
-            run_error("rest catalog namespace create failed"),
-            suppress(NamespaceAlreadyExistsError),
-        ):  # another entity or process created it first
-            catalog.create_namespace(ident)
     identifier = (namespace, name)
-    with run_error("rest catalog table_exists check failed"):
-        exists = catalog.table_exists(identifier)
-    if exists:
-        with run_error("rest catalog load_table failed"):
+    with run_error("rest catalog load_table failed"):
+        try:
             table = catalog.load_table(identifier)
-        added: list[NestedField] = []
-        if schema_evolution == "add_columns":
-            added = additive_columns(table.schema(), schema, entity)
-            # field ids of `schema` may differ from the table's once columns are added
-            check_schema = table.schema()
-        else:
-            check_schema_matches(table.schema(), schema, entity)
-            check_schema = schema
-        check_partition_spec_matches(
-            table.spec(),
+        except (
+            NoSuchTableError,
+            NoSuchNamespaceError,
+        ):  # fmt: skip -- a missing namespace raises either, per catalog
+            table = None
+    if table is None:
+        ident = (namespace,)
+        with run_error("rest catalog namespace_exists check failed"):
+            namespace_exists = catalog.namespace_exists(ident)
+        if not namespace_exists:
+            if not create_namespace:
+                raise FloeRunError(f"entity.name={entity} iceberg namespace {namespace} does not exist and create_database_if_missing is false")  # fmt: skip
+            with (
+                run_error("rest catalog namespace create failed"),
+                suppress(NamespaceAlreadyExistsError),
+            ):  # another entity or process created it first
+                catalog.create_namespace(ident)
+        spec = (
             None
             if partition_fields is None
-            else build_partition_spec(check_schema, partition_fields, entity),
-            entity,
+            else build_partition_spec(schema, partition_fields, entity)
         )
-        if added:
-            with run_error("rest catalog update_schema failed"):
-                with table.update_schema() as update:
-                    for field in added:
-                        update.add_column(field.name, field.field_type, required=False)
-                table.refresh()
-        return table, [f.name for f in added]
-    spec = (
+        with run_error("rest catalog create_table failed"):
+            created = catalog.create_table(  # pyright: ignore[reportUnknownMemberType] -- PyIceberg's `schema` is `Schema | Unknown`
+                identifier,
+                schema,
+                location=location,
+                partition_spec=spec if spec is not None else PartitionSpec(),
+            )
+        return created, []
+    added: list[NestedField] = []
+    if schema_evolution == "add_columns":
+        added = additive_columns(table.schema(), schema, entity)
+        # field ids of `schema` may differ from the table's once columns are added
+        check_schema = table.schema()
+    else:
+        check_schema_matches(table.schema(), schema, entity)
+        check_schema = schema
+    check_partition_spec_matches(
+        table.spec(),
         None
         if partition_fields is None
-        else build_partition_spec(schema, partition_fields, entity)
+        else build_partition_spec(check_schema, partition_fields, entity),
+        entity,
     )
-    with run_error("rest catalog create_table failed"):
-        created = catalog.create_table(  # pyright: ignore[reportUnknownMemberType] -- PyIceberg's `schema` is `Schema | Unknown`
-            identifier,
-            schema,
-            location=location,
-            partition_spec=spec if spec is not None else PartitionSpec(),
-        )
-    return created, []
+    if added:
+        with run_error("rest catalog update_schema failed"):
+            with table.update_schema() as update:
+                for field in added:
+                    update.add_column(field.name, field.field_type, required=False)
+            table.refresh()
+    return table, [f.name for f in added]

floe/iceberg/sink.py

@@ -15,6 +15,7 @@ from typing import Any
 import polars as pl
 import pyarrow as pa
 from pyiceberg.catalog import Catalog
+from pyiceberg.exceptions import NoSuchNamespaceError, NoSuchTableError
 from pyiceberg.schema import Schema, assign_fresh_schema_ids
 from pyiceberg.table import Table
 
@@ -39,6 +40,7 @@ from floe.iceberg.merge import merge_scd1, merge_scd2
 from floe.iceberg.write import (
     SMALL_FILE_THRESHOLD_BYTES,
     IcebergWriteResult,
+    parquet_properties,
     write_table,
 )
 from floe.storage.inputs import InputFile
@@ -176,13 +178,15 @@ def write_iceberg(
     primary_key = entity.schema_.primary_key or []  # validated non-empty for merges
     key = [output.get(k.strip(), k.strip()) for k in primary_key]
     identifier = (target.namespace, target.table)
-    with run_error("rest catalog table_exists check failed"):
-        # the configured mode: a refreshed merge writes as overwrite and keeps the key guard (#1091)
-        exists = entity.sink.write_mode in ("merge_scd1", "merge_scd2") and catalog.table_exists(identifier)  # fmt: skip
-    if exists:
+    # the configured mode: a refreshed merge writes as overwrite and keeps the key guard (#1091)
+    if entity.sink.write_mode in ("merge_scd1", "merge_scd2"):
         with run_error("rest catalog load_table failed"):
-            existing = set(catalog.load_table(identifier).schema().column_names)
-        if added := [k for k in key if k not in existing]:  # Rust `merge/shared.rs`
+            try:
+                existing = set(catalog.load_table(identifier).schema().column_names)
+            except (NoSuchTableError, NoSuchNamespaceError):
+                existing = None
+        # Rust `merge/shared.rs`
+        if existing is not None and (added := [k for k in key if k not in existing]):
             raise FloeRunError(f"entity.name={entity.name} iceberg schema evolution failed: merge key columns cannot be added: {', '.join(added)}")  # fmt: skip
     table, added = ensure_table(
         catalog, target.namespace, target.table, schema, entity.name, target.location.removeprefix("local://"),
@@ -215,7 +219,7 @@ def write_iceberg(
         threshold = SMALL_FILE_THRESHOLD_BYTES if size is None else max(1, size // 2)
         append = "overwrite" if mode == "overwrite" else "append"
         unique = [[output.get(c, c) for c in k] for k in resolve_unique_keys(entity.schema_.unique_keys, [c.name for c in entity.schema_.columns if c.unique], entity.schema_.primary_key)]  # fmt: skip
-        result = write_table(table, reader, append, run_id, digest, threshold, unique_keys=unique)  # fmt: skip
+        result = write_table(table, reader, append, run_id, digest, threshold, unique_keys=unique, parquet=parquet_properties(options and options.compression, options and options.row_group_size))  # fmt: skip
     ids = {"table_version": result.metadata_version, "snapshot_id": result.snapshot_id}
     fields = {k: v for k, v in ids.items() if v is not None} | {
         "iceberg_catalog_name": target.catalog.name,

floe/iceberg/write.py

@@ -5,7 +5,7 @@
 
 import itertools
 import uuid
-from collections.abc import Callable, Iterator, Sequence
+from collections.abc import Callable, Iterator, Mapping, Sequence
 from dataclasses import dataclass, replace
 from datetime import datetime
 from pathlib import PurePosixPath
@@ -18,9 +18,17 @@ from pyiceberg.io.pyarrow import (
     _check_pyarrow_schema_compatible,  # pyright: ignore[reportPrivateUsage] -- same check `Transaction.append` makes
     _dataframe_to_data_files,  # pyright: ignore[reportPrivateUsage] -- feeds one snapshot producer from many chunks
 )
-from pyiceberg.manifest import DataFile, DataFileContent, ManifestEntryStatus
+from pyiceberg.manifest import (
+    DataFile,
+    DataFileContent,
+    ManifestEntryStatus,
+    ManifestFile,
+)
 from pyiceberg.table import Table, TableProperties
-from pyiceberg.table.snapshots import ancestors_of
+from pyiceberg.table.snapshots import Operation, ancestors_of
+from pyiceberg.table.update.snapshot import (
+    _OverwriteFiles,  # pyright: ignore[reportPrivateUsage] -- PyIceberg 0.12 has no public hook on the manifest list
+)
 
 from floe.errors import FloeRunError
 from floe.iceberg.catalog import run_error
@@ -55,6 +63,14 @@ class IcebergWriteResult:
     )
 
 
+class _LiveOverwrite(_OverwriteFiles):
+    """PyIceberg 0.12 keeps the all-DELETED manifest of every earlier overwrite in the manifest list, one more per
+    overwrite, so the scan and the commit read more manifests each time (#1132); Java drops them, so do we."""
+
+    def _existing_manifests(self) -> list[ManifestFile]:
+        return [m for m in super()._existing_manifests() if m.has_added_files() or m.has_existing_files()]  # fmt: skip
+
+
 def _chunks(reader: pa.RecordBatchReader, chunk_rows: int) -> Iterator[pa.Table]:
     pending: list[pa.RecordBatch] = []
     rows = 0
@@ -72,6 +88,16 @@ def _chunks(reader: pa.RecordBatchReader, chunk_rows: int) -> Iterator[pa.Table]
         yield pa.Table.from_batches(pending, reader.schema)
 
 
+def parquet_properties(
+    compression: str | None, row_group_size: int | None
+) -> dict[str, str]:
+    """The sink's `compression` and `row_group_size` as PyIceberg's write properties; unset keeps the table's."""
+    props = {TableProperties.PARQUET_COMPRESSION: compression} if compression else {}
+    if row_group_size:
+        props[TableProperties.PARQUET_ROW_GROUP_LIMIT] = str(row_group_size)
+    return props
+
+
 def _metadata_version(location: str | None) -> int | None:
     prefix = PurePosixPath(location or "").name.split("-", 1)[0]
     return int(prefix) if prefix.isdigit() else None
@@ -86,22 +112,25 @@ def write_table(
     small_file_threshold_bytes: int = SMALL_FILE_THRESHOLD_BYTES,
     chunk_rows: int = CHUNK_ROWS,
     unique_keys: Sequence[Sequence[str]] = (),
+    parquet: Mapping[str, str] | None = None,
 ) -> IcebergWriteResult:
     """Data files are written chunk by chunk (partitioned tables split each chunk), then committed once.
 
     Overwrite replaces every existing file in the same snapshot. An append of no rows commits nothing.
     On a conflict an append checks `unique_keys` (table column names) against the files added since the base
     snapshot and fails closed, committing nothing, when a rival already holds a key (#549).
+    `parquet` holds `write.parquet.*` properties for these data files only; the table's own properties are not changed.
     """
     with run_error("iceberg data write failed"):
         _check_pyarrow_schema_compatible(table.schema(), reader.schema)
+        metadata = table.metadata.model_copy(update={"properties": {**table.properties, **(parquet or {})}})  # fmt: skip
         counter = itertools.count()
         write_uuid = uuid.uuid4()
         data_files: list[DataFile] = [
             data_file
             for chunk in _chunks(reader, chunk_rows)
             for data_file in _dataframe_to_data_files(
-                table.metadata, chunk, table.io, write_uuid, counter
+                metadata, chunk, table.io, write_uuid, counter
             )
         ]
     digest = (
@@ -131,13 +160,21 @@ def write_table(
                 # PyIceberg retries a 409 itself (refresh, rebuild) and would skip the guard; in memory only, never sent
                 table.metadata = table.metadata.model_copy(update={"properties": {**table.properties, TableProperties.COMMIT_NUM_RETRIES: "0"}})  # fmt: skip
                 tx = table.transaction()
-                update = tx.update_snapshot(
-                    snapshot_properties={RUN_ID: run_id, INPUT_HASH: digest}
-                )
+                props = {RUN_ID: run_id, INPUT_HASH: digest}
                 with (
-                    update.overwrite()
+                    _LiveOverwrite(
+                        operation=Operation.OVERWRITE
+                        if table.current_snapshot()
+                        else Operation.APPEND,
+                        transaction=tx,
+                        io=table.io,
+                        branch="main",
+                        snapshot_properties=props,
+                    )
                     if mode == "overwrite"
-                    else update.fast_append() as snap
+                    else tx.update_snapshot(
+                        snapshot_properties=props
+                    ).fast_append() as snap
                 ):
                     for old in replaced:
                         snap.delete_data_file(old)

floe/run/__init__.py

@@ -2,6 +2,7 @@
 
 import time
 from collections.abc import Sequence
+from concurrent.futures import ThreadPoolExecutor
 from dataclasses import dataclass
 from datetime import UTC, datetime
 from pathlib import Path
@@ -158,12 +159,15 @@ def run(
 
     emit("run_started", config=config, report_base=report_path)
     # Rust resolves every entity's inputs before the first entity_started (#864); run_entity reuses them
-    listed: dict[str, ResolvedInputs] = {}
-    for e in selected:
-        # D24: a full refresh may rebuild from the archive alone, so run_entity decides
-        archive = full_refresh and e.sink.archive and e.incremental_mode in ("none", "archive")  # fmt: skip
-        if not archive:
-            listed[e.id] = inputs(e)
+    # D24: a full refresh may rebuild from the archive alone, so run_entity decides
+    to_list = [e for e in selected if not (full_refresh and e.sink.archive and e.incremental_mode in ("none", "archive"))]  # fmt: skip
+    # `map` yields in config order, so the first failure in config order is raised
+    if workers > 1 and len(to_list) > 1:
+        with ThreadPoolExecutor(workers, thread_name_prefix="floe-list") as pool:
+            found = list(pool.map(inputs, to_list))
+    else:
+        found = [inputs(e) for e in to_list]
+    listed = {e.id: f for e, f in zip(to_list, found, strict=True)}
     client = storage_client(report_storage)
 
     def finish(e: EntityConfig) -> dict[str, Any]:

floe/run/entity.py

@@ -402,7 +402,8 @@ def _run_file(plan: _Plan, file: InputFile, path: Path, spill: Path) -> tuple[di
     def failed(err: FloeIoError, mismatch: MismatchOutcome | None) -> tuple[dict[str, Any], Iterable[pl.DataFrame]]:  # fmt: skip
         # Rust skips the raw copy under PII: the file cannot be masked
         plan.tracker.restore(keys)  # the unreadable file leaves no keys behind
-        keep = entity.pii is None and entity.sink.rejected is not None
+        # a file removed after listing has nothing to copy: the read error alone is reported
+        keep = entity.pii is None and entity.sink.rejected is not None and path.exists()
         raw = _copy_raw(plan, path, severity, file.source_name) if keep else None
         return _failed_file(entity, uri, len(declared) + len(derived), mismatch, err, raw), []  # fmt: skip
 

{floe_python-0.8.8.dist-info → floe_python-0.8.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: floe-python
-Version: 0.8.8
+Version: 0.8.9
 Summary: Floe: a data-contract runtime for file ingestion
 License-File: LICENSE
 Requires-Python: >=3.11

{floe_python-0.8.8.dist-info → floe_python-0.8.9.dist-info}/RECORD

@@ -15,7 +15,7 @@ floe/checks/cast.py,sha256=lM40xtKEggWI8FW3jijM3T2JFQtaXs8FhsFXo3vy5oM,6788
 floe/checks/mismatch.py,sha256=RNqRL1nihH6Y83RI-dxPXf0WTWZccXq6mnR4m6V0IIo,5827
 floe/checks/normalize.py,sha256=9fdRYFjWGXBAEw1Po71N5tsUWG8eekmSWIQktPduOig,4431
 floe/checks/rows.py,sha256=-yPieSus0-7ZewLv2vR8waHqQ9DGMbVvmJh1_hK4eDs,4433
-floe/checks/unique.py,sha256=qoZVqS_uG_mWZlV7-LdxT6_dMVQRlklEvMutO_V0qaY,12396
+floe/checks/unique.py,sha256=ZVckMOoGuKIzq3M84TGeZ1ks0nab9YTaI54w5Q_rjZc,10864
 floe/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 floe/config/entity.py,sha256=CLXLXzkUbQhxenD_LwjBt0eoPreaYaxiBVEsdmnFIco,15883
 floe/config/include.py,sha256=XKYhp2QK_VUmAODAXJ35Wl4FCpQEMQm24m-WKlpI_og,5033
@@ -27,12 +27,12 @@ floe/config/types.py,sha256=4eveoOlyGmNxyZpI1PSjli9lnXLPc1-jYj4fL8qHN_8,5038
 floe/config/validate.py,sha256=7tyofwoTBL-BBCNxnmkXeSOybwmMNngeEcj8zviRyLs,36176
 floe/config/vars.py,sha256=7Bq0IU0KrFeRlyA8W9-F0gDSDKfXCfFpBrX08H8Flvw,4577
 floe/config/yaml.py,sha256=HeFGhKFxYkiqQOwljYOgUD5naJyxL_ZIX6hUIS36tzU,10071
-floe/iceberg/catalog.py,sha256=R0IBTaLe80k49SUuVMoAw0j7Ira2EDgjjk3XHSISIGg,16573
+floe/iceberg/catalog.py,sha256=qEhMvH4NFBd4GxqBEg4jqgTNxtqWkL_RRzIlgXr2GmA,16722
 floe/iceberg/compact.py,sha256=5O372vAIsvgRc2PGihryAsrQ0otn0F30AQu-cetRCP0,7123
 floe/iceberg/merge.py,sha256=VE1Odf2B34Gxj7ZcuhbrfbgTGM9AdiDz6_2BbcQ-kSQ,12448
-floe/iceberg/sink.py,sha256=WyT6yrp5JQyfaqWES96NWh3V-EzgTD4Y-IjB84mZ9Sg,11842
+floe/iceberg/sink.py,sha256=vdkgLjqvWH7opOrfc-147xCMQhLnxRjUzLjHLchHlAM,12043
 floe/iceberg/unique.py,sha256=OmiPQthhB5jGTaXsCu9ZztNFEFUf6eT0MLU2Gnh-C2A,1095
-floe/iceberg/write.py,sha256=SRX5tb17zUeWwpg6uXKkVQ_muNJ2GqlQd0n-kmjWPVc,11141
+floe/iceberg/write.py,sha256=YNE8IwLV9jK3vksO0XCj36HKHqW6ZEHCu4173Xpi6hg,12854
 floe/lineage/events.py,sha256=4txd8bGUwKBZd-8Aw_ebTurhlxAYk8SVMgH8vSjC3bs,6682
 floe/lineage/observer.py,sha256=IFHjzsT65L-NkcQ8Noa_8CDVpLu4iGadRB2-K0Lj8t8,10216
 floe/read/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -45,8 +45,8 @@ floe/read/xlsx.py,sha256=dengSY8HuNh9ahyR_LR8beqXTZQubqQ1Jx8qEak5jrY,3009
 floe/read/xml.py,sha256=7m6DtoU8iExuLROavyojysqOUE_Bd_N0uwFaLAzjI_Y,8004
 floe/report/entity.py,sha256=FRwLtXrlJXDNXrOKscitm-NCNJWQXd0vr_JIf_cUp20,9867
 floe/report/summary.py,sha256=tb547VRkM5WGWHQ-4vZB2DUW4VTWgv9FUoym-NpuWE4,4452
-floe/run/__init__.py,sha256=leKCs7YOoPADLFzKzU8m-mdfmStbGz_VH9kAg12kzyo,8902
-floe/run/entity.py,sha256=e-IfES1ajZtIBrX9UnWDOpFHSoxjfYRtCBp63QavCFY,49653
+floe/run/__init__.py,sha256=yCLCoLbtA_Iuy7wabkFSImeuU8xrLp8Q0ZgYmw8WDRg,9229
+floe/run/entity.py,sha256=2NxCKNVUn0v2Oat4FslZfNjWAu3YhGKnSks3NRwkexU,49764
 floe/run/events.py,sha256=OE7zYkt0Dz2xrvgNavT1nHfZJ-97IIJ8LpHcameUJZU,2859
 floe/run/parallel.py,sha256=lKBW9NOpOu6KFOcEo-RQ56ukEOKHXPPoLI3o6gmlY_g,3435
 floe/storage/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -61,8 +61,8 @@ floe/storage/s3.py,sha256=XcG1qJTEY3KLSMLT950mUdrAxuCA8-Gx3fpNSzyV_Xo,7508
 floe/storage/types.py,sha256=FvAEXWMdVdopRK276JyETRYGOva2-uR8pZvsWj6Xvy0,993
 floe/write/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 floe/write/outputs.py,sha256=cXxGUIJnZ38XPaqEI6a83GFUsapBRdY52XQm3GlUPcI,6937
-floe_python-0.8.8.dist-info/METADATA,sha256=nkx-wlv0W9muP3wviq1E6TBG-fS7wPa1Szy7qjGig_E,442
-floe_python-0.8.8.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
-floe_python-0.8.8.dist-info/entry_points.txt,sha256=DU75r-E3zcK0quvwg5iT5DeWbUJck_Tz80bEj1IIzHA,40
-floe_python-0.8.8.dist-info/licenses/LICENSE,sha256=dUhuoK-TCRQMpuLEAdfme-qPSJI0TlcH9jlNxeg9_EQ,1056
-floe_python-0.8.8.dist-info/RECORD,,
+floe_python-0.8.9.dist-info/METADATA,sha256=jwfiIw93AklPynvV_-ABBNgnNCZjBArFMK4APsKu9Bk,442
+floe_python-0.8.9.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+floe_python-0.8.9.dist-info/entry_points.txt,sha256=DU75r-E3zcK0quvwg5iT5DeWbUJck_Tz80bEj1IIzHA,40
+floe_python-0.8.9.dist-info/licenses/LICENSE,sha256=dUhuoK-TCRQMpuLEAdfme-qPSJI0TlcH9jlNxeg9_EQ,1056
+floe_python-0.8.9.dist-info/RECORD,,