def test_fk_transform_sets_on_delete_cascade(self):
with deepstar_path():
FrameSetModel().insert(None)
FrameModel().insert(1, 0)
transform_set_model = TransformSetModel()
transform_set_model.insert('test', 1)
transform_model = TransformModel()
transform_model.insert(1, 1, '{}', 0)
self.assertEqual(transform_model.list(1), [(1, 1, 1, '{}', 0)])
transform_set_model.delete(1)
self.assertIsNone(transform_model.list(1))
def transform_set_select_curate(self, transform_set_id, opts):
"""
This method automatically curates a transform set and rejects
transforms that are more blurry than the 'max-blur'.
:param int transform_set_id: The transform set ID.
:param dict opts: The dict of options.
:raises: ValueError
:rtype: None
"""
if 'max-blur' not in opts:
raise ValueError(
'The max-blur option is required but was not supplied')
max_blur = float(opts['max-blur'])
transform_model = TransformModel()
length = 100
offset = 0
p1 = TransformSetSubDir.path(transform_set_id)
while True:
transforms = transform_model.list(transform_set_id,
length=length,
offset=offset)
if not transforms:
break
for transform in transforms:
p2 = TransformFile.path(p1, transform[0], 'jpg')
debug(f'Curating transform with ID {transform[0]:08d} at {p2}',
4)
image = cv2.imread(p2)
image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
h, w = image.shape[:2]
# recommendation to scale down image to ~500
if h > 600 or w > 600:
# imutils.resize preserves aspect ratio.
image = imutils.resize(image, width=500, height=500)
score = cv2.Laplacian(image, cv2.CV_64F).var()
if score < max_blur:
transform_model.update(transform[0], rejected=1)
debug(f'Transform with ID {transform[0]:08d} rejected', 4)
offset += length
def list(self, transform_set_id):
"""
This method lists transforms in the transform collection for a
transform set.
:param int transform_set_id: The transform set ID.
:raises: CommandLineRouteHandlerError
:rtype: None
"""
result = TransformSetModel().select(transform_set_id)
if result is None:
raise CommandLineRouteHandlerError(
f'Transform set with ID {transform_set_id:08d} not found')
transform_model = TransformModel()
count = transform_model.count(transform_set_id)
debug(f'{count} results', 3)
debug(
'id | fk_transform_sets | fk_frames | metadata | rejected | '
'(width | height)', 3)
debug(
'-----------------------------------------------------------'
'----------------', 3)
if count == 0:
return
length = int(os.environ.get('MODEL_LIST_LENGTH', '100'))
offset = 0
p1 = TransformSetSubDir.path(transform_set_id)
while True:
transforms = transform_model.list(transform_set_id,
length=length,
offset=offset)
if not transforms:
break
for transform in transforms:
p2 = TransformFile.path(p1, transform[0], 'jpg')
height, width, _ = cv2.imread(p2).shape
debug(
f'{transform[0]} | {transform[1]} | {transform[2]} | '
f'{transform[3]} | {transform[4]} | ({width} | '
f'{height})', 3)
offset += length
def test_list(self):
with deepstar_path():
FrameSetModel().insert(None)
FrameModel().insert(1, 0)
TransformSetModel().insert('test', 1)
transform_model = TransformModel()
transform_model.insert(1, 1, '{}', 0)
transform_model.insert(1, 1, '{}', 1)
transform_model.insert(1, 1, '{}', 0)
result = transform_model.list(1)
self.assertEqual(len(result), 3)
self.assertEqual(result[0], (1, 1, 1, '{}', 0))
self.assertEqual(result[1], (2, 1, 1, '{}', 1))
self.assertEqual(result[2], (3, 1, 1, '{}', 0))
result = transform_model.list(1, length=2)
self.assertEqual(len(result), 2)
self.assertEqual(result[0], (1, 1, 1, '{}', 0))
self.assertEqual(result[1], (2, 1, 1, '{}', 1))
result = transform_model.list(1, offset=1)
self.assertEqual(len(result), 2)
self.assertEqual(result[0], (2, 1, 1, '{}', 1))
self.assertEqual(result[1], (3, 1, 1, '{}', 0))
result = transform_model.list(1, length=1, offset=1)
self.assertEqual(len(result), 1)
self.assertEqual(result[0], (2, 1, 1, '{}', 1))
result = transform_model.list(1, rejected=False)
self.assertEqual(len(result), 2)
self.assertEqual(result[0], (1, 1, 1, '{}', 0))
self.assertEqual(result[1], (3, 1, 1, '{}', 0))
def transform_set_select_curate(self, transform_set_id, opts):
"""
This method automatically curates a transform set and rejects
transforms with width or height less than 'min-size'.
:param int transform_set_id: The transform set ID.
:param dict opts: The dict of options.
:raises: ValueError
:rtype: None
"""
if 'min-size' not in opts:
raise ValueError(
'The min-size option is required but was not supplied')
min_length = int(opts['min-size'])
transform_model = TransformModel()
length = 100
offset = 0
p1 = TransformSetSubDir.path(transform_set_id)
while True:
transforms = transform_model.list(transform_set_id,
length=length,
offset=offset)
if not transforms:
break
for transform in transforms:
p2 = TransformFile.path(p1, transform[0], 'jpg')
debug(f'Curating transform with ID {transform[0]:08d} at {p2}',
4)
h, w = cv2.imread(p2).shape[:2]
if h < min_length or w < min_length:
transform_model.update(transform[0], rejected=1)
debug(f'Transform with ID {transform[0]:08d} rejected', 4)
offset += length
def transform_set_select_extract(self, transform_set_id, opts):
"""
This method adjusts color for each transform in a transform set.
:param int transform_set_id: The transform set ID.
:param dict opts: The dict of options.
:raises: ValueError
:rtype: None
"""
r = opts.get('r', None)
g = opts.get('g', None)
b = opts.get('b', None)
if r is None and g is None and b is None:
raise ValueError(
'The r, g and/or b options are required but were not supplied')
for channel in [r, g, b]:
if channel is not None:
if not re.match('^[+,\\-]\\d+$', channel):
raise ValueError(
'A color adjustment option value must be formatted as '
'+/- followed by a number (e.g. --r=+10)')
color_adjustments = []
for index, channel in enumerate([b, g, r]):
if channel is not None:
color_adjustments.append(
[index, int(channel[1:]),
True if (channel[:1] == '+') else False])
else:
color_adjustments.append(None)
transform_set_model = TransformSetModel()
result = transform_set_model.select(transform_set_id)
transform_set_id_ = TransformSetModel().insert('adjust_color',
result[2],
transform_set_id)
p1 = TransformSetSubDir.path(transform_set_id_)
os.makedirs(p1)
p2 = TransformSetSubDir.path(transform_set_id)
transform_model = TransformModel()
length = int(os.environ.get('MODEL_LIST_LENGTH', '100'))
offset = 0
while True:
transforms = transform_model.list(transform_set_id, length=length,
offset=offset, rejected=False)
if not transforms:
break
for transform in transforms:
transform_id = transform_model.insert(transform_set_id_,
transform[2],
transform[3],
transform[4])
p3 = TransformFile.path(p2, transform[0], 'jpg')
p4 = TransformFile.path(p1, transform_id, 'jpg')
image = cv2.imread(p3)
image = image.astype(np.short)
for color_adjustment in color_adjustments:
if color_adjustment is not None:
image = adjust_color(image, color_adjustment[0],
color_adjustment[1],
color_adjustment[2])
cv2.imwrite(p4, image, [cv2.IMWRITE_JPEG_QUALITY, 100])
debug(f'Transform with ID {transform_id:08d} at {p4} '
f'extracted from transform with ID {transform[0]:08d} '
f'at {p3}', 4)
offset += length
return transform_set_id_
def transform_set_select_extract(self, transform_set_id, opts):
"""
This method crops each transform in a transform set.
:param int transform_set_id: The transform set ID.
:param dict opts: The dict of options.
:raises: ValueError
:rtype: None
"""
x1 = int(opts['x1']) if ('x1' in opts) else None
y1 = int(opts['y1']) if ('y1' in opts) else None
x2 = int(opts['x2']) if ('x2' in opts) else None
y2 = int(opts['y2']) if ('y2' in opts) else None
if x1 is None or y1 is None or x2 is None or y2 is None:
raise ValueError(
'The x1, y1, x2 and y2 options are required but were not '
'supplied')
transform_set_model = TransformSetModel()
result = transform_set_model.select(transform_set_id)
transform_set_id_ = TransformSetModel().insert('crop', result[2],
transform_set_id)
p1 = TransformSetSubDir.path(transform_set_id_)
os.makedirs(p1)
p2 = TransformSetSubDir.path(transform_set_id)
transform_model = TransformModel()
length = int(os.environ.get('MODEL_LIST_LENGTH', '100'))
offset = 0
while True:
transforms = transform_model.list(transform_set_id,
length=length,
offset=offset,
rejected=False)
if not transforms:
break
for transform in transforms:
transform_id = transform_model.insert(transform_set_id_,
transform[2],
transform[3],
transform[4])
p3 = TransformFile.path(p2, transform[0], 'jpg')
p4 = TransformFile.path(p1, transform_id, 'jpg')
image_1 = cv2.imread(p3)
image_2 = image_1[y1:y2, x1:x2]
cv2.imwrite(p4, image_2, [cv2.IMWRITE_JPEG_QUALITY, 100])
debug(
f'Transform with ID {transform_id:08d} at {p4} '
f'extracted from transform with ID {transform[0]:08d} '
f'at {p3}', 4)
offset += length
return transform_set_id_
def transform_set_select_extract(self, transform_set_id, opts):
"""
This method resizes each transform in a transform set.
:param int transform_set_id: The transform set ID.
:param dict opts: The dict of options.
:raises: ValueError
:rtype: None
"""
height = int(opts['height']) if ('height' in opts) else None
width = int(opts['width']) if ('width' in opts) else None
if height is None and width is None:
raise ValueError(
'The height or width options are required but were not '
'supplied')
transform_set_model = TransformSetModel()
result = transform_set_model.select(transform_set_id)
transform_set_id_ = TransformSetModel().insert('resize', result[2],
transform_set_id)
p1 = TransformSetSubDir.path(transform_set_id_)
os.makedirs(p1)
p2 = TransformSetSubDir.path(transform_set_id)
transform_model = TransformModel()
length = int(os.environ.get('MODEL_LIST_LENGTH', '100'))
offset = 0
while True:
transforms = transform_model.list(transform_set_id,
length=length,
offset=offset,
rejected=False)
if not transforms:
break
for transform in transforms:
transform_id = transform_model.insert(transform_set_id_,
transform[2],
transform[3],
transform[4])
p3 = TransformFile.path(p2, transform[0], 'jpg')
p4 = TransformFile.path(p1, transform_id, 'jpg')
image_1 = cv2.imread(p3)
if width is not None:
image_2 = imutils.resize(image_1, width=width)
else:
image_2 = imutils.resize(image_1, height=height)
cv2.imwrite(p4, image_2, [cv2.IMWRITE_JPEG_QUALITY, 100])
debug(
f'Transform with ID {transform_id:08d} at {p4} '
f'extracted from transform with ID {transform[0]:08d} '
f'at {p3}', 4)
offset += length
return transform_set_id_
def transform_set_select_extract(self, transform_set_id, opts):
"""
This method extracts a slice from a transform set (a subset).
:param int transform_set_id: The transform set ID.
:param dict opts: The dict of opts.
:raises: ValueError
:rtype: int
"""
start = int(opts['start']) if ('start' in opts) else None
end = int(opts['end']) if ('end' in opts) else None
if start is None or end is None:
raise ValueError(
'The start and end options are required but were not '
'supplied')
transform_set_model = TransformSetModel()
result = transform_set_model.select(transform_set_id)
transform_set_id_ = TransformSetModel().insert('slice', result[2],
transform_set_id)
p1 = TransformSetSubDir.path(transform_set_id_)
os.makedirs(p1)
p2 = TransformSetSubDir.path(transform_set_id)
transform_model = TransformModel()
length = int(os.environ.get('MODEL_LIST_LENGTH', '100'))
offset = 0
flag = True
while flag:
transforms = transform_model.list(transform_set_id,
length=length,
offset=offset,
rejected=False)
if not transforms:
break
for transform in transforms:
if transform[0] < start:
continue
if transform[0] > end:
flag = False
break
transform_id = transform_model.insert(transform_set_id_,
transform[2],
transform[3],
transform[4])
p3 = TransformFile.path(p2, transform[0], 'jpg')
p4 = TransformFile.path(p1, transform_id, 'jpg')
shutil.copy(p3, p4)
debug(
f'Transform with ID {transform_id:08d} at {p4} '
f'extracted from transform with ID {transform[0]:08d} '
f'at {p3}', 4)
offset += length
return transform_set_id_
def transform_set_select_merge(self, transform_set_ids, opts):
"""
This method merges transform sets w/ a fade effect applied.
:param list(int) transform_set_ids: The transform set IDs.
:param dict opts: The dict of options.
:raises: ValueError
:rtype: int
"""
if len(transform_set_ids) != 2:
raise ValueError('Exactly two transform set IDs must be supplied')
if 'frame-count' not in opts:
raise ValueError(
'The frame-count option is required but was not supplied')
frame_count = int(opts['frame-count'])
if frame_count < 1:
raise ValueError('Frame count must be 1 or greater')
transform_set_id_1 = transform_set_ids[0]
transform_set_id_2 = transform_set_ids[1]
transform_model = TransformModel()
transform_set_1_count = transform_model.count(transform_set_id_1,
rejected=False)
transform_set_2_count = transform_model.count(transform_set_id_2,
rejected=False)
if transform_set_1_count <= frame_count or \
transform_set_2_count <= frame_count:
raise ValueError(
'Both transform sets must be greater than frame count')
transform_set_id = TransformSetModel().insert('fade', None, None)
p1 = TransformSetSubDir.path(transform_set_id)
os.makedirs(p1)
p2 = TransformSetSubDir.path(transform_set_id_1)
p3 = TransformSetSubDir.path(transform_set_id_2)
length = int(os.environ.get('MODEL_LIST_LENGTH', '100'))
offset = 0
flag = True
while flag:
transforms = transform_model.list(transform_set_id_1,
length=length,
offset=offset,
rejected=False)
for transform in transforms:
transform_id = transform_model.insert(transform_set_id,
transform[2],
transform[3],
transform[4])
p4 = TransformFile.path(p2, transform[0], 'jpg')
p5 = TransformFile.path(p1, transform_id, 'jpg')
shutil.copy(p4, p5)
debug(
f'Transform with ID {transform[0]:08d} at {p4} '
f'merged as ID {transform_id:08d} at {p5}', 4)
offset += 1
if transform_set_1_count - offset == frame_count:
flag = False
break
transforms_1 = transform_model.list(transform_set_id_1,
length=frame_count,
offset=offset,
rejected=False)
transforms_2 = transform_model.list(transform_set_id_2,
length=frame_count,
offset=0,
rejected=False)
for i in range(0, frame_count):
transform_id_1 = transforms_1[i][0]
transform_id_2 = transforms_2[i][0]
image_path_1 = TransformFile.path(p2, transform_id_1, 'jpg')
image_path_2 = TransformFile.path(p3, transform_id_2, 'jpg')
transform_id = transform_model.insert(transform_set_id, None, None,
0)
image_path_3 = TransformFile.path(p1, transform_id, 'jpg')
image_1 = cv2.imread(image_path_1)
image_2 = cv2.imread(image_path_2)
alpha = 1.0 - float(i + 1) / float(frame_count)
image_3 = cv2.addWeighted(image_1, alpha, image_2, 1.0 - alpha, 0)
cv2.imwrite(image_path_3, image_3, [cv2.IMWRITE_JPEG_QUALITY, 100])
debug(
f'Transforms with ID {transform_id_1:08d} at {image_path_1} '
f'and {transform_id_2:08d} at {image_path_2} merged with '
f'alpha {alpha} as ID {transform_id:08d} at {image_path_3}', 4)
offset = frame_count
while True:
transforms = transform_model.list(transform_set_id_2,
length=length,
offset=offset,
rejected=False)
if not transforms:
break
for transform in transforms:
transform_id = transform_model.insert(transform_set_id,
transform[2],
transform[3],
transform[4])
p4 = TransformFile.path(p3, transform[0], 'jpg')
p5 = TransformFile.path(p1, transform_id, 'jpg')
shutil.copy(p4, p5)
debug(
f'Transform with ID {transform[0]:08d} at {p4} '
f'merged as ID {transform_id:08d} at {p5}', 4)
offset += 1
return transform_set_id
def transform_set_select_merge(self, transform_set_ids, opts):
"""
This method merges one transform set with one image. This is to say
that one image is overlaid onto every transform in a transform set and
at a specified position.
:param list(int) transform_set_ids: The transform set IDs.
:param dict opts: The dict of options.
:raises: ValueError
:rtype: int
"""
if len(transform_set_ids) != 1:
raise ValueError('Exactly one transform set ID must be supplied')
image_path_1 = opts.get('image-path', None)
x1 = int(opts['x1']) if ('x1' in opts) else None
y1 = int(opts['y1']) if ('y1' in opts) else None
if image_path_1 is None or x1 is None or y1 is None:
raise ValueError(
'The image-path, x1 and y1 options are required but were not '
'supplied')
if not os.path.isfile(image_path_1):
raise ValueError(
f'The image path {image_path_1} does not exist or is not a '
f'file')
transform_set_id = transform_set_ids[0]
transform_model = TransformModel()
transform_set_id_ = TransformSetModel().insert('overlay_image', None,
None)
p1 = TransformSetSubDir.path(transform_set_id_)
os.makedirs(p1)
p2 = TransformSetSubDir.path(transform_set_id)
length = int(os.environ.get('MODEL_LIST_LENGTH', '100'))
offset = 0
image_1 = cv2.imread(image_path_1, cv2.IMREAD_UNCHANGED)
while True:
transforms = transform_model.list(transform_set_id,
length=length,
offset=offset,
rejected=False)
if not transforms:
break
for transform in transforms:
transform_id = transform_model.insert(transform_set_id_, None,
None, 0)
image_path_2 = TransformFile.path(p2, transform[0], 'jpg')
image_2 = cv2.imread(image_path_2)
image_3 = overlay_transparent_image(image_2, image_1, x1, y1)
image_path_3 = TransformFile.path(p1, transform_id, 'jpg')
cv2.imwrite(image_path_3, image_3,
[cv2.IMWRITE_JPEG_QUALITY, 100])
debug(
f'{image_path_1} and transform with ID '
f'{transform[0]:08d} at {image_path_2} merged as ID '
f'{transform_id:08d} at {image_path_3}', 4)
offset += length
return transform_set_id_
def transform_set_select_merge(self, transform_set_ids, opts):
"""
This method merges transform sets overlaying transform set 1 onto
transform set 2 at a specified position.
:param list(int) transform_set_ids: The transform set IDs.
:param dict opts: The dict of options.
:raises: ValueError
:rtype: int
"""
if len(transform_set_ids) != 2:
raise ValueError('Exactly two transform set IDs must be supplied')
x1 = int(opts['x1']) if ('x1' in opts) else None
y1 = int(opts['y1']) if ('y1' in opts) else None
if x1 is None or y1 is None:
raise ValueError(
'The x1 and y1 options are required but were not supplied')
transform_set_id_1 = transform_set_ids[0]
transform_set_id_2 = transform_set_ids[1]
transform_model = TransformModel()
transform_set_1_count = transform_model.count(transform_set_id_1,
rejected=False)
transform_set_2_count = transform_model.count(transform_set_id_2,
rejected=False)
if transform_set_1_count != transform_set_2_count:
raise ValueError(
'Both transform sets must have the same number of '
'non-rejected transforms (be the same length)')
transform_set_id = TransformSetModel().insert('overlay', None, None)
p1 = TransformSetSubDir.path(transform_set_id)
os.makedirs(p1)
p2 = TransformSetSubDir.path(transform_set_id_1)
p3 = TransformSetSubDir.path(transform_set_id_2)
length = int(os.environ.get('MODEL_LIST_LENGTH', '100'))
offset = 0
while True:
transforms_1 = transform_model.list(transform_set_id_1,
length=length,
offset=offset,
rejected=False)
transforms_2 = transform_model.list(transform_set_id_2,
length=length,
offset=offset,
rejected=False)
if not transforms_1:
break
for i in range(0, len(transforms_1)):
transform_id_1 = transforms_1[i][0]
transform_id_2 = transforms_2[i][0]
image_path_1 = TransformFile.path(p2, transform_id_1, 'jpg')
image_path_2 = TransformFile.path(p3, transform_id_2, 'jpg')
transform_id = transform_model.insert(transform_set_id, None,
None, 0)
image_path_3 = TransformFile.path(p1, transform_id, 'jpg')
image_1 = cv2.imread(image_path_1)
height_1, width_1 = image_1.shape[:2]
image_2 = cv2.imread(image_path_2)
image_2[y1:y1 + height_1, x1:x1 + width_1] = image_1
cv2.imwrite(image_path_3, image_2,
[cv2.IMWRITE_JPEG_QUALITY, 100])
debug(
f'Transforms with ID {transform_id_1:08d} at '
f'{image_path_1} and {transform_id_2:08d} at '
f'{image_path_2} merged as ID {transform_id:08d} at '
f'{image_path_3}', 4)
offset += length
return transform_set_id
def select_merge(self,
transform_set_ids,
name='merge',
fk_frame_sets=None,
fk_prev_transform_sets=None,
rejected=False):
"""
This method merges multiple transform sets into one transform set.
:param list(int) transform_set_ids: The transform set IDs.
:param str name: The merged transform set's name. The default value is
'merge'.
:param int fk_frame_sets: The frame set ID to which this transform set
corresponds (if any). The default value is None.
:param int fk_prev_transform_sets: The transform set ID the previous
transform set in this series of transformations. The default value
is None.
:param bool rejected: True if should include rejected else False if
should not. The default value is False.
:raises: CommandLineRouteHandlerError
:rtype: None
"""
transform_set_model = TransformSetModel()
for transform_set_id in transform_set_ids:
result = transform_set_model.select(transform_set_id)
if result is None:
raise CommandLineRouteHandlerError(
f'Transform set with ID {transform_set_id:08d} not found')
transform_set_id = transform_set_model.insert(name, fk_frame_sets,
fk_prev_transform_sets)
p1 = TransformSetSubDir.path(transform_set_id)
os.makedirs(p1)
transform_model = TransformModel()
length = int(os.environ.get('MODEL_LIST_LENGTH', '100'))
for transform_set_id_ in transform_set_ids:
offset = 0
p2 = TransformSetSubDir.path(transform_set_id_)
while True:
transforms = transform_model.list(transform_set_id_,
length=length,
offset=offset,
rejected=rejected)
if not transforms:
break
for transform in transforms:
transform_id = transform_model.insert(
transform_set_id, transform[2], transform[3],
transform[4])
p3 = TransformFile.path(p2, transform[0], 'jpg')
p4 = TransformFile.path(p1, transform_id, 'jpg')
shutil.copy(p3, p4)
debug(
f'Transform with ID {transform[0]:08d} at {p3} '
f'merged as ID {transform_id:08d} at {p4}', 4)
offset += length
result = transform_set_model.select(transform_set_id)
debug(
f'transform_set_id={result[0]}, name={result[1]}, '
f'fk_frame_sets={result[2]}, fk_prev_transform_sets={result[3]}',
3)
def select_export_dir(self, transform_set_ids, target_dir, opts={}):
"""
This method exports transform sets to a directory.
:param list transform_set_ids: The list of transform set IDs.
:param str target_dir: The directory to which to export the transform
sets.
:param dict opts: The dict of options.
:raises: CommandLineRouteHandlerError
:rtype: None
"""
transform_set_model = TransformSetModel()
for transform_set_id in transform_set_ids:
result = transform_set_model.select(transform_set_id)
if result is None:
raise CommandLineRouteHandlerError(
f'Transform set with ID {transform_set_id:08d} not found')
if not os.path.isdir(target_dir):
raise CommandLineRouteHandlerError(
f'{target_dir} is not a directory')
transform_model = TransformModel()
length = int(os.environ.get('MODEL_LIST_LENGTH', '100'))
count = 0
for tid in transform_set_ids:
offset = 0
transform_set_path = TransformSetSubDir.path(tid)
while True:
results = transform_model.list(tid,
length=length,
offset=offset,
rejected=False)
if not results:
break
for transform_id, _, _, _, _ in results:
file_path = TransformFile().path(transform_set_path,
transform_id, 'jpg')
if 'format' in opts:
filename = opts['format'] % transform_id
else:
filename = os.path.basename(file_path)
target_path = os.path.join(target_dir, filename)
shutil.copy(file_path, target_path)
count += 1
debug(
f'Transform with ID {transform_id:08d} at '
f'{file_path} exported to {target_path}', 4)
offset += length
debug(f'{count} transforms were successfully exported to {target_dir}',
3)