Merge pull request #74 from DiamondLightSource/backup

Backup

Author: UrszulaNeuman

build.bat

@@ -6,11 +6,9 @@ cd dls_barcode
 REM use to debug the exe file
 REM pyinstaller --onefile --icon=..\resources\icons\qr_code.ico --debug --clean main.py
 
-pyinstaller --onefile --windowed --icon=..\resources\icons\qr_code.ico --clean main.py
+pyinstaller --onefile --windowed --icon="C:\Users\rqq82173\PycharmProjects\PuckBarcodeReader\resources\icons\qr_code.ico" --clean "C:\Users\rqq82173\PycharmProjects\PuckBarcodeReader\dls_barcode\main.py"
 
 move dist\main.exe ..\bin\barcode.exe
 rd /S /Q build
 rd /S /Q dist
 del main.spec
-
-@echo start barcode.exe --config_file .\config.ini>"..\bin\launch_barcode.bat"

dls_barcode/config/barcode_config.py

@@ -44,6 +44,7 @@ def __init__(self, file, file_manager):
 
         self.store_directory = add(DirectoryConfigItem, "Store Directory", default=default_store)
         self.store_capacity = add(IntConfigItem, "Results History Size", default=50)
+        self.backup_time = add(IntConfigItem, "Backup in Weeks", default=3)
 
         self.console_frame = add(BoolConfigItem, "Print Frame Summary", default=False)
         self.slot_images = add(BoolConfigItem, "Save Debug Images", default=False)

dls_barcode/config/barcode_config_dialog.py

@@ -55,6 +55,7 @@ def _init_ui(self):
 
         self.start_group("Store")
         self._add_control(StoreDirectoryConfigControl(cfg.store_directory))
+        add(cfg.backup_time)
         add(cfg.store_capacity)
 
         self.start_group("Debug")

dls_barcode/data_store/backup.py

@@ -0,0 +1,33 @@
+import time
+
+from dls_barcode.data_store.comms_manager import CommsManager
+
+
+class Backup:
+
+    """
+    Backup class maintains the short time backaup of records which is kept in the same folder as the store files.
+    """
+
+    WEEK_IN_SECONDS = 604800
+
+    def __init__(self, comms_man, backup_time):
+        self._comms = comms_man
+        self._backup_time = backup_time.value()
+        self._records = self._comms.load_records_from_file()
+
+    def _truncate_record_list(self):
+        self._records = list(filter(lambda x: not self._is_old(x), self._records))
+
+    def backup_records(self, to_back):
+        self._records.extend(to_back)
+        self._truncate_record_list()
+        self._comms.to_csv_file(self._records)
+
+    def _is_old(self, record):
+        tm = time.time()
+        record_time = record.timestamp
+        delta = tm - record_time
+        weeks = self._backup_time * self.WEEK_IN_SECONDS  # weeks in seconds
+        return delta > weeks
+

dls_barcode/data_store/comms_manager.py

@@ -0,0 +1,56 @@
+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.value()
+        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 = os.path.join(self._directory, "img_dir")
+        if not self._file_manager.is_dir(img_dir):
+            self._file_manager.make_dir(img_dir)
+        return 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/record.py

@@ -162,3 +162,4 @@ def _formatted_date(self):
         """
         return datetime.datetime.fromtimestamp(self.timestamp).strftime(Record.DATE_FORMAT)
 
+

dls_barcode/data_store/store.py

@@ -5,42 +5,22 @@
 
 
 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, file_manager):
+    MIN_STORE_CAPACITY = 2
+
+    def __init__(self, comms_manager, backup, store_capacity):
         """ Initializes a new instance of Store.
         """
         self._store_capacity = store_capacity
-        self._directory = directory
-        self._file_manager = file_manager
-        self._file = os.path.join(directory, "store.txt")
-        self._csv_file = os.path.join(directory, "store.csv")
-        self._img_dir = os.path.join(directory, "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._backup = backup
+        self._comms_manager = comms_manager
+        self._img_dir = self._comms_manager.make_img_dir()
+        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
@@ -79,44 +59,35 @@ 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:]
+            self.backup_records(to_delete)
             self.delete_records(to_delete)
 
     def _process_change(self):
         """ Sort the records and save to file.
         """
         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/data_store/store_manager.py

@@ -0,0 +1,31 @@
+from dls_barcode.data_store import Store
+from dls_barcode.data_store.backup import Backup
+from dls_barcode.data_store.comms_manager import CommsManager
+
+
+class StoreManager:
+
+    def __init__(self, directory, store_capacity, backup_time):
+        self._store_capacity = store_capacity
+        self._directory = directory
+        self._backup_time = backup_time
+
+    def create_store(self):
+        comms_manager = self._create_store_comms_manager()
+        backup_comms_manager = self._create_backup_comms_manager()
+        backup = self._create_backup(backup_comms_manager)
+        return Store(comms_manager, backup, self._store_capacity)
+
+    def _create_store_comms_manager(self):
+        return CommsManager(self._directory, "store")
+
+    def _create_backup(self, backup_comms_manager):
+        return Backup(backup_comms_manager, self._backup_time)
+
+    def _create_backup_comms_manager(self):
+        return CommsManager(self._directory, "backup")
+
+
+
+
+

dls_barcode/gui/record_table.py

@@ -5,6 +5,7 @@
 from PyQt5.QtWidgets import QGroupBox, QVBoxLayout, QHBoxLayout, QTableWidget, QMessageBox
 
 from dls_barcode.data_store import Store
+from dls_barcode.data_store.store_manager import StoreManager
 from dls_util.file import FileManager
 
 # todo: allow delete key to be used for deletion
@@ -22,7 +23,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, FileManager())
+        self._store = StoreManager(options.store_directory, options.store_capacity, options.backup_time).create_store()
         self._options = options
 
         self._barcodeTable = barcode_table
@@ -115,7 +116,7 @@ def _record_selected(self):
             self._imageFrame.display_puck_image(marked_image)
         except IndexError:
             self._barcodeTable.clear()
-            self._imageFrame.clear_frame("Record table empty\nNothing to display")
+#            self._imageFrame.clear_frame("Record table empty\nNothing to display")
 
     def _delete_selected_records(self):
         """ Called when the 'Delete' button is pressed. Deletes all of the selected records
@@ -135,7 +136,9 @@ def _delete_selected_records(self):
                 record = self._store.get_record(index)
                 records_to_delete.append(record)
 
+            self._store.backup_records(records_to_delete)
             self._store.delete_records(records_to_delete)
+
             self._load_store_records()
 
     def is_latest_holder_barcode(self, holder_barcode):

dls_util/file/file_manager.py

@@ -14,6 +14,11 @@ def write_lines(self, file_path, lines):
         with open(file_path, 'w') as file:
             file.writelines(lines)
 
+    def append_lines(self, file_path, lines):
+        """Calls file.writelines, so doesn't append any new line characters"""
+        with open(file_path, 'a') as file:
+            file.writelines(lines)
+
     def is_file(self, path):
         return os.path.isfile(path)