DataExcept 0.1.0__py3-none-any.whl

dataexcept/__init__.py

@@ -0,0 +1,81 @@
+"""Top-level package for DataExcept.
+
+Exposes the common job-related exceptions directly and also provides
+access to data science specific exceptions via the ``datascience_exceptions``
+module.
+"""
+
+from pathlib import Path
+
+try:  # Python >=3.11
+    import tomllib  # type: ignore
+except ModuleNotFoundError:  # pragma: no cover - fallback for Python <3.11
+    import tomli as tomllib  # type: ignore
+
+from importlib import import_module, metadata
+from typing import Any
+
+from . import (
+    database_exceptions,
+    dataengineering_exceptions,
+    datascience_exceptions,
+)
+from . import exceptions as _exceptions
+from . import (
+    io_exceptions,
+    network_exceptions,
+    pandas_exceptions,
+    pipeline_exceptions,
+    security_exceptions,
+)
+from .exceptions import (  # noqa: F401
+    AuthenticationError,
+    AuthorizationError,
+    ConfigurationError,
+    ConnectionError,
+    CronExpressionError,
+    DependencyError,
+    DeserializationError,
+    EmailError,
+    JobCancellationError,
+    JobError,
+    NotificationError,
+    ParsingError,
+    ResourceNotFoundError,
+    ScheduleConflictError,
+    SerializationError,
+    TimeoutError,
+    ValidationError,
+    WebhookError,
+)
+from .logging_helpers import log_and_raise, log_exception, log_then_raise
+
+try:
+    __version__ = metadata.version("DataExcept")
+except metadata.PackageNotFoundError:  # pragma: no cover - fallback during dev
+    _root = Path(__file__).resolve().parents[1]
+    with open(_root / "pyproject.toml", "rb") as _f:
+        __version__ = tomllib.load(_f)["tool"]["poetry"]["version"]
+
+__all__ = list(_exceptions.__all__) + [
+    "datascience_exceptions",
+    "job_exceptions",
+    "pipeline_exceptions",
+    "dataengineering_exceptions",
+    "network_exceptions",
+    "io_exceptions",
+    "database_exceptions",
+    "security_exceptions",
+    "pandas_exceptions",
+    "log_exception",
+    "log_and_raise",
+    "log_then_raise",
+]
+
+
+def __getattr__(name: str) -> Any:
+    if name == "job_exceptions":
+        module = import_module("dataexcept.job_exceptions")
+        globals()[name] = module
+        return module
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

dataexcept/__main__.py

@@ -0,0 +1,74 @@
+"""Command line interface for the DataExcept package."""
+
+from __future__ import annotations
+
+import argparse
+import pkgutil
+import sys
+from importlib import import_module
+from types import ModuleType
+from typing import Iterable
+
+from . import __path__ as _PKG_PATH
+from . import __version__
+
+
+def _iter_exception_modules() -> Iterable[ModuleType]:
+    """Yield every submodule that explicitly defines ``__all__``."""
+    allowed_suffixes = ("exceptions", "_exceptions")
+
+    for module_info in pkgutil.walk_packages(
+        _PKG_PATH, prefix="dataexcept.", onerror=lambda name: None
+    ):
+        if not module_info.name.endswith(allowed_suffixes):
+            continue
+        try:
+            module = import_module(module_info.name)
+        except ImportError as exc:  # pragma: no cover - defensive guard
+            print(
+                f"dataexcept: failed to import {module_info.name}: {exc}",
+                file=sys.stderr,
+            )
+            continue
+        if getattr(module, "__all__", None):
+            yield module
+
+
+def _iter_exception_names() -> Iterable[str]:
+    seen: set[str] = set()
+    for module in _iter_exception_modules():
+        names = getattr(module, "__all__", None)
+        if not names:
+            continue
+        for name in names:
+            if name.endswith("Error") and name not in seen:
+                seen.add(name)
+                yield name
+
+
+def _list_exceptions() -> None:
+    for name in sorted(_iter_exception_names()):
+        print(name)
+
+
+def main(argv: list[str] | None = None) -> None:
+    """Entry point for the ``dataexcept`` command."""
+    parser = argparse.ArgumentParser(description="Utilities for DataExcept")
+    parser.add_argument(
+        "--version",
+        action="version",
+        version=f"%(prog)s {__version__}",
+    )
+    subparsers = parser.add_subparsers(dest="command")
+    subparsers.add_parser("list", help="List available exception classes")
+
+    args = parser.parse_args(argv)
+
+    if args.command == "list":
+        _list_exceptions()
+    else:  # pragma: no cover - help message
+        parser.print_help()
+
+
+if __name__ == "__main__":  # pragma: no cover - manual invocation
+    main()

