duckrun 0.2.13__py3-none-any.whl → 0.2.19.dev1__py3-none-any.whl

duckrun/stats.py

@@ -60,32 +60,89 @@ def _get_existing_tables_in_schema(duckrun_instance, schema_name: str) -> list:
         return []
 
 
-def get_stats(duckrun_instance, source: str):
+def _match_tables_by_pattern(duckrun_instance, pattern: str) -> dict:
+    """Match tables across all schemas using a wildcard pattern.
+    Pattern can be:
+    - '*.summary' - matches 'summary' table in all schemas
+    - '*summary' - matches any table ending with 'summary'
+    - 'schema.*' - matches all tables in 'schema'
+    Returns a dict mapping schema names to lists of matching table names."""
+    import fnmatch
+    
+    try:
+        # Query all schemas and tables in one go
+        query = """
+            SELECT table_schema, table_name 
+            FROM information_schema.tables 
+            WHERE table_schema NOT LIKE 'pg_%' 
+            AND table_schema != 'information_schema'
+            AND table_name NOT LIKE 'tbl_%'
+        """
+        result = duckrun_instance.con.execute(query).fetchall()
+        
+        matched = {}
+        
+        # Check if pattern contains a dot (schema.table pattern)
+        if '.' in pattern:
+            schema_pattern, table_pattern = pattern.split('.', 1)
+            for schema, table in result:
+                if fnmatch.fnmatch(schema, schema_pattern) and fnmatch.fnmatch(table, table_pattern):
+                    if schema not in matched:
+                        matched[schema] = []
+                    matched[schema].append(table)
+        else:
+            # Pattern matches only table names
+            for schema, table in result:
+                if fnmatch.fnmatch(table, pattern):
+                    if schema not in matched:
+                        matched[schema] = []
+                    matched[schema].append(table)
+        
+        return matched
+    except:
+        return {}
+
+
+def get_stats(duckrun_instance, source: str = None, detailed = False):
     """
     Get comprehensive statistics for Delta Lake tables.
     
     Args:
         duckrun_instance: The Duckrun connection instance
-        source: Can be one of:
+        source: Optional. Can be one of:
+               - None: Use all tables in the connection's schema (default)
                - Table name: 'table_name' (uses main schema in DuckDB)
                - Schema.table: 'schema.table_name' (specific table in schema, if multi-schema)
                - Schema only: 'schema' (all tables in schema, if multi-schema)
+               - Wildcard pattern: '*.summary' (matches tables across all schemas)
+        detailed: Optional. Controls the level of detail in statistics:
+                 - False (default): Aggregated table-level stats (total rows, file count, 
+                   row groups, average row group size, file sizes, VORDER status)
+                 - True: Row group level statistics with compression details, row group sizes,
+                   and parquet metadata
     
     Returns:
-        Arrow table with statistics including total rows, file count, row groups, 
-        average row group size, file sizes, VORDER status, and timestamp
+        DataFrame with statistics based on detailed parameter:
+        - If detailed=False: Aggregated table-level summary
+        - If detailed=True: Granular file and row group level stats
     
     Examples:
         con = duckrun.connect("tmp/data.lakehouse/test")
         
-        # Single table in main schema (DuckDB uses 'main', not 'test')
-        stats = con.get_stats('price_today')
+        # All tables in the connection's schema (aggregated)
+        stats = con.get_stats()
+        
+        # Single table with detailed row group statistics
+        stats_detailed = con.get_stats('price_today', detailed=True)
         
         # Specific table in different schema (only if multi-schema enabled)
         stats = con.get_stats('aemo.price')
         
         # All tables in a schema (only if multi-schema enabled)
         stats = con.get_stats('aemo')
+        
+        # Wildcard pattern across all schemas (only if multi-schema enabled)
+        stats = con.get_stats('*.summary')
     """
     timestamp = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
     
@@ -93,8 +150,31 @@ def get_stats(duckrun_instance, source: str):
     duckdb_schema = "main"
     url_schema = duckrun_instance.schema  # This is from the connection URL path
     
+    # If source is not provided, default to all tables in the connection's schema
+    if source is None:
+        source = url_schema
+    
+    # Check if source contains wildcard characters
+    if '*' in source or '?' in source:
+        # Wildcard pattern mode - only valid if multi-schema is enabled
+        if not duckrun_instance.scan_all_schemas:
+            raise ValueError(f"Wildcard pattern '{source}' not supported. Connection was made to a specific schema '{url_schema}'. Enable multi-schema mode to use wildcards.")
+        
+        matched_tables = _match_tables_by_pattern(duckrun_instance, source)
+        
+        if not matched_tables:
+            raise ValueError(f"No tables found matching pattern '{source}'")
+        
+        # Flatten the matched tables into a list with schema info
+        tables_with_schemas = []
+        for schema, tables in matched_tables.items():
+            for table in tables:
+                tables_with_schemas.append((schema, table))
+        
+        print(f"Found {len(tables_with_schemas)} tables matching pattern '{source}'")
+        
     # Parse the source and validate existence
-    if '.' in source:
+    elif '.' in source:
         # Format: schema.table - only valid if multi-schema is enabled
         schema_name, table_name = source.split('.', 1)
         
@@ -105,44 +185,45 @@ def get_stats(duckrun_instance, source: str):
         if not _table_exists(duckrun_instance, schema_name, table_name):
             raise ValueError(f"Table '{table_name}' does not exist in schema '{schema_name}'")
         
-        list_tables = [table_name]
+        tables_with_schemas = [(schema_name, table_name)]
     else:
         # Could be just table name or schema name
         if duckrun_instance.scan_all_schemas:
             # Multi-schema mode: DuckDB has actual schemas
             # First check if it's a table in main schema
             if _table_exists(duckrun_instance, duckdb_schema, source):
-                list_tables = [source]
-                schema_name = duckdb_schema
+                tables_with_schemas = [(duckdb_schema, source)]
             # Otherwise, check if it's a schema name
             elif _schema_exists(duckrun_instance, source):
                 schema_name = source
                 list_tables = _get_existing_tables_in_schema(duckrun_instance, source)
                 if not list_tables:
                     raise ValueError(f"Schema '{source}' exists but contains no tables")
+                tables_with_schemas = [(schema_name, tbl) for tbl in list_tables]
             else:
                 raise ValueError(f"Neither table '{source}' in main schema nor schema '{source}' exists")
         else:
             # Single-schema mode: tables are in DuckDB's main schema, use URL schema for file paths
             if _table_exists(duckrun_instance, duckdb_schema, source):
                 # It's a table name
-                list_tables = [source]
-                schema_name = url_schema  # Use URL schema for file path construction
+                tables_with_schemas = [(url_schema, source)]
             elif source == url_schema:
                 # Special case: user asked for stats on the URL schema name - list all tables
                 list_tables = _get_existing_tables_in_schema(duckrun_instance, duckdb_schema)
-                schema_name = url_schema  # Use URL schema for file path construction
                 if not list_tables:
                     raise ValueError(f"No tables found in schema '{url_schema}'")
+                tables_with_schemas = [(url_schema, tbl) for tbl in list_tables]
             else:
                 raise ValueError(f"Table '{source}' does not exist in the current context (schema: {url_schema})")
     
     # Use the existing connection
     con = duckrun_instance.con
     
-    print(f"Processing {len(list_tables)} tables: {list_tables}")
+    print(f"Processing {len(tables_with_schemas)} tables from {len(set(s for s, t in tables_with_schemas))} schema(s)")
     
-    for idx, tbl in enumerate(list_tables):
+    successful_tables = []
+    for idx, (schema_name, tbl) in enumerate(tables_with_schemas):
+        print(f"[{idx+1}/{len(tables_with_schemas)}] Processing table '{schema_name}.{tbl}'...")
         # Construct lakehouse path using correct ABFSS URL format (no .Lakehouse suffix)
         table_path = f"{duckrun_instance.table_base_url}{schema_name}/{tbl}"
         
