starrocks-br 0.1.0__py3-none-any.whl

starrocks_br/restore.py

@@ -0,0 +1,493 @@
+import time
+import datetime
+from typing import Dict, List, Optional
+from . import history, concurrency, logger
+
+MAX_POLLS = 21600 # 6 hours
+
+def get_snapshot_timestamp(db, repo_name: str, snapshot_name: str) -> str:
+    """Get the backup timestamp for a specific snapshot from the repository.
+    
+    Args:
+        db: Database connection
+        repo_name: Repository name
+        snapshot_name: Snapshot name to look up
+        
+    Returns:
+        The backup timestamp string
+        
+    Raises:
+        ValueError: If snapshot is not found in the repository
+    """
+    query = f"SHOW SNAPSHOT ON {repo_name} WHERE Snapshot = '{snapshot_name}'"
+    
+    rows = db.query(query)
+    if not rows:
+        raise ValueError(f"Snapshot '{snapshot_name}' not found in repository '{repo_name}'")
+    
+    # The result should be a single row with columns: Snapshot, Timestamp, Status
+    result = rows[0]
+    
+    if isinstance(result, dict):
+        timestamp = result.get("Timestamp")
+    else:
+        timestamp = result[1] if len(result) > 1 else None
+    
+    if not timestamp:
+        raise ValueError(f"Could not extract timestamp for snapshot '{snapshot_name}'")
+    
+    return timestamp
+
+
+def build_partition_restore_command(
+    database: str,
+    table: str,
+    partition: str,
+    backup_label: str,
+    repository: str,
+    backup_timestamp: str,
+) -> str:
+    """Build RESTORE command for single partition recovery."""
+    return f"""RESTORE SNAPSHOT {backup_label}
+    FROM {repository}
+    DATABASE {database}
+    ON (TABLE {table} PARTITION ({partition}))
+    PROPERTIES ("backup_timestamp" = "{backup_timestamp}")"""
+
+
+def build_table_restore_command(
+    database: str,
+    table: str,
+    backup_label: str,
+    repository: str,
+    backup_timestamp: str,
+) -> str:
+    """Build RESTORE command for full table recovery."""
+    return f"""RESTORE SNAPSHOT {backup_label}
+    FROM {repository}
+    DATABASE {database}
+    ON (TABLE {table})
+    PROPERTIES ("backup_timestamp" = "{backup_timestamp}")"""
+
+
+def build_database_restore_command(
+    database: str,
+    backup_label: str,
+    repository: str,
+    backup_timestamp: str,
+) -> str:
+    """Build RESTORE command for full database recovery."""
+    return f"""RESTORE SNAPSHOT {backup_label}
+    FROM {repository}
+    DATABASE {database}
+    PROPERTIES ("backup_timestamp" = "{backup_timestamp}")"""
+
+
+def poll_restore_status(db, label: str, database: str, max_polls: int = MAX_POLLS, poll_interval: float = 1.0) -> Dict[str, str]:
+    """Poll restore status until completion or timeout.
+    
+    Note: SHOW RESTORE only returns the LAST restore in a database.
+    We verify that the Label matches our expected label.
+    
+    Important: If we see a different label, it means another restore
+    operation overwrote ours and we've lost tracking (race condition).
+    
+    Args:
+        db: Database connection
+        label: Expected snapshot label to monitor
+        database: Database name where restore was submitted
+        max_polls: Maximum number of polling attempts
+        poll_interval: Seconds to wait between polls
+    
+    Returns dictionary with keys: state, label
+    Possible states: FINISHED, CANCELLED, TIMEOUT, ERROR, LOST
+    """
+    query = f"SHOW RESTORE FROM {database}"
+    first_poll = True
+    last_state = None
+    poll_count = 0
+    
+    for _ in range(max_polls):
+        poll_count += 1
+        try:
+            rows = db.query(query)
+            
+            if not rows:
+                time.sleep(poll_interval)
+                continue
+            
+            result = rows[0]
+            
+            if isinstance(result, dict):
+                snapshot_label = result.get("Label", "")
+                state = result.get("State", "UNKNOWN")
+            else:
+                # Tuple format: JobId, Label, Timestamp, DbName, State, ...
+                snapshot_label = result[1] if len(result) > 1 else ""
+                state = result[4] if len(result) > 4 else "UNKNOWN"
+            
+            if snapshot_label != label and snapshot_label:
+                if first_poll:
+                    first_poll = False
+                    time.sleep(poll_interval)
+                    continue
+                else:
+                    return {"state": "LOST", "label": label}
+            
+            first_poll = False
+            
+            if state != last_state or poll_count % 10 == 0:
+                logger.progress(f"Restore status: {state} (poll {poll_count}/{max_polls})")
+                last_state = state
+            
+            if state in ["FINISHED", "CANCELLED", "UNKNOWN"]:
+                return {"state": state, "label": label}
+            
+            time.sleep(poll_interval)
+            
+        except Exception:
+            return {"state": "ERROR", "label": label}
+    
+    return {"state": "TIMEOUT", "label": label}
+
+
+def execute_restore(
+    db,
+    restore_command: str,
+    backup_label: str,
+    restore_type: str,
+    repository: str,
+    database: str,
+    max_polls: int = MAX_POLLS,
+    poll_interval: float = 1.0,
+    scope: str = "restore",
+) -> Dict:
+    """Execute a complete restore workflow: submit command and monitor progress.
+    
+    Returns dictionary with keys: success, final_status, error_message
+    """
+    started_at = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    
+    try:
+        db.execute(restore_command.strip())
+    except Exception as e:
+        logger.error(f"Failed to submit restore command: {str(e)}")
+        return {
+            "success": False,
+            "final_status": None,
+            "error_message": f"Failed to submit restore command: {str(e)}"
+        }
+    
+    label = backup_label
+    
+    try:
+        final_status = poll_restore_status(db, label, database, max_polls, poll_interval)
+        
+        success = final_status["state"] == "FINISHED"
+        finished_at = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        
+        try:
+            history.log_restore(
+                db,
+                {
+                    "job_id": label,
+                    "backup_label": backup_label,
+                    "restore_type": restore_type,
+                    "status": final_status["state"],
+                    "repository": repository,
+                    "started_at": started_at,
+                    "finished_at": finished_at,
+                    "error_message": None if success else final_status["state"],
+                },
+            )
+        except Exception as e:
+            logger.error(f"Failed to log restore history: {str(e)}")
+        
+        try:
+            concurrency.complete_job_slot(db, scope=scope, label=label, final_state=final_status["state"])
+        except Exception as e:
+            logger.error(f"Failed to complete job slot: {str(e)}")
+        
+        return {
+            "success": success,
+            "final_status": final_status,
+            "error_message": None if success else f"Restore failed with state: {final_status['state']}"
+        }
+        
+    except Exception as e:
+        logger.error(f"Restore execution failed: {str(e)}")
+        return {
+            "success": False,
+            "final_status": None,
+            "error_message": str(e)
+        }
+
+
+def find_restore_pair(db, target_label: str) -> List[str]:
+    """Find the correct sequence of backups needed for restore.
+    
+    Args:
+        db: Database connection
+        target_label: The backup label to restore to
+        
+    Returns:
+        List of backup labels in restore order [base_full_backup, target_label]
+        or [target_label] if target is a full backup
+        
+    Raises:
+        ValueError: If target label not found or incremental has no preceding full backup
+    """
+    query = f"""
+    SELECT label, backup_type, finished_at
+    FROM ops.backup_history
+    WHERE label = '{target_label}'
+    AND status = 'FINISHED'
+    """
+    
+    rows = db.query(query)
+    if not rows:
+        raise ValueError(f"Backup label '{target_label}' not found or not successful")
+    
+    target_info = {
+        "label": rows[0][0],
+        "backup_type": rows[0][1],
+        "finished_at": rows[0][2]
+    }
+    
+    if target_info["backup_type"] == "full":
+        return [target_label]
+    
+    if target_info["backup_type"] == "incremental":
+        database_name = target_label.split('_')[0]
+        
+        full_backup_query = f"""
+        SELECT label, backup_type, finished_at
+        FROM ops.backup_history
+        WHERE backup_type = 'full'
+        AND status = 'FINISHED'
+        AND label LIKE '{database_name}_%'
+        AND finished_at < '{target_info["finished_at"]}'
+        ORDER BY finished_at DESC
+        LIMIT 1
+        """
+        
+        full_rows = db.query(full_backup_query)
+        if not full_rows:
+            raise ValueError(f"No successful full backup found before incremental '{target_label}'")
+        
+        base_full_backup = full_rows[0][0]
+        return [base_full_backup, target_label]
+    
+    raise ValueError(f"Unknown backup type '{target_info['backup_type']}' for label '{target_label}'")
+
+
+def get_tables_from_backup(db, label: str, group: Optional[str] = None) -> List[str]:
+    """Get list of tables to restore from backup manifest.
+    
+    Args:
+        db: Database connection
+        label: Backup label
+        group: Optional inventory group to filter tables
+        
+    Returns:
+        List of table names to restore
+    """
+    query = f"""
+    SELECT DISTINCT database_name, table_name
+    FROM ops.backup_partitions
+    WHERE label = '{label}'
+    ORDER BY database_name, table_name
+    """
+    
+    rows = db.query(query)
+    if not rows:
+        return []
+    
+    tables = [f"{row[0]}.{row[1]}" for row in rows]
+    
+    if group:
+        group_query = f"""
+        SELECT database_name, table_name
+        FROM ops.table_inventory
+        WHERE inventory_group = '{group}'
+        """
+        
+        group_rows = db.query(group_query)
+        if not group_rows:
+            return []
+        
+        group_tables = {f"{row[0]}.{row[1]}" for row in group_rows}
+        
+        tables = [table for table in tables if table in group_tables]
+    
+    return tables
+
+
+def execute_restore_flow(db, repo_name: str, restore_pair: List[str], tables_to_restore: List[str], rename_suffix: str = "_restored") -> Dict:
+    """Execute the complete restore flow with safety measures.
+    
+    Args:
+        db: Database connection
+        repo_name: Repository name
+        restore_pair: List of backup labels in restore order
+        tables_to_restore: List of tables to restore (format: database.table)
+        rename_suffix: Suffix for temporary tables
+        
+    Returns:
+        Dictionary with success status and details
+    """
+    if not restore_pair:
+        return {
+            "success": False,
+            "error_message": "No restore pair provided"
+        }
+    
+    if not tables_to_restore:
+        return {
+            "success": False,
+            "error_message": "No tables to restore"
+        }
+    
+    logger.info("")
+    logger.info("=== RESTORE PLAN ===")
+    logger.info(f"Repository: {repo_name}")
+    logger.info(f"Restore sequence: {' -> '.join(restore_pair)}")
+    logger.info(f"Tables to restore: {', '.join(tables_to_restore)}")
+    logger.info(f"Temporary table suffix: {rename_suffix}")
+    logger.info("")
+    logger.info("This will restore data to temporary tables and then perform atomic rename.")
+    logger.warning("WARNING: This operation will replace existing tables!")
+    
+    confirmation = input("\nDo you want to proceed? [Y/n]: ").strip()
+    if confirmation.lower() != 'y':
+        return {
+            "success": False,
+            "error_message": "Restore operation cancelled by user"
+        }
+    
+    try:
+        database_name = tables_to_restore[0].split('.')[0]
+        
+        base_label = restore_pair[0]
+        logger.info("")
+        logger.info(f"Step 1: Restoring base backup '{base_label}'...")
+        
+        base_timestamp = get_snapshot_timestamp(db, repo_name, base_label)
+        
+        base_restore_command = _build_restore_command_with_rename(
+            base_label, repo_name, tables_to_restore, rename_suffix, database_name, base_timestamp
+        )
+        
+        base_result = execute_restore(
+            db, base_restore_command, base_label, "full", repo_name, database_name, scope="restore"
+        )
+        
+        if not base_result["success"]:
+            return {
+                "success": False,
+                "error_message": f"Base restore failed: {base_result['error_message']}"
+            }
+        
+        logger.success("Base restore completed successfully")
+        
+        if len(restore_pair) > 1:
+            incremental_label = restore_pair[1]
+            logger.info("")
+            logger.info(f"Step 2: Applying incremental backup '{incremental_label}'...")
+            
+            incremental_timestamp = get_snapshot_timestamp(db, repo_name, incremental_label)
+            
+            incremental_restore_command = _build_restore_command_without_rename(
+                incremental_label, repo_name, tables_to_restore, database_name, incremental_timestamp
+            )
+            
+            incremental_result = execute_restore(
+                db, incremental_restore_command, incremental_label, "incremental", repo_name, database_name, scope="restore"
+            )
+            
+            if not incremental_result["success"]:
+                return {
+                    "success": False,
+                    "error_message": f"Incremental restore failed: {incremental_result['error_message']}"
+                }
+            
+            logger.success("Incremental restore completed successfully")
+        
+        logger.info("")
+        logger.info("Step 3: Performing atomic rename...")
+        rename_result = _perform_atomic_rename(db, tables_to_restore, rename_suffix)
+        
+        if not rename_result["success"]:
+            return {
+                "success": False,
+                "error_message": f"Atomic rename failed: {rename_result['error_message']}"
+            }
+        
+        logger.success("Atomic rename completed successfully")
+        
+        return {
+            "success": True,
+            "message": f"Restore completed successfully. Restored {len(tables_to_restore)} tables."
+        }
+        
+    except Exception as e:
+        return {
+            "success": False,
+            "error_message": f"Restore flow failed: {str(e)}"
+        }
+
+
+def _build_restore_command_with_rename(backup_label: str, repo_name: str, tables: List[str], rename_suffix: str, database: str, backup_timestamp: str) -> str:
+    """Build restore command with AS clause for temporary table names."""
+    table_clauses = []
+    for table in tables:
+        _, table_name = table.split('.', 1)
+        temp_table_name = f"{table_name}{rename_suffix}"
+        table_clauses.append(f"TABLE {table_name} AS {temp_table_name}")
+    
+    on_clause = ",\n    ".join(table_clauses)
+    
+    return f"""RESTORE SNAPSHOT {backup_label}
+    FROM {repo_name}
+    DATABASE {database}
+    ON ({on_clause})
+    PROPERTIES ("backup_timestamp" = "{backup_timestamp}")"""
+
+
+def _build_restore_command_without_rename(backup_label: str, repo_name: str, tables: List[str], database: str, backup_timestamp: str) -> str:
+    """Build restore command without AS clause (for incremental restores to existing temp tables)."""
+    table_clauses = []
+    for table in tables:
+        _, table_name = table.split('.', 1)
+        table_clauses.append(f"TABLE {table_name}")
+    
+    on_clause = ",\n    ".join(table_clauses)
+    
+    return f"""RESTORE SNAPSHOT {backup_label}
+    FROM {repo_name}
+    DATABASE {database}
+    ON ({on_clause})
+    PROPERTIES ("backup_timestamp" = "{backup_timestamp}")"""
+
+
+def _perform_atomic_rename(db, tables: List[str], rename_suffix: str) -> Dict:
+    """Perform atomic rename of temporary tables to make them live."""
+    try:
+        rename_statements = []
+        for table in tables:
+            database, table_name = table.split('.', 1)
+            temp_table_name = f"{table_name}{rename_suffix}"
+            
+            rename_statements.append(f"ALTER TABLE {database}.{table_name} RENAME {table_name}_backup")
+            rename_statements.append(f"ALTER TABLE {database}.{temp_table_name} RENAME {table_name}")
+        
+        for statement in rename_statements:
+            db.execute(statement)
+        
+        return {"success": True}
+        
+    except Exception as e:
+        return {
+            "success": False,
+            "error_message": f"Failed to perform atomic rename: {str(e)}"
+        }

