db-drift 1.0.0__py3-none-any.whl → 1.1.0__py3-none-any.whl

db_drift/__init__.py

@@ -1,2 +1 @@
-def main() -> None:
-    print("Hello from db-drift!")
+from db_drift.__main__ import main  # noqa: F401

db_drift/__main__.py

@@ -0,0 +1,103 @@
+import os
+
+from db_drift.cli.cli import cli
+from db_drift.utils import custom_logging
+from db_drift.utils.exceptions import CliError, ConfigError, DatabaseError, DbDriftError, DbDriftInterruptError, ExitCode
+from db_drift.utils.exceptions.base import DbDriftSystemError
+from db_drift.utils.exceptions.formatting import handle_error_and_exit, handle_unexpected_error
+
+logger = custom_logging.setup_logger("db-drift")
+
+
+DEBUG_MODE: int | bool = os.getenv("DB_DRIFT_DEBUG", "").lower() in ("1", "true", "yes", "on")
+
+
+def main() -> None:
+    """Entry point for the db-drift package."""
+    try:
+        logger.debug("Starting db-drift CLI")
+        cli()
+
+    except KeyboardInterrupt:
+        # Handle Ctrl+C gracefully
+        error = DbDriftInterruptError()
+        logger.info("Operation cancelled by user")
+        handle_error_and_exit(
+            error,
+            logger=logger,
+            show_traceback=DEBUG_MODE,
+            show_suggestions=False,
+        )
+
+    except CliError as e:
+        # Handle CLI-specific errors (argument parsing, usage errors, etc.)
+        logger.exception("CLI Error occurred")
+        handle_error_and_exit(
+            e,
+            logger=logger,
+            show_traceback=DEBUG_MODE,
+            show_suggestions=True,
+        )
+
+    except ConfigError as e:
+        # Handle configuration errors
+        logger.exception("Configuration Error occurred")
+        handle_error_and_exit(
+            e,
+            logger=logger,
+            show_traceback=DEBUG_MODE,
+            show_suggestions=True,
+        )
+
+    except DatabaseError as e:
+        # Handle database connection and query errors
+        logger.exception("Database Error occurred")
+        handle_error_and_exit(
+            e,
+            logger=logger,
+            show_traceback=DEBUG_MODE,
+            show_suggestions=True,
+        )
+
+    except DbDriftError as e:
+        # Handle other custom application errors
+        logger.exception("Application Error occurred")
+        handle_error_and_exit(
+            e,
+            logger=logger,
+            show_traceback=DEBUG_MODE,
+            show_suggestions=True,
+        )
+
+    except FileNotFoundError as e:
+        # Handle file not found errors
+        logger.exception("File not found")
+        system_error = DbDriftSystemError(f"Required file not found: {e}", exit_code=ExitCode.NO_INPUT)
+        handle_error_and_exit(
+            system_error,
+            logger=logger,
+            show_traceback=DEBUG_MODE,
+            show_suggestions=True,
+        )
+
+    except PermissionError as e:
+        # Handle permission errors
+        logger.exception("Permission denied")
+        system_error = DbDriftSystemError(f"Permission denied: {e}", exit_code=ExitCode.NO_PERMISSION)
+        handle_error_and_exit(
+            system_error,
+            logger=logger,
+            show_traceback=DEBUG_MODE,
+            show_suggestions=True,
+        )
+
+    except Exception:
+        # Handle any unexpected errors
+        logger.exception("Unexpected error occurred")
+
+        # In debug mode, show full traceback; otherwise, show generic message
+        handle_unexpected_error(DEBUG_MODE, logger)
+
+
+if __name__ == "__main__":
+    main()

db_drift/cli/cli.py

