cool-seq-tool 0.4.0.dev3__py3-none-any.whl → 0.5.0__py3-none-any.whl

cool_seq_tool/sources/uta_database.py

@@ -1,16 +1,15 @@
 """Provide transcript lookup and metadata tools via the UTA database."""
+
 import ast
-import base64
 import logging
 from os import environ
-from typing import Any, Dict, List, Optional, Tuple, Type, TypeVar, Union
+from typing import Any, Literal, TypeVar
 from urllib.parse import ParseResult as UrlLibParseResult
 from urllib.parse import quote, unquote, urlparse
 
 import asyncpg
 import boto3
 import polars as pl
-from agct import Converter, Genome
 from asyncpg.exceptions import InterfaceError, InvalidAuthorizationSpecificationError
 from botocore.exceptions import ClientError
 
@@ -19,15 +18,11 @@ from cool_seq_tool.schemas import AnnotationLayer, Assembly, Strand
 # use `bound` to upper-bound UtaDatabase or child classes
 UTADatabaseType = TypeVar("UTADatabaseType", bound="UtaDatabase")
 
-# Environment variables for paths to chain files for agct
-LIFTOVER_CHAIN_37_TO_38 = environ.get("LIFTOVER_CHAIN_37_TO_38")
-LIFTOVER_CHAIN_38_TO_37 = environ.get("LIFTOVER_CHAIN_38_TO_37")
-
 UTA_DB_URL = environ.get(
-    "UTA_DB_URL", "postgresql://uta_admin:uta@localhost:5433/uta/uta_20210129b"
+    "UTA_DB_URL", "postgresql://uta_admin:uta@localhost:5432/uta/uta_20210129b"
 )
 
-logger = logging.getLogger(__name__)
+_logger = logging.getLogger(__name__)
 
 
 class UtaDatabase:
@@ -43,25 +38,12 @@ class UtaDatabase:
     >>> uta_db = asyncio.run(UtaDatabase.create())
     """
 
-    def __init__(
-        self,
-        db_url: str = UTA_DB_URL,
-        chain_file_37_to_38: Optional[str] = None,
-        chain_file_38_to_37: Optional[str] = None,
-    ) -> None:
+    def __init__(self, db_url: str = UTA_DB_URL) -> None:
         """Initialize DB class. Should only be used by ``create()`` method, and not
         be called directly by a user.
 
         :param db_url: PostgreSQL connection URL
             Format: ``driver://user:password@host/database/schema``
-        :param chain_file_37_to_38: Optional path to chain file for 37 to 38 assembly.
-            This is used for ``agct``. If this is not provided, will check to see
-            if ``LIFTOVER_CHAIN_37_TO_38`` env var is set. If neither is provided, will
-            allow ``agct`` to download a chain file from UCSC
-        :param chain_file_38_to_37: Optional path to chain file for 38 to 37 assembly.
-            This is used for ``agct``. If this is not provided, will check to see
-            if ``LIFTOVER_CHAIN_38_TO_37`` env var is set. If neither is provided, will
-            allow ``agct`` to download a chain file from UCSC
         """
         self.schema = None
         self._connection_pool = None
@@ -69,19 +51,7 @@ class UtaDatabase:
         self.db_url = db_url.replace(original_pwd, quote(original_pwd))
         self.args = self._get_conn_args()
 
-        chain_file_37_to_38 = chain_file_37_to_38 or LIFTOVER_CHAIN_37_TO_38
-        if chain_file_37_to_38:
-            self.liftover_37_to_38 = Converter(chainfile=chain_file_37_to_38)
-        else:
-            self.liftover_37_to_38 = Converter(from_db=Genome.HG19, to_db=Genome.HG38)
-
-        chain_file_38_to_37 = chain_file_38_to_37 or LIFTOVER_CHAIN_38_TO_37
-        if chain_file_38_to_37:
-            self.liftover_38_to_37 = Converter(chainfile=chain_file_38_to_37)
-        else:
-            self.liftover_38_to_37 = Converter(from_db=Genome.HG38, to_db=Genome.HG19)
-
-    def _get_conn_args(self) -> Dict:
+    def _get_conn_args(self) -> dict:
         """Return connection arguments.
 
         :param db_url: raw connection URL