@@ -169,8 +250,18 @@ def get_stats(duckrun_instance, source: str):
                     print(f"Warning: Could not convert RecordBatch for table '{tbl}': Unexpected type {type(add_actions)}")
                     xx = {}
             
-            # Check if VORDER exists
-            vorder = 'tags.VORDER' in xx.keys()
+            # Check if VORDER exists - handle both formats:
+            # 1. Flattened format: 'tags.VORDER' or 'tags.vorder' in keys
+            # 2. Nested format: check in 'tags' dict for 'VORDER' or 'vorder'
+            vorder = False
+            if 'tags.VORDER' in xx.keys() or 'tags.vorder' in xx.keys():
+                vorder = True
+            elif 'tags' in xx.keys() and xx['tags']:
+                # Check nested tags dictionary (tags is a list of dicts, one per file)
+                for tag_dict in xx['tags']:
+                    if tag_dict and ('VORDER' in tag_dict or 'vorder' in tag_dict):
+                        vorder = True
+                        break
             
             # Calculate total size
             total_size = sum(xx['size_bytes']) if xx['size_bytes'] else 0
@@ -185,66 +276,180 @@ def get_stats(duckrun_instance, source: str):
                 con.execute(f'''
                     CREATE OR REPLACE TEMP TABLE tbl_{idx} AS
                     SELECT 
+                        '{schema_name}' as schema,
                         '{tbl}' as tbl,
                         'empty' as file_name,
                         0 as num_rows,
                         0 as num_row_groups,
                         0 as size,
                         {vorder} as vorder,
+                        '' as compression,
                         '{timestamp}' as timestamp
                     WHERE false
                 ''')
             else:
-                # Get parquet metadata and create temp table
-                con.execute(f'''
-                    CREATE OR REPLACE TEMP TABLE tbl_{idx} AS
-                    SELECT 
-                        '{tbl}' as tbl,
-                        file_name,
-                        num_rows,
-                        num_row_groups,
-                        CEIL({total_size}/(1024*1024)) as size,
-                        {vorder} as vorder,
-                        '{timestamp}' as timestamp
-                    FROM parquet_file_metadata({delta})
-                ''')
+                # Get parquet metadata and create temp table with compression info
+                if detailed == True:
+                    # Detailed mode: Include ALL parquet_metadata columns
+                    con.execute(f'''
+                        CREATE OR REPLACE TEMP TABLE tbl_{idx} AS
+                        SELECT 
+                            '{schema_name}' as schema,
+                            '{tbl}' as tbl,
+                            {vorder} as vorder,
+                            pm.*,
+                            '{timestamp}' as timestamp
+                        FROM parquet_metadata({delta}) pm
+                    ''')
+                else:
+                    # Aggregated mode: Original summary statistics
+                    con.execute(f'''
+                        CREATE OR REPLACE TEMP TABLE tbl_{idx} AS
+                        SELECT 
+                            '{schema_name}' as schema,
+                            '{tbl}' as tbl,
+                            fm.file_name,
+                            fm.num_rows,
+                            fm.num_row_groups,
+                            CEIL({total_size}/(1024*1024)) as size,
+                            {vorder} as vorder,
+                            COALESCE(STRING_AGG(DISTINCT pm.compression, ', ' ORDER BY pm.compression), 'UNCOMPRESSED') as compression,
+                            '{timestamp}' as timestamp
+                        FROM parquet_file_metadata({delta}) fm
+                        LEFT JOIN parquet_metadata({delta}) pm ON fm.file_name = pm.file_name
+                        GROUP BY fm.file_name, fm.num_rows, fm.num_row_groups
+                    ''')
             
         except Exception as e:
-            print(f"Warning: Could not process table '{tbl}': {e}")
-            # Create empty temp table for failed tables
-            con.execute(f'''
-                CREATE OR REPLACE TEMP TABLE tbl_{idx} AS
-                SELECT 
-                    '{tbl}' as tbl,
-                    'error' as file_name,
-                    0 as num_rows,
-                    0 as num_row_groups,
-                    0 as size,
-                    false as vorder,
-                    '{timestamp}' as timestamp
-                WHERE false
-            ''')
+            error_msg = str(e)
+            print(f"Warning: Could not process table '{tbl}' using DeltaTable API: {e}")
+            
+            # Fallback: Use DuckDB's delta_scan with filename parameter
+            if "Invalid JSON" in error_msg or "MetadataValue" in error_msg:
+                print(f"   Detected JSON parsing issue - falling back to DuckDB delta_scan")
+            else:
+                print(f"   Falling back to DuckDB delta_scan")
+            
+            try:
+                # First get the list of actual parquet files using delta_scan
+                file_list_result = con.execute(f'''
+                    SELECT DISTINCT filename 
+                    FROM delta_scan('{table_path}', filename=1)
+                ''').fetchall()
+                
+                if not file_list_result:
+                    # Empty table
+                    con.execute(f'''
+                        CREATE OR REPLACE TEMP TABLE tbl_{idx} AS
+                        SELECT 
+                            '{schema_name}' as schema,
+                            '{tbl}' as tbl,
+                            'empty' as file_name,
+                            0 as num_rows,
+                            0 as num_row_groups,
+                            0 as size,
+                            false as vorder,
+                            '' as compression,
+                            '{timestamp}' as timestamp
+                        WHERE false
+                    ''')
+                else:
+                    # Extract just the filename (not the full path) from delta_scan results
+                    # delta_scan returns full ABFSS paths, we need to extract just the filename part
+                    filenames = []
+                    for row in file_list_result:
+                        full_path = row[0]
+                        # Extract just the filename from the full ABFSS path
+                        if '/' in full_path:
+                            filename = full_path.split('/')[-1]
+                        else:
+                            filename = full_path
+                        filenames.append(table_path + "/" + filename)
+                    
+                    # Use parquet_file_metadata to get actual parquet stats with compression
+                    if detailed == True:
+                        # Detailed mode: Include ALL parquet_metadata columns
+                        con.execute(f'''
+                            CREATE OR REPLACE TEMP TABLE tbl_{idx} AS
+                            SELECT 
+                                '{schema_name}' as schema,
+                                '{tbl}' as tbl,
+                                false as vorder,
+                                pm.*,
+                                '{timestamp}' as timestamp
+                            FROM parquet_metadata({filenames}) pm
+                        ''')
+                    else:
+                        # Aggregated mode: Original summary statistics
+                        con.execute(f'''
+                            CREATE OR REPLACE TEMP TABLE tbl_{idx} AS
+                            SELECT 
+                                '{schema_name}' as schema,
+                                '{tbl}' as tbl,
+                                fm.file_name,
+                                fm.num_rows,
+                                fm.num_row_groups,
+                                0 as size,
+                                false as vorder,
+                                COALESCE(STRING_AGG(DISTINCT pm.compression, ', ' ORDER BY pm.compression), 'UNCOMPRESSED') as compression,
+                                '{timestamp}' as timestamp
+                            FROM parquet_file_metadata({filenames}) fm
+                            LEFT JOIN parquet_metadata({filenames}) pm ON fm.file_name = pm.file_name
+                            GROUP BY fm.file_name, fm.num_rows, fm.num_row_groups
+                        ''')
+                
+                print(f"   ✓ Successfully processed '{tbl}' using DuckDB fallback with parquet metadata")
+            except Exception as fallback_error:
+                print(f"   ✗ DuckDB fallback also failed for '{tbl}': {fallback_error}")
+                print(f"   ⏭️  Skipping table '{tbl}'")
+                continue
+        
+        # Mark this table as successfully processed
+        successful_tables.append(idx)
+    
+    # Only union tables that were successfully processed
+    if not successful_tables:
+        # No tables were processed successfully - return empty dataframe
+        print("⚠️  No tables could be processed successfully")
+        import pandas as pd
+        if detailed == True:
+            return pd.DataFrame(columns=['schema', 'tbl', 'vorder', 'timestamp'])
+        else:
+            return pd.DataFrame(columns=['schema', 'tbl', 'total_rows', 'num_files', 'num_row_group', 
+                                         'average_row_group', 'file_size_MB', 'vorder', 'compression', 'timestamp'])
     