@@ -0,0 +1,35 @@
+import argparse
+import logging
+
+from db_drift.cli.utils import get_version
+from db_drift.utils.exceptions import CliArgumentError, CliUsageError
+
+logger = logging.getLogger("db-drift")
+
+
+def cli() -> None:
+    parser = argparse.ArgumentParser(
+        prog="db-drift",
+        description="A command-line tool to visualize the differences between two DB states.",
+        exit_on_error=False,  # We'll handle errors ourselves
+    )
+
+    parser.add_argument(
+        "-v",
+        "--version",
+        action="version",
+        version=f"db-drift {get_version()}",
+    )
+
+    try:
+        _ = parser.parse_args()
+    except argparse.ArgumentError as e:
+        msg = f"Invalid argument: {e}"
+        raise CliArgumentError(msg) from e
+    except SystemExit as e:
+        # argparse calls sys.exit() on error, convert to our exception
+        if e.code != 0:
+            msg = "Invalid command line arguments. Use --help for usage information."
+            raise CliUsageError(msg) from e
+        # Re-raise if it's a successful exit (like --help)
+        raise

db_drift/cli/utils.py

@@ -0,0 +1,9 @@
+from importlib import metadata
+
+
+def get_version() -> str:
+    """Get the current version of the package."""
+    try:
+        return metadata.version("db-drift")
+    except metadata.PackageNotFoundError:
+        return "unknown"

db_drift/utils/custom_logging.py

@@ -0,0 +1,52 @@
+import logging
+from logging.handlers import RotatingFileHandler
+from pathlib import Path
+
+LOGFILES_DIR_NAME = ".logs"
+
+
+def setup_logger(name: str, level: int = logging.INFO) -> logging.Logger:
+    """
+    Set up a logger with a specific name and configuration.
+    Note: This could also be used to modify an existing logger's configuration.
+
+    Args:
+        name (str): The name of the logger.
+        level (int): The logging level. Default is logging.INFO.
+
+    Returns:
+        logging.Logger: The configured logger instance.
+    """
+    formatter = logging.Formatter(
+        "%(asctime)s - %(threadName)s:%(thread)d - %(module)s:%(lineno)d - %(levelname)s - %(message)s",
+        datefmt="%Y-%m-%d %H:%M:%S",
+    )
+
+    if not Path(LOGFILES_DIR_NAME).exists():
+        Path(LOGFILES_DIR_NAME).mkdir(parents=True, exist_ok=True)
+
+    logger = logging.getLogger(name)
+
+    if logger.hasHandlers():
+        logger.handlers.clear()
+
+    logger.setLevel(level)
+
+    file_handler = RotatingFileHandler(
+        filename=Path(LOGFILES_DIR_NAME) / f"{name}.log",
+        maxBytes=5 * 1024 * 1024,  # 5 MB
+        backupCount=5,  # Keep up to 5 backup log files
+    )
+    file_handler.setFormatter(formatter)
+    file_handler.setLevel(logging.DEBUG)  # File handler logs everything from DEBUG and above
+
+    console_handler = logging.StreamHandler()
+    console_handler.setFormatter(formatter)
+
+    logger.addHandler(file_handler)
+    logger.addHandler(console_handler)
+
+    logger.propagate = False  # Prevent log messages from being propagated to the root logger
+    logger.info(f"Logger '{name}' initialized with level {logging.getLevelName(level)}")
+
+    return logger

db_drift/utils/exceptions/__init__.py