@@ -99,9 +69,9 @@ class UtaDatabase:
             self.schema = schema
 
             environ["PGPASSWORD"] = password
-            environ[
-                "UTA_DB_URL"
-            ] = f"postgresql://{username}@{host}:{port}/{database}/{schema}"
+            environ["UTA_DB_URL"] = (
+                f"postgresql://{username}@{host}:{port}/{database}/{schema}"
+            )
             return {
                 "host": host,
                 "port": int(port),
@@ -137,7 +107,7 @@ class UtaDatabase:
                     database=self.args["database"],
                 )
             except InterfaceError as e:
-                logger.error(
+                _logger.error(
                     "While creating connection pool, encountered exception %s", e
                 )
                 msg = "Could not create connection pool"
@@ -145,7 +115,7 @@ class UtaDatabase:
 
     @classmethod
     async def create(
-        cls: Type[UTADatabaseType], db_url: str = UTA_DB_URL
+        cls: type[UTADatabaseType], db_url: str = UTA_DB_URL
     ) -> UTADatabaseType:
         """Manufacture a fully-initialized class instance (a la factory pattern). This
         method should be used instead of calling the class directly to create a new
@@ -173,7 +143,10 @@ class UtaDatabase:
         """
 
         async def _execute_query(q: str) -> Any:  # noqa: ANN401
-            async with self._connection_pool.acquire() as connection, connection.transaction():
+            async with (
+                self._connection_pool.acquire() as connection,
+                connection.transaction(),
+            ):
                 return await connection.fetch(q)
 
         if not self._connection_pool:
@@ -197,7 +170,7 @@ class UtaDatabase:
         genomic_table_exists = await self.execute_query(check_table_exists)
         genomic_table_exists = genomic_table_exists[0].get("exists")
         if genomic_table_exists is None:
-            logger.critical(
+            _logger.critical(
                 "SELECT EXISTS query in UtaDatabase._create_genomic_table "
                 "returned invalid response"
             )
@@ -234,25 +207,22 @@ class UtaDatabase:
                 await self.execute_query(create_index)
 
     @staticmethod
-    def _transform_list(li: List) -> List[List[Any]]:
+    def _transform_list(li: list) -> list[list[Any]]:
         """Transform list to only contain field values
 
         :param li: List of asyncpg.Record objects
         :return: List of list of objects
         """
-        results = []
-        for item in li:
-            results.append(list(item))
-        return results
+        return [list(i) for i in li]
 
     async def get_genes_and_alt_acs(
         self,
         pos: int,
-        strand: Optional[Strand] = None,
-        chromosome: Optional[int] = None,
-        alt_ac: Optional[str] = None,
-        gene: Optional[str] = None,
-    ) -> Tuple[Optional[Dict], Optional[str]]:
+        strand: Strand | None = None,
+        chromosome: int | None = None,
+        alt_ac: str | None = None,
+        gene: str | None = None,
+    ) -> tuple[dict | None, str | None]:
         """Return genes and genomic accessions for a position on a chromosome or alt_ac
 
         :param pos: Genomic position
@@ -261,7 +231,7 @@ class UtaDatabase:
             (i.e. ``1`` or ``X``). If not provided, must provide ``alt_ac``.
             If ``alt_ac`` is also provided, ``alt_ac`` will be used.
         :param alt_ac: Genomic accession (i.e. ``NC_000001.11``). If not provided,
-            must provide ``chromosome. If ``chromosome`` is also provided, ``alt_ac``
+            must provide ``chromosome``. If ``chromosome`` is also provided, ``alt_ac``
             will be used.
         :param gene: Gene symbol
         :return: Dictionary containing genes and genomic accessions and warnings if found
@@ -309,8 +279,8 @@ class UtaDatabase:
         return {"genes": genes, "alt_acs": alt_acs}, None
 
     async def get_tx_exons(
-        self, tx_ac: str, alt_ac: Optional[str] = None
-    ) -> Tuple[Optional[List[Tuple[int, int]]], Optional[str]]:
+        self, tx_ac: str, alt_ac: str | None = None
+    ) -> tuple[list[tuple[int, int]] | None, str | None]:
         """Get list of transcript exons start/end coordinates.
 
         :param tx_ac: Transcript accession
@@ -343,7 +313,7 @@ class UtaDatabase:
 
         if not result:
             msg = f"Unable to get exons for {tx_ac}"
-            logger.warning(msg)
+            _logger.warning(msg)
             return None, msg
         tx_exons = [(r["tx_start_i"], r["tx_end_i"]) for r in result]
         return tx_exons, None
@@ -352,7 +322,7 @@ class UtaDatabase:
         self,
         tx_ac: str,
         alt_ac: str,
-    ) -> Tuple[Optional[Tuple[int, int, int, int, int]], Optional[str]]:
+    ) -> tuple[tuple[int, int, int, int, int] | None, str | None]:
         """Get exon number, transcript coordinates, and genomic coordinates
 
         :param tx_ac: Transcript accession
@@ -370,7 +340,7 @@ class UtaDatabase:
 
         if not result:
             msg = f"Unable to get exons and genomic coordinates for {tx_ac} on {alt_ac}"
-            logger.warning(msg)
+            _logger.warning(msg)
             return None, msg
         tx_exons_genomic_coords = [
             (r["ord"], r["tx_start_i"], r["tx_end_i"], r["alt_start_i"], r["alt_end_i"])
@@ -379,8 +349,8 @@ class UtaDatabase:
         return tx_exons_genomic_coords, None
 
     async def get_alt_ac_start_or_end(
-        self, tx_ac: str, tx_exon_start: int, tx_exon_end: int, gene: Optional[str]
-    ) -> Tuple[Optional[Tuple[str, str, int, int, int]], Optional[str]]:
+        self, tx_ac: str, tx_exon_start: int, tx_exon_end: int, gene: str | None
+    ) -> tuple[tuple[str, str, int, int, int] | None, str | None]:
         """Get genomic data for related transcript exon start or end.
 
         :param tx_ac: Transcript accession
