geney 1.2.20__py2.py3-none-any.whl → 1.2.21__py2.py3-none-any.whl

geney/data_parsers/gtex.py

@@ -1,68 +0,0 @@
-import pandas as pd
-from tqdm import tqdm
-
-# Set pandas display options (if necessary)
-pd.options.display.max_rows = 999
-
-# Read metadata
-metadata = pd.read_csv('GTEx_Analysis_v8_Annotations_SampleAttributesDS.txt', delimiter='\t')
-metadata_tissue_mapper = metadata[['SAMPID', 'SMTS']].drop_duplicates().set_index('SAMPID').to_dict()['SMTS']
-
-# Initialize an empty DataFrame for combined results
-combined_df = pd.DataFrame()
-
-# Define chunk size
-tpm_mean = []
-# Process the main data file in chunks
-for chunk in tqdm(pd.read_csv('GTEx_Analysis_2017-06-05_v8_RSEMv1.3.0_transcript_tpm.gct', header=2, chunksize=1000,
-                              delimiter='\t')):
-    # Perform the same operations on the chunk
-    chunk = chunk.set_index(['transcript_id', 'gene_id']).rename(columns=metadata_tissue_mapper)
-    # Append the processed chunk to the combined DataFrame
-    tpm_mean.append(chunk.T.groupby(by=chunk.columns).mean().T)
-
-# Compute the mean TPM per tissue
-tpm_mean = pd.concat(tpm_mean)
-
-
-cancer_projects = {
-    "Adrenal Gland": "ACC",
-    "Bladder": "BLCA",
-    "Brain": ["GBM", "LGG"],  # Note: Brain maps to two projects
-    "Breast": "BRCA",
-    "Colon": "COAD",
-    "Esophagus": "ESCA",
-    "Kidney": ["KICH", "KIRC", "KIRP"],  # Note: Kidney maps to three projects
-    "Liver": "LIHC",
-    "Lung": "LUNG",
-    "Ovary": "OV",
-    "Pancreas": "PAAD",
-    "Prostate": "PRAD",
-    "Skin": "SKCM",
-    "Stomach": "STAD",
-    "Testis": "TGCT",
-    "Uterus": "UCS"
-}
-
-tissue_projects = {
-    "ACC": "Adrenal Gland",
-    "BLCA": "Bladder",
-    "GBM": "Brain",
-    "LGG": "Brain",
-    "BRCA": "Breast",
-    "COAD": "Colon",
-    "ESCA": "Esophagus",
-    "KICH": "Kidney",
-    "KIRC": "Kidney",
-    "KIRP": "Kidney",
-    "LIHC": "Liver",
-    "LUNG": "Lung",
-    "OV": "Ovary",
-    "PAAD": "Pancreas",
-    "PRAD": "Prostate",
-    "SKCM": "Skin",
-    "STAD": "Stomach",
-    "TGCT": "Testis",
-    "UCS": "Uterus"
-}
-

geney/gtex.py

