duckrun 0.2.21.dev2__tar.gz → 0.2.22.dev2__tar.gz

{duckrun-0.2.21.dev2 → duckrun-0.2.22.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: duckrun
-Version: 0.2.21.dev2
+Version: 0.2.22.dev2
 Summary: Helper library for Fabric Python using duckdb, arrow and delta_rs (orchestration, queries, etc.)
 Author: mim
 License: MIT

{duckrun-0.2.21.dev2 → duckrun-0.2.22.dev2}/duckrun/__init__.py

@@ -2,11 +2,10 @@
 
 from duckrun.core import Duckrun
 from duckrun.notebook import import_notebook_from_web, import_notebook
-from duckrun import rle
 
-__version__ = "0.2.18"
+__version__ = "0.2.22.dev2"
 
 # Expose unified connect method at module level
 connect = Duckrun.connect
 
-__all__ = ["Duckrun", "connect", "import_notebook_from_web", "import_notebook", "rle"]
+__all__ = ["Duckrun", "connect", "import_notebook_from_web", "import_notebook"]

{duckrun-0.2.21.dev2 → duckrun-0.2.22.dev2}/duckrun/core.py

@@ -7,7 +7,7 @@ import time
 from typing import List, Tuple, Union, Optional, Callable, Dict, Any
 from string import Template
 from datetime import datetime
-from .stats import get_stats as _get_stats
+from .stats import get_stats as _get_stats, get_rle as _get_rle
 from .runner import run as _run
 from .files import copy as _copy, download as _download
 from .writer import QueryResult
@@ -1050,6 +1050,98 @@ class Duckrun(WorkspaceOperationsMixin):
         """
         self.con.register(name, df)
 
+    def get_rle_stats(self, table_name: str, top_n_values: int = 10):
+        """
+        Get comprehensive table statistics including NDV and value frequency analysis.
+        
+        Analyzes column characteristics for RLE compression optimization.
+        
+        Args:
+            table_name: Name of the table to analyze
+            top_n_values: Number of top frequent values to show per column (default: 10)
+        
+        Returns:
+            DataFrame with statistics for each column:
+            - column_name: Name of the column
+            - data_type: Data type
+            - total_rows: Total number of rows
+            - null_count, null_pct: NULL statistics
+            - ndv: Number of distinct values (exact)
+            - cardinality_ratio: NDV / total_rows (lower = better for RLE)
+            - top_value, top_value_count, top_value_pct: Most frequent value stats
+            - top_n_coverage: Percentage covered by top N values
+            - repetition_score: RLE potential score (higher = better)
+        
+        Examples:
+            con = duckrun.connect("workspace/lakehouse.lakehouse")
+            
+            # Analyze a table
+            stats = con.get_rle_stats('sales')
+            print(stats)
+            
+            # Show top 20 values per column
+            stats = con.get_rle_stats('sales', top_n_values=20)
+        """
+        from .rle import get_table_stats as _get_rle_stats
+        return _get_rle_stats(self, table_name, top_n_values)
+    
+    def get_value_frequency(self, table_name: str, column_name: str, limit: int = 20):
+        """
+        Get detailed value frequency distribution for a specific column.
+        
+        Args:
+            table_name: Name of the table
+            column_name: Name of the column to analyze
+            limit: Maximum number of values to return (default: 20)
+        
+        Returns:
+            DataFrame with value frequencies:
+            - value: The distinct value
+            - count: Number of occurrences
+            - percentage: Percentage of total rows
+            - cumulative_pct: Cumulative percentage
+        
+        Examples:
+            con = duckrun.connect("workspace/lakehouse.lakehouse")
+            
+            # Get top 20 values for a column
+            freq = con.get_value_frequency('sales', 'status')
+            print(freq)
+        """
+        from .rle import get_value_frequency_details as _get_value_frequency
+        return _get_value_frequency(self, table_name, column_name, limit)
+    
+    def find_optimal_sort_order(self, table_name: str, max_combinations: int = 10):
+        """
+        Find optimal column sort order for compression using V-Order-like testing.
+        
+        Tests different column orderings and measures RLE compression effectiveness.
+        This simulates how V-Order/VertiPaq optimizes data layout.
+        
+        Args:
+            table_name: Name of the table to analyze
+            max_combinations: Maximum sort orderings to test (default: 10)
+        
+        Returns:
+            DataFrame with tested orderings ranked by compression:
+            - sort_order: Column ordering (e.g., "date → DUID → time")
+            - total_runs: Total RLE runs (fewer = better compression)
+            - compression_score: Compression effectiveness (higher = better)
+            - Individual RLE counts per column
+        
+        Examples:
+            con = duckrun.connect("workspace/lakehouse.lakehouse")
+            
+            # Find optimal sort order
+            optimal = con.find_optimal_sort_order('energy_data')
+            print(optimal)
+            
+            # Test more combinations
+            optimal = con.find_optimal_sort_order('energy_data', max_combinations=20)
+        """
+        from .rle import find_optimal_sort_order as _find_optimal_sort_order
+        return _find_optimal_sort_order(self, table_name, max_combinations)
+
     def get_stats(self, source: str = None, detailed = False):
         """
         Get comprehensive statistics for Delta Lake tables.
@@ -1089,6 +1181,39 @@ class Duckrun(WorkspaceOperationsMixin):
         """
         return _get_stats(self, source, detailed)
 
+    def get_rle(self, source: str = None):
+        """
+        Get RLE (Run-Length Encoding) statistics for Delta Lake tables.
+        Measures compression potential by counting consecutive identical values.
+        
+        Args:
+            source: Optional. Can be one of:
+                   - None: Use all tables in the connection's schema (default)
+                   - Table name: 'table_name' (uses current schema)
+                   - Schema.table: 'schema.table_name' (specific table in schema)
+                   - Schema only: 'schema' (all tables in schema)
+                   - Wildcard patterns: '*.summary' or 'schema.*'
+        
+        Returns:
+            DataFrame with columns: schema_name, table_name, total_rle_runs
+            
+        Examples:
+            con = duckrun.connect("tmp/data.lakehouse/aemo")
+            
+            # All tables in current schema
+            rle = con.get_rle()
+            
+            # Single table in current schema
+            rle = con.get_rle('price')
+            
+            # Specific table in different schema
+            rle = con.get_rle('deltars.summary')
+            
+            # All tables matching pattern
+            rle = con.get_rle('*.summary')
+        """
+        return _get_rle(self, source)
+
     def list_lakehouses(self) -> List[str]:
         """
         List all lakehouses in the current workspace.

{duckrun-0.2.21.dev2 → duckrun-0.2.22.dev2}/duckrun/stats.py

@@ -454,3 +454,195 @@ def get_stats(duckrun_instance, source: str = None, detailed = False):
     return final_result
 
 
+def get_rle(duckrun_instance, source: str = None) -> 'pd.DataFrame':
+    """
+    Get RLE statistics for tables at the column level.
+    
+    Args:
+        duckrun_instance: Duckrun connection (from duckrun.connect())
+        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)
+               - Schema only: 'schema' (all tables in schema)
+               - Wildcard pattern: '*.summary' (matches tables across all schemas)
+    
+    Returns:
+        DataFrame with columns:
+        - schema_name: Schema name
+        - table_name: Table name
+        - column_name: Column name
+        - total_rows: Total number of rows
+        - rle_runs: RLE runs for this column in natural order
+        - ndv: Number of distinct values
+        - total_rle_runs: Sum of RLE runs across all columns (same for all rows of a table)
+    """
+    import fnmatch
+    import pandas as pd
+    
+    con = duckrun_instance.con  # Get underlying DuckDB connection
+    
+    # Determine which tables to process
+    tables_to_process = []  # List of (schema, table) tuples
+    
+    if source is None:
+        # Get all tables in the connection's schema
+        schema_name = duckrun_instance.schema if hasattr(duckrun_instance, 'schema') else 'main'
+        try:
+            if schema_name == 'main':
+                query = "SHOW TABLES"
+                result = con.execute(query).fetchall()
+                if result:
+                    tables = [row[0] for row in result if not row[0].startswith('tbl_')]
+                    tables_to_process = [(schema_name, tbl) for tbl in tables]
+            else:
+                query = f"SELECT table_name FROM information_schema.tables WHERE table_schema = '{schema_name}'"
+                result = con.execute(query).fetchall()
+                if result:
+                    tables = [row[0] for row in result if not row[0].startswith('tbl_')]
+                    tables_to_process = [(schema_name, tbl) for tbl in tables]
+        except:
+            pass
+    
+    elif '.' in source:
+        parts = source.split('.', 1)
+        schema_pattern, table_pattern = parts[0], parts[1]
+        
+        # Check if patterns contain wildcards
+        if '*' in schema_pattern or '*' in table_pattern:
+            # Wildcard matching
+            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 = con.execute(query).fetchall()
+            for schema, table in result:
+                if fnmatch.fnmatch(schema, schema_pattern) and fnmatch.fnmatch(table, table_pattern):
+                    tables_to_process.append((schema, table))
+        else:
+            # Exact schema.table
+            tables_to_process = [(schema_pattern, table_pattern)]
+    
+    elif '*' in source:
+        # Wildcard pattern for table names across all schemas
+        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 = con.execute(query).fetchall()
+        for schema, table in result:
+            if fnmatch.fnmatch(table, source):
+                tables_to_process.append((schema, table))
+    
+    else:
+        # Check if it's a schema name or table name
+        try:
+            # Try as schema first
+            schema_query = f"SELECT 1 FROM information_schema.schemata WHERE schema_name = '{source}' LIMIT 1"
+            schema_exists = con.execute(schema_query).fetchone()
+            
+            if schema_exists:
+                # It's a schema - get all tables
+                tables_query = f"SELECT table_name FROM information_schema.tables WHERE table_schema = '{source}'"
+                result = con.execute(tables_query).fetchall()
+                if result:
+                    tables = [row[0] for row in result if not row[0].startswith('tbl_')]
+                    tables_to_process = [(source, tbl) for tbl in tables]
+            else:
+                # It's a table name in default schema
+                schema_name = duckrun_instance.schema if hasattr(duckrun_instance, 'schema') else 'main'
+                tables_to_process = [(schema_name, source)]
+        except:
+            # Assume it's a table name
+            schema_name = duckrun_instance.schema if hasattr(duckrun_instance, 'schema') else 'main'
+            tables_to_process = [(schema_name, source)]
+    
+    if not tables_to_process:
+        print("No tables found matching the criteria")
+        return pd.DataFrame(columns=['schema_name', 'table_name', 'column_name', 'total_rows', 
+                                     'rle_runs', 'ndv', 'total_rle_runs'])
+    
+    print(f"Processing {len(tables_to_process)} table(s)...")
+    
+    # Process each table
+    results = []
+    for schema, table in tables_to_process:
+        table_path = f"{duckrun_instance.table_base_url}{schema}/{table}"
+        
+        print(f"\nCalculating RLE runs for {schema}.{table}...")
+        
+        # Get column names and row count
+        try:
+            schema_info = con.sql(f"""
+                SELECT column_name
+                FROM (DESCRIBE SELECT * FROM delta_scan('{table_path}'))
+            """).df()
+            
+            # Get total row count
+            total_rows = con.sql(f"SELECT COUNT(*) FROM delta_scan('{table_path}')").fetchone()[0]
+            
+            if schema_info.empty:
+                continue
+            
+            # Track total RLE runs for this table
+            table_total_rle = 0
+            table_results = []
+            
+            for _, row in schema_info.iterrows():
+                col_name = row['column_name']
+                
+                # Calculate RLE runs in natural (physical) order using delta_scan
+                rle_query = f"""
+                WITH numbered AS (
+                    SELECT 
+                        filename,
+                        file_row_number,
+                        {col_name},
+                        LAG({col_name}) OVER (ORDER BY filename, file_row_number) as prev_value
+                    FROM delta_scan('{table_path}', file_row_number=1, filename=1)
+                )
+                SELECT COUNT(*) as runs
+                FROM numbered
+                WHERE prev_value IS NULL OR {col_name} != prev_value OR {col_name} IS NULL OR prev_value IS NULL
+                """
+                
+                try:
+                    runs = con.sql(rle_query).fetchone()[0]
+                    
+                    # Also calculate NDV for this column
+                    ndv_query = f"SELECT COUNT(DISTINCT {col_name}) FROM delta_scan('{table_path}')"
+                    ndv = con.sql(ndv_query).fetchone()[0]
+                    
+                    table_total_rle += runs
+                    
+                    print(f"  {col_name}: {runs:,} runs, ndv={ndv:,}")
+                    
+                    table_results.append({
+                        'schema_name': schema,
+                        'table_name': table,
+                        'column_name': col_name,
+                        'total_rows': total_rows,
+                        'rle_runs': runs,
+                        'ndv': ndv
+                    })
+                except Exception as e:
+                    print(f"  Warning: Could not calculate RLE runs for {col_name}: {e}")
+            
+            # Add total_rle_runs to all rows for this table
+            for result in table_results:
+                result['total_rle_runs'] = table_total_rle
+                results.append(result)
+            
+            print(f"  Total RLE runs for table: {table_total_rle:,}")
+        
+        except Exception as e:
+            print(f"  Error processing table: {e}")
+    
+    return pd.DataFrame(results)
+

{duckrun-0.2.21.dev2 → duckrun-0.2.22.dev2}/duckrun.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: duckrun
-Version: 0.2.21.dev2
+Version: 0.2.22.dev2
 Summary: Helper library for Fabric Python using duckdb, arrow and delta_rs (orchestration, queries, etc.)
 Author: mim
 License: MIT

{duckrun-0.2.21.dev2 → duckrun-0.2.22.dev2}/duckrun.egg-info/SOURCES.txt

@@ -8,7 +8,6 @@ duckrun/ducklake_metadata.py
 duckrun/files.py
 duckrun/lakehouse.py
 duckrun/notebook.py
-duckrun/rle.py
 duckrun/runner.py
 duckrun/semantic_model.py
 duckrun/stats.py
@@ -19,10 +18,13 @@ duckrun.egg-info/dependency_links.txt
 duckrun.egg-info/requires.txt
 duckrun.egg-info/top_level.txt
 tests/test_checkpoint_format.py
+tests/test_consecutive_values.py
 tests/test_deploy_fresh.py
 tests/test_ducklake_export.py
 tests/test_filename.py
 tests/test_register.py
 tests/test_rle.py
+tests/test_rle_analysis.py
+tests/test_rle_summary.py
 tests/test_writer_dictionary.py
 tests/test_writer_integration.py

{duckrun-0.2.21.dev2 → duckrun-0.2.22.dev2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "duckrun"
-version = "0.2.21.dev2"
+version = "0.2.22.dev2"
 description = "Helper library for Fabric Python using duckdb, arrow and delta_rs (orchestration, queries, etc.)"
 readme = "README.md"
 license = {text = "MIT"}

duckrun-0.2.22.dev2/tests/test_consecutive_values.py

@@ -0,0 +1,115 @@
+"""
+Test: Analyze Consecutive Values in Delta Table
+
+This test connects to tmp/data.lakehouse and analyzes the deltars.summary table
+for consecutive runs in the 'time' column.
+"""
+
+import sys
+from pathlib import Path
+
+# Add parent directory to path to import duckrun
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+import duckrun
+from duckrun.rle import analyze_consecutive_values
+
+
+def test_consecutive_values():
+    """Test consecutive value analysis on deltars.summary table"""
+    
+    lakehouse_path = "tmp/data.lakehouse"
+    
+    print("=" * 80)
+    print("CONSECUTIVE VALUES ANALYSIS TEST")
+    print("=" * 80)
+    print(f"Lakehouse: {lakehouse_path}")
+    print(f"Table: deltars.summary")
+    print(f"Column: time")
+    
+    try:
+        # Connect to lakehouse
+        print("\nConnecting to lakehouse...")
+        con = duckrun.connect(lakehouse_path)
+        
+        # Analyze consecutive values in the 'time' column
+        print("\n" + "=" * 80)
+        print("ANALYZING CONSECUTIVE VALUES")
+        print("=" * 80)
+        
+        df = analyze_consecutive_values(
+            duckrun_con=con,
+            table_name='summary',
+            column_name='time',
+            min_consecutive=3,
+            schema_name='deltars'
+        )
+        
+        # Display results
+        if not df.empty:
+            print("\n" + "=" * 80)
+            print("RESULTS")
+            print("=" * 80)
+            print(f"\nFound {len(df)} consecutive sequences")
+            print("\nTop 20 longest sequences:")
+            print(df.head(20).to_string(index=False))
+            
+            # Statistics
+            print("\n" + "=" * 80)
+            print("STATISTICS")
+            print("=" * 80)
+            total_in_sequences = df['consecutive_count'].sum()
+            longest = df['consecutive_count'].max()
+            shortest = df['consecutive_count'].min()
+            avg = df['consecutive_count'].mean()
+            
+            print(f"Total values in sequences: {total_in_sequences:,}")
+            print(f"Longest sequence: {longest:,}")
+            print(f"Shortest sequence: {shortest:,}")
+            print(f"Average sequence length: {avg:.2f}")
+            
+            # File distribution
+            print("\n" + "=" * 80)
+            print("FILE DISTRIBUTION")
+            print("=" * 80)
+            file_counts = df.groupby('filename').agg({
+                'consecutive_count': ['count', 'sum', 'max']
+            }).reset_index()
+            file_counts.columns = ['filename', 'num_sequences', 'total_values', 'max_sequence']
+            
+            # Extract just filename from path
+            file_counts['filename'] = file_counts['filename'].apply(
+                lambda x: x.split('/')[-1] if '/' in str(x) else x
+            )
+            
+            print(f"\nSequences across {len(file_counts)} files:")
+            print(file_counts.to_string(index=False))
+            
+            print("\n✅ Test completed successfully!")
+            return True
+        else:
+            print("\n⚠ No consecutive sequences found")
+            return True
+        
+    except Exception as e:
+        print(f"\n❌ Error during analysis: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+
+if __name__ == "__main__":
+    print("\n" + "=" * 80)
+    print("STARTING CONSECUTIVE VALUES TEST")
+    print("=" * 80)
+    
+    success = test_consecutive_values()
+    
+    print("\n" + "=" * 80)
+    if success:
+        print("✅ TEST PASSED")
+    else:
+        print("❌ TEST FAILED")
+    print("=" * 80)
+    
+    sys.exit(0 if success else 1)

duckrun-0.2.22.dev2/tests/test_rle_analysis.py

@@ -0,0 +1,149 @@
+"""
+Test: RLE Analysis with Real Parquet Data
+
+This test demonstrates the refactored RLE module using real parquet data.
+It analyzes table statistics, NDV, and value frequency patterns.
+"""
+
+import duckdb
+import sys
+from pathlib import Path
+
+# Add parent directory to path to import duckrun
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from duckrun.rle import get_table_stats, get_value_frequency_details
+
+
+def test_rle_with_real_parquet():
+    """Test RLE analysis with real parquet file"""
+    
+    # Path to the test parquet file
+    parquet_path = Path(__file__).parent / "part-00000-19052469-6a9d-4faa-86ac-60efce3e4443-c000.snappy.parquet"
+    
+    if not parquet_path.exists():
+        print(f"❌ Error: Parquet file not found at {parquet_path}")
+        return False
+    
+    print("=" * 80)
+    print("RLE ANALYSIS TEST: Real Parquet Data")
+    print("=" * 80)
+    print(f"File: {parquet_path.name}")
+    print(f"Size: {parquet_path.stat().st_size:,} bytes")
+    
+    # Connect to DuckDB
+    con = duckdb.connect(':memory:')
+    
+    try:
+        # First, let's see the schema
+        print("\n" + "=" * 80)
+        print("SCHEMA INSPECTION")
+        print("=" * 80)
+        
+        schema_df = con.sql(f"""
+            SELECT * FROM parquet_schema('{parquet_path}')
+        """).df()
+        
+        print(f"\nColumns found: {len(schema_df)}")
+        print(schema_df.to_string(index=False))
+        
+        # Get row count
+        row_count = con.sql(f"""
+            SELECT COUNT(*) FROM read_parquet('{parquet_path}')
+        """).fetchone()[0]
+        
+        print(f"\nTotal rows: {row_count:,}")
+        
+        # Run comprehensive RLE analysis
+        print("\n" + "=" * 80)
+        print("COMPREHENSIVE RLE ANALYSIS")
+        print("=" * 80)
+        
+        stats_df = get_table_stats(con, str(parquet_path), is_parquet=True, top_n_values=10)
+        
+        # Display results
+        print("\n" + "=" * 80)
+        print("RESULTS: Columns Ranked by RLE Potential")
+        print("=" * 80)
+        
+        print("\n" + stats_df[['column_name', 'data_type', 'ndv', 'cardinality_ratio', 
+                                'top_value_pct', 'top_n_coverage', 'repetition_score']].to_string(index=False))
+        
+        # Detailed analysis of top 3 columns
+        print("\n" + "=" * 80)
+        print("DETAILED VALUE FREQUENCY ANALYSIS")
+        print("=" * 80)
+        
+        for idx in range(min(3, len(stats_df))):
+            col_name = stats_df.iloc[idx]['column_name']
+            score = stats_df.iloc[idx]['repetition_score']
+            
+            print(f"\n[{idx+1}] Column: {col_name} (repetition_score: {score})")
+            print("-" * 80)
+            
+            freq_df = get_value_frequency_details(con, str(parquet_path), col_name, 
+                                                  is_parquet=True, limit=15)
+            print(freq_df.to_string(index=False))
+            
+            if not freq_df.empty:
+                print(f"\n✓ Top value appears {freq_df.iloc[0]['percentage']:.2f}% of the time")
+                print(f"✓ Top 15 values cover {freq_df['cumulative_pct'].iloc[-1]:.2f}% of all data")
+        
+        # Summary and recommendations
+        print("\n" + "=" * 80)
+        print("SUMMARY & RECOMMENDATIONS")
+        print("=" * 80)
+        
+        # Categorize columns
+        excellent = stats_df[stats_df['repetition_score'] > 100]
+        good = stats_df[(stats_df['repetition_score'] >= 10) & (stats_df['repetition_score'] <= 100)]
+        poor = stats_df[stats_df['repetition_score'] < 10]
+        
+        print(f"\n📊 RLE Compression Potential:")
+        print(f"   Excellent (score > 100): {len(excellent)} columns")
+        if len(excellent) > 0:
+            print(f"      {', '.join(excellent['column_name'].tolist())}")
+        
+        print(f"   Good (score 10-100): {len(good)} columns")
+        if len(good) > 0:
+            print(f"      {', '.join(good['column_name'].tolist())}")
+        
+        print(f"   Poor (score < 10): {len(poor)} columns")
+        if len(poor) > 0:
+            print(f"      {', '.join(poor['column_name'].tolist())}")
+        
+        print(f"\n💡 Sorting Recommendation:")
+        top_3 = stats_df.head(3)['column_name'].tolist()
+        print(f"   For optimal RLE compression, consider sorting by:")
+        for i, col in enumerate(top_3, 1):
+            print(f"   {i}. {col}")
+        
+        print(f"\n✅ Test completed successfully!")
+        
+        return True
+        
+    except Exception as e:
+        print(f"\n❌ Error during analysis: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+        
+    finally:
+        con.close()
+
+
+if __name__ == "__main__":
+    print("\n" + "=" * 80)
+    print("STARTING RLE ANALYSIS TEST")
+    print("=" * 80)
+    
+    success = test_rle_with_real_parquet()
+    
+    print("\n" + "=" * 80)
+    if success:
+        print("✅ TEST PASSED")
+    else:
+        print("❌ TEST FAILED")
+    print("=" * 80)
+    
+    sys.exit(0 if success else 1)