@@ -415,12 +385,12 @@ class UtaDatabase:
             )
             if gene_query:
                 msg += f" on gene {gene}"
-            logger.warning(msg)
+            _logger.warning(msg)
             return None, msg
         result = result[0]
         return (result[0], result[1], result[2], result[3], result[4]), None
 
-    async def get_cds_start_end(self, tx_ac: str) -> Optional[Tuple[int, int]]:
+    async def get_cds_start_end(self, tx_ac: str) -> tuple[int, int] | None:
         """Get coding start and end site
 
         :param tx_ac: Transcript accession
@@ -439,12 +409,12 @@ class UtaDatabase:
             if cds_start_end[0] is not None and cds_start_end[1] is not None:  # noqa: RET503
                 return cds_start_end[0], cds_start_end[1]
         else:
-            logger.warning(
+            _logger.warning(
                 "Unable to get coding start/end site for accession: %s", tx_ac
             )
             return None
 
-    async def get_newest_assembly_ac(self, ac: str) -> List[str]:
+    async def get_newest_assembly_ac(self, ac: str) -> list[str]:
         """Find accession associated to latest genomic assembly
 
         :param ac: Accession
@@ -489,7 +459,7 @@ class UtaDatabase:
         result = await self.execute_query(query)
         return result[0][0]
 
