fixturify 0.1.10__py3-none-any.whl → 0.1.11__py3-none-any.whl

fixturify/__init__.py

@@ -1,6 +1,6 @@
 """PyTools - A collection of reusable Python utility modules."""
 
-__version__ = "0.1.10"
+__version__ = "0.1.11"
 
 from fixturify.sql_d import sql, Phase, SqlTestConfig
 from fixturify.read_d import read

fixturify/sql_d/__init__.py

@@ -1,7 +1,8 @@
 """SQL module for executing SQL files before/after tests."""
 
 from fixturify.sql_d._config import SqlTestConfig
+from fixturify.sql_d._connection_cache import get_connection_cache
 from fixturify.sql_d._decorator import sql
 from fixturify.sql_d._phase import Phase
 
-__all__ = ["sql", "Phase", "SqlTestConfig"]
+__all__ = ["sql", "Phase", "SqlTestConfig", "get_connection_cache"]

fixturify/sql_d/_connection_cache.py

@@ -0,0 +1,220 @@
+"""Connection cache for sharing database connections across test decorators.
+
+This module provides a singleton cache that stores database connections
+keyed by their configuration. This avoids creating a new connection
+for each @sql decorator invocation, significantly improving test performance.
+"""
+
+import atexit
+import asyncio
+from dataclasses import dataclass
+from typing import Any, Dict, Optional, Tuple, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ._config import SqlTestConfig
+
+
+@dataclass(frozen=True)
+class CacheKey:
+    """Immutable key for connection cache lookup."""
+
+    driver: str
+    host: str
+    database: str
+    user: str
+    port: Optional[int]
+
+    @classmethod
+    def from_config(cls, config: "SqlTestConfig") -> "CacheKey":
+        """Create cache key from SqlTestConfig."""
+        return cls(
+            driver=config.driver,
+            host=config.host,
+            database=config.database,
+            user=config.user,
+            port=config.port,
+        )
+
+
+class ConnectionCache:
+    """
+    Singleton cache for database connections.
+
+    Maintains separate caches for sync and async connections.
+    Connections are created on first access and reused for subsequent calls.
+    All connections are closed when the process exits via atexit handler.
+    """
+
+    _instance: Optional["ConnectionCache"] = None
+
+    def __new__(cls) -> "ConnectionCache":
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+            cls._instance._initialized = False
+        return cls._instance
+
+    def __init__(self) -> None:
+        if self._initialized:
+            return
+        self._initialized = True
+        self._sync_connections: Dict[CacheKey, Any] = {}
+        self._async_connections: Dict[CacheKey, Any] = {}
+        self._sync_close_funcs: Dict[CacheKey, Any] = {}
+        self._async_close_funcs: Dict[CacheKey, Any] = {}
+
+    def get_sync(
+        self,
+        config: "SqlTestConfig",
+        connect_func: Any,
+        connect_params: Dict[str, Any],
+    ) -> Any:
+        """
+        Get or create a sync connection.
+
+        Args:
+            config: Database configuration
+            connect_func: Function to create connection (e.g., driver.connect)
+            connect_params: Parameters to pass to connect_func
+
+        Returns:
+            Database connection object
+        """
+        key = CacheKey.from_config(config)
+
+        if key not in self._sync_connections:
+            connection = connect_func(**connect_params)
+            self._sync_connections[key] = connection
+
+        return self._sync_connections[key]
+
+    async def get_async(
+        self,
+        config: "SqlTestConfig",
+        connect_coro: Any,
+    ) -> Any:
+        """
+        Get or create an async connection.
+
+        Args:
+            config: Database configuration
+            connect_coro: Coroutine that creates connection
+
+        Returns:
+            Database connection object
+        """
+        key = CacheKey.from_config(config)
+
+        if key not in self._async_connections:
+            connection = await connect_coro
+            self._async_connections[key] = connection
+
+        return self._async_connections[key]
+
+    def register_sync_closer(
+        self,
+        config: "SqlTestConfig",
+        close_func: Any,
+    ) -> None:
+        """Register a close function for a sync connection."""
+        key = CacheKey.from_config(config)
+        if key not in self._sync_close_funcs:
+            self._sync_close_funcs[key] = close_func
+
+    def register_async_closer(
+        self,
+        config: "SqlTestConfig",
+        close_func: Any,
+    ) -> None:
+        """Register a close function for an async connection."""
+        key = CacheKey.from_config(config)
+        if key not in self._async_close_funcs:
+            self._async_close_funcs[key] = close_func
+
+    def close_all_sync(self) -> None:
+        """Close all cached sync connections."""
+        for key, connection in list(self._sync_connections.items()):
+            try:
+                if key in self._sync_close_funcs:
+                    self._sync_close_funcs[key](connection)
+                elif hasattr(connection, "close"):
+                    connection.close()
+            except Exception:
+                pass  # Best effort cleanup
+        self._sync_connections.clear()
+        self._sync_close_funcs.clear()
+
+    def close_all_async_sync(self) -> None:
+        """
+        Close all async connections from sync context.
+
+        This is called by atexit handler which runs in sync context.
+        We need to handle async cleanup carefully.
+        """
+        for key, connection in list(self._async_connections.items()):
+            try:
+                if hasattr(connection, "close"):
+                    # Some async connections have sync close()
+                    result = connection.close()
+                    # If close() returns a coroutine, we need to run it
+                    if asyncio.iscoroutine(result):
+                        try:
+                            loop = asyncio.get_event_loop()
+                            if loop.is_running():
+                                # Can't run from within running loop
+                                pass
+                            else:
+                                loop.run_until_complete(result)
+                        except RuntimeError:
+                            # No event loop, create new one
+                            asyncio.run(result)
+            except Exception:
+                pass  # Best effort cleanup
+        self._async_connections.clear()
+        self._async_close_funcs.clear()
+
+    async def close_all_async(self) -> None:
+        """Close all cached async connections from async context."""
+        for key, connection in list(self._async_connections.items()):
+            try:
+                if key in self._async_close_funcs:
+                    await self._async_close_funcs[key](connection)
+                elif hasattr(connection, "close"):
+                    result = connection.close()
+                    if asyncio.iscoroutine(result):
+                        await result
+                    # Handle wait_closed for aiomysql-style connections
+                    if hasattr(connection, "wait_closed"):
+                        await connection.wait_closed()
+            except Exception:
+                pass  # Best effort cleanup
+        self._async_connections.clear()
+        self._async_close_funcs.clear()
+
+    def clear(self) -> None:
+        """Clear all connections (for testing purposes)."""
+        self.close_all_sync()
+        self.close_all_async_sync()
+
+
+# Global cache instance
+_cache: Optional[ConnectionCache] = None
+
+
+def get_connection_cache() -> ConnectionCache:
+    """Get the global connection cache instance."""
+    global _cache
+    if _cache is None:
+        _cache = ConnectionCache()
+    return _cache
+
+
+def _cleanup_connections() -> None:
+    """Cleanup handler called at process exit."""
+    global _cache
+    if _cache is not None:
+        _cache.close_all_sync()
+        _cache.close_all_async_sync()
+
+
+# Register cleanup handler
+atexit.register(_cleanup_connections)

fixturify/sql_d/_strategies/_aiomysql.py

@@ -26,17 +26,14 @@ class AiomysqlStrategy(AsyncSqlExecutionStrategy):
         """Execute SQL using aiomysql."""
         driver = self.get_driver_module()
         params = self.build_connection_params(config)
-        
-        connection = await driver.connect(**params)
-        try:
-            async with connection.cursor() as cursor:
-                # aiomysql doesn't support multi-statement by default
-                await self._execute_statements(cursor, sql_content)
-            await connection.commit()
-        finally:
-            connection.close()
-            if hasattr(connection, "wait_closed"):
-                await connection.wait_closed()
+
+        connection = await self.get_cached_connection_async(
+            config, driver.connect(**params)
+        )
+        async with connection.cursor() as cursor:
+            # aiomysql doesn't support multi-statement by default
+            await self._execute_statements(cursor, sql_content)
+        await connection.commit()
 
     async def _execute_statements(self, cursor: Any, sql_content: str) -> None:
         """

fixturify/sql_d/_strategies/_aiosqlite.py

@@ -22,8 +22,11 @@ class AiosqliteStrategy(AsyncSqlExecutionStrategy):
         """Execute SQL using aiosqlite."""
         driver = self.get_driver_module()
         params = self.build_connection_params(config)
-        
+
         database_path = params.get("database", ":memory:")
-        async with driver.connect(database_path) as connection:
-            await connection.executescript(sql_content)
-            await connection.commit()
+
+        connection = await self.get_cached_connection_async(
+            config, driver.connect(database_path)
+        )
+        await connection.executescript(sql_content)
+        await connection.commit()

fixturify/sql_d/_strategies/_asyncpg.py

@@ -26,9 +26,8 @@ class AsyncpgStrategy(AsyncSqlExecutionStrategy):
         """Execute SQL using asyncpg."""
         driver = self.get_driver_module()
         params = self.build_connection_params(config)
-        
-        connection = await driver.connect(**params)
-        try:
-            await connection.execute(sql_content)
-        finally:
-            await connection.close()
+
+        connection = await self.get_cached_connection_async(
+            config, driver.connect(**params)
+        )
+        await connection.execute(sql_content)

fixturify/sql_d/_strategies/_base.py

@@ -1,7 +1,7 @@
 """Base classes for SQL execution strategies."""
 
 from abc import ABC, abstractmethod
-from typing import Any, Dict, TYPE_CHECKING
+from typing import Any, Callable, Dict, TYPE_CHECKING
 
 if TYPE_CHECKING:
     from .._config import SqlTestConfig
@@ -92,6 +92,28 @@ class SqlExecutionStrategy(ABC):
                 f"Install it with: pip install {self.driver_name}"
             ) from e
 
+    def get_cached_connection(
+        self,
+        config: "SqlTestConfig",
+        connect_func: Callable[..., Any],
+        connect_params: Dict[str, Any],
+    ) -> Any:
+        """
+        Get a cached connection or create a new one.
+
+        Args:
+            config: Database configuration
+            connect_func: Function to create connection
+            connect_params: Parameters for connect_func
+
+        Returns:
+            Database connection (cached or newly created)
+        """
+        from .._connection_cache import get_connection_cache
+
+        cache = get_connection_cache()
+        return cache.get_sync(config, connect_func, connect_params)
+
 
 class AsyncSqlExecutionStrategy(SqlExecutionStrategy):
     """
@@ -116,3 +138,23 @@ class AsyncSqlExecutionStrategy(SqlExecutionStrategy):
         raise RuntimeError(
             f"Strategy {self.driver_name} is async. Use execute_async() instead."
         )
+
+    async def get_cached_connection_async(
+        self,
+        config: "SqlTestConfig",
+        connect_coro: Any,
+    ) -> Any:
+        """
+        Get a cached async connection or create a new one.
+
+        Args:
+            config: Database configuration
+            connect_coro: Coroutine that creates connection
+
+        Returns:
+            Database connection (cached or newly created)
+        """
+        from .._connection_cache import get_connection_cache
+
+        cache = get_connection_cache()
+        return await cache.get_async(config, connect_coro)

fixturify/sql_d/_strategies/_mysql.py

@@ -26,18 +26,15 @@ class MysqlConnectorStrategy(SqlExecutionStrategy):
         """Execute SQL using mysql.connector."""
         driver = self.get_driver_module()
         params = self.build_connection_params(config)
-        
-        connection = driver.connect(**params)
+
+        connection = self.get_cached_connection(config, driver.connect, params)
+        cursor = connection.cursor()
         try:
-            cursor = connection.cursor()
-            try:
-                # MySQL connector doesn't support multi-statement by default
-                self._execute_statements(cursor, sql_content, driver)
-                connection.commit()
-            finally:
-                cursor.close()
+            # MySQL connector doesn't support multi-statement by default
+            self._execute_statements(cursor, sql_content, driver)
+            connection.commit()
         finally:
-            connection.close()
+            cursor.close()
 
     def _execute_statements(self, cursor: Any, sql_content: str, driver: Any) -> None:
         """

fixturify/sql_d/_strategies/_psycopg.py

@@ -27,9 +27,8 @@ class PsycopgStrategy(AsyncSqlExecutionStrategy):
         driver = self.get_driver_module()
         params = self.build_connection_params(config)
 
-        connection = await driver.AsyncConnection.connect(**params)
-        try:
-            await connection.execute(sql_content)
-            await connection.commit()
-        finally:
-            await connection.close()
+        connection = await self.get_cached_connection_async(
+            config, driver.AsyncConnection.connect(**params)
+        )
+        await connection.execute(sql_content)
+        await connection.commit()

fixturify/sql_d/_strategies/_psycopg2.py

@@ -26,15 +26,12 @@ class Psycopg2Strategy(SqlExecutionStrategy):
         """Execute SQL using psycopg2."""
         driver = self.get_driver_module()
         params = self.build_connection_params(config)
-        
-        connection = driver.connect(**params)
+
+        connection = self.get_cached_connection(config, driver.connect, params)
+        cursor = connection.cursor()
         try:
-            cursor = connection.cursor()
-            try:
-                # psycopg2 supports multi-statement execution
-                cursor.execute(sql_content)
-                connection.commit()
-            finally:
-                cursor.close()
+            # psycopg2 supports multi-statement execution
+            cursor.execute(sql_content)
+            connection.commit()
         finally:
-            connection.close()
+            cursor.close()

fixturify/sql_d/_strategies/_sqlite.py

@@ -1,6 +1,6 @@
 """Strategy for sqlite3 driver."""
 
-from typing import TYPE_CHECKING
+from typing import Any, TYPE_CHECKING
 
 from ._base import SqlExecutionStrategy
 
@@ -22,12 +22,13 @@ class Sqlite3Strategy(SqlExecutionStrategy):
         """Execute SQL using sqlite3."""
         driver = self.get_driver_module()
         params = self.build_connection_params(config)
-        
+
         database_path = params.get("database", ":memory:")
-        connection = driver.connect(database_path)
-        try:
-            # SQLite supports executescript for multi-statement execution
-            connection.executescript(sql_content)
-            connection.commit()
-        finally:
-            connection.close()
+
+        def connect_sqlite() -> Any:
+            return driver.connect(database_path)
+
+        connection = self.get_cached_connection(config, connect_sqlite, {})
+        # SQLite supports executescript for multi-statement execution
+        connection.executescript(sql_content)
+        connection.commit()

{fixturify-0.1.10.dist-info → fixturify-0.1.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fixturify
-Version: 0.1.10
+Version: 0.1.11
 Summary: A collection of convenient testing utilities for Python
 Project-URL: Homepage, https://github.com/eleven-sea/pytools
 Project-URL: Repository, https://github.com/eleven-sea/pytools

{fixturify-0.1.10.dist-info → fixturify-0.1.11.dist-info}/RECORD

@@ -1,4 +1,4 @@
-fixturify/__init__.py,sha256=xzimdoGamcRB-WMmfeGc4W-HBYTWQ_M_ypiqWK16_2A,485
+fixturify/__init__.py,sha256=KOtcjgkSXK30bgl49i_edSu2yUNDqWAzVubxosMBqFQ,485
 fixturify/_utils/__init__.py,sha256=Ago2DIAS0UgTvVRxWGisxPoawDFNAB5mbjnC0hYsmNw,334
 fixturify/_utils/_constants.py,sha256=CYkqgI-ljyMcntBUP8ZCQmx7JSsLqyNxzIwNfxm2XkA,453
 fixturify/_utils/_fixture_discovery.py,sha256=u9hfoNdbLz35-X7h6fwdGuQQ8edryGNWfg_ba5i8Nq8,5185
@@ -49,23 +49,24 @@ fixturify/object_mapper/_serializers/_sqlmodel.py,sha256=66PHxMw32rACjaYgjLHSGu_
 fixturify/read_d/__init__.py,sha256=t3f3OxBenqMN-DeEifXJ6A2_jZ4XHo4tkby9XtpIoo0,130
 fixturify/read_d/_decorator.py,sha256=7uKRZ-WkGHxSNf87qlC7u-0PfiNrlZHbnQ-jWXrk5no,7700
 fixturify/read_d/_fixture_loader.py,sha256=9pXJxLOEcdLylZup41wXuok6n7bHYExPBqvFZP2Fya0,2857
-fixturify/sql_d/__init__.py,sha256=nqjA4Bd6h1RCq_kzSVrN2A5kuv8zHqzvYEbgBRyJhEQ,241
+fixturify/sql_d/__init__.py,sha256=Y18FgZFI_z-HUAdQ6uHOppMDZC1W5hYGZhC3ZJZ5pB0,332
 fixturify/sql_d/_config.py,sha256=W3RL1UW9WrYWNHu2FqcOW22Q_loYLi9htXsqARALH6s,762
+fixturify/sql_d/_connection_cache.py,sha256=5J0RLWl-6Aoyc4Ybx5FthsjeN_SA4flWgDrl6L2bODw,7172
 fixturify/sql_d/_decorator.py,sha256=9ynQlODhU5m4d29DjMQMpuMG_Fd0jikhzuMKkNDXUmA,12531
 fixturify/sql_d/_driver_registry.py,sha256=Fwxt86Gv2UbnO7V_FgzaGc1UvCzd8QV5UtHiRdahlNs,3349
 fixturify/sql_d/_executor.py,sha256=iEizcgSKrShh1CHwiVjkM1Xjs1Iiw7WESnzborAQpqY,2271
 fixturify/sql_d/_fixture_discovery.py,sha256=17m3RmJvSH8ygdZoDbkm7RIdcewe5wEyIx6X_40MxjY,1635
 fixturify/sql_d/_phase.py,sha256=zQv2YwRkXSB4Kdeqrcp5BELplWHJVgQd_0wlcjS2eqY,228
 fixturify/sql_d/_strategies/__init__.py,sha256=36IdX6pFdBgZJ1-Cn3HQfwhKgKp-bB9g4qvN3KwoncQ,323
-fixturify/sql_d/_strategies/_aiomysql.py,sha256=IYG1G-yQfugSLTic7bH_iPHfMMF3gaCAF8cZrjmedDk,2179
-fixturify/sql_d/_strategies/_aiosqlite.py,sha256=GmZA2mUtV2fJYCIroqc1ttcPC6ZzksWNQmVwC7cAUEw,916
-fixturify/sql_d/_strategies/_asyncpg.py,sha256=bRgTPoof4GBMhcp-0-1a2dpt4MwGb2NggewemqeShqs,945
-fixturify/sql_d/_strategies/_base.py,sha256=BhtbqN5tQjQzM3au_EZtWawCs1AuSbFUIsyjELrReO8,3459
-fixturify/sql_d/_strategies/_mysql.py,sha256=3l7aoP9FSfG-_sUofN8q9EGvSNjuavWoPU8lkPNQIsE,2452
-fixturify/sql_d/_strategies/_psycopg.py,sha256=3P75nMDJDwx1-JlRDnnPlCHWPXFOKI9BjEfdJChuHxA,1006
-fixturify/sql_d/_strategies/_psycopg2.py,sha256=aeQRpj1k1cTtOWLFnOEaQ7IcTZ-4oV_Z4p6YHsM-iyA,1105
+fixturify/sql_d/_strategies/_aiomysql.py,sha256=uo0y27kfl82c9OqhWSLsx1hHN6ow0gCQLiwi5Bwi5iY,2060
+fixturify/sql_d/_strategies/_aiosqlite.py,sha256=gccGZKYA17JZXG7P4o6NrgHK77BGgErz0XDKWGMAY3A,958
+fixturify/sql_d/_strategies/_asyncpg.py,sha256=3TW0XW6M3jYJGfn8KeZtgLP6XC3jSi2anGVFAn5HCGA,930
+fixturify/sql_d/_strategies/_base.py,sha256=4g-7-W1muTcQ5H4h3pN64m3MiuUou1wMcQeGLohg_4Y,4705
+fixturify/sql_d/_strategies/_mysql.py,sha256=4MG0Pn7GWNYaakqAbFkNT3xOKKJh4DJ9JshHdbJwgts,2389
+fixturify/sql_d/_strategies/_psycopg.py,sha256=8uD-mkeQKuVW9wqnfizw_FJ67MTQ80A1AP8XGvVMMIQ,995
+fixturify/sql_d/_strategies/_psycopg2.py,sha256=2M0fmYtLxFxJXHsgxomaEEzPVS9u0TFs6u4ldIINy08,1042
 fixturify/sql_d/_strategies/_registry.py,sha256=ddQpp9cU4SHA2OylsPpMBMarLyQKmV-4Ge4X395tg1Q,3346
-fixturify/sql_d/_strategies/_sqlite.py,sha256=auW6nV1bfE8UJlk4TW5fZkcqlnr_9q6Eia5bQjE2n3w,965
-fixturify-0.1.10.dist-info/METADATA,sha256=siIGshwAVslx6ql--TW4lmqDi6_NYGd3WxK_2Vg-wcw,2979
-fixturify-0.1.10.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-fixturify-0.1.10.dist-info/RECORD,,
+fixturify/sql_d/_strategies/_sqlite.py,sha256=ZXZwdgzcMdbrE2dUMjbBJD4m1gLec5nAM6DThs108_g,1002
+fixturify-0.1.11.dist-info/METADATA,sha256=4B1_WgTgeN43Lrf1RX_Q69j9mQQaN-h6lM0lCTwp2tI,2979
+fixturify-0.1.11.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+fixturify-0.1.11.dist-info/RECORD,,