def __set_sheet_data(self, dic): #delete old rows if there are any self.__delete_all_rows() lst = Converter.to_list(dic) self.__disable_rows(lst) self.sheet.set_sheet_data(lst, redraw=True)
def sort(self): """ This method sorts the table by the first column. """ dic = self.__data_as_dict() dic = Converter.group_dict(dic) self.__set_sheet_data(dic)
def test_save_list_deleted_row(self): lst = [["model", "bar"], ["software", "python"]] p = self.__path('modified.jpg') writer = Writer(self.reader.binary(), Converter.to_dict(lst)) writer.save([["model", "bar"]], p) keys = Reader(p).keys() self.assertFalse("software" in keys)
def __parse_value(self, cell): try: key = self.__get_key(cell[0]) value = self.__get_value(cell[0]) dat = Converter.to_format(key, value) self.sheet.set_cell_data(cell[0], cell[1], dat, False, True) except ValueError as exc: logging.warning(exc) self.__restore_origin_cell_data(cell[0], cell[1])
class Writer: """This class writes the edited Exif Tags back to the image.""" def __init__(self, image, origin_dict=None): self.image = image self.origin_dict = {} if origin_dict is None else origin_dict self.converter = Converter() def save(self, rows, img_path): """ Saves the the collection of Exif tags to a file given by the path. """ self.__set_values(Converter.to_dict(rows)) self.__save(img_path) def __set_values(self, dic): for key, value in dic.items(): if Writer.__is_valid(key, value): self.__set_value(key, value) # updated an existing element, so remove from source if key in self.origin_dict: self.origin_dict.pop(key) #the elements which survived above loop, are those which were deleted self.__delete_tags() def __set_value(self, key, value): try: val = self.converter.to_exif(key, value) self.image[key] = val except Exception as exc: logging.warning("exception while setting new value: %s", exc) @staticmethod def __is_valid(key, value): return key not in ExifFilter.read_only() and value is not None def __delete_tags(self): #we need to iterate through each and check if we allowed to delete it locked = ExifFilter.locked() for key, _ in self.origin_dict.items(): if key not in locked: self.image.delete(key) def __save(self, img_path): with open(img_path, 'wb') as file: file.write(self.image.get_file())
def test_to_dict(self): d = Converter.to_dict([["model", "bar"]]) self.assertDictEqual({'model': 'bar'}, d)
def test_try_read(self): m = {'foo': 'bar'} self.assertIsNone(Converter.read_from_dict(m, 'baz'))
def grouped_dict(self) -> dict: """ Returns a dictionary with groups, where every group is sorted. """ return Converter.group_dict(self.dict())
def test_illegal_degree(self): dic = {'gps_latitude': 'a'} self.assertIsNone(Converter.read_from_dict(dic, 'gps_latitude'))
def test_filter(self): keys = Converter.keys() self.assertTrue(len(keys) > 0)
def test_to_exif_int(self): res = Converter.to_exif('', 12) self.assertIsInstance(res, int)
def test_grouped_dict(self): res = Converter.group_dict({"b": 1, "a": 2, "exif_version": 22}) self.assertEqual({"exif_version": 22, "a": 2, "b": 1}, res)
def test_convert_resolution_unit_centimeters(self): self.assertEqual(ResolutionUnit.CENTIMETERS, Converter.to_exif("resolution_unit", "CENTIMETERS"))
def test_convert_color_space_uncalibrated(self): self.assertEqual(ColorSpace.UNCALIBRATED, Converter.to_exif("color_space", "UNCALIBRATED"))
def test_convert_color_space_srgb(self): self.assertEqual(ColorSpace.SRGB, Converter.to_exif("color_space", "SRGB"))
def test_convert_unknown(self): self.assertEqual(1, Converter.to_exif('foo', 1))
def save(self, rows, img_path): """ Saves the the collection of Exif tags to a file given by the path. """ self.__set_values(Converter.to_dict(rows)) self.__save(img_path)
def __init__(self, image, origin_dict=None): self.image = image self.origin_dict = {} if origin_dict is None else origin_dict self.converter = Converter()
def test_to_dict_raise_error(self): rows = [["model"]] self.assertRaises(ValueError, lambda: Converter.to_dict(rows))
def test_convert_resolution_unit_inches(self): self.assertEqual(ResolutionUnit.INCHES, Converter.to_exif("resolution_unit", "1"))
def test_to_list(self): res = Converter.to_list({'model': 'bar'}) self.assertListEqual([["model", "bar"]], res)
def test_convert_orientations(self): self.assertEqual(Orientation.LEFT_BOTTOM, Converter.to_exif("orientation", "LEFT_BOTTOM"))
def test_to_exif_dms(self): loc = DegreeFormatFactory.create([78.0, 55.0, 44.33324]) res = Converter.to_exif('', loc) self.assertIsInstance(res, tuple)
def __data_as_dict(self): if self.has_rows(): data = self.sheet.get_sheet_data() return Converter.to_dict(data) return {}
def test_to_exif_fallback(self): res = Converter.to_exif('', 'a') self.assertEqual(res, 'a')
def test_convert_orientations_default(self): self.assertEqual(Orientation.TOP_LEFT, Converter.to_exif("orientation", "9"))
def test_to_custom_gps_timestamp(self): res = Converter.to_format('gps_timestamp', '15:01:01') self.assertIsInstance(res.get_source(), tuple)
def test_convert_orientations_none(self): self.assertEqual(Orientation.TOP_LEFT, Converter.to_exif("orientation", None))
def test_convert_orientations_numeric(self): self.assertEqual(Orientation.TOP_RIGHT, Converter.to_exif("orientation", "2"))
def value(self, key) -> str: """ This method returns the value for a given key. """ return Converter.read_from_dict(self.image, key)