diff --git a/README.md b/README.md index f3e345c..16c6301 100644 --- a/README.md +++ b/README.md @@ -1 +1,261 @@ -# Junior_Bioinformatic_tool \ No newline at end of file +# My junior biochemical tool +This package consists of 2 mini-tools +`tools_for_bioinformatics` designed to work with nucleotide and amino acid sequences and FASTQ files +`bio_files_processor` provides opportunity to manipulate with FASTA files + + +# My junior biochemical tool +This package for junior bioinformaticians is designed to work with nucleotide and amino acid sequences and FASTQ files, and consists of three parts. Each module `amino_acid_tools`, `dna_rna_tools` and `fastq_filtration` presents its own possibilities for sequence processing. + +# `amino_acids_tools` +This tool is designed to work with amino acid sequences consisting of _22 proteinogenic amino acid_ residues (including pyrrolizine and selenocysteine) recorded in a standard one-letter format. It is not intended to process sequences with post-translational and other amino acid modifications + +## Usage +You call the `amino_acid_tools` function, which takes as input an arbitrary number of arguments with amino-acid sequences (str), as well as the name of the procedure to be executed (it is always the last argument, str). After that the command performs the specified action on all the given sequences. If one sequence is submitted, a string with the result is returned. If several sequences are submitted, a list of strings is returned. +Input sequences can contain both uppercase and lowercase letters, but the last argument with the function name must correspond to the listed functions. + + +## Options +The following options for aminoacid sequence processing are available at the moment: + +- **molecular_weight**: calculate the molecular weight of the amino acid chain in Da, according to the average amino acid residues molecular masses rounded to 1 or 2 decimal places. +- **three_letter_code**: converts standard single letter translations to three letter translations +- **show_length**: count the overall number of amino acids in the given +- **sequence folding**: count the number of amino acids characteristic separately for alpha helixes and beta sheets,and give out what will be the structure of the protein more. This function has been tested on proteins such as 2M3X, 6DT4 (PDB ID) and MHC, CRP. The obtained results corresponded to reality. +- **seq_charge**: evaluates the overall charge of the aminoacid chain in neutral aqueous solution (pH = 7), according to the pKa of amino acid side chains, lysine, pyrrolizine and arginine contribute +1, while asparagine and glutamic amino acids contribute -1. The total charge of a protein is evaluated as positive, negative, or neutral as the sum of these contributions + +### Remarks +If sequense contains symbols differ from IUPAC 1-letter code for 22 proteinogenic amino acids, +the result *for this sequence* will be `'unexpected symbols in sequence'` regardless of function +If action is not in the function the message `'unexpected action'` will occur + +## Examples +Below is an example of processing an amino acid sequence for different input data +```Python +amino_acid_tools('DNA', 'molecular_weight') +``` +Output: 300.28 + +```Python +amino_acid_tools('DNA', 'russco', 'LOLkEk', 'azaz', 'three_letter_code') +``` +Output: ['AspAsnAla', 'ArgSecSerSerCysPyl', 'LeuPylLeuLysGluLys', 'unexpected symbols in sequence'] + +```Python +amino_acid_tools('DNA', 'russco', 'LOLkEk', 'azaz', 'letter_code') +``` +ValueError: Unexpected action + +### Using the function for molecular weight calculation + +```Python +amino_acid_tools('EGVIMSELKLK', 'PLPKvelPPDFVD', 'DVIGISILGKEV', 'molecular_weight') +``` + +Input: 'EGVIMSELKLK', 'PLPKvelPPDFVD', 'DVIGISILGKEV', 'molecular_weight' +Output: '[1228.66, 1447.8400000000001, 1224.6399999999999]' + +### Using the function to convert one-letter translations to three-letter translations + +```Python +amino_acid_tools('EGVIMSELKLK', 'PLPKvelPPDFVD', 'DVIGISILGKEV', 'three_letter_code') +``` + +Input: 'EGVIMSELKLK', 'PLPKvelPPDFVD', 'DVIGISILGKEV', 'three_letter_code' +Output: '['GluGlyValIleMetSerGluLeuLysLeuLys', 'ProLeuProLysValGluLeuProProAspPheValAsp', 'AspValIleGlyIleSerIleLeuGlyLysGluVal']' + +### Using the function to counts the number of amino acids in the given sequence + +```Python +amino_acid_tools('EGVIMSELKLK', 'PLPKvelPPDFVD', 'DVIGISILGKEV', 'show_length') +``` + +Input: 'EGVIMSELKLK', 'PLPKvelPPDFVD', 'DVIGISILGKEV', 'show_length' +Output: '[11, 13, 12]' + +### Using the function to determine the predominant secondary structure + +```Python +amino_acid_tools('EGVIMSELKLK', 'PLPKvelPPDFVD', 'DVIGISILGKEV', 'folding') +``` +Input: 'EGVIMSELKLK', 'PLPKvelPPDFVD', 'DVIGISILGKEV', 'folding' +Output: '['alfa_helix', 'equally', 'equally']' + +### Using the function to estimate relative charge + +```Python +amino_acid_tools('EGVIMSELKLK', 'PLPKvelPPDFVD', 'DVIGISILGKEV', 'seq_charge') +``` + +Input: 'EGVIMSELKLK', 'PLPKvelPPDFVD', 'DVIGISILGKEV', 'seq_charge' +Output: '['neutral', 'negative', 'negative']' + +# `DNA_RNA_tools` + +This program is designed to work with nucleic acid sequences. We expect RNA and DNA chains in the standard NNNNNNNN form, without phosphate groups, in uppercase or lowercase letters + +### Usage +You call the `dna_rna_tools` function, which takes as input anumber of arguments with amino-acid sequences (str), as well as the name of the procedure to be executed (it is always the last argument, str). + +The nucleotide sequence can consist of both uppercase and lowercase letters. +Input example: +```Python +dna_rna_tools('GCGGT','auccuc','GCTatGc','complement') +``` + +### Functions: +Folowing options are avaliable now: + + - **complement:** makes complement sequence to seq + - **reverse**: reverses sequence, (from 5'-3' to 3' -5' there or back) + - **reverse_complement**: makes complement sequence and reverse it + - **transcribe**: make transcript of DNA sequence. in the case of RNA + sequence, no changes will be returned + +*Returns:* +If one sequence is supplied, a string with the result is returned. +If several are submitted, a list of strings is returned. + +#### Remarks +If seq contains both U(u) and T(t) the result *for this sequence* will be `"U and T in one seq"` regardless of function + +If seq contains symbols differ from standardized oligonucleotide notation, the result *for this sequence* will be `'unexpected symbols in sequence'` regardless of function +If action is not in the function the message `'unexpected action'` will occur + +### Examples: +```Python +dna_rna_tools('ATTC', 'CGcGc', 'AZA', 'atuc', 'Au', 'transcribe') +``` +Output: ['AUUC', 'CGcGc', 'unexpected symbols in sequence', 'T and U in one seq', 'Au'] + + +```Python +dna_rna_tools('ATTC', 'CGcGc', 'AZA', 'atuc', 'Au', 'revese') +``` +ValueError: Unexpected action + +```Python +dna_rna_tools('UuCG','complement') +``` +Output: 'AaGC' + +# `FASTQ_filtration tool` + +This function provides you the opportunity to filter the FASTQ list to select sequences according to requirements on three parameters: length, GC composition, and quality of the reed + +### Usage +It is required to input the list of sequences in dictionary format, as well as values for filtering parameters: interval by GC-composition, interval by sequence length, threshold value of average quality of reed. You also need input file and output file name (optional) + **input_fastq:** FASTQ file +**output_fastq** name of output file, you can find it in fastq_filtrator_resuls directory, if name is not defined, it will be the same of the input file in `fastq_filtration_result` directory + +```Python +fastq_filtration('example_fastq.fastq', , gc_bounds=(20, 40), length_bounds=(0, 2 *8), quality_treshold=10, 'outfastq_gc' ) +``` + +#### Filtering parameters + + - **gc_bounds:** interval for the of acceptable GC content, in %, *Default + value = (0,100)* + - **length_bounds**: interval for the of acceptable sequense length in + number of nucleotide, *Default value = (2,2**32)* + - **quality_treshold**: threshold value for average quality per nucleotide + (phred33 scale), *Default value = 0* + + +### Result: +New FASTQ file consists of selected sequences after 3-step filtration +#### Remarks +After running without specifying the filtering parameters, all sequences will be be selected as appropriate +You also can specify only the upper limit for GC-content and length filtering + +### Examples +```Python +fastq_filtration('example_fastq.fastq', gc_bounds= (80, 100)) +``` +@SRX079804:1:SRR292678:1:1101:1120907:1120907 1:N:0:1 BH:ok +CATGGTGGCG ++SRX079804:1:SRR292678:1:1101:1120907:1120907 1:N:0:1 BH:ok +HHHHHFHHGG +@SRX079804:1:SRR292678:1:1101:1175112:1175112 1:N:0:1 BH:failed +AGGCC ++SRX079804:1:SRR292678:1:1101:1175112:1175112 1:N:0:1 BH:failed +EC8EE +@SRX079804:1:SRR292678:1:1101:1269735:1269735 1:N:0:1 BH:failed +C ++SRX079804:1:SRR292678:1:1101:1269735:1269735 1:N:0:1 BH:failed +G +```Python +fastq_filtration('example_fastq.fastq', length_bounds= (8, 12),output_fastq = 'outfastq_length') +``` +@SRX079804:1:SRR292678:1:1101:1119783:1119783 1:N:0:1 BH:failed +TGTTGTGTCAAG ++SRX079804:1:SRR292678:1:1101:1119783:1119783 1:N:0:1 BH:failed +C@ABABEEEEAC +@SRX079804:1:SRR292678:1:1101:1120614:1120614 1:N:0:1 BH:failed +TGCTTTGCTTT ++SRX079804:1:SRR292678:1:1101:1120614:1120614 1:N:0:1 BH:failed +DFDD8FE@FFE +@SRX079804:1:SRR292678:1:1101:1120907:1120907 1:N:0:1 BH:ok +CATGGTGGCG ++SRX079804:1:SRR292678:1:1101:1120907:1120907 1:N:0:1 BH:ok +HHHHHFHHGG +@SRX079804:1:SRR292678:1:1101:1130921:1130921 1:N:0:1 BH:failed +AAGGGTCGA ++SRX079804:1:SRR292678:1:1101:1130921:1130921 1:N:0:1 BH:failed +D@CDDBEEB +@SRX079804:1:SRR292678:1:1101:1156698:1156698 1:N:0:1 BH:failed +GAAAGAAC ++SRX079804:1:SRR292678:1:1101:1156698:1156698 1:N:0:1 BH:failed +E=FFFFFF +```Python +fastq_filtration('example_fastq.fastq') +``` +input file (no filtratation with default parameters) +```Python +fastq_filtration('example_fastq.fastq', gc_bounds=(100, 100), length_bounds=(0, 0 ), quality_treshold=0, output_fastq = 'outfastq_none') +``` +empty file + + +# `bio_files_processor` + +works with FASTA files, provides 2 functions + +## `convert_multiline_fasta_to_oneline +This function covert multiple string FASTA-file to one-long-string format + + - **input_fasta**: path to the FASTA file + - **output_fasta**: name for output FASTA-file, if not defined it will be saved to the directory `Result` as `'Result'/input_fasta` + +Example input: +```Python +convert_multiline_fasta_to_oneline('example_multiline_fasta.fasta', 'output2'): +``` + +## `change_fasta_start_pos` + + +This function moves the position to a new starting nucleotide and needs 3 parameters + + - **input_fasta:** data for processing (1-string single fasta) + - **n:** position of new start nucleotide (started with 0) + - **output_fasta:** name for output fasta file + + + +Example input: +```Python +change_fasta_start_pos('example_fasta.fasta', 3, 'output2'): +``` + +Examples: +ACTGGA initial sequence +TGGAAC n =2 +AACTGG n =-1 +AACTGG n = 5 + + + +##### Contacts +Maria Lukina +maria.v.luk@gmail.com \ No newline at end of file diff --git a/bio_files_processor.py b/bio_files_processor.py new file mode 100644 index 0000000..b65fe39 --- /dev/null +++ b/bio_files_processor.py @@ -0,0 +1,68 @@ +import os + + +def convert_multiline_fasta_to_oneline(input_fasta, output_fasta = ''): + """ + This function covert multiple string FASTA-file to one-long-string format + :param input_fasta: the pass to the FASTA file + :param output_fasta: name for output FASTA-file, if not defined it will be saved to the directory + 'Result'/input_fasta + Example input: convert_multiline_fasta_to_oneline('example_multiline_fasta.fasta', 'output2'): + """ + if not os.path.isdir('multiple_to_online_results'): + os.mkdir('multiple_to_online_results') + if output_fasta == '': + output_fasta = os.path.join('multiple_to_online_results', os.path.basename(input_fasta)) + else: + output_fasta = os.path.join('multiple_to_online_results', output_fasta + ".fasta") + with open(input_fasta) as input_file, open(output_fasta, 'w') as output_file: + current = [] + output_file.write(input_file.readline()) + while True: + line = input_file.readline() + current.append(line.strip()) + if line.startswith('>'): + output_file.write(''.join(current) + '\n') + output_file.write(line) + current = [] + break + + for line in input_file: + if line.startswith('>'): + output_file.write(''.join(current) + '\n') + output_file.write(line) + current = [] + else: + current.append(line.strip()) + output_file.write(''.join(current) + '\n') + + +def change_fasta_start_pos(input_fasta, n: int, output_fasta=''): + """ + This function moves the position to a new starting nucleotide. + :param input_fasta: data for processing (1-string single fasta) + :param n: position of new start nucleotide (started with 0) + :param output_fasta: name for output fasta file + """ + if not os.path.isdir('shifted_fasta_results'): + os.mkdir('shifted_fasta_results') + if output_fasta == '': + output_fasta = os.path.join('shifted_fasta_results', os.path.basename(input_fasta)) + else: + output_fasta = os.path.join('shifted_fasta_results', output_fasta + ".fasta") + with open(input_fasta) as input_file: + name = input_file.readline().strip() + string = input_file.readline().strip() + s1 = '' + s2 = '' + if n <= 0: + n = len(string) + n + for i in range(0, len(string)): + if i < n: + s2 = s2 + string[i] + else: + s1 = s1 + string[i] + new_fasta = s1 +s2 + with open(output_fasta, 'w') as output_file: + output_file.write(name +'\n') + output_file.write(new_fasta[0] + '\n') diff --git a/modules/amino_acids_functions.py b/modules/amino_acids_functions.py new file mode 100644 index 0000000..876ab09 --- /dev/null +++ b/modules/amino_acids_functions.py @@ -0,0 +1,96 @@ +NAMES = {'A': 'Ala', 'R': 'Arg', 'N': 'Asn', 'D': 'Asp', 'C': 'Cys', 'E': 'Glu', 'Q': 'Gln', 'G': 'Gly', 'H': 'His', + 'I': 'Ile', 'L': 'Leu', 'K': 'Lys', 'M': 'Met', 'F': 'Phe', 'P': 'Pro', 'S': 'Ser', 'T': 'Thr', 'W': 'Trp', + 'Y': 'Tyr', 'V': 'Val', 'U': 'Sec', 'O': 'Pyl', 'a': 'Ala', 'r': 'Arg', 'n': 'Asn', 'd': 'Asp', 'c': 'Cys', + 'e': 'Glu', 'q': 'Gln', 'g': 'Gly', 'h': 'His', 'i': 'Ile', 'l': 'Leu', 'k': 'Lys', 'm': 'Met', 'f': 'Phe', + 'p': 'Pro', 's': 'Ser', 't': 'Thr', 'w': 'Trp', 'y': 'Tyr', 'v': 'Val', 'u': 'Sec', 'o': 'Pyl'} +MASSES = {'A': 71.08, 'R': 156.2, 'N': 114.1, 'D': 115.1, 'C': 103.1, 'E': 129.1, 'Q': 128.1, 'G': 57.05, 'H': 137.1, + 'I': 113.2, 'L': 113.2, 'K': 128.2, 'M': 131.2, 'F': 147.2, 'P': 97.12, 'S': 87.08, 'T': 101.1, 'W': 186.2, + 'Y': 163.2, 'V': 99.13, 'U': 168.05, 'O': 255.3, 'a': 71.08, 'r': 156.2, 'n': 114.1, 'd': 115.1, 'c': 103.1, + 'e': 129.1, 'q': 128.1, 'g': 57.05, 'h': 137.1, 'i': 113.2, 'l': 113.2, 'k': 128.2, 'm': 131.2, 'f': 147.2, + 'p': 97.12, 's': 87.08, 't': 101.1, 'w': 186.2, 'y': 163.2, 'v': 99.13, 'u': 168.05, 'o': 255.3} + + +def molecular_weight(seq: str) -> float: + """ + Function calculates molecular weight of the amino acid chain + Parameters: + seq (str): each letter refers to one-letter coded proteinogenic amino acids + Returns: + (float) Molecular weight of tge given amino acid chain in Da + """ + m = 0 + for acid in seq: + m += MASSES[acid] + return m + + +def three_letter_code(seq: str) -> str: + """ + Function converts single letter translations to three letter translations + Parameters: + seq (str): each letter refers to one-letter coded proteinogenic amino acids + Returns: + (str) translated in three-letter code + """ + recording = seq.maketrans(NAMES) + return seq.translate(recording) + + +def length(seq: str) -> int: + """ + Function counts the number of amino acids in the given sequence + Parameters: + seq (str): amino acid sequence + Returns: + (int): integer number of amino acid residues + """ + return len(seq) + + +def folding(seq: str) -> str: + """ + Counts the number of amino acids characteristic separately for alpha helixes and beta sheets, + and gives out what will be the structure of the protein more. + This function has been tested on proteins such as 2M3X, 6DT4 (PDB ID) and MHC, CRP. + The obtained results corresponded to reality. + Parameters: + seq (str): amino acid sequence + Returns: + (str): overcoming structure ('alfa_helix', 'beta_sheet', 'equally') + """ + alfa_helix = ['A', 'E', 'L', 'M', 'G', 'Y', 'S', 'a', 'e', 'l', 'm', 'g', 'y', 's'] + beta_sheet = ['Y', 'F', 'W', 'T', 'V', 'I', 'y', 'f', 'w', 't', 'v', 'i'] + alfa_helix_counts = 0 + beta_sheet_counts = 0 + for amino_acid in seq: + if amino_acid in alfa_helix: + alfa_helix_counts += 1 + elif amino_acid in beta_sheet: + beta_sheet_counts += 1 + if alfa_helix_counts > beta_sheet_counts: + return 'alfa_helix' + elif alfa_helix_counts < beta_sheet_counts: + return 'beta_sheet' + elif alfa_helix_counts == beta_sheet_counts: + return 'equally' + + +def seq_charge(seq: str) -> str: + """ + Function evaluates the overall charge of the aminoacid chain in neutral aqueous solution (pH = 7) + Parameters: + seq (str): amino acid sequence of proteinogenic amino acids + Returns: + (str): "positive", "negative" or "neutral" + """ + aminoacid_charge = {'R': 1, 'D': -1, 'E': -1, 'K': 1, 'O': 1, 'r': 1, 'd': -1, 'e': -1, 'k': 1, 'o': 1} + charge = 0 + for aminoacid in seq: + if aminoacid in aminoacid_charge.keys(): + charge += aminoacid_charge[aminoacid] + if charge > 0: + return 'positive' + elif charge < 0: + return 'negative' + else: + return 'neutral' diff --git a/modules/fastq_filters.py b/modules/fastq_filters.py new file mode 100644 index 0000000..8e8924a --- /dev/null +++ b/modules/fastq_filters.py @@ -0,0 +1,99 @@ +def gc_content(seq: str) -> float: + """ + Supporting function + Function counts GC-content in sequence, and returns result in % + Parameters: + seq (str): oligo- and polynucleotide sequence + Returns: + (float): % of GC-content + """ + n = 0 + for nucl in seq: + if nucl == 'c' or nucl == 'g' or nucl == 'C' or nucl == 'G': + n += 1 + return 100 * n / len(seq) + + +def filter_gc(seqs: dict, gc_bounds_both_side=(0, 100)) -> dict: + """ + This function selects sequences with the GC content of your interest + :parameters: + seqs: dictionary of FASTQ sequences {name: (sequence, quality)} + gc_bound: interval for the of acceptable GC content, in % + :return:(dict) new dictionary consists of selected sequences + """ + d_new = {} + for key, params in seqs.items(): + if gc_bounds_both_side[1] >= gc_content(params[0]) >= gc_bounds_both_side[0]: + d_new[key] = (params[0], params[1], params[2]) + return d_new + + +def filter_length(seqs: dict, length_bounds_both_side=(0, 2 ** 32)) -> dict: + """ + This function selects sequences with the length of your interest + :parameters: + seqs: dictionary of FASTQ sequences {name: (sequence, quality)} + length_bound: interval for the of acceptable sequense length in number of nucleotide + :return:(dict) new dictionary consists of selected sequences + """ + d_new = {} + for key, params in seqs.items(): + if length_bounds_both_side[1] >= len(params[0]) >= length_bounds_both_side[0]: + d_new[key] = (params[0], params[1], params[2]) + return d_new + + +def filter_quality(seqs: dict, quality_treshold=0) -> dict: + """ + This function selects FASTQ sequences with appropriate average nucleotide read quality + parameters: + seqs: dictionary of FASTQ sequences {name: (sequence, quality)} + quality_treshold: threshold value for average quality per nucleotide (phred33 scale) + :return:(dict) new dictionary consists of selected sequences + """ + d_new = {} + for key, params in seqs.items(): + quality_sum = 0 + for n in params[2]: + quality_sum += ord(n) - 33 + if quality_sum / len(params[2]) >= quality_treshold: + d_new[key] = (params[0], params[1], params[2]) + return d_new + + +def convert_fastq_to_dict(input_path) -> dict: + """ + This function converts fastq file to dictionary with name as a key, and sequence, comment and quality as values + :parameters: + input_path: path for data + :return:(dict) dictionary {name: (sequence, comment, quality}} + """ + with open(input_path) as input_file: + seqs = {} + while True: + key = input_file.readline().strip() + if key == '': + break + seq = input_file.readline().strip() + com = input_file.readline().strip() + qual = input_file.readline().strip() + seqs[key] = (seq, com, qual) + return seqs + + +def write_dict_file_to_fastq(seqs, output_fastq): + """ + This function forms output file from the fastq dictionary {name: (sequence, comment, quality}} + with name as a key, and sequence, comment and quality as values + :parameters: + seqs: dictionary of FASTQ sequences {name: (sequence, quality)} + output_file: filename for output data + :return:(dict) output_file.fastq + """ + with open(output_fastq, 'w') as output_file: + for key, params in seqs.items(): + output_file.write(key + '\n') + output_file.write(params[0] + '\n') + output_file.write(params[1] + '\n') + output_file.write(params[2] + '\n') diff --git a/modules/nucleic_acids_functions.py b/modules/nucleic_acids_functions.py new file mode 100644 index 0000000..26638f4 --- /dev/null +++ b/modules/nucleic_acids_functions.py @@ -0,0 +1,58 @@ +DICT_COMPLEMENT_DNA = {'A': 'T', 'C': 'G', 'T': 'A', 'G': 'C', 'a': 't', 'c': 'g', 't': 'a', 'g': 'c'} +DICT_COMPLEMENT_RNA = {'A': 'U', 'C': 'G', 'U': 'A', 'G': 'C', 'a': 'u', 'c': 'g', 'u': 'a', 'g': 'c'} +DICT_TRANSCRIPTION = {'A': 'A', 'C': 'C', 'T': 'U', 'G': 'G', 'a': 'a', 'c': 'c', 't': 'u', 'g': 'g'} + + +def complement(seq: str) -> str: + """ + Function return complement sequence to sec + Parameters: + seq (str): oligo- and polynucleotide sequence + Returns: + (str): oligo- and polynucleotide sequence + """ + if ('U' in seq) or ('u' in seq): + complementary_rna = seq.maketrans(DICT_COMPLEMENT_RNA) + modified_seq = seq.translate(complementary_rna) + else: + complementary_dna = seq.maketrans(DICT_COMPLEMENT_DNA) + modified_seq = seq.translate(complementary_dna) + return modified_seq + + +def transcribe(seq: str) -> str: + """ + Function return transcript of DNA sequence, if the case of RNA sequence, no changes will be returned + Parameters: + seq (str): oligo- and polynucleotide sequence + Returns: + (str): oligo- and polynucleotide sequence + """ + if ('U' in seq) or ('u' in seq): + modified_seq = seq + else: + transcribe_dna = seq.maketrans(DICT_TRANSCRIPTION) + modified_seq = seq.translate(transcribe_dna) + return modified_seq + + +def reverse(seq: str) -> str: + """ + Function return reversed sequence, (from 5'-3' to 3' -5' there or back) + Parameters: + seq (str): oligo- and polynucleotide sequence + Returns: + (str): oligo- and polynucleotide sequence + """ + return seq[::-1] + + +def reverse_complement(seq: str) -> str: + """ + Function makes complement sequence and reverse it, (from 5'-3' to 3' -5' there or back) + Parameters: + seq (str): oligo- and polynucleotide sequence + Returns: + (str): oligo- and polynucleotide sequence + """ + return complement(seq)[::-1] diff --git a/tool_for_bioinformatics.py b/tool_for_bioinformatics.py new file mode 100644 index 0000000..150d3a7 --- /dev/null +++ b/tool_for_bioinformatics.py @@ -0,0 +1,153 @@ +from typing import Union +import os +import modules.nucleic_acids_functions as na +import modules.fastq_filters as ff +import modules.amino_acids_functions as aa +NUCLEOTIDES = {'U', 'A', 'g', 't', 'G', 'T', 'a', 'c', 'C', 'u'} +AMINO_ACIDS = {'M', 'O', 'v', 'D', 'f', 'N', 'c', 'A', 'R', 'W', 'I', 'm', 'L', 's', 'H', 'q', 'w', 'V', 'n', 'i', + 'g', 'F', 'S', 'e', 'l', 'U', 'P', 'Q', 'K', 'Y', 'u', 'y', 'd', 'h', 'k', 'r', 't', 'G', 'o', 'E', + 'p', 'T', 'C', 'a'} + + +def dna_rna_tools(*args: str) -> str | list: + """ + Performs functions for working with poly- and oligonucleotide sequences. + + Parameters: + The function must accept a number of nucleotide sequences (str) as input, + the last variable must be the function (str) you want to execute. + The nucleotide sequence can consist of both uppercase and lowercase letters. + Input example: + dna_rna_tools('GCGGT','auccuc','GCTatGc','complement') + Function: + complement: makes complement sequence to seq + reverse: reverses sequence, (from 5'-3' to 3' -5' there or back) + reverse_complement: makes complement sequence and reverse it + transcribe: make transcript of DNA sequence. in the case of RNA sequence, no changes will be returned + Returns: + If one sequence is supplied, a string with the result is returned. + If several are submitted, a list of strings is returned. + Depending on the function performed, the following returns will occur: + complement: (str) or (list) complement sequence to seq + reverse: (str) or (list) reversed sequence to seq + reverse_complement: (str) or (list) complement and reversed sequence + transcribe (str) or (list): transcript of DNA sequence. + in the case of RNA sequence, no changes will be returned, + If seq contains both U(u) and T(t) the result for this str will be + "U and T in one seq" regardless of function + If seq contains symbols differ from standardized oligonucleotide notation, the result will be + 'unexpected symbols in sequence' regardless of function + If action is not in the function the message 'unexpected action' will occur + """ + *seqs, action = args + result = list() + for seq in seqs: + if not set(seq).issubset(NUCLEOTIDES): + result.append('unexpected symbols in sequence') + elif (('U' in seq) or ('u' in seq)) and (('T' in seq) or ('t' in seq)): + result.append('T and U in one seq') + else: + if action == 'reverse': + result.append(na.reverse(seq)) + elif action == 'complement': + result.append(na.complement(seq)) + elif action == 'transcribe': + result.append(na.transcribe(seq)) + elif action == 'reverse_complement': + result.append(na.reverse_complement(seq)) + else: + raise ValueError("unexpected action") + if len(result) == 1: + result = result[0] + return result + + +def amino_acid_tools(*args: str) -> list | int | float | str : + """ + Performs functions for working with protein sequences. + + Parameters: + The function must accept an unlimited number of protein sequences (str) as input, + the last variable must be the function (str) you want to execute. + The amino acid sequence can consist of both uppercase and lowercase letters. + Input example: + amino_acid_tools('PLPKVEL','VDviRIkLQ','PPDFGKT','folding') + Function: + molecular_weight: calculates molecular weight of the amino acid chain + three_letter_code: converts single letter translations to three letter translations + length: counts the number of amino acids in the given sequence + folding: counts the number of amino acids characteristic separately for alpha helixes and beta sheets, + and gives out what will be the structure of the protein more + seq_charge: evaluates the overall charge of the aminoacid chain in neutral aqueous solution (pH = 7) + + Returns: + If one sequence is supplied, a string with the result is returned. + If several are submitted, a list of strings is returned. + Depending on the function performed, the following returns will occur: + molecular_weight (int) or (list): amino acid sequence molecular weight number or list of numbers + three_letter_code (str) or (list): translated sequence from one-letter in three-letter code + length (int) or (list): integer number of amino acid residues + folding (str) or (list): 'alpha_helix', if there are more alpha helices + 'beta_sheet', if there are more beta sheets + 'equally', if the probability of alpha spirals and beta sheets are the same + seq_charge(str) or (list): "positive", "negative" or "neutral" + If seq contains symbols differ from IUPAC 1letter code for 22 proteinogenic amino acids, + the result for this sequence will be 'unexpected symbols in sequence' regardless of function + If action is not in the function the message 'unexpected action' will occur + """ + *seqs, function = args + d_of_functions = {'molecular_weight': aa.molecular_weight, + 'three_letter_code': aa.three_letter_code, + 'length': aa.length, + 'folding': aa.folding, + 'seq_charge': aa.seq_charge} + answer = [] + if function not in d_of_functions.keys(): + raise ValueError("unexpected action") + for sequence in seqs: + if not set(sequence).issubset(AMINO_ACIDS): + answer.append('unexpected symbols in sequence') + else: + answer.append(d_of_functions[function](sequence)) + if len(answer) == 1: + return answer[0] + else: + return answer + + +def fastq_filtration(input_fastq, gc_bounds=(0, 100), length_bounds=(0, 2 ** 32), quality_treshold=0, output_fastq=''): + """ + This function provides you the opportunity to filter the FASTQ file to select sequences + that fit requirements on 5 parameters: input and output(optional) files, length, GC composition, + and quality of the reed + :parameters + input_fastq: path to fastq file + gc_bounds: (tuple) interval for the of acceptable GC content, in % + length_bounds: (tuple) interval for the of acceptable sequense length in number of nucleotide + quality_treshold: (float) threshold value for average quality per nucleotide (phred33 scale) + output_fastq = name of output file, ./fastq_filtrator_resuls/output_fastq, if it is not defined, + it will be the same of the input file + + """ + if not os.path.isdir('fastq_filtrator_resuls'): + os.mkdir('fastq_filtrator_resuls') + if output_fastq == '': + output_fastq = os.path.join('fastq_filtrator_resuls', os.path.basename(input_fastq)) + else: + output_fastq = os.path.join('fastq_filtrator_resuls', output_fastq + ".fasta") + seqs = ff.convert_fastq_to_dict(input_fastq) + if type(gc_bounds) == float or type(gc_bounds) == int: + gc_bounds_both_side = (0, gc_bounds) + else: + gc_bounds_both_side = gc_bounds + if type(length_bounds) == int: + length_bounds_both_side = (0, length_bounds) + else: + length_bounds_both_side = length_bounds + good_seqs = ff.filter_length(ff.filter_quality(ff.filter_gc(seqs, gc_bounds_both_side), quality_treshold), + length_bounds_both_side) + + ff.write_dict_file_to_fastq(good_seqs, output_fastq) + return good_seqs + +fastq_filtration('example_fastq.fastq', gc_bounds=(20, 80), length_bounds=140, quality_treshold=38, output_fastq='')