dataexcept/database_exceptions.py

@@ -0,0 +1,71 @@
+"""Custom exceptions for database operations."""
+
+from __future__ import annotations
+
+
+class DatabaseError(Exception):
+    """Base exception for database-related errors."""
+
+    pass
+
+
+class DatabaseConnectionError(DatabaseError):
+    """Raised when connecting to the database fails."""
+
+    def __init__(self, db_url: str, message: str | None = None) -> None:
+        """Initialize DatabaseConnectionError.
+
+        Args:
+            db_url: Database connection URL.
+            message: Optional custom error message.
+        """
+        self.db_url = db_url
+        default = f"Failed to connect to database at '{db_url}'"
+        super().__init__(message or default)
+
+
+class QueryExecutionError(DatabaseError):
+    """Raised when a database query execution fails."""
+
+    def __init__(self, query: str, original: Exception | None = None) -> None:
+        """Initialize QueryExecutionError.
+
+        Args:
+            query: SQL query string.
+            original: Optional underlying exception.
+        """
+        self.query = query
+        self.original = original
+        msg = f"Query failed: {query}"
+        if original:
+            msg += f" ({original})"
+        super().__init__(msg)
+
+
+class TransactionError(DatabaseError):
+    """Raised when a database transaction fails."""
+
+    def __init__(
+        self,
+        transaction_id: str | None = None,
+        message: str | None = None,
+    ) -> None:
+        """Initialize TransactionError.
+
+        Args:
+            transaction_id: Identifier for the transaction.
+            message: Optional custom error message.
+        """
+        self.transaction_id = transaction_id
+        default = "Database transaction failed"
+        if transaction_id:
+            default += f" (id={transaction_id})"
+        super().__init__(message or default)
+
+
+__all__ = [
+    "DatabaseError",
+    "DatabaseConnectionError",
+    "QueryExecutionError",
+    "TransactionError",
+]

dataexcept/dataengineering_exceptions.py

