trying to fix warnings

Author: antonkulaga

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "biothings-typed-client"
-version = "0.0.4"
+version = "0.0.5"
 description = "A strongly-typed Python wrapper around the BioThings Client library, providing type safety and better IDE support through Python's type hints and Pydantic models."
 readme = "README.md"
 authors = [
@@ -30,5 +30,5 @@ exclude = [
 [dependency-groups]
 dev = [
     "pytest>=8.3.5",
-    "pytest-asyncio>=0.26.0",
+    "pytest-asyncio>=1.0.0",
 ]

src/biothings_typed_client/abstract_client.py

@@ -299,15 +299,49 @@ def _response_model(self) -> type[T]:
         raise NotImplementedError("Subclasses must implement _response_model")
 
 class AbstractClientAsync(Generic[T]):
-    """Abstract base class for BioThings clients (asynchronous)"""
+    """Abstract base class for BioThings clients (asynchronous)
+    
+    For proper caching setup, use as an async context manager:
+        async with ClientAsync() as client:
+            result = await client.get("some_id")
+    
+    Or manually enable caching after instantiation:
+        client = ClientAsync()
+        await client.set_caching()
+        result = await client.get("some_id")
+    """
 
     def __init__(self, api_name: str, caching: bool = True):
         self._client = get_async_client(api_name)
         self._closed = False
+        self._enable_caching = caching
+    
+    @classmethod
+    async def create(cls, caching: bool = True):
+        """
+        Create and initialize an async client with caching properly set up.
+        
+        This is a convenience factory method for users who don't want to use
+        the async context manager pattern.
+        
+        Args:
+            caching: Whether to enable caching
+            
+        Returns:
+            Fully initialized async client
+            
+        Example:
+            client = await GeneClientAsync.create(caching=True)
+            result = await client.get("some_id")
+        """
+        instance = cls(caching=False)  # Don't auto-enable caching
         if caching:
-            self._client.set_caching()
+            await instance.set_caching()
+        return instance
 
     async def __aenter__(self):
+        if self._enable_caching:
+            await self.set_caching()
         return self
 
     async def __aexit__(self, exc_type, exc_val, exc_tb):
@@ -326,21 +360,13 @@ async def close(self):
 
     def __del__(self):
         """Cleanup when the object is deleted"""
-        if not self._closed and hasattr(self._client, 'close'):
-            import asyncio
-            try:
-                loop = asyncio.get_event_loop()
-                if loop.is_running():
-                    # If loop is running, create a task to close the client
-                    loop.create_task(self._client.close())
-                else:
-                    # If loop is not running, run the close operation
-                    loop.run_until_complete(self._client.close())
-            except Exception:
-                # Ignore any errors during cleanup
-                pass
-            finally:
-                self._closed = True
+        if not self._closed:
+            # Mark as closed to prevent further cleanup attempts
+            self._closed = True
+            
+            # Don't try to close async resources during garbage collection
+            # This can cause "coroutine was never awaited" warnings
+            # Proper cleanup should be done via explicit close() calls or context managers
 
     async def set_caching(self) -> None:
         """

src/biothings_typed_client/genes.py

@@ -181,41 +181,6 @@ def __init__(self, caching: bool = True):
 
     def _response_model(self) -> type[GeneResponse]:
         return GeneResponse
-
-    async def __aenter__(self):
-        return self
-        
-    async def __aexit__(self, exc_type, exc_val, exc_tb):
-        await self.close()
-            
-    async def close(self):
-        """Close the client connection"""
-        if not self._closed and hasattr(self._client, 'close'):
-            try:
-                await self._client.close()
-            except Exception:
-                # Ignore any errors during cleanup
-                pass
-            finally:
-                self._closed = True
-                
-    def __del__(self):
-        """Cleanup when the object is deleted"""
-        if not self._closed and hasattr(self._client, 'close'):
-            import asyncio
-            try:
-                loop = asyncio.get_event_loop()
-                if loop.is_running():
-                    # If loop is running, create a task to close the client
-                    loop.create_task(self._client.close())
-                else:
-                    # If loop is not running, run the close operation
-                    loop.run_until_complete(self._client.close())
-            except Exception:
-                # Ignore any errors during cleanup
-                pass
-            finally:
-                self._closed = True
 
     async def getgene(
         self,

src/biothings_typed_client/genesets.py

@@ -181,21 +181,13 @@ async def close(self):
 
     def __del__(self):
         """Cleanup when the object is deleted"""
-        if not self._closed and hasattr(self._client, 'close'):
-            import asyncio
-            try:
-                loop = asyncio.get_event_loop()
-                if loop.is_running():
-                    # If loop is running, create a task to close the client
-                    loop.create_task(self._client.close())
-                else:
-                    # If loop is not running, run the close operation
-                    loop.run_until_complete(self._client.close())
-            except Exception:
-                # Ignore any errors during cleanup
-                pass
-            finally:
-                self._closed = True
+        if not self._closed:
+            # Mark as closed to prevent further cleanup attempts
+            self._closed = True
+            
+            # Don't try to close async resources during garbage collection
+            # This can cause "coroutine was never awaited" warnings
+            # Proper cleanup should be done via explicit close() calls or context managers
 
     async def metadata(self) -> Dict[str, Any]:
         """

src/biothings_typed_client/taxons.py

@@ -10,8 +10,8 @@ class TaxonResponse(BaseModel):
     """Response model for taxon information"""
     model_config = ConfigDict(extra='allow')
 
-    id: str = Field(description="Taxon identifier", validation_alias="_id")
-    version: int = Field(description="Version number of the data", validation_alias="_version")
+    id: str = Field(description="Taxon identifier", validation_alias="_id", serialization_alias="_id")
+    version: int = Field(description="Version number of the data", validation_alias="_version", serialization_alias="_version")
     authority: Optional[List[str]] = Field(default=None, description="Taxonomic authority")
     common_name: Optional[str] = Field(default=None, description="Common name")
     genbank_common_name: Optional[str] = Field(default=None, description="GenBank common name")

src/biothings_typed_client/variants.py

@@ -489,24 +489,16 @@ def __del__(self):
         Cleanup when the object is deleted.
         
         This method ensures that resources are properly cleaned up even if the client
-        is not explicitly closed. It attempts to close the client in a safe manner,
-        handling both running and non-running event loops.
+        is not explicitly closed. However, to avoid "coroutine was never awaited" warnings,
+        async resource cleanup is not performed during garbage collection.
         """
-        if not self._closed and hasattr(self._client, 'close'):
-            import asyncio
-            try:
-                loop = asyncio.get_event_loop()
-                if loop.is_running():
-                    # If loop is running, create a task to close the client
-                    loop.create_task(self._client.close())
-                else:
-                    # If loop is not running, run the close operation
-                    loop.run_until_complete(self._client.close())
-            except Exception:
-                # Ignore any errors during cleanup
-                pass
-            finally:
-                self._closed = True
+        if not self._closed:
+            # Mark as closed to prevent further cleanup attempts
+            self._closed = True
+            
+            # Don't try to close async resources during garbage collection
+            # This can cause "coroutine was never awaited" warnings
+            # Proper cleanup should be done via explicit close() calls or context managers
 
     async def getvariant(
         self,

test_fix.py

@@ -0,0 +1,64 @@
+#!/usr/bin/env python3
+"""Test script to verify the async client fix"""
+
+import asyncio
+import warnings
+import pytest
+from biothings_typed_client.genes import GeneClientAsync
+
+@pytest.mark.asyncio
+async def test_async_client_instantiation():
+    """Test that creating an async client doesn't produce the original warning"""
+    print("Creating async gene client...")
+    
+    # Test 1: Direct instantiation with proper cleanup
+    print("Testing direct instantiation:")
+    async with GeneClientAsync(caching=False) as client:
+        print("✓ Client created successfully without the set_caching warning")
+        
+        # Test 3: Manual caching setup
+        print("Testing manual caching setup:")
+        await client.set_caching()
+        print("✓ Manual caching setup completed")
+    
+    # Test 2: Use as context manager (caching will be set up automatically)
+    print("\nTesting context manager pattern:")
+    async with GeneClientAsync(caching=False) as client_cm:
+        print("✓ Context manager setup completed")
+    
+    # Test 4: Factory method with proper cleanup
+    print("\nTesting factory method:")
+    client_factory = await GeneClientAsync.create(caching=False)
+    try:
+        print("✓ Factory method completed")
+    finally:
+        await client_factory.close()
+    
+    print("\n✅ All tests passed!")
+
+if __name__ == "__main__":
+    # Capture warnings to see if we still get the original issue
+    with warnings.catch_warnings(record=True) as w:
+        warnings.simplefilter("always")
+        asyncio.run(test_async_client_instantiation())
+        
+        # Check for the specific warning we fixed
+        set_caching_warnings = [warning for warning in w 
+                              if "coroutine 'AsyncBiothingClient._set_caching' was never awaited" in str(warning.message)]
+        
+        if set_caching_warnings:
+            print(f"\n❌ Original warning still present: {len(set_caching_warnings)} occurrences")
+            for warning in set_caching_warnings:
+                print(f"   {warning.message}")
+        else:
+            print("\n✅ Original set_caching warning is fixed!")
+            
+        # Show any other warnings (for informational purposes)
+        other_warnings = [warning for warning in w 
+                         if "coroutine 'AsyncBiothingClient._set_caching' was never awaited" not in str(warning.message)]
+        if other_warnings:
+            print(f"\nℹ️  Other warnings present ({len(other_warnings)}):")
+            for warning in other_warnings:
+                print(f"   {warning.message}")
+        else:
+            print("\nℹ️  No other warnings detected") 

tests/test_chem_async.py

@@ -9,9 +9,8 @@
 @pytest_asyncio.fixture
 async def async_client():
     """Fixture providing an asynchronous chem client"""
-    client = ChemClientAsync()
-    yield client
-    await client.close()
+    async with ChemClientAsync() as client:
+        yield client
 
 @pytest.mark.asyncio
 async def test_getchem_async(async_client: ChemClientAsync):

tests/test_genes.py

@@ -14,36 +14,35 @@ def sync_client():
 
 @pytest_asyncio.fixture
 async def async_client():
-    client = GeneClientAsync()
-    yield client
-    await client.close()
+    async with GeneClientAsync() as client:
+        yield client
 
 def test_getgene_sync(sync_client: GeneClient):
     """Test synchronous gene retrieval"""
-    gene = sync_client.getgene("1017")
+    gene = sync_client.getgene("672")
     assert gene is not None
     assert isinstance(gene, GeneResponse)
-    assert gene.id == "1017"
-    assert gene.symbol == "CDK2"
-    assert gene.name == "cyclin dependent kinase 2"
+    assert gene.id == "672"
+    assert gene.symbol == "BRCA1"
+    assert gene.name is not None
 
 def test_getgene_sync_with_fields(sync_client: GeneClient):
     """Test synchronous gene retrieval with specific fields"""
-    gene = sync_client.getgene("1017", fields=["symbol", "name"])
+    gene = sync_client.getgene("672", fields=["symbol", "name"])
     assert gene is not None
     assert isinstance(gene, GeneResponse)
-    assert gene.id == "1017"
-    assert gene.symbol == "CDK2"
-    assert gene.name == "cyclin dependent kinase 2"
+    assert gene.id == "672"
+    assert gene.symbol == "BRCA1"
+    assert gene.name is not None
     assert gene.refseq is None  # Not requested
 
 def test_getgenes_sync(sync_client: GeneClient):
     """Test synchronous multiple gene retrieval"""
-    genes = sync_client.getgenes(["1017", "1018"])
+    genes = sync_client.getgenes(["672", "675"])
     assert len(genes) == 2
     assert all(isinstance(gene, GeneResponse) for gene in genes)
-    assert genes[0].id == "1017"
-    assert genes[1].id == "1018"
+    assert genes[0].id == "672"
+    assert genes[1].id == "675"
 
 def test_query_sync(sync_client: GeneClient):
     """Test synchronous gene query"""

tests/test_genes_async.py

@@ -5,9 +5,8 @@
 @pytest_asyncio.fixture
 async def async_client():
     """Fixture providing an asynchronous gene client"""
-    client = GeneClientAsync()
-    yield client
-    await client.close()
+    async with GeneClientAsync() as client:
+        yield client
 
 @pytest.mark.asyncio
 async def test_getgene_async(async_client: GeneClientAsync):