def date_weekday(values: dict, data: StepData):
"""Wandelt das angegebene Datum in den jeweiligen Wochentag um.
Wandelt das angegebene Datum, im unter `"given_format"` angegebenen Format, in den jeweiligen Wochentag um.
:param values: Werte aus der JSON-Datei
:param data: Daten aus der API
"""
day_weekday = {
0: "Montag",
1: "Dienstag",
2: "Mittwoch",
3: "Donnerstag",
4: "Freitag",
5: "Samstag",
6: "Sonntag"
}
for idx, key in data.loop_key(values["keys"], values):
value = data.get_data(values["keys"][idx], values)
given_format = data.format(values["given_format"], values)
date = datetime.strptime(value, given_format).date()
new_key = get_new_keys(values, idx)
new_value = day_weekday[date.weekday()]
data.insert_data(new_key, new_value, values)
def loop(values: dict, data: StepData):
"""Durchläuft das angegebene Array und führt für jedes Element die angegebenen `"transform"`-Funktionen aus.
:param values: Werte aus der JSON-Datei
:param data: Daten aus der API
"""
loop_values = data.deep_format(values.get("values", None), values=values)
# if values is none use range
if loop_values is None:
start = data.get_data(values.get("range_start", 0), values, int)
stop = data.get_data(values["range_stop"], values, int)
loop_values = range(start, stop)
for _ in data.loop_array(loop_values, values):
transform(values, data)
def calculate_round(values: dict, data: StepData):
"""Rundet gegebene Werte auf eine gewünschte Nachkommastelle.
:param values: Werte aus der JSON-Datei
:param data: Daten aus der API
"""
for idx, key in data.loop_key(values["keys"], values):
value = data.get_data(key, values)
new_key = get_new_keys(values, idx)
if values.get("decimal", None):
new_value = round(
value, data.get_data(values["decimal"], values,
numbers.Number))
else:
new_value = round(value)
data.insert_data(new_key, new_value, values)
def transform_dict(values: dict, data: StepData):
"""Führt alle angegebenen `"transform"`-Funktionen für alle Werte eines Dictionaries aus.
:param values: Werte aus der JSON-Datei
:param data: Daten aus der API
"""
for _ in data.loop_dict(data.get_data(values["dict_key"], values), values):
transform(values, data)
def replace(values: dict, data: StepData):
"""Ersetzt ein Zeichen, Symbol, Wort, einen Satz oder eine ganzen Text in einem String.
:param values: Werte aus der JSON-Datei
:param data: Daten aus der API
"""
for idx, key in data.loop_key(values["keys"], values):
value = str(data.get_data(key, values))
new_key = get_new_keys(values, idx)
new_value = value.replace(
data.format(values["old_value"], values),
data.format(values["new_value"], values),
data.get_data(values.get("count", -1), values, int))
# test mit RegEx
# new_value = re.sub(data.format(values["old_value"], values), data.format(values["new_value"], values), value, count=data.get_data(values.get("count", 0), values, int))
data.insert_data(new_key, new_value, values)
def calculate_mean(values: dict, data: StepData):
"""Berechnet den Mittelwert von Werten, die in einem Array stehen.
: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)
mean_value = float(np.mean(value))
if values.get("decimal", None):
new_value = round(
mean_value,
data.get_data(values["decimal"], values, numbers.Number))
else:
new_value = round(mean_value)
data.insert_data(new_key, new_value, values)
def custom(values: dict, step_data: StepData, out_images, out_audios, out_audio_l):
"""Generierung des Output-Videos aus ausgewählten Bild- und Audiodateien.
Generiert das Output-Video. In values (in der JSON) muss angegeben sein in welcher Reihenfolge und wie lange jedes Bild
und die passenden Audiodatei aneinandergereiht werden sollen.
:param values: Werte aus der JSON-Datei
:param step_data: Daten aus der API
:return: Pfad zum Output-Video
:rtype: str
"""
for s in values["sequence"]["pattern"]:
out_images.append(values["images"][step_data.format(s["image"])])
if s.get("audio_l", None) is None:
out_audio_l.append(step_data.get_data(s.get("time_diff", 0), None, numbers.Number))
else:
out_audios.append(values["audio"]["audios"][step_data.format(s["audio_l"])])
out_audio_l.append(step_data.get_data(s.get("time_diff", 0), None, numbers.Number) + MP3(
values["audio"]["audios"][step_data.format(s["audio_l"])]).info.length)
def most_common(values: dict, data: StepData):
"""Sortiert die Wörter nach der Häufigkeit, optional mit Häufigkeit.
: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)
most_c_list = Counter(value).most_common()
if data.get_data(values.get("include_count", False), values, bool):
new_value = most_c_list
else:
new_value = [elm[0] for elm in most_c_list]
data.insert_data(new_key, new_value, values)
def split_string(values: dict, data: StepData):
"""Teilt einen String am angegebenen Trennzeichen.
Das Trennzeichen können auch mehrere Zeichen sein. Soll die Groß- und Kleinschreibung des Trennzeichens (delimiter) ignoriert werden, setzte `ignore_case` auf `true`.
: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)
delimiter = data.format(values.get("delimiter", " "), values)
new_key = get_new_keys(values, idx)
if data.get_data(values.get("ignore_case", False), values, bool):
new_value = re.split(delimiter, value, flags=re.IGNORECASE)
else:
new_value = re.split(delimiter, value)
data.insert_data(new_key, new_value, values)
def copy(values: dict, data: StepData):
"""Kopiert einen Wert zu einem neuen Key.
:param values: Werte aus der JSON-Datei
:param data: Daten aus der API
"""
for idx, key in data.loop_key(values["keys"], values):
new_key = get_new_keys(values, idx)
new_value = data.get_data(key, values)
data.insert_data(new_key, new_value, values)
def check_key(values: dict, data: StepData):
"""Überprüft, ob ein Key vorhanden ist und setzt den dazugehörigen `key` bzw. den `new_keys` auf `true`.
:param values: Werte aus der JSON-Datei
:param data: Daten aus der API
:return:
"""
for idx, key in enumerate(values["keys"]):
try:
data.get_data(key, values)
value = True
except StepKeyError:
if "init_with" in values:
init = data.deep_format(values["init_with"], values=values)
data.insert_data(key, init, values)
value = False
if "new_keys" in values:
data.insert_data(values["new_keys"][idx], value, values)
def sub_lists(values: dict, data: StepData):
"""Extrahiert aus einem Array (Liste) kleinere Arrays (Listen).
:param values: Werte aus der JSON-Datei
:param data: Daten aus der API
:return:
"""
value = data.get_data(values["array_key"], values)
for sub_list in values["sub_lists"]:
start = data.get_data(sub_list.get("range_start", 0), values,
numbers.Number)
end = data.get_data(sub_list.get("range_end", -1), values,
numbers.Number)
new_key = get_new_key(sub_list)
new_value = value[start:end]
data.insert_data(new_key, new_value, values)
def calculate_mode(values: dict, data: StepData):
"""Bestimmt den am häufigsten in einem Array vorkommenden Wert.
:param values: Werte aus der JSON-Datei
:param data: Daten aus der API
"""
for idx, key in data.loop_key(values["keys"], values):
value = data.get_data(key, values)
new_key = get_new_keys(values, idx)
new_value = collections.Counter(value).most_common()[0][0]
data.insert_data(new_key, new_value, values)
def text(overlay: dict, step_data: StepData, source_img, prev_paths, draw):
"""
Methode, um Text auf ein gegebenes Bild zu schreiben 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 geschrieben werden soll
:param prev_paths: Alle Image-Baupläne und somit auch alle Pfade zu den bisher erstellen Bildern
:param draw: Draw-Objekt
"""
content = step_data.format(overlay["pattern"])
draw_func = get_type_func(overlay, DRAW_TYPES, "anchor_point")
draw_func(draw,
(step_data.get_data(overlay["pos_x"], None, numbers.Number),
step_data.get_data(overlay["pos_y"], None, numbers.Number)),
content,
step_data.get_data(overlay["font_size"], None, numbers.Number),
step_data.format(overlay["color"]),
step_data.format(overlay["font"]), overlay.get("width", None))
def custom(values: dict, data: StepData, config: dict):
"""Generiert eine Audiodatei mithilfe einer bestimmten TTS-API und Konfigurationen dafür.
:param values: Werte aus der JSON-Datei
:param data: Daten aus der API
:param config: Daten aus der Konfigurationsdatei
:return:
"""
logger.info("Generate audio with custom audio config")
_prepare_custom(config.get("prepare", None), data, config)
for key in values:
text = part.audio_parts(values[key]["parts"], data)
if text[1]:
data.data["_audio"]["text"] = text[0]
generate = config["generate"]
generate["include_headers"] = True
api_request(generate, data, "audio", "_audio|gen", True)
values[key] = _save_audio(data.get_data("_audio|gen", values),
data, config)
else:
audio_list = []
for item in values[key]["parts"]:
if item["type"] == "text":
data.data["_audio"]["text"] = data.format(
item["pattern"], values)
generate = config["generate"]
generate["include_headers"] = True
api_request(generate, data, "audio", "_audio|gen", True)
audio_list.append(
_save_audio(data.get_data("_audio|gen", values), data,
config))
if item["type"] == "file":
audio_list.append(resources.get_audio_path(item["path"]))
values[key] = _audios_to_audio(audio_list, data)
def sort(values: dict, data: StepData):
"""Sortiert Wörter nach dem Alphabet oder Zahlen aufsteigend.
Ist reverse auf True gesetzt, werden die Wörter zu Z nach A sortiert, bzw. Zahlen absteigend.
Achtung: Sortierung von A nach Z
["Argentina", "Canada", "Cyprus", "Germany", "Norway", "Schweden", "USA", "United Kingdom", "Z"]
"USA" ist vor "United Kingdom", weil bei "USA" der zweite Buchstabe auch groß geschrieben ist.
Würde dort "Usa" statt "USA" stehen, wäre "United Kingdom" vor "USA".
:param values: Werte aus der JSON-Datei
:param data: Daten aus der API
:return:
"""
for idx, key in data.loop_key(values["keys"], values):
new_key = get_new_keys(values, idx)
value = data.get_data(key, values)
reverse = data.get_data(values.get("reverse", False), values, bool)
new_value = sorted(value, reverse=reverse)
data.insert_data(new_key, new_value, values)
def length(values: dict, data: StepData):
"""Gibt die Länge von Arrays (Listen), Strings, Tupeln und Dictionaries aus.
: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)
data.insert_data(new_key, len(value), values)
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 to_dict(values: dict, data: StepData):
"""Wandelt eine Liste aus Tupeln oder Arrays in ein Dictionary um.
: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)
new_value = dict(value)
data.insert_data(new_key, new_value, values)
def seperator(values: dict, data: StepData):
"""Fügt Trennzeichen in einen Integer hinzu.
:param values: Werte aus der JSON-Datei
:param data: Daten aus der API
"""
for idx, key in data.loop_key(values["keys"], values):
value = int(data.get_data(key, values))
new_key = get_new_keys(values, idx)
new_value = '{:,}'.format(value).replace(
',', data.format(values["seperator"], values))
data.insert_data(new_key, new_value, values)
def convert(values: dict, data: StepData):
"""Konvertiert ein Datentyp in einen anderen Datentyp.
:param values: Werte aus der JSON-Datei
:param data: Daten aus der API
:return:
"""
new_type = locate(values["to"])
for idx, key in data.loop_key(values["keys"], values):
new_key = get_new_keys(values, idx)
value = new_type(data.get_data(key, values))
data.insert_data(new_key, value, values)
def capitalize(values: dict, data: StepData):
"""Der erste Buchstabe jedes Worts in der Liste wird groß geschrieben.
: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)
new_value = [each.capitalize() for each in value]
data.insert_data(new_key, new_value, values)
def timestamp(values: dict, data: StepData):
"""Wandelt einen UNIX-Zeitstempel in ein anderes Format um.
Wandelt einen UNIX-Zeitstempel in ein anderes Format um, welches unter `"format"` angegeben wird. Ist zeropaded_off
true, so wird aus z.B. 05 eine 5.
:param values: Werte aus der JSON-Datei
:param data: Daten aus der API
"""
for idx, key in data.loop_key(values["keys"], values):
value = data.get_data(key, values)
date = datetime.fromtimestamp(value)
new_key = get_new_keys(values, idx)
zeropaded_off = data.get_data(values.get("zeropaded_off", False),
values, bool)
if zeropaded_off:
new_value = date.strftime(data.format(values["format"],
values)).lstrip("0").replace(
" 0", " ")
else:
new_value = date.strftime(data.format(values["format"], values))
data.insert_data(new_key, new_value, values)
def upper_case(values: dict, data: StepData):
"""Jedes Wort in der Liste wird komplett in Großbuchstaben geschrieben.
: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)
new_value = [each.upper() for each in value]
data.insert_data(new_key, new_value, values)
def date_format(values: dict, data: StepData):
"""Ändert das Format des Datums und der Uhrzeit.
Ändert das Format des Datums und der Uhrzeit, welches unter `"given_format"` angegeben wird, in ein gewünschtes
anderes Format, welches unter `"format"` angegeben wird.
:param values: Werte aus der JSON-Datei
:param data: Daten aus der API
"""
for idx, key in data.loop_key(values["keys"], values):
value = data.get_data(key, values)
given_format = data.format(values["given_format"], values)
date = datetime.strptime(value, given_format).date()
new_key = get_new_keys(values, idx)
zeropaded_off = data.get_data(values.get("zeropaded_off", False),
values, bool)
if zeropaded_off:
new_value = date.strftime(data.format(values["format"],
values)).lstrip("0").replace(
" 0", " ")
else:
new_value = date.strftime(data.format(values["format"], values))
data.insert_data(new_key, new_value, values)
def _text_to_audio(data: StepData, values: dict, text: str, config: dict):
sub_pairs = data.deep_format(config.get("sub_pairs", None), values=values)
if sub_pairs:
for key in sub_pairs:
value = data.get_data(key, values)
gtts.tokenizer.symbols.SUB_PAIRS.append((key, value))
tts = gTTS(data.format(text, values), lang=data.format(config["lang"]))
file_path = resources.new_temp_resource_path(data.data["_pipe_id"],
data.format(config["format"]))
tts.save(file_path)
return file_path
def _build_params_array(values: dict, data: StepData, api_key_name: str,
req: dict):
if req["params"] is None:
req["params"] = {}
for params in values["params_array"]:
params_array = data.get_data(params["array"], values, list)
data.deep_format(params_array, api_key_name, values)
param = "".join([
f"{data.format(params['pattern'], values)}{data.format(params.get('delimiter', ''), values)}"
for _ in data.loop_array(params_array, values)
])
req["params"][params["key"]] = param[:-1]
def calculate_min(values: dict, data: StepData):
"""Findet den Minimalwert von Werten, die in einem Array stehen.
:param values: Werte aus der JSON-Datei
:param data: Daten aus der API
"""
for idx, key in data.loop_key(values["keys"], values):
value = data.get_data(key, values)
new_key = get_new_keys(values, idx)
new_value = min(value)
data.insert_data(new_key, new_value, values)
if values.get("save_idx_to", None):
data.insert_data(values["save_idx_to"][idx],
value.index(new_value), values)
def join(values: dict, data: StepData):
"""Fügt Elemente einer Liste zu einem String zusammen mit jeweils einem Delimiter dazwischen.
: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)
delimiter = data.format(values.get("delimiter", ""), values)
new_value = delimiter.join(value)
data.insert_data(new_key, new_value, values)
def random_value(values: dict, data: StepData):
"""Wählt random einen Wert aus einem Array oder einem Dictionary (zu einem bestimmten Key) aus.
:param values: Werte aus der JSON-Datei
:param data: Daten aus der API
"""
if "array" in values:
for key in values["new_keys"]:
array = data.get_data(values["array"], values, list)
length = len(array)
rand = randint(0, length - 1)
new_value = data.format(array[rand], values)
data.insert_data(key, new_value, values)
elif "dict" in values:
for idx, key in data.loop_key(values["keys"], values):
new_key = get_new_keys(values, idx)
new_values = data.get_data(values.get("dict", None), values, dict)
value = str(data.get_data(key, values))
length = len(new_values[value])
rand = randint(0, length - 1)
new_value = data.format(new_values[value][rand], values)
data.insert_data(new_key, new_value, values)
