Merge pull request #51 from DiamondLightSource/I04_1-165_holder_barcode_in_records_table

I04 1 165 holder barcode in records table

Author: IsabellaRey

dls_barcode/data_store/record.py

@@ -29,9 +29,10 @@ class Record:
 
     BAD_SYMBOLS = [EMPTY_SLOT_SYMBOL, NOT_FOUND_SLOT_SYMBOL]
 
-    def __init__(self, plate_type, barcodes, image_path, geometry, timestamp=0.0, id=0):
+    def __init__(self, plate_type, holder_barcode, barcodes, image_path, geometry, timestamp=0.0, id=0):
         """
         :param plate_type: the type of the sample holder plate (string)
+        :param holder_barcode: the barcode of the holder plate
         :param barcodes: ordered array of strings giving the barcodes in each slot
             of the plate in order. Empty slots should be denoted by empty strings.
         :param image_path: the absolute path of the image.
@@ -43,8 +44,10 @@ def __init__(self, plate_type, barcodes, image_path, geometry, timestamp=0.0, id
             self.timestamp = float(timestamp)
         except ValueError:
             self.timestamp = 0.0
+
         self.image_path = image_path
         self.plate_type = plate_type
+        self.holder_barcode = holder_barcode
         self.barcodes = barcodes
         self.geometry = geometry
         self.id = str(id)
@@ -57,27 +60,25 @@ def __init__(self, plate_type, barcodes, image_path, geometry, timestamp=0.0, id
         # Generate timestamp and uid if none are supplied
         if timestamp == 0:
             self.timestamp = time.time()
+
         if id == 0:
             self.id = str(uuid.uuid4())
 
-        # Separate Data and Time
+        # Separate Date and Time
         dt = self._formatted_date().split(" ")
         self.date = dt[0]
         self.time = dt[1]
 
         # Counts of numbers slots and barcodes
-        self.num_slots = len(barcodes)
-        self.num_empty_slots = len([b for b in barcodes if b == EMPTY_SLOT_SYMBOL])
-        self.num_unread_slots = len([b for b in barcodes if b == NOT_FOUND_SLOT_SYMBOL])
+        self.num_slots = len(self.barcodes)
+        self.num_empty_slots = len([b for b in self.barcodes if b == EMPTY_SLOT_SYMBOL])
+        self.num_unread_slots = len([b for b in self.barcodes if b == NOT_FOUND_SLOT_SYMBOL])
         self.num_valid_barcodes = self.num_slots - self.num_unread_slots - self.num_empty_slots
 
     @staticmethod
-    def from_plate(plate, second_plate, image_path):
-        plate_type = second_plate.type
-        geometry = second_plate.geometry()
-        barcodes = plate.barcodes() + second_plate.barcodes()
-
-        return Record(plate_type=plate_type, barcodes=barcodes, image_path=image_path, geometry=geometry)
+    def from_plate(holder_barcode, plate, image_path):
+        return Record(plate_type=plate.type, holder_barcode=holder_barcode, barcodes=plate.barcodes(),
+                      image_path=image_path, geometry=plate.geometry())
 
     @staticmethod
     def from_string(string):
@@ -89,21 +90,24 @@ def from_string(string):
         timestamp = items[Record.IND_TIMESTAMP] #used to convert into float twice
         image = items[Record.IND_IMAGE]
         plate_type = items[Record.IND_PLATE]
-        barcodes = items[Record.IND_BARCODES].split(Record.BC_SEPARATOR)
+        all_barcodes = items[Record.IND_BARCODES].split(Record.BC_SEPARATOR)
+        holder_barcode = all_barcodes[0]
+        pin_barcodes = all_barcodes[1:]
 
         geo_class = Geometry.get_class(plate_type)
         geometry = geo_class.deserialize(items[Record.IND_GEOMETRY])
 
-        return Record(plate_type=plate_type, barcodes=barcodes, timestamp=timestamp,
+        return Record(plate_type=plate_type, holder_barcode=holder_barcode, barcodes=pin_barcodes, timestamp=timestamp,
                       image_path=image, id=id, geometry=geometry)
 
     def to_csv_string(self):
         """ Converts a scan record object into a string that can be stored in a csv file.
         """
-        items = [0] * 3
-        items[0] = str(self.id)
-        items[1] = str(self._formatted_date())
-        items[2] = Record.BC_SEPARATOR.join(self.barcodes)
+        items = list()
+        items.append(str(self.id))
+        items.append(str(self._formatted_date()))
+        items.append(self.holder_barcode)
+        items.append(Record.BC_SEPARATOR.join(self.barcodes))
         return Record.BC_SEPARATOR.join(items)
 
     def to_string(self):
@@ -115,32 +119,20 @@ def to_string(self):
         items[Record.IND_TIMESTAMP] = str(self.timestamp)
         items[Record.IND_IMAGE] = self.image_path
         items[Record.IND_PLATE] = self.plate_type
-        items[Record.IND_BARCODES] = Record.BC_SEPARATOR.join(self.barcodes)
+        items[Record.IND_BARCODES] = Record.BC_SEPARATOR.join(self._all_barcodes())
         items[Record.IND_GEOMETRY] = self.geometry.serialize()
         return Record.ITEM_SEPARATOR.join(items)
 
-    def any_barcode_matches(self, barcodes):
-        """ Returns true if the record contains any barcode which is also
-        contained in the specified list
-        """
-        barcodes = [bc for bc in barcodes if bc not in Record.BAD_SYMBOLS]
-        for bc in barcodes:
-            if bc in self.barcodes:
-                return True
-
-        return False
+    def _all_barcodes(self):
+        return [self.holder_barcode] + self.barcodes
 
-    #TODO: modify when two images merged
-    # only the image of the top for the time being
-    def image(self):
+    def _image(self):
         image = Image.from_file(self.image_path)
         return image
 
-    #TODO: modify when two images merged
-    # only the image of the top for the time being
     def marked_image(self, options):
         geo = self.geometry
-        image = self.image()
+        image = self._image()
 
         if options.image_puck.value():
             geo.draw_plate(image, Color.Blue())
@@ -155,9 +147,7 @@ def marked_image(self, options):
 
     # marking the top image
     def _draw_pins(self, image, geometry, options):
-        top_barcodes = list(self.barcodes) #copy of the list
-        top_barcodes.pop(0)# remove the first element (side barcode)
-        for i, bc in enumerate(top_barcodes):
+        for i, bc in enumerate(self.barcodes):
             if bc == NOT_FOUND_SLOT_SYMBOL:
                 color = options.col_bad()
             elif bc == EMPTY_SLOT_SYMBOL:

dls_barcode/data_store/store.py

@@ -8,10 +8,10 @@ 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, options, file_manager):
+    def __init__(self, directory, store_capacity, file_manager):
         """ Initializes a new instance of Store.
         """
-        self._options = options
+        self._store_capacity = store_capacity
         self._directory = directory
         self._file_manager = file_manager
         self._file = os.path.join(directory, "store.txt")
@@ -52,57 +52,56 @@ def get_record(self, index):
         """
         return self.records[index] if self.records else None
 