-    async def get_ac_descr(self, ac: str) -> Optional[str]:
+    async def get_ac_descr(self, ac: str) -> str | None:
         """Return accession description. This is typically available only for accessions
         from older (pre-GRCh38) builds.
 
@@ -512,7 +482,7 @@ class UtaDatabase:
             """  # noqa: S608
         result = await self.execute_query(query)
         if not result:
-            logger.warning("Accession %s does not have a description", ac)
+            _logger.warning("Accession %s does not have a description", ac)
             return None
         result = result[0][0]
         if result == "":
@@ -524,10 +494,10 @@ class UtaDatabase:
         tx_ac: str,
         start_pos: int,
         end_pos: int,
-        alt_ac: Optional[str] = None,
+        alt_ac: str | None = None,
         use_tx_pos: bool = True,
         like_tx_ac: bool = False,
-    ) -> List:
+    ) -> list:
         """Return queried data from tx_exon_aln_v table.
 
         :param tx_ac: accession on c. coordinate
@@ -584,21 +554,18 @@ class UtaDatabase:
             """  # noqa: S608
         result = await self.execute_query(query)
         if not result:
-            logger.warning("Unable to find transcript alignment for query: %s", query)
+            _logger.warning("Unable to find transcript alignment for query: %s", query)
             return []
         if alt_ac and not use_tx_pos and len(result) > 1:
-            logger.debug(
+            _logger.debug(
                 "Found more than one match for tx_ac %s and alt_ac = %s",
                 temp_ac,
                 alt_ac,
             )
-        results = []
-        for r in result:
-            results.append(list(r))
-        return results
+        return [list(r) for r in result]
 
     @staticmethod
-    def data_from_result(result: List) -> Optional[Dict]:
+    def data_from_result(result: list) -> dict | None:
         """Return data found from result.
 
         :param result: Data from tx_exon_aln_v table
@@ -613,7 +580,7 @@ class UtaDatabase:
         alt_exon_id = result[10]
 
         if (tx_pos_range[1] - tx_pos_range[0]) != (alt_pos_range[1] - alt_pos_range[0]):
-            logger.warning(
+            _logger.warning(
                 "tx_pos_range %s is not the same length as alt_pos_range %s.",
                 tx_pos_range,
                 alt_pos_range,
@@ -631,8 +598,8 @@ class UtaDatabase:
         }
 
     async def get_mane_c_genomic_data(
-        self, ac: str, alt_ac: Optional[str], start_pos: int, end_pos: int
-    ) -> Optional[Dict]:
+        self, ac: str, alt_ac: str | None, start_pos: int, end_pos: int
+    ) -> dict | None:
         """Get MANE transcript and genomic data. Used when going from g. to MANE c.
         representation.
 
@@ -671,7 +638,7 @@ class UtaDatabase:
 
         coding_start_site = await self.get_cds_start_end(ac)
         if coding_start_site is None:
-            logger.warning("Accession %s not found in UTA", ac)
+            _logger.warning("Accession %s not found in UTA", ac)
             return None
 
         data["tx_ac"] = result[1]
@@ -697,13 +664,12 @@ class UtaDatabase:
     async def get_genomic_tx_data(
         self,
         tx_ac: str,
-        pos: Tuple[int, int],
-        annotation_layer: Union[
-            AnnotationLayer.CDNA, AnnotationLayer.GENOMIC
-        ] = AnnotationLayer.CDNA,
-        alt_ac: Optional[str] = None,
+        pos: tuple[int, int],
+        annotation_layer: Literal[AnnotationLayer.CDNA]
+        | Literal[AnnotationLayer.GENOMIC] = AnnotationLayer.CDNA,
+        alt_ac: str | None = None,
         target_genome_assembly: Assembly = Assembly.GRCH38,
-    ) -> Optional[Dict]:
+    ) -> dict | None:
         """Get transcript mapping to genomic data.
 
         :param tx_ac: Accession on c. coordinate
@@ -760,7 +726,7 @@ class UtaDatabase:
 
         return data
 
-    async def get_ac_from_gene(self, gene: str) -> List[str]:
+    async def get_ac_from_gene(self, gene: str) -> list[str]:
         """Return genomic accession(s) associated to a gene.
 
         :param gene: Gene symbol
