Upload DNAseq.py

DNAseq.py

@@ -1,119 +1,51 @@
-class DNAseq:
-    def __init__(self, sequence):
-        self.sequence = sequence.lower()
+from sequence import Sequence
 
-    def get_total_bases(self):
-        return len(self.sequence)
-        # Total length of sequence
-
-    def get_base_count(self, base):
-        base = base.lower()
-        return self.sequence.count(base)
-        # Total number of specified base. Can be A, T, G or C
 
+class DNAseq(Sequence):
     def get_base_counts(self):
         base_counts = {
-            'a': self.get_base_count('a'),
-            't': self.get_base_count('t'),
-            'g': self.get_base_count('g'),
-            'c': self.get_base_count('c'),
+            'a': self.get_unit_count('a'),
+            't': self.get_unit_count('t'),
+            'g': self.get_unit_count('g'),
+            'c': self.get_unit_count('c'),
         }
         return base_counts
         # Total number of each base within the sequence returned as a dictionary
 
-    def get_base_percentage(self, base):
-        total_bases = self.get_total_bases()
-        base_count = self.get_base_count(base)
-        base_percentage = (base_count / total_bases) * 100
-        return base_percentage
-        # Base content by percentage.Can be A, T, G or C
-
     def get_base_percentages(self):
         base_percentages = {
-            'a': self.get_base_percentage('a'),
-            't': self.get_base_percentage('t'),
-            'g': self.get_base_percentage('g'),
-            'c': self.get_base_percentage('c')
+            'a': self.get_unit_percentage('a'),
+            't': self.get_unit_percentage('t'),
+            'g': self.get_unit_percentage('g'),
+            'c': self.get_unit_percentage('c'),
         }
         return base_percentages
         # Base content percentage for each base returned as a dictionary
 
     def get_gc_content(self):
-        total_bases = self.get_total_bases()
+        total_bases = self.get_seq_length()
         gc_count = self.sequence.count('g') + self.sequence.count('c')
         gc_content = (gc_count / total_bases) * 100
         return gc_content
         # Guanine Cytosine (gc) content by percentage
 
     def get_at_content(self):
-        total_bases = self.get_total_bases()
+        total_bases = self.get_seq_length()
         at_count = self.sequence.count('a') + self.sequence.count('t')
         at_content = (at_count / total_bases) * 100
         return at_content
         # Adenine Thymine (at) content by percentage
 
     def get_purine_content(self):
-        total_bases = self.get_total_bases()
+        total_bases = self.get_seq_length()
         ag_count = self.sequence.count('a') + self.sequence.count('g')
         ag_content = (ag_count / total_bases) * 100
         return ag_content
         # Adenine Guanine (purine) content by percentage
 
     def get_pyrimidine_content(self):
-        total_bases = self.get_total_bases()
+        total_bases = self.get_seq_length()
         ct_count = self.sequence.count('c') + self.sequence.count('t')
         ct_content = (ct_count / total_bases) * 100
         return ct_content
         # Cytosine Thymine (pyrimidine) content by percentage
-
-    def get_base_at_position(self, position):
-        pos = position - 1
-
-        if 0 <= pos < len(self.sequence):
-            base_at_pos = self.sequence[pos]
-            return base_at_pos
-        else:
-            return "Position is out of range. Positions should be 1 - {}".format(len(self.sequence))
-        # Returns the base at a specified position in the sequence
-
-    def get_base_at_positions(self, position_list):
-        if self.check_positions(position_list):
-            pos_dict = {i: self.sequence[i - 1] for i in position_list if 0 <= i < len(self.sequence)}
-            return pos_dict
-        else:
-            return "Position is out of range.Positions should be 1 - {}".format(len(self.sequence))
-        # Returns base for each position in list
-
-    def check_positions(self, position_list):
-        # Check if the positions are within the range of the sequence length
-        # Value = 0 -> position out of sequence range
-        # Value = 1 -> position within sequence range
-
-        checked = {}
-        for pos in position_list:
-            if pos <= 0 or pos > len(self.sequence):
-                checked[pos] = 0
-            else:
-                checked[pos] = 1
-
-        # Check if all values are equal to 1 / All positions in the list are within the range of the sequence length
-        all_values_equal_to_1 = all(value == 1 for value in checked.values())
-
-        if all_values_equal_to_1:
-            valid = True
-        else:
-            valid = False
-
-        return valid
-
-    def get_subsequence(self, start_position, end_position):
-        # Ensure the start and end positions are within the bounds of the sequence
-        if start_position > 0 and end_position <= len(self.sequence):
-            return self.sequence[start_position - 1:end_position]
-        else:
-            return "Position is out of range. Positions should be 1 - {}".format(len(self.sequence))
-        # Returns the subsequence based on given positions
-
-    def subsequence_total_bases(self, start_position, end_position):
-        return len(self.get_subsequence(start_position, end_position))
-