danielutils 1.0.45__tar.gz → 1.0.50__tar.gz

{danielutils-1.0.45/danielutils.egg-info → danielutils-1.0.50}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: danielutils
-Version: 1.0.45
+Version: 1.0.50
 Summary: A python utils library for things I find useful
 Author-email: danielnachumdev <danielnachumdev@gmail.com>
 License: MIT License
@@ -40,7 +40,7 @@ License-File: LICENSE
 [![gitleaks](https://github.com/danielnachumdev/danielutils/actions/workflows/gitleaks.yml/badge.svg)](https://github.com/danielnachumdev/danielutils/actions/workflows/gitleaks.yml)
 [![CodeQL](https://github.com/danielnachumdev/danielutils/actions/workflows/github-code-scanning/codeql/badge.svg)](https://github.com/danielnachumdev/danielutils/actions/workflows/github-code-scanning/codeql)
 
-# danielutils v1.0.39
+# danielutils v1.0.50
 
 A comprehensive Python utilities library designed to enhance your development workflow with powerful tools for type safety, async programming, database operations, and much more.
 
@@ -53,7 +53,7 @@ A comprehensive Python utilities library designed to enhance your development wo
 - 🎨 **Developer Experience**: Progress bars, logging, reflection, and debugging tools
 - 🧮 **Academic Tools**: Probability theory and statistical functions
 
-**Tested Python versions**: `3.8.0+`, `3.9.0`, `3.10.13`, `3.11+`
+**Tested Python versions**: `3.8.0+`, `3.9.0`, `3.10.13`
 
 > **Note**: This package is actively developed and subject to change. Use at your own risk!
 

{danielutils-1.0.45 → danielutils-1.0.50}/README.md

@@ -4,7 +4,7 @@
 [![gitleaks](https://github.com/danielnachumdev/danielutils/actions/workflows/gitleaks.yml/badge.svg)](https://github.com/danielnachumdev/danielutils/actions/workflows/gitleaks.yml)
 [![CodeQL](https://github.com/danielnachumdev/danielutils/actions/workflows/github-code-scanning/codeql/badge.svg)](https://github.com/danielnachumdev/danielutils/actions/workflows/github-code-scanning/codeql)
 
-# danielutils v1.0.39
+# danielutils v1.0.50
 
 A comprehensive Python utilities library designed to enhance your development workflow with powerful tools for type safety, async programming, database operations, and much more.
 
@@ -17,7 +17,7 @@ A comprehensive Python utilities library designed to enhance your development wo
 - 🎨 **Developer Experience**: Progress bars, logging, reflection, and debugging tools
 - 🧮 **Academic Tools**: Probability theory and statistical functions
 
-**Tested Python versions**: `3.8.0+`, `3.9.0`, `3.10.13`, `3.11+`
+**Tested Python versions**: `3.8.0+`, `3.9.0`, `3.10.13`
 
 > **Note**: This package is actively developed and subject to change. Use at your own risk!
 

{danielutils-1.0.45 → danielutils-1.0.50}/danielutils/abstractions/__init__.py

@@ -1,4 +1,3 @@
-from .database import *
 from .db import *
 from .multiprogramming import *
 from .repl import *

{danielutils-1.0.45 → danielutils-1.0.50}/danielutils/abstractions/db/__init__.py

@@ -7,4 +7,4 @@ from .database_definitions import *
 from .database_exceptions import *
 from .database_factory import *
 from .dependencies import *
-from .initializer import *
+from .database_initializer import *

{danielutils-1.0.45 → danielutils-1.0.50}/danielutils/abstractions/db/database.py

@@ -1,6 +1,6 @@
 import functools
 from abc import ABC, abstractmethod
-from typing import Dict, Any, List, Callable, TypeVar, cast, Optional
+from typing import Dict, Any, List, Callable, TypeVar, cast, Optional, Set
 from .database_exceptions import DBException
 from .database_definitions import TableSchema, SelectQuery, UpdateQuery, DeleteQuery
 
@@ -17,23 +17,41 @@ class Database(ABC):
         Private decorator to wrap database implementation methods and convert implementation-specific
         exceptions to our standard database exceptions.
         """
+
         @functools.wraps(db_method)
-        def wrapper(self: 'Database', *args: Any, **kwargs: Any) -> Any:
+        async def wrapper(self: 'Database', *args: Any, **kwargs: Any) -> Any:
             try:
-                return db_method(self, *args, **kwargs)
+                return await db_method(self, *args, **kwargs)
             except DBException:
                 raise
             except Exception as e:
                 raise cls._default_class_exception_conversion(e)
+
         return cast(F, wrapper)
 
+    @classmethod
+    def _get_functions_with_auto_converted_exceptions(cls) -> Set[str]:
+        return {
+            "connect",
+            "disconnect",
+            "get_schemas",
+            "create_table",
+            "insert",
+            "get",
+            "update",
+            "delete"
+        }
+
     @classmethod
     def __init_subclass__(cls) -> None:
         """Initialize subclass by wrapping all public methods with exception handling"""
         for name, method in cls.__dict__.items():
-            if (callable(method) and
-                not name.startswith('_') and
-                    not isinstance(method, (classmethod, staticmethod))):
+            if (
+                    callable(method) and
+                    not name.startswith('_') and
+                    not isinstance(method, (classmethod, staticmethod))
+                    and name in cls._get_functions_with_auto_converted_exceptions()
+            ):
                 setattr(cls, name, cls._wrap_db_exceptions(method))
 
     @classmethod
@@ -48,19 +66,19 @@ class Database(ABC):
         Returns:
             Exception: The converted exception
         """
-        return DBException(f"Database error: {str(e)}", e)
+        return DBException(f"Database error: {str(e)}")
 
-    def __enter__(self) -> 'Database':
+    async def __aenter__(self) -> 'Database':
         """
         Context manager entry point. Connects to the database.
 
         Returns:
             Database: The database instance for use in the context
         """
-        self.connect()
+        await self.connect()
         return self
 
-    def __exit__(self, exc_type: Optional[type], exc_val: Optional[Exception], exc_tb: Optional[Any]) -> None:
+    async def __aexit__(self, exc_type: Optional[type], exc_val: Optional[Exception], exc_tb: Optional[Any]) -> None:
         """
         Context manager exit point. Disconnects from the database.
 
@@ -69,18 +87,22 @@ class Database(ABC):
             exc_val: The exception instance that was raised, if any
             exc_tb: The traceback for the exception, if any
         """
-        self.disconnect()
+        await self.disconnect()
 
     @abstractmethod
-    def connect(self) -> None:
+    async def connect(self) -> None:
         """Establish connection to the database"""
 
     @abstractmethod
-    def disconnect(self) -> None:
+    async def disconnect(self) -> None:
         """Close the database connection"""
 
     @abstractmethod
-    def get_schemas(self) -> Dict[str, TableSchema]:
+    def is_connected(self) -> bool:
+        """Check if the database connection is open"""
+
+    @abstractmethod
+    async def get_schemas(self) -> Dict[str, TableSchema]:
         """
         Get the complete database schema
 
@@ -89,7 +111,7 @@ class Database(ABC):
         """
 
     @abstractmethod
-    def create_table(self, schema: TableSchema) -> None:
+    async def create_table(self, schema: TableSchema) -> None:
         """
         Create a new table in the database
 
@@ -98,7 +120,7 @@ class Database(ABC):
         """
 
     @abstractmethod
-    def insert(self, table: str, data: Dict[str, Any]) -> Any:
+    async def insert(self, table: str, data: Dict[str, Any]) -> Any:
         """
         Insert a record into the specified table
 
@@ -111,7 +133,7 @@ class Database(ABC):
         """
 
     @abstractmethod
-    def get(self, query: SelectQuery) -> List[Dict[str, Any]]:
+    async def get(self, query: SelectQuery) -> List[Dict[str, Any]]:
         """
         Get records from the database
 
@@ -123,7 +145,7 @@ class Database(ABC):
         """
 
     @abstractmethod
-    def update(self, query: UpdateQuery) -> int:
+    async def update(self, query: UpdateQuery) -> int:
         """
         Update records in the database
 
@@ -135,7 +157,7 @@ class Database(ABC):
         """
 
     @abstractmethod
-    def delete(self, query: DeleteQuery) -> int:
+    async def delete(self, query: DeleteQuery) -> int:
         """
         Delete records from the database
 

{danielutils-1.0.45 → danielutils-1.0.50}/danielutils/abstractions/db/database_exceptions.py

@@ -1,6 +1,13 @@
+from typing import Optional
+
+
 class DBException(Exception):
     """Base class for all database exceptions"""
 
+    def __init__(self, message: Optional[str] = None, status_code: Optional[int] = None) -> None:
+        super().__init__(message)
+        self.status_code = status_code
+
 
 class DBConnectionError(DBException):
     """Raised when there is an error connecting to the database"""

{danielutils-1.0.45 → danielutils-1.0.50}/danielutils/abstractions/db/database_factory.py

@@ -3,6 +3,13 @@ from typing import Literal, Dict, Any, Optional, Tuple
 from .database import Database
 from .implementations import InMemoryDatabase, SQLiteDatabase, PersistentInMemoryDatabase, RedisDatabase
 
+MAPPING = {
+    "sqlite": SQLiteDatabase,
+    "memory": InMemoryDatabase,
+    "persistent_memory": PersistentInMemoryDatabase,
+    "redis": RedisDatabase
+}
+
 
 class DatabaseFactory(ABC):
     """Factory class for creating database instances"""
@@ -12,8 +19,7 @@ class DatabaseFactory(ABC):
     @classmethod
     def get_database(
             cls,
-            db_type: Literal["sqlite", "memory",
-                             "persistent_memory", "redis"] = "persistent_memory",
+            db_type: Literal["sqlite", "memory", "persistent_memory", "redis"] = "persistent_memory",
             db_args: Optional[Tuple[Any, ...]] = None,
             db_kwargs: Optional[Dict[str, Any]] = None
     ) -> Database:
@@ -29,19 +35,13 @@ class DatabaseFactory(ABC):
             Database: Database instance
         """
         if db_type not in cls._instances:
-            mapping = {
-                "sqlite": SQLiteDatabase,
-                "memory": InMemoryDatabase,
-                "persistent_memory": PersistentInMemoryDatabase,
-                "redis": RedisDatabase
-            }
-            if db_type not in mapping:
+            if db_type not in MAPPING:
                 raise ValueError(f"Unsupported database type: '{db_type}'")
 
             # Convert None to empty tuple/dict for database initialization
             args = db_args or ()
             kwargs = db_kwargs or {}
-            cls._instances[db_type] = mapping[db_type](*args, **kwargs)
+            cls._instances[db_type] = MAPPING[db_type](*args, **kwargs)
         return cls._instances[db_type]
 
     @classmethod

danielutils-1.0.50/danielutils/abstractions/db/database_initializer.py

@@ -0,0 +1,256 @@
+import logging
+from abc import ABC, abstractmethod
+from typing import Dict, Optional, Type, Any, Sequence
+
+try:
+    from sqlalchemy import inspect, Column
+    from sqlalchemy.orm import DeclarativeBase
+except ImportError:
+    from ...mock_ import MockImportObject
+
+    inspect = MockImportObject("'sqlalchemy' is not installed")  # type:ignore
+    Column = MockImportObject("'sqlalchemy' is not installed")  # type:ignore
+    DeclarativeBase = type("DeclarativeBase", (object,), {})  # type:ignore
+
+from .database import Database
+from .database_definitions import ColumnType, TableSchema, TableColumn as ColumnSchema, TableIndex as IndexSchema
+
+logger = logging.getLogger(__name__)
+
+TYPE_MAPPING = {
+    'INTEGER': ColumnType.INTEGER,
+    'BIGINT': ColumnType.INTEGER,
+    'FLOAT': ColumnType.FLOAT,
+    'NUMERIC': ColumnType.FLOAT,
+    'DECIMAL': ColumnType.FLOAT,
+    'BOOLEAN': ColumnType.BOOLEAN,
+    'TEXT': ColumnType.TEXT,
+    'VARCHAR': ColumnType.TEXT,
+    'CHAR': ColumnType.TEXT,
+    'UUID': ColumnType.TEXT,
+    'DATETIME': ColumnType.DATETIME,
+    'DATE': ColumnType.DATE,
+    'TIME': ColumnType.TIME,
+    'JSON': ColumnType.JSON,
+    'BLOB': ColumnType.BLOB,
+}
+
+
+async def validate_schema(db: Database, table_name: str, expected_schema: TableSchema) -> bool:
+    """
+    Validate that the existing table schema matches the expected schema.
+
+    Args:
+        db: Database instance
+        table_name: Name of the table to validate
+        expected_schema: Expected table schema
+
+    Returns:
+        bool: True if schema matches, False otherwise
+    """
+    try:
+        # Get existing schema
+        existing_schemas = await db.get_schemas()
+        if table_name not in existing_schemas:
+            logger.warning(f"Table '{table_name}' does not exist")
+            return False
+
+        existing_schema = existing_schemas[table_name]
+
+        # Compare columns
+        if len(existing_schema.columns) != len(expected_schema.columns):
+            logger.warning(
+                f"Column count mismatch in '{table_name}': "
+                f"expected {len(expected_schema.columns)}, "
+                f"got {len(existing_schema.columns)}"
+            )
+            return False
+
+        # Compare each column
+        for expected_col, existing_col in zip(expected_schema.columns, existing_schema.columns
+                                              ):
+            if (
+                    expected_col.name != existing_col.name or
+                    expected_col.type != existing_col.type or
+                    expected_col.primary_key != existing_col.primary_key or
+                    expected_col.nullable != existing_col.nullable or
+                    expected_col.unique != existing_col.unique or
+                    expected_col.foreign_key != existing_col.foreign_key
+            ):
+                logger.warning(
+                    f"Column mismatch in '{table_name}': expected {expected_col}, got {existing_col}"
+                )
+                return False
+
+        # Compare indexes
+        if len(existing_schema.indexes) != len(expected_schema.indexes):
+            logger.warning(
+                f"Index count mismatch in '{table_name}': "
+                f"expected {len(expected_schema.indexes)}, "
+                f"got {len(existing_schema.indexes)}"
+            )
+            return False
+
+        # Compare each index
+        for expected_idx, existing_idx in zip(expected_schema.indexes, existing_schema.indexes):
+            if (
+                    expected_idx.name != existing_idx.name or
+                    expected_idx.columns != existing_idx.columns or
+                    expected_idx.unique != existing_idx.unique
+            ):
+                logger.warning(f"Index mismatch in '{table_name}': expected {expected_idx}, got {existing_idx}")
+                return False
+
+        return True
+
+    except Exception as e:
+        logger.error(f"Error validating schema for '{table_name}': {str(e)}")
+        return False
+
+
+def get_column_type(column: Column) -> ColumnType:
+    """Convert SQLAlchemy column type to our ColumnType enum"""
+    # Ensure autoincrement for integer primary key named 'id'
+    if (
+            column.name == 'id'
+            and getattr(column, 'primary_key', False)
+            and ('INTEGER' in str(column.type).upper() or 'BIGINT' in str(column.type).upper())
+    ):
+        return ColumnType.AUTOINCREMENT
+    # Check for autoincrement attribute
+    if getattr(column, 'autoincrement', False) == True:
+        return ColumnType.AUTOINCREMENT
+    # Then check the column type
+    type_name = str(column.type).upper()
+    for sql_type, our_type in TYPE_MAPPING.items():
+        if sql_type in type_name:
+            return our_type
+    return ColumnType.TEXT  # Default to TEXT if type not found
+
+
+def get_foreign_key(column: Column) -> Optional[Dict[str, str]]:
+    """Extract foreign key information from a column"""
+    for fk in column.foreign_keys:
+        return {
+            "table": fk.column.table.name,
+            "column": fk.column.name
+        }
+    return None
+
+
+def get_default_value(column: Column) -> Optional[Any]:
+    """Extract default value from a column"""
+    if column.default is not None:
+        if hasattr(column.default, 'arg'):
+            return column.default.arg
+        return column.default
+    return None
+
+
+def model_to_schema(model_class: Type[DeclarativeBase]) -> TableSchema:
+    """Convert a SQLAlchemy model to our TableSchema"""
+    mapper = inspect(model_class)
+    table_name = mapper.local_table.name  # type: ignore
+
+    # Convert columns
+    columns = []
+    for column in mapper.columns:
+        # Get unique constraint from column
+        is_unique = False
+        if column.unique:
+            is_unique = True
+        elif column.index and column.index.unique:  # type: ignore
+            is_unique = True
+
+        col_schema = ColumnSchema(
+            name=column.name,
+            type=get_column_type(column),
+            primary_key=column.primary_key,
+            nullable=column.nullable,  # type: ignore
+            unique=is_unique,
+            foreign_key=get_foreign_key(column),
+            default=get_default_value(column)
+        )
+        columns.append(col_schema)
+
+    # Convert indexes
+    indexes = []
+    for index in mapper.local_table.indexes:  # type: ignore
+        # Skip indexes that are already handled by unique constraints
+        if len(index.columns) == 1 and index.columns[0].unique:
+            continue
+
+        idx_schema = IndexSchema(
+            name=index.name,
+            columns=[col.name for col in index.columns],
+            unique=index.unique
+        )
+        indexes.append(idx_schema)
+
+    return TableSchema(
+        name=table_name,
+        columns=columns,
+        indexes=indexes
+    )
+
+
+class DatabaseInitializer(ABC):
+    # Map SQLAlchemy types to our ColumnType enum
+
+    @classmethod
+    @abstractmethod
+    def _get_models(cls) -> Sequence[Type[DeclarativeBase]]:
+        """Get all pydantic models from our models"""
+
+    @classmethod
+    def _get_table_schemas(cls) -> Dict[str, TableSchema]:
+        """Get all table schemas from our models"""
+        models = cls._get_models()
+        res = {}
+        for model in models:
+            try:
+                res[model.__tablename__] = model_to_schema(model)
+            except Exception as e:
+                raise Exception(f"Failed parsing '{model.__tablename__}'") from e
+        return res
+
+    @classmethod
+    async def init_db(cls, db: Database) -> None:
+        """
+        Initialize the database by creating or validating all required tables.
+
+        Args:
+            db: Database instance to initialize
+        """
+        try:
+            await db.connect()
+
+            # Get existing schemas
+            existing_schemas = await db.get_schemas()
+
+            # Get table schemas from models
+            table_schemas = cls._get_table_schemas()
+
+            # Create or validate each table
+            for table_name, expected_schema in table_schemas.items():
+                if table_name not in existing_schemas:
+                    logger.info(f"Creating table '{table_name}'")
+                    await db.create_table(expected_schema)
+                else:
+                    logger.info(f"Validating table '{table_name}'")
+                    if not await validate_schema(db, table_name, expected_schema):
+                        raise ValueError(
+                            f"Schema validation failed for table '{table_name}'. "
+                            "Please check the logs for details."
+                        )
+
+            logger.info("Database initialization completed successfully")
+
+        except Exception as e:
+            logger.error(f"Error initializing database: {str(e)}")
+            raise
+
+
+__all__ = [
+    "DatabaseInitializer"
+]

{danielutils-1.0.45 → danielutils-1.0.50}/danielutils/abstractions/db/dependencies.py

@@ -4,4 +4,3 @@ from .database_factory import DatabaseFactory
 
 def get_db() -> Database:
     return DatabaseFactory.get_database_from_settings()
- 

{danielutils-1.0.45 → danielutils-1.0.50}/danielutils/abstractions/db/implementations/in_memory_database.py

@@ -1,5 +1,5 @@
 import logging
-from typing import Dict, Any, List
+from typing import Dict, Any, List, Type, Union, Sequence
 from datetime import datetime
 
 try:
@@ -18,16 +18,19 @@ from ..database_exceptions import DBValidationError, DBQueryError, DBConnectionE
 class InMemoryDatabase(Database):
     """In-memory database implementation using dictionaries"""
 
+    def is_connected(self) -> bool:
+        return self._connected
+
     @classmethod
     def _default_class_exception_conversion(cls, e: Exception) -> Exception:
         """
         Convert in-memory database specific exceptions to standard database exceptions.
         """
         if isinstance(e, ValueError):
-            return DBValidationError(f"Validation error: {str(e)}", e)
+            return DBValidationError(f"Validation error: {str(e)}")
         if isinstance(e, RuntimeError):
-            return DBQueryError(f"Query error: {str(e)}", e)
-        return DBException(f"Database error: {str(e)}", e)
+            return DBQueryError(f"Query error: {str(e)}")
+        return DBException(f"Database error: {str(e)}")
 
     def __init__(self, *args, **kwargs) -> None:
         try:
@@ -42,23 +45,19 @@ class InMemoryDatabase(Database):
         self._connected = False
         self.logger = logging.getLogger(__name__)
 
-    def connect(self) -> None:
+    async def connect(self) -> None:
         """Connect to the database (no-op for in-memory)"""
         self._connected = True
         self.logger.info("Connected to in-memory database")
 
-    def disconnect(self) -> None:
+    async def disconnect(self) -> None:
         """Disconnect from the database (no-op for in-memory)"""
         self._connected = False
         self.logger.info("Disconnected from in-memory database")
 
-    def is_connected(self) -> bool:
-        """Check if connected to the database"""
-        return self._connected
-
-    def create_table(self, schema: TableSchema) -> None:
+    async def create_table(self, schema: TableSchema) -> None:
         """Create a new table with the given schema"""
-        if not self._connected:
+        if not self.is_connected():
             raise RuntimeError("Not connected to database")
 
         if schema.name in self.tables:
@@ -98,16 +97,16 @@ class InMemoryDatabase(Database):
                 f"Column '{column}' is not an auto-increment column")
         self.auto_increment_counters[table][column] -= 1
 
-    def get_schemas(self) -> Dict[str, TableSchema]:
+    async def get_schemas(self) -> Dict[str, TableSchema]:
         """Get all table schemas"""
-        if not self._connected:
+        if not self.is_connected():
             raise RuntimeError("Not connected to database")
 
         return {schema.name: schema for schema in self.schemas.values()}
 
-    def insert(self, table: str, data: Dict[str, Any]) -> Any:
+    async def insert(self, table: str, data: Dict[str, Any]) -> Any:
         """Insert a new row into the table"""
-        if not self._connected:
+        if not self.is_connected():
             raise RuntimeError("Not connected to database")
 
         if table not in self.tables:
@@ -165,9 +164,9 @@ class InMemoryDatabase(Database):
             f"Inserted row into '{table}' with ID '{row_data['id']}'")
         return row_data['id']
 
-    def get(self, query: SelectQuery) -> List[Dict[str, Any]]:
+    async def get(self, query: SelectQuery) -> List[Dict[str, Any]]:
         """Get rows from the table matching the query"""
-        if not self._connected:
+        if not self.is_connected():
             raise DBConnectionError("Not connected to database")
 
         if query.table not in self.tables:
@@ -203,9 +202,9 @@ class InMemoryDatabase(Database):
 
         return rows
 
-    def update(self, query: UpdateQuery) -> int:
+    async def update(self, query: UpdateQuery) -> int:
         """Update rows in the table matching the query"""
-        if not self._connected:
+        if not self.is_connected():
             raise RuntimeError("Not connected to database")
 
         if query.table not in self.tables:
@@ -236,9 +235,9 @@ class InMemoryDatabase(Database):
         self.logger.info(f"Updated '{updated_count}' rows in '{query.table}'")
         return updated_count
 
-    def delete(self, query: DeleteQuery) -> int:
+    async def delete(self, query: DeleteQuery) -> int:
         """Delete rows from the table matching the query"""
-        if not self._connected:
+        if not self.is_connected():
             raise RuntimeError("Not connected to database")
 
         if query.table not in self.tables:
@@ -263,7 +262,7 @@ class InMemoryDatabase(Database):
         if value is None:
             return column.nullable
 
-        type_map = {
+        type_map: Dict[str, Union[Type, Sequence[Type]]] = {
             "INTEGER": int,
             "BIGINT": int,
             "FLOAT": float,
@@ -351,9 +350,9 @@ class InMemoryDatabase(Database):
         elif condition.operator == Operator.CONTAINS_CS:
             return str(condition.value) in str(value)
         elif condition.operator == Operator.IN:
-            return value in condition.values
+            return value in condition.values  # type: ignore
         elif condition.operator == Operator.NOT_IN:
-            return value not in condition.values
+            return value not in condition.values  # type: ignore
         elif condition.operator == Operator.IS_NULL:
             return value is None
         elif condition.operator == Operator.IS_NOT_NULL: