basic backup added

Small refactorisation - communication between backup/store and
file manager is now in separate class.

Next step: add the backup time to config so that users cna decide
for how long do they want to keep the data.

Author: UrszulaNeuman

dls_barcode/data_store/backup.py

@@ -1,38 +1,21 @@
 import time
 
-from dls_barcode.data_store.record import Record
-from dls_util.file import FileManager
+from dls_barcode.data_store.comms_manager import CommsManager
 
 
 class Backup:
 
-    def __init__(self, backup_file):
-        self._backup_file = backup_file
-        self._file_manager = FileManager()
-        self._load_records_from_file()
+    """
+    Backup class maintains the short time backaup of records which is kept in the same folder as the store files.
+    """
 
-    def _load_records_from_file(self):
-        """ Clear the current record store and load a new set of records from the specified file. """
-        self.records = []
+    MAX_BACKUP_TIME = 6   # maximum backup time in weeks
 
-        if not self._file_manager.is_file(self._backup_file):
-            return
-
-        lines = self._file_manager.read_lines(self._backup_file)
-        for line in lines:
-            try:
-                record = Record.from_string(line)
-                self.records.append(record)
-            except Exception:
-                print("Failed to parse store Record: {}".format(line))
-
-        #self._truncate_record_list()
-
-    def _to_backup_file(self):
-        """ Save the contents of the store to the backing file
-        """
-        record_lines = [rec.to_string() + "\n" for rec in self.records]
-        self._file_manager.write_lines(self._backup_file, record_lines)
+    def __init__(self, directory, backup_time):
+        self.comms = CommsManager(directory, "backup")
+        self.backup_time = backup_time
+        self.records = self.comms.load_records_from_file()
+        self._truncate_record_list()
 
     def _truncate_record_list(self):
         for record in self.records:
@@ -42,12 +25,13 @@ def _truncate_record_list(self):
     def backup_records(self, to_back):
         self.records.extend(to_back)
         self._truncate_record_list()
-        self._to_backup_file()
+        self.comms.to_csv_file(self.records)
 
-    def _is_old(self,record):
+    def _is_old(self, record):
         tm = time.time()
         record_time = record.timestamp
         delta = tm - record_time
-        weeks = 3 * 604800 #3 weeks in seconds
+        backup_time = min(self.backup_time, self.MAX_BACKUP_TIME)
+        weeks = backup_time * 604800  # weeks in seconds
         return delta > weeks
 

dls_barcode/data_store/comms_manager.py

@@ -0,0 +1,54 @@
+import os
+
+from dls_barcode.data_store.record import Record
+from dls_util.file import FileManager
+
+
+class CommsManager:
+    """ Maintains communication between store/backup and the file manager.
+    """
+
+    def __init__(self, directory, file_name):
+        self._file_manager = FileManager()
+        self._directory = directory
+        self._file_name = file_name
+
+    def load_records_from_file(self):
+        """ Clear the current record store and load a new set of records from the specified file. """
+        file = os.path.join(self._directory, self._file_name + '.txt')
+        records = []
+
+        if not self._file_manager.is_file(file):
+            return records
+
+        lines = self._file_manager.read_lines(file)
+        for line in lines:
+            try:
+                record = Record.from_string(line)
+                records.append(record)
+            except Exception:
+                print("Failed to parse store Record: {}".format(line))
+
+        return records
+
+    def to_file(self, records):
+        """ Save the contents of the store to the backing file
+        """
+        file = os.path.join(self._directory, self._file_name + '.txt')
+        record_lines = [rec.to_string() + "\n" for rec in records]
+        self._file_manager.write_lines(file, record_lines)
+
+    def to_csv_file(self, records):
+        """ Save the contents of the store to the backing csv file
+        """
+        csv_file = os.path.join(self._directory, self._file_name + ".csv")
+        record_lines = [rec.to_csv_string() + "\n" for rec in records]
+        self._file_manager.write_lines(csv_file, record_lines)
+
+    def make_img_dir(self, img_dir):
+        if not self._file_manager.is_dir(img_dir):
+            self._file_manager.make_dir(img_dir)
+
+    def remove_img_file(self, record):
+        if self._file_manager.is_file(record.image_path):
+            self._file_manager.remove(record.image_path)

dls_barcode/data_store/store.py

