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 default(values: dict, data: StepData, config: dict):
"""Generiert eine Audiodatei mit der Python-Bibliothek gTTS.
Wenn in der Konfiguration `sub_pairs` angegeben sind, werden diese den bisherigen `sub_pairs` hinzugefügt.
`sub_pairs` sind bestimmte Wörter, die im Text ersetzt werden sollen.
Beispiel: "z.B." soll vorgelesen werden als "zum Beispiel".
:param values: Werte aus der JSON-Datei
:param data: Daten aus der API
:param config: Daten aus der Konfigurationsdatei
:return:
"""
for key in values:
text = part.audio_parts(values[key]["parts"], data)
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(text, lang=data.format(config["lang"]))
file_path = resources.new_temp_resource_path(data.data["_pipe_id"], data.format(config["format"]))
tts.save(file_path)
values[key] = file_path
def add_data(values: dict, data: StepData):
"""Fügt Daten zu einem neuen Key hinzu.
Fügt die unter `"data"` angegebenen Daten zu einem neuen Key hinzu.
:param values: Werte aus der JSON-Datei
:param data: Daten aus der API
"""
for new_key in values["new_keys"]:
value = data.deep_format(values["data"], values=values)
data.insert_data(new_key, value, values)
def _create_query(values: dict, data: StepData):
req = {}
api_key_name = values.get("api_key_name", None)
# Get/Format method and headers
req["method"] = data.format(values.get("method", "get"))
req["headers"] = data.deep_format(values.get("headers", None),
api_key_name, values)
# Get/Format body data
req["body_type"] = data.format(values.get("body_type", "json"), values)
if req["body_type"].__eq__("json"):
req["json"] = data.deep_format(values.get("body", None), api_key_name,
values)
else:
req["other"] = data.format(
values["body"]) if "body" in values else None
if values.get("body_encoding", None) is not None:
req[req["body_type"]] = req[req["body_type"]].encode(
values["body_encoding"])
# Get/Format url
req["url"] = data.format_api(values["url_pattern"], api_key_name, values)
# Get/Format params
req["params"] = data.deep_format(values.get("params", None), api_key_name,
values)
if values.get("params_array", None) is not None:
_build_params_array(values, data, api_key_name, req)
# Get/Format response, format
req["res_format"] = data.format(values.get("response_format", "json"))
# TODO use Format
req["xml_config"] = data.deep_format(values.get("xml_config", {}),
values=values)
req["include_headers"] = data.get_data(
values.get("include_headers", False), values, bool)
return req
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 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 input(values: dict,
data: StepData,
name: str,
save_key,
ignore_testing=False):
"""Hier können Daten angegeben werden, die einfach hinzugefügt werden.
:param values: Werte aus der JSON-Datei
:param data: Daten aus der API
:param name: Testdatei, die geladen werden soll.
:param save_key: Key, unter dem die Daten gespeichert werden.
:param ignore_testing: Ob der Request durchgeführt werden soll, obwohl testing `true` ist.
"""
res = data.deep_format(values["data"], values=values)
data.insert_data(save_key, res, 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)