@@ -784,14 +750,16 @@ class UtaDatabase:
 
     async def get_gene_from_ac(
         self, ac: str, start_pos: int, end_pos: int
-    ) -> Optional[List[str]]:
+    ) -> list[str] | None:
         """Get gene(s) within the provided coordinate range
 
         >>> import asyncio
         >>> from cool_seq_tool.sources import UtaDatabase
         >>> async def get_gene():
         ...     uta_db = await UtaDatabase.create()
-        ...     result = await uta_db.get_gene_from_ac("NC_000017.11", 43044296, 43045802)
+        ...     result = await uta_db.get_gene_from_ac(
+        ...         "NC_000017.11", 43044296, 43045802
+        ...     )
         ...     return result
         >>> asyncio.run(get_gene())
         ['BRCA1']
@@ -812,12 +780,12 @@ class UtaDatabase:
             """  # noqa: S608
         results = await self.execute_query(query)
         if not results:
-            logger.warning(
+            _logger.warning(
                 "Unable to find gene between %s and %s on %s", start_pos, end_pos, ac
             )
             return None
         if len(results) > 1:
-            logger.info(
+            _logger.info(
                 "Found more than one gene between %s and %s on %s",
                 start_pos,
                 end_pos,
@@ -828,11 +796,11 @@ class UtaDatabase:
 
     async def get_transcripts(
         self,
-        start_pos: Optional[int] = None,
-        end_pos: Optional[int] = None,
-        gene: Optional[str] = None,
+        start_pos: int | None = None,
+        end_pos: int | None = None,
+        gene: str | None = None,
         use_tx_pos: bool = True,
-        alt_ac: Optional[str] = None,
+        alt_ac: str | None = None,
     ) -> pl.DataFrame:
         """Get transcripts for a given ``gene`` or ``alt_ac`` related to optional positions.
 
@@ -901,16 +869,26 @@ class UtaDatabase:
         results = [
             (r["pro_ac"], r["tx_ac"], r["alt_ac"], r["cds_start_i"]) for r in results
         ]
-        results_df = pl.DataFrame(results, schema=schema)
+        results_df = pl.DataFrame(results, schema=schema, orient="row")
         if results:
             results_df = results_df.unique()
         return results_df
 
-    async def get_chr_assembly(self, ac: str) -> Optional[Tuple[str, str]]:
+    async def get_chr_assembly(self, ac: str) -> tuple[str, Assembly] | None:
         """Get chromosome and assembly for NC accession if not in GRCh38.
 
-        :param ac: NC accession
-        :return: Chromosome and Assembly accession is on
+        >>> import asyncio
+        >>> from cool_seq_tool.sources.uta_database import UtaDatabase
+        >>> uta_db = asyncio.run(UtaDatabase.create())
+        >>> result = asyncio.run(uta_db.get_chr_assembly("NC_000007.13"))
+        >>> result
+        ('chr7', <Assembly.GRCH37: 'GRCh37'>)
+
+        Returns ``None`` if unable to find (either unrecognized/invalid, or
+        a GRCh38 accession).
+
+        :param ac: RefSeq NC accession, eg ``"NC_000007.13"``
+        :return: Chromosome and assembly that accession is on, if available.
         """
         descr = await self.get_ac_descr(ac)
         if not descr:
@@ -920,136 +898,15 @@ class UtaDatabase:
         chromosome = f"chr{descr[0].split()[-1]}"
         assembly = f"GRCh{descr[1].split('.')[0].split('GRCh')[-1]}"
 
-        if assembly not in ["GRCh37", "GRCh38"]:
-            logger.warning(
-                "Assembly not supported: %s. Only GRCh37 and GRCh38 are supported.",
-                assembly,
-            )
+        try:
+            assembly = Assembly(assembly)
+        except ValueError as e:
+            _logger.error(e)
             return None
 
         return chromosome, assembly
 
-    async def liftover_to_38(self, genomic_tx_data: Dict) -> None:
-        """Liftover genomic_tx_data to hg38 assembly.
-
-        :param genomic_tx_data: Dictionary containing gene, nc_accession, alt_pos, and
-            strand
-        """
-        descr = await self.get_chr_assembly(genomic_tx_data["alt_ac"])
-        if descr is None:
-            # already grch38
-            return
-        chromosome, _ = descr
-
-        query = f"""
-            SELECT DISTINCT alt_ac
-            FROM {self.schema}.tx_exon_aln_v
-            WHERE tx_ac = '{genomic_tx_data['tx_ac']}';
-            """  # noqa: S608
-        nc_acs = await self.execute_query(query)
-        nc_acs = [nc_ac[0] for nc_ac in nc_acs]
-        if nc_acs == [genomic_tx_data["alt_ac"]]:
-            logger.warning(
-                "UTA does not have GRCh38 assembly for %s",
-                genomic_tx_data["alt_ac"].split(".")[0],
-            )
-            return
-
-        # Get most recent assembly version position
-        # Liftover range
-        self._set_liftover(
-            genomic_tx_data, "alt_pos_range", chromosome, Assembly.GRCH38
-        )
-
-        # Liftover changes range
-        self._set_liftover(
-            genomic_tx_data, "alt_pos_change_range", chromosome, Assembly.GRCH38
-        )
-
-        # Change alt_ac to most recent
-        if genomic_tx_data["alt_ac"].startswith("EN"):
-            order_by_cond = "ORDER BY alt_ac DESC;"
-        else:
-            order_by_cond = """
-            ORDER BY CAST(SUBSTR(alt_ac, position('.' in alt_ac) + 1,
-            LENGTH(alt_ac)) AS INT) DESC;
-            """
-        query = f"""
-            SELECT alt_ac
-            FROM {self.schema}.genomic
-            WHERE alt_ac LIKE '{genomic_tx_data['alt_ac'].split('.')[0]}%'
-            {order_by_cond}
-            """  # noqa: S608
-        nc_acs = await self.execute_query(query)
-        genomic_tx_data["alt_ac"] = nc_acs[0][0]
-
-    def get_liftover(
-        self, chromosome: str, pos: int, liftover_to_assembly: Assembly
-    ) -> Optional[Tuple[str, int]]:
-        """Get new genome assembly data for a position on a chromosome.
-
-        :param chromosome: The chromosome number. Must be prefixed with ``chr``
-        :param pos: Position on the chromosome
-        :param liftover_to_assembly: Assembly to liftover to
-        :return: Target chromosome and target position for assembly
-        """
-        if not chromosome.startswith("chr"):
-            logger.warning("`chromosome` must be prefixed with chr")
-            return None
-
-        if liftover_to_assembly == Assembly.GRCH38:
-            liftover = self.liftover_37_to_38.convert_coordinate(chromosome, pos)
-        elif liftover_to_assembly == Assembly.GRCH37:
-            liftover = self.liftover_38_to_37.convert_coordinate(chromosome, pos)
-        else:
-            logger.warning("%s assembly not supported", liftover_to_assembly)
-            liftover = None
-
-        if not liftover:
-            logger.warning("%s does not exist on %s", pos, chromosome)
-            return None
-        return liftover[0][:2]
-
-    def _set_liftover(
-        self,
-        genomic_tx_data: Dict,
-        key: str,
-        chromosome: str,
-        liftover_to_assembly: Assembly,
-    ) -> None:
-        """Update genomic_tx_data to have coordinates for given assembly.
-
-        :param genomic_tx_data: Dictionary containing gene, nc_accession, alt_pos, and
-            strand
-        :param key: Key to access coordinate positions
-        :param chromosome: Chromosome, must be prefixed with ``chr``
-        :param liftover_to_assembly: Assembly to liftover to
-        """
-        liftover_start_i = self.get_liftover(
-            chromosome, genomic_tx_data[key][0], liftover_to_assembly
-        )
-        if liftover_start_i is None:
-            logger.warning(
-                "Unable to liftover position %s on %s",
-                genomic_tx_data[key][0],
-                chromosome,
-            )
-            return
-
-        liftover_end_i = self.get_liftover(
-            chromosome, genomic_tx_data[key][1], liftover_to_assembly
-        )
-        if liftover_end_i is None:
-            logger.warning(
-                "Unable to liftover position %s on %s",
-                genomic_tx_data[key][1],
-                chromosome,
-            )
-            return
-
-        genomic_tx_data[key] = liftover_start_i[1], liftover_end_i[1]
-
-    async def p_to_c_ac(self, p_ac: str) -> List[str]:
+    async def p_to_c_ac(self, p_ac: str) -> list[str]:
         """Return cDNA reference sequence accession from protein reference sequence
         accession (i.e. ``p.`` to ``c.`` in HGVS syntax)
 
@@ -1079,7 +936,7 @@ class UtaDatabase:
 
     async def get_transcripts_from_genomic_pos(
         self, alt_ac: str, g_pos: int
-    ) -> List[str]:
+    ) -> list[str]:
         """Get transcripts associated to a genomic ac and position.
 
         :param alt_ac: Genomic accession
@@ -1100,7 +957,12 @@ class UtaDatabase:
 
     @staticmethod
     def get_secret() -> str:
-        """Get secrets for UTA DB instances. Used for deployment on AWS."""
+        """Get secrets for UTA DB instances. Used for deployment on AWS.
+
+        :raises ClientError: If unable to retrieve secret value due to decryption
+            decryption failure, internal service error, invalid parameter, invalid
+            request, or resource not found.
+        """
         secret_name = environ["UTA_DB_SECRET"]
         region_name = "us-east-2"
 
@@ -1111,27 +973,12 @@ class UtaDatabase:
         try:
             get_secret_value_response = client.get_secret_value(SecretId=secret_name)
         except ClientError as e:
-            logger.warning(e)
-            if e.response["Error"]["Code"] in {
-                # Secrets Manager can"t decrypt the protected secret text using the provided KMS key.
-                "DecryptionFailureException",
-                # An error occurred on the server side.
-                "InternalServiceErrorException",
-                # You provided an invalid value for a parameter.
-                "InvalidParameterException",
-                # You provided a parameter value that is not valid for the current state of the resource.
-                "InvalidRequestException",
-                # We can"t find the resource that you asked for.
-                "ResourceNotFoundException",
-            }:
-                raise e
+            # For a list of exceptions thrown, see
+            # https://docs.aws.amazon.com/secretsmanager/latest/apireference/API_GetSecretValue.html
+            _logger.error(e)
+            raise e
         else:
-            # Decrypts secret using the associated KMS CMK.
-            # Depending on whether the secret is a string or binary,
-            # one of these fields will be populated.
-            if "SecretString" in get_secret_value_response:
-                return get_secret_value_response["SecretString"]
-        return base64.b64decode(get_secret_value_response["SecretBinary"])
+            return get_secret_value_response["SecretString"]
 
 
 class ParseResult(UrlLibParseResult):
@@ -1145,13 +992,13 @@ class ParseResult(UrlLibParseResult):
         return super(ParseResult, cls).__new__(cls, *pr)  # noqa: UP008
 
     @property
-    def database(self) -> Optional[str]:
+    def database(self) -> str | None:
         """Create database property."""
         path_elems = self.path.split("/")
         return path_elems[1] if len(path_elems) > 1 else None
 
     @property
-    def schema(self) -> Optional[str]:
+    def schema(self) -> str | None:
         """Create schema property."""
         path_elems = self.path.split("/")
         return path_elems[2] if len(path_elems) > 2 else None