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 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 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 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 _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 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 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 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 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 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 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 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 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 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 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 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 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 regex(values: dict, data: StepData):
"""Führt `"re.sub"` für die angegebenen Felder aus.
regex (suche nach dieser Expression, replace_by (ersetze Expression durch), value (String in dem ersetzt werden soll)
Geht nur für regex ohne backslash \
: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)
regex = data.format(values["regex"], values)
find = fr"{regex}"
replace_by = data.format(values["replace_by"], values)
new_value = re.sub(find, replace_by, value)
data.insert_data(new_key, new_value, values)
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 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 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 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 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)
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)
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 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)
