fix up query api issues

Author: jsstevenson

src/cool_seq_tool/app.py

@@ -16,7 +16,7 @@
 )
 from cool_seq_tool.sources.mane_transcript_mappings import ManeTranscriptMappings
 from cool_seq_tool.sources.transcript_mappings import TranscriptMappings
-from cool_seq_tool.sources.uta_database import UtaDatabase
+from cool_seq_tool.sources.uta_database import LazyUtaDatabase, UtaDatabase
 
 
 class CoolSeqTool:
@@ -73,7 +73,10 @@ def __init__(
         :param transcript_file_path: The path to ``transcript_mapping.tsv``
         :param lrg_refseqgene_path: The path to the LRG_RefSeqGene file
         :param mane_data_path: Path to RefSeq MANE summary data
-        :param uta_connection_pool: pyscopg connection pool to UTA instance
+        :param uta_connection_pool: pyscopg connection pool to UTA instance. If not
+            provided, a lazy UTA connection will be used, meaning the connection won't
+            be initiated until the first attempted UTA query, and will use environment
+            configs/library defaults
         :param sr: SeqRepo instance. If this is not provided, will create a new instance
         :param force_local_files: if ``True``, don't check for or try to acquire latest
             versions of static data files -- just use most recently available, if any
@@ -89,7 +92,10 @@ def __init__(
         self.mane_transcript_mappings = ManeTranscriptMappings(
             mane_data_path=mane_data_path, from_local=force_local_files
         )
-        self.uta_db = UtaDatabase(uta_connection_pool)
+        if uta_connection_pool:
+            self.uta_db = UtaDatabase(uta_connection_pool)
+        else:
+            self.uta_db = LazyUtaDatabase()
         self.alignment_mapper = AlignmentMapper(
             self.seqrepo_access, self.transcript_mappings, self.uta_db
         )

src/cool_seq_tool/mappers/exon_genomic_coords.py

@@ -647,7 +647,7 @@ async def _get_all_exon_coords(
                 WHERE tx_ac = %(tx_ac)s
                 AND alt_aln_method = 'splign'
                 AND alt_ac = %(genomic_ac)s
-                ORDER BY ord ASC
+                ORDER BY ord ASC;
                 """
         else:
             query = """
@@ -656,18 +656,28 @@ async def _get_all_exon_coords(
                 INNER JOIN _seq_anno_most_recent as s
                 ON t.alt_ac = s.ac
                 WHERE s.descr = ''
-                AND t.tx_ac = %{tx_ac}s
+                AND t.tx_ac = %(tx_ac)s
                 AND t.alt_aln_method = 'splign'
-                AND t.alt_ac like 'NC_000%'
-                ORDER BY ord ASC
+                AND t.alt_ac like 'NC_000%%'
+                ORDER BY ord ASC;
                 """
 
         async with self.uta_db.repository() as uta:
             cursor = await uta.execute_query(
                 query, {"tx_ac": tx_ac, "genomic_ac": genomic_ac}
             )
             results = await cursor.fetchall()
-        return [_ExonCoord(**r) for r in results]
+        return [
+            _ExonCoord(
+                ord=r[0],
+                tx_start_i=r[1],
+                tx_end_i=r[2],
+                alt_start_i=r[3],
+                alt_end_i=r[4],
+                alt_strand=r[5],
+            )
+            for r in results
+        ]
 
     async def _get_genomic_aln_coords(
         self,
@@ -904,7 +914,7 @@ async def _genomic_to_tx_segment(
                         SELECT DISTINCT tx_ac
                         FROM tx_exon_aln_mv
                         WHERE hgnc = %(gene)s
-                        AND alt_ac = %(genomic_ac)s
+                        AND alt_ac = %(genomic_ac)s;
                         """
                     async with self.uta_db.repository() as uta:
                         cursor = await uta.execute_query(
@@ -1057,7 +1067,7 @@ async def _validate_genomic_breakpoint(
                 AND alt_ac = %(genomic_ac)s
             )
             SELECT * FROM tx_boundaries
-            WHERE %(pos)s between (tx_boundaries.min_start - 150) and (tx_boundaries.max_end + 150)
+            WHERE %(pos)s between (tx_boundaries.min_start - 150) and (tx_boundaries.max_end + 150);
             """
         async with self.uta_db.repository() as uta:
             cursor = await uta.execute_query(
@@ -1087,7 +1097,7 @@ async def _get_tx_ac_gene(
             LIMIT 1;
             """
         async with self.uta_db.repository() as uta:
-            cursor = await uta.execute_query(query)
+            cursor = await uta.execute_query(query, {"tx_ac": tx_ac})
             result = await cursor.fetchone()
         if not result:
             return None, f"No gene(s) found given {tx_ac}"

src/cool_seq_tool/sources/uta_database.py

@@ -1006,45 +1006,45 @@ async def create_uta_connection_pool(
     try:
         async with pool.connection() as conn:
             await UtaRepository(conn).create_genomic_table()
-    # catch all exceptions, this is probably a critical error, it's important to
+    # catch all exceptions -- this is probably a critical error, it's good to
     # close the pool first
     except:
         await pool.close()
         raise
     return pool
 
 
+class ClosedUtaConnectionError(Exception):
+    """Raise for attempts to access a UTA connection when it's been closed/deleted"""
+
+
 class UtaDatabase:
     """Provide pooled access to connection-scoped UTA repositories.
 
     This class owns or borrows an async psycopg connection pool and yields
     ``UtaRepository`` instances bound to checked-out connections.
     """
 
-    def __init__(self, pool: AsyncConnectionPool | None = None) -> None:
+    def __init__(self, pool: AsyncConnectionPool) -> None:
         """Initialize access wrapper.
 
         :param pool: Existing async connection pool to use. If omitted, a default
             pool is created lazily on first use.
         """
         self._connection_pool = pool
 
-    async def open(self) -> None:
-        """Initialize connection"""
-        if self._connection_pool is None:
-            # TODO not sure i like this here
-            self._connection_pool = await create_uta_connection_pool()
-
     @asynccontextmanager
     async def repository(self) -> AsyncIterator[UtaRepository]:
         """Yield a ``UtaRepository`` backed by a pooled connection.
 
         If no pool has been provided yet, a default one is created on first use.
 
         :yield: Repository bound to an active pooled connection
+        :raise ClosedUtaConnectionError: if connection associated w/ this instance is closed
+            or nullified
         """
-        await self.open()
-
+        if self._connection_pool is None:
+            raise ClosedUtaConnectionError
         async with self._connection_pool.connection() as conn:
             yield UtaRepository(conn)
 
@@ -1056,3 +1056,53 @@ async def close(self) -> None:
 
         await self._connection_pool.close()
         self._connection_pool = None
+
+
+class LazyUtaDatabase(UtaDatabase):
+    """UTA access wrapper with lazy connection pool initialization.
+
+    This variant defers creation of the underlying connection pool until first use.
+    It exists primarily for backward compatibility with earlier APIs that did not
+    require explicit pool construction.
+
+    Because configuration is resolved at runtime (via environment variables or
+    defaults), this class can introduce implicit behavior and is not recommended
+    for applications that require explicit control over database connections.
+    """
+
+    def __init__(self, pool: AsyncConnectionPool | None = None) -> None:
+        """Initialize the lazy access wrapper.
+
+        :param pool: Optional existing async connection pool. If not provided,
+            a pool will be created on first use using environment variables
+            or default configuration.
+        """
+        if pool is None:
+            _logger.info(
+                "LazyUtaDatabase initialized without a connection pool; "
+                "a pool will be created on first use from environment/default settings."
+            )
+        self._connection_pool = pool
+
+    async def open(self) -> None:
+        """Ensure that a connection pool has been initialized.
+
+        If no pool is currently set, one is created using default configuration.
+        """
+        if self._connection_pool is None:
+            _logger.debug("Creating UTA connection pool lazily on first use")
+            self._connection_pool = await create_uta_connection_pool()
+
+    @asynccontextmanager
+    async def repository(self) -> AsyncIterator[UtaRepository]:
+        """Yield a repository backed by a pooled UTA connection.
+
+        This method ensures that a connection pool exists, creating one if
+        necessary, and then yields a ``UtaRepository`` bound to a checked-out
+        connection.
+
+        :yield: Repository bound to an active pooled connection
+        """
+        await self.open()
+        async with self._connection_pool.connection() as conn:
+            yield UtaRepository(conn)