identifier
stringlengths 0
89
| parameters
stringlengths 0
399
| return_statement
stringlengths 0
982
⌀ | docstring
stringlengths 10
3.04k
| docstring_summary
stringlengths 0
3.04k
| function
stringlengths 13
25.8k
| function_tokens
sequence | start_point
sequence | end_point
sequence | argument_list
null | language
stringclasses 3
values | docstring_language
stringclasses 4
values | docstring_language_predictions
stringclasses 4
values | is_langid_reliable
stringclasses 2
values | is_langid_extra_reliable
bool 1
class | type
stringclasses 9
values |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
tensorflow_detection_tf2 | (value_threshold, dict_images, num_classes, vectores_interes,
categories, max_width_crop, max_height_crop, detect_fn) | return detection_result | Función para realizar la detección en imágenes con tensorflow.
Parameters
----------
value_threshold: str
Valor umbral para detectar un objeto entre 0 y 1
dict_images: dict
Diccionario con las imágenes y sus códigos
num_classes: int
Número de clases posibles a ser detectadas
vectores_interes: list
Lista con los vectores de interés que serán retornados en la detección
categories: list
Clases posibles a ser detectadas
max_width_crop: int
Valor máximo de ancho para realizar el crop, mayor que 0
max_height_crop: int
Valor máximo de alto para realizar el crop, mayor que 0
detect_fn: function
Función de detección del modelo
Returns
-------
list
Lista de listas con vectores detectados por cada imagen en la que se ha realizado detección
| Función para realizar la detección en imágenes con tensorflow. | def tensorflow_detection_tf2(value_threshold, dict_images, num_classes, vectores_interes,
categories, max_width_crop, max_height_crop, detect_fn):
"""Función para realizar la detección en imágenes con tensorflow.
Parameters
----------
value_threshold: str
Valor umbral para detectar un objeto entre 0 y 1
dict_images: dict
Diccionario con las imágenes y sus códigos
num_classes: int
Número de clases posibles a ser detectadas
vectores_interes: list
Lista con los vectores de interés que serán retornados en la detección
categories: list
Clases posibles a ser detectadas
max_width_crop: int
Valor máximo de ancho para realizar el crop, mayor que 0
max_height_crop: int
Valor máximo de alto para realizar el crop, mayor que 0
detect_fn: function
Función de detección del modelo
Returns
-------
list
Lista de listas con vectores detectados por cada imagen en la que se ha realizado detección
"""
# Abrimos el grafo de detección
detection_result = []
value_threshold = float(value_threshold)
for contador_imagen, image in dict_images.items():
# En obtenemos los atributos de la imagen
if type(dict_images) == dict: # Imágenes
image_code = str(contador_imagen)
image = dict_images[str(contador_imagen)]
(width, height) = image.size
#print("DEBUG: detectando imagen " + str(contador_imagen) + '/' + str(len(dict_images.keys())))
# Preparamos las variables a usar
num_rows = int(width / (max_width_crop / 2))
num_cols = int(height / (max_height_crop / 2))
if num_cols == 0:
num_cols = 1
if num_rows == 0:
num_rows = 1
crop_x = 0
crop_y = 0
objects_detected = []
objects_detected_dict = {}
clases_detected = []
# Realizamos la detección por crop
for row in range(num_rows):
# Ajustamos las imágenes de crop para que tengan las mismas dimensiones
last_crop_x = crop_x
for col in range(num_cols):
#print("DEBUG: detectando crop row-col", row + 1, col + 1, "de", num_rows, num_cols)
# Ajustamos hasta donde se va a cortar la imagen
top_crop_x = crop_x + max_width_crop
top_crop_y = crop_y + max_height_crop
# Nos aseguramos de que no se vaya a recortar más de las dimensiones de las imágenes
if top_crop_x > width:
top_crop_x = width
if top_crop_y > height:
top_crop_y = height
# Ajustamos las imágenes de crop para que tengan las mismas dimensiones
last_crop_y = crop_y
if max_width_crop > top_crop_x - crop_x:
crop_x = top_crop_x - max_width_crop
if max_height_crop > top_crop_y - crop_y:
crop_y = top_crop_y - max_height_crop
# Obtenemos la imagen cropeada y la detectamos
crop_image = image.crop((crop_x, crop_y, top_crop_x, top_crop_y))
(crop_width, crop_height) = crop_image.size
# image_np = np.array(crop_image.getdata()).reshape((crop_height, crop_width, 3)).astype(np.uint8)
image_np = np.array(crop_image).astype(np.uint8)
input_tensor = tf.convert_to_tensor(np.expand_dims(image_np, 0), dtype=tf.float32)
init_time_det = time.time()
detections, predictions_dict, shapes = detect_fn(input_tensor)
#print("DEBUG: Tiempo solo de deteccion:", time.time() - init_time_det)
label_id_offset = 1
# Una vez detectado el crop, sacamos los objetos que se han detectado para guardarlos
x_height, x_width, channels = image_np.shape
for i in range((np.squeeze(detections['detection_boxes'][0].numpy())).shape[0]):
if (np.squeeze(detections['detection_scores'][0].numpy())[i]) > value_threshold:
nombre_clase = np.squeeze((detections['detection_classes'][0].numpy() +
label_id_offset).astype(int)).astype(np.int32)[i] - 1
if nombre_clase <= num_classes:
for elem_list in categories:
if elem_list['id'] == (nombre_clase + 1):
name_class = elem_list['name']
class_id = (nombre_clase + 1)
# Incluir solo los vectores de interés en la predicción
if name_class in vectores_interes:
x_min = int(np.squeeze(detections['detection_boxes'][0].numpy())[i][1] * x_width)
x_max = int(np.squeeze(detections['detection_boxes'][0].numpy())[i][3] * x_width)
y_min = int(np.squeeze(detections['detection_boxes'][0].numpy())[i][0] * x_height)
y_max = int(np.squeeze(detections['detection_boxes'][0].numpy())[i][2] * x_height)
final_string = str(x_min + crop_x) + '_' + str(y_min + crop_y) + '_' + \
str(x_max + crop_x) + '_' + str(y_max + crop_y) + '_' + \
str(np.squeeze(detections['detection_scores'][0].numpy())[i]) + '_' + \
str(class_id)
if name_class in objects_detected_dict:
if final_string in objects_detected_dict[name_class]:
pass
else:
aux_list = objects_detected_dict[name_class]
aux_list.append(final_string)
objects_detected_dict[name_class] = aux_list
else:
objects_detected_dict[name_class] = [final_string]
clases_detected.append(np.squeeze(
(detections['detection_classes'][0].numpy() + label_id_offset).astype(int)).astype(
np.int32)[i])
else:
print("DEBUG: Detectada clase de no interes:", name_class)
# Actualizamos el siguiente crop a realizar para la misma fila
crop_y = last_crop_y + int(max_height_crop / 2)
# Actualizamos el siguiente crop a realizar avanzando de fila
crop_x = last_crop_x + int(max_width_crop / 2)
crop_y = 0
# Montamos los datos para la imagen final con los bounding box
final_box = ""
final_scores = ""
final_clases = ""
count_objet = 0
for name_class in objects_detected_dict:
for obj in objects_detected_dict[name_class]:
split_obj = obj.split('_')
nuevo_objeto = [name_class, int(split_obj[0]), int(split_obj[1]), int(split_obj[2]), int(split_obj[3]),
split_obj[4], split_obj[5]]
objects_detected.append(nuevo_objeto)
for object in objects_detected:
aux_box = np.array([[object[2] / height, object[1] / width, object[4] / height, object[3] / width]])
aux_scores = np.array([float(object[5])])
aux_classes = np.array([clases_detected[count_objet]])
if type(final_box) == type(aux_box):
final_box = np.append(final_box, aux_box, axis=0)
final_scores = np.append(final_scores, aux_scores, axis=0)
final_clases = np.append(final_clases, aux_classes, axis=0)
else:
final_box = aux_box
final_scores = aux_scores
final_clases = aux_classes
count_objet += 1
# Preparamos los metadatos para devolverlos
detection_result = {
"Id_imagen": image_code,
"objects_detected": [],
"class_names": []
}
for object_detected in objects_detected:
detection_result["objects_detected"].append([int(object_detected[1]), int(object_detected[2]),
int(object_detected[3]), int(object_detected[4]), float(object_detected[5]), int(object_detected[6])])
detection_result["class_names"].append(object_detected[0])
detection_result["objects_detected"] = np.array(detection_result["objects_detected"])
return detection_result | [
"def",
"tensorflow_detection_tf2",
"(",
"value_threshold",
",",
"dict_images",
",",
"num_classes",
",",
"vectores_interes",
",",
"categories",
",",
"max_width_crop",
",",
"max_height_crop",
",",
"detect_fn",
")",
":",
"# Abrimos el grafo de detección",
"detection_result",
"=",
"[",
"]",
"value_threshold",
"=",
"float",
"(",
"value_threshold",
")",
"for",
"contador_imagen",
",",
"image",
"in",
"dict_images",
".",
"items",
"(",
")",
":",
"# En obtenemos los atributos de la imagen",
"if",
"type",
"(",
"dict_images",
")",
"==",
"dict",
":",
"# Imágenes",
"image_code",
"=",
"str",
"(",
"contador_imagen",
")",
"image",
"=",
"dict_images",
"[",
"str",
"(",
"contador_imagen",
")",
"]",
"(",
"width",
",",
"height",
")",
"=",
"image",
".",
"size",
"#print(\"DEBUG: detectando imagen \" + str(contador_imagen) + '/' + str(len(dict_images.keys())))",
"# Preparamos las variables a usar",
"num_rows",
"=",
"int",
"(",
"width",
"/",
"(",
"max_width_crop",
"/",
"2",
")",
")",
"num_cols",
"=",
"int",
"(",
"height",
"/",
"(",
"max_height_crop",
"/",
"2",
")",
")",
"if",
"num_cols",
"==",
"0",
":",
"num_cols",
"=",
"1",
"if",
"num_rows",
"==",
"0",
":",
"num_rows",
"=",
"1",
"crop_x",
"=",
"0",
"crop_y",
"=",
"0",
"objects_detected",
"=",
"[",
"]",
"objects_detected_dict",
"=",
"{",
"}",
"clases_detected",
"=",
"[",
"]",
"# Realizamos la detección por crop",
"for",
"row",
"in",
"range",
"(",
"num_rows",
")",
":",
"# Ajustamos las imágenes de crop para que tengan las mismas dimensiones",
"last_crop_x",
"=",
"crop_x",
"for",
"col",
"in",
"range",
"(",
"num_cols",
")",
":",
"#print(\"DEBUG: detectando crop row-col\", row + 1, col + 1, \"de\", num_rows, num_cols)",
"# Ajustamos hasta donde se va a cortar la imagen",
"top_crop_x",
"=",
"crop_x",
"+",
"max_width_crop",
"top_crop_y",
"=",
"crop_y",
"+",
"max_height_crop",
"# Nos aseguramos de que no se vaya a recortar más de las dimensiones de las imágenes",
"if",
"top_crop_x",
">",
"width",
":",
"top_crop_x",
"=",
"width",
"if",
"top_crop_y",
">",
"height",
":",
"top_crop_y",
"=",
"height",
"# Ajustamos las imágenes de crop para que tengan las mismas dimensiones",
"last_crop_y",
"=",
"crop_y",
"if",
"max_width_crop",
">",
"top_crop_x",
"-",
"crop_x",
":",
"crop_x",
"=",
"top_crop_x",
"-",
"max_width_crop",
"if",
"max_height_crop",
">",
"top_crop_y",
"-",
"crop_y",
":",
"crop_y",
"=",
"top_crop_y",
"-",
"max_height_crop",
"# Obtenemos la imagen cropeada y la detectamos",
"crop_image",
"=",
"image",
".",
"crop",
"(",
"(",
"crop_x",
",",
"crop_y",
",",
"top_crop_x",
",",
"top_crop_y",
")",
")",
"(",
"crop_width",
",",
"crop_height",
")",
"=",
"crop_image",
".",
"size",
"# image_np = np.array(crop_image.getdata()).reshape((crop_height, crop_width, 3)).astype(np.uint8)",
"image_np",
"=",
"np",
".",
"array",
"(",
"crop_image",
")",
".",
"astype",
"(",
"np",
".",
"uint8",
")",
"input_tensor",
"=",
"tf",
".",
"convert_to_tensor",
"(",
"np",
".",
"expand_dims",
"(",
"image_np",
",",
"0",
")",
",",
"dtype",
"=",
"tf",
".",
"float32",
")",
"init_time_det",
"=",
"time",
".",
"time",
"(",
")",
"detections",
",",
"predictions_dict",
",",
"shapes",
"=",
"detect_fn",
"(",
"input_tensor",
")",
"#print(\"DEBUG: Tiempo solo de deteccion:\", time.time() - init_time_det)",
"label_id_offset",
"=",
"1",
"# Una vez detectado el crop, sacamos los objetos que se han detectado para guardarlos",
"x_height",
",",
"x_width",
",",
"channels",
"=",
"image_np",
".",
"shape",
"for",
"i",
"in",
"range",
"(",
"(",
"np",
".",
"squeeze",
"(",
"detections",
"[",
"'detection_boxes'",
"]",
"[",
"0",
"]",
".",
"numpy",
"(",
")",
")",
")",
".",
"shape",
"[",
"0",
"]",
")",
":",
"if",
"(",
"np",
".",
"squeeze",
"(",
"detections",
"[",
"'detection_scores'",
"]",
"[",
"0",
"]",
".",
"numpy",
"(",
")",
")",
"[",
"i",
"]",
")",
">",
"value_threshold",
":",
"nombre_clase",
"=",
"np",
".",
"squeeze",
"(",
"(",
"detections",
"[",
"'detection_classes'",
"]",
"[",
"0",
"]",
".",
"numpy",
"(",
")",
"+",
"label_id_offset",
")",
".",
"astype",
"(",
"int",
")",
")",
".",
"astype",
"(",
"np",
".",
"int32",
")",
"[",
"i",
"]",
"-",
"1",
"if",
"nombre_clase",
"<=",
"num_classes",
":",
"for",
"elem_list",
"in",
"categories",
":",
"if",
"elem_list",
"[",
"'id'",
"]",
"==",
"(",
"nombre_clase",
"+",
"1",
")",
":",
"name_class",
"=",
"elem_list",
"[",
"'name'",
"]",
"class_id",
"=",
"(",
"nombre_clase",
"+",
"1",
")",
"# Incluir solo los vectores de interés en la predicción",
"if",
"name_class",
"in",
"vectores_interes",
":",
"x_min",
"=",
"int",
"(",
"np",
".",
"squeeze",
"(",
"detections",
"[",
"'detection_boxes'",
"]",
"[",
"0",
"]",
".",
"numpy",
"(",
")",
")",
"[",
"i",
"]",
"[",
"1",
"]",
"*",
"x_width",
")",
"x_max",
"=",
"int",
"(",
"np",
".",
"squeeze",
"(",
"detections",
"[",
"'detection_boxes'",
"]",
"[",
"0",
"]",
".",
"numpy",
"(",
")",
")",
"[",
"i",
"]",
"[",
"3",
"]",
"*",
"x_width",
")",
"y_min",
"=",
"int",
"(",
"np",
".",
"squeeze",
"(",
"detections",
"[",
"'detection_boxes'",
"]",
"[",
"0",
"]",
".",
"numpy",
"(",
")",
")",
"[",
"i",
"]",
"[",
"0",
"]",
"*",
"x_height",
")",
"y_max",
"=",
"int",
"(",
"np",
".",
"squeeze",
"(",
"detections",
"[",
"'detection_boxes'",
"]",
"[",
"0",
"]",
".",
"numpy",
"(",
")",
")",
"[",
"i",
"]",
"[",
"2",
"]",
"*",
"x_height",
")",
"final_string",
"=",
"str",
"(",
"x_min",
"+",
"crop_x",
")",
"+",
"'_'",
"+",
"str",
"(",
"y_min",
"+",
"crop_y",
")",
"+",
"'_'",
"+",
"str",
"(",
"x_max",
"+",
"crop_x",
")",
"+",
"'_'",
"+",
"str",
"(",
"y_max",
"+",
"crop_y",
")",
"+",
"'_'",
"+",
"str",
"(",
"np",
".",
"squeeze",
"(",
"detections",
"[",
"'detection_scores'",
"]",
"[",
"0",
"]",
".",
"numpy",
"(",
")",
")",
"[",
"i",
"]",
")",
"+",
"'_'",
"+",
"str",
"(",
"class_id",
")",
"if",
"name_class",
"in",
"objects_detected_dict",
":",
"if",
"final_string",
"in",
"objects_detected_dict",
"[",
"name_class",
"]",
":",
"pass",
"else",
":",
"aux_list",
"=",
"objects_detected_dict",
"[",
"name_class",
"]",
"aux_list",
".",
"append",
"(",
"final_string",
")",
"objects_detected_dict",
"[",
"name_class",
"]",
"=",
"aux_list",
"else",
":",
"objects_detected_dict",
"[",
"name_class",
"]",
"=",
"[",
"final_string",
"]",
"clases_detected",
".",
"append",
"(",
"np",
".",
"squeeze",
"(",
"(",
"detections",
"[",
"'detection_classes'",
"]",
"[",
"0",
"]",
".",
"numpy",
"(",
")",
"+",
"label_id_offset",
")",
".",
"astype",
"(",
"int",
")",
")",
".",
"astype",
"(",
"np",
".",
"int32",
")",
"[",
"i",
"]",
")",
"else",
":",
"print",
"(",
"\"DEBUG: Detectada clase de no interes:\"",
",",
"name_class",
")",
"# Actualizamos el siguiente crop a realizar para la misma fila",
"crop_y",
"=",
"last_crop_y",
"+",
"int",
"(",
"max_height_crop",
"/",
"2",
")",
"# Actualizamos el siguiente crop a realizar avanzando de fila",
"crop_x",
"=",
"last_crop_x",
"+",
"int",
"(",
"max_width_crop",
"/",
"2",
")",
"crop_y",
"=",
"0",
"# Montamos los datos para la imagen final con los bounding box",
"final_box",
"=",
"\"\"",
"final_scores",
"=",
"\"\"",
"final_clases",
"=",
"\"\"",
"count_objet",
"=",
"0",
"for",
"name_class",
"in",
"objects_detected_dict",
":",
"for",
"obj",
"in",
"objects_detected_dict",
"[",
"name_class",
"]",
":",
"split_obj",
"=",
"obj",
".",
"split",
"(",
"'_'",
")",
"nuevo_objeto",
"=",
"[",
"name_class",
",",
"int",
"(",
"split_obj",
"[",
"0",
"]",
")",
",",
"int",
"(",
"split_obj",
"[",
"1",
"]",
")",
",",
"int",
"(",
"split_obj",
"[",
"2",
"]",
")",
",",
"int",
"(",
"split_obj",
"[",
"3",
"]",
")",
",",
"split_obj",
"[",
"4",
"]",
",",
"split_obj",
"[",
"5",
"]",
"]",
"objects_detected",
".",
"append",
"(",
"nuevo_objeto",
")",
"for",
"object",
"in",
"objects_detected",
":",
"aux_box",
"=",
"np",
".",
"array",
"(",
"[",
"[",
"object",
"[",
"2",
"]",
"/",
"height",
",",
"object",
"[",
"1",
"]",
"/",
"width",
",",
"object",
"[",
"4",
"]",
"/",
"height",
",",
"object",
"[",
"3",
"]",
"/",
"width",
"]",
"]",
")",
"aux_scores",
"=",
"np",
".",
"array",
"(",
"[",
"float",
"(",
"object",
"[",
"5",
"]",
")",
"]",
")",
"aux_classes",
"=",
"np",
".",
"array",
"(",
"[",
"clases_detected",
"[",
"count_objet",
"]",
"]",
")",
"if",
"type",
"(",
"final_box",
")",
"==",
"type",
"(",
"aux_box",
")",
":",
"final_box",
"=",
"np",
".",
"append",
"(",
"final_box",
",",
"aux_box",
",",
"axis",
"=",
"0",
")",
"final_scores",
"=",
"np",
".",
"append",
"(",
"final_scores",
",",
"aux_scores",
",",
"axis",
"=",
"0",
")",
"final_clases",
"=",
"np",
".",
"append",
"(",
"final_clases",
",",
"aux_classes",
",",
"axis",
"=",
"0",
")",
"else",
":",
"final_box",
"=",
"aux_box",
"final_scores",
"=",
"aux_scores",
"final_clases",
"=",
"aux_classes",
"count_objet",
"+=",
"1",
"# Preparamos los metadatos para devolverlos",
"detection_result",
"=",
"{",
"\"Id_imagen\"",
":",
"image_code",
",",
"\"objects_detected\"",
":",
"[",
"]",
",",
"\"class_names\"",
":",
"[",
"]",
"}",
"for",
"object_detected",
"in",
"objects_detected",
":",
"detection_result",
"[",
"\"objects_detected\"",
"]",
".",
"append",
"(",
"[",
"int",
"(",
"object_detected",
"[",
"1",
"]",
")",
",",
"int",
"(",
"object_detected",
"[",
"2",
"]",
")",
",",
"int",
"(",
"object_detected",
"[",
"3",
"]",
")",
",",
"int",
"(",
"object_detected",
"[",
"4",
"]",
")",
",",
"float",
"(",
"object_detected",
"[",
"5",
"]",
")",
",",
"int",
"(",
"object_detected",
"[",
"6",
"]",
")",
"]",
")",
"detection_result",
"[",
"\"class_names\"",
"]",
".",
"append",
"(",
"object_detected",
"[",
"0",
"]",
")",
"detection_result",
"[",
"\"objects_detected\"",
"]",
"=",
"np",
".",
"array",
"(",
"detection_result",
"[",
"\"objects_detected\"",
"]",
")",
"return",
"detection_result"
] | [
66,
0
] | [
234,
27
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
EstimationModel.convert_velocity_from_pixels_frames | (self, velocity: FloatVector2D) | return FloatVector2D(velocity_x, velocity_y) | Convierte el vector de velocidad en píxeles / frames a la unidad especificada al
instanciar la clase.
:param velocity: vector de velocidad en píxeles/frames.
:return: vector de velocidad en la unidad especificada al instanciar la clase.
| Convierte el vector de velocidad en píxeles / frames a la unidad especificada al
instanciar la clase. | def convert_velocity_from_pixels_frames(self, velocity: FloatVector2D) -> FloatVector2D:
"""Convierte el vector de velocidad en píxeles / frames a la unidad especificada al
instanciar la clase.
:param velocity: vector de velocidad en píxeles/frames.
:return: vector de velocidad en la unidad especificada al instanciar la clase.
"""
# Convertir unidad de espacio.
velocity_x, velocity_y = velocity
if self.length_unit == self.LengthUnit.METER:
velocity_x = velocity_x * self.pixel_to_meters.x
velocity_y = velocity_y * self.pixel_to_meters.y
elif self.length_unit == self.LengthUnit.KILOMETER:
velocity_x = velocity_x * self.pixel_to_meters.x / 1000
velocity_y = velocity_y * self.pixel_to_meters.y / 1000
# Convertir la unidad de tiempo.
if self.time_unit == self.TimeUnit.SECOND:
velocity_x = velocity_x * self.frames_per_second
velocity_y = velocity_y * self.frames_per_second
elif self.time_unit == self.TimeUnit.HOUR:
velocity_x = velocity_x * self.frames_per_second * 3600
velocity_y = velocity_y * self.frames_per_second * 3600
# Devolver vector de velocidad.
return FloatVector2D(velocity_x, velocity_y) | [
"def",
"convert_velocity_from_pixels_frames",
"(",
"self",
",",
"velocity",
":",
"FloatVector2D",
")",
"->",
"FloatVector2D",
":",
"# Convertir unidad de espacio.",
"velocity_x",
",",
"velocity_y",
"=",
"velocity",
"if",
"self",
".",
"length_unit",
"==",
"self",
".",
"LengthUnit",
".",
"METER",
":",
"velocity_x",
"=",
"velocity_x",
"*",
"self",
".",
"pixel_to_meters",
".",
"x",
"velocity_y",
"=",
"velocity_y",
"*",
"self",
".",
"pixel_to_meters",
".",
"y",
"elif",
"self",
".",
"length_unit",
"==",
"self",
".",
"LengthUnit",
".",
"KILOMETER",
":",
"velocity_x",
"=",
"velocity_x",
"*",
"self",
".",
"pixel_to_meters",
".",
"x",
"/",
"1000",
"velocity_y",
"=",
"velocity_y",
"*",
"self",
".",
"pixel_to_meters",
".",
"y",
"/",
"1000",
"# Convertir la unidad de tiempo.",
"if",
"self",
".",
"time_unit",
"==",
"self",
".",
"TimeUnit",
".",
"SECOND",
":",
"velocity_x",
"=",
"velocity_x",
"*",
"self",
".",
"frames_per_second",
"velocity_y",
"=",
"velocity_y",
"*",
"self",
".",
"frames_per_second",
"elif",
"self",
".",
"time_unit",
"==",
"self",
".",
"TimeUnit",
".",
"HOUR",
":",
"velocity_x",
"=",
"velocity_x",
"*",
"self",
".",
"frames_per_second",
"*",
"3600",
"velocity_y",
"=",
"velocity_y",
"*",
"self",
".",
"frames_per_second",
"*",
"3600",
"# Devolver vector de velocidad.",
"return",
"FloatVector2D",
"(",
"velocity_x",
",",
"velocity_y",
")"
] | [
230,
4
] | [
253,
52
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
make_file | (timestamp) | return | Método para estructurar el
archivo del informe | Método para estructurar el
archivo del informe | def make_file(timestamp):
'''Método para estructurar el
archivo del informe'''
global first
data=open('%s.txt'%timestamp,'w')
for i in users:
indice=users.index(i)
avg_throu=prom(throughput_list[indice])
avg_delay=prom(delay_list[indice])
dictionary=errors[indice] #dicionario correspondiente a cada usuario
v=list(dictionary.values())
error=sum(v)
if first: #Mensaje de bienvenida si es la primera vez escribiendo el archivo
first=False
data.write(' '.center(67,'*')+'\n\n')
data.write(bienvenida)
horario = 'HORARIO\t%s'%datetime.datetime.fromtimestamp(timestamp)
data.write(horario.center(70,' ')+'\n')
data.write(' '.center(67,'*')+'\n')
data.write('Users\t\t\t\tAvg Throughput(kb/s)\tAvg Delay(s)\n')
data.write('\n'+users[indice]+'\t\t\t%0.2f\t\t\t%0.2f\n\nErrors: %d.\n'%(avg_throu,avg_delay,error))
for key, values in sorted(dictionary.items(),key=itemgetter(1),reverse=True):
data.write(str(key)+':'+str(values)+'\n')
data.write('-'*65)
data.close()
return | [
"def",
"make_file",
"(",
"timestamp",
")",
":",
"global",
"first",
"data",
"=",
"open",
"(",
"'%s.txt'",
"%",
"timestamp",
",",
"'w'",
")",
"for",
"i",
"in",
"users",
":",
"indice",
"=",
"users",
".",
"index",
"(",
"i",
")",
"avg_throu",
"=",
"prom",
"(",
"throughput_list",
"[",
"indice",
"]",
")",
"avg_delay",
"=",
"prom",
"(",
"delay_list",
"[",
"indice",
"]",
")",
"dictionary",
"=",
"errors",
"[",
"indice",
"]",
"#dicionario correspondiente a cada usuario",
"v",
"=",
"list",
"(",
"dictionary",
".",
"values",
"(",
")",
")",
"error",
"=",
"sum",
"(",
"v",
")",
"if",
"first",
":",
"#Mensaje de bienvenida si es la primera vez escribiendo el archivo ",
"first",
"=",
"False",
"data",
".",
"write",
"(",
"' '",
".",
"center",
"(",
"67",
",",
"'*'",
")",
"+",
"'\\n\\n'",
")",
"data",
".",
"write",
"(",
"bienvenida",
")",
"horario",
"=",
"'HORARIO\\t%s'",
"%",
"datetime",
".",
"datetime",
".",
"fromtimestamp",
"(",
"timestamp",
")",
"data",
".",
"write",
"(",
"horario",
".",
"center",
"(",
"70",
",",
"' '",
")",
"+",
"'\\n'",
")",
"data",
".",
"write",
"(",
"' '",
".",
"center",
"(",
"67",
",",
"'*'",
")",
"+",
"'\\n'",
")",
"data",
".",
"write",
"(",
"'Users\\t\\t\\t\\tAvg Throughput(kb/s)\\tAvg Delay(s)\\n'",
")",
"data",
".",
"write",
"(",
"'\\n'",
"+",
"users",
"[",
"indice",
"]",
"+",
"'\\t\\t\\t%0.2f\\t\\t\\t%0.2f\\n\\nErrors: %d.\\n'",
"%",
"(",
"avg_throu",
",",
"avg_delay",
",",
"error",
")",
")",
"for",
"key",
",",
"values",
"in",
"sorted",
"(",
"dictionary",
".",
"items",
"(",
")",
",",
"key",
"=",
"itemgetter",
"(",
"1",
")",
",",
"reverse",
"=",
"True",
")",
":",
"data",
".",
"write",
"(",
"str",
"(",
"key",
")",
"+",
"':'",
"+",
"str",
"(",
"values",
")",
"+",
"'\\n'",
")",
"data",
".",
"write",
"(",
"'-'",
"*",
"65",
")",
"data",
".",
"close",
"(",
")",
"return"
] | [
80,
0
] | [
105,
10
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
p_opcion_from_1_0_0_0_1_0_0_0 | (t) | opcion_from : ID opcion_sobrenombre HAVING expresion_logica | opcion_from : ID opcion_sobrenombre HAVING expresion_logica | def p_opcion_from_1_0_0_0_1_0_0_0(t):
'opcion_from : ID opcion_sobrenombre HAVING expresion_logica' | [
"def",
"p_opcion_from_1_0_0_0_1_0_0_0",
"(",
"t",
")",
":"
] | [
1817,
0
] | [
1818,
66
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
Partner.save | (self, *args, **kwargs) | Funcion para generar el código del socio | Funcion para generar el código del socio | def save(self, *args, **kwargs):
"Funcion para generar el código del socio"
if not self.code:
if self.partner_type != PartnerType.DONJUAN:
if self.partner_type == PartnerType.DIRECTO:
self.code = '{}{}-{}'.format(self.office.country.abbr, self.office.office.number, self.office.consecutive)
self.office.consecutive += 1
self.office.save()
else:
self.code = '{}-{}'.format(self.direct_partner.code, self.direct_partner.consecutive)
self.direct_partner.consecutive += 1
self.direct_partner.save()
else:
self.code = 'PRESIDENT'
super(Partner, self).save(*args, **kwargs) | [
"def",
"save",
"(",
"self",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"if",
"not",
"self",
".",
"code",
":",
"if",
"self",
".",
"partner_type",
"!=",
"PartnerType",
".",
"DONJUAN",
":",
"if",
"self",
".",
"partner_type",
"==",
"PartnerType",
".",
"DIRECTO",
":",
"self",
".",
"code",
"=",
"'{}{}-{}'",
".",
"format",
"(",
"self",
".",
"office",
".",
"country",
".",
"abbr",
",",
"self",
".",
"office",
".",
"office",
".",
"number",
",",
"self",
".",
"office",
".",
"consecutive",
")",
"self",
".",
"office",
".",
"consecutive",
"+=",
"1",
"self",
".",
"office",
".",
"save",
"(",
")",
"else",
":",
"self",
".",
"code",
"=",
"'{}-{}'",
".",
"format",
"(",
"self",
".",
"direct_partner",
".",
"code",
",",
"self",
".",
"direct_partner",
".",
"consecutive",
")",
"self",
".",
"direct_partner",
".",
"consecutive",
"+=",
"1",
"self",
".",
"direct_partner",
".",
"save",
"(",
")",
"else",
":",
"self",
".",
"code",
"=",
"'PRESIDENT'",
"super",
"(",
"Partner",
",",
"self",
")",
".",
"save",
"(",
"*",
"args",
",",
"*",
"*",
"kwargs",
")"
] | [
88,
4
] | [
102,
50
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
parse_home | () | Para extraer los link de las noticias | Para extraer los link de las noticias | def parse_home():
''' Para extraer los link de las noticias'''
# Creamos un bloque try para manejar los errores. Y manejar los Status Code.
try:
response = requests.get(HOME_URL)
# Lógica para traer los links.
if response.status_code == 200:
# .content trae el HTML que necesita ser traducido con un decode para que python lo entienda
# en terminos de caracteres, me devuelve un string que noes más que el HTML crudo.
home = response.content.decode('utf-8')
# En esta línea uso el parser para transformar el contentido
# html a un archivo que sea de utilidad para las expresiones xpath
parsed = html.fromstring(home)
# En esta línea estoy usando el archivo parseado con la función xpath y le paso por parámetro mi constante
# la cual almacena la expresión Xpath.
links_to_notices = parsed.xpath(XPATH_LINK_TO_ARTICLE)
# For debugg
# print(len(links_to_notices))
# print(type(links_to_notices))
# print(links_to_notices)
# Traigo una fecha con la función fecha. Y Today, la fecha del día de hoy. La variable today
# se almacena un objeto de tipo fecha, pero nos interesa más tener una cadena de caracteres que contenga la fecha
# en determinado formato que será guardado en la carpeta y con la función strftime logramos esto
today = datetime.date.today().strftime("%d-%m-%Y")
# Este condicional sirve para decirle que si no existe una carpeta con la fehca del día de hoy
# me cree una carpeta.
if not os.path.isdir(today):
os.mkdir(today)
# Creo la función para recorrer la lista de links y ejecuto en cada ciclo la función parse_notice()
for link in links_to_notices:
parse_notices(link, today)
else:
#Elevamos el error para ser capturado en el try-except, too lo que sea un error.
raise ValueError(f'Error: {response.status_code}')
except ValueError as ve:
print(ve) | [
"def",
"parse_home",
"(",
")",
":",
"# Creamos un bloque try para manejar los errores. Y manejar los Status Code.",
"try",
":",
"response",
"=",
"requests",
".",
"get",
"(",
"HOME_URL",
")",
"# Lógica para traer los links.",
"if",
"response",
".",
"status_code",
"==",
"200",
":",
"# .content trae el HTML que necesita ser traducido con un decode para que python lo entienda",
"# en terminos de caracteres, me devuelve un string que noes más que el HTML crudo.",
"home",
"=",
"response",
".",
"content",
".",
"decode",
"(",
"'utf-8'",
")",
"# En esta línea uso el parser para transformar el contentido",
"# html a un archivo que sea de utilidad para las expresiones xpath",
"parsed",
"=",
"html",
".",
"fromstring",
"(",
"home",
")",
"# En esta línea estoy usando el archivo parseado con la función xpath y le paso por parámetro mi constante",
"# la cual almacena la expresión Xpath.",
"links_to_notices",
"=",
"parsed",
".",
"xpath",
"(",
"XPATH_LINK_TO_ARTICLE",
")",
"# For debugg",
"# print(len(links_to_notices))",
"# print(type(links_to_notices))",
"# print(links_to_notices)",
"# Traigo una fecha con la función fecha. Y Today, la fecha del día de hoy. La variable today",
"# se almacena un objeto de tipo fecha, pero nos interesa más tener una cadena de caracteres que contenga la fecha",
"# en determinado formato que será guardado en la carpeta y con la función strftime logramos esto",
"today",
"=",
"datetime",
".",
"date",
".",
"today",
"(",
")",
".",
"strftime",
"(",
"\"%d-%m-%Y\"",
")",
"# Este condicional sirve para decirle que si no existe una carpeta con la fehca del día de hoy",
"# me cree una carpeta.",
"if",
"not",
"os",
".",
"path",
".",
"isdir",
"(",
"today",
")",
":",
"os",
".",
"mkdir",
"(",
"today",
")",
"# Creo la función para recorrer la lista de links y ejecuto en cada ciclo la función parse_notice()",
"for",
"link",
"in",
"links_to_notices",
":",
"parse_notices",
"(",
"link",
",",
"today",
")",
"else",
":",
"#Elevamos el error para ser capturado en el try-except, too lo que sea un error.",
"raise",
"ValueError",
"(",
"f'Error: {response.status_code}'",
")",
"except",
"ValueError",
"as",
"ve",
":",
"print",
"(",
"ve",
")"
] | [
58,
0
] | [
100,
17
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
s3_cancel | (message: Message, replies: Replies) | Cancela la descarga de tu petición. | Cancela la descarga de tu petición. | def s3_cancel(message: Message, replies: Replies) -> None:
"""Cancela la descarga de tu petición."""
addr = message.get_sender_contact().addr
download = None
for d in list(downloading):
if d.addr == addr:
download = d
if download:
download.abort()
else:
replies.add(
text="❌ No tienes ninguna descarga en curso. Si tienes una petición en la cola, debes esperar a que tu descarga comience para cancelarla",
quote=message,
) | [
"def",
"s3_cancel",
"(",
"message",
":",
"Message",
",",
"replies",
":",
"Replies",
")",
"->",
"None",
":",
"addr",
"=",
"message",
".",
"get_sender_contact",
"(",
")",
".",
"addr",
"download",
"=",
"None",
"for",
"d",
"in",
"list",
"(",
"downloading",
")",
":",
"if",
"d",
".",
"addr",
"==",
"addr",
":",
"download",
"=",
"d",
"if",
"download",
":",
"download",
".",
"abort",
"(",
")",
"else",
":",
"replies",
".",
"add",
"(",
"text",
"=",
"\"❌ No tienes ninguna descarga en curso. Si tienes una petición en la cola, debes esperar a que tu descarga comience para cancelarla\",",
"",
"quote",
"=",
"message",
",",
")"
] | [
232,
0
] | [
245,
9
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
generar_decimales | (min: int, max: int, n: int, r: int = 2) | return [round(uniform(min, max), r) for _ in range(n)] | Genera 'n' números aleatorios entre 'min' y 'max' con 'r'
decimales. Por defecto, 'r' es 2.
:param min: Mínimo valor
:min type: int
:param max: Máximo valor
:max type: int
:param n: Número de números aleatorios
:n type: int
:param r: Número de decimales
:r type: int
:return: Lista con 'n' números aleatorios
:return type: List[float]
| Genera 'n' números aleatorios entre 'min' y 'max' con 'r'
decimales. Por defecto, 'r' es 2. | def generar_decimales(min: int, max: int, n: int, r: int = 2) -> List[float]:
"""Genera 'n' números aleatorios entre 'min' y 'max' con 'r'
decimales. Por defecto, 'r' es 2.
:param min: Mínimo valor
:min type: int
:param max: Máximo valor
:max type: int
:param n: Número de números aleatorios
:n type: int
:param r: Número de decimales
:r type: int
:return: Lista con 'n' números aleatorios
:return type: List[float]
"""
return [round(uniform(min, max), r) for _ in range(n)] | [
"def",
"generar_decimales",
"(",
"min",
":",
"int",
",",
"max",
":",
"int",
",",
"n",
":",
"int",
",",
"r",
":",
"int",
"=",
"2",
")",
"->",
"List",
"[",
"float",
"]",
":",
"return",
"[",
"round",
"(",
"uniform",
"(",
"min",
",",
"max",
")",
",",
"r",
")",
"for",
"_",
"in",
"range",
"(",
"n",
")",
"]"
] | [
17,
0
] | [
32,
58
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
p_opciones_sobrenombre2 | (t) | opciones_sobrenombres : opcion_sobrenombre | opciones_sobrenombres : opcion_sobrenombre | def p_opciones_sobrenombre2(t):
' opciones_sobrenombres : opcion_sobrenombre '
reporte_bnf.append("<opciones_sobrenombres> ::= <opcion_sobrenombre>")
t[0] = [t[1]] | [
"def",
"p_opciones_sobrenombre2",
"(",
"t",
")",
":",
"reporte_bnf",
".",
"append",
"(",
"\"<opciones_sobrenombres> ::= <opcion_sobrenombre>\"",
")",
"t",
"[",
"0",
"]",
"=",
"[",
"t",
"[",
"1",
"]",
"]"
] | [
1780,
0
] | [
1783,
17
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
p_crear | (t) | crear : CREATE reemplazar DATABASE verificacion ID propietario modo
| CREATE TABLE ID PAR_A columnas PAR_C herencia
| CREATE TYPE ID AS ENUM PAR_A lista_exp PAR_C | crear : CREATE reemplazar DATABASE verificacion ID propietario modo
| CREATE TABLE ID PAR_A columnas PAR_C herencia
| CREATE TYPE ID AS ENUM PAR_A lista_exp PAR_C | def p_crear(t):
'''crear : CREATE reemplazar DATABASE verificacion ID propietario modo
| CREATE TABLE ID PAR_A columnas PAR_C herencia
| CREATE TYPE ID AS ENUM PAR_A lista_exp PAR_C''' | [
"def",
"p_crear",
"(",
"t",
")",
":"
] | [
502,
0
] | [
505,
63
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
ModelBase.get_action | (self, action: str, size: str="1rem", fill: str=None) | return item | Obtiene la acción indicada. | Obtiene la acción indicada. | def get_action(self, action: str, size: str="1rem", fill: str=None) -> dict:
"""Obtiene la acción indicada."""
info = {
"create": {
"name": _("Nuevo"),
"icon": icons.svg("plus-circle-fill", size=size,
fill=fill or "var(--bs-success)", on_error=icons.DEFAULT)},
"update": {
"name": _("Modificar"),
"icon": icons.svg("pencil-fill", size=size,
fill=fill or "var(--bs-warning)", on_error=icons.DEFAULT)},
"delete": {
"name": _("Eliminar"),
"icon": icons.svg("x-circle-fill", size=size,
fill=fill or "var(--bs-danger)", on_error=icons.DEFAULT)},
"list": {
"name": _("Lista"),
"icon": icons.svg("card-list", size=size,
fill=fill or "var(--bs-dark)", on_error=icons.DEFAULT)},
"detail": {
"name": _("Detalle"),
"icon": icons.svg("eye-fill", size=size,
fill=fill or "var(--bs-primary)", on_error=icons.DEFAULT)},
}
try:
url = str(getattr(self, f"get_{action}_url")())
except (NoReverseMatch):
return None
item = info[action]
item["url"] = url
return item | [
"def",
"get_action",
"(",
"self",
",",
"action",
":",
"str",
",",
"size",
":",
"str",
"=",
"\"1rem\"",
",",
"fill",
":",
"str",
"=",
"None",
")",
"->",
"dict",
":",
"info",
"=",
"{",
"\"create\"",
":",
"{",
"\"name\"",
":",
"_",
"(",
"\"Nuevo\"",
")",
",",
"\"icon\"",
":",
"icons",
".",
"svg",
"(",
"\"plus-circle-fill\"",
",",
"size",
"=",
"size",
",",
"fill",
"=",
"fill",
"or",
"\"var(--bs-success)\"",
",",
"on_error",
"=",
"icons",
".",
"DEFAULT",
")",
"}",
",",
"\"update\"",
":",
"{",
"\"name\"",
":",
"_",
"(",
"\"Modificar\"",
")",
",",
"\"icon\"",
":",
"icons",
".",
"svg",
"(",
"\"pencil-fill\"",
",",
"size",
"=",
"size",
",",
"fill",
"=",
"fill",
"or",
"\"var(--bs-warning)\"",
",",
"on_error",
"=",
"icons",
".",
"DEFAULT",
")",
"}",
",",
"\"delete\"",
":",
"{",
"\"name\"",
":",
"_",
"(",
"\"Eliminar\"",
")",
",",
"\"icon\"",
":",
"icons",
".",
"svg",
"(",
"\"x-circle-fill\"",
",",
"size",
"=",
"size",
",",
"fill",
"=",
"fill",
"or",
"\"var(--bs-danger)\"",
",",
"on_error",
"=",
"icons",
".",
"DEFAULT",
")",
"}",
",",
"\"list\"",
":",
"{",
"\"name\"",
":",
"_",
"(",
"\"Lista\"",
")",
",",
"\"icon\"",
":",
"icons",
".",
"svg",
"(",
"\"card-list\"",
",",
"size",
"=",
"size",
",",
"fill",
"=",
"fill",
"or",
"\"var(--bs-dark)\"",
",",
"on_error",
"=",
"icons",
".",
"DEFAULT",
")",
"}",
",",
"\"detail\"",
":",
"{",
"\"name\"",
":",
"_",
"(",
"\"Detalle\"",
")",
",",
"\"icon\"",
":",
"icons",
".",
"svg",
"(",
"\"eye-fill\"",
",",
"size",
"=",
"size",
",",
"fill",
"=",
"fill",
"or",
"\"var(--bs-primary)\"",
",",
"on_error",
"=",
"icons",
".",
"DEFAULT",
")",
"}",
",",
"}",
"try",
":",
"url",
"=",
"str",
"(",
"getattr",
"(",
"self",
",",
"f\"get_{action}_url\"",
")",
"(",
")",
")",
"except",
"(",
"NoReverseMatch",
")",
":",
"return",
"None",
"item",
"=",
"info",
"[",
"action",
"]",
"item",
"[",
"\"url\"",
"]",
"=",
"url",
"return",
"item"
] | [
307,
4
] | [
340,
19
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
OptimizedResultsExtractor.get_basic_info | (self, single_rest_result) | return {
"name": name,
"address": address,
"type": found_type,
"cost": cost,
"telephone": telephone,
"url": url
} | Función encargada de extraer la información, como nombre, url y dirección básica de un resultado de local
comercial
Parameters
----------
single_rest_result : WebElement
elemento web del que se extrae la información básica
Returns
-------
dict
diccionario que contiene la información básica del resultado
| Función encargada de extraer la información, como nombre, url y dirección básica de un resultado de local
comercial | def get_basic_info(self, single_rest_result):
"""Función encargada de extraer la información, como nombre, url y dirección básica de un resultado de local
comercial
Parameters
----------
single_rest_result : WebElement
elemento web del que se extrae la información básica
Returns
-------
dict
diccionario que contiene la información básica del resultado
"""
name = single_rest_result.find_element_by_xpath("div[@class='section-result-text-content']//h3/span").text
self.logger.info("-{postal_code}-: place found name: -{name}-".format(postal_code=self._postal_code, name=name))
found_type = single_rest_result.find_element_by_xpath("div[@class='section-result-text-content']//span[contains(@class, 'section-result-details')]").text
cost = single_rest_result.find_element_by_xpath("div[@class='section-result-text-content']//span[contains(@class, 'section-result-cost')]").text
address = single_rest_result.find_element_by_xpath("div[@class='section-result-text-content']//span[contains(@class, 'section-result-location')]").text
telephone = single_rest_result.find_element_by_xpath("div[@class='section-result-text-content']//span[contains(@class, 'section-result-phone-number')]/span").text
"""
if address == "":
url = self._url_place_template.format(postal_code_info=self._postal_code_info, coords=self._coords,
places_types=self._places_types, place_name=name.replace(" ", "+"))
else:
url = self._url_place_template.format(postal_code_info=self._postal_code_info, coords=self._coords,
places_types=address.replace(" ", "+"),
place_name=name.replace(" ", "+"))
"""
url = self._url_place_template.format(postal_code_info=self._postal_code_info, coords=self._coords,
places_types=self._places_types, place_name=name.replace(" ", "+"))
return {
"name": name,
"address": address,
"type": found_type,
"cost": cost,
"telephone": telephone,
"url": url
} | [
"def",
"get_basic_info",
"(",
"self",
",",
"single_rest_result",
")",
":",
"name",
"=",
"single_rest_result",
".",
"find_element_by_xpath",
"(",
"\"div[@class='section-result-text-content']//h3/span\"",
")",
".",
"text",
"self",
".",
"logger",
".",
"info",
"(",
"\"-{postal_code}-: place found name: -{name}-\"",
".",
"format",
"(",
"postal_code",
"=",
"self",
".",
"_postal_code",
",",
"name",
"=",
"name",
")",
")",
"found_type",
"=",
"single_rest_result",
".",
"find_element_by_xpath",
"(",
"\"div[@class='section-result-text-content']//span[contains(@class, 'section-result-details')]\"",
")",
".",
"text",
"cost",
"=",
"single_rest_result",
".",
"find_element_by_xpath",
"(",
"\"div[@class='section-result-text-content']//span[contains(@class, 'section-result-cost')]\"",
")",
".",
"text",
"address",
"=",
"single_rest_result",
".",
"find_element_by_xpath",
"(",
"\"div[@class='section-result-text-content']//span[contains(@class, 'section-result-location')]\"",
")",
".",
"text",
"telephone",
"=",
"single_rest_result",
".",
"find_element_by_xpath",
"(",
"\"div[@class='section-result-text-content']//span[contains(@class, 'section-result-phone-number')]/span\"",
")",
".",
"text",
"\"\"\"\n if address == \"\":\n url = self._url_place_template.format(postal_code_info=self._postal_code_info, coords=self._coords,\n places_types=self._places_types, place_name=name.replace(\" \", \"+\"))\n else:\n url = self._url_place_template.format(postal_code_info=self._postal_code_info, coords=self._coords,\n places_types=address.replace(\" \", \"+\"),\n place_name=name.replace(\" \", \"+\"))\n \"\"\"",
"url",
"=",
"self",
".",
"_url_place_template",
".",
"format",
"(",
"postal_code_info",
"=",
"self",
".",
"_postal_code_info",
",",
"coords",
"=",
"self",
".",
"_coords",
",",
"places_types",
"=",
"self",
".",
"_places_types",
",",
"place_name",
"=",
"name",
".",
"replace",
"(",
"\" \"",
",",
"\"+\"",
")",
")",
"return",
"{",
"\"name\"",
":",
"name",
",",
"\"address\"",
":",
"address",
",",
"\"type\"",
":",
"found_type",
",",
"\"cost\"",
":",
"cost",
",",
"\"telephone\"",
":",
"telephone",
",",
"\"url\"",
":",
"url",
"}"
] | [
84,
4
] | [
124,
9
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
write_report | (model_name, train_size, test_size, accuracy_set, train_time,
hyper) | Escribe el reporte con resultados e hiperparametros
| Escribe el reporte con resultados e hiperparametros
| def write_report(model_name, train_size, test_size, accuracy_set, train_time,
hyper):
"""Escribe el reporte con resultados e hiperparametros
"""
# Header
line = ''
line += model_name + ','
avg_accuracy = sum(accuracy_set) / len(accuracy_set)
line += str(round(avg_accuracy, 4)) + ','
line += f'"{str(accuracy_set)}",'
line += train_time + ','
line += str(hyper['L1']) + ','
line += str(hyper['L2']) + ','
line += str(train_size) + ','
line += str(test_size) + ','
line += str(hyper['max-iter']) + ','
line += str(hyper['k-folds']) + '\n'
with open('results.csv', 'a') as f:
f.write(line) | [
"def",
"write_report",
"(",
"model_name",
",",
"train_size",
",",
"test_size",
",",
"accuracy_set",
",",
"train_time",
",",
"hyper",
")",
":",
"# Header",
"line",
"=",
"''",
"line",
"+=",
"model_name",
"+",
"','",
"avg_accuracy",
"=",
"sum",
"(",
"accuracy_set",
")",
"/",
"len",
"(",
"accuracy_set",
")",
"line",
"+=",
"str",
"(",
"round",
"(",
"avg_accuracy",
",",
"4",
")",
")",
"+",
"','",
"line",
"+=",
"f'\"{str(accuracy_set)}\",'",
"line",
"+=",
"train_time",
"+",
"','",
"line",
"+=",
"str",
"(",
"hyper",
"[",
"'L1'",
"]",
")",
"+",
"','",
"line",
"+=",
"str",
"(",
"hyper",
"[",
"'L2'",
"]",
")",
"+",
"','",
"line",
"+=",
"str",
"(",
"train_size",
")",
"+",
"','",
"line",
"+=",
"str",
"(",
"test_size",
")",
"+",
"','",
"line",
"+=",
"str",
"(",
"hyper",
"[",
"'max-iter'",
"]",
")",
"+",
"','",
"line",
"+=",
"str",
"(",
"hyper",
"[",
"'k-folds'",
"]",
")",
"+",
"'\\n'",
"with",
"open",
"(",
"'results.csv'",
",",
"'a'",
")",
"as",
"f",
":",
"f",
".",
"write",
"(",
"line",
")"
] | [
586,
0
] | [
604,
21
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
AbstractGMapsExtractor._get_driver_config | (self, driver_arguments=None, experimental_arguments=None) | return chrome_options | Función privada que devuelve la configuración necesaria para instanciar un chromedriver. Si le llegan
argumentos se genera el webdriver.ChromeOptions usando los argumentos, en caso contrario se usarán los de por
defecto definidos en los atributos de la clase `_default_driver_args` y `_default_experimental_driver_args`
clase.
Parameters
----------
driver_arguments: list
lista de argumentos para configurar la instancia `webdriver.ChromeOptions`
experimental_arguments: dict
diccionario con argumentos experimentales que configurarán la instancia de `webdriver.ChromeOptions`
Returns
-------
chrome_options : webdriver.ChromeOptions
| Función privada que devuelve la configuración necesaria para instanciar un chromedriver. Si le llegan
argumentos se genera el webdriver.ChromeOptions usando los argumentos, en caso contrario se usarán los de por
defecto definidos en los atributos de la clase `_default_driver_args` y `_default_experimental_driver_args`
clase. | def _get_driver_config(self, driver_arguments=None, experimental_arguments=None):
"""Función privada que devuelve la configuración necesaria para instanciar un chromedriver. Si le llegan
argumentos se genera el webdriver.ChromeOptions usando los argumentos, en caso contrario se usarán los de por
defecto definidos en los atributos de la clase `_default_driver_args` y `_default_experimental_driver_args`
clase.
Parameters
----------
driver_arguments: list
lista de argumentos para configurar la instancia `webdriver.ChromeOptions`
experimental_arguments: dict
diccionario con argumentos experimentales que configurarán la instancia de `webdriver.ChromeOptions`
Returns
-------
chrome_options : webdriver.ChromeOptions
"""
chrome_options = webdriver.ChromeOptions()
arguments = driver_arguments if driver_arguments else self._default_driver_args
experimental_args = experimental_arguments if experimental_arguments else self._default_experimental_driver_args
for experimental_key, experimental_value in experimental_args.items():
chrome_options.add_experimental_option(experimental_key, experimental_value)
for argument in arguments:
chrome_options.add_argument(argument)
return chrome_options | [
"def",
"_get_driver_config",
"(",
"self",
",",
"driver_arguments",
"=",
"None",
",",
"experimental_arguments",
"=",
"None",
")",
":",
"chrome_options",
"=",
"webdriver",
".",
"ChromeOptions",
"(",
")",
"arguments",
"=",
"driver_arguments",
"if",
"driver_arguments",
"else",
"self",
".",
"_default_driver_args",
"experimental_args",
"=",
"experimental_arguments",
"if",
"experimental_arguments",
"else",
"self",
".",
"_default_experimental_driver_args",
"for",
"experimental_key",
",",
"experimental_value",
"in",
"experimental_args",
".",
"items",
"(",
")",
":",
"chrome_options",
".",
"add_experimental_option",
"(",
"experimental_key",
",",
"experimental_value",
")",
"for",
"argument",
"in",
"arguments",
":",
"chrome_options",
".",
"add_argument",
"(",
"argument",
")",
"return",
"chrome_options"
] | [
108,
4
] | [
137,
29
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
ProcControl.stop | (self, item: Union["multiprocessing.context", "ThreadSafe"], killProc: bool = False) | Parar el proceso/subproceso en ejecución
Args:
item:
Un objeto `multiprocessing.context` o `ThreadSafe`
killProc:
**True** manda una señal SIGKILL; **False** una SIGTERM
| Parar el proceso/subproceso en ejecución | def stop(self, item: Union["multiprocessing.context", "ThreadSafe"], killProc: bool = False) -> None:
"""Parar el proceso/subproceso en ejecución
Args:
item:
Un objeto `multiprocessing.context` o `ThreadSafe`
killProc:
**True** manda una señal SIGKILL; **False** una SIGTERM
"""
if (item.__module__ == "multiprocessing.context"):
if (killProc):
item.kill()
else:
item.terminate()
else:
item.kill()
item.join() | [
"def",
"stop",
"(",
"self",
",",
"item",
":",
"Union",
"[",
"\"multiprocessing.context\"",
",",
"\"ThreadSafe\"",
"]",
",",
"killProc",
":",
"bool",
"=",
"False",
")",
"->",
"None",
":",
"if",
"(",
"item",
".",
"__module__",
"==",
"\"multiprocessing.context\"",
")",
":",
"if",
"(",
"killProc",
")",
":",
"item",
".",
"kill",
"(",
")",
"else",
":",
"item",
".",
"terminate",
"(",
")",
"else",
":",
"item",
".",
"kill",
"(",
")",
"item",
".",
"join",
"(",
")"
] | [
203,
4
] | [
223,
23
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
RBF.rbf_list | (self, X, centroids, coef) | return np.array(RBF_list) | Método que calcula la matriz Z para el modelo lineal a ajustar,
aplicando la función de base radial a cada punto del cojunto de datos
X, con cada uno de los centroides en 'centroids' y parámetros de escala
dados en 'coef' | Método que calcula la matriz Z para el modelo lineal a ajustar,
aplicando la función de base radial a cada punto del cojunto de datos
X, con cada uno de los centroides en 'centroids' y parámetros de escala
dados en 'coef' | def rbf_list(self, X, centroids, coef):
""" Método que calcula la matriz Z para el modelo lineal a ajustar,
aplicando la función de base radial a cada punto del cojunto de datos
X, con cada uno de los centroides en 'centroids' y parámetros de escala
dados en 'coef' """
RBF_list = []
for x in X:
RBF_list.append([self.rbf(x, c, r) for (c, r) in zip(centroids, coef)])
RBF_list=np.insert(RBF_list,0,np.ones(X.shape[0]),axis=1) #Añade un 1 para el sesgo, al principio de cada fila
return np.array(RBF_list) | [
"def",
"rbf_list",
"(",
"self",
",",
"X",
",",
"centroids",
",",
"coef",
")",
":",
"RBF_list",
"=",
"[",
"]",
"for",
"x",
"in",
"X",
":",
"RBF_list",
".",
"append",
"(",
"[",
"self",
".",
"rbf",
"(",
"x",
",",
"c",
",",
"r",
")",
"for",
"(",
"c",
",",
"r",
")",
"in",
"zip",
"(",
"centroids",
",",
"coef",
")",
"]",
")",
"RBF_list",
"=",
"np",
".",
"insert",
"(",
"RBF_list",
",",
"0",
",",
"np",
".",
"ones",
"(",
"X",
".",
"shape",
"[",
"0",
"]",
")",
",",
"axis",
"=",
"1",
")",
"#Añade un 1 para el sesgo, al principio de cada fila",
"return",
"np",
".",
"array",
"(",
"RBF_list",
")"
] | [
57,
4
] | [
67,
33
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
p_instrucciones2 | (t) | instrucciones : instruccion
| instrucciones : instruccion
| def p_instrucciones2(t):
'''instrucciones : instruccion
'''
t[0] = [t[1]] | [
"def",
"p_instrucciones2",
"(",
"t",
")",
":",
"t",
"[",
"0",
"]",
"=",
"[",
"t",
"[",
"1",
"]",
"]"
] | [
51,
0
] | [
54,
17
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
TrackedObjects.registered_objects | (self) | return registered_objects | Devuelve la lista de los objetos registrados con el último frame en el que fue visto.
Únicamente se devuelven los objetos cuyo estado esté marcado como registrado.
:return: lista de (último frame visto, objeto).
| Devuelve la lista de los objetos registrados con el último frame en el que fue visto. | def registered_objects(self) -> List[TrackedObjectDetection]:
"""Devuelve la lista de los objetos registrados con el último frame en el que fue visto.
Únicamente se devuelven los objetos cuyo estado esté marcado como registrado.
:return: lista de (último frame visto, objeto).
"""
registered_objects = []
for obj in self._tracked_objects:
if obj.status:
registered_objects.append(obj[-1])
return registered_objects | [
"def",
"registered_objects",
"(",
"self",
")",
"->",
"List",
"[",
"TrackedObjectDetection",
"]",
":",
"registered_objects",
"=",
"[",
"]",
"for",
"obj",
"in",
"self",
".",
"_tracked_objects",
":",
"if",
"obj",
".",
"status",
":",
"registered_objects",
".",
"append",
"(",
"obj",
"[",
"-",
"1",
"]",
")",
"return",
"registered_objects"
] | [
281,
4
] | [
292,
33
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
p_SubConsultas_comandosS1 | (t) | QUE_SUBS : SELECT DISTINCT LISTA_CAMPOS FROM NOMBRES_TABLAS CUERPOS | QUE_SUBS : SELECT DISTINCT LISTA_CAMPOS FROM NOMBRES_TABLAS CUERPOS | def p_SubConsultas_comandosS1(t):
'QUE_SUBS : SELECT DISTINCT LISTA_CAMPOS FROM NOMBRES_TABLAS CUERPOS '
t[0] = SubSelect4(t[2],t[6],t[3],t[5])
rep_gramatica('\n <TR><TD> QUE_SUBS → SELECT DISTINCT LISTA_CAMPOS FROM NOMBRES_TABLAS CUERPOS </TD><TD> t[0] = SubSelect4(t[2],t[6],t[3],t[5]) </TD></TR>') | [
"def",
"p_SubConsultas_comandosS1",
"(",
"t",
")",
":",
"t",
"[",
"0",
"]",
"=",
"SubSelect4",
"(",
"t",
"[",
"2",
"]",
",",
"t",
"[",
"6",
"]",
",",
"t",
"[",
"3",
"]",
",",
"t",
"[",
"5",
"]",
")",
"rep_gramatica",
"(",
"'\\n <TR><TD> QUE_SUBS → SELECT DISTINCT LISTA_CAMPOS FROM NOMBRES_TABLAS CUERPOS </TD><TD> t[0] = SubSelect4(t[2],t[6],t[3],t[5]) </TD></TR>')",
""
] | [
1186,
0
] | [
1189,
167
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
charge | (
apiclient: ApiClient, charge_data: Dict[str, Any]
) | Este servicio permite efectuar un cargo automático en la tarjeta de
crédito previamente registrada por el cliente. Si el cliente no
tiene registrada una tarjeta el metodo retornará error.
| Este servicio permite efectuar un cargo automático en la tarjeta de
crédito previamente registrada por el cliente. Si el cliente no
tiene registrada una tarjeta el metodo retornará error.
| def charge(
apiclient: ApiClient, charge_data: Dict[str, Any]
) -> Union[PaymentStatus, Error]:
"""Este servicio permite efectuar un cargo automático en la tarjeta de
crédito previamente registrada por el cliente. Si el cliente no
tiene registrada una tarjeta el metodo retornará error.
"""
url = f"{apiclient.api_url}/customer/charge"
charge = CustomerChargeRequest.from_dict(charge_data)
if charge.apiKey is None:
charge.apiKey = apiclient.api_key
charge.s = apiclient.make_signature(asdict(charge))
logging.debug("Before Request:" + str(charge))
response = apiclient.post(url, asdict(charge))
if response.status_code == 200:
return PaymentStatus.from_dict(cast(Dict[str, Any], response.json()))
if response.status_code == 400:
return Error.from_dict(cast(Dict[str, Any], response.json()))
if response.status_code == 401:
return Error.from_dict(cast(Dict[str, Any], response.json()))
else:
raise Exception(response=response) | [
"def",
"charge",
"(",
"apiclient",
":",
"ApiClient",
",",
"charge_data",
":",
"Dict",
"[",
"str",
",",
"Any",
"]",
")",
"->",
"Union",
"[",
"PaymentStatus",
",",
"Error",
"]",
":",
"url",
"=",
"f\"{apiclient.api_url}/customer/charge\"",
"charge",
"=",
"CustomerChargeRequest",
".",
"from_dict",
"(",
"charge_data",
")",
"if",
"charge",
".",
"apiKey",
"is",
"None",
":",
"charge",
".",
"apiKey",
"=",
"apiclient",
".",
"api_key",
"charge",
".",
"s",
"=",
"apiclient",
".",
"make_signature",
"(",
"asdict",
"(",
"charge",
")",
")",
"logging",
".",
"debug",
"(",
"\"Before Request:\"",
"+",
"str",
"(",
"charge",
")",
")",
"response",
"=",
"apiclient",
".",
"post",
"(",
"url",
",",
"asdict",
"(",
"charge",
")",
")",
"if",
"response",
".",
"status_code",
"==",
"200",
":",
"return",
"PaymentStatus",
".",
"from_dict",
"(",
"cast",
"(",
"Dict",
"[",
"str",
",",
"Any",
"]",
",",
"response",
".",
"json",
"(",
")",
")",
")",
"if",
"response",
".",
"status_code",
"==",
"400",
":",
"return",
"Error",
".",
"from_dict",
"(",
"cast",
"(",
"Dict",
"[",
"str",
",",
"Any",
"]",
",",
"response",
".",
"json",
"(",
")",
")",
")",
"if",
"response",
".",
"status_code",
"==",
"401",
":",
"return",
"Error",
".",
"from_dict",
"(",
"cast",
"(",
"Dict",
"[",
"str",
",",
"Any",
"]",
",",
"response",
".",
"json",
"(",
")",
")",
")",
"else",
":",
"raise",
"Exception",
"(",
"response",
"=",
"response",
")"
] | [
250,
0
] | [
275,
42
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
TokenCallback.change_services | (token: str, services: str, *, cursor) | Cambiar los servicios permitidos por un token de acceso | Cambiar los servicios permitidos por un token de acceso | async def change_services(token: str, services: str, *, cursor) -> None:
"""Cambiar los servicios permitidos por un token de acceso"""
await cursor.execute(
"UPDATE tokens SET services = %s WHERE token = %s LIMIT 1",
(services, token)
) | [
"async",
"def",
"change_services",
"(",
"token",
":",
"str",
",",
"services",
":",
"str",
",",
"*",
",",
"cursor",
")",
"->",
"None",
":",
"await",
"cursor",
".",
"execute",
"(",
"\"UPDATE tokens SET services = %s WHERE token = %s LIMIT 1\"",
",",
"(",
"services",
",",
"token",
")",
")"
] | [
309,
4
] | [
317,
9
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
extra_fields | (request, csv_file_name, document_name, pdf_file_name) | Configura los campos extra detectados en un ``CSV``
:param request: Objeto ``HttpRequets`` de Django
:type request: HttpRequest
:param csv_file_name: Nombre del archivo ``csv``
:type csv_file_name: str
:param document_name: Nombre del documento
:type document_name: str
:param pdf_file_name: Nombre del archivo ``pdf``
:type pdf_file_name: str
:return: Redirecciona a la vista de nuevo documento
:rtype: None
| Configura los campos extra detectados en un ``CSV`` | def extra_fields(request, csv_file_name, document_name, pdf_file_name):
"""Configura los campos extra detectados en un ``CSV``
:param request: Objeto ``HttpRequets`` de Django
:type request: HttpRequest
:param csv_file_name: Nombre del archivo ``csv``
:type csv_file_name: str
:param document_name: Nombre del documento
:type document_name: str
:param pdf_file_name: Nombre del archivo ``pdf``
:type pdf_file_name: str
:return: Redirecciona a la vista de nuevo documento
:rtype: None
"""
if request.method == "POST":
has_extra_fields = False
if "config-fields-switch" in request.POST:
data = dict(request.POST)
del data['config-fields-switch']
del data['csrfmiddlewaretoken']
configs = get_index_config()
for field, field_type in data.items():
configs['mappings']['properties'][field] = {'type': field_type[0]}
try:
es.indices.put_mapping(configs['mappings'], index=settings.INDEX)
except es_exceptions.RequestError as e:
messages.error(request, "Error al configurar índice :(")
# TODO: Tell to the user that something goes wrong!
print(e)
new_mappings = es.indices.get_mapping(index=settings.INDEX)
configs['mappings'] = new_mappings[settings.INDEX]['mappings']
update_config(configs)
has_extra_fields = True
messages.add_message(request,
messages.SUCCESS,
f"Los campos extra <b>\
{', '.join(data.keys())}\
</b>fueron configurados exitosamente")
# Upload document as usual
lines = csv_uploader(csv_file_name, document_name, pdf_file_name,
extra_fields=has_extra_fields)
notification = 'El documento <b>' + document_name + \
'</b> fue guardado correctamente. <b>' + \
str(lines) + ' líneas</b> agregadas al corpus.'
messages.add_message(request, messages.INFO, notification)
return HttpResponseRedirect('/corpus-admin/new/')
else:
return HttpResponseRedirect("/corpus-admin/new/") | [
"def",
"extra_fields",
"(",
"request",
",",
"csv_file_name",
",",
"document_name",
",",
"pdf_file_name",
")",
":",
"if",
"request",
".",
"method",
"==",
"\"POST\"",
":",
"has_extra_fields",
"=",
"False",
"if",
"\"config-fields-switch\"",
"in",
"request",
".",
"POST",
":",
"data",
"=",
"dict",
"(",
"request",
".",
"POST",
")",
"del",
"data",
"[",
"'config-fields-switch'",
"]",
"del",
"data",
"[",
"'csrfmiddlewaretoken'",
"]",
"configs",
"=",
"get_index_config",
"(",
")",
"for",
"field",
",",
"field_type",
"in",
"data",
".",
"items",
"(",
")",
":",
"configs",
"[",
"'mappings'",
"]",
"[",
"'properties'",
"]",
"[",
"field",
"]",
"=",
"{",
"'type'",
":",
"field_type",
"[",
"0",
"]",
"}",
"try",
":",
"es",
".",
"indices",
".",
"put_mapping",
"(",
"configs",
"[",
"'mappings'",
"]",
",",
"index",
"=",
"settings",
".",
"INDEX",
")",
"except",
"es_exceptions",
".",
"RequestError",
"as",
"e",
":",
"messages",
".",
"error",
"(",
"request",
",",
"\"Error al configurar índice :(\")",
"",
"# TODO: Tell to the user that something goes wrong!",
"print",
"(",
"e",
")",
"new_mappings",
"=",
"es",
".",
"indices",
".",
"get_mapping",
"(",
"index",
"=",
"settings",
".",
"INDEX",
")",
"configs",
"[",
"'mappings'",
"]",
"=",
"new_mappings",
"[",
"settings",
".",
"INDEX",
"]",
"[",
"'mappings'",
"]",
"update_config",
"(",
"configs",
")",
"has_extra_fields",
"=",
"True",
"messages",
".",
"add_message",
"(",
"request",
",",
"messages",
".",
"SUCCESS",
",",
"f\"Los campos extra <b>\\\n {', '.join(data.keys())}\\\n </b>fueron configurados exitosamente\"",
")",
"# Upload document as usual",
"lines",
"=",
"csv_uploader",
"(",
"csv_file_name",
",",
"document_name",
",",
"pdf_file_name",
",",
"extra_fields",
"=",
"has_extra_fields",
")",
"notification",
"=",
"'El documento <b>'",
"+",
"document_name",
"+",
"'</b> fue guardado correctamente. <b>'",
"+",
"str",
"(",
"lines",
")",
"+",
"' líneas</b> agregadas al corpus.'",
"messages",
".",
"add_message",
"(",
"request",
",",
"messages",
".",
"INFO",
",",
"notification",
")",
"return",
"HttpResponseRedirect",
"(",
"'/corpus-admin/new/'",
")",
"else",
":",
"return",
"HttpResponseRedirect",
"(",
"\"/corpus-admin/new/\"",
")"
] | [
385,
0
] | [
432,
57
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
p_BLOCK | (t) | BLOCK : sentencias
| ASIGNACION
| RETORNO
| CONTINUE
| EXIT
| SENTENCIAS_CONTROL
| DECLARACION_RAICENOTE
| STATEMENT
| CALL ptComa
| BLOCK : sentencias
| ASIGNACION
| RETORNO
| CONTINUE
| EXIT
| SENTENCIAS_CONTROL
| DECLARACION_RAICENOTE
| STATEMENT
| CALL ptComa
| def p_BLOCK(t):
''' BLOCK : sentencias
| ASIGNACION
| RETORNO
| CONTINUE
| EXIT
| SENTENCIAS_CONTROL
| DECLARACION_RAICENOTE
| STATEMENT
| CALL ptComa
'''
t[0] =t[1]
lista.append("<BLOCK> :: = < "+str(t[1].Etiqueta)+">\n") | [
"def",
"p_BLOCK",
"(",
"t",
")",
":",
"t",
"[",
"0",
"]",
"=",
"t",
"[",
"1",
"]",
"lista",
".",
"append",
"(",
"\"<BLOCK> :: = < \"",
"+",
"str",
"(",
"t",
"[",
"1",
"]",
".",
"Etiqueta",
")",
"+",
"\">\\n\"",
")"
] | [
1282,
0
] | [
1294,
60
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
Simulador.calc_distancia | (self) | return distancia | Retorna la distancia en metros
entre las coordenadas de origen y destino.
| Retorna la distancia en metros
entre las coordenadas de origen y destino.
| def calc_distancia(self):
"""Retorna la distancia en metros
entre las coordenadas de origen y destino.
"""
g = self.geod.Inverse(self.origen.latitud,
self.origen.longitud,
self.destino.latitud,
self.destino.longitud)
distancia = g['s12']
self.distancia = distancia
return distancia | [
"def",
"calc_distancia",
"(",
"self",
")",
":",
"g",
"=",
"self",
".",
"geod",
".",
"Inverse",
"(",
"self",
".",
"origen",
".",
"latitud",
",",
"self",
".",
"origen",
".",
"longitud",
",",
"self",
".",
"destino",
".",
"latitud",
",",
"self",
".",
"destino",
".",
"longitud",
")",
"distancia",
"=",
"g",
"[",
"'s12'",
"]",
"self",
".",
"distancia",
"=",
"distancia",
"return",
"distancia"
] | [
28,
4
] | [
38,
24
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
DataCleaner._update_series | (self, field, new_series,
keep_original=False, prefix=None, sufix=None) | Agrega o pisa una serie nueva en el DataFrame. | Agrega o pisa una serie nueva en el DataFrame. | def _update_series(self, field, new_series,
keep_original=False, prefix=None, sufix=None):
"""Agrega o pisa una serie nueva en el DataFrame."""
if not keep_original:
self.df[field] = new_series
else:
new_field = "_".join([elem for elem in [prefix, field, sufix]
if elem])
self.df.insert(self.df.columns.get_loc(field),
new_field, new_series) | [
"def",
"_update_series",
"(",
"self",
",",
"field",
",",
"new_series",
",",
"keep_original",
"=",
"False",
",",
"prefix",
"=",
"None",
",",
"sufix",
"=",
"None",
")",
":",
"if",
"not",
"keep_original",
":",
"self",
".",
"df",
"[",
"field",
"]",
"=",
"new_series",
"else",
":",
"new_field",
"=",
"\"_\"",
".",
"join",
"(",
"[",
"elem",
"for",
"elem",
"in",
"[",
"prefix",
",",
"field",
",",
"sufix",
"]",
"if",
"elem",
"]",
")",
"self",
".",
"df",
".",
"insert",
"(",
"self",
".",
"df",
".",
"columns",
".",
"get_loc",
"(",
"field",
")",
",",
"new_field",
",",
"new_series",
")"
] | [
291,
4
] | [
300,
49
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
p_instrucciones_funcion_avg | (t) | funciones_math_esenciales : AVG PARIZQ lista_funciones_math_esenciales PARDER
| AVG PARIZQ lista_funciones_math_esenciales PARDER parametro
| funciones_math_esenciales : AVG PARIZQ lista_funciones_math_esenciales PARDER
| AVG PARIZQ lista_funciones_math_esenciales PARDER parametro
| def p_instrucciones_funcion_avg(t):
'''funciones_math_esenciales : AVG PARIZQ lista_funciones_math_esenciales PARDER
| AVG PARIZQ lista_funciones_math_esenciales PARDER parametro
''' | [
"def",
"p_instrucciones_funcion_avg",
"(",
"t",
")",
":"
] | [
996,
0
] | [
999,
39
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
p_relacional | (t) | relacional : IGUAL IGUAL
| MAYORQ
| MENORQ
| MAYOR_IGUALQ
| MENOR_IGUALQ
| DISTINTO
| relacional : IGUAL IGUAL
| MAYORQ
| MENORQ
| MAYOR_IGUALQ
| MENOR_IGUALQ
| DISTINTO
| def p_relacional(t):
'''relacional : IGUAL IGUAL
| MAYORQ
| MENORQ
| MAYOR_IGUALQ
| MENOR_IGUALQ
| DISTINTO
'''
t[0] = t[1] | [
"def",
"p_relacional",
"(",
"t",
")",
":",
"t",
"[",
"0",
"]",
"=",
"t",
"[",
"1",
"]"
] | [
242,
0
] | [
250,
15
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
Resaltado_Decorador.render | (self) | return "<b>" + self.textodecorado.render() + "</b>" | Decora el texto agregándole las etiquetas <b></b> | Decora el texto agregándole las etiquetas <b></b> | def render(self):
"""Decora el texto agregándole las etiquetas <b></b>"""
return "<b>" + self.textodecorado.render() + "</b>" | [
"def",
"render",
"(",
"self",
")",
":",
"return",
"\"<b>\"",
"+",
"self",
".",
"textodecorado",
".",
"render",
"(",
")",
"+",
"\"</b>\""
] | [
43,
3
] | [
45,
57
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
User.greet_user | (self) | Saludo al usuario | Saludo al usuario | def greet_user(self):
"""Saludo al usuario"""
print("\nBienvenido/a, " + self.username + "!") | [
"def",
"greet_user",
"(",
"self",
")",
":",
"print",
"(",
"\"\\nBienvenido/a, \"",
"+",
"self",
".",
"username",
"+",
"\"!\"",
")"
] | [
24,
4
] | [
26,
55
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
p_operacion_aritmetica_18 | (t) | operacion_aritmetica : funciones_extras operacion_aritmetica_2 | operacion_aritmetica : funciones_extras operacion_aritmetica_2 | def p_operacion_aritmetica_18(t):
'''operacion_aritmetica : funciones_extras operacion_aritmetica_2'''
node = grammer.nodoDireccion('operacion_aritmetica')
node2 = grammer.nodoDireccion(t[1])
node.agregar(node2)
t[0] = node | [
"def",
"p_operacion_aritmetica_18",
"(",
"t",
")",
":",
"node",
"=",
"grammer",
".",
"nodoDireccion",
"(",
"'operacion_aritmetica'",
")",
"node2",
"=",
"grammer",
".",
"nodoDireccion",
"(",
"t",
"[",
"1",
"]",
")",
"node",
".",
"agregar",
"(",
"node2",
")",
"t",
"[",
"0",
"]",
"=",
"node"
] | [
1863,
0
] | [
1868,
15
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
colors | (request) | return {'COLORS': settings.COLORS} | **Configura variables de entorno para los colores** | **Configura variables de entorno para los colores** | def colors(request):
"""**Configura variables de entorno para los colores**"""
return {'COLORS': settings.COLORS} | [
"def",
"colors",
"(",
"request",
")",
":",
"return",
"{",
"'COLORS'",
":",
"settings",
".",
"COLORS",
"}"
] | [
20,
0
] | [
22,
38
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
ingresar_datos | () | Ingresa los datos de los empleados. | Ingresa los datos de los empleados. | def ingresar_datos() -> object:
"""Ingresa los datos de los empleados."""
tipo, *data = _ingreso_base()
if tipo == "Supervisor":
lic = input(cyan("Ingresar licenciatura: "))
area = input(cyan("Ingresar area supervisada: "))
return Supervisor(*data, lic, area)
else:
nivel = menu_input(NIVEL, numbers=True, lang="es")
habilidades = input(cyan("Ingresar habilidades: "))
if tipo == "Analista":
return Analista(*data, nivel, habilidades)
else:
return Operativo(*data, nivel, habilidades) | [
"def",
"ingresar_datos",
"(",
")",
"->",
"object",
":",
"tipo",
",",
"",
"*",
"data",
"=",
"_ingreso_base",
"(",
")",
"if",
"tipo",
"==",
"\"Supervisor\"",
":",
"lic",
"=",
"input",
"(",
"cyan",
"(",
"\"Ingresar licenciatura: \"",
")",
")",
"area",
"=",
"input",
"(",
"cyan",
"(",
"\"Ingresar area supervisada: \"",
")",
")",
"return",
"Supervisor",
"(",
"*",
"data",
",",
"lic",
",",
"area",
")",
"else",
":",
"nivel",
"=",
"menu_input",
"(",
"NIVEL",
",",
"numbers",
"=",
"True",
",",
"lang",
"=",
"\"es\"",
")",
"habilidades",
"=",
"input",
"(",
"cyan",
"(",
"\"Ingresar habilidades: \"",
")",
")",
"if",
"tipo",
"==",
"\"Analista\"",
":",
"return",
"Analista",
"(",
"*",
"data",
",",
"nivel",
",",
"habilidades",
")",
"else",
":",
"return",
"Operativo",
"(",
"*",
"data",
",",
"nivel",
",",
"habilidades",
")"
] | [
24,
0
] | [
37,
55
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
p_create_opciones | (t) | create_opciones : OWNER SIGNO_IGUAL ID create_opciones
| MODE SIGNO_IGUAL NUMERO create_opciones
| | create_opciones : OWNER SIGNO_IGUAL ID create_opciones
| MODE SIGNO_IGUAL NUMERO create_opciones
| | def p_create_opciones(t):
'''create_opciones : OWNER SIGNO_IGUAL ID create_opciones
| MODE SIGNO_IGUAL NUMERO create_opciones
| '''
if len(t) == 5:
id = inc()
t[0] = id
dot.node(str(id), "create_opciones")
dot.edge(str(id), str(id) + '_' + str(t[1]))
dot.edge(str(id), str(id) + '_' + str(t[2]))
dot.edge(str(id), str(id) + '_' + str(t[3]))
if t[4] != None:
dot.edge(str(id), str(t[4]))
else:
t[0] = None | [
"def",
"p_create_opciones",
"(",
"t",
")",
":",
"if",
"len",
"(",
"t",
")",
"==",
"5",
":",
"id",
"=",
"inc",
"(",
")",
"t",
"[",
"0",
"]",
"=",
"id",
"dot",
".",
"node",
"(",
"str",
"(",
"id",
")",
",",
"\"create_opciones\"",
")",
"dot",
".",
"edge",
"(",
"str",
"(",
"id",
")",
",",
"str",
"(",
"id",
")",
"+",
"'_'",
"+",
"str",
"(",
"t",
"[",
"1",
"]",
")",
")",
"dot",
".",
"edge",
"(",
"str",
"(",
"id",
")",
",",
"str",
"(",
"id",
")",
"+",
"'_'",
"+",
"str",
"(",
"t",
"[",
"2",
"]",
")",
")",
"dot",
".",
"edge",
"(",
"str",
"(",
"id",
")",
",",
"str",
"(",
"id",
")",
"+",
"'_'",
"+",
"str",
"(",
"t",
"[",
"3",
"]",
")",
")",
"if",
"t",
"[",
"4",
"]",
"!=",
"None",
":",
"dot",
".",
"edge",
"(",
"str",
"(",
"id",
")",
",",
"str",
"(",
"t",
"[",
"4",
"]",
")",
")",
"else",
":",
"t",
"[",
"0",
"]",
"=",
"None"
] | [
570,
0
] | [
584,
19
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
p_combinaciones1_3 | (p) | combinaciones1 : ID | combinaciones1 : ID | def p_combinaciones1_3(p):
'combinaciones1 : ID' | [
"def",
"p_combinaciones1_3",
"(",
"p",
")",
":"
] | [
572,
0
] | [
573,
25
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
p_instrif1 | (t) | instrif : IF condiciones THEN instrlistabloque ELSE instrlistabloque END IF PTCOMA | instrif : IF condiciones THEN instrlistabloque ELSE instrlistabloque END IF PTCOMA | def p_instrif1(t):
'instrif : IF condiciones THEN instrlistabloque ELSE instrlistabloque END IF PTCOMA'
t[0] = getinstrif1(t) | [
"def",
"p_instrif1",
"(",
"t",
")",
":",
"t",
"[",
"0",
"]",
"=",
"getinstrif1",
"(",
"t",
")"
] | [
812,
0
] | [
814,
25
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
rellenar_matriz | (matriz, ocurrencia) | return [lista[i:i + chunk_sz] for i in range(0, len(lista), chunk_sz)] | En esta funcion se crea la matriz que luego sera utilizada | En esta funcion se crea la matriz que luego sera utilizada | def rellenar_matriz(matriz, ocurrencia):
""""En esta funcion se crea la matriz que luego sera utilizada"""
procesar_matriz(matriz)
lista = lista_preliminar(ocurrencia)
chunk_sz = int(len(lista) / TAMANO[0])
return [lista[i:i + chunk_sz] for i in range(0, len(lista), chunk_sz)] | [
"def",
"rellenar_matriz",
"(",
"matriz",
",",
"ocurrencia",
")",
":",
"procesar_matriz",
"(",
"matriz",
")",
"lista",
"=",
"lista_preliminar",
"(",
"ocurrencia",
")",
"chunk_sz",
"=",
"int",
"(",
"len",
"(",
"lista",
")",
"/",
"TAMANO",
"[",
"0",
"]",
")",
"return",
"[",
"lista",
"[",
"i",
":",
"i",
"+",
"chunk_sz",
"]",
"for",
"i",
"in",
"range",
"(",
"0",
",",
"len",
"(",
"lista",
")",
",",
"chunk_sz",
")",
"]"
] | [
30,
0
] | [
35,
74
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
get_best_replacements | (clusters, counts) | return res | Selecciona los strings más utilizados por cluster.
Itera por cada cluster para determinar la mejor string para reemplazar las
strings originales. De momento solo utiliza un conteo simple pero podria
agregarse algun criterio basado en la capitalizacion de las palabras
Args:
clusters (dict): {fingerprint: [raw_string_1, raw_string_2]}
counts (dict): {raw_string: cant_veces_utilizada}
Returns:
dict: {fingerprint: string_mas_usada_para_esa_fingerprint}
| Selecciona los strings más utilizados por cluster. | def get_best_replacements(clusters, counts):
"""Selecciona los strings más utilizados por cluster.
Itera por cada cluster para determinar la mejor string para reemplazar las
strings originales. De momento solo utiliza un conteo simple pero podria
agregarse algun criterio basado en la capitalizacion de las palabras
Args:
clusters (dict): {fingerprint: [raw_string_1, raw_string_2]}
counts (dict): {raw_string: cant_veces_utilizada}
Returns:
dict: {fingerprint: string_mas_usada_para_esa_fingerprint}
"""
res = {}
for (fingerprint, key_strings) in clusters.items():
res[fingerprint] = max(key_strings, key=lambda s: counts[s])
return res | [
"def",
"get_best_replacements",
"(",
"clusters",
",",
"counts",
")",
":",
"res",
"=",
"{",
"}",
"for",
"(",
"fingerprint",
",",
"key_strings",
")",
"in",
"clusters",
".",
"items",
"(",
")",
":",
"res",
"[",
"fingerprint",
"]",
"=",
"max",
"(",
"key_strings",
",",
"key",
"=",
"lambda",
"s",
":",
"counts",
"[",
"s",
"]",
")",
"return",
"res"
] | [
88,
0
] | [
105,
14
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
Chimp.test | (self, id, data) | Este metodo se define para enviar un test de email, para verificar que todo funcione bien
antes de enviar la campaña de email a todos los contactos. Recibe como parametros, la campaña que
será enviada y un diccionario con el siguiente formato:
{"test_emails":["[email protected]"],"send_type":"html"} | Este metodo se define para enviar un test de email, para verificar que todo funcione bien
antes de enviar la campaña de email a todos los contactos. Recibe como parametros, la campaña que
será enviada y un diccionario con el siguiente formato:
{"test_emails":["email_al_que_sera_enviado | def test(self, id, data):
"""Este metodo se define para enviar un test de email, para verificar que todo funcione bien
antes de enviar la campaña de email a todos los contactos. Recibe como parametros, la campaña que
será enviada y un diccionario con el siguiente formato:
{"test_emails":["[email protected]"],"send_type":"html"}"""
self.client.campaigns.actions.test(campaign_id=id, data=data) | [
"def",
"test",
"(",
"self",
",",
"id",
",",
"data",
")",
":",
"self",
".",
"client",
".",
"campaigns",
".",
"actions",
".",
"test",
"(",
"campaign_id",
"=",
"id",
",",
"data",
"=",
"data",
")"
] | [
161,
4
] | [
166,
69
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
eval_labeled_positions | (y_correct, y_pred) | Imprime un reporte de metricas entre las bio labels predichas
por el modelo y las reales
Genera diccionarios con las labels como llaves y el total de ocurrencias
como valores. Con estos diccionarios obtiene precision, recall y f-score
por cada label. Además, obtiene dichas métricas para todas las labels.
:param y_correct: Bio labels reales
:type: list
:param y_pred: Bio labels predichas por el modelo
:type: list
:return: None
| Imprime un reporte de metricas entre las bio labels predichas
por el modelo y las reales | def eval_labeled_positions(y_correct, y_pred):
"""Imprime un reporte de metricas entre las bio labels predichas
por el modelo y las reales
Genera diccionarios con las labels como llaves y el total de ocurrencias
como valores. Con estos diccionarios obtiene precision, recall y f-score
por cada label. Además, obtiene dichas métricas para todas las labels.
:param y_correct: Bio labels reales
:type: list
:param y_pred: Bio labels predichas por el modelo
:type: list
:return: None
"""
# group the labels by morpheme and get list of morphemes
correctmorphs, _ = concatenateLabels(y_correct)
predmorphs, predLabels = concatenateLabels(y_pred)
# Count instances of each morpheme
test_morphcts = countMorphemes(correctmorphs)
pred_morphcts = countMorphemes(predmorphs)
correctMorphemects = {}
idx = 0
num_correct = 0
for morpheme in correctmorphs: # TODO: Improve this section
correct = True
for label in morpheme:
if label != predLabels[idx]:
correct = False
idx += 1
if correct == True:
num_correct += 1
correctMorphemects[morpheme[0][2:]] = correctMorphemects.get(morpheme[0][2:], 0) + 1
# calculate P, R F1 for each morpheme
results = ''
for firstlabel in correctMorphemects.keys():
# Calculate precision for each label
lprec = correctMorphemects[firstlabel] / pred_morphcts[firstlabel]
# Calculate Recall for each label
lrecall = correctMorphemects[firstlabel] / test_morphcts[firstlabel]
results += firstlabel + '\t\t{0:.2f}'.format(lprec) + '\t\t' + '{0:.2f}'.format(
lrecall) + '\t' + '{0:.2f}'.format((2 * lprec * lrecall) / (lprec + lrecall)) + '\t\t' + str(
test_morphcts[firstlabel]) + '\n'
# overall results
precision = num_correct / len(predmorphs)
recall = num_correct / len(correctmorphs)
print('\t\tPrecision\tRecall\tf1-score\tInstances\n\n' + results + '\ntotal/avg\t{0:.2f}'.format(
precision) + '\t\t' + '{0:.2f}'.format(recall) + '\t' + '{0:.2f}'.format(
(2 * precision * recall) / (precision + recall))) | [
"def",
"eval_labeled_positions",
"(",
"y_correct",
",",
"y_pred",
")",
":",
"# group the labels by morpheme and get list of morphemes",
"correctmorphs",
",",
"_",
"=",
"concatenateLabels",
"(",
"y_correct",
")",
"predmorphs",
",",
"predLabels",
"=",
"concatenateLabels",
"(",
"y_pred",
")",
"# Count instances of each morpheme",
"test_morphcts",
"=",
"countMorphemes",
"(",
"correctmorphs",
")",
"pred_morphcts",
"=",
"countMorphemes",
"(",
"predmorphs",
")",
"correctMorphemects",
"=",
"{",
"}",
"idx",
"=",
"0",
"num_correct",
"=",
"0",
"for",
"morpheme",
"in",
"correctmorphs",
":",
"# TODO: Improve this section",
"correct",
"=",
"True",
"for",
"label",
"in",
"morpheme",
":",
"if",
"label",
"!=",
"predLabels",
"[",
"idx",
"]",
":",
"correct",
"=",
"False",
"idx",
"+=",
"1",
"if",
"correct",
"==",
"True",
":",
"num_correct",
"+=",
"1",
"correctMorphemects",
"[",
"morpheme",
"[",
"0",
"]",
"[",
"2",
":",
"]",
"]",
"=",
"correctMorphemects",
".",
"get",
"(",
"morpheme",
"[",
"0",
"]",
"[",
"2",
":",
"]",
",",
"0",
")",
"+",
"1",
"# calculate P, R F1 for each morpheme",
"results",
"=",
"''",
"for",
"firstlabel",
"in",
"correctMorphemects",
".",
"keys",
"(",
")",
":",
"# Calculate precision for each label",
"lprec",
"=",
"correctMorphemects",
"[",
"firstlabel",
"]",
"/",
"pred_morphcts",
"[",
"firstlabel",
"]",
"# Calculate Recall for each label",
"lrecall",
"=",
"correctMorphemects",
"[",
"firstlabel",
"]",
"/",
"test_morphcts",
"[",
"firstlabel",
"]",
"results",
"+=",
"firstlabel",
"+",
"'\\t\\t{0:.2f}'",
".",
"format",
"(",
"lprec",
")",
"+",
"'\\t\\t'",
"+",
"'{0:.2f}'",
".",
"format",
"(",
"lrecall",
")",
"+",
"'\\t'",
"+",
"'{0:.2f}'",
".",
"format",
"(",
"(",
"2",
"*",
"lprec",
"*",
"lrecall",
")",
"/",
"(",
"lprec",
"+",
"lrecall",
")",
")",
"+",
"'\\t\\t'",
"+",
"str",
"(",
"test_morphcts",
"[",
"firstlabel",
"]",
")",
"+",
"'\\n'",
"# overall results",
"precision",
"=",
"num_correct",
"/",
"len",
"(",
"predmorphs",
")",
"recall",
"=",
"num_correct",
"/",
"len",
"(",
"correctmorphs",
")",
"print",
"(",
"'\\t\\tPrecision\\tRecall\\tf1-score\\tInstances\\n\\n'",
"+",
"results",
"+",
"'\\ntotal/avg\\t{0:.2f}'",
".",
"format",
"(",
"precision",
")",
"+",
"'\\t\\t'",
"+",
"'{0:.2f}'",
".",
"format",
"(",
"recall",
")",
"+",
"'\\t'",
"+",
"'{0:.2f}'",
".",
"format",
"(",
"(",
"2",
"*",
"precision",
"*",
"recall",
")",
"/",
"(",
"precision",
"+",
"recall",
")",
")",
")"
] | [
476,
0
] | [
525,
57
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
p_propiedades | (p) | propiedades : null propiedades
| not null propiedades
| identity propiedades
| primary key propiedades
| null
| not null
| identity
| primary key | propiedades : null propiedades
| not null propiedades
| identity propiedades
| primary key propiedades
| null
| not null
| identity
| primary key | def p_propiedades(p):
'''propiedades : null propiedades
| not null propiedades
| identity propiedades
| primary key propiedades
| null
| not null
| identity
| primary key''' | [
"def",
"p_propiedades",
"(",
"p",
")",
":"
] | [
77,
0
] | [
85,
30
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
ingresar_datos | () | return tipo, cantidad | Pide al usuario los datos para calcular el precio de la compra
de boletos.
:return: tipo, cantidad
:rtype: tuple
| Pide al usuario los datos para calcular el precio de la compra
de boletos. | def ingresar_datos():
"""Pide al usuario los datos para calcular el precio de la compra
de boletos.
:return: tipo, cantidad
:rtype: tuple
"""
text_align("Datos de la compra", width=35)
tipo: str = choice_input(tuple(TIPO.keys()))
cantidad: int = int_input("Ingrese el número de boletos: ", min=1, max=12)
return tipo, cantidad | [
"def",
"ingresar_datos",
"(",
")",
":",
"text_align",
"(",
"\"Datos de la compra\"",
",",
"width",
"=",
"35",
")",
"tipo",
":",
"str",
"=",
"choice_input",
"(",
"tuple",
"(",
"TIPO",
".",
"keys",
"(",
")",
")",
")",
"cantidad",
":",
"int",
"=",
"int_input",
"(",
"\"Ingrese el número de boletos: \",",
" ",
"in=",
"1",
",",
" ",
"ax=",
"1",
"2)",
"",
"return",
"tipo",
",",
"cantidad"
] | [
37,
0
] | [
47,
25
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
p_combinaciones2_3 | (p) | combinaciones2 : owner mode | combinaciones2 : owner mode | def p_combinaciones2_3(p):
'combinaciones2 : owner mode' | [
"def",
"p_combinaciones2_3",
"(",
"p",
")",
":"
] | [
588,
0
] | [
589,
33
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
NormalizarUnidadTerritorialTestCase.test_validate_filters | (self) | Debería validar los filtros. | Debería validar los filtros. | def test_validate_filters(self):
"""Debería validar los filtros."""
entity = 'localidad'
test_filters = {
"provincia_field": "provincia",
"departamento_field": "departamento",
"municipio_field": "municipio",
}
self.assertTrue(DataCleaner._validate_filters(entity, test_filters)) | [
"def",
"test_validate_filters",
"(",
"self",
")",
":",
"entity",
"=",
"'localidad'",
"test_filters",
"=",
"{",
"\"provincia_field\"",
":",
"\"provincia\"",
",",
"\"departamento_field\"",
":",
"\"departamento\"",
",",
"\"municipio_field\"",
":",
"\"municipio\"",
",",
"}",
"self",
".",
"assertTrue",
"(",
"DataCleaner",
".",
"_validate_filters",
"(",
"entity",
",",
"test_filters",
")",
")"
] | [
510,
4
] | [
518,
76
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
exec | () | Ejecuta una consulta y devuelve el resultado | Ejecuta una consulta y devuelve el resultado | def exec():
"""Ejecuta una consulta y devuelve el resultado"""
# Recupera la consulta a ejecutar
body = request.get_json()
query = body.get('query')
try:
# Ejecuta el query (con el interpreter)
result = interpreter.execution(query)
result = json.loads(json.dumps(result, ignore_nan = True))
return {"result": result, "ok": True}, 200
except Exception as e:
# Retorna un mensaje de error en el servidor
print(e)
return {"ok": False}, 400 | [
"def",
"exec",
"(",
")",
":",
"# Recupera la consulta a ejecutar",
"body",
"=",
"request",
".",
"get_json",
"(",
")",
"query",
"=",
"body",
".",
"get",
"(",
"'query'",
")",
"try",
":",
"# Ejecuta el query (con el interpreter)",
"result",
"=",
"interpreter",
".",
"execution",
"(",
"query",
")",
"result",
"=",
"json",
".",
"loads",
"(",
"json",
".",
"dumps",
"(",
"result",
",",
"ignore_nan",
"=",
"True",
")",
")",
"return",
"{",
"\"result\"",
":",
"result",
",",
"\"ok\"",
":",
"True",
"}",
",",
"200",
"except",
"Exception",
"as",
"e",
":",
"# Retorna un mensaje de error en el servidor",
"print",
"(",
"e",
")",
"return",
"{",
"\"ok\"",
":",
"False",
"}",
",",
"400"
] | [
10,
0
] | [
23,
33
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
Ventana5.play | (self) | Si ban es True el video esta reproduciéndose y se quiere pausar | Si ban es True el video esta reproduciéndose y se quiere pausar | def play(self):
'''Si ban es True el video esta reproduciéndose y se quiere pausar'''
if(self.ban==True):
self.media.set_pause(1)#Se pausa el video
self.ban=False#La bandera se pone en False para que cuando se
#oprima el botón ahora reanude el video
else:
self.media.play()#Se reanuda el video
self.ban=True#La bandera se pone en True para que cuando se | [
"def",
"play",
"(",
"self",
")",
":",
"if",
"(",
"self",
".",
"ban",
"==",
"True",
")",
":",
"self",
".",
"media",
".",
"set_pause",
"(",
"1",
")",
"#Se pausa el video",
"self",
".",
"ban",
"=",
"False",
"#La bandera se pone en False para que cuando se",
"#oprima el botón ahora reanude el video",
"else",
":",
"self",
".",
"media",
".",
"play",
"(",
")",
"#Se reanuda el video",
"self",
".",
"ban",
"=",
"True",
"#La bandera se pone en True para que cuando se"
] | [
303,
4
] | [
311,
71
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
ProfileFeedItem.__str__ | (self) | return self.status_text | Retorna el modelo como string | Retorna el modelo como string | def __str__(self):
"""Retorna el modelo como string"""
return self.status_text | [
"def",
"__str__",
"(",
"self",
")",
":",
"return",
"self",
".",
"status_text"
] | [
68,
4
] | [
70,
31
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
Expediente.comitentes_count | (self) | return self.expedientepersona_set.filter(comitente=True).count() | Devuelve la cantidad de personas que figuran como comitentes. | Devuelve la cantidad de personas que figuran como comitentes. | def comitentes_count(self):
"""Devuelve la cantidad de personas que figuran como comitentes."""
return self.expedientepersona_set.filter(comitente=True).count() | [
"def",
"comitentes_count",
"(",
"self",
")",
":",
"return",
"self",
".",
"expedientepersona_set",
".",
"filter",
"(",
"comitente",
"=",
"True",
")",
".",
"count",
"(",
")"
] | [
297,
4
] | [
299,
72
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
matar | (bicho: int, arma: int) | return (bicho - arma) <= 0 | Recibe un bicho y un arma, ambos enteros que representan
La cantidad de vida del primero, y cuanto daño hace la segunda
y retorna True si la cantidad de vida se disminuye 0 | Recibe un bicho y un arma, ambos enteros que representan
La cantidad de vida del primero, y cuanto daño hace la segunda
y retorna True si la cantidad de vida se disminuye 0 | def matar(bicho: int, arma: int) -> bool:
"""Recibe un bicho y un arma, ambos enteros que representan
La cantidad de vida del primero, y cuanto daño hace la segunda
y retorna True si la cantidad de vida se disminuye 0"""
return (bicho - arma) <= 0 | [
"def",
"matar",
"(",
"bicho",
":",
"int",
",",
"arma",
":",
"int",
")",
"->",
"bool",
":",
"return",
"(",
"bicho",
"-",
"arma",
")",
"<=",
"0"
] | [
0,
0
] | [
4,
30
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
InstantaneousVelocityWithKernelRegression.nadayara_watson_estimator | (t: float,
xs: List[FloatVector2D],
ts: List[float],
h: float,
kernel: Callable[[float, float, float], float]) | return FloatVector2D(*result) | Estimador de la posición aplicando Nadaraya-Watson.
:param t: instante en el que se evalúa.
:param xs: lista de posiciones.
:param ts: lista de instantes.
:param h: bandwidth.
:param kernel: kernel utilizado.
:return: lista de posiciones suavizadas.
| Estimador de la posición aplicando Nadaraya-Watson. | def nadayara_watson_estimator(t: float,
xs: List[FloatVector2D],
ts: List[float],
h: float,
kernel: Callable[[float, float, float], float]) -> FloatVector2D:
"""Estimador de la posición aplicando Nadaraya-Watson.
:param t: instante en el que se evalúa.
:param xs: lista de posiciones.
:param ts: lista de instantes.
:param h: bandwidth.
:param kernel: kernel utilizado.
:return: lista de posiciones suavizadas.
"""
xs = np.array(xs, dtype=np.float64)
ts = np.array(ts, dtype=np.float64)
indexes = list(range(len(ts)))
_num = np.array([kernel(t, ts[i], h) * xs[i] for i in indexes]).sum(axis=0)
_den = np.array([kernel(t, ts[i], h) for i in indexes]).sum(axis=0)
result = _num / _den
return FloatVector2D(*result) | [
"def",
"nadayara_watson_estimator",
"(",
"t",
":",
"float",
",",
"xs",
":",
"List",
"[",
"FloatVector2D",
"]",
",",
"ts",
":",
"List",
"[",
"float",
"]",
",",
"h",
":",
"float",
",",
"kernel",
":",
"Callable",
"[",
"[",
"float",
",",
"float",
",",
"float",
"]",
",",
"float",
"]",
")",
"->",
"FloatVector2D",
":",
"xs",
"=",
"np",
".",
"array",
"(",
"xs",
",",
"dtype",
"=",
"np",
".",
"float64",
")",
"ts",
"=",
"np",
".",
"array",
"(",
"ts",
",",
"dtype",
"=",
"np",
".",
"float64",
")",
"indexes",
"=",
"list",
"(",
"range",
"(",
"len",
"(",
"ts",
")",
")",
")",
"_num",
"=",
"np",
".",
"array",
"(",
"[",
"kernel",
"(",
"t",
",",
"ts",
"[",
"i",
"]",
",",
"h",
")",
"*",
"xs",
"[",
"i",
"]",
"for",
"i",
"in",
"indexes",
"]",
")",
".",
"sum",
"(",
"axis",
"=",
"0",
")",
"_den",
"=",
"np",
".",
"array",
"(",
"[",
"kernel",
"(",
"t",
",",
"ts",
"[",
"i",
"]",
",",
"h",
")",
"for",
"i",
"in",
"indexes",
"]",
")",
".",
"sum",
"(",
"axis",
"=",
"0",
")",
"result",
"=",
"_num",
"/",
"_den",
"return",
"FloatVector2D",
"(",
"*",
"result",
")"
] | [
148,
4
] | [
168,
37
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
TrackedObject.find_in_frame | (self, frame: int) | return TrackedObjectDetection(self.id, self.frames[index], self.detections[index]) | Busca la detección del objeto en el frame indicado.
:param frame: número del frame.
:return: el objeto si fue encontrado o None.
| Busca la detección del objeto en el frame indicado. | def find_in_frame(self, frame: int) -> Optional[TrackedObjectDetection]:
"""Busca la detección del objeto en el frame indicado.
:param frame: número del frame.
:return: el objeto si fue encontrado o None.
"""
try:
index = self.frames.index(frame)
except ValueError:
return None
return TrackedObjectDetection(self.id, self.frames[index], self.detections[index]) | [
"def",
"find_in_frame",
"(",
"self",
",",
"frame",
":",
"int",
")",
"->",
"Optional",
"[",
"TrackedObjectDetection",
"]",
":",
"try",
":",
"index",
"=",
"self",
".",
"frames",
".",
"index",
"(",
"frame",
")",
"except",
"ValueError",
":",
"return",
"None",
"return",
"TrackedObjectDetection",
"(",
"self",
".",
"id",
",",
"self",
".",
"frames",
"[",
"index",
"]",
",",
"self",
".",
"detections",
"[",
"index",
"]",
")"
] | [
73,
4
] | [
83,
90
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
ModelGraphs.plot_acc | (history, title="Model Accuracy") | Imprime una gráfica mostrando la accuracy por epoch obtenida en un entrenamiento | Imprime una gráfica mostrando la accuracy por epoch obtenida en un entrenamiento | def plot_acc(history, title="Model Accuracy"):
"""Imprime una gráfica mostrando la accuracy por epoch obtenida en un entrenamiento"""
plt.plot(history.history['acc'])
plt.plot(history.history['val_acc'])
plt.title(title)
plt.ylabel('Accuracy')
plt.xlabel('Epoch')
plt.legend(['Train', 'Val'], loc='upper left')
plt.show() | [
"def",
"plot_acc",
"(",
"history",
",",
"title",
"=",
"\"Model Accuracy\"",
")",
":",
"plt",
".",
"plot",
"(",
"history",
".",
"history",
"[",
"'acc'",
"]",
")",
"plt",
".",
"plot",
"(",
"history",
".",
"history",
"[",
"'val_acc'",
"]",
")",
"plt",
".",
"title",
"(",
"title",
")",
"plt",
".",
"ylabel",
"(",
"'Accuracy'",
")",
"plt",
".",
"xlabel",
"(",
"'Epoch'",
")",
"plt",
".",
"legend",
"(",
"[",
"'Train'",
",",
"'Val'",
"]",
",",
"loc",
"=",
"'upper left'",
")",
"plt",
".",
"show",
"(",
")"
] | [
6,
4
] | [
14,
18
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
panel | () | return render_template("inicio/panel.html") | Panel principal de la aplicacion. | Panel principal de la aplicacion. | def panel():
"""Panel principal de la aplicacion."""
return render_template("inicio/panel.html") | [
"def",
"panel",
"(",
")",
":",
"return",
"render_template",
"(",
"\"inicio/panel.html\"",
")"
] | [
658,
0
] | [
660,
47
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
registrar | () | return taller | Registra estudiantes en las aulas del taller. | Registra estudiantes en las aulas del taller. | def registrar():
"""Registra estudiantes en las aulas del taller."""
taller = Taller()
for aula in taller.aulas:
print(f"Aula: {aula.nombre}")
while True:
registrar_estudiante(aula)
if not ask_to_finish():
break
return taller | [
"def",
"registrar",
"(",
")",
":",
"taller",
"=",
"Taller",
"(",
")",
"for",
"aula",
"in",
"taller",
".",
"aulas",
":",
"print",
"(",
"f\"Aula: {aula.nombre}\"",
")",
"while",
"True",
":",
"registrar_estudiante",
"(",
"aula",
")",
"if",
"not",
"ask_to_finish",
"(",
")",
":",
"break",
"return",
"taller"
] | [
116,
0
] | [
125,
17
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
HeistSystem.DB_dropTable_Messages | (self) | return True | Benachrichtigungs Tabelle löschen | Benachrichtigungs Tabelle löschen | def DB_dropTable_Messages(self):
''' Benachrichtigungs Tabelle löschen '''
thisActionName = "DB_dropTable_Messages"
# Bestehende Tabelle löschen
sql = "DROP TABLE game_heist_messages"
try:
self.GameDB.execute(sql)
self.GameDB.commit()
except Exception as e:
# Fehler in Log-Datei schreiben
self.Logger.WriteLog(
" --- FEHLER - {0} ---".format(thisActionName))
self.Logger.WriteLog(
" --- EXCEPTION: {0}".format(str(sys.exc_info())))
return False
return True | [
"def",
"DB_dropTable_Messages",
"(",
"self",
")",
":",
"thisActionName",
"=",
"\"DB_dropTable_Messages\"",
"# Bestehende Tabelle löschen\r",
"sql",
"=",
"\"DROP TABLE game_heist_messages\"",
"try",
":",
"self",
".",
"GameDB",
".",
"execute",
"(",
"sql",
")",
"self",
".",
"GameDB",
".",
"commit",
"(",
")",
"except",
"Exception",
"as",
"e",
":",
"# Fehler in Log-Datei schreiben\r",
"self",
".",
"Logger",
".",
"WriteLog",
"(",
"\" --- FEHLER - {0} ---\"",
".",
"format",
"(",
"thisActionName",
")",
")",
"self",
".",
"Logger",
".",
"WriteLog",
"(",
"\" --- EXCEPTION: {0}\"",
".",
"format",
"(",
"str",
"(",
"sys",
".",
"exc_info",
"(",
")",
")",
")",
")",
"return",
"False",
"return",
"True"
] | [
762,
4
] | [
783,
19
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
ispCheckClass.getMeanDose | ( self, field=None ) | return roi.mean() | Die mittlere Dosis eines Angegebenen Bereichs ermitteln
| Die mittlere Dosis eines Angegebenen Bereichs ermitteln
| def getMeanDose( self, field=None ):
"""Die mittlere Dosis eines Angegebenen Bereichs ermitteln
"""
if not field: # pragma: no cover
field = { "X1":-2, "X2": 2, "Y1": -2, "Y2":2 }
# holt den angegebenen Bereich um dort die Dosis zu bestimmen
roi = self.image.getRoi( field ).copy()
#print( roi.mean() )
return roi.mean() | [
"def",
"getMeanDose",
"(",
"self",
",",
"field",
"=",
"None",
")",
":",
"if",
"not",
"field",
":",
"# pragma: no cover",
"field",
"=",
"{",
"\"X1\"",
":",
"-",
"2",
",",
"\"X2\"",
":",
"2",
",",
"\"Y1\"",
":",
"-",
"2",
",",
"\"Y2\"",
":",
"2",
"}",
"# holt den angegebenen Bereich um dort die Dosis zu bestimmen",
"roi",
"=",
"self",
".",
"image",
".",
"getRoi",
"(",
"field",
")",
".",
"copy",
"(",
")",
"#print( roi.mean() )",
"return",
"roi",
".",
"mean",
"(",
")"
] | [
126,
4
] | [
135,
25
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
ariaClass.getImages | ( self,
PatientId=None, CourseId=None,
PlanSetupId=None, RadiationSer=None,
AcquisitionYear=None,
AcquisitionMonth=None,
AcquisitionDay=None,
testTags:list=None, addWhere:str="" ) | return self.execute( sql ), sql | Alle felder holen die für die Auswertungen benötigt werden.
Nicht SliceRTType: SliceDRR verwendet werden: SlicePI :
| Alle felder holen die für die Auswertungen benötigt werden. | def getImages( self,
PatientId=None, CourseId=None,
PlanSetupId=None, RadiationSer=None,
AcquisitionYear=None,
AcquisitionMonth=None,
AcquisitionDay=None,
testTags:list=None, addWhere:str="" ):
"""Alle felder holen die für die Auswertungen benötigt werden.
Nicht SliceRTType: SliceDRR verwendet werden: SlicePI :
"""
if not PatientId and addWhere == "":
return [], ""
# alles aufeinmal holen
sql = """
SELECT [Patient].[PatientId], [Course].[CourseId], [PlanSetup].[PlanSetupId], [Radiation].[RadiationId]
, [Series].[SeriesUID], [Series].[FrameOfReferenceUID]
, [Series].[SeriesId], [Series].[SeriesNumber], [Series].[CreationDate]
, [Slice].[SliceUID], [Study].[StudyUID]
, [SliceRT].[SliceRTType], [SliceRT].[AcqNote], [SliceRT].[Energy],[SliceRT].[MetersetExposure], [SliceRT].[DoseRate], [SliceRT].[SAD], [SliceRT].[GantryAngle], [SliceRT].[CollRtn]
, [SliceRT].[CollX1], [SliceRT].[CollX2], [SliceRT].[CollY1], [SliceRT].[CollY2], [SliceRT].[RadiationMachineName]
, [ExternalField].[GantryRtn], [ExternalField].[GantryRtnExt], [ExternalField].[GantryRtnDirection], [ExternalField].[StopAngle], [ExternalField].[CollMode]
, [Slice].[AcquisitionDateTime], [Slice].[SliceUID], [Slice].[PatientSupportAngle], [Slice].[FileName], [Slice].[SliceModality]
, [MLCPlan].[MLCPlanType], [MLCPlan].[IndexParameterType]
, [Radiation].[RadiationSer], [Radiation].[TechniqueLabel], [Radiation].[Comment]
, [Image].[ImageId]
FROM [{dbname}].[dbo].[Patient] [Patient]
INNER JOIN [{dbname}].[dbo].[Course] [Course] ON ([Patient].[PatientSer] = [Course].[PatientSer])
INNER JOIN [{dbname}].[dbo].[PlanSetup] [PlanSetup] ON ([Course].[CourseSer] = [PlanSetup].[CourseSer])
INNER JOIN [{dbname}].[dbo].[Radiation] [Radiation] ON ([PlanSetup].[PlanSetupSer] = [Radiation].[PlanSetupSer])
INNER JOIN [{dbname}].[dbo].[ExternalField] [ExternalField] ON ([Radiation].[RadiationSer] = [ExternalField].[RadiationSer])
INNER JOIN [{dbname}].[dbo].[SliceRT] [SliceRT] ON ([Radiation].[RadiationSer] = [SliceRT].[RadiationSer])
INNER JOIN [{dbname}].[dbo].[Slice] [Slice] ON ([SliceRT].[SliceSer] = [Slice].[SliceSer])
INNER JOIN [{dbname}].[dbo].[Series] [Series] ON ([Slice].[SeriesSer] = [Series].[SeriesSer])
LEFT JOIN [{dbname}].[dbo].[MLCPlan] [MLCPlan] ON ([Radiation].[RadiationSer] = [MLCPlan].[RadiationSer])
INNER JOIN [{dbname}].[dbo].[Study] [Study] ON ([Series].[StudySer] = [Study].[StudySer])
INNER JOIN [{dbname}].[dbo].[ImageSlice] [ImageSlice] ON ([Slice].[SliceSer] = [ImageSlice].[SliceSer])
INNER JOIN [{dbname}].[dbo].[Image] [Image] ON ([ImageSlice].[ImageSer] = [Image].[ImageSer])
WHERE NOT [SliceRT].[SliceRTType] = 'SliceDRR'
"""
if PatientId:
sql = sql + " AND [Patient].[PatientId] = '{}' ".format( PatientId )
if CourseId:
sql = sql + " AND [Course].[CourseId] = '{}' ".format( CourseId)
if PlanSetupId:
sql = sql + " AND [PlanSetup].[PlanSetupId] = '{}' ".format( PlanSetupId)
if RadiationSer:
sql = sql + " AND [Radiation].[RadiationSer] = {} ".format( RadiationSer)
if AcquisitionYear:
sql = sql + " AND YEAR([Slice].[AcquisitionDateTime]) = {} ".format( AcquisitionYear)
if AcquisitionMonth:
sql = sql + " AND MONTH([Slice].[AcquisitionDateTime]) = {} ".format( AcquisitionMonth )
if AcquisitionDay:
sql = sql + " AND DAY([Slice].[AcquisitionDateTime]) = {} ".format( AcquisitionDay )
if testTags:
subSql = []
for tag in testTags:
subSql.append("CHARINDEX('{}', [Radiation].[Comment] ) > 0".format( tag ) )
if len( subSql ) > 0:
sql += " AND (" + " OR ".join( subSql ) + ")"
if addWhere != "":
sql += " AND " + addWhere
return self.execute( sql ), sql | [
"def",
"getImages",
"(",
"self",
",",
"PatientId",
"=",
"None",
",",
"CourseId",
"=",
"None",
",",
"PlanSetupId",
"=",
"None",
",",
"RadiationSer",
"=",
"None",
",",
"AcquisitionYear",
"=",
"None",
",",
"AcquisitionMonth",
"=",
"None",
",",
"AcquisitionDay",
"=",
"None",
",",
"testTags",
":",
"list",
"=",
"None",
",",
"addWhere",
":",
"str",
"=",
"\"\"",
")",
":",
"if",
"not",
"PatientId",
"and",
"addWhere",
"==",
"\"\"",
":",
"return",
"[",
"]",
",",
"\"\"",
"# alles aufeinmal holen",
"sql",
"=",
"\"\"\"\n SELECT [Patient].[PatientId], [Course].[CourseId], [PlanSetup].[PlanSetupId], [Radiation].[RadiationId]\n , [Series].[SeriesUID], [Series].[FrameOfReferenceUID]\n , [Series].[SeriesId], [Series].[SeriesNumber], [Series].[CreationDate]\n , [Slice].[SliceUID], [Study].[StudyUID]\n , [SliceRT].[SliceRTType], [SliceRT].[AcqNote], [SliceRT].[Energy],[SliceRT].[MetersetExposure], [SliceRT].[DoseRate], [SliceRT].[SAD], [SliceRT].[GantryAngle], [SliceRT].[CollRtn]\n , [SliceRT].[CollX1], [SliceRT].[CollX2], [SliceRT].[CollY1], [SliceRT].[CollY2], [SliceRT].[RadiationMachineName]\n , [ExternalField].[GantryRtn], [ExternalField].[GantryRtnExt], [ExternalField].[GantryRtnDirection], [ExternalField].[StopAngle], [ExternalField].[CollMode]\n , [Slice].[AcquisitionDateTime], [Slice].[SliceUID], [Slice].[PatientSupportAngle], [Slice].[FileName], [Slice].[SliceModality]\n , [MLCPlan].[MLCPlanType], [MLCPlan].[IndexParameterType]\n , [Radiation].[RadiationSer], [Radiation].[TechniqueLabel], [Radiation].[Comment]\n , [Image].[ImageId]\n FROM [{dbname}].[dbo].[Patient] [Patient]\n INNER JOIN [{dbname}].[dbo].[Course] [Course] ON ([Patient].[PatientSer] = [Course].[PatientSer])\n INNER JOIN [{dbname}].[dbo].[PlanSetup] [PlanSetup] ON ([Course].[CourseSer] = [PlanSetup].[CourseSer])\n INNER JOIN [{dbname}].[dbo].[Radiation] [Radiation] ON ([PlanSetup].[PlanSetupSer] = [Radiation].[PlanSetupSer])\n INNER JOIN [{dbname}].[dbo].[ExternalField] [ExternalField] ON ([Radiation].[RadiationSer] = [ExternalField].[RadiationSer])\n INNER JOIN [{dbname}].[dbo].[SliceRT] [SliceRT] ON ([Radiation].[RadiationSer] = [SliceRT].[RadiationSer])\n INNER JOIN [{dbname}].[dbo].[Slice] [Slice] ON ([SliceRT].[SliceSer] = [Slice].[SliceSer])\n INNER JOIN [{dbname}].[dbo].[Series] [Series] ON ([Slice].[SeriesSer] = [Series].[SeriesSer])\n LEFT JOIN [{dbname}].[dbo].[MLCPlan] [MLCPlan] ON ([Radiation].[RadiationSer] = [MLCPlan].[RadiationSer])\n INNER JOIN [{dbname}].[dbo].[Study] [Study] ON ([Series].[StudySer] = [Study].[StudySer])\n INNER JOIN [{dbname}].[dbo].[ImageSlice] [ImageSlice] ON ([Slice].[SliceSer] = [ImageSlice].[SliceSer])\n INNER JOIN [{dbname}].[dbo].[Image] [Image] ON ([ImageSlice].[ImageSer] = [Image].[ImageSer])\n WHERE NOT [SliceRT].[SliceRTType] = 'SliceDRR'\n \"\"\"",
"if",
"PatientId",
":",
"sql",
"=",
"sql",
"+",
"\" AND [Patient].[PatientId] = '{}' \"",
".",
"format",
"(",
"PatientId",
")",
"if",
"CourseId",
":",
"sql",
"=",
"sql",
"+",
"\" AND [Course].[CourseId] = '{}' \"",
".",
"format",
"(",
"CourseId",
")",
"if",
"PlanSetupId",
":",
"sql",
"=",
"sql",
"+",
"\" AND [PlanSetup].[PlanSetupId] = '{}' \"",
".",
"format",
"(",
"PlanSetupId",
")",
"if",
"RadiationSer",
":",
"sql",
"=",
"sql",
"+",
"\" AND [Radiation].[RadiationSer] = {} \"",
".",
"format",
"(",
"RadiationSer",
")",
"if",
"AcquisitionYear",
":",
"sql",
"=",
"sql",
"+",
"\" AND YEAR([Slice].[AcquisitionDateTime]) = {} \"",
".",
"format",
"(",
"AcquisitionYear",
")",
"if",
"AcquisitionMonth",
":",
"sql",
"=",
"sql",
"+",
"\" AND MONTH([Slice].[AcquisitionDateTime]) = {} \"",
".",
"format",
"(",
"AcquisitionMonth",
")",
"if",
"AcquisitionDay",
":",
"sql",
"=",
"sql",
"+",
"\" AND DAY([Slice].[AcquisitionDateTime]) = {} \"",
".",
"format",
"(",
"AcquisitionDay",
")",
"if",
"testTags",
":",
"subSql",
"=",
"[",
"]",
"for",
"tag",
"in",
"testTags",
":",
"subSql",
".",
"append",
"(",
"\"CHARINDEX('{}', [Radiation].[Comment] ) > 0\"",
".",
"format",
"(",
"tag",
")",
")",
"if",
"len",
"(",
"subSql",
")",
">",
"0",
":",
"sql",
"+=",
"\" AND (\"",
"+",
"\" OR \"",
".",
"join",
"(",
"subSql",
")",
"+",
"\")\"",
"if",
"addWhere",
"!=",
"\"\"",
":",
"sql",
"+=",
"\" AND \"",
"+",
"addWhere",
"return",
"self",
".",
"execute",
"(",
"sql",
")",
",",
"sql"
] | [
120,
4
] | [
188,
39
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
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
| Erstzt einen Key durch einen neuen Key. | 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",
"alias",
"(",
"values",
":",
"dict",
",",
"data",
":",
"StepData",
")",
":",
"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",
")"
] | [
241,
0
] | [
254,
41
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
|
checkField.doJT_7_5 | (self, fileData) | return self.pdf.finish(), result | Jahrestest: 7.5. ()
Parameters
----------
fileData : pandas.DataFrame
Returns
-------
pdfFilename : str
Name der erzeugten Pdfdatei
result : list
list mit dicts der Testergebnisse
See Also
--------
isp.results : Aufbau von result
| Jahrestest: 7.5. () | def doJT_7_5(self, fileData):
"""Jahrestest: 7.5. ()
Parameters
----------
fileData : pandas.DataFrame
Returns
-------
pdfFilename : str
Name der erzeugten Pdfdatei
result : list
list mit dicts der Testergebnisse
See Also
--------
isp.results : Aufbau von result
"""
# used on progress
filesMax=len( fileData )
self.fileCount = 0
# holds evaluation results
result=[]
# prepare metadata
md = dict_merge( DotMap( {
"series_sort_values": ["gantry", "StopAngle"],
"series_groupby": ["day"],
"sub_series_groupby": ["energy"],
"querys" : {
"base" : "GantryRtnDirection == 'NONE'",
"fields" : "GantryRtnDirection != 'NONE'",
"sub_base" : "GantryRtnDirection == 'NONE'",
"sub_fields" : "GantryRtnDirection != 'NONE'",
},
"manual": {
"filename": self.metadata.info["anleitung"],
"attrs": {"class":"layout-fill-width", "margin-bottom": "5mm"},
},
"doseArea" : { "X1":-5, "X2": 5, "Y1": -5, "Y2": 5 },
"plotImage": {
"original": False,
"plotTitle": "{Kennung} - G:{von_nach}",
"field": 10,
"invert": True,
"cmap": "gray_r", # gray_r twilight jet
"plotCax": True,
"plotField": True
},
"plotImage_pdf": {
"area" : { "width" : 90, "height" : 90 },
#"attrs": "",
},
"evaluation_table_pdf" : {
"attrs": { "class":"layout-fill-width", "margin-top": "5mm" },
"fields": [
{'field': 'Kennung', 'label':'Kennung', 'format':'{0}', 'style': [('text-align', 'left')] },
# {'field': 'ME', 'label':'MU' },
{'field': 'von_nach', 'label':'Gantry' },
{'field': 'baseMeanDose', 'label':'Dosis', 'format':'{0:.5f}' },
{'field': 'fieldMeanDose', 'label':'Prüf Dosis', 'format':'{0:.5f}' },
{'field': 'diff', 'label':'Abweichung [%]', 'format':'{0:.2f}' },
{'field': 'diff_passed', 'label':'Passed' }
],
},
"table_sort_values_by": ["ME"],
"table_sort_values_ascending": [True],
} ), self.metadata )
# alte Auswertung
pre2020 = False
if md.get("AcquisitionYear", 0) < 2020:
md.evaluation_text = ""
md.tolerance_pdf.mode = "text"
pre2020 = True
#md.pprint(pformat='json')
def evaluate( df_group ):
"""Evaluate grouped Fields
create PDF output and fills result
Parameters
----------
df_group : pandas Dataframe
felder unter 0° sind basis für die winkel felder
Auswertung je doserate
"""
# get base and fields, check number of data
ok, df_base, df_fields = self.evaluationPrepare(df_group, md, result)
if not ok:
return
data = []
# gruppiert nach gantry und kollimator
def sub_evaluate( df ):
# get base and fields, check number of data
# print("doJT_7_5", df[ [ "RadiationId", "gantry", "StopAngle", "collimator", "ME", "doserate", "check_subtag" ] ])
df_base = df.query( md.querys[ "sub_base"] )
df_fields = df.query( md.querys[ "sub_fields"] )
# base Field und dosis bereitstellen
baseField = qa_field( self.getFullData( df_base.loc[df_base.index[0]] ) )
baseMeanDose = baseField.getMeanDose( md["doseArea"] )
# zusätzliche Spalte in fields anlegen
df_fields["von_nach"] = df_group[['gantry','StopAngle']].apply(lambda x : '{:.1f} -> {:.1f}'.format(x[0],x[1]), axis=1)
if pre2020 == True:
data.append({
'Kennung': baseField.infos["Kennung"],
'von_nach': "{:01.1f}".format( baseField.infos["gantry"] ),
'ME': baseField.infos["ME"],
'baseMeanDose': baseMeanDose,
'fieldMeanDose': np.nan,
'diff': np.nan,
})
# alle Felder durchgehen
for info in df_fields.itertuples():
# prüf Field und dosis bereitstellen
checkField = qa_field( self.getFullData(info), normalize="none" )
fieldDose = checkField.getMeanDose( md["doseArea"] )
#
if pre2020 == True:
data.append({
'Kennung': checkField.infos["Kennung"],
'von_nach': checkField.infos["von_nach"],
'ME': checkField.infos["ME"],
'baseMeanDose': np.nan,
'fieldMeanDose': fieldDose,
'diff': (fieldDose-baseMeanDose) / baseMeanDose * 100,
})
else:
data.append({
'Kennung': checkField.infos["Kennung"],
'von_nach': checkField.infos["von_nach"],
'ME': checkField.infos["ME"],
'baseMeanDose': baseMeanDose,
'fieldMeanDose': fieldDose,
})
# Bild anzeigen
img = checkField.image.plotImage( **md["plotImage"] )
self.pdf.image(img, **md["plotImage_pdf"] )
# progress pro file stimmt nicht immer genau (baseimage)
# 40% für die dicom daten 40% für die Auswertung 20 % für das pdf
self.fileCount += 1
if hasattr( logger, "progress"):
logger.progress( md["testId"], 40 + ( 40 / filesMax * self.fileCount ) )
# sub evaluate
#
df_group.groupby( md["sub_series_groupby"] ).apply( sub_evaluate )
evaluation_df = pd.DataFrame( data )
# check tolerance - printout tolerance, evaluation_df and result icon
acceptance = self.evaluationResult( evaluation_df, md, result, 'diff' )
# call evaluate with sorted and grouped fields
fileData.sort_values(md["series_sort_values"]).groupby( md["series_groupby"] ).apply( evaluate )
# abschließen pdfdaten und result zurückgeben
return self.pdf.finish(), result | [
"def",
"doJT_7_5",
"(",
"self",
",",
"fileData",
")",
":",
"# used on progress",
"filesMax",
"=",
"len",
"(",
"fileData",
")",
"self",
".",
"fileCount",
"=",
"0",
"# holds evaluation results",
"result",
"=",
"[",
"]",
"# prepare metadata",
"md",
"=",
"dict_merge",
"(",
"DotMap",
"(",
"{",
"\"series_sort_values\"",
":",
"[",
"\"gantry\"",
",",
"\"StopAngle\"",
"]",
",",
"\"series_groupby\"",
":",
"[",
"\"day\"",
"]",
",",
"\"sub_series_groupby\"",
":",
"[",
"\"energy\"",
"]",
",",
"\"querys\"",
":",
"{",
"\"base\"",
":",
"\"GantryRtnDirection == 'NONE'\"",
",",
"\"fields\"",
":",
"\"GantryRtnDirection != 'NONE'\"",
",",
"\"sub_base\"",
":",
"\"GantryRtnDirection == 'NONE'\"",
",",
"\"sub_fields\"",
":",
"\"GantryRtnDirection != 'NONE'\"",
",",
"}",
",",
"\"manual\"",
":",
"{",
"\"filename\"",
":",
"self",
".",
"metadata",
".",
"info",
"[",
"\"anleitung\"",
"]",
",",
"\"attrs\"",
":",
"{",
"\"class\"",
":",
"\"layout-fill-width\"",
",",
"\"margin-bottom\"",
":",
"\"5mm\"",
"}",
",",
"}",
",",
"\"doseArea\"",
":",
"{",
"\"X1\"",
":",
"-",
"5",
",",
"\"X2\"",
":",
"5",
",",
"\"Y1\"",
":",
"-",
"5",
",",
"\"Y2\"",
":",
"5",
"}",
",",
"\"plotImage\"",
":",
"{",
"\"original\"",
":",
"False",
",",
"\"plotTitle\"",
":",
"\"{Kennung} - G:{von_nach}\"",
",",
"\"field\"",
":",
"10",
",",
"\"invert\"",
":",
"True",
",",
"\"cmap\"",
":",
"\"gray_r\"",
",",
"# gray_r twilight jet",
"\"plotCax\"",
":",
"True",
",",
"\"plotField\"",
":",
"True",
"}",
",",
"\"plotImage_pdf\"",
":",
"{",
"\"area\"",
":",
"{",
"\"width\"",
":",
"90",
",",
"\"height\"",
":",
"90",
"}",
",",
"#\"attrs\": \"\",",
"}",
",",
"\"evaluation_table_pdf\"",
":",
"{",
"\"attrs\"",
":",
"{",
"\"class\"",
":",
"\"layout-fill-width\"",
",",
"\"margin-top\"",
":",
"\"5mm\"",
"}",
",",
"\"fields\"",
":",
"[",
"{",
"'field'",
":",
"'Kennung'",
",",
"'label'",
":",
"'Kennung'",
",",
"'format'",
":",
"'{0}'",
",",
"'style'",
":",
"[",
"(",
"'text-align'",
",",
"'left'",
")",
"]",
"}",
",",
"# {'field': 'ME', 'label':'MU' },",
"{",
"'field'",
":",
"'von_nach'",
",",
"'label'",
":",
"'Gantry'",
"}",
",",
"{",
"'field'",
":",
"'baseMeanDose'",
",",
"'label'",
":",
"'Dosis'",
",",
"'format'",
":",
"'{0:.5f}'",
"}",
",",
"{",
"'field'",
":",
"'fieldMeanDose'",
",",
"'label'",
":",
"'Prüf Dosis',",
" ",
"format':",
"'",
"{0:.5f}' ",
",",
"",
"{",
"'field'",
":",
"'diff'",
",",
"'label'",
":",
"'Abweichung [%]'",
",",
"'format'",
":",
"'{0:.2f}'",
"}",
",",
"{",
"'field'",
":",
"'diff_passed'",
",",
"'label'",
":",
"'Passed'",
"}",
"]",
",",
"}",
",",
"\"table_sort_values_by\"",
":",
"[",
"\"ME\"",
"]",
",",
"\"table_sort_values_ascending\"",
":",
"[",
"True",
"]",
",",
"}",
")",
",",
"self",
".",
"metadata",
")",
"# alte Auswertung",
"pre2020",
"=",
"False",
"if",
"md",
".",
"get",
"(",
"\"AcquisitionYear\"",
",",
"0",
")",
"<",
"2020",
":",
"md",
".",
"evaluation_text",
"=",
"\"\"",
"md",
".",
"tolerance_pdf",
".",
"mode",
"=",
"\"text\"",
"pre2020",
"=",
"True",
"#md.pprint(pformat='json')",
"def",
"evaluate",
"(",
"df_group",
")",
":",
"\"\"\"Evaluate grouped Fields\n\n create PDF output and fills result\n\n Parameters\n ----------\n df_group : pandas Dataframe\n\n\n felder unter 0° sind basis für die winkel felder\n Auswertung je doserate\n \"\"\"",
"# get base and fields, check number of data",
"ok",
",",
"df_base",
",",
"df_fields",
"=",
"self",
".",
"evaluationPrepare",
"(",
"df_group",
",",
"md",
",",
"result",
")",
"if",
"not",
"ok",
":",
"return",
"data",
"=",
"[",
"]",
"# gruppiert nach gantry und kollimator",
"def",
"sub_evaluate",
"(",
"df",
")",
":",
"# get base and fields, check number of data",
"# print(\"doJT_7_5\", df[ [ \"RadiationId\", \"gantry\", \"StopAngle\", \"collimator\", \"ME\", \"doserate\", \"check_subtag\" ] ])",
"df_base",
"=",
"df",
".",
"query",
"(",
"md",
".",
"querys",
"[",
"\"sub_base\"",
"]",
")",
"df_fields",
"=",
"df",
".",
"query",
"(",
"md",
".",
"querys",
"[",
"\"sub_fields\"",
"]",
")",
"# base Field und dosis bereitstellen",
"baseField",
"=",
"qa_field",
"(",
"self",
".",
"getFullData",
"(",
"df_base",
".",
"loc",
"[",
"df_base",
".",
"index",
"[",
"0",
"]",
"]",
")",
")",
"baseMeanDose",
"=",
"baseField",
".",
"getMeanDose",
"(",
"md",
"[",
"\"doseArea\"",
"]",
")",
"# zusätzliche Spalte in fields anlegen",
"df_fields",
"[",
"\"von_nach\"",
"]",
"=",
"df_group",
"[",
"[",
"'gantry'",
",",
"'StopAngle'",
"]",
"]",
".",
"apply",
"(",
"lambda",
"x",
":",
"'{:.1f} -> {:.1f}'",
".",
"format",
"(",
"x",
"[",
"0",
"]",
",",
"x",
"[",
"1",
"]",
")",
",",
"axis",
"=",
"1",
")",
"if",
"pre2020",
"==",
"True",
":",
"data",
".",
"append",
"(",
"{",
"'Kennung'",
":",
"baseField",
".",
"infos",
"[",
"\"Kennung\"",
"]",
",",
"'von_nach'",
":",
"\"{:01.1f}\"",
".",
"format",
"(",
"baseField",
".",
"infos",
"[",
"\"gantry\"",
"]",
")",
",",
"'ME'",
":",
"baseField",
".",
"infos",
"[",
"\"ME\"",
"]",
",",
"'baseMeanDose'",
":",
"baseMeanDose",
",",
"'fieldMeanDose'",
":",
"np",
".",
"nan",
",",
"'diff'",
":",
"np",
".",
"nan",
",",
"}",
")",
"# alle Felder durchgehen",
"for",
"info",
"in",
"df_fields",
".",
"itertuples",
"(",
")",
":",
"# prüf Field und dosis bereitstellen",
"checkField",
"=",
"qa_field",
"(",
"self",
".",
"getFullData",
"(",
"info",
")",
",",
"normalize",
"=",
"\"none\"",
")",
"fieldDose",
"=",
"checkField",
".",
"getMeanDose",
"(",
"md",
"[",
"\"doseArea\"",
"]",
")",
"#",
"if",
"pre2020",
"==",
"True",
":",
"data",
".",
"append",
"(",
"{",
"'Kennung'",
":",
"checkField",
".",
"infos",
"[",
"\"Kennung\"",
"]",
",",
"'von_nach'",
":",
"checkField",
".",
"infos",
"[",
"\"von_nach\"",
"]",
",",
"'ME'",
":",
"checkField",
".",
"infos",
"[",
"\"ME\"",
"]",
",",
"'baseMeanDose'",
":",
"np",
".",
"nan",
",",
"'fieldMeanDose'",
":",
"fieldDose",
",",
"'diff'",
":",
"(",
"fieldDose",
"-",
"baseMeanDose",
")",
"/",
"baseMeanDose",
"*",
"100",
",",
"}",
")",
"else",
":",
"data",
".",
"append",
"(",
"{",
"'Kennung'",
":",
"checkField",
".",
"infos",
"[",
"\"Kennung\"",
"]",
",",
"'von_nach'",
":",
"checkField",
".",
"infos",
"[",
"\"von_nach\"",
"]",
",",
"'ME'",
":",
"checkField",
".",
"infos",
"[",
"\"ME\"",
"]",
",",
"'baseMeanDose'",
":",
"baseMeanDose",
",",
"'fieldMeanDose'",
":",
"fieldDose",
",",
"}",
")",
"# Bild anzeigen",
"img",
"=",
"checkField",
".",
"image",
".",
"plotImage",
"(",
"*",
"*",
"md",
"[",
"\"plotImage\"",
"]",
")",
"self",
".",
"pdf",
".",
"image",
"(",
"img",
",",
"*",
"*",
"md",
"[",
"\"plotImage_pdf\"",
"]",
")",
"# progress pro file stimmt nicht immer genau (baseimage)",
"# 40% für die dicom daten 40% für die Auswertung 20 % für das pdf",
"self",
".",
"fileCount",
"+=",
"1",
"if",
"hasattr",
"(",
"logger",
",",
"\"progress\"",
")",
":",
"logger",
".",
"progress",
"(",
"md",
"[",
"\"testId\"",
"]",
",",
"40",
"+",
"(",
"40",
"/",
"filesMax",
"*",
"self",
".",
"fileCount",
")",
")",
"# sub evaluate",
"#",
"df_group",
".",
"groupby",
"(",
"md",
"[",
"\"sub_series_groupby\"",
"]",
")",
".",
"apply",
"(",
"sub_evaluate",
")",
"evaluation_df",
"=",
"pd",
".",
"DataFrame",
"(",
"data",
")",
"# check tolerance - printout tolerance, evaluation_df and result icon",
"acceptance",
"=",
"self",
".",
"evaluationResult",
"(",
"evaluation_df",
",",
"md",
",",
"result",
",",
"'diff'",
")",
"# call evaluate with sorted and grouped fields",
"fileData",
".",
"sort_values",
"(",
"md",
"[",
"\"series_sort_values\"",
"]",
")",
".",
"groupby",
"(",
"md",
"[",
"\"series_groupby\"",
"]",
")",
".",
"apply",
"(",
"evaluate",
")",
"# abschließen pdfdaten und result zurückgeben",
"return",
"self",
".",
"pdf",
".",
"finish",
"(",
")",
",",
"result"
] | [
800,
4
] | [
968,
40
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
ispResults.upsert | ( self, rows:list=[] ) | return True | Einen update oder insert Befehl in gqa durchführen
Parameters
----------
rows: list
Ein Liste von Objecten mit Feldern aus self.columns
Returns
-------
bool
True wenn das Einfügen möglich war
| Einen update oder insert Befehl in gqa durchführen | def upsert( self, rows:list=[] ):
""" Einen update oder insert Befehl in gqa durchführen
Parameters
----------
rows: list
Ein Liste von Objecten mit Feldern aus self.columns
Returns
-------
bool
True wenn das Einfügen möglich war
"""
if len(rows) == 0:
return False
# print("upsert", rows )
# Dataframe mit gleichem index vorbereiten
upsert_df = pd.DataFrame( rows )
upsert_df.set_index(self.gqa.index.names, inplace=True)
for idx, row in upsert_df.iterrows():
# daten überschreiben oder anhängen
#print( "upsert-idx", idx )
self.gqa.loc[ idx ] = row
return True | [
"def",
"upsert",
"(",
"self",
",",
"rows",
":",
"list",
"=",
"[",
"]",
")",
":",
"if",
"len",
"(",
"rows",
")",
"==",
"0",
":",
"return",
"False",
"# print(\"upsert\", rows )",
"# Dataframe mit gleichem index vorbereiten",
"upsert_df",
"=",
"pd",
".",
"DataFrame",
"(",
"rows",
")",
"upsert_df",
".",
"set_index",
"(",
"self",
".",
"gqa",
".",
"index",
".",
"names",
",",
"inplace",
"=",
"True",
")",
"for",
"idx",
",",
"row",
"in",
"upsert_df",
".",
"iterrows",
"(",
")",
":",
"# daten überschreiben oder anhängen",
"#print( \"upsert-idx\", idx )",
"self",
".",
"gqa",
".",
"loc",
"[",
"idx",
"]",
"=",
"row",
"return",
"True"
] | [
155,
4
] | [
182,
19
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
HeistSystem.DB_get_MessageText | (self, messageType) | return resultList | Auslesen eines Textes aus der Datenbank | Auslesen eines Textes aus der Datenbank | def DB_get_MessageText(self, messageType):
''' Auslesen eines Textes aus der Datenbank '''
thisActionName = "DB_get_MessageText"
resultList = []
# SQL-Abfrage vorbereiten
sql = "SELECT messageText FROM game_heist_messages WHERE messageType = ?"
val = (messageType, )
try:
# SQL-Abfrage ausführen
rows = self.GameDB.execute(sql, val).fetchall()
except Exception as e:
# Fehler in Log-Datei schreiben
self.Logger.WriteLog(
" --- FEHLER - {0} ---".format(thisActionName))
self.Logger.WriteLog(
" --- EXCEPTION: {0}".format(str(sys.exc_info())))
return resultList
# Abfrage lieferte Daten
if rows:
# Für jeden Datensatz ausführen
for row in rows:
# Übergebe Daten an Liste
resultList.append(row[0])
return resultList | [
"def",
"DB_get_MessageText",
"(",
"self",
",",
"messageType",
")",
":",
"thisActionName",
"=",
"\"DB_get_MessageText\"",
"resultList",
"=",
"[",
"]",
"# SQL-Abfrage vorbereiten\r",
"sql",
"=",
"\"SELECT messageText FROM game_heist_messages WHERE messageType = ?\"",
"val",
"=",
"(",
"messageType",
",",
")",
"try",
":",
"# SQL-Abfrage ausführen\r",
"rows",
"=",
"self",
".",
"GameDB",
".",
"execute",
"(",
"sql",
",",
"val",
")",
".",
"fetchall",
"(",
")",
"except",
"Exception",
"as",
"e",
":",
"# Fehler in Log-Datei schreiben\r",
"self",
".",
"Logger",
".",
"WriteLog",
"(",
"\" --- FEHLER - {0} ---\"",
".",
"format",
"(",
"thisActionName",
")",
")",
"self",
".",
"Logger",
".",
"WriteLog",
"(",
"\" --- EXCEPTION: {0}\"",
".",
"format",
"(",
"str",
"(",
"sys",
".",
"exc_info",
"(",
")",
")",
")",
")",
"return",
"resultList",
"# Abfrage lieferte Daten\r",
"if",
"rows",
":",
"# Für jeden Datensatz ausführen\r",
"for",
"row",
"in",
"rows",
":",
"# Übergebe Daten an Liste\r",
"resultList",
".",
"append",
"(",
"row",
"[",
"0",
"]",
")",
"return",
"resultList"
] | [
890,
4
] | [
922,
25
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
init_db | (topics: list, db_path: str) | Initialisiert DB außerhalb des Flask-Kontexts.
Nur wenn noch keine Datenbank im "instance"-Ordner angelegt ist, wird eine neue erstellt.
:param topics: Liste mit allen Themen.
| Initialisiert DB außerhalb des Flask-Kontexts. | def init_db(topics: list, db_path: str):
""" Initialisiert DB außerhalb des Flask-Kontexts.
Nur wenn noch keine Datenbank im "instance"-Ordner angelegt ist, wird eine neue erstellt.
:param topics: Liste mit allen Themen.
"""
global DATABASE_LOCATION
DATABASE_LOCATION = resources.path_from_root(db_path)
if not os.path.exists(DATABASE_LOCATION):
logger.info("Initialize Database ...")
os.makedirs(os.path.dirname(DATABASE_LOCATION), exist_ok=True)
with open_con() as con:
with open(os.path.join(os.path.dirname(os.path.realpath(__file__)), 'schema.sql')) as f:
con.executescript(f.read())
con.commit()
_init_topics(topics)
logger.info("Database initialisation done!") | [
"def",
"init_db",
"(",
"topics",
":",
"list",
",",
"db_path",
":",
"str",
")",
":",
"global",
"DATABASE_LOCATION",
"DATABASE_LOCATION",
"=",
"resources",
".",
"path_from_root",
"(",
"db_path",
")",
"if",
"not",
"os",
".",
"path",
".",
"exists",
"(",
"DATABASE_LOCATION",
")",
":",
"logger",
".",
"info",
"(",
"\"Initialize Database ...\"",
")",
"os",
".",
"makedirs",
"(",
"os",
".",
"path",
".",
"dirname",
"(",
"DATABASE_LOCATION",
")",
",",
"exist_ok",
"=",
"True",
")",
"with",
"open_con",
"(",
")",
"as",
"con",
":",
"with",
"open",
"(",
"os",
".",
"path",
".",
"join",
"(",
"os",
".",
"path",
".",
"dirname",
"(",
"os",
".",
"path",
".",
"realpath",
"(",
"__file__",
")",
")",
",",
"'schema.sql'",
")",
")",
"as",
"f",
":",
"con",
".",
"executescript",
"(",
"f",
".",
"read",
"(",
")",
")",
"con",
".",
"commit",
"(",
")",
"_init_topics",
"(",
"topics",
")",
"logger",
".",
"info",
"(",
"\"Database initialisation done!\"",
")"
] | [
48,
0
] | [
69,
52
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
|
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:
| Generiert eine Audiodatei mithilfe einer bestimmten TTS-API und Konfigurationen dafür. | 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",
"custom",
"(",
"values",
":",
"dict",
",",
"data",
":",
"StepData",
",",
"config",
":",
"dict",
")",
":",
"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",
")"
] | [
122,
0
] | [
158,
60
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
|
strip | (s) | return str(s).strip() | Leerzeichen am Anfang und Ende löschen
:param s: Eingangswert
:type s: alle
:return: bearbeiteter Wert oder None
:rtype: str/None
| Leerzeichen am Anfang und Ende löschen | def strip(s):
""" Leerzeichen am Anfang und Ende löschen
:param s: Eingangswert
:type s: alle
:return: bearbeiteter Wert oder None
:rtype: str/None
"""
if s is None:
return None
return str(s).strip() | [
"def",
"strip",
"(",
"s",
")",
":",
"if",
"s",
"is",
"None",
":",
"return",
"None",
"return",
"str",
"(",
"s",
")",
".",
"strip",
"(",
")"
] | [
30,
0
] | [
40,
25
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
DBConnector.__init__ | ( self, dbfile ) | Instanz einer Datenbank erstellen. | Instanz einer Datenbank erstellen. | def __init__( self, dbfile ):
""" Instanz einer Datenbank erstellen. """
self.ClassName = "DBConnector"
thisActionName = "__init__"
self._connection = sqlite3.connect(
dbfile,
check_same_thread=False,
detect_types=sqlite3.PARSE_DECLTYPES
| sqlite3.PARSE_COLNAMES )
self._cursor = self._connection.cursor() | [
"def",
"__init__",
"(",
"self",
",",
"dbfile",
")",
":",
"self",
".",
"ClassName",
"=",
"\"DBConnector\"",
"thisActionName",
"=",
"\"__init__\"",
"self",
".",
"_connection",
"=",
"sqlite3",
".",
"connect",
"(",
"dbfile",
",",
"check_same_thread",
"=",
"False",
",",
"detect_types",
"=",
"sqlite3",
".",
"PARSE_DECLTYPES",
"|",
"sqlite3",
".",
"PARSE_COLNAMES",
")",
"self",
".",
"_cursor",
"=",
"self",
".",
"_connection",
".",
"cursor",
"(",
")"
] | [
17,
4
] | [
27,
48
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
|
bezierKreisNRM | (n,r,M) | return [ [ [P[0]+M[0], P[1]+M[1]] for P in k] for k in kurven] | Kreis mit Radius r um Punkt M=[x,y] in Bezierkurven, Quadranten n-fach geteilt | Kreis mit Radius r um Punkt M=[x,y] in Bezierkurven, Quadranten n-fach geteilt | def bezierKreisNRM(n,r,M):
'''Kreis mit Radius r um Punkt M=[x,y] in Bezierkurven, Quadranten n-fach geteilt'''
kurven = _bezierKreisNR(n,r)
return [ [ [P[0]+M[0], P[1]+M[1]] for P in k] for k in kurven] | [
"def",
"bezierKreisNRM",
"(",
"n",
",",
"r",
",",
"M",
")",
":",
"kurven",
"=",
"_bezierKreisNR",
"(",
"n",
",",
"r",
")",
"return",
"[",
"[",
"[",
"P",
"[",
"0",
"]",
"+",
"M",
"[",
"0",
"]",
",",
"P",
"[",
"1",
"]",
"+",
"M",
"[",
"1",
"]",
"]",
"for",
"P",
"in",
"k",
"]",
"for",
"k",
"in",
"kurven",
"]"
] | [
69,
0
] | [
72,
66
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
qa_wl._mergeArray | (self, art="all", imageArray=[] ) | image array der jeweiligen Achse (G,C,T) addieren
FIXME: was ist bei unterschiedlichen array größen
| image array der jeweiligen Achse (G,C,T) addieren
FIXME: was ist bei unterschiedlichen array größen
| def _mergeArray(self, art="all", imageArray=[] ):
""" image array der jeweiligen Achse (G,C,T) addieren
FIXME: was ist bei unterschiedlichen array größen
"""
if len( self.mergeArray[art] ) == 0:
self.mergeArray[art] = imageArray
else:
try:
self.mergeArray[art] = np.add( self.mergeArray[art], imageArray )
except:
logger.error("qa_wl.findColliCenter np.add shape size ungleich")
pass
pass | [
"def",
"_mergeArray",
"(",
"self",
",",
"art",
"=",
"\"all\"",
",",
"imageArray",
"=",
"[",
"]",
")",
":",
"if",
"len",
"(",
"self",
".",
"mergeArray",
"[",
"art",
"]",
")",
"==",
"0",
":",
"self",
".",
"mergeArray",
"[",
"art",
"]",
"=",
"imageArray",
"else",
":",
"try",
":",
"self",
".",
"mergeArray",
"[",
"art",
"]",
"=",
"np",
".",
"add",
"(",
"self",
".",
"mergeArray",
"[",
"art",
"]",
",",
"imageArray",
")",
"except",
":",
"logger",
".",
"error",
"(",
"\"qa_wl.findColliCenter np.add shape size ungleich\"",
")",
"pass",
"pass"
] | [
342,
4
] | [
355,
12
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
|
ispBaseWebApp.routeIndex | (self, filepath="" ) | return self.routeFile( filepath, root ) | Verarbeitet normale Aufrufe.
Umgeleitete filepath Pfade:
* resources/ nach server.webserver.resources
* fonts/ nach server.webserver.resources/fonts
* globals/ nach server.webserver.globals
* dbadminframe/ iframe für dbadmin erstellen
* docs nach docs/build/html/
* htmlcov nach docs/
* render/ rendert .phtml in ui/
alles andere wird auch aus ui/ geholt
ohne filepath wird index.html aufgerufen
Parameters
----------
filepath : str, optional
file und path zu einer datei. The default is "".
Returns
-------
output :
Inhalt der geladenen Datei
| Verarbeitet normale Aufrufe. | def routeIndex(self, filepath="" ):
"""Verarbeitet normale Aufrufe.
Umgeleitete filepath Pfade:
* resources/ nach server.webserver.resources
* fonts/ nach server.webserver.resources/fonts
* globals/ nach server.webserver.globals
* dbadminframe/ iframe für dbadmin erstellen
* docs nach docs/build/html/
* htmlcov nach docs/
* render/ rendert .phtml in ui/
alles andere wird auch aus ui/ geholt
ohne filepath wird index.html aufgerufen
Parameters
----------
filepath : str, optional
file und path zu einer datei. The default is "".
Returns
-------
output :
Inhalt der geladenen Datei
"""
# alles normalerweise aus ui verwenden
root = self._config.get("server.webserver.ui", "", replaceVariables = True)
if filepath[:10] == "resources/":
root = self._config.get("server.webserver.resources", "", replaceVariables = True)
filepath = filepath[10:]
elif filepath[:6] == "fonts/":
root = self._config.get("server.webserver.resources", "", replaceVariables = True)
elif filepath[:8] == "globals/":
root = self._config.get("server.webserver.globals", "", replaceVariables = True)
elif filepath[:12] == "apiframe":
return self.routeIFrame( "/api" )
elif filepath[:12] == "dbadminframe":
return self.routeIFrame( "/dbadmin" )
elif filepath[:4] == "docs":
return self.routeDocs( filepath )
elif filepath[:8] == "coverage":
return self.routeCoverage( filepath )
elif filepath[:7] == "render/":
return self.routeRender( filepath[7:] )
elif filepath[-4:] == ".vue" or filepath[:6] == "views/":
self.default_header = {'Content-Type': 'application/javascript; charset=utf-8'}
root = self._config.get("server.webserver.ui", "", replaceVariables = True)
#return self.routeFile( filepath, root )
elif filepath[:9] == "unittest_":
# Spezielle render aufruf für unittest
return self.routeRender( filepath )
else:
# alles andere - ohne angaben index aufrufen
if filepath == "" or filepath == "index.html" or filepath == "index.phtml":
filepath = "index"
return self.routeRender( filepath )
return self.routeFile( filepath, root ) | [
"def",
"routeIndex",
"(",
"self",
",",
"filepath",
"=",
"\"\"",
")",
":",
"# alles normalerweise aus ui verwenden",
"root",
"=",
"self",
".",
"_config",
".",
"get",
"(",
"\"server.webserver.ui\"",
",",
"\"\"",
",",
"replaceVariables",
"=",
"True",
")",
"if",
"filepath",
"[",
":",
"10",
"]",
"==",
"\"resources/\"",
":",
"root",
"=",
"self",
".",
"_config",
".",
"get",
"(",
"\"server.webserver.resources\"",
",",
"\"\"",
",",
"replaceVariables",
"=",
"True",
")",
"filepath",
"=",
"filepath",
"[",
"10",
":",
"]",
"elif",
"filepath",
"[",
":",
"6",
"]",
"==",
"\"fonts/\"",
":",
"root",
"=",
"self",
".",
"_config",
".",
"get",
"(",
"\"server.webserver.resources\"",
",",
"\"\"",
",",
"replaceVariables",
"=",
"True",
")",
"elif",
"filepath",
"[",
":",
"8",
"]",
"==",
"\"globals/\"",
":",
"root",
"=",
"self",
".",
"_config",
".",
"get",
"(",
"\"server.webserver.globals\"",
",",
"\"\"",
",",
"replaceVariables",
"=",
"True",
")",
"elif",
"filepath",
"[",
":",
"12",
"]",
"==",
"\"apiframe\"",
":",
"return",
"self",
".",
"routeIFrame",
"(",
"\"/api\"",
")",
"elif",
"filepath",
"[",
":",
"12",
"]",
"==",
"\"dbadminframe\"",
":",
"return",
"self",
".",
"routeIFrame",
"(",
"\"/dbadmin\"",
")",
"elif",
"filepath",
"[",
":",
"4",
"]",
"==",
"\"docs\"",
":",
"return",
"self",
".",
"routeDocs",
"(",
"filepath",
")",
"elif",
"filepath",
"[",
":",
"8",
"]",
"==",
"\"coverage\"",
":",
"return",
"self",
".",
"routeCoverage",
"(",
"filepath",
")",
"elif",
"filepath",
"[",
":",
"7",
"]",
"==",
"\"render/\"",
":",
"return",
"self",
".",
"routeRender",
"(",
"filepath",
"[",
"7",
":",
"]",
")",
"elif",
"filepath",
"[",
"-",
"4",
":",
"]",
"==",
"\".vue\"",
"or",
"filepath",
"[",
":",
"6",
"]",
"==",
"\"views/\"",
":",
"self",
".",
"default_header",
"=",
"{",
"'Content-Type'",
":",
"'application/javascript; charset=utf-8'",
"}",
"root",
"=",
"self",
".",
"_config",
".",
"get",
"(",
"\"server.webserver.ui\"",
",",
"\"\"",
",",
"replaceVariables",
"=",
"True",
")",
"#return self.routeFile( filepath, root )",
"elif",
"filepath",
"[",
":",
"9",
"]",
"==",
"\"unittest_\"",
":",
"# Spezielle render aufruf für unittest",
"return",
"self",
".",
"routeRender",
"(",
"filepath",
")",
"else",
":",
"# alles andere - ohne angaben index aufrufen",
"if",
"filepath",
"==",
"\"\"",
"or",
"filepath",
"==",
"\"index.html\"",
"or",
"filepath",
"==",
"\"index.phtml\"",
":",
"filepath",
"=",
"\"index\"",
"return",
"self",
".",
"routeRender",
"(",
"filepath",
")",
"return",
"self",
".",
"routeFile",
"(",
"filepath",
",",
"root",
")"
] | [
585,
4
] | [
647,
47
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
HeistSystem.DB_insert_NewPlayer | (self, playerData) | return True | Neuen Spieler in der Datenbank eintragen, falls nocht nicht vorhanden | Neuen Spieler in der Datenbank eintragen, falls nocht nicht vorhanden | def DB_insert_NewPlayer(self, playerData):
''' Neuen Spieler in der Datenbank eintragen, falls nocht nicht vorhanden '''
thisActionName = "DB_insert_NewPlayer"
sql = "INSERT INTO game_heist_gamedata( gameID, gameStartTimestamp, userName, userStake ) VALUES ( ?,?,?,? )"
val = (self.GameID, self.GameStartTimestamp,
playerData["playerName"], playerData["playerStake"])
try:
# SQL-Abfrage ausführen
self.GameDB.execute(sql, val)
self.GameDB.commit()
except Exception as e:
# Fehler in Log-Datei schreiben
self.Logger.WriteLog(
" --- FEHLER - {0} ---".format(thisActionName))
self.Logger.WriteLog(
" --- EXCEPTION: {0}".format(str(sys.exc_info())))
return False
return True | [
"def",
"DB_insert_NewPlayer",
"(",
"self",
",",
"playerData",
")",
":",
"thisActionName",
"=",
"\"DB_insert_NewPlayer\"",
"sql",
"=",
"\"INSERT INTO game_heist_gamedata( gameID, gameStartTimestamp, userName, userStake ) VALUES ( ?,?,?,? )\"",
"val",
"=",
"(",
"self",
".",
"GameID",
",",
"self",
".",
"GameStartTimestamp",
",",
"playerData",
"[",
"\"playerName\"",
"]",
",",
"playerData",
"[",
"\"playerStake\"",
"]",
")",
"try",
":",
"# SQL-Abfrage ausführen\r",
"self",
".",
"GameDB",
".",
"execute",
"(",
"sql",
",",
"val",
")",
"self",
".",
"GameDB",
".",
"commit",
"(",
")",
"except",
"Exception",
"as",
"e",
":",
"# Fehler in Log-Datei schreiben\r",
"self",
".",
"Logger",
".",
"WriteLog",
"(",
"\" --- FEHLER - {0} ---\"",
".",
"format",
"(",
"thisActionName",
")",
")",
"self",
".",
"Logger",
".",
"WriteLog",
"(",
"\" --- EXCEPTION: {0}\"",
".",
"format",
"(",
"str",
"(",
"sys",
".",
"exc_info",
"(",
")",
")",
")",
")",
"return",
"False",
"return",
"True"
] | [
1000,
4
] | [
1023,
19
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
ispTest.test_isp_mpdf_fonts | ( self ) | Testet Fonts für die PDF Erstellung mit fc-list
Benötigte Fonts:
* DejaVuSerif
* Material Design Icons
Returns
-------
None.
| Testet Fonts für die PDF Erstellung mit fc-list
Benötigte Fonts:
* DejaVuSerif
* Material Design Icons
Returns
-------
None.
| def test_isp_mpdf_fonts( self ):
"""Testet Fonts für die PDF Erstellung mit fc-list
Benötigte Fonts:
* DejaVuSerif
* Material Design Icons
Returns
-------
None.
"""
import subprocess
cmd = '/usr/bin/fc-list --format="%{family[0]}\n" | sort | uniq'
output = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE ).communicate()[0]
self.assertIn(
b"Material Design Icons",
output,
"Der Font 'Material Design Icons' fehlt im System"
)
self.assertIn(
b"DejaVu Serif",
output,
"Der Font 'DejaVuSerif' fehlt im System"
) | [
"def",
"test_isp_mpdf_fonts",
"(",
"self",
")",
":",
"import",
"subprocess",
"cmd",
"=",
"'/usr/bin/fc-list --format=\"%{family[0]}\\n\" | sort | uniq'",
"output",
"=",
"subprocess",
".",
"Popen",
"(",
"cmd",
",",
"shell",
"=",
"True",
",",
"stdout",
"=",
"subprocess",
".",
"PIPE",
")",
".",
"communicate",
"(",
")",
"[",
"0",
"]",
"self",
".",
"assertIn",
"(",
"b\"Material Design Icons\"",
",",
"output",
",",
"\"Der Font 'Material Design Icons' fehlt im System\"",
")",
"self",
".",
"assertIn",
"(",
"b\"DejaVu Serif\"",
",",
"output",
",",
"\"Der Font 'DejaVuSerif' fehlt im System\"",
")"
] | [
2417,
4
] | [
2447,
13
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
|
plotImage.mm2dots | ( self, point ) | return Point( self.mm2dots_X(point.x), self.mm2dots_Y(point.y) ) | Wandelt Point Angaben von mm nach dot.
Parameters
----------
point : Point
| Wandelt Point Angaben von mm nach dot.
Parameters
----------
point : Point
| def mm2dots( self, point ):
"""Wandelt Point Angaben von mm nach dot.
Parameters
----------
point : Point
"""
return Point( self.mm2dots_X(point.x), self.mm2dots_Y(point.y) ) | [
"def",
"mm2dots",
"(",
"self",
",",
"point",
")",
":",
"return",
"Point",
"(",
"self",
".",
"mm2dots_X",
"(",
"point",
".",
"x",
")",
",",
"self",
".",
"mm2dots_Y",
"(",
"point",
".",
"y",
")",
")"
] | [
109,
4
] | [
117,
72
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
HeistSystem.DB_get_LastID | (self) | return lastHeistID | Auslesen der letzten HeistID aus der Datenbank | Auslesen der letzten HeistID aus der Datenbank | def DB_get_LastID(self):
''' Auslesen der letzten HeistID aus der Datenbank '''
thisActionName = "DB_get_LastID"
# SQL-Abfrage vorbereiten
sql = "SELECT MAX(gameID) FROM game_heist_gamedata"
try:
# SQL-Abfrage ausführen
lastHeistID = self.GameDB.execute(sql).fetchone()[0]
except Exception as e:
# Fehler in Log-Datei schreiben
self.Logger.WriteLog(
" --- FEHLER - {0} ---".format(thisActionName))
self.Logger.WriteLog(
" --- EXCEPTION: {0}".format(str(sys.exc_info())))
if not lastHeistID:
lastHeistID = 0
return lastHeistID | [
"def",
"DB_get_LastID",
"(",
"self",
")",
":",
"thisActionName",
"=",
"\"DB_get_LastID\"",
"# SQL-Abfrage vorbereiten\r",
"sql",
"=",
"\"SELECT MAX(gameID) FROM game_heist_gamedata\"",
"try",
":",
"# SQL-Abfrage ausführen\r",
"lastHeistID",
"=",
"self",
".",
"GameDB",
".",
"execute",
"(",
"sql",
")",
".",
"fetchone",
"(",
")",
"[",
"0",
"]",
"except",
"Exception",
"as",
"e",
":",
"# Fehler in Log-Datei schreiben\r",
"self",
".",
"Logger",
".",
"WriteLog",
"(",
"\" --- FEHLER - {0} ---\"",
".",
"format",
"(",
"thisActionName",
")",
")",
"self",
".",
"Logger",
".",
"WriteLog",
"(",
"\" --- EXCEPTION: {0}\"",
".",
"format",
"(",
"str",
"(",
"sys",
".",
"exc_info",
"(",
")",
")",
")",
")",
"if",
"not",
"lastHeistID",
":",
"lastHeistID",
"=",
"0",
"return",
"lastHeistID"
] | [
866,
4
] | [
888,
26
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
Circle.minmax | (self) | return [self.center[0]-self.radius, self.center[0]+self.radius,
self.center[1]-self.radius, self.center[1]+self.radius] | Die Funktion bestimmt das Minimum und Maximum auf der x- und der
y-Achse (return [<min-x>, <max-x>, <min-y>, <max-y>])
| Die Funktion bestimmt das Minimum und Maximum auf der x- und der
y-Achse (return [<min-x>, <max-x>, <min-y>, <max-y>])
| def minmax(self):
""" Die Funktion bestimmt das Minimum und Maximum auf der x- und der
y-Achse (return [<min-x>, <max-x>, <min-y>, <max-y>])
"""
return [self.center[0]-self.radius, self.center[0]+self.radius,
self.center[1]-self.radius, self.center[1]+self.radius] | [
"def",
"minmax",
"(",
"self",
")",
":",
"return",
"[",
"self",
".",
"center",
"[",
"0",
"]",
"-",
"self",
".",
"radius",
",",
"self",
".",
"center",
"[",
"0",
"]",
"+",
"self",
".",
"radius",
",",
"self",
".",
"center",
"[",
"1",
"]",
"-",
"self",
".",
"radius",
",",
"self",
".",
"center",
"[",
"1",
"]",
"+",
"self",
".",
"radius",
"]"
] | [
259,
4
] | [
264,
71
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
qa_wl.plotChart | (self, chartSize={}, text="") | return self.getPlot() | Alle Achsen charts ausgeben
| Alle Achsen charts ausgeben
| def plotChart(self, chartSize={}, text=""):
"""Alle Achsen charts ausgeben
"""
fig, ax = self.initPlot( chartSize, True, nrows=2, ncols=2 )
#print( self.centers )
rms = {}
for mpl_axis, wl_axis, title, color in zip_longest(
ax.flatten(), ["G", "C", "T"], ["Gantry", "Kollimator", "Tisch"], ["g", "m", "c"]
):
#print( mpl_axis, wl_axis)
if wl_axis in ["G", "C", "T"]:
try:
rms[ wl_axis ] = self._axisChart( mpl_axis, wl_axis, title, color )
except:
# print( "plotChart", mpl_axis, wl_axis, title, color )
pass
else:
# jetzt sind in rms alle achsen
# Initialise the spider plot
mpl_axis.axis('off')
gs = fig.add_gridspec( 2, 4)
ax = fig.add_subplot( gs[1, 2 ], polar=True )
#ax = plt.subplot(2,2,4, polar=True, )
#print("WL.plotChart", gs )
ax.set_title( "RMS", position=(0.5, 1.1) )
# If you want the first axis to be on top:
ax.set_theta_offset(pi / 2)
ax.set_theta_direction(-1)
ax.plot( rms[ "G" ]["angles"], rms[ "G" ]["rms"], 'go', ls='-', label='Gantry', alpha=1, markersize=4 )
#ax.fill( rms[ "G" ]["angles"], rms[ "G" ]["rms"], color="green", alpha=0.4 )
ax.plot( rms[ "C" ]["angles"], rms[ "C" ]["rms"], 'm^', ls='-', label='Kollimator',alpha=1, markersize=4 )
#ax.fill( rms[ "C" ]["angles"], rms[ "C" ]["rms"], color="blue", alpha=0.4 )
ax.plot( rms[ "T" ]["angles"], rms[ "T" ]["rms"], 'cs', ls='-', label='Tisch', alpha=1, markersize=4 )
# Draw ylabels
ax.set_rlabel_position(0)
# Achsenlimit
# wenn die maximalen y Werte kleiner 1 sind immer limit 0/1 verwenden
ylimit = ax.get_ylim()
#print("ylimit-RMS", ax.get_ylim() )
if max(ax.get_ylim()) < 1:
ylimit = [0, 1]
ax.set_ylim( ylimit )
# skalierung der Achse
ax.yaxis.set_major_formatter(ticker.FormatStrFormatter('%0.2f'))
plt.yticks(np.arange( ylimit[0], ylimit[1] , 0.25 ), color="grey", size=9)
# legende
ax.legend(numpoints=1, loc=(0.9, .9) )
# text
ax = fig.add_subplot( gs[1, -1 ] )
ax.axis('off')
# np.max gibt einen fehler bei leerem Array deshalb abfangen
gmax = 0
cmax = 0
tmax = 0
if len( rms[ "G" ]["rms"] ) > 1:
gmax = np.max( rms[ "G" ]["rms"] )
if len( rms[ "C" ]["rms"] ) > 1:
cmax = np.max( rms[ "C" ]["rms"] )
if len( rms[ "T" ]["rms"] ) > 1:
tmax = np.max( rms[ "T" ]["rms"] )
ft = """
Virt. ISO (x/y): {:1.3f} / {:1.3f}\n
Max. Gantry Abweichung: {:1.3f}\n
Max. Kollimator Abweichung: {:1.3f}\n
Max. Tisch Abweichung: {:1.3f}\n
{}
""".format(self.virtualCenter.x , self.virtualCenter.y,
gmax,
cmax,
tmax,
text
)
ft = re.sub('[ \t]+' , ' ', ft)
#print( ft.splitlines() )
#t = ""
#for line in ft.splitlines():
#print("line", line.trim() )
#t += line.trim()
ax.text(0, 0, ft, fontsize=20, bbox=dict(facecolor='yellow', alpha=0.3))
plt.tight_layout(pad=0.4, w_pad=0.1, h_pad=1.0)
plt.subplots_adjust( hspace=0.4, wspace=0.2)
return self.getPlot() | [
"def",
"plotChart",
"(",
"self",
",",
"chartSize",
"=",
"{",
"}",
",",
"text",
"=",
"\"\"",
")",
":",
"fig",
",",
"ax",
"=",
"self",
".",
"initPlot",
"(",
"chartSize",
",",
"True",
",",
"nrows",
"=",
"2",
",",
"ncols",
"=",
"2",
")",
"#print( self.centers )",
"rms",
"=",
"{",
"}",
"for",
"mpl_axis",
",",
"wl_axis",
",",
"title",
",",
"color",
"in",
"zip_longest",
"(",
"ax",
".",
"flatten",
"(",
")",
",",
"[",
"\"G\"",
",",
"\"C\"",
",",
"\"T\"",
"]",
",",
"[",
"\"Gantry\"",
",",
"\"Kollimator\"",
",",
"\"Tisch\"",
"]",
",",
"[",
"\"g\"",
",",
"\"m\"",
",",
"\"c\"",
"]",
")",
":",
"#print( mpl_axis, wl_axis)",
"if",
"wl_axis",
"in",
"[",
"\"G\"",
",",
"\"C\"",
",",
"\"T\"",
"]",
":",
"try",
":",
"rms",
"[",
"wl_axis",
"]",
"=",
"self",
".",
"_axisChart",
"(",
"mpl_axis",
",",
"wl_axis",
",",
"title",
",",
"color",
")",
"except",
":",
"# print( \"plotChart\", mpl_axis, wl_axis, title, color )",
"pass",
"else",
":",
"# jetzt sind in rms alle achsen",
"# Initialise the spider plot",
"mpl_axis",
".",
"axis",
"(",
"'off'",
")",
"gs",
"=",
"fig",
".",
"add_gridspec",
"(",
"2",
",",
"4",
")",
"ax",
"=",
"fig",
".",
"add_subplot",
"(",
"gs",
"[",
"1",
",",
"2",
"]",
",",
"polar",
"=",
"True",
")",
"#ax = plt.subplot(2,2,4, polar=True, )",
"#print(\"WL.plotChart\", gs )",
"ax",
".",
"set_title",
"(",
"\"RMS\"",
",",
"position",
"=",
"(",
"0.5",
",",
"1.1",
")",
")",
"# If you want the first axis to be on top:",
"ax",
".",
"set_theta_offset",
"(",
"pi",
"/",
"2",
")",
"ax",
".",
"set_theta_direction",
"(",
"-",
"1",
")",
"ax",
".",
"plot",
"(",
"rms",
"[",
"\"G\"",
"]",
"[",
"\"angles\"",
"]",
",",
"rms",
"[",
"\"G\"",
"]",
"[",
"\"rms\"",
"]",
",",
"'go'",
",",
"ls",
"=",
"'-'",
",",
"label",
"=",
"'Gantry'",
",",
"alpha",
"=",
"1",
",",
"markersize",
"=",
"4",
")",
"#ax.fill( rms[ \"G\" ][\"angles\"], rms[ \"G\" ][\"rms\"], color=\"green\", alpha=0.4 )",
"ax",
".",
"plot",
"(",
"rms",
"[",
"\"C\"",
"]",
"[",
"\"angles\"",
"]",
",",
"rms",
"[",
"\"C\"",
"]",
"[",
"\"rms\"",
"]",
",",
"'m^'",
",",
"ls",
"=",
"'-'",
",",
"label",
"=",
"'Kollimator'",
",",
"alpha",
"=",
"1",
",",
"markersize",
"=",
"4",
")",
"#ax.fill( rms[ \"C\" ][\"angles\"], rms[ \"C\" ][\"rms\"], color=\"blue\", alpha=0.4 )",
"ax",
".",
"plot",
"(",
"rms",
"[",
"\"T\"",
"]",
"[",
"\"angles\"",
"]",
",",
"rms",
"[",
"\"T\"",
"]",
"[",
"\"rms\"",
"]",
",",
"'cs'",
",",
"ls",
"=",
"'-'",
",",
"label",
"=",
"'Tisch'",
",",
"alpha",
"=",
"1",
",",
"markersize",
"=",
"4",
")",
"# Draw ylabels",
"ax",
".",
"set_rlabel_position",
"(",
"0",
")",
"# Achsenlimit",
"# wenn die maximalen y Werte kleiner 1 sind immer limit 0/1 verwenden ",
"ylimit",
"=",
"ax",
".",
"get_ylim",
"(",
")",
"#print(\"ylimit-RMS\", ax.get_ylim() )",
"if",
"max",
"(",
"ax",
".",
"get_ylim",
"(",
")",
")",
"<",
"1",
":",
"ylimit",
"=",
"[",
"0",
",",
"1",
"]",
"ax",
".",
"set_ylim",
"(",
"ylimit",
")",
"# skalierung der Achse",
"ax",
".",
"yaxis",
".",
"set_major_formatter",
"(",
"ticker",
".",
"FormatStrFormatter",
"(",
"'%0.2f'",
")",
")",
"plt",
".",
"yticks",
"(",
"np",
".",
"arange",
"(",
"ylimit",
"[",
"0",
"]",
",",
"ylimit",
"[",
"1",
"]",
",",
"0.25",
")",
",",
"color",
"=",
"\"grey\"",
",",
"size",
"=",
"9",
")",
"# legende",
"ax",
".",
"legend",
"(",
"numpoints",
"=",
"1",
",",
"loc",
"=",
"(",
"0.9",
",",
".9",
")",
")",
"# text",
"ax",
"=",
"fig",
".",
"add_subplot",
"(",
"gs",
"[",
"1",
",",
"-",
"1",
"]",
")",
"ax",
".",
"axis",
"(",
"'off'",
")",
"# np.max gibt einen fehler bei leerem Array deshalb abfangen",
"gmax",
"=",
"0",
"cmax",
"=",
"0",
"tmax",
"=",
"0",
"if",
"len",
"(",
"rms",
"[",
"\"G\"",
"]",
"[",
"\"rms\"",
"]",
")",
">",
"1",
":",
"gmax",
"=",
"np",
".",
"max",
"(",
"rms",
"[",
"\"G\"",
"]",
"[",
"\"rms\"",
"]",
")",
"if",
"len",
"(",
"rms",
"[",
"\"C\"",
"]",
"[",
"\"rms\"",
"]",
")",
">",
"1",
":",
"cmax",
"=",
"np",
".",
"max",
"(",
"rms",
"[",
"\"C\"",
"]",
"[",
"\"rms\"",
"]",
")",
"if",
"len",
"(",
"rms",
"[",
"\"T\"",
"]",
"[",
"\"rms\"",
"]",
")",
">",
"1",
":",
"tmax",
"=",
"np",
".",
"max",
"(",
"rms",
"[",
"\"T\"",
"]",
"[",
"\"rms\"",
"]",
")",
"ft",
"=",
"\"\"\"\n Virt. ISO (x/y): {:1.3f} / {:1.3f}\\n\n Max. Gantry Abweichung: {:1.3f}\\n\n Max. Kollimator Abweichung: {:1.3f}\\n\n Max. Tisch Abweichung: {:1.3f}\\n\n {}\n \"\"\"",
".",
"format",
"(",
"self",
".",
"virtualCenter",
".",
"x",
",",
"self",
".",
"virtualCenter",
".",
"y",
",",
"gmax",
",",
"cmax",
",",
"tmax",
",",
"text",
")",
"ft",
"=",
"re",
".",
"sub",
"(",
"'[ \\t]+'",
",",
"' '",
",",
"ft",
")",
"#print( ft.splitlines() )",
"#t = \"\"",
"#for line in ft.splitlines():",
"#print(\"line\", line.trim() )",
"#t += line.trim()",
"ax",
".",
"text",
"(",
"0",
",",
"0",
",",
"ft",
",",
"fontsize",
"=",
"20",
",",
"bbox",
"=",
"dict",
"(",
"facecolor",
"=",
"'yellow'",
",",
"alpha",
"=",
"0.3",
")",
")",
"plt",
".",
"tight_layout",
"(",
"pad",
"=",
"0.4",
",",
"w_pad",
"=",
"0.1",
",",
"h_pad",
"=",
"1.0",
")",
"plt",
".",
"subplots_adjust",
"(",
"hspace",
"=",
"0.4",
",",
"wspace",
"=",
"0.2",
")",
"return",
"self",
".",
"getPlot",
"(",
")"
] | [
513,
4
] | [
609,
29
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
register_transform | (func) | return register_type_func(TRANSFORM_TYPES, TransformError, func) | Registriert die übergebene Funktion und versieht sie mit einem `"try/except"`-Block.
Fügt eine Typ-Funktion dem Dictionary TRANSFORM_TYPES hinzu.
:param func: die zu registrierende Funktion
:return: Funktion mit try/except-Block
| Registriert die übergebene Funktion und versieht sie mit einem `"try/except"`-Block.
Fügt eine Typ-Funktion dem Dictionary TRANSFORM_TYPES hinzu. | def register_transform(func):
"""Registriert die übergebene Funktion und versieht sie mit einem `"try/except"`-Block.
Fügt eine Typ-Funktion dem Dictionary TRANSFORM_TYPES hinzu.
:param func: die zu registrierende Funktion
:return: Funktion mit try/except-Block
"""
return register_type_func(TRANSFORM_TYPES, TransformError, func) | [
"def",
"register_transform",
"(",
"func",
")",
":",
"return",
"register_type_func",
"(",
"TRANSFORM_TYPES",
",",
"TransformError",
",",
"func",
")"
] | [
41,
0
] | [
48,
68
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
ispDicom.PATIENT | ( self, query:dict={} ) | return self.query( ds ) | Führt eine suche nach PATIENT durch.
Wie query mit einem default Dataset
Parameters
----------
query : dict, optional
query parameter für ds. The default is {}.
Returns
-------
results : list
gefundene daten
status : hex
Rückgabecode von send_c_find::
| Führt eine suche nach PATIENT durch. | def PATIENT( self, query:dict={} ):
"""Führt eine suche nach PATIENT durch.
Wie query mit einem default Dataset
Parameters
----------
query : dict, optional
query parameter für ds. The default is {}.
Returns
-------
results : list
gefundene daten
status : hex
Rückgabecode von send_c_find::
"""
ds_model = dicomQueryDefaults["PATIENT"].copy()
ds_model.update( query )
ds = Dataset()
for name, value in ds_model.items():
ds.__setattr__(name, value)
# Abfrage durchführen
return self.query( ds ) | [
"def",
"PATIENT",
"(",
"self",
",",
"query",
":",
"dict",
"=",
"{",
"}",
")",
":",
"ds_model",
"=",
"dicomQueryDefaults",
"[",
"\"PATIENT\"",
"]",
".",
"copy",
"(",
")",
"ds_model",
".",
"update",
"(",
"query",
")",
"ds",
"=",
"Dataset",
"(",
")",
"for",
"name",
",",
"value",
"in",
"ds_model",
".",
"items",
"(",
")",
":",
"ds",
".",
"__setattr__",
"(",
"name",
",",
"value",
")",
"# Abfrage durchführen",
"return",
"self",
".",
"query",
"(",
"ds",
")"
] | [
702,
4
] | [
728,
31
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
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.
| Ließt Daten aus einer memory-Datei (JSON-Format) zu einem bestimmtem Datum. | 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:
folder = values.get("memory_folder", data.get_config("job_name"))
if "memory_folder" in list(values.keys()):
skip = values.get("skip_today", False)
use_last = values.get("use_last", 1)
hist_data = []
for offset in range(1, use_last + 1):
with resources.open_specific_memory_resource(folder, values["name"], skip, offset) as fp:
hist_data.append(json.loads(fp.read()))
data.insert_data(save_key, hist_data, values)
else:
if values.get("timedelta", None) is None:
skip = values.get("skip_today", False)
with resources.open_specific_memory_resource(data.get_config("job_name"), values["name"], skip, values.get("use_last", 1)) as fp:
data.insert_data(save_key, json.loads(fp.read()), values)
else:
with resources.open_memory_resource(folder, 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",
"request_memory",
"(",
"values",
":",
"dict",
",",
"data",
":",
"StepData",
",",
"name",
":",
"str",
",",
"save_key",
",",
"ignore_testing",
"=",
"False",
")",
":",
"try",
":",
"folder",
"=",
"values",
".",
"get",
"(",
"\"memory_folder\"",
",",
"data",
".",
"get_config",
"(",
"\"job_name\"",
")",
")",
"if",
"\"memory_folder\"",
"in",
"list",
"(",
"values",
".",
"keys",
"(",
")",
")",
":",
"skip",
"=",
"values",
".",
"get",
"(",
"\"skip_today\"",
",",
"False",
")",
"use_last",
"=",
"values",
".",
"get",
"(",
"\"use_last\"",
",",
"1",
")",
"hist_data",
"=",
"[",
"]",
"for",
"offset",
"in",
"range",
"(",
"1",
",",
"use_last",
"+",
"1",
")",
":",
"with",
"resources",
".",
"open_specific_memory_resource",
"(",
"folder",
",",
"values",
"[",
"\"name\"",
"]",
",",
"skip",
",",
"offset",
")",
"as",
"fp",
":",
"hist_data",
".",
"append",
"(",
"json",
".",
"loads",
"(",
"fp",
".",
"read",
"(",
")",
")",
")",
"data",
".",
"insert_data",
"(",
"save_key",
",",
"hist_data",
",",
"values",
")",
"else",
":",
"if",
"values",
".",
"get",
"(",
"\"timedelta\"",
",",
"None",
")",
"is",
"None",
":",
"skip",
"=",
"values",
".",
"get",
"(",
"\"skip_today\"",
",",
"False",
")",
"with",
"resources",
".",
"open_specific_memory_resource",
"(",
"data",
".",
"get_config",
"(",
"\"job_name\"",
")",
",",
"values",
"[",
"\"name\"",
"]",
",",
"skip",
",",
"values",
".",
"get",
"(",
"\"use_last\"",
",",
"1",
")",
")",
"as",
"fp",
":",
"data",
".",
"insert_data",
"(",
"save_key",
",",
"json",
".",
"loads",
"(",
"fp",
".",
"read",
"(",
")",
")",
",",
"values",
")",
"else",
":",
"with",
"resources",
".",
"open_memory_resource",
"(",
"folder",
",",
"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",
")"
] | [
75,
0
] | [
103,
80
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
|
ImageTaggingCNN._downsampling_layer | (self, input, num_of_kernel) | return Conv2D(
filters=num_of_kernel,
kernel_size=3,
strides=2,
kernel_initializer='VarianceScaling')(input) | Ein Convolution Layer mit 3 x 3 Kernel und 2px Stride
:tensor|list input: Die Tensoren aus vorherigen Layer
:int num_of_kernel: Die Anzahl der Kernel (Filter)
| Ein Convolution Layer mit 3 x 3 Kernel und 2px Stride | def _downsampling_layer(self, input, num_of_kernel):
""" Ein Convolution Layer mit 3 x 3 Kernel und 2px Stride
:tensor|list input: Die Tensoren aus vorherigen Layer
:int num_of_kernel: Die Anzahl der Kernel (Filter)
"""
return Conv2D(
filters=num_of_kernel,
kernel_size=3,
strides=2,
kernel_initializer='VarianceScaling')(input) | [
"def",
"_downsampling_layer",
"(",
"self",
",",
"input",
",",
"num_of_kernel",
")",
":",
"return",
"Conv2D",
"(",
"filters",
"=",
"num_of_kernel",
",",
"kernel_size",
"=",
"3",
",",
"strides",
"=",
"2",
",",
"kernel_initializer",
"=",
"'VarianceScaling'",
")",
"(",
"input",
")"
] | [
59,
4
] | [
69,
56
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
Circle.intersect_line | (self, line, rtol=1e-03, atol=1e-03, include_end=False) | Von einem Circle-Objekt und einem Line-Objekt werden die
Schnittpunkte bestimmt und in einer Liste ausgegeben.
| Von einem Circle-Objekt und einem Line-Objekt werden die
Schnittpunkte bestimmt und in einer Liste ausgegeben.
| def intersect_line(self, line, rtol=1e-03, atol=1e-03, include_end=False):
""" Von einem Circle-Objekt und einem Line-Objekt werden die
Schnittpunkte bestimmt und in einer Liste ausgegeben.
"""
line_m = line.m()
p = []
if line_m is None:
p = [line.p1[0], self.center[1]]
elif np.isclose(line_m, 0.0, rtol, atol):
p = [self.center[0], line.p1[1]]
else:
m = -1/line_m
p = lines_intersect_point(line.p1, line_m, line.n(line_m),
self.center, m, line_n(self.center, m))
d = distance(self.center, p)
if np.isclose(d, self.radius, rtol, atol):
if line.is_point_inside(p, rtol, atol, include_end):
# Wenn der Abstand d dem Radius entspricht, handelt es sich um
# eine Tangente und es gibt genau einen Schnittpunkt
if include_end:
return [p]
else:
return []
if self.radius < d:
# d liegt ausserhalb des Kreises -> kein Schnittpunkt
return []
A = np.sqrt(self.radius**2 - d**2)
delta = alpha_line(line.p1, line.p2)
p1 = point(p, -A, delta)
p2 = point(p, A, delta)
# Die Schnittpunkte p1 und p2 sind bestimmt. Nun muss noch sicher
# gestellt werden, dass sie innerhalb des Start- und Endpunkts der
# Linie liegen
p1_inside = line.is_point_inside(p1, rtol, atol, include_end)
p2_inside = line.is_point_inside(p2, rtol, atol, include_end)
if p1_inside:
if p2_inside:
return [p1, p2]
else:
return[p1]
else:
if p2_inside:
return[p2]
else:
return [] | [
"def",
"intersect_line",
"(",
"self",
",",
"line",
",",
"rtol",
"=",
"1e-03",
",",
"atol",
"=",
"1e-03",
",",
"include_end",
"=",
"False",
")",
":",
"line_m",
"=",
"line",
".",
"m",
"(",
")",
"p",
"=",
"[",
"]",
"if",
"line_m",
"is",
"None",
":",
"p",
"=",
"[",
"line",
".",
"p1",
"[",
"0",
"]",
",",
"self",
".",
"center",
"[",
"1",
"]",
"]",
"elif",
"np",
".",
"isclose",
"(",
"line_m",
",",
"0.0",
",",
"rtol",
",",
"atol",
")",
":",
"p",
"=",
"[",
"self",
".",
"center",
"[",
"0",
"]",
",",
"line",
".",
"p1",
"[",
"1",
"]",
"]",
"else",
":",
"m",
"=",
"-",
"1",
"/",
"line_m",
"p",
"=",
"lines_intersect_point",
"(",
"line",
".",
"p1",
",",
"line_m",
",",
"line",
".",
"n",
"(",
"line_m",
")",
",",
"self",
".",
"center",
",",
"m",
",",
"line_n",
"(",
"self",
".",
"center",
",",
"m",
")",
")",
"d",
"=",
"distance",
"(",
"self",
".",
"center",
",",
"p",
")",
"if",
"np",
".",
"isclose",
"(",
"d",
",",
"self",
".",
"radius",
",",
"rtol",
",",
"atol",
")",
":",
"if",
"line",
".",
"is_point_inside",
"(",
"p",
",",
"rtol",
",",
"atol",
",",
"include_end",
")",
":",
"# Wenn der Abstand d dem Radius entspricht, handelt es sich um",
"# eine Tangente und es gibt genau einen Schnittpunkt",
"if",
"include_end",
":",
"return",
"[",
"p",
"]",
"else",
":",
"return",
"[",
"]",
"if",
"self",
".",
"radius",
"<",
"d",
":",
"# d liegt ausserhalb des Kreises -> kein Schnittpunkt",
"return",
"[",
"]",
"A",
"=",
"np",
".",
"sqrt",
"(",
"self",
".",
"radius",
"**",
"2",
"-",
"d",
"**",
"2",
")",
"delta",
"=",
"alpha_line",
"(",
"line",
".",
"p1",
",",
"line",
".",
"p2",
")",
"p1",
"=",
"point",
"(",
"p",
",",
"-",
"A",
",",
"delta",
")",
"p2",
"=",
"point",
"(",
"p",
",",
"A",
",",
"delta",
")",
"# Die Schnittpunkte p1 und p2 sind bestimmt. Nun muss noch sicher",
"# gestellt werden, dass sie innerhalb des Start- und Endpunkts der",
"# Linie liegen",
"p1_inside",
"=",
"line",
".",
"is_point_inside",
"(",
"p1",
",",
"rtol",
",",
"atol",
",",
"include_end",
")",
"p2_inside",
"=",
"line",
".",
"is_point_inside",
"(",
"p2",
",",
"rtol",
",",
"atol",
",",
"include_end",
")",
"if",
"p1_inside",
":",
"if",
"p2_inside",
":",
"return",
"[",
"p1",
",",
"p2",
"]",
"else",
":",
"return",
"[",
"p1",
"]",
"else",
":",
"if",
"p2_inside",
":",
"return",
"[",
"p2",
"]",
"else",
":",
"return",
"[",
"]"
] | [
390,
4
] | [
439,
25
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
|
RawData.Get_RawMessageData | ( self, data ) | return tags | Auswerten von Twitch-Meldungen Roh-Daten | Auswerten von Twitch-Meldungen Roh-Daten | def Get_RawMessageData( self, data ):
''' Auswerten von Twitch-Meldungen Roh-Daten '''
thisActionName = "Get_RawMessageData"
tags = False
# RawData auswerten
PRIVMSG = self.rePRIVMSG.search( data.RawData )
USERNOTICE = self.reUSERNOTICE.search( data.RawData )
JOIN = self.reJOIN.search( data.RawData )
WHISPER = self.reWHISPER.search( data.RawData )
if USERNOTICE:
''' Nachricht ist vom Typ: USERNOTICE
VERFÜGBARE TAGS (Allgemeine Übersicht):
- user-id > User ID des Users
- login > User Name des Users
- display-name > Display Name des Users
- msg-id > Typ der Nachricht
(sub, resub, charity, subgift, raid, rewardgift)
- msg-param-months > Anzahl der Subs (zusammenhängend)
- msg-param-cumulative-months > Anzahl der Subs (insgesamt)
- msg-param-sub-plan > Sub Stufe (Prime, 1000, 2000, 3000)
- msg-param-recipient-id > Gift Empfänger - User ID
- msg-param-recipient-user-name > Gift Empfänger - User Name
- msg-param-recipient-display-name > Gift Empfänger - Display Name
- msg-param-profileImageURL > Profilbild des Users
#########################################################################
VERFÜGBARE TAGS (Sub):
#########################################################################
- msg-id > Typ der Nachricht ("sub")
- user-id > User ID des Users
- login > Benutzername des Users
- display-name > DisplayName des Users
- color > Vom User festgelegte Farbe
- msg-param-cumulative-months > Anzahl der Subs (insgesamt)
- msg-param-streak-months > Anzahl der Monate in Serie
- msg-param-sub-plan > Sub Stufe (Prime, 1000, 2000, 3000)
#########################################################################
VERFÜGBARE TAGS (Sub-Gift):
#########################################################################
- msg-id > Typ der Nachricht ("subgift")
- user-id > User ID des Users
- login > Benutzername des Users
- display-name > DisplayName des Users
- color > Vom User festgelegte Farbe
- msg-param-cumulative-months > Anzahl der Subs (insgesamt)
- msg-param-streak-months > Anzahl der Monate in Serie
- msg-param-sub-plan > Sub Stufe (Prime, 1000, 2000, 3000)
- msg-param-recipient-id > UserID des Empfängers
- msg-param-recipient-user-name > Username des Empfängers
- msg-param-recipient-display-name > DisplayName des Empfängers
#########################################################################
VERFÜGBARE TAGS (Reward-Gift):
#########################################################################
- msg-id > Typ der Nachricht ("rewardgift")
- user-id > User ID des Users
- login > Benutzername des Users
- display-name > DisplayName des Users
- color > Vom User festgelegte Farbe
- msg-param-selected-count=5
- msg-param-total-reward-count=5
#########################################################################
VERFÜGBARE TAGS (Resub):
#########################################################################
- msg-id > Typ der Nachricht ("resub")
- user-id > User ID des Users
- login > Benutzername des Users
- display-name > DisplayName des Users
- color > Vom User festgelegte Farbe
- msg-param-cumulative-months > Anzahl der Subs (insgesamt)
- msg-param-streak-months > Anzahl der Monate in Serie
- msg-param-sub-plan > Sub Stufe (Prime, 1000, 2000, 3000)
#########################################################################
VERFÜGBARE TAGS (Raid):
#########################################################################
- msg-id > Typ der Nachricht ("raid")
- user-id > User ID des Users
- login > Benutzername des Users
- display-name > DisplayName des Users
- color > Vom User festgelegte Farbe
- msg-param-profileImageURL > Profilbild des Users
- msg-param-viewerCount > Anzahl der Viewer bei einem Raid
#########################################################################
VERFÜGBARE TAGS (Host):
#########################################################################
- msg-id > Typ der Nachricht ("host")
- user-id > User ID des Users
- login > Benutzername des Users
- display-name > DisplayName des Users
- color > Vom User festgelegte Farbe
- msg-param-profileImageURL > Profilbild des Users
- msg-param-viewerCount > Anzahl der Viewer bei einem Raid
'''
# Tags auslesen
tags = dict( re.findall( r"([^=]+)=([^;]*)(?:;|$)", USERNOTICE.group( "irctags" ) ) )
elif PRIVMSG:
''' Nachricht ist vom Typ: PRIVMSG
#########################################################################
VERFÜGBARE TAGS:
#########################################################################
- user-id > User-ID
- display-name > Display-Name des Users
- color > Vom User festgelegte Farbe
- subscriber > Ist aktuell Subscriber (0 oder 1)
- bits > Aktuelle Anzahl der gecheerten Bits
!!!Nur Verfügbar, wenn auch Bits gecheert wurden!!!
'''
tags = dict( re.findall( r"([^=]+)=([^;]*)(?:;|$)", PRIVMSG.group( "irctags" ) ) )
# elif WHISPER:
# '''
# #########################################################################
# VERFÜGBARE TAGS (Whisper):
# #########################################################################
# - user-id > User ID des Users
# - display-name > DisplayName des Users
# - color > Vom User festgelegte Farbe
# '''
#tags = dict( re.findall( r"([^=]+)=([^;]*)(?:;|$)", WHISPER.group( "irctags" ) ) )
# elif JOIN:
# ''' Nachricht ist vom Typ: JOIN
# Liefert nur den Benutzer
# '''
# tags = JOIN.group( "name" )
else:
''' Es wurde keine der definierten Nachrichten-Typen gefunden '''
#self.Logger.WriteLog( " --- RAWDATEN: {0}".format( "RAW-Daten sind nicht auswertbar" ) )
tags = False
return tags | [
"def",
"Get_RawMessageData",
"(",
"self",
",",
"data",
")",
":",
"thisActionName",
"=",
"\"Get_RawMessageData\"",
"tags",
"=",
"False",
"# RawData auswerten\r",
"PRIVMSG",
"=",
"self",
".",
"rePRIVMSG",
".",
"search",
"(",
"data",
".",
"RawData",
")",
"USERNOTICE",
"=",
"self",
".",
"reUSERNOTICE",
".",
"search",
"(",
"data",
".",
"RawData",
")",
"JOIN",
"=",
"self",
".",
"reJOIN",
".",
"search",
"(",
"data",
".",
"RawData",
")",
"WHISPER",
"=",
"self",
".",
"reWHISPER",
".",
"search",
"(",
"data",
".",
"RawData",
")",
"if",
"USERNOTICE",
":",
"''' Nachricht ist vom Typ: USERNOTICE\r\n\r\n VERFÜGBARE TAGS (Allgemeine Übersicht):\r\n - user-id > User ID des Users\r\n - login > User Name des Users\r\n - display-name > Display Name des Users\r\n - msg-id > Typ der Nachricht \r\n (sub, resub, charity, subgift, raid, rewardgift)\r\n - msg-param-months > Anzahl der Subs (zusammenhängend)\r\n - msg-param-cumulative-months > Anzahl der Subs (insgesamt)\r\n - msg-param-sub-plan > Sub Stufe (Prime, 1000, 2000, 3000)\r\n - msg-param-recipient-id > Gift Empfänger - User ID\r\n - msg-param-recipient-user-name > Gift Empfänger - User Name\r\n - msg-param-recipient-display-name > Gift Empfänger - Display Name\r\n - msg-param-profileImageURL > Profilbild des Users\r\n\r\n #########################################################################\r\n VERFÜGBARE TAGS (Sub):\r\n #########################################################################\r\n - msg-id > Typ der Nachricht (\"sub\")\r\n - user-id > User ID des Users\r\n - login > Benutzername des Users\r\n - display-name > DisplayName des Users\r\n - color > Vom User festgelegte Farbe\r\n - msg-param-cumulative-months > Anzahl der Subs (insgesamt)\r\n - msg-param-streak-months > Anzahl der Monate in Serie\r\n - msg-param-sub-plan > Sub Stufe (Prime, 1000, 2000, 3000)\r\n\r\n #########################################################################\r\n VERFÜGBARE TAGS (Sub-Gift):\r\n #########################################################################\r\n - msg-id > Typ der Nachricht (\"subgift\")\r\n - user-id > User ID des Users\r\n - login > Benutzername des Users\r\n - display-name > DisplayName des Users\r\n - color > Vom User festgelegte Farbe\r\n - msg-param-cumulative-months > Anzahl der Subs (insgesamt)\r\n - msg-param-streak-months > Anzahl der Monate in Serie\r\n - msg-param-sub-plan > Sub Stufe (Prime, 1000, 2000, 3000)\r\n - msg-param-recipient-id > UserID des Empfängers\r\n - msg-param-recipient-user-name > Username des Empfängers\r\n - msg-param-recipient-display-name > DisplayName des Empfängers\r\n\r\n #########################################################################\r\n VERFÜGBARE TAGS (Reward-Gift):\r\n #########################################################################\r\n - msg-id > Typ der Nachricht (\"rewardgift\")\r\n - user-id > User ID des Users\r\n - login > Benutzername des Users\r\n - display-name > DisplayName des Users\r\n - color > Vom User festgelegte Farbe\r\n - msg-param-selected-count=5\r\n - msg-param-total-reward-count=5\r\n \r\n #########################################################################\r\n VERFÜGBARE TAGS (Resub):\r\n #########################################################################\r\n - msg-id > Typ der Nachricht (\"resub\")\r\n - user-id > User ID des Users\r\n - login > Benutzername des Users\r\n - display-name > DisplayName des Users\r\n - color > Vom User festgelegte Farbe\r\n - msg-param-cumulative-months > Anzahl der Subs (insgesamt)\r\n - msg-param-streak-months > Anzahl der Monate in Serie\r\n - msg-param-sub-plan > Sub Stufe (Prime, 1000, 2000, 3000)\r\n \r\n #########################################################################\r\n VERFÜGBARE TAGS (Raid):\r\n #########################################################################\r\n - msg-id > Typ der Nachricht (\"raid\")\r\n - user-id > User ID des Users\r\n - login > Benutzername des Users\r\n - display-name > DisplayName des Users\r\n - color > Vom User festgelegte Farbe\r\n - msg-param-profileImageURL > Profilbild des Users\r\n - msg-param-viewerCount > Anzahl der Viewer bei einem Raid\r\n\r\n #########################################################################\r\n VERFÜGBARE TAGS (Host):\r\n #########################################################################\r\n - msg-id > Typ der Nachricht (\"host\")\r\n - user-id > User ID des Users\r\n - login > Benutzername des Users\r\n - display-name > DisplayName des Users\r\n - color > Vom User festgelegte Farbe\r\n - msg-param-profileImageURL > Profilbild des Users\r\n - msg-param-viewerCount > Anzahl der Viewer bei einem Raid\r\n\r\n '''",
"# Tags auslesen\r",
"tags",
"=",
"dict",
"(",
"re",
".",
"findall",
"(",
"r\"([^=]+)=([^;]*)(?:;|$)\"",
",",
"USERNOTICE",
".",
"group",
"(",
"\"irctags\"",
")",
")",
")",
"elif",
"PRIVMSG",
":",
"''' Nachricht ist vom Typ: PRIVMSG\r\n\r\n #########################################################################\r\n VERFÜGBARE TAGS:\r\n #########################################################################\r\n - user-id > User-ID\r\n - display-name > Display-Name des Users\r\n - color > Vom User festgelegte Farbe\r\n - subscriber > Ist aktuell Subscriber (0 oder 1)\r\n - bits > Aktuelle Anzahl der gecheerten Bits\r\n !!!Nur Verfügbar, wenn auch Bits gecheert wurden!!!\r\n \r\n '''",
"tags",
"=",
"dict",
"(",
"re",
".",
"findall",
"(",
"r\"([^=]+)=([^;]*)(?:;|$)\"",
",",
"PRIVMSG",
".",
"group",
"(",
"\"irctags\"",
")",
")",
")",
"# elif WHISPER:\r",
"# '''\r",
"# #########################################################################\r",
"# VERFÜGBARE TAGS (Whisper):\r",
"# #########################################################################\r",
"# - user-id > User ID des Users\r",
"# - display-name > DisplayName des Users\r",
"# - color > Vom User festgelegte Farbe\r",
"# '''\r",
"#tags = dict( re.findall( r\"([^=]+)=([^;]*)(?:;|$)\", WHISPER.group( \"irctags\" ) ) )\r",
"# elif JOIN:\r",
"# ''' Nachricht ist vom Typ: JOIN \r",
"# Liefert nur den Benutzer\r",
"# '''\r",
"# tags = JOIN.group( \"name\" )\r",
"else",
":",
"''' Es wurde keine der definierten Nachrichten-Typen gefunden '''",
"#self.Logger.WriteLog( \" --- RAWDATEN: {0}\".format( \"RAW-Daten sind nicht auswertbar\" ) )\r",
"tags",
"=",
"False",
"return",
"tags"
] | [
241,
4
] | [
387,
19
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
GUI.setzen_analoge_eingaenge_2 | (self) | Analoge Eingänge setzen - Durchführung | Analoge Eingänge setzen - Durchführung | def setzen_analoge_eingaenge_2(self):
""" Analoge Eingänge setzen - Durchführung"""
ae_daten = []
for i in range(Konfig.ANAMAXLAENGE):
ae_daten = ae_daten + [float(self.AE[i].get())]
ae_zugriff = DateiZugriff(Konfig.ANAEIN, Konfig.ANAMAXLAENGE)
ae_zugriff.schreiben_alle(ae_daten) | [
"def",
"setzen_analoge_eingaenge_2",
"(",
"self",
")",
":",
"ae_daten",
"=",
"[",
"]",
"for",
"i",
"in",
"range",
"(",
"Konfig",
".",
"ANAMAXLAENGE",
")",
":",
"ae_daten",
"=",
"ae_daten",
"+",
"[",
"float",
"(",
"self",
".",
"AE",
"[",
"i",
"]",
".",
"get",
"(",
")",
")",
"]",
"ae_zugriff",
"=",
"DateiZugriff",
"(",
"Konfig",
".",
"ANAEIN",
",",
"Konfig",
".",
"ANAMAXLAENGE",
")",
"ae_zugriff",
".",
"schreiben_alle",
"(",
"ae_daten",
")"
] | [
229,
4
] | [
235,
43
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
|
Circle.intersect_arc | (self, arc, rtol=1e-03, atol=1e-03, include_end=False) | return arc.intersect_circle(self, rtol, atol, include_end) | Von einem Circle-Objekt und einem Arc-Objekt werden die
Schnittpunkte bestimmt und in einer Liste ausgegeben
| Von einem Circle-Objekt und einem Arc-Objekt werden die
Schnittpunkte bestimmt und in einer Liste ausgegeben
| def intersect_arc(self, arc, rtol=1e-03, atol=1e-03, include_end=False):
""" Von einem Circle-Objekt und einem Arc-Objekt werden die
Schnittpunkte bestimmt und in einer Liste ausgegeben
"""
assert(isinstance(arc, Arc))
# let Arc do the work
return arc.intersect_circle(self, rtol, atol, include_end) | [
"def",
"intersect_arc",
"(",
"self",
",",
"arc",
",",
"rtol",
"=",
"1e-03",
",",
"atol",
"=",
"1e-03",
",",
"include_end",
"=",
"False",
")",
":",
"assert",
"(",
"isinstance",
"(",
"arc",
",",
"Arc",
")",
")",
"# let Arc do the work",
"return",
"arc",
".",
"intersect_circle",
"(",
"self",
",",
"rtol",
",",
"atol",
",",
"include_end",
")"
] | [
465,
4
] | [
471,
66
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
plotImage.mm2dots_X | ( self, position ) | return int(round( self.dpmm * position + self.cax.x )) | Wandelt eine X mm Angabe in die Pixel Positionen des image um.
Parameters
----------
position : int, float
Position in mm.
Returns
-------
int
Umgewandelte Position
| Wandelt eine X mm Angabe in die Pixel Positionen des image um.
Parameters
----------
position : int, float
Position in mm. | def mm2dots_X( self, position ):
"""Wandelt eine X mm Angabe in die Pixel Positionen des image um.
Parameters
----------
position : int, float
Position in mm.
Returns
-------
int
Umgewandelte Position
"""
return int(round( self.dpmm * position + self.cax.x )) | [
"def",
"mm2dots_X",
"(",
"self",
",",
"position",
")",
":",
"return",
"int",
"(",
"round",
"(",
"self",
".",
"dpmm",
"*",
"position",
"+",
"self",
".",
"cax",
".",
"x",
")",
")"
] | [
44,
4
] | [
58,
62
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
MQTTclass.onMessage | (self, client, userdata, msgObj:mqtt.MQTTMessage ) | return | Eingehende Nachrichten verarbeiten.
Parameters
----------
client:
the client instance for this callback
userdata:
the private user data as set in Client() or userdata_set()
msgObj: mqtt.MQTTMessage(object)
| Eingehende Nachrichten verarbeiten. | def onMessage(self, client, userdata, msgObj:mqtt.MQTTMessage ):
"""Eingehende Nachrichten verarbeiten.
Parameters
----------
client:
the client instance for this callback
userdata:
the private user data as set in Client() or userdata_set()
msgObj: mqtt.MQTTMessage(object)
"""
#print("mqtt.onMessage", msgObj.topic )
# topics splitten und basetopic entfernen
topics = msgObj.topic.split("/")
#print("mqtt.onMessage topics:", topics )
base = topics.pop(0)
#print("mqtt.onMessage base:", base, self.defaults["basetopic"] )
# kann eigentlich nicht passieren da subscribe zwei Elemente hat
if not base == self.defaults["basetopic"] and len(topics) <= 2: # pragma: no cover
self.warning("onMessage:mqtt.Topic not allowed: {}".format( msgObj.topic ) )
#print( "mqtt.warning", msgObj.topic )
return
# cmnd entfernen
cmd = topics.pop(0)
# und prüfen
if cmd == self.defaults["cmnd"]:
# ggf payload json string umwandeln
# den neuen Topic zusammenstellen
topic = "/".join( topics )
if topic == "status": #pragma: no cover
self.doStatus( )
elif topic == "process": #pragma: no cover
self.doProcess( msgObj )
else:
self.warning("mqtt.Topic {} keine do Funktion".format( topic ) )
self.doSignal( msgObj )
return | [
"def",
"onMessage",
"(",
"self",
",",
"client",
",",
"userdata",
",",
"msgObj",
":",
"mqtt",
".",
"MQTTMessage",
")",
":",
"#print(\"mqtt.onMessage\", msgObj.topic )",
"# topics splitten und basetopic entfernen",
"topics",
"=",
"msgObj",
".",
"topic",
".",
"split",
"(",
"\"/\"",
")",
"#print(\"mqtt.onMessage topics:\", topics )",
"base",
"=",
"topics",
".",
"pop",
"(",
"0",
")",
"#print(\"mqtt.onMessage base:\", base, self.defaults[\"basetopic\"] )",
"# kann eigentlich nicht passieren da subscribe zwei Elemente hat",
"if",
"not",
"base",
"==",
"self",
".",
"defaults",
"[",
"\"basetopic\"",
"]",
"and",
"len",
"(",
"topics",
")",
"<=",
"2",
":",
"# pragma: no cover",
"self",
".",
"warning",
"(",
"\"onMessage:mqtt.Topic not allowed: {}\"",
".",
"format",
"(",
"msgObj",
".",
"topic",
")",
")",
"#print( \"mqtt.warning\", msgObj.topic )",
"return",
"# cmnd entfernen",
"cmd",
"=",
"topics",
".",
"pop",
"(",
"0",
")",
"# und prüfen",
"if",
"cmd",
"==",
"self",
".",
"defaults",
"[",
"\"cmnd\"",
"]",
":",
"# ggf payload json string umwandeln",
"# den neuen Topic zusammenstellen",
"topic",
"=",
"\"/\"",
".",
"join",
"(",
"topics",
")",
"if",
"topic",
"==",
"\"status\"",
":",
"#pragma: no cover",
"self",
".",
"doStatus",
"(",
")",
"elif",
"topic",
"==",
"\"process\"",
":",
"#pragma: no cover",
"self",
".",
"doProcess",
"(",
"msgObj",
")",
"else",
":",
"self",
".",
"warning",
"(",
"\"mqtt.Topic {} keine do Funktion\"",
".",
"format",
"(",
"topic",
")",
")",
"self",
".",
"doSignal",
"(",
"msgObj",
")",
"return"
] | [
548,
4
] | [
596,
14
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
ImpfterminService.run | (code: str, plz: str, kontakt: json, check_delay: int = 60) | Workflow für die Terminbuchung.
:param code: 14-stelliger Impf-Code
:param plz: PLZ des Impfzentrums
:param kontakt: Kontaktdaten der zu impfenden Person als JSON
:param check_delay: Zeit zwischen Iterationen der Terminsuche
:return:
| Workflow für die Terminbuchung. | def run(code: str, plz: str, kontakt: json, check_delay: int = 60):
"""Workflow für die Terminbuchung.
:param code: 14-stelliger Impf-Code
:param plz: PLZ des Impfzentrums
:param kontakt: Kontaktdaten der zu impfenden Person als JSON
:param check_delay: Zeit zwischen Iterationen der Terminsuche
:return:
"""
its = ImpfterminService(code, plz, kontakt)
its.cookies_erneuern()
# login ist nicht zwingend erforderlich
its.login()
while True:
termin_gefunden = False
while not termin_gefunden:
termin_gefunden, status_code = its.terminsuche()
if status_code >= 400:
its.cookies_erneuern()
elif not termin_gefunden:
time.sleep(check_delay)
if its.termin_buchen():
break
time.sleep(30) | [
"def",
"run",
"(",
"code",
":",
"str",
",",
"plz",
":",
"str",
",",
"kontakt",
":",
"json",
",",
"check_delay",
":",
"int",
"=",
"60",
")",
":",
"its",
"=",
"ImpfterminService",
"(",
"code",
",",
"plz",
",",
"kontakt",
")",
"its",
".",
"cookies_erneuern",
"(",
")",
"# login ist nicht zwingend erforderlich",
"its",
".",
"login",
"(",
")",
"while",
"True",
":",
"termin_gefunden",
"=",
"False",
"while",
"not",
"termin_gefunden",
":",
"termin_gefunden",
",",
"status_code",
"=",
"its",
".",
"terminsuche",
"(",
")",
"if",
"status_code",
">=",
"400",
":",
"its",
".",
"cookies_erneuern",
"(",
")",
"elif",
"not",
"termin_gefunden",
":",
"time",
".",
"sleep",
"(",
"check_delay",
")",
"if",
"its",
".",
"termin_buchen",
"(",
")",
":",
"break",
"time",
".",
"sleep",
"(",
"30",
")"
] | [
354,
4
] | [
381,
26
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
|
get_monthspan | (date) | return startdate, enddate | Gibt den ersten und letzten Tag des Monats zurück in dem `date` liegt
>>> get_monthspan(datetime.date(1980, 5, 4))
(datetime.date(1980, 5, 1), datetime.date(1980, 5, 31))
| Gibt den ersten und letzten Tag des Monats zurück in dem `date` liegt | def get_monthspan(date):
"""Gibt den ersten und letzten Tag des Monats zurück in dem `date` liegt
>>> get_monthspan(datetime.date(1980, 5, 4))
(datetime.date(1980, 5, 1), datetime.date(1980, 5, 31))
"""
startdate = date_trunc('month', date)
_, days = calendar.monthrange(startdate.year, startdate.month)
enddate = type(startdate)(startdate.year, startdate.month, days)
return startdate, enddate | [
"def",
"get_monthspan",
"(",
"date",
")",
":",
"startdate",
"=",
"date_trunc",
"(",
"'month'",
",",
"date",
")",
"_",
",",
"days",
"=",
"calendar",
".",
"monthrange",
"(",
"startdate",
".",
"year",
",",
"startdate",
".",
"month",
")",
"enddate",
"=",
"type",
"(",
"startdate",
")",
"(",
"startdate",
".",
"year",
",",
"startdate",
".",
"month",
",",
"days",
")",
"return",
"startdate",
",",
"enddate"
] | [
186,
0
] | [
195,
29
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
get_tertialspan | (date) | return startdate, enddate | Gibt den ersten und den letzten Tag des Tertials zurück in dem `date` liegt
>>> get_tertialspan(datetime.date(1978, 9, 23))
(datetime.date(1978, 9, 1), datetime.date(1978, 12, 31))
| Gibt den ersten und den letzten Tag des Tertials zurück in dem `date` liegt | def get_tertialspan(date):
"""Gibt den ersten und den letzten Tag des Tertials zurück in dem `date` liegt
>>> get_tertialspan(datetime.date(1978, 9, 23))
(datetime.date(1978, 9, 1), datetime.date(1978, 12, 31))
"""
startdate = date_trunc('tertial', date)
enddate = date_trunc('tertial', startdate + datetime.timedelta(days=130)) - datetime.timedelta(days=1)
return startdate, enddate | [
"def",
"get_tertialspan",
"(",
"date",
")",
":",
"startdate",
"=",
"date_trunc",
"(",
"'tertial'",
",",
"date",
")",
"enddate",
"=",
"date_trunc",
"(",
"'tertial'",
",",
"startdate",
"+",
"datetime",
".",
"timedelta",
"(",
"days",
"=",
"130",
")",
")",
"-",
"datetime",
".",
"timedelta",
"(",
"days",
"=",
"1",
")",
"return",
"startdate",
",",
"enddate"
] | [
162,
0
] | [
170,
29
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
Argument.to_vec | (split_text, model, vector_size) | return (vec, unk_words) | Erstelle einen Vektor aus dem Dokument
Returns:
(numpy.array or None, list or None): Embedding und unbekannte Wörter.
Ist keines der Wörter bekannt, wird (None, None) zurückgegeben.
| Erstelle einen Vektor aus dem Dokument | def to_vec(split_text, model, vector_size):
"""Erstelle einen Vektor aus dem Dokument
Returns:
(numpy.array or None, list or None): Embedding und unbekannte Wörter.
Ist keines der Wörter bekannt, wird (None, None) zurückgegeben.
"""
emb_matrix = np.zeros(
(len(split_text), vector_size)
)
unk_word_count = 0
unk_words = []
for i, word in enumerate(split_text):
try:
emb_vec = model.wv[word]
emb_matrix[i] = emb_vec / LA.norm(emb_vec)
except Exception as e:
unk_word_count += 1
unk_words.append(word)
if emb_matrix.shape[0] == 0:
return (None, None)
vec = np.sum(emb_matrix, axis=0) / (emb_matrix.shape[0])
return (vec, unk_words) | [
"def",
"to_vec",
"(",
"split_text",
",",
"model",
",",
"vector_size",
")",
":",
"emb_matrix",
"=",
"np",
".",
"zeros",
"(",
"(",
"len",
"(",
"split_text",
")",
",",
"vector_size",
")",
")",
"unk_word_count",
"=",
"0",
"unk_words",
"=",
"[",
"]",
"for",
"i",
",",
"word",
"in",
"enumerate",
"(",
"split_text",
")",
":",
"try",
":",
"emb_vec",
"=",
"model",
".",
"wv",
"[",
"word",
"]",
"emb_matrix",
"[",
"i",
"]",
"=",
"emb_vec",
"/",
"LA",
".",
"norm",
"(",
"emb_vec",
")",
"except",
"Exception",
"as",
"e",
":",
"unk_word_count",
"+=",
"1",
"unk_words",
".",
"append",
"(",
"word",
")",
"if",
"emb_matrix",
".",
"shape",
"[",
"0",
"]",
"==",
"0",
":",
"return",
"(",
"None",
",",
"None",
")",
"vec",
"=",
"np",
".",
"sum",
"(",
"emb_matrix",
",",
"axis",
"=",
"0",
")",
"/",
"(",
"emb_matrix",
".",
"shape",
"[",
"0",
"]",
")",
"return",
"(",
"vec",
",",
"unk_words",
")"
] | [
77,
4
] | [
103,
31
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
dicomClass.query | ( self, PatientID:str=None,
StudyInstanceUID:str=None,
SeriesInstanceUID:str=None,
SOPInstanceUID:str=None
) | return results, status | Eine DICOM Abfrage durchführen
Parameters
----------
PatientID : str, optional
Eine PatientenID. The default is None.
StudyInstanceUID : str, optional
Eine StudyInstanceUID. The default is None.
SeriesInstanceUID : str, optional
Eine SeriesInstanceUID. The default is None.
SOPInstanceUID : str, optional
Eine SOPInstanceUID. The default is None.
Returns
-------
status : hex
Rückgabecode von send_c_find::
C-FIND related - 0xC300 to 0xC3FF
Zusätzlich:
- 0xC3F1 - keine PatientID
- 0xC0FF - initAE: Verbindung fehlgeschlagen
results : list
gefundene daten
| Eine DICOM Abfrage durchführen
Parameters
----------
PatientID : str, optional
Eine PatientenID. The default is None.
StudyInstanceUID : str, optional
Eine StudyInstanceUID. The default is None.
SeriesInstanceUID : str, optional
Eine SeriesInstanceUID. The default is None.
SOPInstanceUID : str, optional
Eine SOPInstanceUID. The default is None. | def query( self, PatientID:str=None,
StudyInstanceUID:str=None,
SeriesInstanceUID:str=None,
SOPInstanceUID:str=None
):
'''Eine DICOM Abfrage durchführen
Parameters
----------
PatientID : str, optional
Eine PatientenID. The default is None.
StudyInstanceUID : str, optional
Eine StudyInstanceUID. The default is None.
SeriesInstanceUID : str, optional
Eine SeriesInstanceUID. The default is None.
SOPInstanceUID : str, optional
Eine SOPInstanceUID. The default is None.
Returns
-------
status : hex
Rückgabecode von send_c_find::
C-FIND related - 0xC300 to 0xC3FF
Zusätzlich:
- 0xC3F1 - keine PatientID
- 0xC0FF - initAE: Verbindung fehlgeschlagen
results : list
gefundene daten
'''
# print( "dicomClass : query", PatientID )
results = []
if not PatientID:
logger.warning("dicomClass.query: keine PatientID")
return 0xC3F1, results
# Verbindung ggf herstellen
if not self.assoc:
status = self.initAE()
# und testen
if not self.assoc:
logger.warning("dicomClass.query: Verbindung fehlgeschlagen")
return status, results
# Create our Identifier (query) dataset
ds = Dataset()
# zuerst den Abfragelevel bestimmen
# erstmal Patient
ds.QueryRetrieveLevel = 'PATIENT'
# Unique key for PATIENT level
ds.PatientID = PatientID
# Unique key for STUDY level
if StudyInstanceUID:
ds.QueryRetrieveLevel = 'STUDY'
ds.StudyInstanceUID = str(StudyInstanceUID)
# Unique key for SERIES
if SeriesInstanceUID:
ds.QueryRetrieveLevel = 'SERIES'
ds.SeriesInstanceUID = str(SeriesInstanceUID)
# Unique key for IMAGE
if SOPInstanceUID:
ds.QueryRetrieveLevel = 'IMAGE'
ds.SOPInstanceUID = str(SOPInstanceUID)
logger.debug('dicomClass.query: QueryRetrieveLevel {} - {}'.format( ds.QueryRetrieveLevel, SOPInstanceUID ) )
# Use the C-FIND service to send the identifier
# A query_model value of 'S' means use the 'Study Root Query Retrieve
# Information Model - Find' presentation context
responses = self.assoc.send_c_find(ds, query_model='S')
logger.debug( "dicomClass.query: loaded - QueryRetrieveLevel {}".format( ds.QueryRetrieveLevel, SOPInstanceUID ) )
for (response_status, identifier) in responses:
# status code bestimmen
status = 0xC3F3
if response_status:
status = response_status.Status
# print("dicomClass : query response 0x{0:04x}".format(status) )
# je nach status
if status in (0xFF00, 0xFF01) and identifier:
# If the status is 'Pending' then `identifier` is the C-FIND response
results.append( identifier )
elif status == 0x0000:
# abfrage wurde komplett durchgeführt
# print("identifier:", identifier)
pass
else:
logger.warning('dicomClass.query: Connection timed out, was aborted or received invalid response: 0x{0:04x}'.format( status ) )
return results, status | [
"def",
"query",
"(",
"self",
",",
"PatientID",
":",
"str",
"=",
"None",
",",
"StudyInstanceUID",
":",
"str",
"=",
"None",
",",
"SeriesInstanceUID",
":",
"str",
"=",
"None",
",",
"SOPInstanceUID",
":",
"str",
"=",
"None",
")",
":",
"# print( \"dicomClass : query\", PatientID )",
"results",
"=",
"[",
"]",
"if",
"not",
"PatientID",
":",
"logger",
".",
"warning",
"(",
"\"dicomClass.query: keine PatientID\"",
")",
"return",
"0xC3F1",
",",
"results",
"# Verbindung ggf herstellen",
"if",
"not",
"self",
".",
"assoc",
":",
"status",
"=",
"self",
".",
"initAE",
"(",
")",
"# und testen",
"if",
"not",
"self",
".",
"assoc",
":",
"logger",
".",
"warning",
"(",
"\"dicomClass.query: Verbindung fehlgeschlagen\"",
")",
"return",
"status",
",",
"results",
"# Create our Identifier (query) dataset",
"ds",
"=",
"Dataset",
"(",
")",
"# zuerst den Abfragelevel bestimmen",
"# erstmal Patient",
"ds",
".",
"QueryRetrieveLevel",
"=",
"'PATIENT'",
"# Unique key for PATIENT level",
"ds",
".",
"PatientID",
"=",
"PatientID",
"# Unique key for STUDY level",
"if",
"StudyInstanceUID",
":",
"ds",
".",
"QueryRetrieveLevel",
"=",
"'STUDY'",
"ds",
".",
"StudyInstanceUID",
"=",
"str",
"(",
"StudyInstanceUID",
")",
"# Unique key for SERIES ",
"if",
"SeriesInstanceUID",
":",
"ds",
".",
"QueryRetrieveLevel",
"=",
"'SERIES'",
"ds",
".",
"SeriesInstanceUID",
"=",
"str",
"(",
"SeriesInstanceUID",
")",
"# Unique key for IMAGE ",
"if",
"SOPInstanceUID",
":",
"ds",
".",
"QueryRetrieveLevel",
"=",
"'IMAGE'",
"ds",
".",
"SOPInstanceUID",
"=",
"str",
"(",
"SOPInstanceUID",
")",
"logger",
".",
"debug",
"(",
"'dicomClass.query: QueryRetrieveLevel {} - {}'",
".",
"format",
"(",
"ds",
".",
"QueryRetrieveLevel",
",",
"SOPInstanceUID",
")",
")",
"# Use the C-FIND service to send the identifier",
"# A query_model value of 'S' means use the 'Study Root Query Retrieve",
"# Information Model - Find' presentation context",
"responses",
"=",
"self",
".",
"assoc",
".",
"send_c_find",
"(",
"ds",
",",
"query_model",
"=",
"'S'",
")",
"logger",
".",
"debug",
"(",
"\"dicomClass.query: loaded - QueryRetrieveLevel {}\"",
".",
"format",
"(",
"ds",
".",
"QueryRetrieveLevel",
",",
"SOPInstanceUID",
")",
")",
"for",
"(",
"response_status",
",",
"identifier",
")",
"in",
"responses",
":",
"# status code bestimmen",
"status",
"=",
"0xC3F3",
"if",
"response_status",
":",
"status",
"=",
"response_status",
".",
"Status",
"# print(\"dicomClass : query response 0x{0:04x}\".format(status) )",
"# je nach status",
"if",
"status",
"in",
"(",
"0xFF00",
",",
"0xFF01",
")",
"and",
"identifier",
":",
"# If the status is 'Pending' then `identifier` is the C-FIND response ",
"results",
".",
"append",
"(",
"identifier",
")",
"elif",
"status",
"==",
"0x0000",
":",
"# abfrage wurde komplett durchgeführt",
"# print(\"identifier:\", identifier)",
"pass",
"else",
":",
"logger",
".",
"warning",
"(",
"'dicomClass.query: Connection timed out, was aborted or received invalid response: 0x{0:04x}'",
".",
"format",
"(",
"status",
")",
")",
"return",
"results",
",",
"status"
] | [
399,
4
] | [
503,
30
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
register_generate_audio | (func) | return register_type_func(GENERATE_AUDIO_TYPES, AudioError, func) | Registriert die übergebene Funktion und versieht sie mit einem `"try/except"`-Block.
Fügt eine Typ-Funktion dem Dictionary GENERATE_AUDIO_TYPES hinzu.
:param func: die zu registrierende Funktion
:return: Funktion mit try/except-Block
| Registriert die übergebene Funktion und versieht sie mit einem `"try/except"`-Block.
Fügt eine Typ-Funktion dem Dictionary GENERATE_AUDIO_TYPES hinzu. | def register_generate_audio(func):
"""Registriert die übergebene Funktion und versieht sie mit einem `"try/except"`-Block.
Fügt eine Typ-Funktion dem Dictionary GENERATE_AUDIO_TYPES hinzu.
:param func: die zu registrierende Funktion
:return: Funktion mit try/except-Block
"""
return register_type_func(GENERATE_AUDIO_TYPES, AudioError, func) | [
"def",
"register_generate_audio",
"(",
"func",
")",
":",
"return",
"register_type_func",
"(",
"GENERATE_AUDIO_TYPES",
",",
"AudioError",
",",
"func",
")"
] | [
49,
0
] | [
56,
69
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
all_installed | (programs: list) | Testet, ob alle Programme von der Liste installiert sind.
:param programs: Liste der benötigten Programme.
:type programs: list
| Testet, ob alle Programme von der Liste installiert sind. | def all_installed(programs: list):
"""Testet, ob alle Programme von der Liste installiert sind.
:param programs: Liste der benötigten Programme.
:type programs: list
"""
for prog in programs:
_check_installed(prog) | [
"def",
"all_installed",
"(",
"programs",
":",
"list",
")",
":",
"for",
"prog",
"in",
"programs",
":",
"_check_installed",
"(",
"prog",
")"
] | [
3,
0
] | [
10,
30
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
|
new_temp_resource_path | (pipeline_id: str, extension) | return get_temp_resource_path(f"{datetime.now().strftime('%Y-%m-%d_%H-%M.%S.%f')}.{extension}", pipeline_id) | Erstellt einen absoluten Pfad für eine neue Resource.
Generiert einen neuen Namen mit aktuellem Zeitstempel.
Verwendet um den Pfad zu generieren :func:`get_temp_resource_path` mit dem Ordner der `pipeline_id`.
:param pipeline_id: id der Pipeline von der die Funktion aufgerufen wurde.
:type pipeline_id: str
:param extension: Dateierweiterung ohne `.`
:type extension: str
| Erstellt einen absoluten Pfad für eine neue Resource. | def new_temp_resource_path(pipeline_id: str, extension):
"""Erstellt einen absoluten Pfad für eine neue Resource.
Generiert einen neuen Namen mit aktuellem Zeitstempel.
Verwendet um den Pfad zu generieren :func:`get_temp_resource_path` mit dem Ordner der `pipeline_id`.
:param pipeline_id: id der Pipeline von der die Funktion aufgerufen wurde.
:type pipeline_id: str
:param extension: Dateierweiterung ohne `.`
:type extension: str
"""
return get_temp_resource_path(f"{datetime.now().strftime('%Y-%m-%d_%H-%M.%S.%f')}.{extension}", pipeline_id) | [
"def",
"new_temp_resource_path",
"(",
"pipeline_id",
":",
"str",
",",
"extension",
")",
":",
"return",
"get_temp_resource_path",
"(",
"f\"{datetime.now().strftime('%Y-%m-%d_%H-%M.%S.%f')}.{extension}\"",
",",
"pipeline_id",
")"
] | [
203,
0
] | [
214,
112
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
dicomClass.archive_hasSOPInstanceUID | (self, SOPInstanceUID) | return os.path.isfile( filename ), filename | Prüft ob eine SOPInstanceUID schon im File Archiv vorhanden ist
Parameters
----------
SOPInstanceUID : TYPE
Eine SOPInstanceUID.
Returns
-------
exists : bool
Datei vorhanden oder nicht.
filename : str
Der geprüfte Dateiname
| Prüft ob eine SOPInstanceUID schon im File Archiv vorhanden ist
Parameters
----------
SOPInstanceUID : TYPE
Eine SOPInstanceUID. | def archive_hasSOPInstanceUID(self, SOPInstanceUID):
'''Prüft ob eine SOPInstanceUID schon im File Archiv vorhanden ist
Parameters
----------
SOPInstanceUID : TYPE
Eine SOPInstanceUID.
Returns
-------
exists : bool
Datei vorhanden oder nicht.
filename : str
Der geprüfte Dateiname
'''
filename = osp.join( self.dicomPath, self.subPath, SOPInstanceUID + ".dcm" )
return os.path.isfile( filename ), filename | [
"def",
"archive_hasSOPInstanceUID",
"(",
"self",
",",
"SOPInstanceUID",
")",
":",
"filename",
"=",
"osp",
".",
"join",
"(",
"self",
".",
"dicomPath",
",",
"self",
".",
"subPath",
",",
"SOPInstanceUID",
"+",
"\".dcm\"",
")",
"return",
"os",
".",
"path",
".",
"isfile",
"(",
"filename",
")",
",",
"filename"
] | [
803,
4
] | [
821,
51
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
HeistSystem.DB_create_DefaultMessages | (self) | return | Erzeuge verschiedene Benachrichtigungs-Einträge in der Datenbank | Erzeuge verschiedene Benachrichtigungs-Einträge in der Datenbank | def DB_create_DefaultMessages(self):
''' Erzeuge verschiedene Benachrichtigungs-Einträge in der Datenbank '''
thisActionName = "DB_create_DefaultMessages"
# Nachrichten Listen
message_CoolDown = []
message_GameCooldownOver = []
message_NewGameStart = []
message_NewPlayerEntry = []
message_NotEnoughPoints = []
message_NotEnoughPlayer = []
message_StakeOverMaximum = []
message_WrongCommandOption = []
message_StakeBelowMinimum = []
message_Outcome_100Percent = []
message_Outcome_75_99Percent = []
message_Outcome_25_74Percent = []
message_Outcome_01_24Percent = []
message_Outcome_00Percent = []
message_GameStartIntro = []
#
#
### Default Texte vorbereiten ###
#
#
# Sollte mehr als eine Nachricht mit dem selben Nachrichten-Typ (messageType) vorhanden
# sein, so wird eine der Nachrichten per Zufall ausgewählt.
#
#
### Benachrichtigung - Kommando ist im Cooldown ###
#
# mögliche Variablen:
#
# {time} = Cooldown Zeit
# {command} = Kommando des Spiels
#
# Erster Text
coolDown_text = "Die Sicherheitskräfte sind aktuell alamiert und patrouillieren noch in der Gegend. "
coolDown_text += "Du musst noch {time} warten bis zum nächsten Überfall."
# Text der Liste hinzufügen
message_CoolDown.append(coolDown_text)
# Zweiter Text
coolDown_text = "Das Kommando '{command}' befindet sich derzeit im Cooldown. "
coolDown_text += "Du musst noch {time} warten bis zur nächsten Ausführung des Kommandos."
# Text der Liste hinzufügen
message_CoolDown.append(coolDown_text)
### Benachrichtigung - Cooldown ist abgelaufen ###
#
# mögliche Variablen:
#
# {command} = Kommando des Spiels
#
# Erster Text
gameCooldownOver_text = "Die Sicherheitskräfte der Megaplexe haben ihre Patrouille beendet "
gameCooldownOver_text += "und kehren in ihre Kasernen zurück. "
gameCooldownOver_text += "Verwende '{command} <EINSATZ>' um ein Team für einen neuen Überfall "
gameCooldownOver_text += "zusammenzustellen. "
# Text der Liste hinzufügen
message_GameCooldownOver.append(gameCooldownOver_text)
### Benachrichtigung - Spiel wurde gestartet ###
#
# mögliche Variablen:
#
# {user} = Name des Spielers, der den Heist starten will
# {command} = Kommando des Spiels
# {target} = Name des Ziels
# {time} = Zeit bis das Spiel startet
# {maxpoints} = Höhe des maximalen Einsatzes
# {pointsname} = Name der Chatbot-Punkte
#
# Erster Text
newGameStart_Text = "🗨️ {user} stellt ein Team zusammen um geheime Daten von {target} zu stehlen. "
newGameStart_Text += "Schreibe '{command} <EINSATZ>' in den Chat um an dem Überfall teilzunehmen. "
newGameStart_Text += "Du hast {time} Zeit. "
# Text der Liste hinzufügen
message_NewGameStart.append(newGameStart_Text)
# Zweiter Text
newGameStart_Text = "🗨️ {user} plant einen Überfall, um Daten von {target} zu stehlen. "
newGameStart_Text += "Werde ein Teil des Teams und schreibe '{command} <EINSATZ>' in den Chat um an dem Run teilzunehmen. "
newGameStart_Text += "Du hast {time} Zeit. "
# Text der Liste hinzufügen
message_NewGameStart.append(newGameStart_Text)
### Benachrichtigung - Introtext für den Spielstart ###
#
# mögliche Variablen:
#
# {target} = Name des Ziels
#
#
# Erster Text
gameStartIntro_Text = "👥 Es geht los! Schnappt euch eure Ausrüstung und überprüft nochmals eure Waffen. "
gameStartIntro_Text += "Seit Vorsichtig, die Sicherheitskräfte von {target} schiessen erst und stellen später fragen... "
# Text zur Liste hinzufügen
message_GameStartIntro.append(gameStartIntro_Text)
# Zweiter Text
gameStartIntro_Text = "👥 Wir starten jetzt unseren Angriff auf den Megaplex von {target}. "
gameStartIntro_Text += "Prüft eure Decks und ladet eure Waffen. "
# Text zur Liste hinzufügen
message_GameStartIntro.append(gameStartIntro_Text)
### Benachrichtigung - Neuer Spieler ###
#
# mögliche Variablen:
#
# {user} = Name des Spielers, der den Heist starten will
# {target} = Name des Ziels
# {stake} = Einsatz des Spielers
# {pointsname} = Name der Chatbot-Punkte
#
# Erster Text
newPlayerEntry_Text = "✅ {user} nimmt mit einem Einsatz von {stake} {pointsname} am Überfall auf {target} teil. "
message_NewPlayerEntry.append(newPlayerEntry_Text)
### Benachrichtigung - Spieler hat nicht genug Punkte ###
#
# mögliche Variablen:
#
# {user} = Name des Spielers
# {target} = Name des Ziels
# {points} = Punkte des Spielers
# {pointsname} = Name der Chatbot-Punkte
#
# Erster Text
notEnoughPoints_Text = "🛑 @{user}, du verfügst nur über {points} {pointsname} und kannst daher nicht "
notEnoughPoints_Text += "mit einem so hohen Einsatz am Überfall auf {target} teilnehmen. "
notEnoughPoints_Text += "Versuche es erneut mit einem reduzierten Einsatz."
# Text zur Liste hinzufügen
message_NotEnoughPoints.append(notEnoughPoints_Text)
# Zweiter Text
notEnoughPoints_Text = "🛑 @{user}, du verfügst nur über {points} {pointsname} und kannst daher nicht "
notEnoughPoints_Text += "mit einem so hohen Einsatz am Überfall teilnehmen. "
notEnoughPoints_Text += "Versuche es erneut mit einem reduzierten Einsatz."
# Text zur Liste hinzufügen
message_NotEnoughPoints.append(notEnoughPoints_Text)
### Benachrichtigung - ungenügende Anzahl Spieler ###
#
# mögliche Variablen:
#
# {target} = Name des Ziels
# {pointsname} = Name der Chatbot-Punkte
#
notEnoughPlayer_Text = "Leider sind nicht genügend Runner zusammen gekommen, um den "
notEnoughPlayer_Text += "Run auf {target} erfolgreich durchführen zu können. "
notEnoughPlayer_Text += "Die eingesetzten {pointsname} wurden erstattet. "
# Text zur Liste hinzufügen
message_NotEnoughPlayer.append(notEnoughPlayer_Text)
### Benachrichtigung - Einsatz kleiner eingestelltes Minimum ###
#
# mögliche Variablen:
#
# {user} = Name des Spielers
# {minpoints} = minimaler Einsatze
# {pointsname} = Name der Chatbot-Punkte
# Erster Text
stakeBelowMinimum_Text = "🛑 @{user}, dein Einsatz liegt unterhalb der Grenze "
stakeBelowMinimum_Text += "von {minpoints} {pointsname}. "
stakeBelowMinimum_Text += "Versuche es erneut mit einem höheren Einsatz."
# Text zur Liste hinzufügen
message_StakeBelowMinimum.append(stakeBelowMinimum_Text)
### Benachrichtigung - Spieler will mehr Punkte einsetzen, als das erlaubte Maximum ###
#
# mögliche Variablen:
#
# {user} = Name des Spielers
# {target} = Name des Ziels
# {command} = Kommando zum Aufruf des Spieles
# {maxpoints} = Höhe des maximalen Einsatzes
# {pointsname} = Name der Chatbot-Punkte
#
#
# Erster Text
stakeOverMaximum_Text = "🛑 @{user}, dein Einsatz überschreitet den maximal möglichen Betrag "
stakeOverMaximum_Text += "in Höhe von {maxpoints} {pointsname}. "
stakeOverMaximum_Text += "Reduziere den Betrag und versuche es erneut. "
# Text zur Liste hinzufügen
message_StakeOverMaximum.append(stakeOverMaximum_Text)
### Benachrichtigung - Falscher Kommandoaufruf ###
#
# mögliche Variablen:
#
# {user} = Name des Spielers
# {command} = Kommando zum Aufruf des Spieles
# {maxpoints} = Höhe des maximalen Einsatzes
# {pointsname} = Name der Chatbot-Punkte
#
#
# Erster Text
wrongCommandOption_Text = "⛔ @{user}, das Kommando '{command}' wurde fehlerhaft verwendet. "
wrongCommandOption_Text += "Benutze folgendes Format: '{command} <Zahl>'. "
wrongCommandOption_Text += "Der maximale Einsatz beträgt {maxpoints} {pointsname}."
# Text zur Liste hinzufügen
message_WrongCommandOption.append(wrongCommandOption_Text)
### Benachrichtigung - 100%iger Erfolg ###
#
# mögliche Variablen:
#
# {target} = Name des Ziels
#
#
# Erster Text
outcome_100Percent_Text = "Alle Teilnehmer erfüllten ihre Aufgabe perfekt beim Run auf {target}. "
outcome_100Percent_Text += "Es gab keinerlei Verluste und der Job brachte die gewünschten Informationen. "
outcome_100Percent_Text += "Der Erlös des Verkaufs der erbeuteten Daten wird anteilsmäßig an die Teilnehmer verteilt: "
message_Outcome_100Percent.append(outcome_100Percent_Text)
# Zweiter Text
outcome_100Percent_Text = "Der Plan funktionierte Perfekt. Das ganze Team konnte unerkannt "
outcome_100Percent_Text += "in den Komplex von {target} eindringen, ohne das die Konzerntruppen alamiert wurden. "
outcome_100Percent_Text += "Der Erlös des Verkaufs der erbeuteten Daten wird anteilsmäßig an die Teilnehmer verteilt: "
# Text zur Liste hinzufügen
message_Outcome_100Percent.append(outcome_100Percent_Text)
### Benachrichtigung - 75-99% Überlebende des Run ###
#
# mögliche Variablen:
#
# {target} = Name des Ziels
#
#
# Erster Text
outcome_75_99Percent_Text = "Nicht alle konnten unerkannt in die Schatten entkommen. "
outcome_75_99Percent_Text += "Die Konzerntruppen von {target} konnten ein paar unglückliche des Teams "
outcome_75_99Percent_Text += "ausschalten, die anderen konnten mit wertvollen Informationen entkommen. "
outcome_75_99Percent_Text += "Der Erlös des Verkaufs der erbeuteten Daten wird anteilsmäßig an die "
outcome_75_99Percent_Text += "überlebenden Teilnehmer verteilt: "
# Text zur Liste hinzufügen
message_Outcome_75_99Percent.append(outcome_75_99Percent_Text)
# Zweiter Text
outcome_75_99Percent_Text = "Es gab ein paar wenige Verluste beim Run auf {target}. "
outcome_75_99Percent_Text += "Die meisten entkamen unerkannt in die Schatten. "
outcome_75_99Percent_Text += "Der Erlös des Verkaufs der erbeuteten Daten wird anteilsmäßig an die "
outcome_75_99Percent_Text += "überlebenden Teilnehmer verteilt: "
# Text zur Liste hinzufügen
message_Outcome_75_99Percent.append(outcome_75_99Percent_Text)
### Benachrichtigung - 25-74% Überlebende des Run ###
#
# mögliche Variablen:
#
# {target} = Name des Ziels
#
#
# Erster Text
outcome_25_74Percent_Text = "Verluste waren beim Run einkalkuliert, doch der Preis war hoch. "
outcome_25_74Percent_Text += "Die Kernmannschaft konnte bei dem Run auf {target} "
outcome_25_74Percent_Text += "mit den gewünschten Informationen entkommen. "
outcome_25_74Percent_Text += "Der Erlös des Verkaufs der erbeuteten Daten wird anteilsmäßig an die "
outcome_25_74Percent_Text += "überlebenden Teilnehmer verteilt: "
# Text zur Liste hinzufügen
message_Outcome_25_74Percent.append(outcome_25_74Percent_Text)
# Zweiter Text
outcome_25_74Percent_Text = "Das Team musste einen zu hohen Preis für ihren Erfolg zahlen. "
outcome_25_74Percent_Text += "Trotz hoher Verluste konnten einige Teilnehmer den Run auf {target} "
outcome_25_74Percent_Text += "erfolgreich abschliessen. "
outcome_25_74Percent_Text += "Der Erlös des Verkaufs der erbeuteten Daten wird anteilsmäßig an die "
outcome_25_74Percent_Text += "überlebenden Teilnehmer verteilt: "
# Text zur Liste hinzufügen
message_Outcome_25_74Percent.append(outcome_25_74Percent_Text)
### Benachrichtigung - 01-24% Überlebende des Run ###
#
# mögliche Variablen:
#
# {target} = Name des Ziels
#
#
# Erster Text
outcome_01_24Percent_Text = "Das Team hat bei dem Run auf {target} fast alle Mitglieder verloren. "
outcome_01_24Percent_Text += "Die wenigen Überlebenden verkriechen sich in den Schatten um "
outcome_01_24Percent_Text += "ihre Wunden zu versorgen und die gefallenen Kameraden zu betrauern. "
outcome_01_24Percent_Text += "Der Erlös des Verkaufs der erbeuteten Daten wird anteilsmäßig an die "
outcome_01_24Percent_Text += "überlebenden Teilnehmer verteilt: "
# Text zur Liste hinzufügen
message_Outcome_01_24Percent.append(outcome_01_24Percent_Text)
### Benachrichtigung - keine Überlebende des Run ###
#
# mögliche Variablen:
#
# {target} = Name des Ziels
#
#
# Erster Text
outcome_00Percent_Text = "Die Leben aller Runner wurden ausgelöscht... "
outcome_00Percent_Text += "Die Streitkräfte von {target} waren besser bewaffnet und offensichtlich vorbereitet. "
outcome_00Percent_Text += "Eine bessere Planung hätte diesen Fehlschlag wohl verhindern können. "
# Text zur Liste hinzufügen
message_Outcome_00Percent.append(outcome_00Percent_Text)
# Zweiter Text
outcome_00Percent_Text = "Die Leben aller Runner wurden ausgelöscht... "
outcome_00Percent_Text += "Die Sicherheitskräfte von {target} waren offenbar gewarnt. "
outcome_00Percent_Text += "War der Verräter in den eigenen Reihen? "
# Text zur Liste hinzufügen
message_Outcome_00Percent.append(outcome_00Percent_Text)
# Dritter Text
outcome_00Percent_Text = "Was ist da nur dermassen schief gelaufen? "
outcome_00Percent_Text += "Die Sicherheitskräfte von {target} haben alle Runner ausgelöscht, "
outcome_00Percent_Text += "bevor auch nur einer den Megaplex betreten konnte. "
outcome_00Percent_Text += "Wurden wir etwa verraten? "
# Text zur Liste hinzufügen
message_Outcome_00Percent.append(outcome_00Percent_Text)
#
#
### Benachrichtigs-Texte in die Datenbank eintragen ###
#
#
# Bestehende Tabelle löschen
self.DB_dropTable_Messages()
# Tabelle neu erzeugen
self.DB_create_Tables()
# Basis SQL Kommando um neue Daten in die Tabelle einzutragen
sql = "INSERT INTO game_heist_messages ( messageType, messageText ) VALUES ( ?,? )"
#
# Für jeden Eintrag der 'message_CoolDown'-Liste einen Datensatz in der Datenbank erzeugen
for message in message_CoolDown:
# Variablen für das SQL-Basis Kommando vorbereiten
val = (self.MessageType_IsOnCooldown, message)
# In die Datenbank schreiben - Doppelte Werte werden ignoriert
try:
self.GameDB.execute(sql, val)
except:
pass
#
# Für jeden Eintrag der 'message_GameCooldownOver'-Liste einen Datensatz in der Datenbank erzeugen
for message in message_GameCooldownOver:
# Variablen für das SQL-Basis Kommando vorbereiten
val = (self.MessageType_GameCooldownOver, message)
# In die Datenbank schreiben - Doppelte Werte werden ignoriert
try:
self.GameDB.execute(sql, val)
except:
pass
#
# Für jeden Eintrag der 'message_NewGameStart'-Liste einen Datensatz in der Datenbank erzeugen
for message in message_NewGameStart:
# Variablen für das SQL-Basis Kommando vorbereiten
val = (self.MessageType_NewGameStart, message)
# In die Datenbank schreiben - Doppelte Werte werden ignoriert
try:
self.GameDB.execute(sql, val)
except:
pass
#
# Für jeden Eintrag der 'message_GameStartIntro'-Liste einen Datensatz in der Datenbank erzeugen
for message in message_GameStartIntro:
# Variablen für das SQL-Basis Kommando vorbereiten
val = (self.MessageType_GameStartIntro, message)
# In die Datenbank schreiben - Doppelte Werte werden ignoriert
try:
self.GameDB.execute(sql, val)
except:
pass
#
# Für jeden Eintrag der 'message_NewPlayerEntry'-Liste einen Datensatz in der Datenbank erzeugen
for message in message_NewPlayerEntry:
# Variablen für das SQL-Basis Kommando vorbereiten
val = (self.MessageType_NewPlayer, message)
# In die Datenbank schreiben - Doppelte Werte werden ignoriert
try:
self.GameDB.execute(sql, val)
except:
pass
#
# Für jeden Eintrag der 'message_NotEnoughPoints'-Liste einen Datensatz in der Datenbank erzeugen
for message in message_NotEnoughPoints:
# Variablen für das SQL-Basis Kommando vorbereiten
val = (self.MessageType_NotEnoughPoints, message)
# In die Datenbank schreiben - Doppelte Werte werden ignoriert
try:
self.GameDB.execute(sql, val)
except:
pass
#
# Für jeden Eintrag der 'message_NotEnoughPlayer'-Liste einen Datensatz in der Datenbank erzeugen
for message in message_NotEnoughPlayer:
# Variablen für das SQL-Basis Kommando vorbereiten
val = (self.MessageType_NotEnoughPlayer, message)
# In die Datenbank schreiben - Doppelte Werte werden ignoriert
try:
self.GameDB.execute(sql, val)
except:
pass
#
# Für jeden Eintrag der 'message_StakeBelowMinimum'-Liste einen Datensatz in der Datenbank erzeugen
for message in message_StakeBelowMinimum:
# Variablen für das SQL-Basis Kommando vorbereiten
val = (self.MessageType_StakeBelowMinimum, message)
# In die Datenbank schreiben - Doppelte Werte werden ignoriert
try:
self.GameDB.execute(sql, val)
except:
pass
#
# Für jeden Eintrag der 'message_StakeOverMaximum'-Liste einen Datensatz in der Datenbank erzeugen
for message in message_StakeOverMaximum:
# Variablen für das SQL-Basis Kommando vorbereiten
val = (self.MessageType_StakeOverMaximum, message)
# In die Datenbank schreiben - Doppelte Werte werden ignoriert
try:
self.GameDB.execute(sql, val)
except:
pass
#
# Für jeden Eintrag der 'message_WrongCommandOption'-Liste einen Datensatz in der Datenbank erzeugen
for message in message_WrongCommandOption:
# Variablen für das SQL-Basis Kommando vorbereiten
val = (self.MessageType_WrongCommandOption, message)
# In die Datenbank schreiben - Doppelte Werte werden ignoriert
try:
self.GameDB.execute(sql, val)
except:
pass
#
# Für jeden Eintrag der 'message_Outcome_100Percent'-Liste einen Datensatz in der Datenbank erzeugen
for message in message_Outcome_100Percent:
# Variablen für das SQL-Basis Kommando vorbereiten
val = (self.MessageType_Outcome_100Percent, message)
# In die Datenbank schreiben - Doppelte Werte werden ignoriert
try:
self.GameDB.execute(sql, val)
except:
pass
#
# Für jeden Eintrag der 'message_Outcome_75_99Percent'-Liste einen Datensatz in der Datenbank erzeugen
for message in message_Outcome_75_99Percent:
# Variablen für das SQL-Basis Kommando vorbereiten
val = (self.MessageType_Outcome_75_99Percent, message)
# In die Datenbank schreiben - Doppelte Werte werden ignoriert
try:
self.GameDB.execute(sql, val)
except:
pass
#
# Für jeden Eintrag der 'message_Outcome_25_74Percent'-Liste einen Datensatz in der Datenbank erzeugen
for message in message_Outcome_25_74Percent:
# Variablen für das SQL-Basis Kommando vorbereiten
val = (self.MessageType_Outcome_25_74Percent, message)
# In die Datenbank schreiben - Doppelte Werte werden ignoriert
try:
self.GameDB.execute(sql, val)
except:
pass
#
# Für jeden Eintrag der 'message_Outcome_01_24Percent'-Liste einen Datensatz in der Datenbank erzeugen
for message in message_Outcome_01_24Percent:
# Variablen für das SQL-Basis Kommando vorbereiten
val = (self.MessageType_Outcome_01_24Percent, message)
# In die Datenbank schreiben - Doppelte Werte werden ignoriert
try:
self.GameDB.execute(sql, val)
except:
pass
#
# Für jeden Eintrag der 'message_Outcome_00Percent'-Liste einen Datensatz in der Datenbank erzeugen
for message in message_Outcome_00Percent:
# Variablen für das SQL-Basis Kommando vorbereiten
val = (self.MessageType_Outcome_00Percent, message)
# In die Datenbank schreiben - Doppelte Werte werden ignoriert
try:
self.GameDB.execute(sql, val)
except:
pass
# Daten speichern
self.GameDB.commit()
return | [
"def",
"DB_create_DefaultMessages",
"(",
"self",
")",
":",
"thisActionName",
"=",
"\"DB_create_DefaultMessages\"",
"# Nachrichten Listen\r",
"message_CoolDown",
"=",
"[",
"]",
"message_GameCooldownOver",
"=",
"[",
"]",
"message_NewGameStart",
"=",
"[",
"]",
"message_NewPlayerEntry",
"=",
"[",
"]",
"message_NotEnoughPoints",
"=",
"[",
"]",
"message_NotEnoughPlayer",
"=",
"[",
"]",
"message_StakeOverMaximum",
"=",
"[",
"]",
"message_WrongCommandOption",
"=",
"[",
"]",
"message_StakeBelowMinimum",
"=",
"[",
"]",
"message_Outcome_100Percent",
"=",
"[",
"]",
"message_Outcome_75_99Percent",
"=",
"[",
"]",
"message_Outcome_25_74Percent",
"=",
"[",
"]",
"message_Outcome_01_24Percent",
"=",
"[",
"]",
"message_Outcome_00Percent",
"=",
"[",
"]",
"message_GameStartIntro",
"=",
"[",
"]",
"#\r",
"#\r",
"### Default Texte vorbereiten ###\r",
"#\r",
"#\r",
"# Sollte mehr als eine Nachricht mit dem selben Nachrichten-Typ (messageType) vorhanden\r",
"# sein, so wird eine der Nachrichten per Zufall ausgewählt.\r",
"#\r",
"#\r",
"### Benachrichtigung - Kommando ist im Cooldown ###\r",
"#\r",
"# mögliche Variablen:\r",
"#\r",
"# {time} = Cooldown Zeit\r",
"# {command} = Kommando des Spiels\r",
"#\r",
"# Erster Text\r",
"coolDown_text",
"=",
"\"Die Sicherheitskräfte sind aktuell alamiert und patrouillieren noch in der Gegend. \"\r",
"coolDown_text",
"+=",
"\"Du musst noch {time} warten bis zum nächsten Überfall.\"\r",
"# Text der Liste hinzufügen\r",
"message_CoolDown",
".",
"append",
"(",
"coolDown_text",
")",
"# Zweiter Text\r",
"coolDown_text",
"=",
"\"Das Kommando '{command}' befindet sich derzeit im Cooldown. \"",
"coolDown_text",
"+=",
"\"Du musst noch {time} warten bis zur nächsten Ausführung des Kommandos.\"\r",
"# Text der Liste hinzufügen\r",
"message_CoolDown",
".",
"append",
"(",
"coolDown_text",
")",
"### Benachrichtigung - Cooldown ist abgelaufen ###\r",
"#\r",
"# mögliche Variablen:\r",
"#\r",
"# {command} = Kommando des Spiels\r",
"#\r",
"# Erster Text\r",
"gameCooldownOver_text",
"=",
"\"Die Sicherheitskräfte der Megaplexe haben ihre Patrouille beendet \"\r",
"gameCooldownOver_text",
"+=",
"\"und kehren in ihre Kasernen zurück. \"\r",
"gameCooldownOver_text",
"+=",
"\"Verwende '{command} <EINSATZ>' um ein Team für einen neuen Überfall \"\r",
"gameCooldownOver_text",
"+=",
"\"zusammenzustellen. \"",
"# Text der Liste hinzufügen\r",
"message_GameCooldownOver",
".",
"append",
"(",
"gameCooldownOver_text",
")",
"### Benachrichtigung - Spiel wurde gestartet ###\r",
"#\r",
"# mögliche Variablen:\r",
"#\r",
"# {user} = Name des Spielers, der den Heist starten will\r",
"# {command} = Kommando des Spiels\r",
"# {target} = Name des Ziels\r",
"# {time} = Zeit bis das Spiel startet\r",
"# {maxpoints} = Höhe des maximalen Einsatzes\r",
"# {pointsname} = Name der Chatbot-Punkte\r",
"#\r",
"# Erster Text\r",
"newGameStart_Text",
"=",
"\"🗨️ {user} stellt ein Team zusammen um geheime Daten von {target} zu stehlen. \"\r",
"newGameStart_Text",
"+=",
"\"Schreibe '{command} <EINSATZ>' in den Chat um an dem Überfall teilzunehmen. \"\r",
"newGameStart_Text",
"+=",
"\"Du hast {time} Zeit. \"",
"# Text der Liste hinzufügen\r",
"message_NewGameStart",
".",
"append",
"(",
"newGameStart_Text",
")",
"# Zweiter Text\r",
"newGameStart_Text",
"=",
"\"🗨️ {user} plant einen Überfall, um Daten von {target} zu stehlen. \"\r",
"newGameStart_Text",
"+=",
"\"Werde ein Teil des Teams und schreibe '{command} <EINSATZ>' in den Chat um an dem Run teilzunehmen. \"",
"newGameStart_Text",
"+=",
"\"Du hast {time} Zeit. \"",
"# Text der Liste hinzufügen\r",
"message_NewGameStart",
".",
"append",
"(",
"newGameStart_Text",
")",
"### Benachrichtigung - Introtext für den Spielstart ###\r",
"#\r",
"# mögliche Variablen:\r",
"#\r",
"# {target} = Name des Ziels\r",
"#\r",
"#\r",
"# Erster Text\r",
"gameStartIntro_Text",
"=",
"\"👥 Es geht los! Schnappt euch eure Ausrüstung und überprüft nochmals eure Waffen. \"\r",
"gameStartIntro_Text",
"+=",
"\"Seit Vorsichtig, die Sicherheitskräfte von {target} schiessen erst und stellen später fragen... \"\r",
"# Text zur Liste hinzufügen\r",
"message_GameStartIntro",
".",
"append",
"(",
"gameStartIntro_Text",
")",
"# Zweiter Text\r",
"gameStartIntro_Text",
"=",
"\"👥 Wir starten jetzt unseren Angriff auf den Megaplex von {target}. \"\r",
"gameStartIntro_Text",
"+=",
"\"Prüft eure Decks und ladet eure Waffen. \"\r",
"# Text zur Liste hinzufügen\r",
"message_GameStartIntro",
".",
"append",
"(",
"gameStartIntro_Text",
")",
"### Benachrichtigung - Neuer Spieler ###\r",
"#\r",
"# mögliche Variablen:\r",
"#\r",
"# {user} = Name des Spielers, der den Heist starten will\r",
"# {target} = Name des Ziels\r",
"# {stake} = Einsatz des Spielers\r",
"# {pointsname} = Name der Chatbot-Punkte\r",
"#\r",
"# Erster Text\r",
"newPlayerEntry_Text",
"=",
"\"✅ {user} nimmt mit einem Einsatz von {stake} {pointsname} am Überfall auf {target} teil. \"\r",
"message_NewPlayerEntry",
".",
"append",
"(",
"newPlayerEntry_Text",
")",
"### Benachrichtigung - Spieler hat nicht genug Punkte ###\r",
"#\r",
"# mögliche Variablen:\r",
"#\r",
"# {user} = Name des Spielers\r",
"# {target} = Name des Ziels\r",
"# {points} = Punkte des Spielers\r",
"# {pointsname} = Name der Chatbot-Punkte\r",
"#\r",
"# Erster Text\r",
"notEnoughPoints_Text",
"=",
"\"🛑 @{user}, du verfügst nur über {points} {pointsname} und kannst daher nicht \"\r",
"notEnoughPoints_Text",
"+=",
"\"mit einem so hohen Einsatz am Überfall auf {target} teilnehmen. \"\r",
"notEnoughPoints_Text",
"+=",
"\"Versuche es erneut mit einem reduzierten Einsatz.\"",
"# Text zur Liste hinzufügen\r",
"message_NotEnoughPoints",
".",
"append",
"(",
"notEnoughPoints_Text",
")",
"# Zweiter Text\r",
"notEnoughPoints_Text",
"=",
"\"🛑 @{user}, du verfügst nur über {points} {pointsname} und kannst daher nicht \"\r",
"notEnoughPoints_Text",
"+=",
"\"mit einem so hohen Einsatz am Überfall teilnehmen. \"\r",
"notEnoughPoints_Text",
"+=",
"\"Versuche es erneut mit einem reduzierten Einsatz.\"",
"# Text zur Liste hinzufügen\r",
"message_NotEnoughPoints",
".",
"append",
"(",
"notEnoughPoints_Text",
")",
"### Benachrichtigung - ungenügende Anzahl Spieler ###\r",
"#\r",
"# mögliche Variablen:\r",
"#\r",
"# {target} = Name des Ziels\r",
"# {pointsname} = Name der Chatbot-Punkte\r",
"#\r",
"notEnoughPlayer_Text",
"=",
"\"Leider sind nicht genügend Runner zusammen gekommen, um den \"\r",
"notEnoughPlayer_Text",
"+=",
"\"Run auf {target} erfolgreich durchführen zu können. \"\r",
"notEnoughPlayer_Text",
"+=",
"\"Die eingesetzten {pointsname} wurden erstattet. \"",
"# Text zur Liste hinzufügen\r",
"message_NotEnoughPlayer",
".",
"append",
"(",
"notEnoughPlayer_Text",
")",
"### Benachrichtigung - Einsatz kleiner eingestelltes Minimum ###\r",
"#\r",
"# mögliche Variablen:\r",
"#\r",
"# {user} = Name des Spielers\r",
"# {minpoints} = minimaler Einsatze\r",
"# {pointsname} = Name der Chatbot-Punkte\r",
"# Erster Text\r",
"stakeBelowMinimum_Text",
"=",
"\"🛑 @{user}, dein Einsatz liegt unterhalb der Grenze \"\r",
"stakeBelowMinimum_Text",
"+=",
"\"von {minpoints} {pointsname}. \"",
"stakeBelowMinimum_Text",
"+=",
"\"Versuche es erneut mit einem höheren Einsatz.\"\r",
"# Text zur Liste hinzufügen\r",
"message_StakeBelowMinimum",
".",
"append",
"(",
"stakeBelowMinimum_Text",
")",
"### Benachrichtigung - Spieler will mehr Punkte einsetzen, als das erlaubte Maximum ###\r",
"#\r",
"# mögliche Variablen:\r",
"#\r",
"# {user} = Name des Spielers\r",
"# {target} = Name des Ziels\r",
"# {command} = Kommando zum Aufruf des Spieles\r",
"# {maxpoints} = Höhe des maximalen Einsatzes\r",
"# {pointsname} = Name der Chatbot-Punkte\r",
"#\r",
"#\r",
"# Erster Text\r",
"stakeOverMaximum_Text",
"=",
"\"🛑 @{user}, dein Einsatz überschreitet den maximal möglichen Betrag \"\r",
"stakeOverMaximum_Text",
"+=",
"\"in Höhe von {maxpoints} {pointsname}. \"\r",
"stakeOverMaximum_Text",
"+=",
"\"Reduziere den Betrag und versuche es erneut. \"",
"# Text zur Liste hinzufügen\r",
"message_StakeOverMaximum",
".",
"append",
"(",
"stakeOverMaximum_Text",
")",
"### Benachrichtigung - Falscher Kommandoaufruf ###\r",
"#\r",
"# mögliche Variablen:\r",
"#\r",
"# {user} = Name des Spielers\r",
"# {command} = Kommando zum Aufruf des Spieles\r",
"# {maxpoints} = Höhe des maximalen Einsatzes\r",
"# {pointsname} = Name der Chatbot-Punkte\r",
"#\r",
"#\r",
"# Erster Text\r",
"wrongCommandOption_Text",
"=",
"\"⛔ @{user}, das Kommando '{command}' wurde fehlerhaft verwendet. \"\r",
"wrongCommandOption_Text",
"+=",
"\"Benutze folgendes Format: '{command} <Zahl>'. \"",
"wrongCommandOption_Text",
"+=",
"\"Der maximale Einsatz beträgt {maxpoints} {pointsname}.\"\r",
"# Text zur Liste hinzufügen\r",
"message_WrongCommandOption",
".",
"append",
"(",
"wrongCommandOption_Text",
")",
"### Benachrichtigung - 100%iger Erfolg ###\r",
"#\r",
"# mögliche Variablen:\r",
"#\r",
"# {target} = Name des Ziels\r",
"#\r",
"#\r",
"# Erster Text\r",
"outcome_100Percent_Text",
"=",
"\"Alle Teilnehmer erfüllten ihre Aufgabe perfekt beim Run auf {target}. \"\r",
"outcome_100Percent_Text",
"+=",
"\"Es gab keinerlei Verluste und der Job brachte die gewünschten Informationen. \"\r",
"outcome_100Percent_Text",
"+=",
"\"Der Erlös des Verkaufs der erbeuteten Daten wird anteilsmäßig an die Teilnehmer verteilt: \"\r",
"message_Outcome_100Percent",
".",
"append",
"(",
"outcome_100Percent_Text",
")",
"# Zweiter Text\r",
"outcome_100Percent_Text",
"=",
"\"Der Plan funktionierte Perfekt. Das ganze Team konnte unerkannt \"",
"outcome_100Percent_Text",
"+=",
"\"in den Komplex von {target} eindringen, ohne das die Konzerntruppen alamiert wurden. \"",
"outcome_100Percent_Text",
"+=",
"\"Der Erlös des Verkaufs der erbeuteten Daten wird anteilsmäßig an die Teilnehmer verteilt: \"\r",
"# Text zur Liste hinzufügen\r",
"message_Outcome_100Percent",
".",
"append",
"(",
"outcome_100Percent_Text",
")",
"### Benachrichtigung - 75-99% Überlebende des Run ###\r",
"#\r",
"# mögliche Variablen:\r",
"#\r",
"# {target} = Name des Ziels\r",
"#\r",
"#\r",
"# Erster Text\r",
"outcome_75_99Percent_Text",
"=",
"\"Nicht alle konnten unerkannt in die Schatten entkommen. \"",
"outcome_75_99Percent_Text",
"+=",
"\"Die Konzerntruppen von {target} konnten ein paar unglückliche des Teams \"\r",
"outcome_75_99Percent_Text",
"+=",
"\"ausschalten, die anderen konnten mit wertvollen Informationen entkommen. \"",
"outcome_75_99Percent_Text",
"+=",
"\"Der Erlös des Verkaufs der erbeuteten Daten wird anteilsmäßig an die \"\r",
"outcome_75_99Percent_Text",
"+=",
"\"überlebenden Teilnehmer verteilt: \"\r",
"# Text zur Liste hinzufügen\r",
"message_Outcome_75_99Percent",
".",
"append",
"(",
"outcome_75_99Percent_Text",
")",
"# Zweiter Text\r",
"outcome_75_99Percent_Text",
"=",
"\"Es gab ein paar wenige Verluste beim Run auf {target}. \"",
"outcome_75_99Percent_Text",
"+=",
"\"Die meisten entkamen unerkannt in die Schatten. \"",
"outcome_75_99Percent_Text",
"+=",
"\"Der Erlös des Verkaufs der erbeuteten Daten wird anteilsmäßig an die \"\r",
"outcome_75_99Percent_Text",
"+=",
"\"überlebenden Teilnehmer verteilt: \"\r",
"# Text zur Liste hinzufügen\r",
"message_Outcome_75_99Percent",
".",
"append",
"(",
"outcome_75_99Percent_Text",
")",
"### Benachrichtigung - 25-74% Überlebende des Run ###\r",
"#\r",
"# mögliche Variablen:\r",
"#\r",
"# {target} = Name des Ziels\r",
"#\r",
"#\r",
"# Erster Text\r",
"outcome_25_74Percent_Text",
"=",
"\"Verluste waren beim Run einkalkuliert, doch der Preis war hoch. \"",
"outcome_25_74Percent_Text",
"+=",
"\"Die Kernmannschaft konnte bei dem Run auf {target} \"",
"outcome_25_74Percent_Text",
"+=",
"\"mit den gewünschten Informationen entkommen. \"\r",
"outcome_25_74Percent_Text",
"+=",
"\"Der Erlös des Verkaufs der erbeuteten Daten wird anteilsmäßig an die \"\r",
"outcome_25_74Percent_Text",
"+=",
"\"überlebenden Teilnehmer verteilt: \"\r",
"# Text zur Liste hinzufügen\r",
"message_Outcome_25_74Percent",
".",
"append",
"(",
"outcome_25_74Percent_Text",
")",
"# Zweiter Text\r",
"outcome_25_74Percent_Text",
"=",
"\"Das Team musste einen zu hohen Preis für ihren Erfolg zahlen. \"\r",
"outcome_25_74Percent_Text",
"+=",
"\"Trotz hoher Verluste konnten einige Teilnehmer den Run auf {target} \"",
"outcome_25_74Percent_Text",
"+=",
"\"erfolgreich abschliessen. \"",
"outcome_25_74Percent_Text",
"+=",
"\"Der Erlös des Verkaufs der erbeuteten Daten wird anteilsmäßig an die \"\r",
"outcome_25_74Percent_Text",
"+=",
"\"überlebenden Teilnehmer verteilt: \"\r",
"# Text zur Liste hinzufügen\r",
"message_Outcome_25_74Percent",
".",
"append",
"(",
"outcome_25_74Percent_Text",
")",
"### Benachrichtigung - 01-24% Überlebende des Run ###\r",
"#\r",
"# mögliche Variablen:\r",
"#\r",
"# {target} = Name des Ziels\r",
"#\r",
"#\r",
"# Erster Text\r",
"outcome_01_24Percent_Text",
"=",
"\"Das Team hat bei dem Run auf {target} fast alle Mitglieder verloren. \"",
"outcome_01_24Percent_Text",
"+=",
"\"Die wenigen Überlebenden verkriechen sich in den Schatten um \"\r",
"outcome_01_24Percent_Text",
"+=",
"\"ihre Wunden zu versorgen und die gefallenen Kameraden zu betrauern. \"",
"outcome_01_24Percent_Text",
"+=",
"\"Der Erlös des Verkaufs der erbeuteten Daten wird anteilsmäßig an die \"\r",
"outcome_01_24Percent_Text",
"+=",
"\"überlebenden Teilnehmer verteilt: \"\r",
"# Text zur Liste hinzufügen\r",
"message_Outcome_01_24Percent",
".",
"append",
"(",
"outcome_01_24Percent_Text",
")",
"### Benachrichtigung - keine Überlebende des Run ###\r",
"#\r",
"# mögliche Variablen:\r",
"#\r",
"# {target} = Name des Ziels\r",
"#\r",
"#\r",
"# Erster Text\r",
"outcome_00Percent_Text",
"=",
"\"Die Leben aller Runner wurden ausgelöscht... \"\r",
"outcome_00Percent_Text",
"+=",
"\"Die Streitkräfte von {target} waren besser bewaffnet und offensichtlich vorbereitet. \"\r",
"outcome_00Percent_Text",
"+=",
"\"Eine bessere Planung hätte diesen Fehlschlag wohl verhindern können. \"\r",
"# Text zur Liste hinzufügen\r",
"message_Outcome_00Percent",
".",
"append",
"(",
"outcome_00Percent_Text",
")",
"# Zweiter Text\r",
"outcome_00Percent_Text",
"=",
"\"Die Leben aller Runner wurden ausgelöscht... \"\r",
"outcome_00Percent_Text",
"+=",
"\"Die Sicherheitskräfte von {target} waren offenbar gewarnt. \"\r",
"outcome_00Percent_Text",
"+=",
"\"War der Verräter in den eigenen Reihen? \"\r",
"# Text zur Liste hinzufügen\r",
"message_Outcome_00Percent",
".",
"append",
"(",
"outcome_00Percent_Text",
")",
"# Dritter Text\r",
"outcome_00Percent_Text",
"=",
"\"Was ist da nur dermassen schief gelaufen? \"",
"outcome_00Percent_Text",
"+=",
"\"Die Sicherheitskräfte von {target} haben alle Runner ausgelöscht, \"\r",
"outcome_00Percent_Text",
"+=",
"\"bevor auch nur einer den Megaplex betreten konnte. \"",
"outcome_00Percent_Text",
"+=",
"\"Wurden wir etwa verraten? \"",
"# Text zur Liste hinzufügen\r",
"message_Outcome_00Percent",
".",
"append",
"(",
"outcome_00Percent_Text",
")",
"#\r",
"#\r",
"### Benachrichtigs-Texte in die Datenbank eintragen ###\r",
"#\r",
"#\r",
"# Bestehende Tabelle löschen\r",
"self",
".",
"DB_dropTable_Messages",
"(",
")",
"# Tabelle neu erzeugen\r",
"self",
".",
"DB_create_Tables",
"(",
")",
"# Basis SQL Kommando um neue Daten in die Tabelle einzutragen\r",
"sql",
"=",
"\"INSERT INTO game_heist_messages ( messageType, messageText ) VALUES ( ?,? )\"",
"#\r",
"# Für jeden Eintrag der 'message_CoolDown'-Liste einen Datensatz in der Datenbank erzeugen\r",
"for",
"message",
"in",
"message_CoolDown",
":",
"# Variablen für das SQL-Basis Kommando vorbereiten\r",
"val",
"=",
"(",
"self",
".",
"MessageType_IsOnCooldown",
",",
"message",
")",
"# In die Datenbank schreiben - Doppelte Werte werden ignoriert\r",
"try",
":",
"self",
".",
"GameDB",
".",
"execute",
"(",
"sql",
",",
"val",
")",
"except",
":",
"pass",
"#\r",
"# Für jeden Eintrag der 'message_GameCooldownOver'-Liste einen Datensatz in der Datenbank erzeugen\r",
"for",
"message",
"in",
"message_GameCooldownOver",
":",
"# Variablen für das SQL-Basis Kommando vorbereiten\r",
"val",
"=",
"(",
"self",
".",
"MessageType_GameCooldownOver",
",",
"message",
")",
"# In die Datenbank schreiben - Doppelte Werte werden ignoriert\r",
"try",
":",
"self",
".",
"GameDB",
".",
"execute",
"(",
"sql",
",",
"val",
")",
"except",
":",
"pass",
"#\r",
"# Für jeden Eintrag der 'message_NewGameStart'-Liste einen Datensatz in der Datenbank erzeugen\r",
"for",
"message",
"in",
"message_NewGameStart",
":",
"# Variablen für das SQL-Basis Kommando vorbereiten\r",
"val",
"=",
"(",
"self",
".",
"MessageType_NewGameStart",
",",
"message",
")",
"# In die Datenbank schreiben - Doppelte Werte werden ignoriert\r",
"try",
":",
"self",
".",
"GameDB",
".",
"execute",
"(",
"sql",
",",
"val",
")",
"except",
":",
"pass",
"#\r",
"# Für jeden Eintrag der 'message_GameStartIntro'-Liste einen Datensatz in der Datenbank erzeugen\r",
"for",
"message",
"in",
"message_GameStartIntro",
":",
"# Variablen für das SQL-Basis Kommando vorbereiten\r",
"val",
"=",
"(",
"self",
".",
"MessageType_GameStartIntro",
",",
"message",
")",
"# In die Datenbank schreiben - Doppelte Werte werden ignoriert\r",
"try",
":",
"self",
".",
"GameDB",
".",
"execute",
"(",
"sql",
",",
"val",
")",
"except",
":",
"pass",
"#\r",
"# Für jeden Eintrag der 'message_NewPlayerEntry'-Liste einen Datensatz in der Datenbank erzeugen\r",
"for",
"message",
"in",
"message_NewPlayerEntry",
":",
"# Variablen für das SQL-Basis Kommando vorbereiten\r",
"val",
"=",
"(",
"self",
".",
"MessageType_NewPlayer",
",",
"message",
")",
"# In die Datenbank schreiben - Doppelte Werte werden ignoriert\r",
"try",
":",
"self",
".",
"GameDB",
".",
"execute",
"(",
"sql",
",",
"val",
")",
"except",
":",
"pass",
"#\r",
"# Für jeden Eintrag der 'message_NotEnoughPoints'-Liste einen Datensatz in der Datenbank erzeugen\r",
"for",
"message",
"in",
"message_NotEnoughPoints",
":",
"# Variablen für das SQL-Basis Kommando vorbereiten\r",
"val",
"=",
"(",
"self",
".",
"MessageType_NotEnoughPoints",
",",
"message",
")",
"# In die Datenbank schreiben - Doppelte Werte werden ignoriert\r",
"try",
":",
"self",
".",
"GameDB",
".",
"execute",
"(",
"sql",
",",
"val",
")",
"except",
":",
"pass",
"#\r",
"# Für jeden Eintrag der 'message_NotEnoughPlayer'-Liste einen Datensatz in der Datenbank erzeugen\r",
"for",
"message",
"in",
"message_NotEnoughPlayer",
":",
"# Variablen für das SQL-Basis Kommando vorbereiten\r",
"val",
"=",
"(",
"self",
".",
"MessageType_NotEnoughPlayer",
",",
"message",
")",
"# In die Datenbank schreiben - Doppelte Werte werden ignoriert\r",
"try",
":",
"self",
".",
"GameDB",
".",
"execute",
"(",
"sql",
",",
"val",
")",
"except",
":",
"pass",
"#\r",
"# Für jeden Eintrag der 'message_StakeBelowMinimum'-Liste einen Datensatz in der Datenbank erzeugen\r",
"for",
"message",
"in",
"message_StakeBelowMinimum",
":",
"# Variablen für das SQL-Basis Kommando vorbereiten\r",
"val",
"=",
"(",
"self",
".",
"MessageType_StakeBelowMinimum",
",",
"message",
")",
"# In die Datenbank schreiben - Doppelte Werte werden ignoriert\r",
"try",
":",
"self",
".",
"GameDB",
".",
"execute",
"(",
"sql",
",",
"val",
")",
"except",
":",
"pass",
"#\r",
"# Für jeden Eintrag der 'message_StakeOverMaximum'-Liste einen Datensatz in der Datenbank erzeugen\r",
"for",
"message",
"in",
"message_StakeOverMaximum",
":",
"# Variablen für das SQL-Basis Kommando vorbereiten\r",
"val",
"=",
"(",
"self",
".",
"MessageType_StakeOverMaximum",
",",
"message",
")",
"# In die Datenbank schreiben - Doppelte Werte werden ignoriert\r",
"try",
":",
"self",
".",
"GameDB",
".",
"execute",
"(",
"sql",
",",
"val",
")",
"except",
":",
"pass",
"#\r",
"# Für jeden Eintrag der 'message_WrongCommandOption'-Liste einen Datensatz in der Datenbank erzeugen\r",
"for",
"message",
"in",
"message_WrongCommandOption",
":",
"# Variablen für das SQL-Basis Kommando vorbereiten\r",
"val",
"=",
"(",
"self",
".",
"MessageType_WrongCommandOption",
",",
"message",
")",
"# In die Datenbank schreiben - Doppelte Werte werden ignoriert\r",
"try",
":",
"self",
".",
"GameDB",
".",
"execute",
"(",
"sql",
",",
"val",
")",
"except",
":",
"pass",
"#\r",
"# Für jeden Eintrag der 'message_Outcome_100Percent'-Liste einen Datensatz in der Datenbank erzeugen\r",
"for",
"message",
"in",
"message_Outcome_100Percent",
":",
"# Variablen für das SQL-Basis Kommando vorbereiten\r",
"val",
"=",
"(",
"self",
".",
"MessageType_Outcome_100Percent",
",",
"message",
")",
"# In die Datenbank schreiben - Doppelte Werte werden ignoriert\r",
"try",
":",
"self",
".",
"GameDB",
".",
"execute",
"(",
"sql",
",",
"val",
")",
"except",
":",
"pass",
"#\r",
"# Für jeden Eintrag der 'message_Outcome_75_99Percent'-Liste einen Datensatz in der Datenbank erzeugen\r",
"for",
"message",
"in",
"message_Outcome_75_99Percent",
":",
"# Variablen für das SQL-Basis Kommando vorbereiten\r",
"val",
"=",
"(",
"self",
".",
"MessageType_Outcome_75_99Percent",
",",
"message",
")",
"# In die Datenbank schreiben - Doppelte Werte werden ignoriert\r",
"try",
":",
"self",
".",
"GameDB",
".",
"execute",
"(",
"sql",
",",
"val",
")",
"except",
":",
"pass",
"#\r",
"# Für jeden Eintrag der 'message_Outcome_25_74Percent'-Liste einen Datensatz in der Datenbank erzeugen\r",
"for",
"message",
"in",
"message_Outcome_25_74Percent",
":",
"# Variablen für das SQL-Basis Kommando vorbereiten\r",
"val",
"=",
"(",
"self",
".",
"MessageType_Outcome_25_74Percent",
",",
"message",
")",
"# In die Datenbank schreiben - Doppelte Werte werden ignoriert\r",
"try",
":",
"self",
".",
"GameDB",
".",
"execute",
"(",
"sql",
",",
"val",
")",
"except",
":",
"pass",
"#\r",
"# Für jeden Eintrag der 'message_Outcome_01_24Percent'-Liste einen Datensatz in der Datenbank erzeugen\r",
"for",
"message",
"in",
"message_Outcome_01_24Percent",
":",
"# Variablen für das SQL-Basis Kommando vorbereiten\r",
"val",
"=",
"(",
"self",
".",
"MessageType_Outcome_01_24Percent",
",",
"message",
")",
"# In die Datenbank schreiben - Doppelte Werte werden ignoriert\r",
"try",
":",
"self",
".",
"GameDB",
".",
"execute",
"(",
"sql",
",",
"val",
")",
"except",
":",
"pass",
"#\r",
"# Für jeden Eintrag der 'message_Outcome_00Percent'-Liste einen Datensatz in der Datenbank erzeugen\r",
"for",
"message",
"in",
"message_Outcome_00Percent",
":",
"# Variablen für das SQL-Basis Kommando vorbereiten\r",
"val",
"=",
"(",
"self",
".",
"MessageType_Outcome_00Percent",
",",
"message",
")",
"# In die Datenbank schreiben - Doppelte Werte werden ignoriert\r",
"try",
":",
"self",
".",
"GameDB",
".",
"execute",
"(",
"sql",
",",
"val",
")",
"except",
":",
"pass",
"# Daten speichern\r",
"self",
".",
"GameDB",
".",
"commit",
"(",
")",
"return"
] | [
145,
4
] | [
720,
14
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
GUI.__init__ | (self, hauptfenster) | Konstruktor, in dem das GUI des Simulators aufgebaut wird | Konstruktor, in dem das GUI des Simulators aufgebaut wird | def __init__(self, hauptfenster):
""" Konstruktor, in dem das GUI des Simulators aufgebaut wird """
self.fenster = hauptfenster
self.fenster.iconbitmap("simstb.ico")
self.fenster.protocol("WM_DELETE_WINDOW", lambda: self.beenden())
self.gen_gui = None
# Styles festlegen
self.festlegen_Styles()
# Hauptrahmen anlegen
hauptrahmen = ttk.Frame(master=self.fenster, padding="5", style="Haupt.TFrame")
hauptrahmen.grid(column=1, row=1, sticky="NWES")
self.fenster.columnconfigure(1, weight=1)
self.fenster.rowconfigure(1, weight=1)
# Titelbereich einfügen
ttk.Label(master=hauptrahmen, text="SimSTB", style="HauptLabel1.TLabel").grid(column=1, row=1, sticky="NW")
ttk.Label(master=hauptrahmen, text="Simulationsumgebung für digitale\nund analoge Ein- und Ausgänge", style="HauptLabel2.TLabel").grid(column=2, row=1, columnspan=2, sticky="NW")
self.datum = StringVar()
ttk.Label(master=hauptrahmen, textvariable=self.datum, style="HauptLabel2.TLabel").grid(column=1, row=2, sticky="NW")
self.zeit = StringVar()
ttk.Label(master=hauptrahmen, textvariable=self.zeit, style="HauptLabel2.TLabel").grid(column=2, row=2, sticky="NW")
# Unterrahmen 1 und Knöpfe
unterrahmen1 = ttk.Frame(master=hauptrahmen, padding="5", style="Block.TFrame")
unterrahmen1.grid(column=1, row=3, sticky="NWES")
ttk.Button(master=unterrahmen1, text="Alles 0", command=lambda: self.setzen0_alles() ).grid(column=1, row=1, sticky="WE")
ttk.Button(master=unterrahmen1, text="Alle Ausgänge 0", command=lambda: self.setzen0_ausgaenge() ).grid(column=1, row=2, sticky="WE")
ttk.Button(master=unterrahmen1, text="Alle Eingänge 0", command=lambda: self.setzen0_eingaenge() ).grid(column=1, row=3, sticky="WE")
ttk.Button(master=unterrahmen1, text="Digitale Eingänge 0", command=lambda: self.setzen0_digitale_eingaenge() ).grid(column=1, row=4, sticky="WE")
ttk.Button(master=unterrahmen1, text="Digitale Eingänge 1", command=lambda: self.setzen1_digitale_eingaenge() ).grid(column=1, row=5, sticky="WE")
# Unterrahmen 2 und Knöpfe
unterrahmen2 = ttk.Frame(master=hauptrahmen, padding="5", style="Block.TFrame")
unterrahmen2.grid(column=1, row=4, sticky="NWES")
ttk.Button(master=unterrahmen2, text="Modelle", command=lambda: self.modelle() ).grid(column=1, row=1, sticky="WE")
ttk.Button(master=unterrahmen2, text="Testautomaten", command=lambda: self.testautomaten() ).grid(column=1, row=2, sticky="WE")
ttk.Button(master=unterrahmen2, text="Funktionsgenerator", command=lambda: self.funktionsgenerator()).grid(column=1, row=3, sticky="WE")
ttk.Button(master=unterrahmen2, text="Datenaufzeichnung", command=lambda: self.datenaufzeichnen() ).grid(column=1, row=4, sticky="NW")
# Unterrahmen 3 und Inhalt
unterrahmen3 = ttk.Frame(master=hauptrahmen, padding="5", style="Block.TFrame")
unterrahmen3.grid(column=2, row=3, rowspan=2, sticky="NWES")
ttk.Label(master=unterrahmen3, text="Digitale\nEingänge", style="BlockLabel2.TLabel").grid(column=1, row=1, columnspan=2, sticky="NW")
unterrahmenDE = ttk.Frame(master=unterrahmen3, padding="5", style="Unterblock.TFrame")
unterrahmenDE.grid(column=1, row=2, columnspan=2, sticky="NWES")
self.DE = []
for i in range(Konfig.DIGMAXLAENGE):
eintrag = IntVar()
eintrag.set(0)
ttk.Checkbutton(master=unterrahmenDE, text="DE"+str(i), command=lambda: self.setzen_digitale_eingaenge(), variable=eintrag, style="BlockCheckbutton.TCheckbutton").grid(column=1, row=i+1, sticky="NW")
self.DE.append(eintrag)
ttk.Label(master=unterrahmen3, text="Digitale\nAusgänge", style="BlockLabel2.TLabel").grid(column=3, row=1, columnspan=2, sticky="NW")
unterrahmenDA = ttk.Frame(master=unterrahmen3, padding="5", style="Unterblock.TFrame")
unterrahmenDA.grid(column=3, row=2, columnspan=2, sticky="NWES")
self.DA = []
for i in range(Konfig.DIGMAXLAENGE):
eintrag = IntVar()
eintrag.set(0)
ttk.Checkbutton(master=unterrahmenDA, text="DA"+str(i), variable=eintrag, style="BlockCheckbutton.TCheckbutton", state=DISABLED).grid(column=1, row=i+1, sticky="NW")
self.DA.append(eintrag)
ttk.Label(master=unterrahmen3, text="Analoge\nEingänge", style="BlockLabel2.TLabel").grid(column=1, row=3, columnspan=2, sticky="NW")
validationAE = (self.fenster.register(self.setzen_analoge_eingaenge_1),"%P")
unterrahmenAE = ttk.Frame(master=unterrahmen3, padding="5", style="Unterblock.TFrame")
unterrahmenAE.grid(column=1, row=4, columnspan=2, sticky="NWES")
self.AE = []
for i in range(Konfig.ANAMAXLAENGE):
eintrag = DoubleVar()
eintrag.set(0)
ttk.Label(master=unterrahmenAE, text="AE"+str(i), style="BlockLabel.TLabel").grid(column=1, row=i+1, sticky="NW")
ttk.Entry(master=unterrahmenAE, textvariable=eintrag, validate="focusout", validatecommand=validationAE).grid(column=2, row=i+1, sticky="NW")
self.AE.append(eintrag)
ttk.Label(master=unterrahmen3, text="Analoge\nAusgänge", style="BlockLabel2.TLabel").grid(column=3, row=3, columnspan=2, sticky="NW")
unterrahmenAA = ttk.Frame(master=unterrahmen3, padding="5", style="Unterblock.TFrame")
unterrahmenAA.grid(column=3, row=4, columnspan=2, sticky="NWES")
self.AA = []
for i in range(Konfig.ANAMAXLAENGE):
eintrag = DoubleVar()
eintrag.set(0)
ttk.Label(master=unterrahmenAA, text="AA"+str(i), style="BlockLabel.TLabel").grid(column=1, row=i+1, sticky="NW")
ttk.Entry(master=unterrahmenAA, textvariable=eintrag, state=DISABLED).grid(column=2, row=i+1, sticky="NW")
self.AA.append(eintrag)
# Globale Knöpfe einfügen
ttk.Button(master=hauptrahmen, text="Beenden", command=lambda: self.beenden()).grid(column=2, row=5, sticky="NE")
self.setzen_abstaende(hauptrahmen, unterrahmen1, unterrahmen2)
# Werte laden und Timer starten
self.aktualisieren_eingangswerte()
self.aktualisieren() | [
"def",
"__init__",
"(",
"self",
",",
"hauptfenster",
")",
":",
"self",
".",
"fenster",
"=",
"hauptfenster",
"self",
".",
"fenster",
".",
"iconbitmap",
"(",
"\"simstb.ico\"",
")",
"self",
".",
"fenster",
".",
"protocol",
"(",
"\"WM_DELETE_WINDOW\"",
",",
"lambda",
":",
"self",
".",
"beenden",
"(",
")",
")",
"self",
".",
"gen_gui",
"=",
"None",
"# Styles festlegen",
"self",
".",
"festlegen_Styles",
"(",
")",
"# Hauptrahmen anlegen",
"hauptrahmen",
"=",
"ttk",
".",
"Frame",
"(",
"master",
"=",
"self",
".",
"fenster",
",",
"padding",
"=",
"\"5\"",
",",
"style",
"=",
"\"Haupt.TFrame\"",
")",
"hauptrahmen",
".",
"grid",
"(",
"column",
"=",
"1",
",",
"row",
"=",
"1",
",",
"sticky",
"=",
"\"NWES\"",
")",
"self",
".",
"fenster",
".",
"columnconfigure",
"(",
"1",
",",
"weight",
"=",
"1",
")",
"self",
".",
"fenster",
".",
"rowconfigure",
"(",
"1",
",",
"weight",
"=",
"1",
")",
"# Titelbereich einfügen",
"ttk",
".",
"Label",
"(",
"master",
"=",
"hauptrahmen",
",",
"text",
"=",
"\"SimSTB\"",
",",
"style",
"=",
"\"HauptLabel1.TLabel\"",
")",
".",
"grid",
"(",
"column",
"=",
"1",
",",
"row",
"=",
"1",
",",
"sticky",
"=",
"\"NW\"",
")",
"ttk",
".",
"Label",
"(",
"master",
"=",
"hauptrahmen",
",",
"text",
"=",
"\"Simulationsumgebung für digitale\\nund analoge Ein- und Ausgänge\", ",
"s",
"yle=\"",
"H",
"auptLabel2.TLabel\").",
"g",
"r",
"id(c",
"o",
"lumn=2",
",",
" ",
"r",
"w=1",
",",
" ",
"c",
"lumnspan=2",
",",
" ",
"s",
"icky=\"",
"N",
"W\")",
"",
"self",
".",
"datum",
"=",
"StringVar",
"(",
")",
"ttk",
".",
"Label",
"(",
"master",
"=",
"hauptrahmen",
",",
"textvariable",
"=",
"self",
".",
"datum",
",",
"style",
"=",
"\"HauptLabel2.TLabel\"",
")",
".",
"grid",
"(",
"column",
"=",
"1",
",",
"row",
"=",
"2",
",",
"sticky",
"=",
"\"NW\"",
")",
"self",
".",
"zeit",
"=",
"StringVar",
"(",
")",
"ttk",
".",
"Label",
"(",
"master",
"=",
"hauptrahmen",
",",
"textvariable",
"=",
"self",
".",
"zeit",
",",
"style",
"=",
"\"HauptLabel2.TLabel\"",
")",
".",
"grid",
"(",
"column",
"=",
"2",
",",
"row",
"=",
"2",
",",
"sticky",
"=",
"\"NW\"",
")",
"# Unterrahmen 1 und Knöpfe",
"unterrahmen1",
"=",
"ttk",
".",
"Frame",
"(",
"master",
"=",
"hauptrahmen",
",",
"padding",
"=",
"\"5\"",
",",
"style",
"=",
"\"Block.TFrame\"",
")",
"unterrahmen1",
".",
"grid",
"(",
"column",
"=",
"1",
",",
"row",
"=",
"3",
",",
"sticky",
"=",
"\"NWES\"",
")",
"ttk",
".",
"Button",
"(",
"master",
"=",
"unterrahmen1",
",",
"text",
"=",
"\"Alles 0\"",
",",
"command",
"=",
"lambda",
":",
"self",
".",
"setzen0_alles",
"(",
")",
")",
".",
"grid",
"(",
"column",
"=",
"1",
",",
"row",
"=",
"1",
",",
"sticky",
"=",
"\"WE\"",
")",
"ttk",
".",
"Button",
"(",
"master",
"=",
"unterrahmen1",
",",
"text",
"=",
"\"Alle Ausgänge 0\",",
" ",
"ommand=",
"l",
"ambda:",
" ",
"elf.",
"s",
"etzen0_ausgaenge(",
")",
" ",
".",
"g",
"rid(",
"c",
"olumn=",
"1",
",",
" ",
"ow=",
"2",
",",
" ",
"ticky=",
"\"",
"WE\")",
"",
"ttk",
".",
"Button",
"(",
"master",
"=",
"unterrahmen1",
",",
"text",
"=",
"\"Alle Eingänge 0\",",
" ",
"ommand=",
"l",
"ambda:",
" ",
"elf.",
"s",
"etzen0_eingaenge(",
")",
" ",
".",
"g",
"rid(",
"c",
"olumn=",
"1",
",",
" ",
"ow=",
"3",
",",
" ",
"ticky=",
"\"",
"WE\")",
"",
"ttk",
".",
"Button",
"(",
"master",
"=",
"unterrahmen1",
",",
"text",
"=",
"\"Digitale Eingänge 0\",",
" ",
"ommand=",
"l",
"ambda:",
" ",
"elf.",
"s",
"etzen0_digitale_eingaenge(",
")",
" ",
".",
"g",
"rid(",
"c",
"olumn=",
"1",
",",
" ",
"ow=",
"4",
",",
" ",
"ticky=",
"\"",
"WE\")",
"",
"ttk",
".",
"Button",
"(",
"master",
"=",
"unterrahmen1",
",",
"text",
"=",
"\"Digitale Eingänge 1\",",
" ",
"ommand=",
"l",
"ambda:",
" ",
"elf.",
"s",
"etzen1_digitale_eingaenge(",
")",
" ",
".",
"g",
"rid(",
"c",
"olumn=",
"1",
",",
" ",
"ow=",
"5",
",",
" ",
"ticky=",
"\"",
"WE\")",
"",
"# Unterrahmen 2 und Knöpfe",
"unterrahmen2",
"=",
"ttk",
".",
"Frame",
"(",
"master",
"=",
"hauptrahmen",
",",
"padding",
"=",
"\"5\"",
",",
"style",
"=",
"\"Block.TFrame\"",
")",
"unterrahmen2",
".",
"grid",
"(",
"column",
"=",
"1",
",",
"row",
"=",
"4",
",",
"sticky",
"=",
"\"NWES\"",
")",
"ttk",
".",
"Button",
"(",
"master",
"=",
"unterrahmen2",
",",
"text",
"=",
"\"Modelle\"",
",",
"command",
"=",
"lambda",
":",
"self",
".",
"modelle",
"(",
")",
")",
".",
"grid",
"(",
"column",
"=",
"1",
",",
"row",
"=",
"1",
",",
"sticky",
"=",
"\"WE\"",
")",
"ttk",
".",
"Button",
"(",
"master",
"=",
"unterrahmen2",
",",
"text",
"=",
"\"Testautomaten\"",
",",
"command",
"=",
"lambda",
":",
"self",
".",
"testautomaten",
"(",
")",
")",
".",
"grid",
"(",
"column",
"=",
"1",
",",
"row",
"=",
"2",
",",
"sticky",
"=",
"\"WE\"",
")",
"ttk",
".",
"Button",
"(",
"master",
"=",
"unterrahmen2",
",",
"text",
"=",
"\"Funktionsgenerator\"",
",",
"command",
"=",
"lambda",
":",
"self",
".",
"funktionsgenerator",
"(",
")",
")",
".",
"grid",
"(",
"column",
"=",
"1",
",",
"row",
"=",
"3",
",",
"sticky",
"=",
"\"WE\"",
")",
"ttk",
".",
"Button",
"(",
"master",
"=",
"unterrahmen2",
",",
"text",
"=",
"\"Datenaufzeichnung\"",
",",
"command",
"=",
"lambda",
":",
"self",
".",
"datenaufzeichnen",
"(",
")",
")",
".",
"grid",
"(",
"column",
"=",
"1",
",",
"row",
"=",
"4",
",",
"sticky",
"=",
"\"NW\"",
")",
"# Unterrahmen 3 und Inhalt",
"unterrahmen3",
"=",
"ttk",
".",
"Frame",
"(",
"master",
"=",
"hauptrahmen",
",",
"padding",
"=",
"\"5\"",
",",
"style",
"=",
"\"Block.TFrame\"",
")",
"unterrahmen3",
".",
"grid",
"(",
"column",
"=",
"2",
",",
"row",
"=",
"3",
",",
"rowspan",
"=",
"2",
",",
"sticky",
"=",
"\"NWES\"",
")",
"ttk",
".",
"Label",
"(",
"master",
"=",
"unterrahmen3",
",",
"text",
"=",
"\"Digitale\\nEingänge\",",
" ",
"tyle=",
"\"",
"BlockLabel2.TLabel\")",
".",
"g",
"rid(",
"c",
"olumn=",
"1",
",",
" ",
"ow=",
"1",
",",
" ",
"olumnspan=",
"2",
",",
" ",
"ticky=",
"\"",
"NW\")",
"",
"unterrahmenDE",
"=",
"ttk",
".",
"Frame",
"(",
"master",
"=",
"unterrahmen3",
",",
"padding",
"=",
"\"5\"",
",",
"style",
"=",
"\"Unterblock.TFrame\"",
")",
"unterrahmenDE",
".",
"grid",
"(",
"column",
"=",
"1",
",",
"row",
"=",
"2",
",",
"columnspan",
"=",
"2",
",",
"sticky",
"=",
"\"NWES\"",
")",
"self",
".",
"DE",
"=",
"[",
"]",
"for",
"i",
"in",
"range",
"(",
"Konfig",
".",
"DIGMAXLAENGE",
")",
":",
"eintrag",
"=",
"IntVar",
"(",
")",
"eintrag",
".",
"set",
"(",
"0",
")",
"ttk",
".",
"Checkbutton",
"(",
"master",
"=",
"unterrahmenDE",
",",
"text",
"=",
"\"DE\"",
"+",
"str",
"(",
"i",
")",
",",
"command",
"=",
"lambda",
":",
"self",
".",
"setzen_digitale_eingaenge",
"(",
")",
",",
"variable",
"=",
"eintrag",
",",
"style",
"=",
"\"BlockCheckbutton.TCheckbutton\"",
")",
".",
"grid",
"(",
"column",
"=",
"1",
",",
"row",
"=",
"i",
"+",
"1",
",",
"sticky",
"=",
"\"NW\"",
")",
"self",
".",
"DE",
".",
"append",
"(",
"eintrag",
")",
"ttk",
".",
"Label",
"(",
"master",
"=",
"unterrahmen3",
",",
"text",
"=",
"\"Digitale\\nAusgänge\",",
" ",
"tyle=",
"\"",
"BlockLabel2.TLabel\")",
".",
"g",
"rid(",
"c",
"olumn=",
"3",
",",
" ",
"ow=",
"1",
",",
" ",
"olumnspan=",
"2",
",",
" ",
"ticky=",
"\"",
"NW\")",
"",
"unterrahmenDA",
"=",
"ttk",
".",
"Frame",
"(",
"master",
"=",
"unterrahmen3",
",",
"padding",
"=",
"\"5\"",
",",
"style",
"=",
"\"Unterblock.TFrame\"",
")",
"unterrahmenDA",
".",
"grid",
"(",
"column",
"=",
"3",
",",
"row",
"=",
"2",
",",
"columnspan",
"=",
"2",
",",
"sticky",
"=",
"\"NWES\"",
")",
"self",
".",
"DA",
"=",
"[",
"]",
"for",
"i",
"in",
"range",
"(",
"Konfig",
".",
"DIGMAXLAENGE",
")",
":",
"eintrag",
"=",
"IntVar",
"(",
")",
"eintrag",
".",
"set",
"(",
"0",
")",
"ttk",
".",
"Checkbutton",
"(",
"master",
"=",
"unterrahmenDA",
",",
"text",
"=",
"\"DA\"",
"+",
"str",
"(",
"i",
")",
",",
"variable",
"=",
"eintrag",
",",
"style",
"=",
"\"BlockCheckbutton.TCheckbutton\"",
",",
"state",
"=",
"DISABLED",
")",
".",
"grid",
"(",
"column",
"=",
"1",
",",
"row",
"=",
"i",
"+",
"1",
",",
"sticky",
"=",
"\"NW\"",
")",
"self",
".",
"DA",
".",
"append",
"(",
"eintrag",
")",
"ttk",
".",
"Label",
"(",
"master",
"=",
"unterrahmen3",
",",
"text",
"=",
"\"Analoge\\nEingänge\",",
" ",
"tyle=",
"\"",
"BlockLabel2.TLabel\")",
".",
"g",
"rid(",
"c",
"olumn=",
"1",
",",
" ",
"ow=",
"3",
",",
" ",
"olumnspan=",
"2",
",",
" ",
"ticky=",
"\"",
"NW\")",
"",
"validationAE",
"=",
"(",
"self",
".",
"fenster",
".",
"register",
"(",
"self",
".",
"setzen_analoge_eingaenge_1",
")",
",",
"\"%P\"",
")",
"unterrahmenAE",
"=",
"ttk",
".",
"Frame",
"(",
"master",
"=",
"unterrahmen3",
",",
"padding",
"=",
"\"5\"",
",",
"style",
"=",
"\"Unterblock.TFrame\"",
")",
"unterrahmenAE",
".",
"grid",
"(",
"column",
"=",
"1",
",",
"row",
"=",
"4",
",",
"columnspan",
"=",
"2",
",",
"sticky",
"=",
"\"NWES\"",
")",
"self",
".",
"AE",
"=",
"[",
"]",
"for",
"i",
"in",
"range",
"(",
"Konfig",
".",
"ANAMAXLAENGE",
")",
":",
"eintrag",
"=",
"DoubleVar",
"(",
")",
"eintrag",
".",
"set",
"(",
"0",
")",
"ttk",
".",
"Label",
"(",
"master",
"=",
"unterrahmenAE",
",",
"text",
"=",
"\"AE\"",
"+",
"str",
"(",
"i",
")",
",",
"style",
"=",
"\"BlockLabel.TLabel\"",
")",
".",
"grid",
"(",
"column",
"=",
"1",
",",
"row",
"=",
"i",
"+",
"1",
",",
"sticky",
"=",
"\"NW\"",
")",
"ttk",
".",
"Entry",
"(",
"master",
"=",
"unterrahmenAE",
",",
"textvariable",
"=",
"eintrag",
",",
"validate",
"=",
"\"focusout\"",
",",
"validatecommand",
"=",
"validationAE",
")",
".",
"grid",
"(",
"column",
"=",
"2",
",",
"row",
"=",
"i",
"+",
"1",
",",
"sticky",
"=",
"\"NW\"",
")",
"self",
".",
"AE",
".",
"append",
"(",
"eintrag",
")",
"ttk",
".",
"Label",
"(",
"master",
"=",
"unterrahmen3",
",",
"text",
"=",
"\"Analoge\\nAusgänge\",",
" ",
"tyle=",
"\"",
"BlockLabel2.TLabel\")",
".",
"g",
"rid(",
"c",
"olumn=",
"3",
",",
" ",
"ow=",
"3",
",",
" ",
"olumnspan=",
"2",
",",
" ",
"ticky=",
"\"",
"NW\")",
"",
"unterrahmenAA",
"=",
"ttk",
".",
"Frame",
"(",
"master",
"=",
"unterrahmen3",
",",
"padding",
"=",
"\"5\"",
",",
"style",
"=",
"\"Unterblock.TFrame\"",
")",
"unterrahmenAA",
".",
"grid",
"(",
"column",
"=",
"3",
",",
"row",
"=",
"4",
",",
"columnspan",
"=",
"2",
",",
"sticky",
"=",
"\"NWES\"",
")",
"self",
".",
"AA",
"=",
"[",
"]",
"for",
"i",
"in",
"range",
"(",
"Konfig",
".",
"ANAMAXLAENGE",
")",
":",
"eintrag",
"=",
"DoubleVar",
"(",
")",
"eintrag",
".",
"set",
"(",
"0",
")",
"ttk",
".",
"Label",
"(",
"master",
"=",
"unterrahmenAA",
",",
"text",
"=",
"\"AA\"",
"+",
"str",
"(",
"i",
")",
",",
"style",
"=",
"\"BlockLabel.TLabel\"",
")",
".",
"grid",
"(",
"column",
"=",
"1",
",",
"row",
"=",
"i",
"+",
"1",
",",
"sticky",
"=",
"\"NW\"",
")",
"ttk",
".",
"Entry",
"(",
"master",
"=",
"unterrahmenAA",
",",
"textvariable",
"=",
"eintrag",
",",
"state",
"=",
"DISABLED",
")",
".",
"grid",
"(",
"column",
"=",
"2",
",",
"row",
"=",
"i",
"+",
"1",
",",
"sticky",
"=",
"\"NW\"",
")",
"self",
".",
"AA",
".",
"append",
"(",
"eintrag",
")",
"# Globale Knöpfe einfügen",
"ttk",
".",
"Button",
"(",
"master",
"=",
"hauptrahmen",
",",
"text",
"=",
"\"Beenden\"",
",",
"command",
"=",
"lambda",
":",
"self",
".",
"beenden",
"(",
")",
")",
".",
"grid",
"(",
"column",
"=",
"2",
",",
"row",
"=",
"5",
",",
"sticky",
"=",
"\"NE\"",
")",
"self",
".",
"setzen_abstaende",
"(",
"hauptrahmen",
",",
"unterrahmen1",
",",
"unterrahmen2",
")",
"# Werte laden und Timer starten",
"self",
".",
"aktualisieren_eingangswerte",
"(",
")",
"self",
".",
"aktualisieren",
"(",
")"
] | [
30,
4
] | [
122,
28
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
|
checkVMAT.doMT_VMAT_2 | ( self, fileData ) | return self.doMT_VMAT( fileData ) | DRGS - Variationen von DoseRate und Gantry Speed
| DRGS - Variationen von DoseRate und Gantry Speed
| def doMT_VMAT_2( self, fileData ):
"""DRGS - Variationen von DoseRate und Gantry Speed
"""
# metadata vorbereiten
# Beschriftung für die Bild Achsen
step = { "-100":"-100", "-50":"-50", "0":"0", "50":"50", "100":"100" }
self.metadata.update( {
"vmat_type": "DRGS",
"segments": {
"1" : { "DoseRate": 111, "GantrySpeed": 6},
"2" : { "DoseRate": 222, "GantrySpeed": 6},
"3" : { "DoseRate": 332, "GantrySpeed": 6},
"4" : { "DoseRate": 443, "GantrySpeed": 6},
"5" : { "DoseRate": 554, "GantrySpeed": 6},
"6" : { "DoseRate": 600, "GantrySpeed": 5},
"7" : { "DoseRate": 600, "GantrySpeed": 4.3}
},
"_imgField": { "X1":-100, "X2":100, "Y1": -110, "Y2": 110, "xStep":step , "yStep":step },
"table_fields" : [
{'field': 'segment', 'label':'Segment', 'format':'{0}' },
{'field': 'DoseRate', 'label':'DoseRate', 'format':'{0:d}'},
{'field': 'GantrySpeed', 'label':'GantrySpeed [°/s]', 'format':'{0:1.1f}'},
{'field': 'center', 'label':'Segment Zentrum', 'format':'{0:1.1f}' },
{'field': 'r_corr', 'label':'M<sub>corr</sub>', 'format':'{0:2.3f}' },
{'field': 'r_dev', 'label':'M<sub>dev</sub> [%]', 'format':'{0:2.3f}' },
{'field': 'r_dev_passed', 'label':'Passed' }
]
} )
return self.doMT_VMAT( fileData ) | [
"def",
"doMT_VMAT_2",
"(",
"self",
",",
"fileData",
")",
":",
"# metadata vorbereiten",
"# Beschriftung für die Bild Achsen",
"step",
"=",
"{",
"\"-100\"",
":",
"\"-100\"",
",",
"\"-50\"",
":",
"\"-50\"",
",",
"\"0\"",
":",
"\"0\"",
",",
"\"50\"",
":",
"\"50\"",
",",
"\"100\"",
":",
"\"100\"",
"}",
"self",
".",
"metadata",
".",
"update",
"(",
"{",
"\"vmat_type\"",
":",
"\"DRGS\"",
",",
"\"segments\"",
":",
"{",
"\"1\"",
":",
"{",
"\"DoseRate\"",
":",
"111",
",",
"\"GantrySpeed\"",
":",
"6",
"}",
",",
"\"2\"",
":",
"{",
"\"DoseRate\"",
":",
"222",
",",
"\"GantrySpeed\"",
":",
"6",
"}",
",",
"\"3\"",
":",
"{",
"\"DoseRate\"",
":",
"332",
",",
"\"GantrySpeed\"",
":",
"6",
"}",
",",
"\"4\"",
":",
"{",
"\"DoseRate\"",
":",
"443",
",",
"\"GantrySpeed\"",
":",
"6",
"}",
",",
"\"5\"",
":",
"{",
"\"DoseRate\"",
":",
"554",
",",
"\"GantrySpeed\"",
":",
"6",
"}",
",",
"\"6\"",
":",
"{",
"\"DoseRate\"",
":",
"600",
",",
"\"GantrySpeed\"",
":",
"5",
"}",
",",
"\"7\"",
":",
"{",
"\"DoseRate\"",
":",
"600",
",",
"\"GantrySpeed\"",
":",
"4.3",
"}",
"}",
",",
"\"_imgField\"",
":",
"{",
"\"X1\"",
":",
"-",
"100",
",",
"\"X2\"",
":",
"100",
",",
"\"Y1\"",
":",
"-",
"110",
",",
"\"Y2\"",
":",
"110",
",",
"\"xStep\"",
":",
"step",
",",
"\"yStep\"",
":",
"step",
"}",
",",
"\"table_fields\"",
":",
"[",
"{",
"'field'",
":",
"'segment'",
",",
"'label'",
":",
"'Segment'",
",",
"'format'",
":",
"'{0}'",
"}",
",",
"{",
"'field'",
":",
"'DoseRate'",
",",
"'label'",
":",
"'DoseRate'",
",",
"'format'",
":",
"'{0:d}'",
"}",
",",
"{",
"'field'",
":",
"'GantrySpeed'",
",",
"'label'",
":",
"'GantrySpeed [°/s]',",
" ",
"format':",
"'",
"{0:1.1f}'}",
",",
"",
"{",
"'field'",
":",
"'center'",
",",
"'label'",
":",
"'Segment Zentrum'",
",",
"'format'",
":",
"'{0:1.1f}'",
"}",
",",
"{",
"'field'",
":",
"'r_corr'",
",",
"'label'",
":",
"'M<sub>corr</sub>'",
",",
"'format'",
":",
"'{0:2.3f}'",
"}",
",",
"{",
"'field'",
":",
"'r_dev'",
",",
"'label'",
":",
"'M<sub>dev</sub> [%]'",
",",
"'format'",
":",
"'{0:2.3f}'",
"}",
",",
"{",
"'field'",
":",
"'r_dev_passed'",
",",
"'label'",
":",
"'Passed'",
"}",
"]",
"}",
")",
"return",
"self",
".",
"doMT_VMAT",
"(",
"fileData",
")"
] | [
434,
4
] | [
463,
41
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
HeistSystem.__init__ | (self, parent, settings, path, dbpath, logger, rawdatahandler) | return | Initialisierung der Klasse | Initialisierung der Klasse | def __init__(self, parent, settings, path, dbpath, logger, rawdatahandler):
''' Initialisierung der Klasse '''
thisActionName = "__init__"
# Klassen Variablen
self.ClassName = "Spiel 'Heist'"
self.Version = "1.0.0"
self.ScriptName = str(self.ClassName)
self.Parent = parent
self.Settings = settings
self.Path = path
self.dbPath = dbpath
self.Logger = logger
self.RawDataHandler = rawdatahandler
# Daten des Spiel zwischenspeichern
self.GameStartTimestamp = ""
self.LastGameFinishTimestamp = ""
self.GameID = 0
self.GameTargetName = ""
# Nachrichten Typen
self.MessageType_IsOnCooldown = "IsOnCoolDown"
self.MessageType_NewGameStart = "NewGameStart"
self.MessageType_GameStartIntro = "GameStartIntro"
self.MessageType_GameCooldownOver = "GameCooldownOver"
self.MessageType_NewPlayer = "NewPlayer"
self.MessageType_NotEnoughPlayer = "NotEnoughPlayer"
self.MessageType_NotEnoughPoints = "NotEnoughPoints"
self.MessageType_StakeBelowMinimum = "StakeBelowMinimum"
self.MessageType_StakeOverMaximum = "StakeOverMaximum"
self.MessageType_WrongCommandOption = "WrongCommandOption"
self.MessageType_Outcome_100Percent = "Outcome_100Percent"
self.MessageType_Outcome_75_99Percent = "Outcome_75_99Percent"
self.MessageType_Outcome_25_74Percent = "Outcome_25_74Percent"
self.MessageType_Outcome_01_24Percent = "Outcome_01_24Percent"
self.MessageType_Outcome_00Percent = "Outcome_00Percent"
# Verbindung zur MultiRaffle-Datenbank aufbauen
self.GameDBFile = os.path.join(self.dbPath, "Games.db")
self.GameDB = DBConnector(str(self.GameDBFile))
# Cooldown-Helper initialisieren
self.CD = BotHelper.CoolDownHelper(
parent=self.Parent,
logger=self.Logger
)
# Tabellen erzeugen
self.DB_create_Tables()
# Wenn ".init"-Datei nicht vorhanden,
if not (os.path.isfile(os.path.join(self.Path, ".init"))):
# Default Nachrichten erzeugen
self.DB_create_DefaultMessages()
self.DB_create_DefaultTargets()
# ".init"-Datei erzeugen
init = open(os.path.join(self.Path, ".init"), 'w+')
init.close()
# Meldung bezueglich der Initialisierung der Klasse ins Log schreiben
self.Logger.WriteLog(str(" - '{0}'").format(self.ScriptName))
return | [
"def",
"__init__",
"(",
"self",
",",
"parent",
",",
"settings",
",",
"path",
",",
"dbpath",
",",
"logger",
",",
"rawdatahandler",
")",
":",
"thisActionName",
"=",
"\"__init__\"",
"# Klassen Variablen\r",
"self",
".",
"ClassName",
"=",
"\"Spiel 'Heist'\"",
"self",
".",
"Version",
"=",
"\"1.0.0\"",
"self",
".",
"ScriptName",
"=",
"str",
"(",
"self",
".",
"ClassName",
")",
"self",
".",
"Parent",
"=",
"parent",
"self",
".",
"Settings",
"=",
"settings",
"self",
".",
"Path",
"=",
"path",
"self",
".",
"dbPath",
"=",
"dbpath",
"self",
".",
"Logger",
"=",
"logger",
"self",
".",
"RawDataHandler",
"=",
"rawdatahandler",
"# Daten des Spiel zwischenspeichern\r",
"self",
".",
"GameStartTimestamp",
"=",
"\"\"",
"self",
".",
"LastGameFinishTimestamp",
"=",
"\"\"",
"self",
".",
"GameID",
"=",
"0",
"self",
".",
"GameTargetName",
"=",
"\"\"",
"# Nachrichten Typen\r",
"self",
".",
"MessageType_IsOnCooldown",
"=",
"\"IsOnCoolDown\"",
"self",
".",
"MessageType_NewGameStart",
"=",
"\"NewGameStart\"",
"self",
".",
"MessageType_GameStartIntro",
"=",
"\"GameStartIntro\"",
"self",
".",
"MessageType_GameCooldownOver",
"=",
"\"GameCooldownOver\"",
"self",
".",
"MessageType_NewPlayer",
"=",
"\"NewPlayer\"",
"self",
".",
"MessageType_NotEnoughPlayer",
"=",
"\"NotEnoughPlayer\"",
"self",
".",
"MessageType_NotEnoughPoints",
"=",
"\"NotEnoughPoints\"",
"self",
".",
"MessageType_StakeBelowMinimum",
"=",
"\"StakeBelowMinimum\"",
"self",
".",
"MessageType_StakeOverMaximum",
"=",
"\"StakeOverMaximum\"",
"self",
".",
"MessageType_WrongCommandOption",
"=",
"\"WrongCommandOption\"",
"self",
".",
"MessageType_Outcome_100Percent",
"=",
"\"Outcome_100Percent\"",
"self",
".",
"MessageType_Outcome_75_99Percent",
"=",
"\"Outcome_75_99Percent\"",
"self",
".",
"MessageType_Outcome_25_74Percent",
"=",
"\"Outcome_25_74Percent\"",
"self",
".",
"MessageType_Outcome_01_24Percent",
"=",
"\"Outcome_01_24Percent\"",
"self",
".",
"MessageType_Outcome_00Percent",
"=",
"\"Outcome_00Percent\"",
"# Verbindung zur MultiRaffle-Datenbank aufbauen\r",
"self",
".",
"GameDBFile",
"=",
"os",
".",
"path",
".",
"join",
"(",
"self",
".",
"dbPath",
",",
"\"Games.db\"",
")",
"self",
".",
"GameDB",
"=",
"DBConnector",
"(",
"str",
"(",
"self",
".",
"GameDBFile",
")",
")",
"# Cooldown-Helper initialisieren\r",
"self",
".",
"CD",
"=",
"BotHelper",
".",
"CoolDownHelper",
"(",
"parent",
"=",
"self",
".",
"Parent",
",",
"logger",
"=",
"self",
".",
"Logger",
")",
"# Tabellen erzeugen\r",
"self",
".",
"DB_create_Tables",
"(",
")",
"# Wenn \".init\"-Datei nicht vorhanden,\r",
"if",
"not",
"(",
"os",
".",
"path",
".",
"isfile",
"(",
"os",
".",
"path",
".",
"join",
"(",
"self",
".",
"Path",
",",
"\".init\"",
")",
")",
")",
":",
"# Default Nachrichten erzeugen\r",
"self",
".",
"DB_create_DefaultMessages",
"(",
")",
"self",
".",
"DB_create_DefaultTargets",
"(",
")",
"# \".init\"-Datei erzeugen\r",
"init",
"=",
"open",
"(",
"os",
".",
"path",
".",
"join",
"(",
"self",
".",
"Path",
",",
"\".init\"",
")",
",",
"'w+'",
")",
"init",
".",
"close",
"(",
")",
"# Meldung bezueglich der Initialisierung der Klasse ins Log schreiben\r",
"self",
".",
"Logger",
".",
"WriteLog",
"(",
"str",
"(",
"\" - '{0}'\"",
")",
".",
"format",
"(",
"self",
".",
"ScriptName",
")",
")",
"return"
] | [
32,
4
] | [
98,
14
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
ispSAFRS._int_get_empty_record | ( cls, defaults:dict={} ) | return empty_record | Holt einen leeren Datensatz, ggf mit default Werten belegt.
Eine safrs Klasse hat immer eine id, entweder als Datenbankfeld ober autom. generiert
Parameters
----------
defaults: dict
Defaultwerte für die angegebenen Felder
Result
------
empty_record : dict
* attributes : {},
* id : undefined,
* type : ""
Alle Spalten von table mit null oder defaults vorbelegt
| Holt einen leeren Datensatz, ggf mit default Werten belegt. | def _int_get_empty_record( cls, defaults:dict={} ):
"""Holt einen leeren Datensatz, ggf mit default Werten belegt.
Eine safrs Klasse hat immer eine id, entweder als Datenbankfeld ober autom. generiert
Parameters
----------
defaults: dict
Defaultwerte für die angegebenen Felder
Result
------
empty_record : dict
* attributes : {},
* id : undefined,
* type : ""
Alle Spalten von table mit null oder defaults vorbelegt
"""
empty_record = {
"attributes" : {},
"id" : "undefined",
"type" : cls.__name__
}
# alle durchgehen
for name in cls._s_column_names:
column = getattr(cls, name, None )
if column:
key = column.key
# nur in attributes ablegen id ist mit undefined vorbelegt
if not key == "id":
if key in defaults:
empty_record["attributes"][ name ] = defaults[ key ]
else:
empty_record["attributes"][ name ] = None # c.server_default
else:
empty_record["attributes"][ name ] = None
return empty_record | [
"def",
"_int_get_empty_record",
"(",
"cls",
",",
"defaults",
":",
"dict",
"=",
"{",
"}",
")",
":",
"empty_record",
"=",
"{",
"\"attributes\"",
":",
"{",
"}",
",",
"\"id\"",
":",
"\"undefined\"",
",",
"\"type\"",
":",
"cls",
".",
"__name__",
"}",
"# alle durchgehen",
"for",
"name",
"in",
"cls",
".",
"_s_column_names",
":",
"column",
"=",
"getattr",
"(",
"cls",
",",
"name",
",",
"None",
")",
"if",
"column",
":",
"key",
"=",
"column",
".",
"key",
"# nur in attributes ablegen id ist mit undefined vorbelegt",
"if",
"not",
"key",
"==",
"\"id\"",
":",
"if",
"key",
"in",
"defaults",
":",
"empty_record",
"[",
"\"attributes\"",
"]",
"[",
"name",
"]",
"=",
"defaults",
"[",
"key",
"]",
"else",
":",
"empty_record",
"[",
"\"attributes\"",
"]",
"[",
"name",
"]",
"=",
"None",
"# c.server_default",
"else",
":",
"empty_record",
"[",
"\"attributes\"",
"]",
"[",
"name",
"]",
"=",
"None",
"return",
"empty_record"
] | [
1275,
4
] | [
1315,
27
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
Jahr.zeitrechnung | (self, z: Zeitrechnung) | Die Zeitrechnung setzen | Die Zeitrechnung setzen | def zeitrechnung(self, z: Zeitrechnung):
"""Die Zeitrechnung setzen"""
if type(z) != Zeitrechnung:
raise TypeError("Keine Zeitrechnung angegeben")
self.jahr = self.zeitrechnung.convert(self.jahr, z)
self.__zeitrechnung = z
pass | [
"def",
"zeitrechnung",
"(",
"self",
",",
"z",
":",
"Zeitrechnung",
")",
":",
"if",
"type",
"(",
"z",
")",
"!=",
"Zeitrechnung",
":",
"raise",
"TypeError",
"(",
"\"Keine Zeitrechnung angegeben\"",
")",
"self",
".",
"jahr",
"=",
"self",
".",
"zeitrechnung",
".",
"convert",
"(",
"self",
".",
"jahr",
",",
"z",
")",
"self",
".",
"__zeitrechnung",
"=",
"z",
"pass"
] | [
36,
4
] | [
42,
12
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
|
PdfGenerator._text | ( self, text="", area:dict={}, attrs:dict={}, render=None, replaceNewLine=False ) | return element_html | r"""Einen Textabsatz einfügen.
Dabei je nach replaceNewLine ``\n`` bzw. ``\n\n`` durch ``<br>`` ersetzen
Parameters
----------
text : str
Der einzufügende Text
area : Area {left,top,with,height}
die Größe der Ausgabe
attrs : dict
zu ändernde id class oder Style Angaben
render : bool
sofort rendern oder nur zurückgeben ohne Angabe wird self.autoRender verwendet
replaceNewLine : bool - false
nur doppelte ``\n\n`` durch ``<br>`` ersetzten oder alle newLine ``\n`` ersetzen
Returns
-------
element_html: str
HTML des erzeugten Elements
| r"""Einen Textabsatz einfügen. | def _text( self, text="", area:dict={}, attrs:dict={}, render=None, replaceNewLine=False ):
r"""Einen Textabsatz einfügen.
Dabei je nach replaceNewLine ``\n`` bzw. ``\n\n`` durch ``<br>`` ersetzen
Parameters
----------
text : str
Der einzufügende Text
area : Area {left,top,with,height}
die Größe der Ausgabe
attrs : dict
zu ändernde id class oder Style Angaben
render : bool
sofort rendern oder nur zurückgeben ohne Angabe wird self.autoRender verwendet
replaceNewLine : bool - false
nur doppelte ``\n\n`` durch ``<br>`` ersetzten oder alle newLine ``\n`` ersetzen
Returns
-------
element_html: str
HTML des erzeugten Elements
"""
if render == None:
render = self.autoRender
if not text:
text = ''
if not isinstance(text, str):
text = str(text)
text = text.strip(string.whitespace)
if replaceNewLine:
text = text.replace('\n', "<br/>")
else:
text = text.replace('\n\n', "<br/>")
# Eigenschaften des Elements
if not "font-size" in attrs:
attrs["font-size"] = "8pt"
_id, _class, _style = self._get_attrs( attrs )
_area = self._get_area_style( area )
element_html = '\n\t<div class="text {_class}" style="{_style} {_area}" >{content}</div>'.format(
_class = _class,
_style = _style, _area=_area,
content=text
)
if render:
self._html( element_html )
return element_html | [
"def",
"_text",
"(",
"self",
",",
"text",
"=",
"\"\"",
",",
"area",
":",
"dict",
"=",
"{",
"}",
",",
"attrs",
":",
"dict",
"=",
"{",
"}",
",",
"render",
"=",
"None",
",",
"replaceNewLine",
"=",
"False",
")",
":",
"if",
"render",
"==",
"None",
":",
"render",
"=",
"self",
".",
"autoRender",
"if",
"not",
"text",
":",
"text",
"=",
"''",
"if",
"not",
"isinstance",
"(",
"text",
",",
"str",
")",
":",
"text",
"=",
"str",
"(",
"text",
")",
"text",
"=",
"text",
".",
"strip",
"(",
"string",
".",
"whitespace",
")",
"if",
"replaceNewLine",
":",
"text",
"=",
"text",
".",
"replace",
"(",
"'\\n'",
",",
"\"<br/>\"",
")",
"else",
":",
"text",
"=",
"text",
".",
"replace",
"(",
"'\\n\\n'",
",",
"\"<br/>\"",
")",
"# Eigenschaften des Elements",
"if",
"not",
"\"font-size\"",
"in",
"attrs",
":",
"attrs",
"[",
"\"font-size\"",
"]",
"=",
"\"8pt\"",
"_id",
",",
"_class",
",",
"_style",
"=",
"self",
".",
"_get_attrs",
"(",
"attrs",
")",
"_area",
"=",
"self",
".",
"_get_area_style",
"(",
"area",
")",
"element_html",
"=",
"'\\n\\t<div class=\"text {_class}\" style=\"{_style} {_area}\" >{content}</div>'",
".",
"format",
"(",
"_class",
"=",
"_class",
",",
"_style",
"=",
"_style",
",",
"_area",
"=",
"_area",
",",
"content",
"=",
"text",
")",
"if",
"render",
":",
"self",
".",
"_html",
"(",
"element_html",
")",
"return",
"element_html"
] | [
862,
4
] | [
912,
27
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
CheckUserPermission | ( parent, user ) | Liefere Informationen zu der User Berechtigung | Liefere Informationen zu der User Berechtigung | def CheckUserPermission( parent, user ):
''' Liefere Informationen zu der User Berechtigung '''
thisActionName = "CheckUserPermission"
if parent.HasPermission( user, "Caster", ""):
return "64"
if parent.HasPermission( user, "Editor", ""):
return "32"
if parent.HasPermission( user, "Moderator", ""):
return "16"
if parent.HasPermission( user, "VIP", ""):
return "8"
if parent.HasPermission( user, "Subscriber", ""):
return "4"
if parent.HasPermission( user, "Regular", ""):
return "2"
else:
return "1" | [
"def",
"CheckUserPermission",
"(",
"parent",
",",
"user",
")",
":",
"thisActionName",
"=",
"\"CheckUserPermission\"",
"if",
"parent",
".",
"HasPermission",
"(",
"user",
",",
"\"Caster\"",
",",
"\"\"",
")",
":",
"return",
"\"64\"",
"if",
"parent",
".",
"HasPermission",
"(",
"user",
",",
"\"Editor\"",
",",
"\"\"",
")",
":",
"return",
"\"32\"",
"if",
"parent",
".",
"HasPermission",
"(",
"user",
",",
"\"Moderator\"",
",",
"\"\"",
")",
":",
"return",
"\"16\"",
"if",
"parent",
".",
"HasPermission",
"(",
"user",
",",
"\"VIP\"",
",",
"\"\"",
")",
":",
"return",
"\"8\"",
"if",
"parent",
".",
"HasPermission",
"(",
"user",
",",
"\"Subscriber\"",
",",
"\"\"",
")",
":",
"return",
"\"4\"",
"if",
"parent",
".",
"HasPermission",
"(",
"user",
",",
"\"Regular\"",
",",
"\"\"",
")",
":",
"return",
"\"2\"",
"else",
":",
"return",
"\"1\""
] | [
196,
0
] | [
219,
18
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.