@@ -0,0 +1,125 @@
+"""Custom exceptions for data engineering workflows."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+
+class DataEngineeringError(Exception):
+    """Base exception for data engineering errors."""
+
+    pass
+
+
+class ETLJobError(DataEngineeringError):
+    """Raised when an ETL job fails to complete successfully."""
+
+    def __init__(self, job_name: str, message: Optional[str] = None) -> None:
+        """Initialize ETLJobError.
+
+        Args:
+            job_name: Name of the ETL job.
+            message: Optional custom error message.
+        """
+        self.job_name = job_name
+        default = f"ETL job '{job_name}' failed"
+        super().__init__(message or default)
+
+
+class SchemaEvolutionError(DataEngineeringError):
+    """Raised when database schema evolution fails."""
+
+    def __init__(self, schema_version: str, reason: Optional[str] = None) -> None:
+        """Initialize SchemaEvolutionError.
+
+        Args:
+            schema_version: Version of the schema being applied.
+            reason: Optional explanation of the failure.
+        """
+        self.schema_version = schema_version
+        self.reason = reason
+        msg = f"Schema evolution to {schema_version} failed"
+        if reason:
+            msg += f": {reason}"
+        super().__init__(msg)
+
+
+class DataTransformationError(DataEngineeringError):
+    """Raised when a data transformation step fails."""
+
+    def __init__(self, step: str, details: Optional[str] = None) -> None:
+        """Initialize DataTransformationError.
+
+        Args:
+            step: Name of the transformation step.
+            details: Optional details about the failure.
+        """
+        self.step = step
+        self.details = details
+        msg = f"Data transformation '{step}' failed"
+        if details:
+            msg += f": {details}"
+        super().__init__(msg)
+
+
+class BatchProcessingError(DataEngineeringError):
+    """Raised when processing a data batch fails."""
+
+    def __init__(self, batch_id: str, original: Optional[Exception] = None) -> None:
+        """Initialize BatchProcessingError.
+
+        Args:
+            batch_id: Identifier of the batch being processed.
+            original: Optional underlying exception.
+        """
+        self.batch_id = batch_id
+        self.original = original
+        msg = f"Batch '{batch_id}' processing failed"
+        if original:
+            msg += f": {original}"
+        super().__init__(msg)
+
+
+class DataWarehouseConnectionError(DataEngineeringError):
+    """Raised when a connection to a data warehouse cannot be established."""
+
+    def __init__(self, warehouse: str, message: Optional[str] = None) -> None:
+        """Initialize DataWarehouseConnectionError.
+
+        Args:
+            warehouse: Identifier of the data warehouse.
+            message: Optional custom error message.
+        """
+        self.warehouse = warehouse
+        default = f"Failed to connect to warehouse '{warehouse}'"
+        super().__init__(message or default)
+
+
+class MissingPartitionError(DataEngineeringError):
+    """Raised when a required data partition is missing."""
+
+    def __init__(
+        self, partition: str, location: str, message: Optional[str] = None
+    ) -> None:
+        """Initialize MissingPartitionError.
+
+        Args:
+            partition: Name of the missing partition.
+            location: Data location checked for the partition.
+            message: Optional custom error message.
+        """
+        self.partition = partition
+        self.location = location
+        default = f"Partition '{partition}' not found at {location}"
+        super().__init__(message or default)
+
+
+__all__ = [
+    "DataEngineeringError",
+    "ETLJobError",
+    "SchemaEvolutionError",
+    "DataTransformationError",
+    "BatchProcessingError",
+    "DataWarehouseConnectionError",
+    "MissingPartitionError",
+]

dataexcept/datascience_exceptions/__init__.py

@@ -0,0 +1,85 @@
+"""Custom exceptions for data science workflows."""
+
+from .base import DataScienceError
+from .ingestion import (
+    DataAugmentationError,
+    DataFormatError,
+    DataImbalanceError,
+    DataLeakageError,
+    DataLoadingError,
+    DataNormalizationError,
+    DataValidationError,
+    FeatureEngineeringError,
+    MissingDataError,
+    OutlierDetectionError,
+    SchemaMismatchError,
+)
+from .operations import (
+    DataDriftError,
+    DataExportError,
+    DeploymentError,
+    ResourceLimitError,
+    SerializationError,
+)
+from .training import (
+    BiasDetectionError,
+    ConvergenceError,
+    CrossValidationError,
+    DimensionalityReductionError,
+    EarlyStoppingError,
+    ExperimentTrackingError,
+    ExplainabilityError,
+    FeatureScalingError,
+    FeatureSelectionError,
+    GPUOutOfMemoryError,
+    HyperparameterError,
+    HyperparameterTuningError,
+    ModelCompatibilityError,
+    ModelEvaluationError,
+    ModelInferenceError,
+    ModelTrainingError,
+    OverfittingError,
+    PredictionError,
+    TrainingTimeoutError,
+    UnderfittingError,
+)
+
+__all__ = [
+    "DataScienceError",
+    "DataLoadingError",
+    "DataFormatError",
+    "DataValidationError",
+    "MissingDataError",
+    "OutlierDetectionError",
+    "SchemaMismatchError",
+    "FeatureEngineeringError",
+    "ModelTrainingError",
+    "ConvergenceError",
+    "TrainingTimeoutError",
+    "HyperparameterError",
+    "ModelEvaluationError",
+    "PredictionError",
+    "SerializationError",
+    "DeploymentError",
+    "DataDriftError",
+    "ResourceLimitError",
+    "DataExportError",
+    "FeatureSelectionError",
+    "DimensionalityReductionError",
+    "CrossValidationError",
+    "HyperparameterTuningError",
+    "ExperimentTrackingError",
+    "GPUOutOfMemoryError",
+    "DataNormalizationError",
+    "DataImbalanceError",
+    "ModelInferenceError",
+    "DataAugmentationError",
+    "DataLeakageError",
+    "OverfittingError",
+    "UnderfittingError",
+    "EarlyStoppingError",
+    "BiasDetectionError",
+    "ExplainabilityError",
+    "FeatureScalingError",
+    "ModelCompatibilityError",
+]

dataexcept/datascience_exceptions/base.py

@@ -0,0 +1,17 @@
+"""Base exception shared across data science errors."""
+
+from __future__ import annotations
+
+
+class DataScienceError(Exception):
+    """Base exception for data science errors."""
+
+    def __init__(self, message: str) -> None:
+        # Ensure message is a string
+        if not isinstance(message, str):
+            raise TypeError(f"message must be str, got {type(message).__name__}")
+        self.message = message
+        super().__init__(message)
+
+    def __str__(self) -> str:
+        return f"[DataScienceError] {self.message}"