@@ -0,0 +1,36 @@
+"""Custom exceptions for db-drift application."""
+
+from db_drift.utils.exceptions.base import DbDriftError, DbDriftInterruptError, DbDriftSystemError, DbDriftUserError
+from db_drift.utils.exceptions.cli import CliArgumentError, CliConfigError, CliError, CliUsageError
+from db_drift.utils.exceptions.config import ConfigError, ConfigFormatError, ConfigValidationError, MissingConfigError
+from db_drift.utils.exceptions.database import (
+    DatabaseAuthenticationError,
+    DatabaseConnectionError,
+    DatabaseError,
+    DatabaseQueryError,
+    DatabaseSchemaError,
+    DatabaseTimeoutError,
+)
+from db_drift.utils.exceptions.status_codes import ExitCode
+
+__all__ = [
+    "CliArgumentError",
+    "CliConfigError",
+    "CliError",
+    "CliUsageError",
+    "ConfigError",
+    "ConfigFormatError",
+    "ConfigValidationError",
+    "DatabaseAuthenticationError",
+    "DatabaseConnectionError",
+    "DatabaseError",
+    "DatabaseQueryError",
+    "DatabaseSchemaError",
+    "DatabaseTimeoutError",
+    "DbDriftError",
+    "DbDriftInterruptError",
+    "DbDriftSystemError",
+    "DbDriftUserError",
+    "ExitCode",
+    "MissingConfigError",
+]

db_drift/utils/exceptions/base.py

@@ -0,0 +1,49 @@
+"""Base exceptions for db-drift application."""
+
+
+from db_drift.utils.exceptions.status_codes import ExitCode
+
+
+class DbDriftError(Exception):
+    """Base exception for all db-drift related errors."""
+
+    def __init__(self, message: str, exit_code: int = ExitCode.GENERAL_ERROR) -> None:
+        """
+        Initialize the exception.
+
+        Args:
+            message: The error message
+            exit_code: The exit code to use when this error causes program termination
+        """
+        super().__init__(message)
+        self.message = message
+        self.exit_code = exit_code
+
+    def __str__(self) -> str:
+        """Return the error message."""
+        return self.message
+
+
+class DbDriftUserError(DbDriftError):
+    """Base class for user-caused errors (wrong arguments, invalid config, etc.)."""
+
+    def __init__(self, message: str, exit_code: int = ExitCode.USAGE_ERROR) -> None:
+        """Initialize user error with default exit code 2."""
+        super().__init__(message, exit_code)
+
+
+class DbDriftSystemError(DbDriftError):
+    """Base class for system-level errors (network issues, permission errors, etc.)."""
+
+    def __init__(self, message: str, exit_code: int = ExitCode.GENERAL_ERROR) -> None:
+        """Initialize system error with default exit code 1."""
+        super().__init__(message, exit_code)
+
+
+class DbDriftInterruptError(DbDriftError):
+    """Exception for user interruption (Ctrl+C)."""
+
+    def __init__(self, message: str = "Operation cancelled by user") -> None:
+        """Initialize interrupt error with standard Unix signal exit code."""
+        # 128 + SIGINT (2) = 130
+        super().__init__(message, exit_code=ExitCode.SIGINT)

db_drift/utils/exceptions/cli.py

@@ -0,0 +1,68 @@
+"""CLI-specific exceptions for db-drift."""
+
+from db_drift.utils.exceptions.base import DbDriftUserError
+from db_drift.utils.exceptions.status_codes import ExitCode
+
+
+class CliError(DbDriftUserError):
+    """Base class for CLI-related errors."""
+
+    def __init__(self, message: str, exit_code: int = ExitCode.USAGE_ERROR) -> None:
+        """
+        Initialize CLI error.
+
+        Args:
+            message: The error message
+            exit_code: The exit code (default 2 for CLI usage errors)
+        """
+        super().__init__(message, exit_code)
+
+
+class CliArgumentError(CliError):
+    """Exception for invalid command-line arguments."""
+
+    def __init__(self, message: str, argument: str | None = None) -> None:
+        """
+        Initialize argument error.
+
+        Args:
+            message: The error message
+            argument: The problematic argument name
+        """
+        full_message = f"Invalid argument '{argument}': {message}" if argument else f"Invalid argument: {message}"
+        super().__init__(full_message)
+        self.argument = argument
+
+
+class CliUsageError(CliError):
+    """Exception for incorrect CLI usage."""
+
+    def __init__(self, message: str, suggestion: str | None = None) -> None:
+        """
+        Initialize usage error.
+
+        Args:
+            message: The error message
+            suggestion: Optional suggestion for correct usage
+        """
+        full_message = message
+        if suggestion:
+            full_message += f"\n\nSuggestion: {suggestion}"
+        super().__init__(full_message)
+        self.suggestion = suggestion
+
+
+class CliConfigError(CliError):
+    """Exception for CLI configuration issues."""
+
+    def __init__(self, message: str, config_path: str | None = None) -> None:
+        """
+        Initialize config error.
+
+        Args:
+            message: The error message
+            config_path: Path to the problematic config file
+        """
+        full_message = f"Configuration error in '{config_path}': {message}" if config_path else f"Configuration error: {message}"
+        super().__init__(full_message)
+        self.config_path = config_path

