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)