@@ -1,68 +0,0 @@
-import pandas as pd
-from tqdm import tqdm
-
-# Set pandas display options (if necessary)
-pd.options.display.max_rows = 999
-
-# Read metadata
-metadata = pd.read_csv('GTEx_Analysis_v8_Annotations_SampleAttributesDS.txt', delimiter='\t')
-metadata_tissue_mapper = metadata[['SAMPID', 'SMTS']].drop_duplicates().set_index('SAMPID').to_dict()['SMTS']
-
-# Initialize an empty DataFrame for combined results
-combined_df = pd.DataFrame()
-
-# Define chunk size
-tpm_mean = []
-# Process the main data file in chunks
-for chunk in tqdm(pd.read_csv('GTEx_Analysis_2017-06-05_v8_RSEMv1.3.0_transcript_tpm.gct', header=2, chunksize=1000,
-                              delimiter='\t')):
-    # Perform the same operations on the chunk
-    chunk = chunk.set_index(['transcript_id', 'gene_id']).rename(columns=metadata_tissue_mapper)
-    # Append the processed chunk to the combined DataFrame
-    tpm_mean.append(chunk.T.groupby(by=chunk.columns).mean().T)
-
-# Compute the mean TPM per tissue
-tpm_mean = pd.concat(tpm_mean)
-
-
-cancer_projects = {
-    "Adrenal Gland": "ACC",
-    "Bladder": "BLCA",
-    "Brain": ["GBM", "LGG"],  # Note: Brain maps to two projects
-    "Breast": "BRCA",
-    "Colon": "COAD",
-    "Esophagus": "ESCA",
-    "Kidney": ["KICH", "KIRC", "KIRP"],  # Note: Kidney maps to three projects
-    "Liver": "LIHC",
-    "Lung": "LUNG",
-    "Ovary": "OV",
-    "Pancreas": "PAAD",
-    "Prostate": "PRAD",
-    "Skin": "SKCM",
-    "Stomach": "STAD",
-    "Testis": "TGCT",
-    "Uterus": "UCS"
-}
-
-tissue_projects = {
-    "ACC": "Adrenal Gland",
-    "BLCA": "Bladder",
-    "GBM": "Brain",
-    "LGG": "Brain",
-    "BRCA": "Breast",
-    "COAD": "Colon",
-    "ESCA": "Esophagus",
-    "KICH": "Kidney",
-    "KIRC": "Kidney",
-    "KIRP": "Kidney",
-    "LIHC": "Liver",
-    "LUNG": "Lung",
-    "OV": "Ovary",
-    "PAAD": "Pancreas",
-    "PRAD": "Prostate",
-    "SKCM": "Skin",
-    "STAD": "Stomach",
-    "TGCT": "Testis",
-    "UCS": "Uterus"
-}
-

geney/immunotherapy/netchop.py

@@ -1,78 +0,0 @@
-
-import subprocess
-import logging
-import tempfile
-
-
-class NetChop(object):
-    """
-    Wrapper around netChop tool. Assumes netChop is in your PATH.
-    """
-
-    def predict_epitopes(self, sequences min_len=8):
-        """
-        Return netChop predictions for each position in each sequence.
-
-        Parameters
-        -----------
-        sequences : list of string
-            Amino acid sequences to predict cleavage for
-
-        Returns
-        -----------
-        list of list of float
-
-        The i'th list corresponds to the i'th sequence. Each list gives
-        the cleavage probability for each position in the sequence.
-        """
-        with tempfile.NamedTemporaryFile(suffix=".fsa", mode="w") as input_fd:
-            for (i, sequence) in enumerate(sequences):
-                input_fd.write("> %d\n" % i)
-                input_fd.write(sequence)
-                input_fd.write("\n")
-            input_fd.flush()
-            try:
-                output = subprocess.check_output(["netChop", input_fd.name])
-            except subprocess.CalledProcessError as e:
-                logging.error("Error calling netChop: %s:\n%s" % (e, e.output))
-                raise
-
-        parsed = self.parse_netchop(output)
-        assert len(parsed) == len(sequences), \
-            "Expected %d results but got %d" % (
-                len(sequences), len(parsed))
-        assert [len(x) for x in parsed] == [len(x) for x in sequences]
-        filtered_proteosomes = []
-        for scores, seq in list(zip(parsed, sequences)):
-            proteosome = self.chop_protein(seq, [s > threshold for s in scores])
-            filtered_proteosomes.append([e for e in proteosome if len(e) > min_len])
-        return proteosomes
-
-    @staticmethod
-    def parse_netchop(netchop_output):
-        """
-        Parse netChop stdout.
-        """
-        line_iterator = iter(netchop_output.decode().split("\n"))
-        scores = []
-        for line in line_iterator:
-            if "pos" in line and 'AA' in line and 'score' in line:
-                scores.append([])
-                if "----" not in next(line_iterator):
-                    raise ValueError("Dashes expected")
-                line = next(line_iterator)
-                while '-------' not in line:
-                    score = float(line.split()[3])
-                    scores[-1].append(score)
-                    line = next(line_iterator)
-        return scores
-
-    def chop_protein(self, seq, pos):
-        # Generate subsequences using list comprehension and slicing
-        start = 0
-        subsequences = [seq[start:(start := i+1)] for i, marker in enumerate(pos) if marker == 1]
-        # Check if the last part needs to be added
-        if start < len(seq):
-            subsequences.append(seq[start:])
-        return subsequences
-