db_drift/utils/exceptions/config.py

@@ -0,0 +1,117 @@
+"""Configuration-related exceptions for db-drift."""
+
+from pathlib import Path
+
+from db_drift.utils.exceptions.base import DbDriftUserError
+from db_drift.utils.exceptions.status_codes import ExitCode
+
+
+class ConfigError(DbDriftUserError):
+    """Base class for configuration-related errors."""
+
+    def __init__(self, message: str, config_path: str | Path | None = None) -> None:
+        """
+        Initialize configuration error.
+
+        Args:
+            message: The error message
+            config_path: Path to the problematic configuration file
+        """
+        full_message = f"Configuration error in '{config_path}': {message}" if config_path else f"Configuration error: {message}"
+
+        super().__init__(full_message)
+        self.exit_code = ExitCode.CONFIG_ERROR
+        self.config_path = str(config_path) if config_path else None
+
+
+class MissingConfigError(ConfigError):
+    """Exception for missing configuration files or required settings."""
+
+    def __init__(
+        self,
+        message: str,
+        config_path: str | Path | None = None,
+        setting_name: str | None = None,
+    ) -> None:
+        """
+        Initialize missing config error.
+
+        Args:
+            message: The error message
+            config_path: Path to the configuration file
+            setting_name: Name of the missing setting
+        """
+        if setting_name and config_path:
+            full_message = f"Missing required setting '{setting_name}' in '{config_path}': {message}"
+        elif setting_name:
+            full_message = f"Missing required setting '{setting_name}': {message}"
+        elif config_path:
+            full_message = f"Missing configuration file '{config_path}': {message}"
+        else:
+            full_message = f"Missing configuration: {message}"
+
+        # Call ConfigError.__init__ instead of super() to avoid double processing
+        DbDriftUserError.__init__(self, full_message)
+        self.config_path = str(config_path) if config_path else None
+        self.setting_name = setting_name
+
+
+class ConfigValidationError(ConfigError):
+    """Exception for invalid configuration values."""
+
+    def __init__(
+        self,
+        message: str,
+        config_path: str | Path | None = None,
+        setting_name: str | None = None,
+        setting_value: str | None = None,
+    ) -> None:
+        """
+        Initialize validation error.
+
+        Args:
+            message: The error message
+            config_path: Path to the configuration file
+            setting_name: Name of the invalid setting
+            setting_value: The invalid value
+        """
+        if setting_name and setting_value:
+            full_message = f"Invalid value '{setting_value}' for setting '{setting_name}': {message}"
+        elif setting_name:
+            full_message = f"Invalid setting '{setting_name}': {message}"
+        else:
+            full_message = f"Invalid configuration: {message}"
+
+        # Call ConfigError.__init__ to get proper path handling
+        super().__init__(full_message, config_path)
+        self.setting_name = setting_name
+        self.setting_value = setting_value
+
+
+class ConfigFormatError(ConfigError):
+    """Exception for configuration file format errors."""
+
+    def __init__(
+        self,
+        message: str,
+        config_path: str | Path | None = None,
+        line_number: int | None = None,
+    ) -> None:
+        """
+        Initialize format error.
+
+        Args:
+            message: The error message
+            config_path: Path to the configuration file
+            line_number: Line number where the error occurred
+        """
+        if line_number and config_path:
+            full_message = f"Format error in '{config_path}' at line {line_number}: {message}"
+        elif config_path:
+            full_message = f"Format error in '{config_path}': {message}"
+        else:
+            full_message = f"Configuration format error: {message}"
+
+        # Call ConfigError.__init__ to get proper path handling
+        super().__init__(full_message, config_path)
+        self.line_number = line_number

db_drift/utils/exceptions/database.py

@@ -0,0 +1,153 @@
+"""Database-related exceptions for db-drift."""
+
+from db_drift.utils.exceptions.base import DbDriftSystemError
+from db_drift.utils.exceptions.status_codes import ExitCode
+
+
+class DatabaseError(DbDriftSystemError):
+    """Base class for database-related errors."""
+
+    def __init__(self, message: str, connection_string: str | None = None) -> None:
+        """
+        Initialize database error.
+
+        Args:
+            message: The error message
+            connection_string: Optional connection string (will be redacted in logs)
+        """
+        super().__init__(message)
+        self.connection_string = connection_string
+
+
+class DatabaseConnectionError(DatabaseError):
+    """Exception for database connection failures."""
+
+    def __init__(
+        self,
+        message: str,
+        connection_string: str | None = None,
+        host: str | None = None,
+        port: int | None = None,
+        database: str | None = None,
+    ) -> None:
+        """
+        Initialize connection error.
+
+        Args:
+            message: The error message
+            connection_string: Optional connection string
+            host: Database host
+            port: Database port
+            database: Database name
+        """
+        if host and database:
+            full_message = f"Failed to connect to database '{database}' on {host}"
+            if port:
+                full_message += f":{port}"
+            full_message += f": {message}"
+        else:
+            full_message = f"Database connection failed: {message}"
+
+        # Override the default exit code for connection errors
+        super().__init__(full_message, connection_string)
+        self.exit_code = ExitCode.UNAVAILABLE
+        self.host = host
+        self.port = port
+        self.database = database
+
+
+class DatabaseQueryError(DatabaseError):
+    """Exception for database query execution errors."""
+
+    def __init__(
+        self,
+        message: str,
+        query: str | None = None,
+        connection_string: str | None = None,
+    ) -> None:
+        """
+        Initialize query error.
+
+        Args:
+            message: The error message
+            query: The problematic SQL query
+            connection_string: Optional connection string
+        """
+        full_message = f"Database query failed: {message}"
+        super().__init__(full_message, connection_string)
+        self.exit_code = ExitCode.SOFTWARE_ERROR
+        self.query = query
+
+
+class DatabaseSchemaError(DatabaseError):
+    """Exception for database schema-related errors."""
+
+    def __init__(
+        self,
+        message: str,
+        schema_name: str | None = None,
+        connection_string: str | None = None,
+    ) -> None:
+        """
+        Initialize schema error.
+
+        Args:
+            message: The error message
+            schema_name: The problematic schema name
+            connection_string: Optional connection string
+        """
+        full_message = f"Schema '{schema_name}' error: {message}" if schema_name else f"Database schema error: {message}"
+
+        super().__init__(full_message, connection_string)
+        self.exit_code = ExitCode.DATA_ERROR
+        self.schema_name = schema_name
+
+
+class DatabaseAuthenticationError(DatabaseError):
+    """Exception for database authentication failures."""
+
+    def __init__(
+        self,
+        message: str = "Authentication failed",
+        username: str | None = None,
+        connection_string: str | None = None,
+    ) -> None:
+        """
+        Initialize authentication error.
+
+        Args:
+            message: The error message
+            username: The username that failed authentication
+            connection_string: Optional connection string
+        """
+        full_message = f"Authentication failed for user '{username}': {message}" if username else f"Database authentication failed: {message}"
+
+        super().__init__(full_message, connection_string)
+        self.exit_code = ExitCode.NO_PERMISSION
+        self.username = username
+
+
+class DatabaseTimeoutError(DatabaseError):
+    """Exception for database operation timeouts."""
+
+    def __init__(
+        self,
+        message: str = "Operation timed out",
+        timeout_seconds: float | None = None,
+        connection_string: str | None = None,
+    ) -> None:
+        """
+        Initialize timeout error.
+
+        Args:
+            message: The error message
+            timeout_seconds: The timeout value that was exceeded
+            connection_string: Optional connection string
+        """
+        if timeout_seconds:
+            full_message = f"Database operation timed out after {timeout_seconds}s: {message}"
+        else:
+            full_message = f"Database operation timed out: {message}"
+
+        super().__init__(full_message, connection_string)
+        self.timeout_seconds = timeout_seconds

