def center(draw, position, content, font_size, font_colour, font_path, width=None):
"""
Methode, um Text an einem fixem Punkt in ein Bild zu schreiben
:param draw: Draw-Object, auf welches geschrieben werden soll
:type draw: PIL.ImageDraw.Draw()
:param position: Position, an welche geschrieben werden soll
:type position: tuple
:param content: Text, der geschrieben werden soll
:type content: str
:param font_size: Größe des Texts, Standard Größe = 70
:type font_size: int
:param font_colour: Farbe, in welcher geschrieben werden soll (Textfarbe als string oder Hexadezimalwert)
:type font_colour: str
:param font_path: Pfad zur Schriftart, in welcher geschrieben werden soll
:type font_path: str
"""
ttype = ImageFont.truetype(resources.get_resource_path(font_path), font_size)
w, h = ttype.getsize(content)
if width:
y_text = h
if content != "":
lines = textwrap.wrap(content, width=calc_num_character(ttype, content[0], width))
else:
lines = [content]
for line in lines:
draw.text(((position[0] - (w / 2)), y_text + position[1]), line,
font=ImageFont.truetype(resources.get_resource_path(font_path), font_size),
fill=font_colour)
y_text += h
else:
draw.text(((position[0] - (w / 2)), position[1]), content,
font=ImageFont.truetype(resources.get_resource_path(font_path), font_size),
fill=font_colour)
def center(draw, position, content, font_size, font_colour, font_path):
"""
Methode, um Text an einem fixem Punkt in ein Bild zu schreiben
:param draw: Draw-Object, auf welches geschrieben werden soll
:type draw: PIL.ImageDraw.Draw()
:param position: Position, an welche geschrieben werden soll
:type position: tuple
:param content: Text, der geschrieben werden soll
:type content: str
:param font_size: Größe des Texts, Standard Größe = 70
:type font_size: int
:param font_colour: Farbe, in welcher geschrieben werden soll (Textfarbe als string oder Hexadezimalwert)
:type font_colour: str
:param font_path: Pfad zur Schriftart, in welcher geschrieben werden soll
:type font_path: str
"""
ttype = ImageFont.truetype(resources.get_resource_path(font_path),
font_size)
w, h = ttype.getsize(content)
draw.text(((position[0] - (w / 2)), position[1]),
content,
font=ImageFont.truetype(resources.get_resource_path(font_path),
font_size),
fill=font_colour)
def test_wordcloud_2(self):
values = {
"images": {
"testbild": {
"type": "wordcloud",
"text": "Canada, Argentina, Cyprus, Schweden, Norway, USA, Germany, United Kingdom, Argentina, Norway, USA, Argentina",
"stopwords": ["Cyprus"],
"use_stopwords": True,
"color_func_words": "145 46 5 35",
"parameter": {
"font_path": "Test_Font.ttf",
"figure": "square",
"width": 1000,
"height": 1000,
"collocations": False,
"max_font_size": 400,
"max_words": 2000,
"contour_width": 3,
"contour_color": "white",
"color_func": True,
"colormap": "viridis"
}
}
}
},
data = {
}
expected = prepare_wordcloud_test(values, data)
self.assertEqual(os.path.exists(resources.get_resource_path(expected)), 1)
def delete_memory_files(job_name: str, name: str, count: int):
"""Löscht Memory-Dateien sobald zu viele vorhanden sind.
:param job_name: Name des Jobs von der die Funktion aufgerufen wurde.
:param name: Name des Dictionaries, das exportiert wurde.
:param count: Anzahl an Memory-Dateien, die vorhanden sein sollen (danach wird gelöscht).
"""
files = os.listdir(
get_resource_path(os.path.join(MEMORY_LOCATION, job_name, name)))
files.sort(reverse=True)
for idx, file in enumerate(files):
if idx >= count:
os.remove(
get_resource_path(
os.path.join(MEMORY_LOCATION, job_name, name, file)))
logger.info(f"Old memory file {file} has been deleted.")
def pillow(values: dict, step_data: StepData, prev_paths: dict):
"""
Erstellt ein Bild mit Hilfe der Python-Bibliothek Pillow.
Dazu wird ein neues Bild geöffnet oder ein bisher erstelltes Bild weiter bearbeitet.
In der JSON können beliebige viele Overlays angegeben werden, welche diese Methode alle
ausführt und auf das Bild setzt.
:param values: Image-Bauplan des zu erstellenden Bildes
:param step_data: Daten aus der API
:param prev_paths: alle Image-Baupläne und somit auch alle Pfade zu den bisher erstellten Bildern
:return: Pfad zum erstellten Bild
:rtype: str
"""
if values.get("path", None) is None:
image_name = step_data.format(values["image_name"])
source_img = Image.open(
resources.get_resource_path(prev_paths[image_name]))
else:
path = step_data.format(values["path"])
source_img = Image.open(resources.get_image_path(path))
img1 = Image.new("RGBA", source_img.size)
draw = ImageDraw.Draw(source_img)
for overlay in values["overlay"]:
over_func = get_type_func(overlay, OVERLAY_TYPES)
over_func(overlay, step_data, source_img, prev_paths, draw)
file = resources.new_temp_resource_path(step_data.data["_pipe_id"], "png")
Image.composite(img1, source_img, img1).save(file)
return file
def remove_from_list(values: dict, data: StepData):
"""Bekommt Stopwords und wandelt die jeweiligen Wörter so um, dass Groß- und Kleinschreibung unwichtig ist.
Bekommt eine Stopword-Liste aus der Textdatei resources/stopwords/stopwords.txt und ggf. die bei der Job-Erstellung
eingegebenen wurden und wandelt die jeweiligen Wörter so um, dass Groß- und Kleinschreibung unwichtig ist.
:param values: Werte aus der JSON-Datei
:param data: Daten aus der API
:return:
"""
for idx, key in data.loop_key(values["keys"], values):
value = data.get_data(key, values)
new_key = get_new_keys(values, idx)
to_remove = data.get_data(values.get("to_remove", []), values, list)
if data.get_data(values.get("use_stopwords", False), values, bool):
try:
file = resources.get_resource_path("stopwords/stopwords.txt")
with open(file, "r", encoding='utf-8') as f:
list_stopwords = f.read().splitlines()
to_remove = to_remove + list_stopwords
except IOError:
pass
if data.get_data(values.get("ignore_case", False), values, bool):
to_remove = [r.lower() for r in to_remove]
new_value = [v for v in value if v.lower() not in to_remove]
else:
new_value = [v for v in value if v not in to_remove]
data.insert_data(new_key, new_value, values)
def test_option(self):
values = {
"type":
"option",
"check":
"_req|_test|checker",
"on_true": [
{
"type": "text_array",
"anchor_point": "center",
"pos_x": [90, 104],
"pos_y": [40, 40],
"preset": "test_preset",
"pattern": ["{_req|_test|test_1}", "{_req|_test|test_1}"]
},
],
"on_false": [{
"type": "text",
"anchor_point": "center",
"pos_x": 50,
"pos_y": 45,
"preset": "test_preset",
"pattern": "Hallo"
}]
}
data = {"test_1": "Test text", "checker": False}
expected = prepare_overlay_test(values, data)
self.assertEqual(os.path.exists(resources.get_resource_path(expected)),
1)
def init(config: dict):
# check if all external programs are installed
external_programs.all_installed(config.get("external_programs"))
# initialize logging
level = logging.INFO if config.get("testing", False) else logging.WARNING
logging.basicConfig(format='%(module)s %(levelname)s: %(message)s',
level=level)
# if graphic mode -> init db
if not config["console_mode"]:
# init db
db.init_db(config["db"].get("topics", []), config["db"]["db_path"])
# init log_limit
job.LOG_LIMIT = config["log_limit"]
# INit STEPS_BASE_CONFIG
config_manager.STEPS_BASE_CONFIG = config["steps_base_config"]
# Init resources locations
res_paths = config["resources"]
res_sub_paths = res_paths["sub_paths"]
resources.RESOURCES_LOCATION = res_paths["main_path"]
resources.TEMP_LOCATION = res_sub_paths["temp"]
resources.IMAGES_LOCATION = res_sub_paths["images"]
resources.MEMORY_LOCATION = res_sub_paths["memory"]
resources.INFOPROVIDER_LOCATION = res_sub_paths["infoprovider"]
# create resources folders
os.makedirs(resources.path_from_root(res_paths["main_path"]),
exist_ok=True)
os.makedirs(resources.get_resource_path(res_sub_paths["temp"]),
exist_ok=True)
os.makedirs(resources.get_resource_path(res_sub_paths["images"]),
exist_ok=True)
os.makedirs(resources.get_resource_path(res_sub_paths["memory"]),
exist_ok=True)
# create out and instance folder
out_dir = config.get("steps_base_config", {}).get("output_path", "out")
os.makedirs(resources.path_from_root(out_dir), exist_ok=True)
os.makedirs(resources.path_from_root("instance"), exist_ok=True)
def left(draw, position, content, font_size, font_colour, font_path, width=None):
"""
Methode, um Text mittig auf ein Bild zu schreiben.
Ort, an dem angefangen wird zu schreiben ,ist variabel und wird berechnet
anhand der Größe des zu schreibenden Textes.
:param draw: Draw-Object, auf welches geschrieben werden soll
:type draw: PIL.ImageDraw.Draw()
:param position: Position, an welche geschrieben werden soll
:type position: tuple
:param content: Text, der geschrieben werden soll
:type content: str
:param font_size: Größe des Texts, Standard Größe = 70
:type font_size: int
:param font_colour: Farbe, in welcher geschrieben werden soll (Textfarbe als string oder Hexadezimalwert)
:type font_colour: str
:param font_path: Pfad zur Schriftart, in welcher geschrieben werden soll
:type font_path: str
"""
#draw.text(position, content,
# font=ImageFont.truetype(resources.get_resource_path(font_path), font_size),
# fill=font_colour)
ttype = ImageFont.truetype(resources.get_resource_path(font_path), font_size)
w, h = ttype.getsize(content)
if width:
print("position", position, "width", width, "w", w, "height", h)
y_text = 0
if content != "":
lines = textwrap.wrap(content, width=calc_num_character(ttype, content, width))
else:
lines = [content]
for line in lines:
draw.text(((position[0]), y_text + position[1]), line,
font=ImageFont.truetype(resources.get_resource_path(font_path), font_size),
fill=font_colour)
y_text += h
else:
draw.text(((position[0] - (w / 2)), position[1]), content,
font=ImageFont.truetype(resources.get_resource_path(font_path), font_size),
fill=font_colour)
def test_text(self):
values = {
"type": "text",
"anchor_point": "center",
"pos_x": 200,
"pos_y": 200,
"preset": "test_preset",
"pattern": "{_req|_test|test_1}"
}
data = {"test_1": "Test text"}
expected = prepare_overlay_test(values, data)
self.assertEqual(os.path.exists(resources.get_resource_path(expected)),
1)
def test_image_array(self):
values = {
"type": "image_array",
"pos_x": [187, 190, 45],
"pos_y": [462, 47, 145],
"size_x": 300,
"size_y": 5,
"color": ["RGBA", "L", "RGBA"],
"path": ["Test_Bild_2.png", "Test_Bild_2.png", "Test_Bild_2.png"],
"transparency": False
}
data = {}
expected = prepare_overlay_test(values, data)
self.assertEqual(os.path.exists(resources.get_resource_path(expected)),
1)
def test_text_array(self):
values = {
"type":
"text_array",
"anchor_point":
"center",
"pos_x": [120, 170, 10, 140],
"pos_y": [20, 20, 24, 48],
"preset":
"test_preset",
"pattern": [
"{_req|_test|test_1}", "{_req|_test|test_2}",
"{_req|_test|test_2}", "{_req|_test|test_1}"
]
}
data = {"test_1": "Test text", "test_2": "Test text 2"}
expected = prepare_overlay_test(values, data)
self.assertEqual(os.path.exists(resources.get_resource_path(expected)),
1)
def image(overlay: dict, step_data: StepData, source_img, prev_paths, draw):
"""
Methode, um ein Bild in das `source_img` einzufügen, mit dem Bauplan, der in overlay vorgegeben ist.
:param overlay: Bauplan des zu schreibenden Overlays
:param step_data: Daten aus der API
:param source_img: Bild, auf welches das Bild eingefügt werden soll
:param prev_paths: Alle Image-Baupläne und somit auch alle Pfade zu den bisher erstellen Bildern
:param draw: Draw-Objekt
"""
if overlay.get("path", None) is None:
image_name = step_data.format(overlay["image_name"])
path = resources.get_resource_path(prev_paths[image_name])
else:
path = resources.get_image_path(step_data.format(overlay["path"]))
icon = Image.open(path).convert("RGBA")
if overlay.get("color_transparency", None) is not None:
_color_to_transparent(icon,
step_data.format(overlay["color_transparency"]))
if step_data.format(overlay.get("color", "RGBA")) != "RGBA":
icon = icon.convert(step_data.format(overlay["color"]))
if overlay.get("size_x", None) is not None and overlay.get(
"size_y", None) is not None:
icon = icon.resize([
step_data.get_data(overlay["size_x"], None, numbers.Number),
step_data.get_data(overlay["size_y"], None, numbers.Number)
], Image.LANCZOS)
if overlay.get("pos_x", None) is not None and overlay.get(
"pos_y", None) is not None:
pos_x = step_data.get_data(overlay["pos_x"], None, numbers.Number)
pos_y = step_data.get_data(overlay["pos_y"], None, numbers.Number)
else:
width_b, height_b = source_img.size
width_i, height_i = icon.size
pos_x = int(round((width_b - width_i) / 2))
pos_y = int(round((height_b - height_i) / 2))
if step_data.get_data(overlay.get("transparency", False), None, bool):
source_img.alpha_composite(icon, (pos_x, pos_y))
else:
source_img.paste(icon, (pos_x, pos_y), icon)
def test_single_image(self):
values = {
"test_1": {
"type": "pillow",
"path": "Test_Bild_2.png",
"overlay": [
{
"type": "text",
"anchor_point": "left",
"pos_x": 200,
"pos_y": 50,
"preset": "test_preset",
"pattern": "{_req|_test|test_1}"
}
]
}
}
data = {
"test_1": "Test text"
}
expected = prepare_image_test(values, data)
self.assertEqual(os.path.exists(resources.get_resource_path(expected["test_1"])), 1)
def left(draw, position, content, font_size, font_colour, font_path):
"""
Methode, um Text mittig auf ein Bild zu schreiben.
Ort, an dem angefangen wird zu schreiben ,ist variabel und wird berechnet
anhand der Größe des zu schreibenden Textes.
:param draw: Draw-Object, auf welches geschrieben werden soll
:type draw: PIL.ImageDraw.Draw()
:param position: Position, an welche geschrieben werden soll
:type position: tuple
:param content: Text, der geschrieben werden soll
:type content: str
:param font_size: Größe des Texts, Standard Größe = 70
:type font_size: int
:param font_colour: Farbe, in welcher geschrieben werden soll (Textfarbe als string oder Hexadezimalwert)
:type font_colour: str
:param font_path: Pfad zur Schriftart, in welcher geschrieben werden soll
:type font_path: str
"""
draw.text(position,
content,
font=ImageFont.truetype(resources.get_resource_path(font_path),
font_size),
fill=font_colour)
def test_center(self):
values = "center"
data = {}
expected = prepare_draw_test(values, data)
self.assertEqual(os.path.exists(resources.get_resource_path(expected)),
1)
def setUp(self):
resources.RESOURCES_LOCATION = "tests/resources"
os.makedirs(resources.get_resource_path("temp"), exist_ok=True)
os.makedirs(resources.get_temp_resource_path("", "101"), exist_ok=True)