geney/mutations/variant_utils.py

@@ -1,125 +0,0 @@
-
-from pathlib import Path
-END_CODONS = ['TAA', 'TAG', 'TGA']
-
-def is_monotonic(A):
-    x, y = [], []
-    x.extend(A)
-    y.extend(A)
-    x.sort()
-    y.sort(reverse=True)
-    if(x == A or y == A):
-        return True
-    return False
-
-
-class Mutation:
-    def __init__(self, mid):
-        self.mut_id = mid
-
-        gene, chrom, pos, ref, alt = mid.split(':')
-        self.gene = gene
-        self.chrom = chrom.strip('chr')
-        self.start = int(pos)
-
-        self.file_identifier = self.mut_id.replace(':', '_')
-        self.file_identifier_short = f'{self.start}_{ref}_{alt}'
-
-        self.ref = ref if ref != '-' else ''
-        self.alt = alt if alt != '-' else ''
-
-        if len(self.ref) == len(self.alt) == 1:
-            self.vartype = 'SNP'
-        elif len(self.ref) == len(self.alt) > 1:
-            self.vartype = 'SUB'
-        elif self.ref and not self.alt:
-            self.vartype = 'DEL'
-        elif self.alt and not self.ref:
-            self.vartype = 'INS'
-        else:
-            self.vartype = 'INDEL'
-
-    def __str__(self):
-        return self.mut_id
-
-    def __repr__(self):
-        return self.mut_id
-
-    def __lt__(self, other):
-        return self.start < other.start
-
-
-class Variations:
-    def __init__(self, epistatic_set):
-        self.variants = sorted([Mutation(m) for m in epistatic_set.split('|')])
-        self.mut_id = epistatic_set
-        self.start = self.variants[0].start
-        self.positions = [v.start for v in self.variants]
-        # self.ref = ','.join([m.ref for m in self.variants])
-        # self.alt = ','.join([m.alt for m in self.variants])
-        self.gene = self.variants[0].gene
-        self.chrom = self.variants[0].chrom.strip('chr')
-        self.file_identifier = f'{self.gene}_{self.chrom}' + '_' + '_'.join([v.file_identifier_short for v in self.variants])
-
-    def __str__(self):
-        return '|'.join([m.mut_id for m in self.variants])
-
-    def __repr__(self):
-        return '|'.join([m.mut_id for m in self.variants])
-
-    def __iter__(self):
-        self.current_index = 0
-        return self
-
-    def __next__(self):
-        if self.current_index < len(self.variants):
-            x = self.variants[self.current_index]
-            self.current_index += 1
-            return x
-        raise StopIteration
-
-    @property
-    def file_identifier_json(self):
-        return Path(self.file_identifier + '.json')
-
-
-def generate_mut_variant(seq: str, indices: list, mut: Mutation):
-    offset = 1 if not mut.ref else 0
-
-    check_indices = list(range(mut.start, mut.start + len(mut.ref) + offset))
-    check1 = all([m in indices for m in check_indices])
-    if not check1:
-        print(f"Mutation {mut} not within transcript bounds: {min(indices)} - {max(indices)}.")
-        return seq, indices, False, False
-
-    rel_start, rel_end = indices.index(mut.start)+offset, indices.index(mut.start)+offset+len(mut.ref)
-    acquired_seq = seq[rel_start:rel_end]
-    check2 = acquired_seq == mut.ref
-    if not check2:
-        print(f'Reference allele does not match genome_build allele. {acquired_seq}, {mut.ref}, {mut.start}')
-        consensus_allele = False
-    else:
-        consensus_allele = True
-    if len(mut.ref) == len(mut.alt) > 0:
-        temp_indices = list(range(mut.start, mut.start + len(mut.ref)))
-    else:
-        temp_indices = [indices[indices.index(mut.start)] + v / 1000 for v in list(range(1, len(mut.alt)+1))]
-
-
-    new_indices = indices[:rel_start] + temp_indices + indices[rel_end:]
-    new_seq = seq[:rel_start] + mut.alt + seq[rel_end:]
-
-    assert len(new_seq) == len(new_indices), f'Error in variant modification: {mut}, {len(new_seq)}, {len(new_indices)}'
-    assert is_monotonic(list(filter((-1).__ne__, new_indices))), f'Mut indices are not monotonic.'
-    return new_seq, new_indices, True, consensus_allele
-
-
-def find_new_tts(seq, indices, tis):
-    seq, indices = seq[indices.index(tis):], indices[indices.index(tis):]
-    pos_options = [i for i in list(range(0, len(seq), 3)) if seq[i:i + 3] in END_CODONS and i+3 <= len(seq)]
-    if len(pos_options) == 0:
-        return indices[0] #[len(seq) - (len(seq) % 3) - 1]
-    pos_options = pos_options[0]
-    assert pos_options % 3 == 0, f'{pos_options} not divisible by three.'
-    pos_options -= 1
-    return indices[pos_options]