-    # Union all temp tables
-    union_parts = [f'SELECT * FROM tbl_{i}' for i in range(len(list_tables))]
+    # Union all successfully processed temp tables
+    union_parts = [f'SELECT * FROM tbl_{i}' for i in successful_tables]
     union_query = ' UNION ALL '.join(union_parts)
     
-    # Generate final summary
-    final_result = con.execute(f'''
-        SELECT 
-            tbl,
-            SUM(num_rows) as total_rows,
-            COUNT(*) as num_files,
-            SUM(num_row_groups) as num_row_group,
-            CAST(CEIL(SUM(num_rows)::DOUBLE / NULLIF(SUM(num_row_groups), 0)) AS INTEGER) as average_row_group,
-            MIN(size) as file_size_MB,
-            ANY_VALUE(vorder) as vorder,
-            ANY_VALUE(timestamp) as timestamp
-        FROM ({union_query})
-        WHERE tbl IS NOT NULL
-        GROUP BY tbl
-        ORDER BY total_rows DESC
-    ''').df()
+    # Generate final summary based on detailed flag
+    if detailed == True:
+        # Detailed mode: Return ALL parquet_metadata columns
+        final_result = con.execute(f'''
+            SELECT *
+            FROM ({union_query})
+            WHERE tbl IS NOT NULL
+            ORDER BY schema, tbl, file_name, row_group_id, column_id
+        ''').df()
+    else:
+        # Aggregated mode: Original summary statistics
+        final_result = con.execute(f'''
+            SELECT 
+                schema,
+                tbl,
+                SUM(num_rows) as total_rows,
+                COUNT(*) as num_files,
+                SUM(num_row_groups) as num_row_group,
+                CAST(CEIL(SUM(num_rows)::DOUBLE / NULLIF(SUM(num_row_groups), 0)) AS INTEGER) as average_row_group,
+                MIN(size) as file_size_MB,
+                ANY_VALUE(vorder) as vorder,
+                STRING_AGG(DISTINCT compression, ', ' ORDER BY compression) as compression,
+                ANY_VALUE(timestamp) as timestamp
+            FROM ({union_query})
+            WHERE tbl IS NOT NULL
+            GROUP BY schema, tbl
+            ORDER BY total_rows DESC
+        ''').df()
     
     return final_result
 

duckrun/writer.py

@@ -3,6 +3,20 @@ Delta Lake writer functionality for duckrun - Spark-style write API
 """
 from deltalake import DeltaTable, write_deltalake, __version__ as deltalake_version
 
+# Try to import WriterProperties for Rust engine (available in 0.18.2+)
+try:
+    from deltalake.writer import WriterProperties
+    _HAS_WRITER_PROPERTIES = True
+except ImportError:
+    _HAS_WRITER_PROPERTIES = False
+
+# Try to import PyArrow dataset for old PyArrow engine
+try:
+    import pyarrow.dataset as ds
+    _HAS_PYARROW_DATASET = True
+except ImportError:
+    _HAS_PYARROW_DATASET = False
+
 
 # Row Group configuration for optimal Delta Lake performance
 RG = 8_000_000
@@ -23,12 +37,14 @@ def _build_write_deltalake_args(path, df, mode, schema_mode=None, partition_by=N
     - Has max_rows_per_file/max_rows_per_group/min_rows_per_group for optimization
     - When mergeSchema=True: must set schema_mode='merge' + engine='rust', NO row group params
     - When mergeSchema=False: use row group params, DON'T set engine (pyarrow is default)
+    - COMPRESSION: Defaults to ZSTD via writer_properties (rust) or file_options (pyarrow)
     
     deltalake 0.20+:
     - Does NOT have 'engine' parameter (everything is rust, pyarrow deprecated)
     - Does NOT have max_rows_per_file (row group optimization removed)
     - When mergeSchema=True: must set schema_mode='merge'
     - When mergeSchema=False: just write normally (no special params)
+    - COMPRESSION: Defaults to ZSTD via writer_properties (rust only)
     
     Uses version detection for simpler logic.
     """