-    def add_record(self, plate, second_plate, holder_img, pins_img):
+    def _add_record(self, holder_barcode, plate, holder_img, pins_img):
         """ Add a new record to the store and save to the backing file.
         """
         merged_img = self._merge_holder_image_into_pins_image(holder_img, pins_img)
         guid = str(uuid.uuid4())
         filename = os.path.abspath(os.path.join(self._img_dir, guid + '.png'))
         merged_img.save_as(filename)
 
-        record = Record.from_plate(plate, second_plate, filename)
+        record = Record.from_plate(holder_barcode, plate, filename)
 
         self.records.append(record)
         self._process_change()
-        self._truncate_record_list()
 
-    def merge_record(self, plate, second_plate, holder_img, pins_img):
-        """ Create new record or replace existing record if it has the same barcodes as the most
+    def merge_record(self, holder_barcode, plate, holder_img, pins_img):
+        """ Create new record or replace existing record if it has the same holder barcode as the most
         recent record. Save to backing store. """
-        #Checking only holder barcodes is sufficient
-        if len(self.records) > 0 and self.records[0].any_barcode_matches(plate.barcodes()):
+        if self.records and self.records[0].holder_barcode == holder_barcode:
             self.delete_records([self.records[0]])
 
-        self.add_record(plate, second_plate, holder_img, pins_img)
+        self._add_record(holder_barcode, plate, holder_img, pins_img)
 
-    def delete_records(self, records):
+    def delete_records(self, records_to_delete):
         """ Remove all of the records in the supplied list from the store and
         save changes to the backing file.
         """
-        for record in records:
+        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._process_change()
 
     def _truncate_record_list(self):
-        number = self._options.store_capacity.value()
-        number = max(number, 2)
+        min_store_capacity = 2
+        actual_store_capacity = max(self._store_capacity.value(), min_store_capacity)
 
-        if len(self.records) > number:
-            to_delete = self.records[number:]
+        if len(self.records) > actual_store_capacity:
+            to_delete = self.records[actual_store_capacity:]
             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()
 
     def _sort_records(self):
-        """ Sort the records in descending date order (must recent first).
+        """ Sort the records in descending date order (most recent first).
         """
         self.records.sort(reverse=True, key=lambda record: record.timestamp)
 
