variation-normalizer 0.7.0.dev4__tar.gz → 0.7.0.dev5__tar.gz

{variation-normalizer-0.7.0.dev4/variation_normalizer.egg-info → variation-normalizer-0.7.0.dev5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: variation-normalizer
-Version: 0.7.0.dev4
+Version: 0.7.0.dev5
 Summary: VICC normalization routine for variations
 Home-page: https://github.com/cancervariants/variation-normalization
 Author: VICC

{variation-normalizer-0.7.0.dev4 → variation-normalizer-0.7.0.dev5}/tests/tokenizers/test_coding_dna_delins.py

@@ -1,7 +1,6 @@
 """A module for testing Coding DNA DelIns tokenization."""
 import unittest
 
-from variation.tokenizers.caches import NucleotideCache
 from variation.tokenizers import CodingDNADelIns
 from .tokenizer_base import TokenizerBase
 
@@ -11,7 +10,7 @@ class TestCodingDNADelInsTokenizer(TokenizerBase, unittest.TestCase):
 
     def tokenizer_instance(self):
         """Return Coding DNA DelIns instance."""
-        return CodingDNADelIns(NucleotideCache())
+        return CodingDNADelIns()
 
     def token_type(self):
         """Return DNA coding delins token type."""

{variation-normalizer-0.7.0.dev4 → variation-normalizer-0.7.0.dev5}/tests/tokenizers/test_coding_dna_insertion.py

@@ -1,7 +1,6 @@
 """A module for testing Coding DNA Insertion Tokenization."""
 import unittest
 
-from variation.tokenizers.caches import NucleotideCache
 from variation.tokenizers import CodingDNAInsertion
 from .tokenizer_base import TokenizerBase
 
@@ -11,7 +10,7 @@ class TestCodingDNAInsertionTokenizer(TokenizerBase, unittest.TestCase):
 
     def tokenizer_instance(self):
         """Return Coding DNA Insertion instance."""
-        return CodingDNAInsertion(NucleotideCache())
+        return CodingDNAInsertion()
 
     def token_type(self):
         """Return Coding DNA insertion token type."""

variation-normalizer-0.7.0.dev4/tests/tokenizers/test_gene.py → variation-normalizer-0.7.0.dev5/tests/tokenizers/test_gene_symbol.py

@@ -7,7 +7,7 @@ from variation.tokenizers import GeneSymbol
 from .tokenizer_base import TokenizerBase
 
 
-class TestGenePairTokenizer(TokenizerBase, unittest.TestCase):
+class TestGeneSymbolTokenizer(TokenizerBase, unittest.TestCase):
     """The Gene Pair Tokenizer class."""
 
     def tokenizer_instance(self):

{variation-normalizer-0.7.0.dev4 → variation-normalizer-0.7.0.dev5}/tests/tokenizers/test_genomic_delins.py

@@ -1,7 +1,6 @@
 """A module for testing Genomic DelIns tokenization."""
 import unittest
 
-from variation.tokenizers.caches import NucleotideCache
 from variation.tokenizers import GenomicDelIns
 from .tokenizer_base import TokenizerBase
 
@@ -11,7 +10,7 @@ class TestGenomicDelInsTokenizer(TokenizerBase, unittest.TestCase):
 
     def tokenizer_instance(self):
         """Return Genomic DelIns instance."""
-        return GenomicDelIns(NucleotideCache())
+        return GenomicDelIns()
 
     def token_type(self):
         """Return genomic delins token type."""

{variation-normalizer-0.7.0.dev4 → variation-normalizer-0.7.0.dev5}/tests/tokenizers/test_genomic_insertion.py

@@ -1,7 +1,6 @@
 """A module for testing Genomic Insertion Tokenization."""
 import unittest
 
-from variation.tokenizers.caches import NucleotideCache
 from variation.tokenizers import GenomicInsertion
 from .tokenizer_base import TokenizerBase
 
@@ -11,7 +10,7 @@ class TestGenomicInsertionTokenizer(TokenizerBase, unittest.TestCase):
 
     def tokenizer_instance(self):
         """Return Genomic Insertion instance."""
-        return GenomicInsertion(NucleotideCache())
+        return GenomicInsertion()
 
     def token_type(self):
         """Return genomic insertion token type."""

{variation-normalizer-0.7.0.dev4 → variation-normalizer-0.7.0.dev5}/tests/tokenizers/test_protein_delins.py

@@ -1,7 +1,6 @@
 """A module for testing Protein DelIns tokenization."""
 import unittest
 
-from variation.tokenizers.caches import NucleotideCache
 from variation.tokenizers import ProteinDelIns
 from .tokenizer_base import TokenizerBase
 
@@ -11,7 +10,7 @@ class TestProteinDelInsTokenizer(TokenizerBase, unittest.TestCase):
 
     def tokenizer_instance(self):
         """Return Protein DelIns instance."""
-        return ProteinDelIns(NucleotideCache())
+        return ProteinDelIns()
 
     def token_type(self):
         """Return protein delins token type."""

{variation-normalizer-0.7.0.dev4 → variation-normalizer-0.7.0.dev5}/tests/tokenizers/test_protein_insertion.py

@@ -2,7 +2,6 @@
 import unittest
 
 from variation.tokenizers import ProteinInsertion
-from variation.tokenizers.caches import NucleotideCache
 from .tokenizer_base import TokenizerBase
 
 
@@ -11,7 +10,7 @@ class TestProteinInsertionTokenizer(TokenizerBase, unittest.TestCase):
 
     def tokenizer_instance(self):
         """Return Protein Insertion instance."""
-        return ProteinInsertion(NucleotideCache())
+        return ProteinInsertion()
 
     def token_type(self):
         """Return protein insertion token type."""

{variation-normalizer-0.7.0.dev4 → variation-normalizer-0.7.0.dev5}/variation/query.py

@@ -26,17 +26,21 @@ from variation.to_copy_number_variation import ToCopyNumberVariation
 class QueryHandler:
     """Class for initializing handlers that make app queries."""
 
-    def __init__(self,
-                 dynamodb_url: str = "",
-                 dynamodb_region: str = "us-east-2",
-                 transcript_file_path: str = None,
-                 refseq_file_path: str = None,
-                 mane_data_path: str = None,
-                 uta_db_url: str = UTA_DB_URL,
-                 uta_db_pwd: Optional[str] = None) -> None:
+    def __init__(
+        self, dynamodb_url: str = "", dynamodb_region: str = "us-east-2",
+        gene_query_handler: Optional[GeneQueryHandler] = None,
+        transcript_file_path: str = None, refseq_file_path: str = None,
+        mane_data_path: str = None, uta_db_url: str = UTA_DB_URL,
+        uta_db_pwd: Optional[str] = None
+    ) -> None:
         """Initialize QueryHandler instance.
-        :param str dynamodb_url: URL to gene-normalizer database source.
-        :param str dynamodb_region: AWS default region for gene-normalizer.
+        :param str dynamodb_url: URL to gene normalizer dynamodb. Only used when
+            `gene_query_handler` is `None`.
+        :param str dynamodb_region: AWS region for gene normalizer db. Only used when
+            `gene_query_handler` is `None`.
+        :param Optional[GeneQueryHandler] gene_query_handler: Gene normalizer query
+            handler instance. If this is provided, will use a current instance. If this
+            is not provided, will create a new instance.
         :param str transcript_file_path: Path to transcript mappings file
         :param str refseq_file_path: Path to refseq gene symbol file
         :param str mane_data_path: Path to refseq mane data file
@@ -48,19 +52,27 @@ class QueryHandler:
                                                TRANSCRIPT_MAPPINGS_PATH)
         if not refseq_file_path:
             refseq_file_path = environ.get("LRG_REFSEQGENE_PATH", LRG_REFSEQGENE_PATH)
+
         if not mane_data_path:
             mane_data_path = environ.get("MANE_SUMMARY_PATH", MANE_SUMMARY_PATH)
-        cool_seq_tool = CoolSeqTool(transcript_file_path=transcript_file_path,
-                                    lrg_refseqgene_path=refseq_file_path,
-                                    mane_data_path=mane_data_path,
-                                    db_url=uta_db_url, db_pwd=uta_db_pwd)
+
+        if not gene_query_handler:
+            gene_query_handler = GeneQueryHandler(
+                db_url=dynamodb_url, db_region=dynamodb_region
+            )
+
+        cool_seq_tool = CoolSeqTool(
+            transcript_file_path=transcript_file_path,
+            lrg_refseqgene_path=refseq_file_path,
+            mane_data_path=mane_data_path,
+            db_url=uta_db_url,
+            db_pwd=uta_db_pwd,
+            gene_query_handler=gene_query_handler
+        )
         self._seqrepo_access = cool_seq_tool.seqrepo_access
 
         vrs_representation = VRSRepresentation(self._seqrepo_access)
-
-        gene_normalizer = GeneQueryHandler(db_url=dynamodb_url,
-                                           db_region=dynamodb_region)
-        gene_symbol = GeneSymbol(gene_normalizer)
+        gene_symbol = GeneSymbol(gene_query_handler)
         tokenizer = Tokenize(gene_symbol)
         classifier = Classify()
         uta_db = cool_seq_tool.uta_db
@@ -69,13 +81,13 @@ class QueryHandler:
         self._tlr = Translator(data_proxy=self._seqrepo_access)
         validator = Validate(
             self._seqrepo_access, transcript_mappings, gene_symbol, mane_transcript,
-            uta_db, self._tlr, gene_normalizer, vrs_representation
+            uta_db, self._tlr, gene_query_handler, vrs_representation
         )
         translator = Translate()
         hgvs_dup_del_mode = HGVSDupDelMode(self._seqrepo_access)
         to_vrs_params = [self._seqrepo_access, tokenizer,
                          classifier, validator, translator, hgvs_dup_del_mode,
-                         gene_normalizer]
+                         gene_query_handler]
         self.to_vrs_handler = ToVRS(*to_vrs_params)
         self.to_vrsatile_handler = ToVRSATILE(*to_vrs_params)
         self.normalize_handler = Normalize(*to_vrs_params + [uta_db])

{variation-normalizer-0.7.0.dev4 → variation-normalizer-0.7.0.dev5}/variation/schemas/token_response_schema.py

@@ -111,49 +111,6 @@ class GeneMatchToken(Token):
             }
 
 
-class GenePairMatchToken(Token):
-    """Define model for gene pair token."""
-
-    left_gene_token: GeneMatchToken
-    right_gene_token: GeneMatchToken
-    token_type = "GenePair"
-
-    class Config:
-        """Configure model."""
-
-        @staticmethod
-        def schema_extra(schema: Dict[str, Any],
-                         model: Type["GenePairMatchToken"]) -> None:
-            """Configure OpenAPI schema."""
-            if "title" in schema.keys():
-                schema.pop("title", None)
-            for prop in schema.get("properties", {}).values():
-                prop.pop("title", None)
-            schema["example"] = {
-                "token": "BRAF-ABL1",
-                "token_type": "GenePair",
-                "match_type": 5,
-                "input_string": "braf-abl1",
-                "object_type": "Token",
-                "left_gene_token": {
-                    "token": "BRAF",
-                    "token_type": "GeneSymbol",
-                    "match_type": 2,
-                    "input_string": "BRAF",
-                    "object_type": "Token",
-                    "matched_value": "BRAF"
-                },
-                "right_gene_token": {
-                    "token": "ABL1",
-                    "token_type": "GeneSymbol",
-                    "match_type": 2,
-                    "input_string": "ABL1",
-                    "object_type": "Token",
-                    "matched_value": "ABL1"
-                }
-            }
-
-
 class CoordinateType(str, Enum):
     """Define constraints for coordinate types."""
 
@@ -275,9 +232,15 @@ class TokenResponseSchema(BaseModel):
     """Define model for token response."""
 
     search_term: str
-    tokens: List[Union[GeneMatchToken, GenePairMatchToken,
-                       ProteinSubstitutionToken, PolypeptideTruncationToken,
-                       SilentMutationToken, Token]]
+    tokens: List[
+        Union[
+            GeneMatchToken,
+            ProteinSubstitutionToken,
+            PolypeptideTruncationToken,
+            SilentMutationToken,
+            Token
+        ]
+    ]
 
     class Config:
         """Configure model."""

{variation-normalizer-0.7.0.dev4 → variation-normalizer-0.7.0.dev5}/variation/tokenizers/__init__.py

@@ -1,9 +1,7 @@
 """Module to load and init namespace at package level."""
 from .tokenizer import Tokenizer
 from .tokenize import Tokenize
-from .gene_pair import GenePair
 from .gene_symbol import GeneSymbol
-from .protein_alternate import ProteinAlternate
 from .protein_delins import ProteinDelIns
 from .hgvs import HGVS
 from .reference_sequence import ReferenceSequence

{variation-normalizer-0.7.0.dev4 → variation-normalizer-0.7.0.dev5}/variation/tokenizers/delins_base.py

@@ -4,20 +4,14 @@ from typing import Optional, Dict, List
 
 from variation.schemas.token_response_schema import DelIns, TokenMatchType, Token
 from .tokenizer import Tokenizer
-from .caches import NucleotideCache
-from .tokenize_base import TokenizeBase
 
 
 class DelInsBase(Tokenizer):
     """Class for tokenizing DelIns."""
 
-    def __init__(self, nucleotide_cache: NucleotideCache) -> None:
-        """Initialize the DelIns Class.
-
-        :param NucleotideCache nucleotide_cache: Valid nucleotides
-        """
+    def __init__(self) -> None:
+        """Initialize the DelIns Class."""
         self.parts = None
-        self.tokenize_base = TokenizeBase(nucleotide_cache)
 
     def match(self, input_string: str) -> Optional[DelIns]:
         """Return tokens that match the input string."""
@@ -77,14 +71,13 @@ class DelInsBase(Tokenizer):
         coordinate_type = parts[0][:1]
         parts[0] = parts[0][2:]
 
-        positions_deleted = self.tokenize_base.get_positions_deleted(parts)
+        positions_deleted = self.get_positions_deleted(parts)
         if not positions_deleted:
             return
         start_pos_del = positions_deleted[0]
         end_pos_del = positions_deleted[1]
 
-        inserted_sequences = \
-            self.tokenize_base.get_transcript_genomic_inserted_sequence(parts)
+        inserted_sequences = self.get_transcript_genomic_inserted_sequence(parts)
         if not inserted_sequences:
             return
         inserted_sequence1 = inserted_sequences[0]

{variation-normalizer-0.7.0.dev4 → variation-normalizer-0.7.0.dev5}/variation/tokenizers/gnomad_vcf.py

@@ -12,11 +12,9 @@ from .tokenizer import Tokenizer
 class GnomadVCF(Tokenizer):
     """The gnomad VCF tokenizer class"""
 
-    def __init__(self) -> None:
-        """Initialize the gnomad VCF tokenizer class"""
-        self.splitter = re.compile(
-            r"^(?P<chromosome>(chr|chromosome)?([1-9]|[1][0-9]|[2][0-2]|X|Y))-"
-            r"(?P<pos>[1-9]\d*)-(?P<ref>(?i)[actg]+)-(?P<alt>(?i)[actg]+)$")
+    splitter = re.compile(
+        r"^(?P<chromosome>(chr|chromosome)?([1-9]|[1][0-9]|[2][0-2]|X|Y))-"
+        r"(?P<pos>[1-9]\d*)-(?P<ref>(?i)[actg]+)-(?P<alt>(?i)[actg]+)$")
 
     def match(self, input_string: str) -> Optional[List[Token]]:
         """Return a GnomadVCFToken if a match exists.

{variation-normalizer-0.7.0.dev4 → variation-normalizer-0.7.0.dev5}/variation/tokenizers/hgvs.py

@@ -15,10 +15,8 @@ from .locus_reference_genomic import LocusReferenceGenomic
 class HGVS(Tokenizer):
     """The HGVS tokenizer class."""
 
-    def __init__(self) -> None:
-        """Initialize the HGVS tokenizer class."""
-        self.parser = Parser()
-        self.validator = IntrinsicValidator()
+    parser = Parser()
+    validator = IntrinsicValidator()
 
     def match(self, input_string: str) -> Optional[Token]:
         """Return token matches from input string."""

{variation-normalizer-0.7.0.dev4 → variation-normalizer-0.7.0.dev5}/variation/tokenizers/insertion_base.py

@@ -4,20 +4,14 @@ from typing import Optional, Dict, List
 
 from variation.schemas.token_response_schema import Insertion, TokenMatchType, Token
 from .tokenizer import Tokenizer
-from .caches import NucleotideCache
-from .tokenize_base import TokenizeBase
 
 
 class InsertionBase(Tokenizer):
     """Class for tokenizing Insertion."""
 
-    def __init__(self, nucleotide_cache: NucleotideCache) -> None:
-        """Initialize the Insertion Class.
-
-        :param NucleotideCache nucleotide_cache: Valid nucleotides
-        """
+    def __init__(self) -> None:
+        """Initialize the Insertion Class."""
         self.parts = None
-        self.tokenize_base = TokenizeBase(nucleotide_cache)
 
     def match(self, input_string: str) -> Optional[Insertion]:
         """Return tokens that match the input string."""
@@ -67,14 +61,13 @@ class InsertionBase(Tokenizer):
         coordinate_type = parts[0][:1]
         parts[0] = parts[0][2:]
 
-        positions = self.tokenize_base.get_positions_deleted(parts)
+        positions = self.get_positions_deleted(parts)
         if not positions:
             return None
         start_pos = positions[0]
         end_pos = positions[1]
 
-        inserted_sequences = \
-            self.tokenize_base.get_transcript_genomic_inserted_sequence(parts)
+        inserted_sequences = self.get_transcript_genomic_inserted_sequence(parts)
         if not inserted_sequences or not inserted_sequences[0]:
             return None
 

{variation-normalizer-0.7.0.dev4 → variation-normalizer-0.7.0.dev5}/variation/tokenizers/locus_reference_genomic.py

@@ -10,10 +10,10 @@ from .tokenizer import Tokenizer
 class LocusReferenceGenomic(Tokenizer):
     """The LRG class for tokenization."""
 
+    regex = r"lrg_\d+((t|p)\d+)?"
+
     def __init__(self) -> None:
         """Initialize the LRG class."""
-        self.splitter = re.compile(r"(\d+)")
-        self.regex = r"lrg_\d+((t|p)\d+)?"
         self.parts = None
 
     def match(self, input_string: str) -> Optional[LocusReferenceGenomicToken]:

{variation-normalizer-0.7.0.dev4 → variation-normalizer-0.7.0.dev5}/variation/tokenizers/polypeptide_sequence_variation_base.py

@@ -1,5 +1,4 @@
 """A module for Polypeptide Sequence Variation Tokenization Base Class."""
-import re
 from abc import abstractmethod
 from typing import List, Optional
 
@@ -14,7 +13,6 @@ class PolypeptideSequenceVariationBase(Tokenizer):
 
     def __init__(self) -> None:
         """Initialize the Polypeptide Sequence Variation Base Class."""
-        self.splitter = re.compile(r"(\d+)")
         self.psub = None
 
     def _set_psub(self, amino_acid: str, position: int, new_amino_acid: str) -> None:

{variation-normalizer-0.7.0.dev4 → variation-normalizer-0.7.0.dev5}/variation/tokenizers/polypeptide_truncation.py

@@ -40,11 +40,11 @@ class PolypeptideTruncation(PolypeptideSequenceVariationBase):
             else:
                 p_count = input_string.count("p.")
                 if p_count == 1:
-                    psub_parts = self.splitter.split(input_string)
+                    psub_parts = self.splitter_paren_digits.split(input_string)
             if len(split_whitespace) == 2:
                 psub_parts = split_whitespace
         else:
-            psub_parts = self.splitter.split(input_string)
+            psub_parts = self.splitter_paren_digits.split(input_string)
 
         self._get_psub(psub_parts)
 
@@ -92,5 +92,5 @@ class PolypeptideTruncation(PolypeptideSequenceVariationBase):
                 check_nonsense = f"({psub_parts[0].replace('ter', '*')})"
                 if check_nonsense == psub_parts[1]:
                     psub_parts = \
-                        self.splitter.split(psub_parts[0].split("p.")[-1])
+                        self.splitter_paren_digits.split(psub_parts[0].split("p.")[-1])
                     self._get_psub(psub_parts)

{variation-normalizer-0.7.0.dev4 → variation-normalizer-0.7.0.dev5}/variation/tokenizers/protein_delins.py

@@ -5,21 +5,15 @@ from pydantic.error_wrappers import ValidationError
 
 from variation.schemas.token_response_schema import ProteinDelInsToken, \
     TokenMatchType
-from .caches import NucleotideCache
 from .tokenizer import Tokenizer
-from .tokenize_base import TokenizeBase
 
 
 class ProteinDelIns(Tokenizer):
     """Class for tokenizing DelIns on the protein reference sequence."""
 
-    def __init__(self, nucleotide_cache: NucleotideCache) -> None:
-        """Initialize the Protein DelIns Class.
-
-        :param NucleotideCache nucleotide_cache: Valid nucleotides
-        """
+    def __init__(self) -> None:
+        """Initialize the Protein DelIns Class."""
         self.parts = None
-        self.tokenize_base = TokenizeBase(nucleotide_cache)
 
     def match(self, input_string: str) -> Optional[ProteinDelInsToken]:
         """Return token that match the input string."""
@@ -66,13 +60,12 @@ class ProteinDelIns(Tokenizer):
             return None
 
         # Get reference sequence
-        range_aa_pos = self.tokenize_base.get_aa_pos_range(parts)
+        range_aa_pos = self.get_aa_pos_range(parts)
         if range_aa_pos:
             self.parts["start_aa_del"] = range_aa_pos[0]
             self.parts["end_aa_del"] = range_aa_pos[1]
             self.parts["start_pos_del"] = range_aa_pos[2]
             self.parts["end_pos_del"] = range_aa_pos[3]
             self.parts["used_one_letter"] = range_aa_pos[4]
-        self.parts["inserted_sequence"] = \
-            self.tokenize_base.get_protein_inserted_sequence(
-                parts, self.parts["used_one_letter"])
+        self.parts["inserted_sequence"] = self.get_protein_inserted_sequence(
+            parts, self.parts["used_one_letter"])

{variation-normalizer-0.7.0.dev4 → variation-normalizer-0.7.0.dev5}/variation/tokenizers/protein_insertion.py

@@ -5,21 +5,15 @@ from pydantic.error_wrappers import ValidationError
 
 from variation.schemas.token_response_schema import ProteinInsertionToken, \
     TokenMatchType
-from .caches import NucleotideCache
 from .tokenizer import Tokenizer
-from .tokenize_base import TokenizeBase
 
 
 class ProteinInsertion(Tokenizer):
     """Class for tokenizing Insertions on the protein reference sequence."""
 
-    def __init__(self, nucleotide_cache: NucleotideCache) -> None:
-        """Initialize the Protein Insertion Class.
-
-        :param NucleotideCache nucleotide_cache: Valid nucleotides
-        """
+    def __init__(self) -> None:
+        """Initialize the Protein Insertion Class."""
         self.parts = None
-        self.tokenize_base = TokenizeBase(nucleotide_cache)
 
     def match(self, input_string: str) -> Optional[ProteinInsertionToken]:
         """Return token that match the input string."""
@@ -67,13 +61,13 @@ class ProteinInsertion(Tokenizer):
         if len(parts) != 2:
             return
 
-        range_aa_pos = self.tokenize_base.get_aa_pos_range(parts)
+        range_aa_pos = self.get_aa_pos_range(parts)
         if range_aa_pos:
             self.parts["start_aa_flank"] = range_aa_pos[0]
             self.parts["end_aa_flank"] = range_aa_pos[1]
             self.parts["start_pos_flank"] = range_aa_pos[2]
             self.parts["end_pos_flank"] = range_aa_pos[3]
             self.parts["used_one_letter"] = range_aa_pos[4]
-        self.parts["inserted_sequence"] = \
-            self.tokenize_base.get_protein_inserted_sequence(
-                parts, self.parts["used_one_letter"])
+        self.parts["inserted_sequence"] = self.get_protein_inserted_sequence(
+            parts, self.parts["used_one_letter"]
+        )

{variation-normalizer-0.7.0.dev4 → variation-normalizer-0.7.0.dev5}/variation/tokenizers/protein_substitution.py

@@ -37,11 +37,11 @@ class ProteinSubstitution(PolypeptideSequenceVariationBase):
                 return None
             p_count = input_string.count("p.")
             if p_count == 1:
-                psub_parts = self.splitter.split(input_string)
+                psub_parts = self.splitter_paren_digits.split(input_string)
             elif p_count == 2:
                 psub_parts = input_string.split()
         else:
-            psub_parts = self.splitter.split(input_string)
+            psub_parts = self.splitter_paren_digits.split(input_string)
 
         self._get_psub(psub_parts)
 

{variation-normalizer-0.7.0.dev4 → variation-normalizer-0.7.0.dev5}/variation/tokenizers/silent_mutation.py

@@ -33,9 +33,9 @@ class SilentMutation(PolypeptideSequenceVariationBase):
                 return None
             p_count = input_string.count("p.")
             if p_count == 1:
-                psub_parts = self.splitter.split(input_string)
+                psub_parts = self.splitter_paren_digits.split(input_string)
         else:
-            psub_parts = self.splitter.split(input_string)
+            psub_parts = self.splitter_paren_digits.split(input_string)
 
         self._get_psub(psub_parts)
 

{variation-normalizer-0.7.0.dev4 → variation-normalizer-0.7.0.dev5}/variation/tokenizers/single_nucleotide_variation_base.py

@@ -1,11 +1,9 @@
 """A module for Single Nucleotide Variation Tokenization Base Class."""
-import re
 from abc import abstractmethod
 from typing import List, Optional, Dict
 
-from variation.schemas.token_response_schema import \
-    SingleNucleotideVariation, TokenMatchType
-from variation.tokenizers.caches import NucleotideCache
+from variation.schemas.token_response_schema import SingleNucleotideVariation, \
+    TokenMatchType
 from .tokenizer import Tokenizer
 
 
@@ -14,9 +12,7 @@ class SingleNucleotideVariationBase(Tokenizer):
 
     def __init__(self) -> None:
         """Initialize the Single Nucleotide Variation Base Class."""
-        self.splitter = re.compile(r"(\d+)")
         self.sub = None
-        self.nucleotide_cache = NucleotideCache()
 
     def match(self, input_string: str) -> Optional[SingleNucleotideVariation]:
         """Return a SingleNucleotideVariationToken match if one exists.
@@ -39,7 +35,7 @@ class SingleNucleotideVariationBase(Tokenizer):
         if "c." not in input_string and "g." not in input_string:
             return None
 
-        sub_parts = self.splitter.split(input_string)
+        sub_parts = self.splitter_paren_digits.split(input_string)
         self._get_sub(sub_parts)
         if None not in self.sub.values():
             params = {
@@ -80,9 +76,8 @@ class SingleNucleotideVariationBase(Tokenizer):
                 if ">" in sub_parts[2]:
                     # Substitution
                     ref_nuc, new_nuc = sub_parts[2].split(">")
-                    nucleotides = self.nucleotide_cache.nucleotides.keys()
-                    if ref_nuc.upper() in nucleotides \
-                            and new_nuc.upper() in nucleotides:  # noqa: E501
+                    if ref_nuc.upper() in self.base_nucleotides \
+                            and new_nuc.upper() in self.base_nucleotides:
                         self._set_sub(ref_nuc, sub_parts[1], new_nuc,
                                       sub_parts[0].split(".")[0])
                 elif sub_parts[2] == "=":

{variation-normalizer-0.7.0.dev4 → variation-normalizer-0.7.0.dev5}/variation/tokenizers/tokenize.py

@@ -27,7 +27,6 @@ from .genomic_duplication import GenomicDuplication
 from .genomic_deletion_range import GenomicDeletionRange
 from .gnomad_vcf import GnomadVCF
 from .free_text_categorical import FreeTextCategorical
-from .caches import NucleotideCache
 
 
 class Tokenize:
@@ -35,7 +34,6 @@ class Tokenize:
 
     def __init__(self, gene_symbol: GeneSymbol) -> None:
         """Initialize the tokenize class."""
-        nucleotide_cache = NucleotideCache()
         self.tokenizers = (
             HGVS(),
             ReferenceSequence(),
@@ -50,15 +48,15 @@ class Tokenize:
             GenomicSubstitution(),
             CodingDNASilentMutation(),
             GenomicSilentMutation(),
-            ProteinDelIns(nucleotide_cache),
-            CodingDNADelIns(nucleotide_cache),
-            GenomicDelIns(nucleotide_cache),
+            ProteinDelIns(),
+            CodingDNADelIns(),
+            GenomicDelIns(),
             ProteinDeletion(),
             CodingDNADeletion(),
             GenomicDeletion(),
-            ProteinInsertion(nucleotide_cache),
-            CodingDNAInsertion(nucleotide_cache),
-            GenomicInsertion(nucleotide_cache),
+            ProteinInsertion(),
+            CodingDNAInsertion(),
+            GenomicInsertion(),
             GenomicUncertainDeletion(),
             GenomicDuplication(),
             GenomicDeletionRange()