starrocks_br/schema.py

@@ -0,0 +1,144 @@
+from . import logger
+
+def initialize_ops_schema(db) -> None:
+    """Initialize the ops database and all required control tables.
+    
+    Creates empty ops tables. Does NOT populate with sample data.
+    Users must manually insert their table inventory records.
+    """
+    
+    logger.info("Creating ops database...")
+    db.execute("CREATE DATABASE IF NOT EXISTS ops")
+    logger.success("ops database created")
+    
+    logger.info("Creating ops.table_inventory...")
+    db.execute(get_table_inventory_schema())
+    logger.success("ops.table_inventory created")
+    
+    logger.info("Creating ops.backup_history...")
+    db.execute(get_backup_history_schema())
+    logger.success("ops.backup_history created")
+    
+    logger.info("Creating ops.restore_history...")
+    db.execute(get_restore_history_schema())
+    logger.success("ops.restore_history created")
+    
+    logger.info("Creating ops.run_status...")
+    db.execute(get_run_status_schema())
+    logger.success("ops.run_status created")
+    
+    logger.info("Creating ops.backup_partitions...")
+    db.execute(get_backup_partitions_schema())
+    logger.success("ops.backup_partitions created")
+    logger.info("")
+    logger.success("Schema initialized successfully!")
+
+
+def ensure_ops_schema(db) -> bool:
+    """Ensure ops schema exists, creating it if necessary.
+    
+    Returns True if schema was created, False if it already existed.
+    This is called automatically before backup/restore operations.
+    """
+    try:
+        result = db.query("SHOW DATABASES LIKE 'ops'")
+        
+        if not result:
+            initialize_ops_schema(db)
+            return True
+        
+        db.execute("USE ops")
+        tables_result = db.query("SHOW TABLES")
+        
+        if not tables_result or len(tables_result) < 5:
+            initialize_ops_schema(db)
+            return True
+        
+        return False
+        
+    except Exception:
+        initialize_ops_schema(db)
+        return True
+
+
+def get_table_inventory_schema() -> str:
+    """Get CREATE TABLE statement for table_inventory."""
+    return """
+    CREATE TABLE IF NOT EXISTS ops.table_inventory (
+        inventory_group STRING NOT NULL COMMENT "Group name for a set of tables",
+        database_name STRING NOT NULL COMMENT "Database name",
+        table_name STRING NOT NULL COMMENT "Table name, or '*' for all tables in database",
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+        updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+    )
+    PRIMARY KEY (inventory_group, database_name, table_name)
+    COMMENT "Inventory groups mapping to databases/tables (supports '*' wildcard)"
+    """
+
+
+def get_backup_history_schema() -> str:
+    """Get CREATE TABLE statement for backup_history."""
+    return """
+    CREATE TABLE IF NOT EXISTS ops.backup_history (
+        label STRING NOT NULL COMMENT "Unique backup snapshot label",
+        backup_type STRING NOT NULL COMMENT "Type of backup: full or incremental",
+        status STRING NOT NULL COMMENT "Final backup status: FINISHED, FAILED, CANCELLED, TIMEOUT",
+        repository STRING NOT NULL COMMENT "Repository name where backup was stored",
+        started_at DATETIME NOT NULL COMMENT "Backup start timestamp",
+        finished_at DATETIME COMMENT "Backup completion timestamp",
+        error_message STRING COMMENT "Error message if backup failed",
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP COMMENT "History record creation timestamp"
+    )
+    PRIMARY KEY (label)
+    COMMENT "History log of all backup operations"
+    """
+
+
+def get_restore_history_schema() -> str:
+    """Get CREATE TABLE statement for restore_history."""
+    return """
+    CREATE TABLE IF NOT EXISTS ops.restore_history (
+        job_id STRING NOT NULL COMMENT "Unique restore job identifier",
+        backup_label STRING NOT NULL COMMENT "Source backup snapshot label",
+        restore_type STRING NOT NULL COMMENT "Type of restore: partition, table, or database",
+        status STRING NOT NULL COMMENT "Final restore status: FINISHED, FAILED, CANCELLED",
+        repository STRING NOT NULL COMMENT "Repository name where backup was retrieved from",
+        started_at DATETIME NOT NULL COMMENT "Restore start timestamp",
+        finished_at DATETIME COMMENT "Restore completion timestamp",
+        error_message STRING COMMENT "Error message if restore failed",
+        verification_checksum STRING COMMENT "Checksum for data verification",
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP COMMENT "History record creation timestamp"
+    )
+    PRIMARY KEY (job_id)
+    COMMENT "History log of all restore operations"
+    """
+
+
+def get_run_status_schema() -> str:
+    """Get CREATE TABLE statement for run_status."""
+    return """
+    CREATE TABLE IF NOT EXISTS ops.run_status (
+        scope STRING NOT NULL COMMENT "Job scope: backup or restore",
+        label STRING NOT NULL COMMENT "Job label or identifier",
+        state STRING NOT NULL DEFAULT "ACTIVE" COMMENT "Job state: ACTIVE or COMPLETED",
+        started_at DATETIME DEFAULT CURRENT_TIMESTAMP COMMENT "Job start timestamp",
+        finished_at DATETIME COMMENT "Job completion timestamp"
+    )
+    PRIMARY KEY (scope, label)
+    COMMENT "Tracks active and recently completed jobs for concurrency control"
+    """
+
+
+def get_backup_partitions_schema() -> str:
+    """Get CREATE TABLE statement for backup_partitions."""
+    return """
+    CREATE TABLE IF NOT EXISTS ops.backup_partitions (
+        label STRING NOT NULL COMMENT "The backup label this partition belongs to. FK to ops.backup_history.label.",
+        database_name STRING NOT NULL COMMENT "The name of the database the partition belongs to.",
+        table_name STRING NOT NULL COMMENT "The name of the table the partition belongs to.",
+        partition_name STRING NOT NULL COMMENT "The name of the specific partition.",
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP COMMENT "Timestamp when this record was created."
+    )
+    PRIMARY KEY (label, database_name, table_name, partition_name)
+    COMMENT "Tracks every partition included in a backup snapshot."
+    """

