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)