@@ -2,48 +2,29 @@
 import os
 
 from dls_barcode.data_store.backup import Backup
-from dls_util.file import FileManager
+from dls_barcode.data_store.comms_manager import CommsManager
 from .record import Record
 
 
 class Store:
+
     """ Maintains a list of records of previous barcodes scans. Any changes (additions
     or deletions) are automatically written to the backing file.
     """
-    def __init__(self, directory, store_capacity):
+    MIN_STORE_CAPACITY = 2
+
+    def __init__(self, directory, store_capacity, backup_time):
         """ Initializes a new instance of Store.
         """
         self._store_capacity = store_capacity
-        self._directory = directory
-        self._file_manager = FileManager()
-        self._file = os.path.join(directory, "store.txt")
-        self._csv_file = os.path.join(directory, "store.csv")
-        self._backup = Backup(os.path.join(directory, "backup.txt"))
+        self._backup = Backup(directory, backup_time)
+        self._comms_manager = CommsManager(directory, "store")
         self._img_dir = os.path.join(directory, "img_dir")
+        self._comms_manager.make_img_dir(self._img_dir)
 
-        if not self._file_manager.is_dir(self._img_dir):
-            self._file_manager.make_dir(self._img_dir)
-
-        self.records = []
-        self._load_records_from_file()
-        self._sort_records()
-
-    def _load_records_from_file(self):
-        """ Clear the current record store and load a new set of records from the specified file. """
-        self.records = []
-
-        if not self._file_manager.is_file(self._file):
-            return
-
-        lines = self._file_manager.read_lines(self._file)
-        for line in lines:
-            try:
-                record = Record.from_string(line)
-                self.records.append(record)
-            except Exception:
-                print("Failed to parse store Record: {}".format(line))
-
+        self.records = self._comms_manager.load_records_from_file()
         self._truncate_record_list()
+        self._sort_records()
 
     def size(self):
         """ Returns the number of records in the store
@@ -82,17 +63,16 @@ def delete_records(self, records_to_delete):
         """
         for record in records_to_delete:
             self.records.remove(record)
-            if self._file_manager.is_file(record.image_path):
-                self._file_manager.remove(record.image_path)
+            self._comms_manager.remove_img_file(record)
 
         self._process_change()
 
     def backup_records(self, records_to_backup):
         self._backup.backup_records(records_to_backup)
 
     def _truncate_record_list(self):
-        min_store_capacity = 2
-        actual_store_capacity = max(self._store_capacity.value(), min_store_capacity)
+
+        actual_store_capacity = max(self._store_capacity.value(), self.MIN_STORE_CAPACITY)
 
         if len(self.records) > actual_store_capacity:
             to_delete = self.records[actual_store_capacity:]
@@ -104,27 +84,14 @@ def _process_change(self):
         """
         self._sort_records()
         self._truncate_record_list()
-        self._to_file()
-        self._to_csv_file()
+        self._comms_manager.to_file(self.records)
+        self._comms_manager.to_csv_file(self.records)
 
     def _sort_records(self):
         """ Sort the records in descending date order (most recent first).
         """
         self.records.sort(reverse=True, key=lambda record: record.timestamp)
 
-    def _to_file(self):
-        """ Save the contents of the store to the backing file
-        """
-        record_lines = [rec.to_string() + "\n" for rec in self.records]
-        self._file_manager.write_lines(self._file, record_lines)
-
-    def _to_csv_file(self):
-        """ Save the contents of the store to the backing csv file
-        """
-        record_lines = [rec.to_csv_string() + "\n" for rec in self.records]
-        self._file_manager.write_lines(self._csv_file, record_lines)
-
-
     def _merge_holder_image_into_pins_image(self, holder_img, pins_img):
         factor = 0.22 * pins_img.width / holder_img.width
         small_holder_img = holder_img.rescale(factor)

dls_barcode/gui/record_table.py

@@ -22,7 +22,7 @@ def __init__(self, barcode_table, image_frame, options):
         super(ScanRecordTable, self).__init__()
 
         # Read the store from file
-        self._store = Store(options.store_directory.value(), options.store_capacity)
+        self._store = Store(options.store_directory.value(), options.store_capacity, 3)#options.backup_time
         self._options = options
 
         self._barcodeTable = barcode_table