@@ -50,7 +66,13 @@ def _build_write_deltalake_args(path, df, mode, schema_mode=None, partition_by=N
             # deltalake 0.18.2-0.19.x: must also set engine='rust' for schema merging
             # Do NOT use row group params (they conflict with rust engine)
             args['engine'] = 'rust'
-        # For version 0.20+: just schema_mode='merge' is enough, rust is default
+            # Set ZSTD compression for Rust engine
+            if _HAS_WRITER_PROPERTIES:
+                args['writer_properties'] = WriterProperties(compression='ZSTD')
+        else:
+            # Version 0.20+: rust is default, just add compression
+            if _HAS_WRITER_PROPERTIES:
+                args['writer_properties'] = WriterProperties(compression='ZSTD')
     else:
         # Normal write mode (no schema merging)
         if _IS_OLD_DELTALAKE:
@@ -59,7 +81,14 @@ def _build_write_deltalake_args(path, df, mode, schema_mode=None, partition_by=N
             args['max_rows_per_file'] = RG
             args['max_rows_per_group'] = RG
             args['min_rows_per_group'] = RG
-        # For version 0.20+: no optimization available (rust by default, no row group params supported)
+            # Set ZSTD compression for PyArrow engine
+            if _HAS_PYARROW_DATASET:
+                args['file_options'] = ds.ParquetFileFormat().make_write_options(compression='ZSTD')
+        else:
+            # Version 0.20+: no optimization available (rust by default, no row group params supported)
+            # Set ZSTD compression for Rust engine
+            if _HAS_WRITER_PROPERTIES:
+                args['writer_properties'] = WriterProperties(compression='ZSTD')
     
     return args
 
@@ -135,14 +164,14 @@ class DeltaWriter:
         # Prepare info message based on version and settings
         if self._schema_mode == 'merge':
             if _IS_OLD_DELTALAKE:
-                engine_info = " (engine=rust, schema_mode=merge)"
+                engine_info = " (engine=rust, schema_mode=merge, compression=ZSTD)"
             else:
-                engine_info = " (schema_mode=merge, rust by default)"
+                engine_info = " (schema_mode=merge, rust by default, compression=ZSTD)"
         else:
             if _IS_OLD_DELTALAKE:
-                engine_info = " (engine=pyarrow, optimized row groups)"
+                engine_info = " (engine=pyarrow, optimized row groups, compression=ZSTD)"
             else:
-                engine_info = " (engine=rust by default)"
+                engine_info = " (engine=rust by default, compression=ZSTD)"
         
         partition_info = f" partitioned by {self._partition_by}" if self._partition_by else ""
         print(f"Writing to Delta table: {schema}.{table} (mode={self._mode}){engine_info}{partition_info}")

{duckrun-0.2.13.dist-info → duckrun-0.2.19.dev1.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: duckrun
-Version: 0.2.13
-Summary: Lakehouse task runner powered by DuckDB for Microsoft Fabric
+Version: 0.2.19.dev1
+Summary: Helper library for Fabric Python using duckdb, arrow and delta_rs (orchestration, queries, etc.)
 Author: mim
 License: MIT
 Project-URL: Homepage, https://github.com/djouallah/duckrun
@@ -10,7 +10,7 @@ Project-URL: Issues, https://github.com/djouallah/duckrun/issues
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: duckdb>=1.2.2
+Requires-Dist: duckdb>=1.2.0
 Requires-Dist: deltalake<=0.18.2
 Requires-Dist: requests>=2.28.0
 Requires-Dist: obstore>=0.2.0

duckrun-0.2.19.dev1.dist-info/RECORD

@@ -0,0 +1,15 @@
+duckrun/__init__.py,sha256=-DPOb_ETaBC0M7YqXj482FE1aZ-SxJeSeY6KB6hPgWU,350
+duckrun/auth.py,sha256=EMaf-L2zeNOjbHOT97xYxfZNfWo4WrwrU1h3vBQTgEc,9624
+duckrun/core.py,sha256=jpg1okp6-Y4HubTJmSjyT9uhUc5pFr4A0tcNxNujSig,69086
+duckrun/files.py,sha256=Fvdjg3DyHJzIVzKo8M_j-eGz4zU61lOB38Y_onbQJkI,10137
+duckrun/lakehouse.py,sha256=j--Z3zo8AOWt1GF9VzRosmmTAy6ey2D0LVubti58twU,14109
+duckrun/notebook.py,sha256=lzDRBoWZ_lePF-_5BbA1_42BImLZC5yrq6nzlmlKglM,12183
+duckrun/runner.py,sha256=NGVyerJA44UP2umRdndfL0fuFM_gdOZmuJUz-PLOFf0,13461
+duckrun/semantic_model.py,sha256=shRPBN1II60K_PH8JOqke-_3hAwLspcx4Add0VJRwwU,35913
+duckrun/stats.py,sha256=8Qc9Mimvv7ALbOHw5-UPWrSflFrGrtkCQkB0QYL8jCw,21923
+duckrun/writer.py,sha256=wIsU77DSj4J7d9_bIhvk6AbC51uUrLW0e6pcSPQOY1c,9424
+duckrun-0.2.19.dev1.dist-info/licenses/LICENSE,sha256=-DeQQwdbCbkB4507ZF3QbocysB-EIjDtaLexvqRkGZc,1083
+duckrun-0.2.19.dev1.dist-info/METADATA,sha256=RvjFSOTabsqOYCk2ApzQ5ichMistEScyLKnrn61ODRs,20807
+duckrun-0.2.19.dev1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+duckrun-0.2.19.dev1.dist-info/top_level.txt,sha256=BknMEwebbUHrVAp3SC92ps8MPhK7XSYsaogTvi_DmEU,8
+duckrun-0.2.19.dev1.dist-info/RECORD,,

duckrun-0.2.13.dist-info/RECORD

@@ -1,14 +0,0 @@
-duckrun/__init__.py,sha256=cTj6KQ6hKmgu1z7k9nhDcO5lct049luxjx1V0QnymCo,235
-duckrun/auth.py,sha256=dMqIzozgEQ5v7Uc3Mb_OoFZGmsAq0m-VOoYCVL7rehc,9281
-duckrun/core.py,sha256=C5nnL-MheBfJPcw-Jr8t14jsm2iwMF07cYm8g_AXtFQ,52303
-duckrun/files.py,sha256=Fvdjg3DyHJzIVzKo8M_j-eGz4zU61lOB38Y_onbQJkI,10137
-duckrun/lakehouse.py,sha256=j--Z3zo8AOWt1GF9VzRosmmTAy6ey2D0LVubti58twU,14109
-duckrun/runner.py,sha256=yrDxfy1RVkb8iK9GKGmIFZHzCvcO_0GVQlbng7Vw_iM,14171
-duckrun/semantic_model.py,sha256=obzlN2-dbEW3JmDop-vrZGGGLi9u3ThhTbgtDjou7uY,29509
-duckrun/stats.py,sha256=oKIjZ7u5cFVT63FuOl5UqoDsOG3098woSCn-uI6i_sQ,11084
-duckrun/writer.py,sha256=svUuPCYOhrz299NgnpTKhARKjfej0PxnoND2iPDSypk,8098
-duckrun-0.2.13.dist-info/licenses/LICENSE,sha256=-DeQQwdbCbkB4507ZF3QbocysB-EIjDtaLexvqRkGZc,1083
-duckrun-0.2.13.dist-info/METADATA,sha256=0r-l8dWnd8KLBGj7cspK53eUdaDeUG-iHsa74rGBaCo,20766
-duckrun-0.2.13.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-duckrun-0.2.13.dist-info/top_level.txt,sha256=BknMEwebbUHrVAp3SC92ps8MPhK7XSYsaogTvi_DmEU,8
-duckrun-0.2.13.dist-info/RECORD,,