sqlobjects 1.2.1__tar.gz → 1.2.3__tar.gz

{sqlobjects-1.2.1 → sqlobjects-1.2.3}/CHANGELOG.md

@@ -1,3 +1,22 @@
+## 1.2.3 (2026-02-26)
+
+### Fix
+
+- resolve PostgreSQL test failures and cross-test data pollution
+- **executor**: add overloads to execute() and fix iterator type narrowing
+- **queryset**: replace non-existent executor.session with _get_session()
+- enhance exception handling to surface detailed SQLAlchemy errors
+
+### Refactor
+
+- **metadata**: simplify index handling and config parsing
+
+## 1.2.2 (2026-02-26)
+
+### Fix
+
+- clone Column descriptor per subclass to prevent shared ColumnAttribute binding
+
 ## 1.2.1 (2026-02-25)
 
 ### Refactor

{sqlobjects-1.2.1/sqlobjects.egg-info → sqlobjects-1.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlobjects
-Version: 1.2.1
+Version: 1.2.3
 Summary: Django-style async ORM library based on SQLAlchemy with chainable queries, Q objects, and relationship loading
 Author-email: XtraVisions <gitadmin@xtravisions.com>, Chen Hao <chenhao@xtravisions.com>
 Maintainer-email: XtraVisions <gitadmin@xtravisions.com>, Chen Hao <chenhao@xtravisions.com>

{sqlobjects-1.2.1 → sqlobjects-1.2.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sqlobjects"
-version = "1.2.1"
+version = "1.2.3"
 description = "Django-style async ORM library based on SQLAlchemy with chainable queries, Q objects, and relationship loading"
 readme = "README.md"
 license = "MIT"

{sqlobjects-1.2.1 → sqlobjects-1.2.3}/sqlobjects/database/manager.py

@@ -189,12 +189,17 @@ class Database:
             >>> await db.create_tables(ObjectModel)  # Create all tables
             >>> await db.create_tables(ObjectModel, [User, Post])  # Create specific tables
         """
-        async with self.engine.begin() as conn:
-            if tables is None:
-                await conn.run_sync(base_class.__registry__.create_all)
-            else:
-                table_objects = [model.__table__ for model in tables]
-                await conn.run_sync(base_class.__registry__.create_all, tables=table_objects)
+        try:
+            async with self.engine.begin() as conn:
+                if tables is None:
+                    await conn.run_sync(base_class.__registry__.create_all)
+                else:
+                    table_objects = [model.__table__ for model in tables]
+                    await conn.run_sync(base_class.__registry__.create_all, tables=table_objects)
+        except Exception as e:
+            from ..exceptions import convert_sqlalchemy_error
+
+            raise convert_sqlalchemy_error(e) from e
 
     async def drop_tables(self, base_class, tables: list[type] | None = None) -> None:
         """Drop tables defined in the model registry of SQLObjects base class
@@ -211,12 +216,17 @@ class Database:
             >>> await db.drop_tables(ObjectModel)  # Drop all tables
             >>> await db.drop_tables(ObjectModel, [User, Post])  # Drop specific tables
         """
-        async with self.engine.begin() as conn:
-            if tables is None:
-                await conn.run_sync(base_class.__registry__.drop_all)
-            else:
-                table_objects = [model.__table__ for model in tables]
-                await conn.run_sync(base_class.__registry__.drop_all, tables=table_objects)
+        try:
+            async with self.engine.begin() as conn:
+                if tables is None:
+                    await conn.run_sync(base_class.__registry__.drop_all)
+                else:
+                    table_objects = [model.__table__ for model in tables]
+                    await conn.run_sync(base_class.__registry__.drop_all, tables=table_objects)
+        except Exception as e:
+            from ..exceptions import convert_sqlalchemy_error
+
+            raise convert_sqlalchemy_error(e) from e
 
     async def disconnect(self) -> None:
         """Disconnect database and clean up resources

{sqlobjects-1.2.1 → sqlobjects-1.2.3}/sqlobjects/exceptions.py

@@ -458,8 +458,21 @@ def convert_sqlalchemy_error(error: Exception) -> SQLObjectsError:
         ... except SQLAlchemyError as e:
         ...     raise convert_sqlalchemy_error(e)
     """
+    # Build detailed error message with context
     error_msg = str(error)
 
+    # Add SQL statement if available
+    if hasattr(error, "statement") and getattr(error, "statement", None):
+        error_msg += f"\nSQL: {error.statement}"  # type: ignore[reportAttributeAccessIssue]
+
+    # Add parameters if available
+    if hasattr(error, "params") and getattr(error, "params", None):
+        error_msg += f"\nParams: {error.params}"  # type: ignore[reportAttributeAccessIssue]
+
+    # Add original database error if available
+    if hasattr(error, "orig") and getattr(error, "orig", None):
+        error_msg += f"\nOriginal: {error.orig}"  # type: ignore[reportAttributeAccessIssue]
+
     if isinstance(error, SQLAIntegrityError):
         return IntegrityError(error_msg, original_error=error)
     elif isinstance(error, SQLAOperationalError):

{sqlobjects-1.2.1 → sqlobjects-1.2.3}/sqlobjects/expressions/function.py

@@ -432,13 +432,13 @@ class _FuncWrapper:
 func = _FuncWrapper()
 
 # Add window functions at runtime
-func.row_number = lambda: RowNumberFunction()  # type: ignore
-func.rank = lambda: RankFunction()  # type: ignore
-func.dense_rank = lambda: DenseRankFunction()  # type: ignore
-func.percent_rank = lambda: PercentRankFunction()  # type: ignore
-func.ntile = lambda n: NtileFunction(n)  # type: ignore
-func.lag = lambda col, offset=1, default=None: LagFunction(col, offset, default)  # type: ignore
-func.lead = lambda col, offset=1, default=None: LeadFunction(col, offset, default)  # type: ignore
-func.first_value = lambda col: FirstValueFunction(col)  # type: ignore
-func.last_value = lambda col: LastValueFunction(col)  # type: ignore
-func.nth_value = lambda col, n: NthValueFunction(col, n)  # type: ignore
+func.row_number = lambda: RowNumberFunction()
+func.rank = lambda: RankFunction()
+func.dense_rank = lambda: DenseRankFunction()
+func.percent_rank = lambda: PercentRankFunction()
+func.ntile = lambda n: NtileFunction(n)
+func.lag = lambda col, offset=1, default=None: LagFunction(col, offset, default)
+func.lead = lambda col, offset=1, default=None: LeadFunction(col, offset, default)
+func.first_value = lambda col: FirstValueFunction(col)
+func.last_value = lambda col: LastValueFunction(col)
+func.nth_value = lambda col, n: NthValueFunction(col, n)

{sqlobjects-1.2.1 → sqlobjects-1.2.3}/sqlobjects/fields/core.py

@@ -317,6 +317,7 @@ class ColumnAttribute(ColumnAttributeFunctionMixin, Generic[T]):
     """
 
     inherit_cache = True  # make use of the cache key generated by the superclass from SQLAlchemy
+    is_clause_element = False  # force SQLAlchemy to call __clause_element__() for proper coercion
 
     def __getattr__(self, name):
         """Handle attribute access with proper priority.

{sqlobjects-1.2.1 → sqlobjects-1.2.3}/sqlobjects/metadata.py

@@ -45,25 +45,7 @@ class _RawModelConfig:
 
 @dataclass
 class ModelConfig:
-    """Complete model configuration with all required fields filled.
-
-    This dataclass holds all configuration options that can be applied to a model,
-    including basic settings, database constraints, metadata, and database-specific
-    optimizations. All required fields are guaranteed to have values.
-
-    Attributes:
-        table_name: Database table name (never None after processing)
-        verbose_name: Human-readable singular name for the model (never None)
-        verbose_name_plural: Human-readable plural name for the model (never None)
-        ordering: Default ordering for queries (e.g., ['-created_at', 'name'])
-        indexes: List of database indexes to create for the table
-        constraints: List of database constraints (check, unique) for the table
-        description: Detailed description of the model's purpose (can be None)
-        db_options: Database-specific configuration options by dialect
-        custom: Custom configuration values for application-specific use
-        field_validators: Field-level validators registry
-        field_metadata: Unified field metadata information
-    """
+    """Complete model configuration with all required fields filled."""
 
     table_name: str
     verbose_name: str
@@ -425,25 +407,10 @@ class ModelProcessor(type):
 
     @classmethod
     def _integrate_field_config(mcs, cls: Any, config: ModelConfig) -> ModelConfig:
-        """Integrate field-level configuration into model configuration - optimized version.
-
-        Args:
-            cls: Model class
-            config: Current model configuration
-
-        Returns:
-            Updated model configuration with field-level settings integrated
-        """
-        # Collect all field configuration in single pass
         field_indexes, field_validators, field_metadata = mcs._collect_all_field_config(cls, config.table_name)
-
-        # Merge indexes (avoid duplicates)
-        config.indexes = mcs._merge_indexes(field_indexes, config.indexes, config.table_name)
-
-        # Set validators and metadata
+        config.indexes = field_indexes + config.indexes
         config.field_validators = field_validators
         config.field_metadata = field_metadata
-
         return config
 
     @classmethod
@@ -533,82 +500,6 @@ class ModelProcessor(type):
 
         return indexes, validators, metadata
 
-    @classmethod
-    def _merge_indexes(mcs, field_indexes: list[Index], table_indexes: list[Index], table_name: str) -> list[Index]:
-        """Merge field-level and table-level indexes, avoiding duplicates.
-
-        Args:
-            field_indexes: Indexes generated from field definitions
-            table_indexes: Indexes defined at table level
-            table_name: Database table name
-
-        Returns:
-            Merged list of unique indexes
-        """
-
-        def get_index_signature(idx):  # noqa
-            if hasattr(idx, "_columns") and idx._columns:  # noqa
-                columns = tuple(sorted(str(col) for col in idx._columns))  # noqa
-                return (columns, idx.unique)  # noqa
-            return None
-
-        # Collect table-level index signatures
-        table_signatures = set()
-        for idx in table_indexes:
-            sig = get_index_signature(idx)
-            if sig:
-                table_signatures.add(sig)
-
-        # Filter duplicate field-level indexes
-        merged_indexes = []
-        for idx in field_indexes:
-            sig = get_index_signature(idx)
-            if sig and sig not in table_signatures:
-                merged_indexes.append(idx)
-
-        # Add table-level indexes
-        merged_indexes.extend(table_indexes)
-
-        # Normalize all index naming format
-        return mcs._normalize_all_indexes(merged_indexes, table_name)
-
-    @classmethod
-    def _normalize_all_indexes(mcs, indexes: list[Index], table_name: str) -> list[Index]:
-        """Normalize index names that need normalization.
-
-        Only normalizes indexes with temporary names (starting with __temp__idx_).
-
-        Args:
-            indexes: List of indexes to normalize
-            table_name: Database table name
-
-        Returns:
-            List of indexes with normalized names
-        """
-        normalized_indexes = []
-
-        for idx in indexes:
-            # Only normalize temporary names
-            if not idx.name or not idx.name.startswith(_TEMP_INDEX_PREFIX):
-                normalized_indexes.append(idx)
-                continue
-
-            # Get field name list
-            if hasattr(idx, "columns") and idx.columns:
-                field_names = "_".join(col.name for col in idx.columns)  # noqa
-            elif hasattr(idx, "_columns") and idx._columns:  # noqa
-                # Handle indexes not yet bound to table
-                field_names = "_".join(str(col).split(".")[-1] for col in idx._columns)  # noqa
-            else:
-                normalized_indexes.append(idx)
-                continue
-
-            # Generate standardized name
-            idx.name = f"idx_{table_name}_{field_names}"  # type: ignore[reportAttributeAccessIssue]
-            normalized_indexes.append(idx)
-
-        return normalized_indexes
-
     @classmethod
     def _register_field_validators(mcs, cls: Any, config: ModelConfig) -> None:
         """Register field-level validators to model class.
@@ -634,6 +525,14 @@ class ModelProcessor(type):
         """
         from sqlalchemy import Table
 
+        # Collect fields with explicit indexes to avoid duplicates
+        indexed_fields = set()
+        for idx in config.indexes:
+            if hasattr(idx, "_columns"):
+                for col in idx._columns:
+                    if isinstance(col, str):
+                        indexed_fields.add(col.split(".")[-1])
+
         # Collect column definitions and relationship fields
         columns = []
         relationships = {}
@@ -651,6 +550,10 @@ class ModelProcessor(type):
                     # Use create_table_column method to get independent Column instance
                     if hasattr(column_attr, "create_table_column"):
                         column = column_attr.create_table_column(name)
+                        # Clear index attributes if field has explicit index
+                        if name in indexed_fields:
+                            column.index = False
+                            column.unique = False
                     else:
                         # Fallback for non-ColumnAttribute fields
                         column = column_attr
@@ -685,22 +588,40 @@ class ModelProcessor(type):
 
     @classmethod
     def _post_process_table_indexes(mcs, table, table_name: str) -> None:
-        """Normalize index names after table construction.
+        def col_sig(idx):
+            return tuple(sorted(col.name for col in idx.columns)) if idx.columns else None
 
-        Only normalizes indexes with temporary names (starting with __temp__idx_).
+        full_sig_map: dict[tuple, list] = {}  # (cols, unique) -> indexes
+        col_map: dict[tuple, list] = {}  # cols -> indexes
 
-        Args:
-            table: SQLAlchemy Table instance
-            table_name: Database table name
-        """
-        for idx in table.indexes:
-            # Only normalize temporary names
-            if not idx.name or not idx.name.startswith(_TEMP_INDEX_PREFIX):
+        for idx in list(table.indexes):
+            cs = col_sig(idx)
+            if cs is None:
                 continue
+            full_sig_map.setdefault((cs, getattr(idx, "unique", False)), []).append(idx)
+            col_map.setdefault(cs, []).append(idx)
+
+        to_remove: set = set()
 
-            if hasattr(idx, "columns") and idx.columns:
-                field_names = "_".join(col.name for col in idx.columns)
-                idx.name = f"idx_{table_name}_{field_names}"
+        # Remove exact duplicates: prefer explicit names over SQLAlchemy auto-generated "ix_*"
+        for indexes in full_sig_map.values():
+            if len(indexes) > 1:
+                explicit = [i for i in indexes if not (i.name and i.name.startswith("ix_"))]
+                keep = explicit[0] if explicit else indexes[0]
+                to_remove.update(i for i in indexes if i is not keep)
+
+        # Remove non-unique when unique exists on same columns
+        for indexes in col_map.values():
+            if any(getattr(i, "unique", False) for i in indexes):
+                to_remove.update(i for i in indexes if not getattr(i, "unique", False))
+
+        for idx in to_remove:
+            table.indexes.discard(idx)
+
+        # Normalize temp names after dedup
+        for idx in table.indexes:
+            if idx.name and idx.name.startswith(_TEMP_INDEX_PREFIX) and idx.columns:
+                idx.name = f"idx_{table_name}_{'_'.join(col.name for col in idx.columns)}"
 
     @classmethod
     def _post_process_table_constraints(mcs, table, table_name: str) -> None:
@@ -938,13 +859,25 @@ class ModelProcessor(type):
             cls: Model class
             table: SQLAlchemy Table instance
         """
-        for name, field_def in mcs._get_fields(cls).items():
-            if is_field_definition(field_def) and not getattr(field_def, "_is_relationship", False):
-                column_attr = get_column_from_field(field_def)
-                if column_attr is not None and hasattr(column_attr, "__column__"):
-                    # Update the ColumnAttribute's internal column to reference the table column
-                    if name in table.columns:
-                        column_attr.__column__ = table.columns[name]  # type: ignore[reportAttributeAccessIssue]
+        for name in table.columns.keys():
+            for klass in cls.__mro__:
+                descriptor = klass.__dict__.get(name)
+                if descriptor is not None and hasattr(descriptor, "_column_attribute"):
+                    column_attr = descriptor._column_attribute
+                    if column_attr is None or not hasattr(column_attr, "__column__"):
+                        break
+                    if klass is cls:
+                        column_attr.__column__ = table.columns[name]
+                    else:
+                        new_col_attr = object.__new__(type(column_attr))
+                        new_col_attr.__dict__.update(column_attr.__dict__)
+                        new_col_attr.__column__ = table.columns[name]
+                        new_col_attr.model_class = cls
+                        new_descriptor = object.__new__(type(descriptor))
+                        new_descriptor.__dict__.update(descriptor.__dict__)
+                        new_descriptor._column_attribute = new_col_attr
+                        type.__setattr__(cls, name, new_descriptor)
+                    break
 
     @classmethod
     def _initialize_field_cache(mcs, cls: Any) -> None:
@@ -1011,97 +944,37 @@ class ModelProcessor(type):
 
 
 def _parse_model_config(model_class: Any) -> ModelConfig:
-    """Parse complete configuration for a model class.
-
-    Args:
-        model_class: Model class to process configuration for
-
-    Returns:
-        Complete ModelConfig with all defaults filled
-    """
     config_class = getattr(model_class, "Config", None)
-    if config_class:
-        raw_config = _parse_config_class(config_class)
-    else:
-        raw_config = _RawModelConfig()
+    raw = _parse_config_class(config_class) if config_class else _RawModelConfig()
 
-    return _fill_config_defaults(raw_config, model_class)
-
-
-def _parse_config_class(config_class: type) -> _RawModelConfig:
-    """Parse configuration from a Config inner class.
-
-    Args:
-        config_class: The Config inner class to parse
+    table_name = raw.table_name or pluralize(to_snake_case(model_class.__name__))
+    verbose_name = raw.verbose_name or model_class.__name__
+    verbose_name_plural = raw.verbose_name_plural or pluralize(verbose_name)
 
-    Returns:
-        _RawModelConfig instance with parsed configuration
-    """
-    config = _RawModelConfig()
-
-    # Basic configuration
-    config.table_name = getattr(config_class, "table_name", None)
-    config.ordering = getattr(config_class, "ordering", [])
-
-    # Index configuration
-    config.indexes = getattr(config_class, "indexes", [])
-
-    # Constraint configuration
-    config.constraints = getattr(config_class, "constraints", [])
-
-    # Metadata
-    config.verbose_name = getattr(config_class, "verbose_name", None)
-    config.verbose_name_plural = getattr(config_class, "verbose_name_plural", None)
-    config.description = getattr(config_class, "description", None)
-
-    # Database-specific configuration
-    config.db_options = getattr(config_class, "db_options", {})
-
-    # Custom configuration
-    config.custom = getattr(config_class, "custom", {})
-
-    return config
-
-
-def _fill_config_defaults(config: _RawModelConfig, model_class: Any) -> ModelConfig:
-    """Fill default values for configuration fields that are None.
-
-    Args:
-        config: _RawModelConfig instance to fill defaults for
-        model_class: Model class to generate defaults from
-
-    Returns:
-        ModelConfig instance with defaults filled
-    """
-    # Fill table_name if not set
-    table_name = config.table_name
-    if table_name is None:
-        snake_case_name = to_snake_case(model_class.__name__)
-        table_name = pluralize(snake_case_name)
-
-    # Fill verbose_name if not set
-    verbose_name = config.verbose_name
-    if verbose_name is None:
-        verbose_name = model_class.__name__
-
-    # Fill verbose_name_plural if not set
-    verbose_name_plural = config.verbose_name_plural
-    if verbose_name_plural is None:
-        verbose_name_plural = pluralize(verbose_name)
-
-    # Create complete config with required fields
     return ModelConfig(
         table_name=table_name,
         verbose_name=verbose_name,
         verbose_name_plural=verbose_name_plural,
-        ordering=config.ordering,
-        indexes=config.indexes,
-        constraints=config.constraints,
-        description=config.description,
-        db_options=config.db_options,
-        custom=config.custom,
-        field_validators={},
-        field_metadata={},
+        ordering=raw.ordering,
+        indexes=raw.indexes,
+        constraints=raw.constraints,
+        description=raw.description,
+        db_options=raw.db_options,
+        custom=raw.custom,
+    )
+
+
+def _parse_config_class(config_class: type) -> _RawModelConfig:
+    return _RawModelConfig(
+        table_name=getattr(config_class, "table_name", None),
+        verbose_name=getattr(config_class, "verbose_name", None),
+        verbose_name_plural=getattr(config_class, "verbose_name_plural", None),
+        ordering=getattr(config_class, "ordering", []),
+        indexes=getattr(config_class, "indexes", []),
+        constraints=getattr(config_class, "constraints", []),
+        description=getattr(config_class, "description", None),
+        db_options=getattr(config_class, "db_options", {}),
+        custom=getattr(config_class, "custom", {}),
     )
 
 

{sqlobjects-1.2.1 → sqlobjects-1.2.3}/sqlobjects/queries/executor.py

@@ -1,5 +1,7 @@
 import asyncio
 import gc
+from collections.abc import AsyncGenerator
+from typing import Any, TypeVar, overload
 
 from sqlalchemy import (
     delete,
@@ -11,6 +13,9 @@ from sqlalchemy import (
 )
 
 
+_T = TypeVar("_T")
+
+
 class QueryExecutor:
     """Unified query execution engine with caching and iterator support.
 
@@ -35,6 +40,14 @@ class QueryExecutor:
         readonly = query_type not in self._WRITE_TYPES
         return get_session(self._db_or_session, readonly=readonly)
 
+    @overload
+    async def execute(
+        self, query: Any, query_type: str = ..., *, builder: Any = ..., model_class: type[_T], **kwargs: Any
+    ) -> list[_T]: ...
+    @overload
+    async def execute(
+        self, query: Any, query_type: str = ..., *, builder: Any = ..., model_class: None = ..., **kwargs: Any
+    ) -> list[Any] | int | bool: ...
     async def execute(
         self,
         query,
@@ -91,7 +104,7 @@ class QueryExecutor:
 
         return result
 
-    async def iterator(self, query, chunk_size: int = 1000):
+    async def iterator(self, query, chunk_size: int = 1000) -> AsyncGenerator[Any, None]:
         """Async iterator for processing large datasets in chunks."""
         offset = 0
         processed_chunks = 0
@@ -100,7 +113,7 @@ class QueryExecutor:
             chunk_query = query.offset(offset).limit(chunk_size)
             chunk = await self._execute_query(chunk_query, "all")
 
-            if not chunk:
+            if not isinstance(chunk, list) or not chunk:
                 break
 
             for item in chunk:

{sqlobjects-1.2.1 → sqlobjects-1.2.3}/sqlobjects/queryset.py

@@ -957,11 +957,12 @@ class QuerySet(Generic[T]):
 
     async def raw(self, sql: str, params: dict | None = None) -> list[T]:
         """Execute raw SQL query and return model instances."""
-        if not self._executor.session:
+        session = self._executor._get_session("all")
+        if not session:
             return []
 
         query = text(sql)
-        result = await self._executor.session.execute(query, params or {})
+        result = await session.execute(query, params or {})
 
         instances = []
         for row in result:
@@ -1007,8 +1008,9 @@ class QuerySet(Generic[T]):
 
         # Get database dialect
         dialect_name = "unknown"
-        if hasattr(self._executor, "session") and self._executor.session and hasattr(self._executor.session, "bind"):
-            dialect_name = self._executor.session.bind.dialect.name
+        session = self._executor._get_session("all")
+        if session and hasattr(session, "bind"):
+            dialect_name = session.bind.dialect.name
 
         # Database-specific date expression
         if dialect_name == "postgresql":
@@ -1109,8 +1111,9 @@ class QuerySet(Generic[T]):
 
         # Get database dialect
         dialect_name = "unknown"
-        if hasattr(self._executor, "session") and self._executor.session and hasattr(self._executor.session, "bind"):
-            dialect_name = self._executor.session.bind.dialect.name
+        session = self._executor._get_session("all")
+        if session and hasattr(session, "bind"):
+            dialect_name = session.bind.dialect.name
 
         # Database-specific datetime expression
         if dialect_name == "postgresql":

{sqlobjects-1.2.1 → sqlobjects-1.2.3}/sqlobjects/session.py

@@ -172,6 +172,15 @@ class AsyncSession:
     async def _handle_exception(self, exc: Exception):
         """Handle exceptions with unified error processing."""
         await self.rollback()
+
+        # Log detailed error for debugging when echo is enabled
+        if hasattr(self.bind, "echo") and getattr(self.bind, "echo", False):
+            print(f"SQLObjects Session Error: {exc}")
+            if hasattr(exc, "statement"):
+                print(f"Statement: {exc.statement}")  # type: ignore[reportAttributeAccessIssue]
+            if hasattr(exc, "params"):
+                print(f"Parameters: {exc.params}")  # type: ignore[reportAttributeAccessIssue]
+
         if isinstance(exc, SQLAlchemyError):
             raise convert_sqlalchemy_error(exc) from exc
         raise

{sqlobjects-1.2.1 → sqlobjects-1.2.3/sqlobjects.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlobjects
-Version: 1.2.1
+Version: 1.2.3
 Summary: Django-style async ORM library based on SQLAlchemy with chainable queries, Q objects, and relationship loading
 Author-email: XtraVisions <gitadmin@xtravisions.com>, Chen Hao <chenhao@xtravisions.com>
 Maintainer-email: XtraVisions <gitadmin@xtravisions.com>, Chen Hao <chenhao@xtravisions.com>

{sqlobjects-1.2.1 → sqlobjects-1.2.3}/tests/test_config.py

@@ -44,7 +44,7 @@ class TestDatabaseConfig:
         return config
 
 
-async def test_database_connection(db_type: str, url: str) -> bool:
+async def _check_database_connection(db_type: str, url: str) -> bool:
     """测试数据库连接"""
     if db_type == "postgresql":
         import asyncpg  # type: ignore[reportMissingImports]
@@ -84,7 +84,7 @@ async def check_database_connection(db_type: str) -> bool:
             __import__(driver)
 
         # 测试连接
-        return await test_database_connection(db_type, config["url"])
+        return await _check_database_connection(db_type, config["url"])
 
     except ImportError:
         print(f"❌ {config.get('driver')} not installed for {db_type} testing")  # type: ignore[reportPossiblyUnboundVariable]