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

fixturify/__init__.py

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

fixturify/http_d/_recorder.py

@@ -811,10 +811,36 @@ def create_response_from_http_client(
     Returns:
         HttpResponse model
     """
+    import gzip
+    import zlib
+
     headers = dict(response.getheaders()) if hasattr(response, "getheaders") else {}
     content_type = headers.get("content-type", headers.get("Content-Type", ""))
+    content_encoding = headers.get(
+        "content-encoding", headers.get("Content-Encoding", "")
+    ).lower()
 
     body_bytes = response.read()
+
+    # Decompress if needed (http.client doesn't auto-decompress)
+    if body_bytes and content_encoding in ("gzip", "deflate"):
+        try:
+            if content_encoding == "gzip":
+                body_bytes = gzip.decompress(body_bytes)
+            elif content_encoding == "deflate":
+                # deflate can be raw or zlib-wrapped
+                try:
+                    body_bytes = zlib.decompress(body_bytes)
+                except zlib.error:
+                    body_bytes = zlib.decompress(body_bytes, -zlib.MAX_WBITS)
+            # Remove content-encoding header since we decompressed
+            headers = {
+                k: v for k, v in headers.items()
+                if k.lower() != "content-encoding"
+            }
+        except (gzip.BadGzipFile, OSError, zlib.error):
+            pass  # Not actually compressed, use as-is
+
     body, body_encoding, is_binary = _serialize_body(body_bytes, content_type)
 
     if is_binary:
@@ -1312,18 +1338,43 @@ def create_response_from_httpcore(
     Returns:
         HttpResponse model
     """
+    import gzip
+    import zlib
+
     # Convert headers from list of tuples to dict
     headers_dict: Dict[str, str] = {}
+    content_encoding = ""
     if response.headers:
         for k, v in response.headers:
             key = k.decode() if isinstance(k, bytes) else k
             val = v.decode() if isinstance(v, bytes) else v
             headers_dict[key] = val
+            if key.lower() == "content-encoding":
+                content_encoding = val.lower()
 
     content_type = headers_dict.get("content-type", headers_dict.get("Content-Type", ""))
 
     # Get body content
     body_bytes = response.content
+
+    # Decompress if needed (httpcore doesn't auto-decompress)
+    if body_bytes and content_encoding in ("gzip", "deflate"):
+        try:
+            if content_encoding == "gzip":
+                body_bytes = gzip.decompress(body_bytes)
+            elif content_encoding == "deflate":
+                try:
+                    body_bytes = zlib.decompress(body_bytes)
+                except zlib.error:
+                    body_bytes = zlib.decompress(body_bytes, -zlib.MAX_WBITS)
+            # Remove content-encoding header since we decompressed
+            headers_dict = {
+                k: v for k, v in headers_dict.items()
+                if k.lower() != "content-encoding"
+            }
+        except (gzip.BadGzipFile, OSError, zlib.error):
+            pass  # Not actually compressed, use as-is
+
     body, body_encoding, is_binary = _serialize_body(body_bytes, content_type)
 
     if is_binary:

fixturify/http_d/_stubs/_httpcore.py

@@ -9,7 +9,7 @@ import functools
 from typing import TYPE_CHECKING, Any
 
 from .._models import HttpRequest, HttpResponse
-from .._recorder import create_request_from_httpcore, create_response_from_httpcore
+from .._recorder import create_request_from_httpcore
 
 if TYPE_CHECKING:
     from .._mock_context import HttpMockContext
@@ -72,13 +72,14 @@ def _build_response(response_model: HttpResponse) -> Any:
     """Build httpcore Response from HttpResponse model."""
     from httpcore import Response
     import gzip
-    
+    import zlib
+
     # Get content encoding before filtering headers
     content_encoding = response_model.headers.get(
-        "content-encoding", 
+        "content-encoding",
         response_model.headers.get("Content-Encoding", "")
     ).lower()
-    
+
     # Build headers as list of tuples
     headers = [
         (k.encode("ascii"), v.encode("ascii"))
@@ -86,15 +87,21 @@ def _build_response(response_model: HttpResponse) -> Any:
         # Skip headers that cause issues
         if k.lower() not in ("transfer-encoding", "content-encoding")
     ]
-    
+
     body = response_model.get_body_bytes()
-    
-    # Decompress gzip body if needed (since we removed content-encoding header)
-    if content_encoding == "gzip" and body:
+
+    # Decompress body if needed (since we removed content-encoding header)
+    if body and content_encoding in ("gzip", "deflate"):
         try:
-            body = gzip.decompress(body)
-        except (gzip.BadGzipFile, OSError):
-            pass  # Not actually gzip, use as-is
+            if content_encoding == "gzip":
+                body = gzip.decompress(body)
+            elif content_encoding == "deflate":
+                try:
+                    body = zlib.decompress(body)
+                except zlib.error:
+                    body = zlib.decompress(body, -zlib.MAX_WBITS)
+        except (gzip.BadGzipFile, OSError, zlib.error):
+            pass  # Not actually compressed, use as-is
     
     return Response(
         status=response_model.status,
@@ -105,16 +112,17 @@ def _build_response(response_model: HttpResponse) -> Any:
 
 def _serialize_response(httpcore_response: Any) -> HttpResponse:
     """Create HttpResponse from httpcore Response object.
-    
-    Handles gzip decompression before serialization to ensure
+
+    Handles gzip/deflate decompression before serialization to ensure
     body is stored as readable text, not binary.
     """
     import gzip
+    import zlib
     from .._models import HttpResponse
-    
+
     # Get body - should be available after read()/aread()
     body_bytes = httpcore_response.content
-    
+
     # Convert headers
     headers_dict = {}
     content_encoding = ""
@@ -124,21 +132,24 @@ def _serialize_response(httpcore_response: Any) -> HttpResponse:
         headers_dict[key] = val
         if key.lower() == "content-encoding":
             content_encoding = val.lower()
-    
-    # If gzip, decompress body before serialization
-    if content_encoding == "gzip" and body_bytes:
+
+    # Decompress body before serialization if needed
+    if body_bytes and content_encoding in ("gzip", "deflate"):
         try:
-            body_bytes = gzip.decompress(body_bytes)
+            if content_encoding == "gzip":
+                body_bytes = gzip.decompress(body_bytes)
+            elif content_encoding == "deflate":
+                try:
+                    body_bytes = zlib.decompress(body_bytes)
+                except zlib.error:
+                    body_bytes = zlib.decompress(body_bytes, -zlib.MAX_WBITS)
             # Remove content-encoding header since we decompressed
             headers_dict = {
                 k: v for k, v in headers_dict.items()
                 if k.lower() != "content-encoding"
             }
-        except (gzip.BadGzipFile, OSError):
-            pass  # Not actually gzip, use as-is
-    
-    # Determine content type
-    content_type = headers_dict.get("content-type", headers_dict.get("Content-Type", ""))
+        except (gzip.BadGzipFile, OSError, zlib.error):
+            pass  # Not actually compressed, use as-is
     
     # Try to decode as text/JSON
     body_str = None

fixturify/sql_d/_connection_cache.py

@@ -43,6 +43,9 @@ class ConnectionCache:
     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.
+
+    Async connections are tracked with their event loop - if the loop changes
+    or closes, the cached connection is invalidated automatically.
     """
 
     _instance: Optional["ConnectionCache"] = None
@@ -58,7 +61,8 @@ class ConnectionCache:
             return
         self._initialized = True
         self._sync_connections: Dict[CacheKey, Any] = {}
-        self._async_connections: Dict[CacheKey, Any] = {}
+        # Store (connection, event_loop) tuple for async connections
+        self._async_connections: Dict[CacheKey, Tuple[Any, Any]] = {}
         self._sync_close_funcs: Dict[CacheKey, Any] = {}
         self._async_close_funcs: Dict[CacheKey, Any] = {}
 
@@ -90,25 +94,36 @@ class ConnectionCache:
     async def get_async(
         self,
         config: "SqlTestConfig",
-        connect_coro: Any,
+        connect_factory: Any,
     ) -> Any:
         """
         Get or create an async connection.
 
+        Tracks the event loop - if the cached connection was created in a
+        different or closed loop, it's invalidated and a new one is created.
+
         Args:
             config: Database configuration
-            connect_coro: Coroutine that creates connection
+            connect_factory: Callable that returns a coroutine when called
 
         Returns:
             Database connection object
         """
         key = CacheKey.from_config(config)
+        current_loop = asyncio.get_running_loop()
 
-        if key not in self._async_connections:
-            connection = await connect_coro
-            self._async_connections[key] = connection
+        if key in self._async_connections:
+            connection, cached_loop = self._async_connections[key]
+            # Check if loop is the same and still running
+            if cached_loop is current_loop and not cached_loop.is_closed():
+                return connection
+            # Loop changed or closed - remove stale connection
+            del self._async_connections[key]
 
-        return self._async_connections[key]
+        # Create new connection and track with current loop
+        connection = await connect_factory()
+        self._async_connections[key] = (connection, current_loop)
+        return connection
 
     def register_sync_closer(
         self,
@@ -150,7 +165,7 @@ class ConnectionCache:
         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()):
+        for key, (connection, _loop) in list(self._async_connections.items()):
             try:
                 if hasattr(connection, "close"):
                     # Some async connections have sync close()
@@ -174,7 +189,7 @@ class ConnectionCache:
 
     async def close_all_async(self) -> None:
         """Close all cached async connections from async context."""
-        for key, connection in list(self._async_connections.items()):
+        for key, (connection, _loop) in list(self._async_connections.items()):
             try:
                 if key in self._async_close_funcs:
                     await self._async_close_funcs[key](connection)

fixturify/sql_d/_strategies/_aiomysql.py

@@ -28,7 +28,7 @@ class AiomysqlStrategy(AsyncSqlExecutionStrategy):
         params = self.build_connection_params(config)
 
         connection = await self.get_cached_connection_async(
-            config, driver.connect(**params)
+            config, lambda: driver.connect(**params)
         )
         async with connection.cursor() as cursor:
             # aiomysql doesn't support multi-statement by default

fixturify/sql_d/_strategies/_aiosqlite.py

@@ -26,7 +26,7 @@ class AiosqliteStrategy(AsyncSqlExecutionStrategy):
         database_path = params.get("database", ":memory:")
 
         connection = await self.get_cached_connection_async(
-            config, driver.connect(database_path)
+            config, lambda: driver.connect(database_path)
         )
         await connection.executescript(sql_content)
         await connection.commit()

fixturify/sql_d/_strategies/_asyncpg.py

@@ -9,7 +9,11 @@ if TYPE_CHECKING:
 
 
 class AsyncpgStrategy(AsyncSqlExecutionStrategy):
-    """Execution strategy for asyncpg (PostgreSQL async)."""
+    """Execution strategy for asyncpg (PostgreSQL async).
+
+    Uses connection pools instead of single connections to support
+    concurrent operations across multiple tests.
+    """
 
     driver_name = "asyncpg"
     is_async = True
@@ -23,11 +27,13 @@ class AsyncpgStrategy(AsyncSqlExecutionStrategy):
     }
 
     async def execute_async(self, sql_content: str, config: "SqlTestConfig") -> None:
-        """Execute SQL using asyncpg."""
+        """Execute SQL using asyncpg with connection pool."""
         driver = self.get_driver_module()
         params = self.build_connection_params(config)
 
-        connection = await self.get_cached_connection_async(
-            config, driver.connect(**params)
+        # Use pool instead of single connection for concurrency support
+        pool = await self.get_cached_connection_async(
+            config, lambda: driver.create_pool(**params, min_size=1, max_size=5)
         )
-        await connection.execute(sql_content)
+        async with pool.acquire() as connection:
+            await connection.execute(sql_content)

fixturify/sql_d/_strategies/_base.py

@@ -142,14 +142,20 @@ class AsyncSqlExecutionStrategy(SqlExecutionStrategy):
     async def get_cached_connection_async(
         self,
         config: "SqlTestConfig",
-        connect_coro: Any,
+        connect_factory: Any,
     ) -> Any:
         """
         Get a cached async connection or create a new one.
 
+        Note: Async connections are tied to the event loop. For caching to work,
+        pytest must use session-scoped event loop:
+
+            [tool.pytest.ini_options]
+            asyncio_default_fixture_loop_scope = "session"
+
         Args:
             config: Database configuration
-            connect_coro: Coroutine that creates connection
+            connect_factory: Callable that returns a coroutine when called
 
         Returns:
             Database connection (cached or newly created)
@@ -157,4 +163,4 @@ class AsyncSqlExecutionStrategy(SqlExecutionStrategy):
         from .._connection_cache import get_connection_cache
 
         cache = get_connection_cache()
-        return await cache.get_async(config, connect_coro)
+        return await cache.get_async(config, connect_factory)

fixturify/sql_d/_strategies/_psycopg.py

@@ -28,7 +28,7 @@ class PsycopgStrategy(AsyncSqlExecutionStrategy):
         params = self.build_connection_params(config)
 
         connection = await self.get_cached_connection_async(
-            config, driver.AsyncConnection.connect(**params)
+            config, lambda: driver.AsyncConnection.connect(**params)
         )
         await connection.execute(sql_content)
         await connection.commit()

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fixturify
-Version: 0.1.11
+Version: 0.1.12
 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.11.dist-info → fixturify-0.1.12.dist-info}/RECORD

@@ -1,4 +1,4 @@
-fixturify/__init__.py,sha256=KOtcjgkSXK30bgl49i_edSu2yUNDqWAzVubxosMBqFQ,485
+fixturify/__init__.py,sha256=mVvtOZMpeQKxYJ3TR0GtY0HjT6CKi2RgWATp0ErJX-A,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
@@ -13,12 +13,12 @@ fixturify/http_d/_mock_context.py,sha256=cqKzlaGPDuAPNF1k1M3tVUjDU9SUlgICPe0d2YJ
 fixturify/http_d/_models.py,sha256=4hz9S_OTOE55zsCewfTabaR5fDjKJjPTuO_hLcfq8bk,6372
 fixturify/http_d/_patcher.py,sha256=KTMc9pDcr7yA82hHe4aKjP9clmwSOZTwBcsiQm1S8Cc,18700
 fixturify/http_d/_player.py,sha256=4ayKgDOans7AXX8PIfWxn2nxauQBswIUSY2jvL2eIlU,7275
-fixturify/http_d/_recorder.py,sha256=VQVCxIAxeDhXo_uZ3b1Yr7TKw5-jvUEY-ZXO_0DVr0c,40633
+fixturify/http_d/_recorder.py,sha256=mZEu41SAvvD02tOOePy2K20-fxg88OU5VpqfnXX8vk8,42600
 fixturify/http_d/_utils.py,sha256=FJFZC8IS2MzLbPo6D0CUizcJ-LYXc0fVoSJ-04bL5aQ,5799
 fixturify/http_d/_stubs/__init__.py,sha256=sFcWbdqhnHNiYLfKfrrLt6wjGPWo3J-byTDZd2z41wk,171
 fixturify/http_d/_stubs/_aiohttp.py,sha256=c-zGo78_MHfJz_2OsSv0bGnFAR1NgGkACMuzrKd-qII,6672
 fixturify/http_d/_stubs/_connection.py,sha256=Z_g4C_WWL2ErWO26xV3rJqZU48slabtX_al-_LKmGIk,16253
-fixturify/http_d/_stubs/_httpcore.py,sha256=WR_KZGInuVqoBBRML_T6bGe5LEMjbW4ElRem5pz6HiE,9007
+fixturify/http_d/_stubs/_httpcore.py,sha256=vBpvcaf81PVwMDbL0Gxa6uvokV9k4_gGyJybocxNBRE,9473
 fixturify/http_d/_stubs/_tornado.py,sha256=Vm-hETi01xGIjVVvYmVoIOXhzSWAukae48Tzmy0afFY,3219
 fixturify/json_assert/__init__.py,sha256=eDwsoGZPMDparbzKAJ2xXorVsEVPMcbHMXMfue3a3YM,375
 fixturify/json_assert/_actual_saver.py,sha256=_BXTI2CScIUJ7UeeU1-mIKssaDrHGldlFHDtq1o_i80,2355
@@ -51,22 +51,22 @@ fixturify/read_d/_decorator.py,sha256=7uKRZ-WkGHxSNf87qlC7u-0PfiNrlZHbnQ-jWXrk5n
 fixturify/read_d/_fixture_loader.py,sha256=9pXJxLOEcdLylZup41wXuok6n7bHYExPBqvFZP2Fya0,2857
 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/_connection_cache.py,sha256=SEzfcLsj3aX2Rz7cVKCatol7m4cEKFEXqKuE4gw-SGI,8031
 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=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/_aiomysql.py,sha256=4_E0iuRJW0cEikOi4Oh0JkskViEWI6Z6BwLezTzUnSg,2068
+fixturify/sql_d/_strategies/_aiosqlite.py,sha256=NHsnpL2RR7oEnCKwZfhsroMPPOJtj0hhGydbbAypSpk,966
+fixturify/sql_d/_strategies/_asyncpg.py,sha256=JdLS8ckRieEwgSWpq9omQW_Vx0gxR7_ZIsFpiwqRhG4,1228
+fixturify/sql_d/_strategies/_base.py,sha256=KskvsxFpy9DlNpmteLaZ-dgAeJ6FuBjo4qJTYlKMNQk,4957
 fixturify/sql_d/_strategies/_mysql.py,sha256=4MG0Pn7GWNYaakqAbFkNT3xOKKJh4DJ9JshHdbJwgts,2389
-fixturify/sql_d/_strategies/_psycopg.py,sha256=8uD-mkeQKuVW9wqnfizw_FJ67MTQ80A1AP8XGvVMMIQ,995
+fixturify/sql_d/_strategies/_psycopg.py,sha256=rs86H2FnSnFSCMruRF5xjg7tdMsMlYY5Ew7k_J-gpho,1003
 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=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,,
+fixturify-0.1.12.dist-info/METADATA,sha256=hrmOdh-BmfKlt_NfJnjqF_7donwxNu3GVj4zmnyMgTY,2979
+fixturify-0.1.12.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+fixturify-0.1.12.dist-info/RECORD,,