db_drift/utils/exceptions/formatting.py

@@ -0,0 +1,175 @@
+"""Error formatting utilities for db-drift."""
+
+import logging
+import sys
+import traceback
+from typing import TextIO
+
+from db_drift.utils.exceptions import CliArgumentError, DatabaseConnectionError, MissingConfigError
+from db_drift.utils.exceptions.base import DbDriftError, DbDriftSystemError
+from db_drift.utils.exceptions.status_codes import ExitCode
+
+
+def format_error_message(error: Exception, show_traceback: bool = False) -> str:  # noqa: FBT001, FBT002
+    """
+    Format an error message for display to the user.
+
+    Args:
+        error: The exception to format
+        show_traceback: Whether to include traceback information. Default is False.
+
+    Returns:
+        Formatted error message
+    """
+    if isinstance(error, DbDriftError):
+        message = str(error)
+    else:
+        # For unexpected exceptions, provide a generic message
+        message = f"An unexpected error occurred: {error.__class__.__name__}"
+        if str(error):
+            message += f": {error}"
+
+    if show_traceback:
+        message += f"\n\nTraceback:\n{''.join(traceback.format_exception(type(error), error, error.__traceback__))}"
+
+    return message
+
+
+def format_suggestion(error: Exception) -> str | None:
+    """
+    Generate helpful suggestions for common errors.
+
+    Args:
+        error: The exception to generate suggestions for
+
+    Returns:
+        Suggestion string or None if no suggestion is available
+    """
+    if isinstance(error, CliArgumentError):
+        return "Use 'db-drift --help' to see available options and their usage."
+
+    if isinstance(error, DatabaseConnectionError):
+        suggestions = [
+            "Check that the database server is running and accessible",
+            "Verify your connection parameters (host, port, database name)",
+            "Ensure your credentials are correct",
+            "Check network connectivity and firewall settings",
+        ]
+        return "Try the following:\n" + "\n".join(f"  • {suggestion}" for suggestion in suggestions)
+
+    if isinstance(error, MissingConfigError):
+        return "Create a configuration file or provide the required settings via command-line arguments."
+
+    return None
+
+
+def print_error(
+    error: Exception,
+    file: TextIO = sys.stderr,
+    show_traceback: bool = False,  # noqa: FBT001, FBT002
+    show_suggestions: bool = True,  # noqa: FBT001, FBT002
+) -> None:
+    """
+    Print a formatted error message to the specified file.
+
+    Args:
+        error: The exception to print
+        file: The file to write to (default: stderr)
+        show_traceback: Whether to include traceback information
+        show_suggestions: Whether to show helpful suggestions
+    """
+    message = format_error_message(error, show_traceback)
+    print(f"Error: {message}", file=file)
+
+    if show_suggestions:
+        suggestion = format_suggestion(error)
+        if suggestion:
+            print(f"\n{suggestion}", file=file)
+
+
+def get_exit_code(error: Exception) -> int:
+    """
+    Get the appropriate exit code for an exception.
+
+    Args:
+        error: The exception
+
+    Returns:
+        Exit code integer
+    """
+    if isinstance(error, DbDriftError):
+        return error.exit_code
+
+    # Standard exit codes for common Python exceptions
+    if isinstance(error, KeyboardInterrupt):
+        return ExitCode.SIGINT
+    if isinstance(error, FileNotFoundError):
+        return ExitCode.NO_INPUT
+    if isinstance(error, PermissionError):
+        return ExitCode.NO_PERMISSION
+    if isinstance(error, ConnectionError):
+        return ExitCode.UNAVAILABLE
+
+    # Default generic error
+    return ExitCode.GENERAL_ERROR
+
+
+def handle_error_and_exit(
+    error: Exception,
+    logger: logging.Logger | None = None,
+    show_traceback: bool = False,  # noqa: FBT001, FBT002
+    show_suggestions: bool = True,  # noqa: FBT001, FBT002
+) -> None:
+    """
+    Handle an error by logging it, printing user-friendly message, and exiting.
+
+    Args:
+        error: The exception to handle
+        logger: Logger instance for detailed logging
+        show_traceback: Whether to show traceback to user
+        show_suggestions: Whether to show helpful suggestions
+    """
+    exit_code = get_exit_code(error)
+
+    # Log the full error details
+    if logger:
+        if isinstance(error, DbDriftError):
+            logger.error(f"{error.__class__.__name__}: {error}")
+        else:
+            logger.exception(f"Unexpected error: {error.__class__.__name__}: {error}")
+
+    # Print user-friendly error
+    print_error(error, show_traceback=show_traceback, show_suggestions=show_suggestions)
+
+    sys.exit(exit_code)
+
+
+def handle_unexpected_error(debug_mode: int, logger: logging.Logger) -> None:
+    """
+    Handle unexpected errors based on debug mode.
+
+    Args:
+        debug_mode(int): Whether debug mode is enabled (1/True) or not (0/False).
+        logger(logging.Logger): The logger instance to use.
+    """
+    if debug_mode:
+        # For debug mode, we'll handle the current exception
+        _, exc_value, _ = sys.exc_info()
+        if exc_value:
+            handle_error_and_exit(
+                exc_value,
+                logger=logger,
+                show_traceback=True,
+                show_suggestions=False,
+            )
+    else:
+        system_error = DbDriftSystemError(
+            "An unexpected error occurred. Set DB_DRIFT_DEBUG=1 for more details.",
+            exit_code=ExitCode.GENERAL_ERROR,
+        )
+        handle_error_and_exit(
+            system_error,
+            logger=logger,
+            show_traceback=False,
+            show_suggestions=False,
+        )

db_drift/utils/exceptions/status_codes.py

@@ -0,0 +1,15 @@
+from enum import Enum, unique
+
+
+@unique
+class ExitCode(Enum):
+    SUCCESS = 0
+    GENERAL_ERROR = 1
+    USAGE_ERROR = 2
+    DATA_ERROR = 65
+    NO_INPUT = 66
+    UNAVAILABLE = 69
+    SOFTWARE_ERROR = 70
+    NO_PERMISSION = 77
+    CONFIG_ERROR = 78
+    SIGINT = 130

{db_drift-1.0.0.dist-info → db_drift-1.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: db-drift
-Version: 1.0.0
+Version: 1.1.0
 Summary: A command line tool to visualize the differences between two DB states.
 Project-URL: source, https://github.com/dyka3773/db-drift
 Author-email: Hercules Konsoulas <dyka3773@gmail.com>
@@ -17,13 +17,13 @@ Classifier: Topic :: Software Development :: Build Tools
 Classifier: Topic :: Software Development :: Version Control
 Classifier: Topic :: Utilities
 Classifier: Typing :: Typed
-Requires-Python: >=3.13
+Requires-Python: >=3.10
 Requires-Dist: oracledb>=3.3.0
 Requires-Dist: psycopg[binary]>=3.2.9
 Requires-Dist: pymysql>=1.1.1
 Requires-Dist: python-dotenv>=1.1.1
-Requires-Dist: pyyaml>=6.0.2
-Requires-Dist: sqlmodel>=0.0.24
+Requires-Dist: pyyaml>=6.0.3
+Requires-Dist: sqlmodel>=0.0.25
 Requires-Dist: sshtunnel>=0.4.0
 Description-Content-Type: text/markdown
 

db_drift-1.1.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+db_drift/__init__.py,sha256=_NNjAEiomu4yVTJIPFaLwCtInFaSItHwbFIOx5V122A,49
+db_drift/__main__.py,sha256=IRyqTl3BK8VaSLkUgdl1YZSYbVF4xJA7gMHW-SWAIzI,3210
+db_drift/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+db_drift/cli/cli.py,sha256=GrixgWJrModpQMspMO1Mzglu3lQdqa5AjZIWKxK1WAE,1060
+db_drift/cli/utils.py,sha256=n1V6flmUPLAy1uAtYLIyRnJJWBAwzYERyHGa2OkpZnU,229
+db_drift/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+db_drift/utils/custom_logging.py,sha256=Kl6yvx7csl3c7n7U2PJLI6PQ5JtGoBwQoYwrWxrg5KE,1672
+db_drift/utils/exceptions/__init__.py,sha256=upEKs7xQu9iIRMqZbRe2JmjaKkJa1FKdoqKiMQUlaDU,1134
+db_drift/utils/exceptions/base.py,sha256=BCFYa13G437_MBARRepvn44HOti60jvKTFVRqvyyqxQ,1680
+db_drift/utils/exceptions/cli.py,sha256=VZAK5YsW3vyrJ1y0p_aO8A2Qpdk0v9-eRoBVpgn0in4,2136
+db_drift/utils/exceptions/config.py,sha256=Ut58eUVjaaKFf04KzrR2PeuMjHwyrHlOQpwQwSjNdYw,4089
+db_drift/utils/exceptions/database.py,sha256=V5ofixnWCLxW6EIHiyEpkCip_anc83ZFABi0RloYabs,4821
+db_drift/utils/exceptions/formatting.py,sha256=QeDL2-sSg5qatFS-JwYCIB3RqLTOwXdRxWD9LVOnMzE,5580
+db_drift/utils/exceptions/status_codes.py,sha256=Uk5hGkWtAvl5qsWroSQzHjQPKGAaKbucsFANO-b8b9E,265
+db_drift-1.1.0.dist-info/METADATA,sha256=YTsG-6ySqF1swoCLZdr56tayAMhf2ajLRjK6eY0mChw,3128
+db_drift-1.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+db_drift-1.1.0.dist-info/entry_points.txt,sha256=pFISFFjEb5q5Z0kYsCdrxvKRij6mvTtntx1uiago-7U,43
+db_drift-1.1.0.dist-info/licenses/LICENSE,sha256=4zi6unpe17RUDMBu7ebh14jdbyvyeT-UA3n8Zl7aW74,1075
+db_drift-1.1.0.dist-info/RECORD,,

db_drift-1.0.0.dist-info/RECORD

@@ -1,6 +0,0 @@
-db_drift/__init__.py,sha256=16f_yXLDNRuhMJCzDoBN5FWbXQ0x7cz3rxABt_03L2o,54
-db_drift-1.0.0.dist-info/METADATA,sha256=2JaVQcwMW_4mzWf5mWBQD9oi-o4oEOxhflNcVNZK6QE,3128
-db_drift-1.0.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-db_drift-1.0.0.dist-info/entry_points.txt,sha256=pFISFFjEb5q5Z0kYsCdrxvKRij6mvTtntx1uiago-7U,43
-db_drift-1.0.0.dist-info/licenses/LICENSE,sha256=4zi6unpe17RUDMBu7ebh14jdbyvyeT-UA3n8Zl7aW74,1075
-db_drift-1.0.0.dist-info/RECORD,,