logging module

nested/config/config.py

@@ -26,4 +26,6 @@ blastx_args = {
     'word_size': 2,
     'evalue': 1
 }
+
+logdir = '/tmp/nested/logs'
 #ADD BLAST PARAMETERS

nested/core/nester.py

 #!/usr/bin/env python3
 
+import os
+import re
+
 from nested.utils import intervals
 from nested.core.gene import Gene
 from nested.core.nested_element import NestedElement
+from nested.logging.logger import NesterLogger
+from nested.config import config
 
 class Nester(object):
     """Class represent nesting in sequence, recursivelly find best evaluated transposon and crop it until no new transposons found
@@ -16,7 +21,9 @@ class Nester(object):
         self.seqid = sequence.id
         self.sequence = sequence.seq
         self.nested_element = None
-        self._find_nesting()
+        self._iteration = 0
+        self._logger = NesterLogger('{}/{}'.format(config.logdir, self.seqid))
+        self._find_nesting()                    
 
     def _find_nesting(self):
         nested_list = self._get_unexpanded_transposon_list(self.sequence) #find list of nested transposons
@@ -24,8 +31,9 @@ class Nester(object):
         self.nested_element = NestedElement(self.seqid, self.sequence, nested_list)
 
     def _get_unexpanded_transposon_list(self, sequence): #recursivelly find and crop best evaluated transposon, return unexpanded list of found transposons
+        self._iteration += 1
         gene = Gene(self.seqid, sequence)
-        candidates = gene.get_candidates_above_threshold()
+        candidates = gene.get_candidates_above_threshold(threshold=0)
         if not candidates:
             best_candidate = gene.get_best_candidate()
             if not best_candidate:
@@ -42,6 +50,12 @@ class Nester(object):
                 if intervals.intersect(candidate.location, element.location):
                     choose = False
                     break
+            for other_candidate in candidates:
+                if candidate.location == other_candidate.location:
+                    continue
+                if intervals.contains(candidate.location, other_candidate.location):
+                    choose = False
+                    break
             if choose:
                 nested_list.append(candidate)
         #sort by location (reverse)
@@ -51,13 +65,12 @@ class Nester(object):
 
         for element in nested_list:
             cropped_sequence = cropped_sequence[:(element.location[0] - 1)] + cropped_sequence[(element.location[1] + 1):]
-        nested_list += self._get_unexpanded_transposon_list(cropped_sequence)
-
 
+        #LOG
+        self._logger.log_iteration(self._iteration, nested_list)
+        
+        nested_list += self._get_unexpanded_transposon_list(cropped_sequence)       
 
-        #crop TE and call recursivelly
-        #cropped_sequence = sequence[:(best_candidate.location[0] - 1)] + sequence[(best_candidate.location[1] + 1):]
-        #nested_list += self._get_unexpanded_transposon_list(cropped_sequence)
         return nested_list
 
     def _expand_transposon_list(self, nested_list): #backwards expanding of intervals according to previously found and cropped elements

nested/logging/logger.py

+#!/usr/bin/env python3
+
+import os
+from datetime import datetime
+
+class Logger(object):
+    def __init__(self, destination):
+        self._destination = destination
+        self._make_dirs()
+
+    def _make_dirs(self):
+        dirs = self._destination.split('/')
+        for i in range(len(dirs)):
+            if not dirs[i]:
+                continue
+            subpath = '/'.join(dirs[:(i+1)])
+            if not os.path.exists(subpath):
+        	    os.makedirs(subpath)
+
+    def create_log(self, filepath):
+        open('{}/{}'.format(self._destination, filepath), 'w+').close()
+
+    def log_entry(self, filepath, entry):
+        with open('{}/{}'.format(self._destination, filepath), 'a') as logfile:
+            logfile.write('[{}]\n'.format(datetime.now()))
+            logfile.write('{}\n'.format(entry))
+
+class NesterLogger(Logger):
+    def __init__(self, destination):
+        super().__init__(destination)
+
+    def log_iteration(self, iteration, nested_list):        
+        main_logfile_path = 'iterations.log'
+        iteration_logfile_path = 'iter_{:02d}.log'.format(iteration)
+        if iteration == 1:
+            super().create_log(main_logfile_path)
+        main_entry = 'ITERATION {}\n'.format(iteration)
+        main_entry += '- Cropping {} elements\n'.format(len(nested_list))
+        super().log_entry(main_logfile_path, main_entry)
+
+        super().create_log(iteration_logfile_path)
+        iteration_entry = ''
+        for i in range(len(nested_list)):
+            iteration_entry += ('ELEMENT {}\n\n'.format(i+1))
+            iteration_entry += ('{}\n\n'.format(nested_list[i]))
+            iteration_entry += ('- domains:\n')
+            for domain in nested_list[i].features['domains']:
+                iteration_entry += ('{}\n'.format(domain)) 
+            iteration_entry += '\n\n'
+            super().log_entry(iteration_logfile_path, iteration_entry)