@@ -126,5 +125,6 @@ def _merge_holder_image_into_pins_image(self, holder_img, pins_img):
         merged_img.paste(small_holder_img, 0, 0)
         return merged_img
 
-
-
+    def is_latest_holder_barcode(self, holder_barcode):
+        latest_record = self.get_record(0)
+        return latest_record is not None and holder_barcode == latest_record.holder_barcode

dls_barcode/gui/barcode_table.py

@@ -4,7 +4,7 @@
 
 from PyQt4 import QtGui
 from PyQt4.QtCore import Qt
-from PyQt4.QtGui import QGroupBox, QVBoxLayout, QHBoxLayout, QTableWidget
+from PyQt4.QtGui import QGroupBox, QVBoxLayout, QHBoxLayout
 
 from dls_barcode.plate import NOT_FOUND_SLOT_SYMBOL, EMPTY_SLOT_SYMBOL
 
@@ -15,16 +15,15 @@ class BarcodeTable(QGroupBox):
     def __init__(self, options):
         super(BarcodeTable, self).__init__()
 
-        self._barcodes = []
-
         self._options = options
 
         self.setTitle("Plate Barcodes")
         self._init_ui()
+        self.clear()
 
     def _init_ui(self):
-        # Create record table - lists all the records in the store
-        self._table = QTableWidget()
+        # Plate being displayed
+        self._plate_lbl = QtGui.QLabel()
 
         # Create barcode table - lists all the barcodes in a record
         self._table = QtGui.QTableWidget()
@@ -35,70 +34,85 @@ def _init_ui(self):
         self._table.setHorizontalHeaderLabels(['Barcode'])
         self._table.setColumnWidth(0, 100)
 
-
         # Clipboard button - copy the selected barcodes to the clipboard
         self._btn_clipboard = QtGui.QPushButton('Copy To Clipboard')
         self._btn_clipboard.setToolTip('Copy barcodes for the selected record to the clipboard')
         self._btn_clipboard.resize(self._btn_clipboard.sizeHint())
-        self._btn_clipboard.clicked.connect(self.copy_selected_to_clipboard)
-        self._btn_clipboard.setEnabled(False)
+        self._btn_clipboard.clicked.connect(self.copy_to_clipboard)
 
         hbox = QHBoxLayout()
         hbox.setSpacing(10)
         hbox.addWidget(self._btn_clipboard)
         hbox.addStretch(1)
 
         vbox = QVBoxLayout()
