def _bi_calculate(values: dict, data: StepData, op):
keys_right = values.get("keys_right", None)
value_right = values.get("value_right", None)
value_left = values.get("value_left", None)
decimal = values.get("decimal", None)
# TODO (max) May solve loop two key arrays better to support key, key1
for idx, key in data.loop_key(values["keys"], values):
key = data.get_data(key, values)
new_key = get_new_keys(values, idx)
if keys_right is not None:
# If keys_right is present use that key
right = data.get_data(keys_right[idx], values)
res = op(key, right)
elif value_right is not None:
# If value_right is present use that value
right = data.get_data(value_right, values, numbers.Number)
res = op(key, right)
else:
# If value_left is present use that value
left = data.get_data(value_left, values, numbers.Number)
res = op(left, key)
if decimal is not None:
# If decimal is present round
decimal = data.get_data(decimal, values, numbers.Number)
res = round(res, decimal)
data.insert_data(new_key, res, values)
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 normalize_words(values: dict, data: StepData):
"""Wörter, die öfter vorkommen und unterschiedliche cases besitzen, werden normalisiert.
Eine Liste wird durchlaufen und jedes Wort welches bei zweiten Vorkommen anders geschrieben wurde als das erste
vorgekommene wird dann so ersetzt, dass es so geschrieben wird wie das zuerst vorgekommene. Z.B. Bundesliga und
bundesliga. Aus bundesliga wird Bundesliga.
: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)
already_there = []
new_value = []
for each in value:
if each.upper() in already_there:
new_value.append(each.upper())
elif each.lower() in already_there:
new_value.append(each.lower())
elif each.capitalize() in already_there:
new_value.append(each.capitalize())
else:
already_there.append(each)
new_value.append(each)
data.insert_data(new_key, new_value, values)
def calculate_sum(values: dict, data: StepData):
"""Findet die Summe 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)
inner_key = values.get("innerKey", None)
if inner_key:
value = [
reduce(operator.getitem, inner_key[0].split('|'), x)
for x in value
]
new_key = get_new_keys(values, idx)
new_value = sum(value)
if values.get("decimal", None):
new_value = round(
new_value,
data.get_data(values["decimal"], values, numbers.Number))
else:
new_value = round(new_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 request_memory(values: dict,
data: StepData,
name: str,
save_key,
ignore_testing=False):
"""Ließt Daten aus einer memory-Datei (JSON-Format) zu einem bestimmtem Datum.
: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.
"""
try:
if values.get("timedelta", None) is None:
with resources.open_specific_memory_resource(
data.get_config("job_name"), values["name"],
values.get("use_last", 1)) as fp:
data.insert_data(save_key, json.loads(fp.read()), values)
else:
with resources.open_memory_resource(data.get_config("job_name"),
values["name"],
values["timedelta"]) as fp:
data.insert_data(save_key, json.loads(fp.read()), values)
except (FileNotFoundError, IndexError):
api_request(values["alternative"], data, name, save_key,
ignore_testing)
def _load_test_data(values: dict, data: StepData, name, save_key):
logger.info(f"Loading test data from 'exampledata/{name}.json'")
try:
with resources.open_resource(f"exampledata/{name}.json") as fp:
data.insert_data(save_key, json.loads(fp.read()), values)
except IOError as e:
raise TestDataError(name) from e
def request_multiple_custom(values: dict,
data: StepData,
name: str,
save_key,
ignore_testing=False):
"""Fragt unterschiedliche Daten einer API ab.
: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.
"""
if data.get_config("testing", False) and not ignore_testing:
return _load_test_data(values, data, name, save_key)
if values.get("use_loop_as_key", False):
data.insert_data(save_key, {}, values)
for idx, key in enumerate(values["steps_value"]):
api_request(values["requests"][idx], data, name,
f"{save_key}|{key}", ignore_testing)
else:
data.insert_data(save_key, [None] * len(values["requests"]), values)
for idx, value in enumerate(values["requests"]):
api_request(value, data, name, f"{save_key}|{idx}", ignore_testing)
def request_multiple(values: dict,
data: StepData,
name: str,
save_key,
ignore_testing=False):
"""Fragt für einen variablen Key, mehrere Male gewünschte Daten einer API ab.
: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.
"""
if data.get_config("testing", False) and not ignore_testing:
return _load_test_data(values, data, name, save_key)
if data.get_data(values.get("use_loop_as_key", False), values, bool):
data.insert_data(save_key, {}, values)
for _, key in data.loop_array(values["steps_value"], values):
_fetch(values, data, f"{save_key}|{key}")
else:
data.insert_data(save_key, [None] * len(values["steps_value"]), values)
for idx, _ in data.loop_array(values["steps_value"], values):
_fetch(
values,
data,
f"{save_key}|{idx}",
)
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 prepare_overlay_test(values, data, config=None):
if config is None:
config = {}
values = {
"images": {
"testbild": {
"type": "pillow",
"path": "Test_Bild_1.png",
"overlay": [values]
}
},
"presets": {
"test_preset": {
"color": "black",
"font_size": 20,
"font": "Test_Font.ttf"
},
}
}
step_data = StepData(config, "0", 0, values.get("presets", None))
step_data.insert_data("_req", {"_test": data}, {})
step_data.data["_pipe_id"] = "100"
generate_all_images(values, step_data)
return values["images"]["testbild"]
def _bi_calculate(values: dict, data: StepData, op):
keys_right = values.get("keys_right", None)
value_right = values.get("value_right", None)
value_left = values.get("value_left", None)
decimal = values.get("decimal", None)
# TODO (max) May solve loop two key arrays better to support key, key1
# TODO remove else part and change unittests
if values["keys"][0] == "_req":
for idx, key in data.loop_key(values["keys"], values):
if not value_left:
value_left = data.get_data(key, values)
new_key = get_new_keys(values, idx)
if keys_right:
# If keys_right is present use that key
right = data.get_data(keys_right[idx], values)
res = op(value_left, right)
else:
# If value_right is present use that value
if not value_right:
right = data.get_data(key, values)
else:
right = data.get_data(value_right, values, numbers.Number)
res = op(value_left, right)
if decimal:
# If decimal is present round
decimal = data.get_data(decimal, values, numbers.Number)
res = round(res, decimal)
if decimal == 0:
res = int(res)
data.insert_data(new_key, res, values)
else:
for idx, key in data.loop_key(values["keys"], values):
key = data.get_data(key, values)
new_key = get_new_keys(values, idx)
if keys_right is not None:
# If keys_right is present use that key
right = data.get_data(keys_right[idx], values)
res = op(key, right)
elif value_right is not None:
# If value_right is present use that value
right = data.get_data(value_right, values, numbers.Number)
res = op(key, right)
else:
# If value_left is present use that value
left = data.get_data(value_left, values, numbers.Number)
res = op(left, key)
if decimal:
# If decimal is present round
decimal = data.get_data(decimal, values, numbers.Number)
res = round(res, decimal)
if decimal == 0:
res = int(res)
data.insert_data(new_key, res, 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 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 _get_audio_config(values: dict, data: StepData):
config = get_config()["audio"]
custom_config = values["audio"].get("config", {})
# if config in step-JSON is present, use that config
config.update(custom_config)
# init _audio with audio config
data.insert_data("_audio|_conf", config, {})
return config
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 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 select_range(values: dict, data: StepData):
"""Entfernt alle Werte aus `"array_key"`, die nicht in `"range"` sind.
:param values: Werte aus der JSON-Datei
:param data: Daten aus der API
"""
value_array = data.get_data(values["array_key"], values)
range_start = data.get_data(values.get("range_start", 0), values, int)
range_end = data.get_data(values["range_end"], values, int)
data.insert_data(values["array_key"], value_array[range_start:range_end],
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 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 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 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 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 translate(values: dict, data: StepData):
"""Setzt den Wert eines Keys zu einem neuen Key als Wert für die JSON.
: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)
translation = data.get_data(values["dict"], values, dict)
new_value = data.format(translation[value], values)
data.insert_data(new_key, new_value, values)
def alias(values: dict, data: StepData):
"""Erstzt einen Key durch einen neuen Key.
:param values: Werte aus der JSON-Datei
:param data: Daten aus der API
"""
for key, new_key in zip(values["keys"], values["new_keys"]):
value = data.get_data(key, values)
new_key = data.format(new_key, values)
data.insert_data(new_key, value, values)
if not data.get_data(values.get("keep_old", False), {}, bool):
data.remove_data(key, values)
def prepare_test(values: list, data, expected_data: dict, config=None):
if config is None:
config = {}
step_data = StepData(config, "0", 0)
step_data.insert_data("_req", data, {})
transform({"transform": values}, step_data)
# removed Temporary set data
step_data.data.pop("_conf")
step_data.data.pop("_pipe_id")
step_data.data.pop("_job_id")
return step_data.data, expected_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))
data.insert_data(new_key, 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 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 add_symbol(values: dict, data: StepData):
"""Fügt ein Zeichen, Symbol, Wort oder einen Satz zu einem Wert hinzu.
Fügt ein Zeichen, Symbol, Wort oder einen Satz zu einem Wert hinzu. Dieses kann sowohl vor als auch hinter dem Wert
stehen, der mit `"{_key}"` eingefügt wird. Außerdem kann man so einen Wert kopieren und einem neuen Key zuweisen, wenn
man in unter `"pattern"` nur `"{_key}"` einsetzt.
: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_values = data.format(values['pattern'], values)
data.insert_data(new_key, new_values, values)
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)