starrocks_br-0.1.0.dist-info/METADATA

@@ -0,0 +1,12 @@
+Metadata-Version: 2.4
+Name: starrocks-br
+Version: 0.1.0
+Summary: StarRocks Backup and Restore automation tool
+Requires-Python: >=3.9
+Requires-Dist: click<9,>=8.1.7
+Requires-Dist: PyYAML<7,>=6.0.1
+Requires-Dist: mysql-connector-python<10,>=9.0.0
+Provides-Extra: dev
+Requires-Dist: pytest<9,>=8.3.2; extra == "dev"
+Requires-Dist: pytest-mock<4,>=3.14.0; extra == "dev"
+Requires-Dist: pytest-cov<6,>=5.0.0; extra == "dev"

starrocks_br-0.1.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+starrocks_br/__init__.py,sha256=i1m0FIl2IAXaVyNoya0ZNAx3WfhIp9I6VLhTz06qNFY,28
+starrocks_br/cli.py,sha256=VrLLyvyAop687KNJnXIJhxL7EgVPzutQTAOJz4ANZMw,15969
+starrocks_br/concurrency.py,sha256=wx69u-RW1OnukKn6CQ9EJS4L42N9Gzw7Xz7rgETzmy4,5934
+starrocks_br/config.py,sha256=btmsf43IuxPIraFxJRScuHW-B3Bv7CPO7y43xn2b2cM,1047
+starrocks_br/db.py,sha256=whbkM5LVLNNauPDuSFXOXWuTOFWHBVsNai74O7bIUAg,2450
+starrocks_br/executor.py,sha256=_lbJQ6KjV7Jg5eYbSLZhvvYj-EM5kBV6lM3Lah9h6-U,8748
+starrocks_br/health.py,sha256=DpTy4uqk1UrbV0d9Wtk9Ke9K0iT4ndL-01gqqSywR_c,1050
+starrocks_br/history.py,sha256=j6eqkD1MyTvgoztffnLnr6-6VXd0gdvLxLLKxbC1AG0,3016
+starrocks_br/labels.py,sha256=D67JqIUWtFAnuj9thnC4Y7A0tzLk6d4YpBtDGhen1yc,1689
+starrocks_br/logger.py,sha256=QTfr-nC3TdeU7f1gcRTRDAQSLYpwaevd_iT1B_RbuF8,900
+starrocks_br/planner.py,sha256=wnFMbIQhY9dVaoRjmzB3DypPMEXQam94TFenwGhMGGk,9414
+starrocks_br/repository.py,sha256=6uTJBYgQFEjJBlfhirriTkad80teTPcBSl_tphUExz4,1269
+starrocks_br/restore.py,sha256=IPs8EzIS_7iTUMkKJV32YJvb4b0MTXpLgZmUWhnzPXo,16672
+starrocks_br/schema.py,sha256=_cFzD3Bnvb1WDlLzmFXuMSinLjiXKmLbJ9uUhyOCKK4,6095
+starrocks_br-0.1.0.dist-info/METADATA,sha256=u1ivetyaj0El_v_5Iy9WmJ4_KsEmhU8GUSy3T7Hb4xQ,419
+starrocks_br-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+starrocks_br-0.1.0.dist-info/entry_points.txt,sha256=AKUt01G2MAlh85s1Q9kNQDOUio14kaTnT3dmg9gjdNg,54
+starrocks_br-0.1.0.dist-info/top_level.txt,sha256=CU1tGVo0kjulhDr761Sndg-oTeRKsisDnWm8UG95aBE,13
+starrocks_br-0.1.0.dist-info/RECORD,,

starrocks_br-0.1.0.dist-info/WHEEL

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

starrocks_br-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+starrocks-br = starrocks_br.cli:cli

starrocks_br-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+starrocks_br