+        vbox.addWidget(self._plate_lbl)
         vbox.addWidget(self._table)
         vbox.addLayout(hbox)
 
         self.setLayout(vbox)
 
-    def populate(self, barcodes):
-        """ Called when a new row is selected on the record table. Displays all of the
-        barcodes from the selected record in the barcode table. By default, valid barcodes are
+    def populate(self, holder_barcode, barcodes):
+        """ Called when a new row is selected on the record table.
+        """
+        self._holder_barcode = holder_barcode
+        self._barcodes = barcodes[:]
+        self._update_state()
+
+    def clear(self):
+        self._holder_barcode = None
+        self._barcodes = []
+        self._update_state()
+
+    def _update_state(self):
+        self._populate_table()
+        self._update_button_state()
+        self._update_plate_label()
+
+    def _populate_table(self):
+        """Displays all of the barcodes from the selected record in the barcode table. By default, valid barcodes are
         highlighted green, invalid barcodes are highlighted red, and empty slots are grey.
         """
-        num_slots = len(barcodes)
         self._table.clearContents()
-        self._table.setRowCount(num_slots)
+        self._table.setRowCount(len(self._barcodes))
 
-        for index, barcode in enumerate(barcodes):
-            # Select appropriate background color
+        for index, barcode in enumerate(self._barcodes):
             if barcode == NOT_FOUND_SLOT_SYMBOL:
-                color = self._options.col_bad()
+                cell_color = self._options.col_bad()
             elif barcode == EMPTY_SLOT_SYMBOL:
-                color = self._options.col_empty()
+                cell_color = self._options.col_empty()
             else:
-                color = self._options.col_ok()
+                cell_color = self._options.col_ok()
 
-            color.a = 192
+            cell_color.a = 192
 
             # Set table item
             barcode = QtGui.QTableWidgetItem(barcode)
-            barcode.setBackgroundColor(color.to_qt())
+            barcode.setBackgroundColor(cell_color.to_qt())
             barcode.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
             self._table.setItem(index, 0, barcode)
 
-        self._barcodes = barcodes[:]
-        for i, barcode in enumerate(self._barcodes):
-            if barcode in [NOT_FOUND_SLOT_SYMBOL, EMPTY_SLOT_SYMBOL]:
-                self._barcodes[i] = ""
-
-        self._update_button_state()
-
     def _update_button_state(self):
-        if self._barcodes is None or len(self._barcodes) == 0:
-            self._btn_clipboard.setEnabled(False)
-        else:
-            self._btn_clipboard.setEnabled(True)
+        self._btn_clipboard.setEnabled(self._has_barcodes())
 
-    def copy_selected_to_clipboard(self):
+    def copy_to_clipboard(self):
         """ Called when the copy to clipboard button is pressed. Copies the list/s of
         barcodes for the currently selected records to the clipboard so that the user
         can paste it elsewhere.
         """
+        clipboard_barcodes = [self._holder_barcode] + self._barcodes[:]
+        for i, barcode in enumerate(clipboard_barcodes):
+            if barcode in [NOT_FOUND_SLOT_SYMBOL, EMPTY_SLOT_SYMBOL]:
+                clipboard_barcodes[i] = ""
+
         sep = os.linesep
-        if self._barcodes:
+        if clipboard_barcodes:
             import pyperclip
-            pyperclip.copy(sep.join(self._barcodes))
+            pyperclip.copy(sep.join(clipboard_barcodes))
+
+    def _update_plate_label(self):
+        text = "Plate : " + str(self._holder_barcode) if self._has_barcodes() else "Plate:"
+        self._plate_lbl.setText(text)
+
+    def _has_barcodes(self):
+        return self._barcodes is not None and len(self._barcodes) > 0