geney/netchop.py

@@ -1,79 +0,0 @@
-
-import subprocess
-import logging
-import tempfile
-from geney import config_setup
-
-class NetChop(object):
-    """
-    Wrapper around netChop tool. Assumes netChop is in your PATH.
-    """
-    def predict_epitopes(self, sequences, threshold, min_len=8):
-        """
-        Return netChop predictions for each position in each sequence.
-
-        Parameters
-        -----------
-        sequences : list of string
-            Amino acid sequences to predict cleavage for
-
-        Returns
-        -----------
-        list of list of float
-
-        The i'th list corresponds to the i'th sequence. Each list gives
-        the cleavage probability for each position in the sequence.
-        """
-        with tempfile.NamedTemporaryFile(dir=config_setup['NETCHOP'], suffix=".fsa", mode="w") as input_fd:
-        # temp_file = config_setup['NETCHOP'] / 'netchop_input.fsa'
-        # with open(temp_file, 'w') as input_fd:
-            for (i, sequence) in enumerate(sequences):
-                _ = input_fd.write("> %d\n" % i)
-                _ = input_fd.write(sequence)
-                _ = input_fd.write("\n")
-            # input_fd.flush()
-            # print(str(temp_file))
-
-            try:
-                output = subprocess.check_output(["netchop", str(input_fd.name)])
-            except subprocess.CalledProcessError as e:
-                logging.error("Error calling netChop: %s:\n%s" % (e, e.output))
-                raise
-
-        parsed = self.parse_netchop(output)
-        assert len(parsed) == len(sequences), \
-            "Expected %d results but got %d" % (
-                len(sequences), len(parsed))
-        assert [len(x) for x in parsed] == [len(x) for x in sequences]
-        filtered_proteosomes = []
-        for scores, seq in list(zip(parsed, sequences)):
-            proteosome = self.chop_protein(seq, [s > threshold for s in scores])
-            filtered_proteosomes.append([e for e in proteosome if len(e) > min_len])
-        return filtered_proteosomes
-    @staticmethod
-    def parse_netchop(netchop_output):
-        """
-        Parse netChop stdout.
-        """
-        line_iterator = iter(netchop_output.decode().split("\n"))
-        scores = []
-        for line in line_iterator:
-            if "pos" in line and 'AA' in line and 'score' in line:
-                scores.append([])
-                if "----" not in next(line_iterator):
-                    raise ValueError("Dashes expected")
-                line = next(line_iterator)
-                while '-------' not in line:
-                    score = float(line.split()[3])
-                    scores[-1].append(score)
-                    line = next(line_iterator)
-        return scores
-    def chop_protein(self, seq, pos):
-        # Generate subsequences using list comprehension and slicing
-        start = 0
-        subsequences = [seq[start:(start := i+1)] for i, marker in enumerate(pos) if marker == 1]
-        # Check if the last part needs to be added
-        if start < len(seq):
-            subsequences.append(seq[start:])
-        return subsequences
-