FlowerPower 0.11.6.12__tar.gz → 0.11.6.14__tar.gz

{flowerpower-0.11.6.12/src/FlowerPower.egg-info → flowerpower-0.11.6.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: FlowerPower
-Version: 0.11.6.12
+Version: 0.11.6.14
 Summary: A simple workflow framework. Hamilton + APScheduler = FlowerPower
 Author-email: "Volker L." <ligno.blades@gmail.com>
 Project-URL: Homepage, https://github.com/legout/flowerpower

{flowerpower-0.11.6.12 → flowerpower-0.11.6.14}/pyproject.toml

@@ -4,7 +4,7 @@ description = "A simple workflow framework. Hamilton + APScheduler = FlowerPower
 authors = [{ name = "Volker L.", email = "ligno.blades@gmail.com" }]
 readme = "README.md"
 requires-python = ">= 3.11"
-version = "0.11.6.12"
+version = "0.11.6.14"
 keywords = [
   "hamilton",
   "workflow",

{flowerpower-0.11.6.12 → flowerpower-0.11.6.14/src/FlowerPower.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: FlowerPower
-Version: 0.11.6.12
+Version: 0.11.6.14
 Summary: A simple workflow framework. Hamilton + APScheduler = FlowerPower
 Author-email: "Volker L." <ligno.blades@gmail.com>
 Project-URL: Homepage, https://github.com/legout/flowerpower

{flowerpower-0.11.6.12 → flowerpower-0.11.6.14}/src/flowerpower/fs/ext.py

@@ -951,7 +951,7 @@ def _read_parquet(
         if isinstance(tables, list):
             if len(tables) > 1:
                 schemas = [t.schema for t in tables]
-                unified_schema = unify_schemas_pa(schemas)
+                unified_schema = unify_schemas_pa(schemas, standardize_timezones=True)
                 tables = [cast_schema(t, unified_schema) for t in tables]
 
             tables = [table for table in tables if table.num_rows > 0]
@@ -1095,7 +1095,7 @@ def _read_parquet_batches(
             # Unify schemas before concatenation
             if len(batch_tables) > 1:
                 schemas = [t.schema for t in batch_tables]
-                unified_schema = unify_schemas_pa(schemas)
+                unified_schema = unify_schemas_pa(schemas, standardize_timezones=True)
                 batch_tables = [cast_schema(t, unified_schema) for t in batch_tables]
             batch_tables = [table for table in batch_tables if table.num_rows > 0]
             if not batch_tables:

{flowerpower-0.11.6.12 → flowerpower-0.11.6.14}/src/flowerpower/plugins/io/helpers/pyarrow.py

@@ -28,18 +28,133 @@ F32_MIN = float(np.finfo(np.float32).min)
 F32_MAX = float(np.finfo(np.float32).max)
 
 
+def dominant_timezone_per_column(
+    schemas: list[pa.Schema],
+) -> dict[str, tuple[str | None, str | None]]:
+    """
+    For each timestamp column (by name) across all schemas, detect the most frequent timezone (including None).
+    If None and a timezone are tied, prefer the timezone.
+    Returns a dict: {column_name: dominant_timezone}
+    """
+    from collections import Counter, defaultdict
+
+    tz_counts = defaultdict(Counter)
+    units = {}
+
+    for schema in schemas:
+        for field in schema:
+            if pa.types.is_timestamp(field.type):
+                tz = field.type.tz
+                name = field.name
+                tz_counts[name][tz] += 1
+                # Track unit for each column (assume consistent)
+                if name not in units:
+                    units[name] = field.type.unit
+
+    dominant = {}
+    for name, counter in tz_counts.items():
+        most_common = counter.most_common()
+        if not most_common:
+            continue
+        top_count = most_common[0][1]
+        # Find all with top_count
+        top_tzs = [tz for tz, cnt in most_common if cnt == top_count]
+        # If tie and one is not None, prefer not-None
+        if len(top_tzs) > 1 and any(tz is not None for tz in top_tzs):
+            tz = next(tz for tz in top_tzs if tz is not None)
+        else:
+            tz = most_common[0][0]
+        dominant[name] = (units[name], tz)
+    return dominant
+
+
+def standardize_schema_timezones_by_majority(
+    schemas: list[pa.Schema],
+) -> list[pa.Schema]:
+    """
+    For each timestamp column (by name) across all schemas, set the timezone to the most frequent (with tie-breaking).
+    Returns a new list of schemas with updated timestamp timezones.
+    """
+    dom = dominant_timezone_per_column(schemas)
+    new_schemas = []
+    for schema in schemas:
+        fields = []
+        for field in schema:
+            if pa.types.is_timestamp(field.type) and field.name in dom:
+                unit, tz = dom[field.name]
+                fields.append(
+                    pa.field(
+                        field.name,
+                        pa.timestamp(unit, tz),
+                        field.nullable,
+                        field.metadata,
+                    )
+                )
+            else:
+                fields.append(field)
+        new_schemas.append(pa.schema(fields, schema.metadata))
+    return new_schemas
+
+
+def standardize_schema_timezones(
+    schemas: list[pa.Schema], timezone: str | None = None
+) -> list[pa.Schema]:
+    """
+    Standardize timezone info for all timestamp columns in a list of PyArrow schemas.
+
+    Args:
+        schemas (list of pa.Schema): List of PyArrow schemas.
+        timezone (str or None): If None, remove timezone from all timestamp columns.
+                                If str, set this timezone for all timestamp columns.
+                                If "auto", use the most frequent timezone across schemas.
+
+    Returns:
+        list of pa.Schema: New schemas with standardized timezone info.
+    """
+    if timezone == "auto":
+        # Use the most frequent timezone for each column
+        return standardize_schema_timezones_by_majority(schemas)
+    new_schemas = []
+    for schema in schemas:
+        fields = []
+        for field in schema:
+            if pa.types.is_timestamp(field.type):
+                fields.append(
+                    pa.field(
+                        field.name,
+                        pa.timestamp(field.type.unit, timezone),
+                        field.nullable,
+                        field.metadata,
+                    )
+                )
+            else:
+                fields.append(field)
+        new_schemas.append(pa.schema(fields, schema.metadata))
+    return new_schemas
+
+
 def unify_schemas(
-    schemas: list[pa.Schema], use_large_dtypes: bool = False
+    schemas: list[pa.Schema],
+    use_large_dtypes: bool = False,
+    timezone: str | None = None,
+    standardize_timezones: bool = True,
 ) -> pa.Schema:
     """
     Unify a list of PyArrow schemas into a single schema.
 
     Args:
         schemas (list[pa.Schema]): List of PyArrow schemas to unify.
+        use_large_dtypes (bool): If True, keep large types like large_string.
+        timezone (str | None): If specified, standardize all timestamp columns to this timezone.
+            If "auto", use the most frequent timezone across schemas.
+            If None, remove timezone from all timestamp columns.
+        standardize_timezones (bool): If True, standardize all timestamp columns to the most frequent timezone.
 
     Returns:
         pa.Schema: A unified PyArrow schema.
     """
+    if standardize_timezones:
+        schemas = standardize_schema_timezones(schemas, timezone)
     try:
         return pa.unify_schemas(schemas, promote_options="permissive")
     except (pa.lib.ArrowInvalid, pa.lib.ArrowTypeError) as e:
@@ -189,7 +304,7 @@ def _can_downcast_to_float32(array: pa.Array) -> bool:
     return F32_MIN <= min_val <= max_val <= F32_MAX
 
 
-def _get_optimal_int_type(array: pa.Array) -> pa.DataType:
+def _get_optimal_int_type(array: pa.Array, allow_unsigned: bool) -> pa.DataType:
     """
     Determine the most efficient integer type based on data range.
     """
@@ -202,7 +317,8 @@ def _get_optimal_int_type(array: pa.Array) -> pa.DataType:
     min_val = min_max["min"].as_py()
     max_val = min_max["max"].as_py()
 
-    if min_val >= 0:  # Unsigned
+    if allow_unsigned and min_val >= 0:
+        # If allow_unsigned is True, check for unsigned types
         if max_val <= 255:
             return pa.uint8()
         elif max_val <= 65535:
@@ -211,6 +327,7 @@ def _get_optimal_int_type(array: pa.Array) -> pa.DataType:
             return pa.uint32()
         else:
             return pa.uint64()
+
     else:  # Signed
         if -128 <= min_val and max_val <= 127:
             return pa.int8()
@@ -222,7 +339,9 @@ def _get_optimal_int_type(array: pa.Array) -> pa.DataType:
             return pa.int64()
 
 
-def _optimize_numeric_array(array: pa.Array, shrink: bool) -> pa.Array:
+def _optimize_numeric_array(
+    array: pa.Array, shrink: bool, allow_unsigned: bool = True
+) -> pa.Array:
     """
     Optimize numeric PyArrow array by downcasting when possible.
     Uses vectorized operations for efficiency.
@@ -242,7 +361,7 @@ def _optimize_numeric_array(array: pa.Array, shrink: bool) -> pa.Array:
         if array.type in [pa.int8(), pa.uint8()]:
             return array
 
-        optimal_type = _get_optimal_int_type(array)
+        optimal_type = _get_optimal_int_type(array, allow_unsigned)
         return pc.cast(array, optimal_type)
 
     # Default: return unchanged
@@ -333,7 +452,11 @@ def _optimize_string_array(
 
 
 def _process_column(
-    table: pa.Table, col_name: str, shrink_numerics: bool, time_zone: str | None = None
+    table: pa.Table,
+    col_name: str,
+    shrink_numerics: bool,
+    allow_unsigned: bool,
+    time_zone: str | None = None,
 ) -> pa.Array:
     """
     Process a single column for type optimization.
@@ -346,7 +469,7 @@ def _process_column(
 
     # Process based on current type
     if pa.types.is_floating(array.type) or pa.types.is_integer(array.type):
-        return _optimize_numeric_array(array, shrink_numerics)
+        return _optimize_numeric_array(array, shrink_numerics, allow_unsigned)
     elif pa.types.is_string(array.type):
         return _optimize_string_array(array, col_name, shrink_numerics, time_zone)
 
@@ -360,6 +483,7 @@ def opt_dtype(
     exclude: str | list[str] | None = None,
     time_zone: str | None = None,
     shrink_numerics: bool = True,
+    allow_unsigned: bool = True,
     strict: bool = False,
 ) -> pa.Table:
     """
@@ -376,6 +500,7 @@ def opt_dtype(
         exclude: Column(s) to exclude from optimization
         time_zone: Optional time zone for datetime parsing
         shrink_numerics: Whether to downcast numeric types when possible
+        allow_unsigned: Whether to allow unsigned types
         strict: If True, will raise an error if any column cannot be optimized
 
     Returns:
@@ -401,7 +526,9 @@ def opt_dtype(
             try:
                 # Process column for optimization
                 new_columns.append(
-                    _process_column(table, col_name, shrink_numerics, time_zone)
+                    _process_column(
+                        table, col_name, shrink_numerics, allow_unsigned, time_zone
+                    )
                 )
             except Exception as e:
                 if strict: