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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
ChatbotMessages.WriteChatMessage_UserCooldownDuration | ( self, scriptname, user, command, commandName = False ) | return | Schreibe eine Nachricht bezüglich des Cooldowns in den Chat | Schreibe eine Nachricht bezüglich des Cooldowns in den Chat | def WriteChatMessage_UserCooldownDuration( self, scriptname, user, command, commandName = False ):
''' Schreibe eine Nachricht bezüglich des Cooldowns in den Chat '''
thisActionName = "WriteChatMessage_UserCooldownDuration"
if commandName:
self.CommandName = commandName
else:
self.CommandName = command
self.ScriptName = scriptname
UserDisplayName = self.Parent.GetDisplayName( user )
CoolDownDuration = str( TimePrettyFormatString( self.CoolDown.GetUserCooldownDuration( self.ScriptName, command, user ) ) )
self.Parent.SendStreamMessage( "/me : 💤 {0}, du musst noch {1} warten bis du das Kommando '{2}' erneut aufrufen kannst. 💤".format( UserDisplayName, CoolDownDuration, self.CommandName ) )
return | [
"def",
"WriteChatMessage_UserCooldownDuration",
"(",
"self",
",",
"scriptname",
",",
"user",
",",
"command",
",",
"commandName",
"=",
"False",
")",
":",
"thisActionName",
"=",
"\"WriteChatMessage_UserCooldownDuration\"",
"if",
"commandName",
":",
"self",
".",
"CommandName",
"=",
"commandName",
"else",
":",
"self",
".",
"CommandName",
"=",
"command",
"self",
".",
"ScriptName",
"=",
"scriptname",
"UserDisplayName",
"=",
"self",
".",
"Parent",
".",
"GetDisplayName",
"(",
"user",
")",
"CoolDownDuration",
"=",
"str",
"(",
"TimePrettyFormatString",
"(",
"self",
".",
"CoolDown",
".",
"GetUserCooldownDuration",
"(",
"self",
".",
"ScriptName",
",",
"command",
",",
"user",
")",
")",
")",
"self",
".",
"Parent",
".",
"SendStreamMessage",
"(",
"\"/me : 💤 {0}, du musst noch {1} warten bis du das Kommando '{2}' erneut aufrufen kannst. 💤\".forma",
"t",
"( User",
"D",
"splayName, Cool",
"D",
"wnDuration, self",
".",
"omma",
"n",
"dName ) )\r",
"",
"",
"return"
] | [
119,
4
] | [
133,
14
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
ispResults.__init__ | ( self, config:None, filename=None ) | in gqa ein pandas object bereitstellen
zum laden und speichern den über die Dateiendung bestimmten wrapper verwenden
Parameters
----------
config: ispConfig object
Die eingelesene Konfiguration
filename: str, optional
Der zu verwendene Dateiname ohne Angabe aus config bestimmen
| in gqa ein pandas object bereitstellen
zum laden und speichern den über die Dateiendung bestimmten wrapper verwenden | def __init__( self, config:None, filename=None ):
""" in gqa ein pandas object bereitstellen
zum laden und speichern den über die Dateiendung bestimmten wrapper verwenden
Parameters
----------
config: ispConfig object
Die eingelesene Konfiguration
filename: str, optional
Der zu verwendene Dateiname ohne Angabe aus config bestimmen
"""
self.gqa = None
self.config = config
if filename:
self.filename = filename
else:
self.filename = osp.join( config.get("resultsPath", ".."), config.get("database.gqa.name", "gqa.json") )
# spalten und index bereitstellen(type nur für sql)
self.columns = {
"unit" : "string",
"energy" : "string",
"test" : "string",
"date" : "string",
"group": "int32",
"year" : "int32",
"month" : "int32",
"acceptance" : "int32",
"data" : "string"
}
# date und group auch als index damit mehrere pro jahr/monat möglich sind
# Der Index ist notwendig damit ein update/insert funktioniert
self.index = [ 'unit', 'energy', 'test', 'date', 'group' ]
# pandas dataframe vorbereiten
self.gqa = pd.DataFrame( {}, columns=self.columns.keys() )
self.gqa.set_index( self.index, inplace=True)
# datei noch nicht vorhanden - anlegen
if not osp.isfile( self.filename ):
self.write()
self.isOnline = self.read() | [
"def",
"__init__",
"(",
"self",
",",
"config",
":",
"None",
",",
"filename",
"=",
"None",
")",
":",
"self",
".",
"gqa",
"=",
"None",
"self",
".",
"config",
"=",
"config",
"if",
"filename",
":",
"self",
".",
"filename",
"=",
"filename",
"else",
":",
"self",
".",
"filename",
"=",
"osp",
".",
"join",
"(",
"config",
".",
"get",
"(",
"\"resultsPath\"",
",",
"\"..\"",
")",
",",
"config",
".",
"get",
"(",
"\"database.gqa.name\"",
",",
"\"gqa.json\"",
")",
")",
"# spalten und index bereitstellen(type nur für sql)",
"self",
".",
"columns",
"=",
"{",
"\"unit\"",
":",
"\"string\"",
",",
"\"energy\"",
":",
"\"string\"",
",",
"\"test\"",
":",
"\"string\"",
",",
"\"date\"",
":",
"\"string\"",
",",
"\"group\"",
":",
"\"int32\"",
",",
"\"year\"",
":",
"\"int32\"",
",",
"\"month\"",
":",
"\"int32\"",
",",
"\"acceptance\"",
":",
"\"int32\"",
",",
"\"data\"",
":",
"\"string\"",
"}",
"# date und group auch als index damit mehrere pro jahr/monat möglich sind",
"# Der Index ist notwendig damit ein update/insert funktioniert",
"self",
".",
"index",
"=",
"[",
"'unit'",
",",
"'energy'",
",",
"'test'",
",",
"'date'",
",",
"'group'",
"]",
"# pandas dataframe vorbereiten",
"self",
".",
"gqa",
"=",
"pd",
".",
"DataFrame",
"(",
"{",
"}",
",",
"columns",
"=",
"self",
".",
"columns",
".",
"keys",
"(",
")",
")",
"self",
".",
"gqa",
".",
"set_index",
"(",
"self",
".",
"index",
",",
"inplace",
"=",
"True",
")",
"# datei noch nicht vorhanden - anlegen",
"if",
"not",
"osp",
".",
"isfile",
"(",
"self",
".",
"filename",
")",
":",
"self",
".",
"write",
"(",
")",
"self",
".",
"isOnline",
"=",
"self",
".",
"read",
"(",
")"
] | [
48,
4
] | [
95,
35
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
|
IntelHexParser.load_file | (self, filename) | Liest die Datei in einen internen Puffer | Liest die Datei in einen internen Puffer | def load_file(self, filename):
""" Liest die Datei in einen internen Puffer """
try:
file = open(filename)
self.load_hex_data(file)
file.close()
except IOError:
raise HexParserException("Could not open file: \"%s\"." % filename)
except:
raise HexParserException("No Intel-Hex Format!") | [
"def",
"load_file",
"(",
"self",
",",
"filename",
")",
":",
"try",
":",
"file",
"=",
"open",
"(",
"filename",
")",
"self",
".",
"load_hex_data",
"(",
"file",
")",
"file",
".",
"close",
"(",
")",
"except",
"IOError",
":",
"raise",
"HexParserException",
"(",
"\"Could not open file: \\\"%s\\\".\"",
"%",
"filename",
")",
"except",
":",
"raise",
"HexParserException",
"(",
"\"No Intel-Hex Format!\"",
")"
] | [
44,
4
] | [
53,
60
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
|
restart | () | restart Übersicht.app | restart Übersicht.app | def restart():
"""restart Übersicht.app"""
kill()
start() | [
"def",
"restart",
"(",
")",
":",
"kill",
"(",
")",
"start",
"(",
")"
] | [
43,
0
] | [
46,
11
] | null | python | de | ['de', 'de', 'de'] | False | true | null |
|
ispBase.getFullData | (self, field) | return result | Holt aus dicomData die zu Field id passenden dicomDaten und gibt beide zurück
Parameters
----------
field: dict, OrderedDict, className=Pandas|Series
muss id enthalten
Returns
-------
result : dict
* info: field
* dicom:
| Holt aus dicomData die zu Field id passenden dicomDaten und gibt beide zurück | def getFullData(self, field):
"""Holt aus dicomData die zu Field id passenden dicomDaten und gibt beide zurück
Parameters
----------
field: dict, OrderedDict, className=Pandas|Series
muss id enthalten
Returns
-------
result : dict
* info: field
* dicom:
"""
# ggf. umwandelungen duchführen
if isinstance(field, tuple) and field.__class__.__name__ == "Pandas":
# eine Pandas tuple in ein dict umwandeln
field = dict( field._asdict() )
elif field.__class__.__name__ == 'Series':
# eine Pandas serie in ein dict umwandeln: df.iloc[3]
field = field.to_dict()
elif isinstance( field, OrderedDict):
# ein OrderedDict in ein dict umwandeln
field = dict( field )
#print("getFullData", field )
result = {
"_type" : "fulldata",
"info" : field,
"dicom" : {}
}
#
if "dicom" in field:
result["dicom"] = field["dicom"]
else:
# ist eine id angegeben
if "id" in field and field["id"] in self.dicomData:
result["dicom"] = self.dicomData[ field["id"] ]
return result | [
"def",
"getFullData",
"(",
"self",
",",
"field",
")",
":",
"# ggf. umwandelungen duchführen",
"if",
"isinstance",
"(",
"field",
",",
"tuple",
")",
"and",
"field",
".",
"__class__",
".",
"__name__",
"==",
"\"Pandas\"",
":",
"# eine Pandas tuple in ein dict umwandeln",
"field",
"=",
"dict",
"(",
"field",
".",
"_asdict",
"(",
")",
")",
"elif",
"field",
".",
"__class__",
".",
"__name__",
"==",
"'Series'",
":",
"# eine Pandas serie in ein dict umwandeln: df.iloc[3]",
"field",
"=",
"field",
".",
"to_dict",
"(",
")",
"elif",
"isinstance",
"(",
"field",
",",
"OrderedDict",
")",
":",
"# ein OrderedDict in ein dict umwandeln",
"field",
"=",
"dict",
"(",
"field",
")",
"#print(\"getFullData\", field )",
"result",
"=",
"{",
"\"_type\"",
":",
"\"fulldata\"",
",",
"\"info\"",
":",
"field",
",",
"\"dicom\"",
":",
"{",
"}",
"}",
"#",
"if",
"\"dicom\"",
"in",
"field",
":",
"result",
"[",
"\"dicom\"",
"]",
"=",
"field",
"[",
"\"dicom\"",
"]",
"else",
":",
"# ist eine id angegeben",
"if",
"\"id\"",
"in",
"field",
"and",
"field",
"[",
"\"id\"",
"]",
"in",
"self",
".",
"dicomData",
":",
"result",
"[",
"\"dicom\"",
"]",
"=",
"self",
".",
"dicomData",
"[",
"field",
"[",
"\"id\"",
"]",
"]",
"return",
"result"
] | [
131,
4
] | [
175,
21
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
RawData.Cheer_Handler | ( self, data=False, rawmessage=False ) | Raw Daten auswerten, ob es sich um einen Cheer handelt | Raw Daten auswerten, ob es sich um einen Cheer handelt | def Cheer_Handler( self, data=False, rawmessage=False ):
''' Raw Daten auswerten, ob es sich um einen Cheer handelt '''
thisActionName = "Cheer_Handler"
tags = False
# RawData auswerten
if data:
PRIVMSG = self.rePRIVMSG.search( data.RawData )
elif rawmessage:
PRIVMSG = self.rePRIVMSG.search( rawmessage )
else:
return False
if PRIVMSG:
tags = dict( re.findall( r"([^=]+)=([^;]*)(?:;|$)", PRIVMSG.group( "irctags" ) ) )
# self.Logger.WriteLog(" {0} - CHEER DATA: {1}".format(
# thisActionName,
# str(tags))
# )
try:
# PRIVMSG ist ein Cheer
if tags["bits"]:
# Aktuelle Daten in Files schreiben
self.write_LatestCheerFile( userDisplayName = tags["display-name"], cheerAmount = int(tags["bits"]) )
self.write_CheerDataLog( userDisplayName = tags["display-name"], cheerAmount = int(tags["bits"]) )
return tags
except:
# PRIVMSG ist kein Cheer
# self.Logger.WriteLog(message_text = " {0} - ERROR: {1}".format(
# thisActionName,
# str(sys.exc_info()))
# )
return False | [
"def",
"Cheer_Handler",
"(",
"self",
",",
"data",
"=",
"False",
",",
"rawmessage",
"=",
"False",
")",
":",
"thisActionName",
"=",
"\"Cheer_Handler\"",
"tags",
"=",
"False",
"# RawData auswerten\r",
"if",
"data",
":",
"PRIVMSG",
"=",
"self",
".",
"rePRIVMSG",
".",
"search",
"(",
"data",
".",
"RawData",
")",
"elif",
"rawmessage",
":",
"PRIVMSG",
"=",
"self",
".",
"rePRIVMSG",
".",
"search",
"(",
"rawmessage",
")",
"else",
":",
"return",
"False",
"if",
"PRIVMSG",
":",
"tags",
"=",
"dict",
"(",
"re",
".",
"findall",
"(",
"r\"([^=]+)=([^;]*)(?:;|$)\"",
",",
"PRIVMSG",
".",
"group",
"(",
"\"irctags\"",
")",
")",
")",
"# self.Logger.WriteLog(\" {0} - CHEER DATA: {1}\".format(\r",
"# thisActionName,\r",
"# str(tags))\r",
"# )\r",
"try",
":",
"# PRIVMSG ist ein Cheer\r",
"if",
"tags",
"[",
"\"bits\"",
"]",
":",
"# Aktuelle Daten in Files schreiben\r",
"self",
".",
"write_LatestCheerFile",
"(",
"userDisplayName",
"=",
"tags",
"[",
"\"display-name\"",
"]",
",",
"cheerAmount",
"=",
"int",
"(",
"tags",
"[",
"\"bits\"",
"]",
")",
")",
"self",
".",
"write_CheerDataLog",
"(",
"userDisplayName",
"=",
"tags",
"[",
"\"display-name\"",
"]",
",",
"cheerAmount",
"=",
"int",
"(",
"tags",
"[",
"\"bits\"",
"]",
")",
")",
"return",
"tags",
"except",
":",
"# PRIVMSG ist kein Cheer\r",
"# self.Logger.WriteLog(message_text = \" {0} - ERROR: {1}\".format(\r",
"# thisActionName,\r",
"# str(sys.exc_info()))\r",
"# )\r",
"return",
"False"
] | [
562,
4
] | [
603,
28
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
|
Jahr.zeitrechnung | (self) | return self.__zeitrechnung | Die Zeitrechnung des Jahres | Die Zeitrechnung des Jahres | def zeitrechnung(self):
"""Die Zeitrechnung des Jahres"""
return self.__zeitrechnung | [
"def",
"zeitrechnung",
"(",
"self",
")",
":",
"return",
"self",
".",
"__zeitrechnung"
] | [
31,
4
] | [
33,
34
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
Pipeline.current_step_name | (self) | return self.__steps[self.__current_step]["name"] | Gibt den Namen des aktuellen Schritts zurück.
:return: Name des aktuellen Schritts.
:rtype: str
| Gibt den Namen des aktuellen Schritts zurück. | def current_step_name(self):
"""Gibt den Namen des aktuellen Schritts zurück.
:return: Name des aktuellen Schritts.
:rtype: str
"""
return self.__steps[self.__current_step]["name"] | [
"def",
"current_step_name",
"(",
"self",
")",
":",
"return",
"self",
".",
"__steps",
"[",
"self",
".",
"__current_step",
"]",
"[",
"\"name\"",
"]"
] | [
100,
4
] | [
106,
56
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
GeneratorGUI.start | (self) | Generatorfenster schliessen | Generatorfenster schliessen | def start(self):
""" Generatorfenster schliessen """
opt= self.exrahiere_optionen()
if self.controller.ist_am_laufen() == False:
self.controller.start( opt)
self.gen_status.set( "Generator aktiv")
sblock = ttk.Style()
sblock.configure( "BlockStatusLabel.TLabel", background = Konfig.AKTIVE_BACKGROUND) | [
"def",
"start",
"(",
"self",
")",
":",
"opt",
"=",
"self",
".",
"exrahiere_optionen",
"(",
")",
"if",
"self",
".",
"controller",
".",
"ist_am_laufen",
"(",
")",
"==",
"False",
":",
"self",
".",
"controller",
".",
"start",
"(",
"opt",
")",
"self",
".",
"gen_status",
".",
"set",
"(",
"\"Generator aktiv\"",
")",
"sblock",
"=",
"ttk",
".",
"Style",
"(",
")",
"sblock",
".",
"configure",
"(",
"\"BlockStatusLabel.TLabel\"",
",",
"background",
"=",
"Konfig",
".",
"AKTIVE_BACKGROUND",
")"
] | [
114,
4
] | [
121,
95
] | null | python | de | ['de', 'de', 'de'] | False | true | null |
|
transform_array | (values: dict, data: StepData) | Führt alle angegebenen `"transform"`-Funktionen für alle Werte eines Arrays aus.
:param values: Werte aus der JSON-Datei
:param data: Daten aus der API
| Führt alle angegebenen `"transform"`-Funktionen für alle Werte eines Arrays aus. | def transform_array(values: dict, data: StepData):
"""Führt alle angegebenen `"transform"`-Funktionen für alle Werte eines Arrays aus.
:param values: Werte aus der JSON-Datei
:param data: Daten aus der API
"""
for _ in data.loop_array(data.get_data(values["array_key"], values), values):
transform(values, data) | [
"def",
"transform_array",
"(",
"values",
":",
"dict",
",",
"data",
":",
"StepData",
")",
":",
"for",
"_",
"in",
"data",
".",
"loop_array",
"(",
"data",
".",
"get_data",
"(",
"values",
"[",
"\"array_key\"",
"]",
",",
"values",
")",
",",
"values",
")",
":",
"transform",
"(",
"values",
",",
"data",
")"
] | [
52,
0
] | [
59,
31
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
|
ImpfterminService.impfstoffe_laden | (self) | return False | Laden der verfügbaren Impstoff-Qualifikationen.
In der Regel gibt es 3 Qualifikationen, die je nach Altersgruppe verteilt werden.
| Laden der verfügbaren Impstoff-Qualifikationen.
In der Regel gibt es 3 Qualifikationen, die je nach Altersgruppe verteilt werden. | def impfstoffe_laden(self):
"""Laden der verfügbaren Impstoff-Qualifikationen.
In der Regel gibt es 3 Qualifikationen, die je nach Altersgruppe verteilt werden.
"""
path = "assets/static/its/vaccination-list.json"
res = self.s.get(self.domain + path, timeout=15)
if res.ok:
res_json = res.json()
for qualifikation in res_json:
qualifikation["impfstoffe"] = qualifikation.get("tssname",
"N/A").replace(" ", "").split(",")
self.verfuegbare_qualifikationen.append(qualifikation)
# Ausgabe der verfügbaren Impfstoffe:
for qualifikation in self.verfuegbare_qualifikationen:
q_id = qualifikation["qualification"]
alter = qualifikation.get("age", "N/A")
intervall = qualifikation.get("interval", " ?")
impfstoffe = str(qualifikation["impfstoffe"])
self.log.info(
f"[{q_id}] Altersgruppe: {alter} (Intervall: {intervall} Tage) --> {impfstoffe}")
print("\n")
return True
self.log.error("Keine Impfstoffe im ausgewählten Impfzentrum verfügbar")
return False | [
"def",
"impfstoffe_laden",
"(",
"self",
")",
":",
"path",
"=",
"\"assets/static/its/vaccination-list.json\"",
"res",
"=",
"self",
".",
"s",
".",
"get",
"(",
"self",
".",
"domain",
"+",
"path",
",",
"timeout",
"=",
"15",
")",
"if",
"res",
".",
"ok",
":",
"res_json",
"=",
"res",
".",
"json",
"(",
")",
"for",
"qualifikation",
"in",
"res_json",
":",
"qualifikation",
"[",
"\"impfstoffe\"",
"]",
"=",
"qualifikation",
".",
"get",
"(",
"\"tssname\"",
",",
"\"N/A\"",
")",
".",
"replace",
"(",
"\" \"",
",",
"\"\"",
")",
".",
"split",
"(",
"\",\"",
")",
"self",
".",
"verfuegbare_qualifikationen",
".",
"append",
"(",
"qualifikation",
")",
"# Ausgabe der verfügbaren Impfstoffe:",
"for",
"qualifikation",
"in",
"self",
".",
"verfuegbare_qualifikationen",
":",
"q_id",
"=",
"qualifikation",
"[",
"\"qualification\"",
"]",
"alter",
"=",
"qualifikation",
".",
"get",
"(",
"\"age\"",
",",
"\"N/A\"",
")",
"intervall",
"=",
"qualifikation",
".",
"get",
"(",
"\"interval\"",
",",
"\" ?\"",
")",
"impfstoffe",
"=",
"str",
"(",
"qualifikation",
"[",
"\"impfstoffe\"",
"]",
")",
"self",
".",
"log",
".",
"info",
"(",
"f\"[{q_id}] Altersgruppe: {alter} (Intervall: {intervall} Tage) --> {impfstoffe}\"",
")",
"print",
"(",
"\"\\n\"",
")",
"return",
"True",
"self",
".",
"log",
".",
"error",
"(",
"\"Keine Impfstoffe im ausgewählten Impfzentrum verfügbar\")",
"",
"return",
"False"
] | [
112,
4
] | [
141,
20
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
testBase.setUpClass | (self) | Wird beim initialisieren der Testklasse aufgerufen.
- Api bereitstellen
- test Ergebnisse zum Vergleich laden
| Wird beim initialisieren der Testklasse aufgerufen.
- Api bereitstellen
- test Ergebnisse zum Vergleich laden
| def setUpClass(self):
"""Wird beim initialisieren der Testklasse aufgerufen.
- Api bereitstellen
- test Ergebnisse zum Vergleich laden
"""
self.gqa_data_ready = False
# This attribute controls the maximum length of diffs output by assert methods that report diffs on failure.
# It defaults to 80*8 characters
self.maxDiff = None
# webapp mit unitest config
self.webapp = run( {
"loglevel" :{
"safrs" : logging.DEBUG,
#"webapp" : logging.INFO,
},
"server" : {
"webserver" : {
"name" : "app_test",
"port" : 5001,
"TESTING": True,
"reloader" : False
}
},
"database": {
"servername" : "variansystem"
"main": "gqa",
"gqa" : {
"name" : "gqa_unittest.json"
}
},
"dicom": {
"servername" : "VMSDBD",
"VMSDBD" : {
"local_dir" : "files/DICOM"
}
},
"resultsPath" : "files/results",
"version": "unittest",
"variables" : {
"Datenausgabe" : "unittest"
}
} )
self.app = self.webapp.app
# Vergleichs Daten laden
check_data_file = osp.join( 'resources', 'check', 'gqa_unittest.json')
if osp.isfile( check_data_file ):
self.gqa = pd.read_json( check_data_file, orient="table", precise_float=10 )
# index definiert in app.results
if self.gqa.index.names == ['unit', 'energy', 'test', 'date', 'group']:
self.gqa_data_ready = True
# tags und gqa ids der Tests bestimmen
self.testTags = {}
self.testIds = {}
for testid, item in self.webapp._config.GQA.items():
if "tag" in item:
self.testTags[ item["tag"] ] = testid
self.testIds[ testid ] = item["tag"] | [
"def",
"setUpClass",
"(",
"self",
")",
":",
"self",
".",
"gqa_data_ready",
"=",
"False",
"# This attribute controls the maximum length of diffs output by assert methods that report diffs on failure. ",
"# It defaults to 80*8 characters",
"self",
".",
"maxDiff",
"=",
"None",
"# webapp mit unitest config",
"self",
".",
"webapp",
"=",
"run",
"(",
"{",
"\"loglevel\"",
":",
"{",
"\"safrs\"",
":",
"logging",
".",
"DEBUG",
",",
"#\"webapp\" : logging.INFO,",
"}",
",",
"\"server\"",
":",
"{",
"\"webserver\"",
":",
"{",
"\"name\"",
":",
"\"app_test\"",
",",
"\"port\"",
":",
"5001",
",",
"\"TESTING\"",
":",
"True",
",",
"\"reloader\"",
":",
"False",
"}",
"}",
",",
"\"database\"",
":",
"{",
"\"servername\"",
":",
"\"variansystem\"",
"\"main\"",
":",
"\"gqa\"",
",",
"\"gqa\"",
":",
"{",
"\"name\"",
":",
"\"gqa_unittest.json\"",
"}",
"}",
",",
"\"dicom\"",
":",
"{",
"\"servername\"",
":",
"\"VMSDBD\"",
",",
"\"VMSDBD\"",
":",
"{",
"\"local_dir\"",
":",
"\"files/DICOM\"",
"}",
"}",
",",
"\"resultsPath\"",
":",
"\"files/results\"",
",",
"\"version\"",
":",
"\"unittest\"",
",",
"\"variables\"",
":",
"{",
"\"Datenausgabe\"",
":",
"\"unittest\"",
"}",
"}",
")",
"self",
".",
"app",
"=",
"self",
".",
"webapp",
".",
"app",
"# Vergleichs Daten laden ",
"check_data_file",
"=",
"osp",
".",
"join",
"(",
"'resources'",
",",
"'check'",
",",
"'gqa_unittest.json'",
")",
"if",
"osp",
".",
"isfile",
"(",
"check_data_file",
")",
":",
"self",
".",
"gqa",
"=",
"pd",
".",
"read_json",
"(",
"check_data_file",
",",
"orient",
"=",
"\"table\"",
",",
"precise_float",
"=",
"10",
")",
"# index definiert in app.results",
"if",
"self",
".",
"gqa",
".",
"index",
".",
"names",
"==",
"[",
"'unit'",
",",
"'energy'",
",",
"'test'",
",",
"'date'",
",",
"'group'",
"]",
":",
"self",
".",
"gqa_data_ready",
"=",
"True",
"# tags und gqa ids der Tests bestimmen",
"self",
".",
"testTags",
"=",
"{",
"}",
"self",
".",
"testIds",
"=",
"{",
"}",
"for",
"testid",
",",
"item",
"in",
"self",
".",
"webapp",
".",
"_config",
".",
"GQA",
".",
"items",
"(",
")",
":",
"if",
"\"tag\"",
"in",
"item",
":",
"self",
".",
"testTags",
"[",
"item",
"[",
"\"tag\"",
"]",
"]",
"=",
"testid",
"self",
".",
"testIds",
"[",
"testid",
"]",
"=",
"item",
"[",
"\"tag\"",
"]"
] | [
52,
4
] | [
115,
52
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
|
AppendDataToFile | ( file, text ) | return True | Füge Text in eine Datei am Ende hinzu | Füge Text in eine Datei am Ende hinzu | def AppendDataToFile( file, text ):
''' Füge Text in eine Datei am Ende hinzu '''
thisActionName = "AppendDataToFile"
try:
with codecs.open( file, encoding="utf-8", mode="a") as f:
text = f.write( str( text ) + os.linesep )
f.close()
except:
return False
return True | [
"def",
"AppendDataToFile",
"(",
"file",
",",
"text",
")",
":",
"thisActionName",
"=",
"\"AppendDataToFile\"",
"try",
":",
"with",
"codecs",
".",
"open",
"(",
"file",
",",
"encoding",
"=",
"\"utf-8\"",
",",
"mode",
"=",
"\"a\"",
")",
"as",
"f",
":",
"text",
"=",
"f",
".",
"write",
"(",
"str",
"(",
"text",
")",
"+",
"os",
".",
"linesep",
")",
"f",
".",
"close",
"(",
")",
"except",
":",
"return",
"False",
"return",
"True"
] | [
284,
0
] | [
295,
15
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
ProgressBar.__call__ | (self, value) | Aktualisiert die Statusanzeige und gibt sie auf den stdout-Stream
aus falls sie sich geaendert hat.
Schreibt als erstes ein "carrige return" sodass die aktuelle Zeile
ueberschrieben wird.
| Aktualisiert die Statusanzeige und gibt sie auf den stdout-Stream
aus falls sie sich geaendert hat. | def __call__(self, value):
""" Aktualisiert die Statusanzeige und gibt sie auf den stdout-Stream
aus falls sie sich geaendert hat.
Schreibt als erstes ein "carrige return" sodass die aktuelle Zeile
ueberschrieben wird.
"""
if self.update(value):
progbar = str(self)
sys.stdout.write("\r" + progbar)
sys.stdout.flush() | [
"def",
"__call__",
"(",
"self",
",",
"value",
")",
":",
"if",
"self",
".",
"update",
"(",
"value",
")",
":",
"progbar",
"=",
"str",
"(",
"self",
")",
"sys",
".",
"stdout",
".",
"write",
"(",
"\"\\r\"",
"+",
"progbar",
")",
"sys",
".",
"stdout",
".",
"flush",
"(",
")"
] | [
76,
4
] | [
86,
30
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
|
upper_case | (values: dict, data: StepData) | Jedes Wort in der Liste wird komplett in Großbuchstaben geschrieben.
:param values: Werte aus der JSON-Datei
:param data: Daten aus der API
:return:
| Jedes Wort in der Liste wird komplett in Großbuchstaben geschrieben. | def upper_case(values: dict, data: StepData):
"""Jedes Wort in der Liste wird komplett in Großbuchstaben geschrieben.
:param values: Werte aus der JSON-Datei
:param data: Daten aus der API
:return:
"""
for idx, key in data.loop_key(values["keys"], values):
value = data.get_data(key, values)
new_key = get_new_keys(values, idx)
new_value = [each.upper() for each in value]
data.insert_data(new_key, new_value, values) | [
"def",
"upper_case",
"(",
"values",
":",
"dict",
",",
"data",
":",
"StepData",
")",
":",
"for",
"idx",
",",
"key",
"in",
"data",
".",
"loop_key",
"(",
"values",
"[",
"\"keys\"",
"]",
",",
"values",
")",
":",
"value",
"=",
"data",
".",
"get_data",
"(",
"key",
",",
"values",
")",
"new_key",
"=",
"get_new_keys",
"(",
"values",
",",
"idx",
")",
"new_value",
"=",
"[",
"each",
".",
"upper",
"(",
")",
"for",
"each",
"in",
"value",
"]",
"data",
".",
"insert_data",
"(",
"new_key",
",",
"new_value",
",",
"values",
")"
] | [
685,
0
] | [
697,
52
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
|
MQTTclass.publish | (self, msg:dict=None, qos=0, retain=False) | return True | Stellt einen Wrapper zu self._mqttc.publish bereit.
Intern wird immer basetopic vor topic gesetzt
Parameters
----------
msg: dict
Dict mit::
- topic : str
- payload : mixed
qos : int, optional
Quality of Service. The default is 0.
retain : bool, optional
Retain-Flag. The default is False.
Returns
-------
bool
True wenn ein publish möglich war
| Stellt einen Wrapper zu self._mqttc.publish bereit. | def publish(self, msg:dict=None, qos=0, retain=False):
"""Stellt einen Wrapper zu self._mqttc.publish bereit.
Intern wird immer basetopic vor topic gesetzt
Parameters
----------
msg: dict
Dict mit::
- topic : str
- payload : mixed
qos : int, optional
Quality of Service. The default is 0.
retain : bool, optional
Retain-Flag. The default is False.
Returns
-------
bool
True wenn ein publish möglich war
"""
if not isinstance(msg, (dict)) or not "topic" in msg:
return False
if not "payload" in msg:
msg["payload"] = ""
if isinstance(msg["payload"], (dict)):
try:
msg["payload"] = json.dumps( msg["payload"] )
except Exception: # pragma: no cover
msg["payload"] = ""
if not isinstance(msg["payload"], (str, bytearray, int, float)):
msg["payload"] = ""
if self._mqttc:
self._mqttc.publish( "{}/{}".format( self.defaults["basetopic"], msg["topic"] ) , payload=msg["payload"], qos=qos, retain=retain)
return True | [
"def",
"publish",
"(",
"self",
",",
"msg",
":",
"dict",
"=",
"None",
",",
"qos",
"=",
"0",
",",
"retain",
"=",
"False",
")",
":",
"if",
"not",
"isinstance",
"(",
"msg",
",",
"(",
"dict",
")",
")",
"or",
"not",
"\"topic\"",
"in",
"msg",
":",
"return",
"False",
"if",
"not",
"\"payload\"",
"in",
"msg",
":",
"msg",
"[",
"\"payload\"",
"]",
"=",
"\"\"",
"if",
"isinstance",
"(",
"msg",
"[",
"\"payload\"",
"]",
",",
"(",
"dict",
")",
")",
":",
"try",
":",
"msg",
"[",
"\"payload\"",
"]",
"=",
"json",
".",
"dumps",
"(",
"msg",
"[",
"\"payload\"",
"]",
")",
"except",
"Exception",
":",
"# pragma: no cover",
"msg",
"[",
"\"payload\"",
"]",
"=",
"\"\"",
"if",
"not",
"isinstance",
"(",
"msg",
"[",
"\"payload\"",
"]",
",",
"(",
"str",
",",
"bytearray",
",",
"int",
",",
"float",
")",
")",
":",
"msg",
"[",
"\"payload\"",
"]",
"=",
"\"\"",
"if",
"self",
".",
"_mqttc",
":",
"self",
".",
"_mqttc",
".",
"publish",
"(",
"\"{}/{}\"",
".",
"format",
"(",
"self",
".",
"defaults",
"[",
"\"basetopic\"",
"]",
",",
"msg",
"[",
"\"topic\"",
"]",
")",
",",
"payload",
"=",
"msg",
"[",
"\"payload\"",
"]",
",",
"qos",
"=",
"qos",
",",
"retain",
"=",
"retain",
")",
"return",
"True"
] | [
430,
4
] | [
471,
19
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
Circle.split | (self, points, rtol, atol) | return [] | Die Funktion splittet das Circle-Objekt an den vorgegebenen Punkten
und gibt eine Liste der neu enstandenen Elemente aus.
| Die Funktion splittet das Circle-Objekt an den vorgegebenen Punkten
und gibt eine Liste der neu enstandenen Elemente aus.
| def split(self, points, rtol, atol):
""" Die Funktion splittet das Circle-Objekt an den vorgegebenen Punkten
und gibt eine Liste der neu enstandenen Elemente aus.
"""
if len(points) == 1:
p = points[0]
split_arcs = []
alpha1 = alpha_line(self.center, p)
alpha2 = normalise_angle(alpha1 + np.pi/2)
alpha3 = normalise_angle(alpha1 + np.pi)
arc = Arc(Element(center=self.center, radius=self.radius,
start_angle=alpha1*180/np.pi,
end_angle=alpha2*180/np.pi))
split_arcs.append(arc)
arc = Arc(Element(center=self.center, radius=self.radius,
start_angle=alpha2*180/np.pi,
end_angle=alpha3*180/np.pi))
split_arcs.append(arc)
arc = Arc(Element(center=self.center, radius=self.radius,
start_angle=alpha3*180/np.pi,
end_angle=alpha1*180/np.pi))
split_arcs.append(arc)
return split_arcs
assert(len(points) == 0)
return [] | [
"def",
"split",
"(",
"self",
",",
"points",
",",
"rtol",
",",
"atol",
")",
":",
"if",
"len",
"(",
"points",
")",
"==",
"1",
":",
"p",
"=",
"points",
"[",
"0",
"]",
"split_arcs",
"=",
"[",
"]",
"alpha1",
"=",
"alpha_line",
"(",
"self",
".",
"center",
",",
"p",
")",
"alpha2",
"=",
"normalise_angle",
"(",
"alpha1",
"+",
"np",
".",
"pi",
"/",
"2",
")",
"alpha3",
"=",
"normalise_angle",
"(",
"alpha1",
"+",
"np",
".",
"pi",
")",
"arc",
"=",
"Arc",
"(",
"Element",
"(",
"center",
"=",
"self",
".",
"center",
",",
"radius",
"=",
"self",
".",
"radius",
",",
"start_angle",
"=",
"alpha1",
"*",
"180",
"/",
"np",
".",
"pi",
",",
"end_angle",
"=",
"alpha2",
"*",
"180",
"/",
"np",
".",
"pi",
")",
")",
"split_arcs",
".",
"append",
"(",
"arc",
")",
"arc",
"=",
"Arc",
"(",
"Element",
"(",
"center",
"=",
"self",
".",
"center",
",",
"radius",
"=",
"self",
".",
"radius",
",",
"start_angle",
"=",
"alpha2",
"*",
"180",
"/",
"np",
".",
"pi",
",",
"end_angle",
"=",
"alpha3",
"*",
"180",
"/",
"np",
".",
"pi",
")",
")",
"split_arcs",
".",
"append",
"(",
"arc",
")",
"arc",
"=",
"Arc",
"(",
"Element",
"(",
"center",
"=",
"self",
".",
"center",
",",
"radius",
"=",
"self",
".",
"radius",
",",
"start_angle",
"=",
"alpha3",
"*",
"180",
"/",
"np",
".",
"pi",
",",
"end_angle",
"=",
"alpha1",
"*",
"180",
"/",
"np",
".",
"pi",
")",
")",
"split_arcs",
".",
"append",
"(",
"arc",
")",
"return",
"split_arcs",
"assert",
"(",
"len",
"(",
"points",
")",
"==",
"0",
")",
"return",
"[",
"]"
] | [
479,
4
] | [
507,
17
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
TicTacToe.laeuft | (self) | return self.naechster_zug() != None | gibt True zurück, wenn das Spiel noch läuft, sonst False | gibt True zurück, wenn das Spiel noch läuft, sonst False | def laeuft(self):
""" gibt True zurück, wenn das Spiel noch läuft, sonst False """
return self.naechster_zug() != None | [
"def",
"laeuft",
"(",
"self",
")",
":",
"return",
"self",
".",
"naechster_zug",
"(",
")",
"!=",
"None"
] | [
66,
4
] | [
68,
43
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
date_format | (values: dict, data: StepData) | Ändert das Format des Datums und der Uhrzeit.
Ändert das Format des Datums und der Uhrzeit, welches unter `"given_format"` angegeben wird, in ein gewünschtes
anderes Format, welches unter `"format"` angegeben wird.
:param values: Werte aus der JSON-Datei
:param data: Daten aus der API
| Ändert das Format des Datums und der Uhrzeit. | def date_format(values: dict, data: StepData):
"""Ändert das Format des Datums und der Uhrzeit.
Ändert das Format des Datums und der Uhrzeit, welches unter `"given_format"` angegeben wird, in ein gewünschtes
anderes Format, welches unter `"format"` angegeben wird.
:param values: Werte aus der JSON-Datei
:param data: Daten aus der API
"""
for idx, key in data.loop_key(values["keys"], values):
value = data.get_data(key, values)
given_format = data.format(values["given_format"], values)
date = datetime.strptime(value, given_format).date()
new_key = get_new_keys(values, idx)
zeropaded_off = data.get_data(values.get("zeropaded_off", False), values, bool)
if zeropaded_off:
new_value = date.strftime(data.format(values["format"], values)).lstrip("0").replace(" 0", " ")
else:
new_value = date.strftime(data.format(values["format"], values))
data.insert_data(new_key, new_value, values) | [
"def",
"date_format",
"(",
"values",
":",
"dict",
",",
"data",
":",
"StepData",
")",
":",
"for",
"idx",
",",
"key",
"in",
"data",
".",
"loop_key",
"(",
"values",
"[",
"\"keys\"",
"]",
",",
"values",
")",
":",
"value",
"=",
"data",
".",
"get_data",
"(",
"key",
",",
"values",
")",
"given_format",
"=",
"data",
".",
"format",
"(",
"values",
"[",
"\"given_format\"",
"]",
",",
"values",
")",
"date",
"=",
"datetime",
".",
"strptime",
"(",
"value",
",",
"given_format",
")",
".",
"date",
"(",
")",
"new_key",
"=",
"get_new_keys",
"(",
"values",
",",
"idx",
")",
"zeropaded_off",
"=",
"data",
".",
"get_data",
"(",
"values",
".",
"get",
"(",
"\"zeropaded_off\"",
",",
"False",
")",
",",
"values",
",",
"bool",
")",
"if",
"zeropaded_off",
":",
"new_value",
"=",
"date",
".",
"strftime",
"(",
"data",
".",
"format",
"(",
"values",
"[",
"\"format\"",
"]",
",",
"values",
")",
")",
".",
"lstrip",
"(",
"\"0\"",
")",
".",
"replace",
"(",
"\" 0\"",
",",
"\" \"",
")",
"else",
":",
"new_value",
"=",
"date",
".",
"strftime",
"(",
"data",
".",
"format",
"(",
"values",
"[",
"\"format\"",
"]",
",",
"values",
")",
")",
"data",
".",
"insert_data",
"(",
"new_key",
",",
"new_value",
",",
"values",
")"
] | [
279,
0
] | [
298,
52
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
|
general.pun | (self, ctx) | Weil jeder schlechte Witze mag | Weil jeder schlechte Witze mag | async def pun(self, ctx):
'''Weil jeder schlechte Witze mag'''
await ctx.message.delete()
puns = ['Was sagt das eine Streichholz zum anderen Streichholz?\n Komm, lass uns durchbrennen',
'Wieviele Deutsche braucht man um eine Glühbirne zu wechseln?\n Einen, wir sind humorlos und effizient.',
'Wo wohnt die Katze?\n Im Miezhaus.',
'Wie begrüßen sich zwei plastische Chirurgen?\n "Was machst du denn heute für ein Gesicht?"',
'Warum essen Veganer kein Huhn?\n Könnte Ei enthalten',
'85% der Frauen finden ihren Arsch zu dick, 10% zu dünn, 5% finden ihn so ok, wie er ist und sind froh, dass sie ihn geheiratet haben...',
'Meine Freundin meint, ich wär neugierig...\n...zumindest\' steht das in ihrem Tagebuch.',
'"Schatz, Ich muss mein T-Shirt waschen! Welches Waschmaschinen Programm soll ich nehmen?" - "Was steht denn auf dem T-Shirt drauf?"\n "Slayer!"',
'Gestern erzählte ich meinem Freund, dass ich schon immer dieses Ding aus Harry Potter reiten wollte.\n"einen Besen?" "nein, Hermine."',
'Warum gehen Ameisen nicht in die Kirche?\nSie sind in Sekten.',
'Was steht auf dem Grabstein eines Mathematikers?\n"Damit hat er nicht gerechnet."',
'Wenn ein Yogalehrer seine Beine senkrecht nach oben streckt und dabei furzt, welche Yoga Figur stellt er da?\n Eine Duftkerze',
'Warum ging der Luftballon kaputt?\n Aus Platzgründen.',
'Ich wollte Spiderman anrufen, aber er hatte kein Netz.',
'Was vermisst eine Schraube am meisten? Einen Vater',
'Geht ein Panda über die Straße. Bam....Bus!']
emojis = [':laughing:', ':smile:', ':joy:', ':sob:', ':rofl:']
msg = f'{random.choice(emojis)} {random.choice(puns)}'
await ctx.send(msg) | [
"async",
"def",
"pun",
"(",
"self",
",",
"ctx",
")",
":",
"await",
"ctx",
".",
"message",
".",
"delete",
"(",
")",
"puns",
"=",
"[",
"'Was sagt das eine Streichholz zum anderen Streichholz?\\n Komm, lass uns durchbrennen'",
",",
"'Wieviele Deutsche braucht man um eine Glühbirne zu wechseln?\\n Einen, wir sind humorlos und effizient.',",
"",
"'Wo wohnt die Katze?\\n Im Miezhaus.'",
",",
"'Wie begrüßen sich zwei plastische Chirurgen?\\n \"Was machst du denn heute für ein Gesicht?\"',",
"",
"'Warum essen Veganer kein Huhn?\\n Könnte Ei enthalten',",
"",
"'85% der Frauen finden ihren Arsch zu dick, 10% zu dünn, 5% finden ihn so ok, wie er ist und sind froh, dass sie ihn geheiratet haben...',",
"",
"'Meine Freundin meint, ich wär neugierig...\\n...zumindest\\' steht das in ihrem Tagebuch.',",
"",
"'\"Schatz, Ich muss mein T-Shirt waschen! Welches Waschmaschinen Programm soll ich nehmen?\" - \"Was steht denn auf dem T-Shirt drauf?\"\\n \"Slayer!\"'",
",",
"'Gestern erzählte ich meinem Freund, dass ich schon immer dieses Ding aus Harry Potter reiten wollte.\\n\"einen Besen?\" \"nein, Hermine.\"',",
"",
"'Warum gehen Ameisen nicht in die Kirche?\\nSie sind in Sekten.'",
",",
"'Was steht auf dem Grabstein eines Mathematikers?\\n\"Damit hat er nicht gerechnet.\"'",
",",
"'Wenn ein Yogalehrer seine Beine senkrecht nach oben streckt und dabei furzt, welche Yoga Figur stellt er da?\\n Eine Duftkerze'",
",",
"'Warum ging der Luftballon kaputt?\\n Aus Platzgründen.',",
"",
"'Ich wollte Spiderman anrufen, aber er hatte kein Netz.'",
",",
"'Was vermisst eine Schraube am meisten? Einen Vater'",
",",
"'Geht ein Panda über die Straße. Bam....Bus!']",
"",
"emojis",
"=",
"[",
"':laughing:'",
",",
"':smile:'",
",",
"':joy:'",
",",
"':sob:'",
",",
"':rofl:'",
"]",
"msg",
"=",
"f'{random.choice(emojis)} {random.choice(puns)}'",
"await",
"ctx",
".",
"send",
"(",
"msg",
")"
] | [
122,
4
] | [
143,
27
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
|
ariaDicomClass.prepare_tolerance | (self, testid:str="", energy=None) | return tolerance | Prüft ob es in conig eine tolerance Angabe für die testid und die Energie gibt
Stellt wenn f nicht angegeben wurde eine Formel in f zusammen
Gibt es eine GQA.<testid>.info.tolerance.default Angabe, so wird diese als Grundlage für alle Energien verwendet
Zweig in config::
GQA.<testid>.info.tolerance.<energy>
{
name: {
f: formel mit {value}
value: wert
range: [min, max]
operator: [ eq, ne, lt, gt, le, ge]
}
}
Parameters
----------
testid : str, optional
id des zu verarbeitenden tolerance Bereichs
energy : str, optional
Augabe der Energie für die Info. The default is None.
Ohne Angabe wird nur der Parameter info zurückgegeben
Returns
-------
info : dict
Parameter info mit zusätzlichen Angaben für die Energie.
Beispiel::
"default": {
"warning" : { "f":"abs({value}) > 1.0", "unit": "%" },
"error" : { "f":"abs({value}) > 2.0", "unit": "%" },
"check" : { "field": "diff", "query":"ME == 100" }
},
"MU_20": {
"warning" : { "f":"abs({value}) > 1.0", "unit": "%" },
"error" : { "f":"abs({value}) > 2.5", "unit": "%" },
"check" : { "field": "diff", "query":"ME == 20" }
},
| Prüft ob es in conig eine tolerance Angabe für die testid und die Energie gibt | def prepare_tolerance(self, testid:str="", energy=None):
"""Prüft ob es in conig eine tolerance Angabe für die testid und die Energie gibt
Stellt wenn f nicht angegeben wurde eine Formel in f zusammen
Gibt es eine GQA.<testid>.info.tolerance.default Angabe, so wird diese als Grundlage für alle Energien verwendet
Zweig in config::
GQA.<testid>.info.tolerance.<energy>
{
name: {
f: formel mit {value}
value: wert
range: [min, max]
operator: [ eq, ne, lt, gt, le, ge]
}
}
Parameters
----------
testid : str, optional
id des zu verarbeitenden tolerance Bereichs
energy : str, optional
Augabe der Energie für die Info. The default is None.
Ohne Angabe wird nur der Parameter info zurückgegeben
Returns
-------
info : dict
Parameter info mit zusätzlichen Angaben für die Energie.
Beispiel::
"default": {
"warning" : { "f":"abs({value}) > 1.0", "unit": "%" },
"error" : { "f":"abs({value}) > 2.0", "unit": "%" },
"check" : { "field": "diff", "query":"ME == 100" }
},
"MU_20": {
"warning" : { "f":"abs({value}) > 1.0", "unit": "%" },
"error" : { "f":"abs({value}) > 2.5", "unit": "%" },
"check" : { "field": "diff", "query":"ME == 20" }
},
"""
info = self.config.get( ["GQA", testid, "info" ] )
default = info.tolerance.get( "default", False )
tolerance = info.tolerance.get( energy, False )
if not tolerance and not default:
return DotMap()
if not default:
default = DotMap()
if tolerance:
tolerance = dict_merge( default, tolerance)
else:
tolerance = default
#print("prepare_tolerance tolerance", tolerance )
import functools
# alle Angaben durchgehen
for name in tolerance:
if not isinstance( tolerance.get(name), dict ):
continue
for artName, art in tolerance.get(name).items():
# überspringen wenn art = soll oder f schon vorhanden
if artName == "soll" or art.get("f", None):
continue
# gibt es keine formel dann erstellen
# wurde ein wert angegeben
_value = art.get("value", None)
_range = art.get("range", None)
if _value:
#zuerst den operator festlegen
operator = art.get("operator", "gt")
# [ eq, ne, lt, gt, le, ge]
operator = functools.reduce(lambda a, b: a.replace(*b)
, [('eq','=='),('ne','!='),('lt', '<'),( 'gt', '>'),( 'le','<='),( 'ge', '>=')] #iterable of pairs: (oldval, newval)
, operator #The string from which to replace values
)
tolerance[name][artName]["f"] = "abs({}) {} {}".format( "{value}", operator, _value )
# wurde ein Bereich angegeben
elif art.get("range", None) and len(_range) >= 2:
tolerance[name][artName]["f"] = "{} <= {} >= {}".format( _range[0], "{value}", _range[1] )
return tolerance | [
"def",
"prepare_tolerance",
"(",
"self",
",",
"testid",
":",
"str",
"=",
"\"\"",
",",
"energy",
"=",
"None",
")",
":",
"info",
"=",
"self",
".",
"config",
".",
"get",
"(",
"[",
"\"GQA\"",
",",
"testid",
",",
"\"info\"",
"]",
")",
"default",
"=",
"info",
".",
"tolerance",
".",
"get",
"(",
"\"default\"",
",",
"False",
")",
"tolerance",
"=",
"info",
".",
"tolerance",
".",
"get",
"(",
"energy",
",",
"False",
")",
"if",
"not",
"tolerance",
"and",
"not",
"default",
":",
"return",
"DotMap",
"(",
")",
"if",
"not",
"default",
":",
"default",
"=",
"DotMap",
"(",
")",
"if",
"tolerance",
":",
"tolerance",
"=",
"dict_merge",
"(",
"default",
",",
"tolerance",
")",
"else",
":",
"tolerance",
"=",
"default",
"#print(\"prepare_tolerance tolerance\", tolerance )",
"import",
"functools",
"# alle Angaben durchgehen",
"for",
"name",
"in",
"tolerance",
":",
"if",
"not",
"isinstance",
"(",
"tolerance",
".",
"get",
"(",
"name",
")",
",",
"dict",
")",
":",
"continue",
"for",
"artName",
",",
"art",
"in",
"tolerance",
".",
"get",
"(",
"name",
")",
".",
"items",
"(",
")",
":",
"# überspringen wenn art = soll oder f schon vorhanden",
"if",
"artName",
"==",
"\"soll\"",
"or",
"art",
".",
"get",
"(",
"\"f\"",
",",
"None",
")",
":",
"continue",
"# gibt es keine formel dann erstellen",
"# wurde ein wert angegeben",
"_value",
"=",
"art",
".",
"get",
"(",
"\"value\"",
",",
"None",
")",
"_range",
"=",
"art",
".",
"get",
"(",
"\"range\"",
",",
"None",
")",
"if",
"_value",
":",
"#zuerst den operator festlegen",
"operator",
"=",
"art",
".",
"get",
"(",
"\"operator\"",
",",
"\"gt\"",
")",
"# [ eq, ne, lt, gt, le, ge]",
"operator",
"=",
"functools",
".",
"reduce",
"(",
"lambda",
"a",
",",
"b",
":",
"a",
".",
"replace",
"(",
"*",
"b",
")",
",",
"[",
"(",
"'eq'",
",",
"'=='",
")",
",",
"(",
"'ne'",
",",
"'!='",
")",
",",
"(",
"'lt'",
",",
"'<'",
")",
",",
"(",
"'gt'",
",",
"'>'",
")",
",",
"(",
"'le'",
",",
"'<='",
")",
",",
"(",
"'ge'",
",",
"'>='",
")",
"]",
"#iterable of pairs: (oldval, newval)",
",",
"operator",
"#The string from which to replace values",
")",
"tolerance",
"[",
"name",
"]",
"[",
"artName",
"]",
"[",
"\"f\"",
"]",
"=",
"\"abs({}) {} {}\"",
".",
"format",
"(",
"\"{value}\"",
",",
"operator",
",",
"_value",
")",
"# wurde ein Bereich angegeben",
"elif",
"art",
".",
"get",
"(",
"\"range\"",
",",
"None",
")",
"and",
"len",
"(",
"_range",
")",
">=",
"2",
":",
"tolerance",
"[",
"name",
"]",
"[",
"artName",
"]",
"[",
"\"f\"",
"]",
"=",
"\"{} <= {} >= {}\"",
".",
"format",
"(",
"_range",
"[",
"0",
"]",
",",
"\"{value}\"",
",",
"_range",
"[",
"1",
"]",
")",
"return",
"tolerance"
] | [
677,
4
] | [
766,
24
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
HeistSystem.Writemessage_NewPlayerEntry | (self, playerData) | return | Schreibt die Benachrichtigung über Teilnahme eines neuen Spielers in den Chat | Schreibt die Benachrichtigung über Teilnahme eines neuen Spielers in den Chat | def Writemessage_NewPlayerEntry(self, playerData):
''' Schreibt die Benachrichtigung über Teilnahme eines neuen Spielers in den Chat '''
thisActionName = "Writemessage_NewPlayerEntry"
# Benachrichtigung aus der Datenbank auslesen
messageText = self.RandomMessage_ByType(
messageType=self.MessageType_NewPlayer
)
# Nachricht in den Chat schreiben
self.chat_WriteTextMessage(
messageText=str(messageText).format(
user=playerData["playerDisplayName"],
target=self.GameTargetName,
stake=TransformLocale_Decimals(
playerData["playerStake"]
),
pointsname=self.Parent.GetCurrencyName()
)
)
return | [
"def",
"Writemessage_NewPlayerEntry",
"(",
"self",
",",
"playerData",
")",
":",
"thisActionName",
"=",
"\"Writemessage_NewPlayerEntry\"",
"# Benachrichtigung aus der Datenbank auslesen\r",
"messageText",
"=",
"self",
".",
"RandomMessage_ByType",
"(",
"messageType",
"=",
"self",
".",
"MessageType_NewPlayer",
")",
"# Nachricht in den Chat schreiben\r",
"self",
".",
"chat_WriteTextMessage",
"(",
"messageText",
"=",
"str",
"(",
"messageText",
")",
".",
"format",
"(",
"user",
"=",
"playerData",
"[",
"\"playerDisplayName\"",
"]",
",",
"target",
"=",
"self",
".",
"GameTargetName",
",",
"stake",
"=",
"TransformLocale_Decimals",
"(",
"playerData",
"[",
"\"playerStake\"",
"]",
")",
",",
"pointsname",
"=",
"self",
".",
"Parent",
".",
"GetCurrencyName",
"(",
")",
")",
")",
"return"
] | [
1179,
4
] | [
1200,
14
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
wind_direction | (values: dict, data: StepData) | Wandelt einen String von Windrichtungen um.
Funktion nur mit den wind_cdir_full-Werten aus der Weatherbit-API ausführbar.
:param values: Werte aus der JSON-Datei
:param data: Daten aus der API
| Wandelt einen String von Windrichtungen um. | def wind_direction(values: dict, data: StepData):
"""Wandelt einen String von Windrichtungen um.
Funktion nur mit den wind_cdir_full-Werten aus der Weatherbit-API ausführbar.
:param values: Werte aus der JSON-Datei
:param data: Daten aus der API
"""
value = data.get_data(values["key"], values)
new_key = get_new_key(values)
delimiter = data.format(values["delimiter"], values)
if value.find(delimiter) != -1:
wind = value.split(delimiter)
wind_1 = wind[0]
wind_2 = wind[1]
wind_dir_1 = data.format(values["dict"][wind_1]["0"], values)
wind_dir_2 = data.format(values["dict"][wind_2]["0"], values)
new_value = f"{wind_dir_1}-{wind_dir_2}"
else:
new_value = data.format(values["dict"][value]["1"], values)
data.insert_data(new_key, new_value, values) | [
"def",
"wind_direction",
"(",
"values",
":",
"dict",
",",
"data",
":",
"StepData",
")",
":",
"value",
"=",
"data",
".",
"get_data",
"(",
"values",
"[",
"\"key\"",
"]",
",",
"values",
")",
"new_key",
"=",
"get_new_key",
"(",
"values",
")",
"delimiter",
"=",
"data",
".",
"format",
"(",
"values",
"[",
"\"delimiter\"",
"]",
",",
"values",
")",
"if",
"value",
".",
"find",
"(",
"delimiter",
")",
"!=",
"-",
"1",
":",
"wind",
"=",
"value",
".",
"split",
"(",
"delimiter",
")",
"wind_1",
"=",
"wind",
"[",
"0",
"]",
"wind_2",
"=",
"wind",
"[",
"1",
"]",
"wind_dir_1",
"=",
"data",
".",
"format",
"(",
"values",
"[",
"\"dict\"",
"]",
"[",
"wind_1",
"]",
"[",
"\"0\"",
"]",
",",
"values",
")",
"wind_dir_2",
"=",
"data",
".",
"format",
"(",
"values",
"[",
"\"dict\"",
"]",
"[",
"wind_2",
"]",
"[",
"\"0\"",
"]",
",",
"values",
")",
"new_value",
"=",
"f\"{wind_dir_1}-{wind_dir_2}\"",
"else",
":",
"new_value",
"=",
"data",
".",
"format",
"(",
"values",
"[",
"\"dict\"",
"]",
"[",
"value",
"]",
"[",
"\"1\"",
"]",
",",
"values",
")",
"data",
".",
"insert_data",
"(",
"new_key",
",",
"new_value",
",",
"values",
")"
] | [
371,
0
] | [
391,
48
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
|
testBase.tearDown | (self) | wird nach jeden test aufgerufen
Returns
-------
None.
| wird nach jeden test aufgerufen
| def tearDown(self):
''' wird nach jeden test aufgerufen
Returns
-------
None.
'''
#self.app.
# close the browser window
#self.driver.quit()
pass | [
"def",
"tearDown",
"(",
"self",
")",
":",
"#self.app.",
"# close the browser window",
"#self.driver.quit()",
"pass"
] | [
933,
4
] | [
946,
12
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
|
tertial | (date) | return ret | Wandelt ein Date oder Datetime-Objekt in einen Tertial-String | Wandelt ein Date oder Datetime-Objekt in einen Tertial-String | def tertial(date):
"""Wandelt ein Date oder Datetime-Objekt in einen Tertial-String"""
ret = date.strftime('%Y-%m')
ret = ret[:-2] + {'01': 'A', '02': 'A', '03': 'A', '04': 'A',
'05': 'B', '06': 'B', '07': 'B', '08': 'B',
'09': 'C', '10': 'C', '11': 'C', '12': 'C'}[ret[-2:]]
return ret | [
"def",
"tertial",
"(",
"date",
")",
":",
"ret",
"=",
"date",
".",
"strftime",
"(",
"'%Y-%m'",
")",
"ret",
"=",
"ret",
"[",
":",
"-",
"2",
"]",
"+",
"{",
"'01'",
":",
"'A'",
",",
"'02'",
":",
"'A'",
",",
"'03'",
":",
"'A'",
",",
"'04'",
":",
"'A'",
",",
"'05'",
":",
"'B'",
",",
"'06'",
":",
"'B'",
",",
"'07'",
":",
"'B'",
",",
"'08'",
":",
"'B'",
",",
"'09'",
":",
"'C'",
",",
"'10'",
":",
"'C'",
",",
"'11'",
":",
"'C'",
",",
"'12'",
":",
"'C'",
"}",
"[",
"ret",
"[",
"-",
"2",
":",
"]",
"]",
"return",
"ret"
] | [
28,
0
] | [
34,
14
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
GUI.setzen0_alles | (self) | Alle Ein- und Ausgänge auf 0 setzen | Alle Ein- und Ausgänge auf 0 setzen | def setzen0_alles(self):
""" Alle Ein- und Ausgänge auf 0 setzen """
setzer = Setzer()
setzer.setzen0_alles()
self.aktualisieren_eingangswerte() | [
"def",
"setzen0_alles",
"(",
"self",
")",
":",
"setzer",
"=",
"Setzer",
"(",
")",
"setzer",
".",
"setzen0_alles",
"(",
")",
"self",
".",
"aktualisieren_eingangswerte",
"(",
")"
] | [
189,
4
] | [
193,
42
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
|
calculate_max | (values: dict, data: StepData) | Findet den Maximalwert von Werten, die in einem Array stehen.
:param values: Werte aus der JSON-Datei
:param data: Daten aus der API
| Findet den Maximalwert von Werten, die in einem Array stehen. | def calculate_max(values: dict, data: StepData):
"""Findet den Maximalwert von Werten, die in einem Array stehen.
:param values: Werte aus der JSON-Datei
:param data: Daten aus der API
"""
for idx, key in data.loop_key(values["keys"], values):
value = data.get_data(key, values)
inner_key = values.get("innerKey", None)
if inner_key:
value = [reduce(operator.getitem, inner_key[0].split('|'), x) for x in value]
new_key = get_new_keys(values, idx)
new_value = max(value)
if values.get("decimal", None):
new_value = round(new_value, data.get_data(values["decimal"], values, numbers.Number))
else:
new_value = round(new_value)
data.insert_data(new_key, new_value, values)
if values.get("save_idx_to", None):
data.insert_data(values["save_idx_to"][idx], value.index(new_value), values) | [
"def",
"calculate_max",
"(",
"values",
":",
"dict",
",",
"data",
":",
"StepData",
")",
":",
"for",
"idx",
",",
"key",
"in",
"data",
".",
"loop_key",
"(",
"values",
"[",
"\"keys\"",
"]",
",",
"values",
")",
":",
"value",
"=",
"data",
".",
"get_data",
"(",
"key",
",",
"values",
")",
"inner_key",
"=",
"values",
".",
"get",
"(",
"\"innerKey\"",
",",
"None",
")",
"if",
"inner_key",
":",
"value",
"=",
"[",
"reduce",
"(",
"operator",
".",
"getitem",
",",
"inner_key",
"[",
"0",
"]",
".",
"split",
"(",
"'|'",
")",
",",
"x",
")",
"for",
"x",
"in",
"value",
"]",
"new_key",
"=",
"get_new_keys",
"(",
"values",
",",
"idx",
")",
"new_value",
"=",
"max",
"(",
"value",
")",
"if",
"values",
".",
"get",
"(",
"\"decimal\"",
",",
"None",
")",
":",
"new_value",
"=",
"round",
"(",
"new_value",
",",
"data",
".",
"get_data",
"(",
"values",
"[",
"\"decimal\"",
"]",
",",
"values",
",",
"numbers",
".",
"Number",
")",
")",
"else",
":",
"new_value",
"=",
"round",
"(",
"new_value",
")",
"data",
".",
"insert_data",
"(",
"new_key",
",",
"new_value",
",",
"values",
")",
"if",
"values",
".",
"get",
"(",
"\"save_idx_to\"",
",",
"None",
")",
":",
"data",
".",
"insert_data",
"(",
"values",
"[",
"\"save_idx_to\"",
"]",
"[",
"idx",
"]",
",",
"value",
".",
"index",
"(",
"new_value",
")",
",",
"values",
")"
] | [
51,
0
] | [
71,
88
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
|
HeistSystem.WriteMessage_NotEnoughPlayer | (self, allPlayerData) | return | Schreibt eine Benachrichtigung in den Chat, dass sich nicht genügend
Spieler eingefunden haben
| Schreibt eine Benachrichtigung in den Chat, dass sich nicht genügend
Spieler eingefunden haben
| def WriteMessage_NotEnoughPlayer(self, allPlayerData):
''' Schreibt eine Benachrichtigung in den Chat, dass sich nicht genügend
Spieler eingefunden haben
'''
thisActionName = "WriteMessage_NotEnoughPlayer"
# Rückerstattung des Einsatzes
for player in allPlayerData:
# Punkte zurück erstatten
self.Parent.AddPoints(player["userName"],
self.Parent.GetDisplayName(
player["userName"]),
player["userStake"])
# Benachrichtigung aus der Datenbank auslesen
messageText = self.RandomMessage_ByType(
messageType=self.MessageType_NotEnoughPlayer
)
# Nachricht in den Chat schreiben
self.chat_WriteTextMessage(
messageText=str(messageText).format(
target=self.GameTargetName,
pointsname=self.Parent.GetCurrencyName()
)
)
return | [
"def",
"WriteMessage_NotEnoughPlayer",
"(",
"self",
",",
"allPlayerData",
")",
":",
"thisActionName",
"=",
"\"WriteMessage_NotEnoughPlayer\"",
"# Rückerstattung des Einsatzes\r",
"for",
"player",
"in",
"allPlayerData",
":",
"# Punkte zurück erstatten\r",
"self",
".",
"Parent",
".",
"AddPoints",
"(",
"player",
"[",
"\"userName\"",
"]",
",",
"self",
".",
"Parent",
".",
"GetDisplayName",
"(",
"player",
"[",
"\"userName\"",
"]",
")",
",",
"player",
"[",
"\"userStake\"",
"]",
")",
"# Benachrichtigung aus der Datenbank auslesen\r",
"messageText",
"=",
"self",
".",
"RandomMessage_ByType",
"(",
"messageType",
"=",
"self",
".",
"MessageType_NotEnoughPlayer",
")",
"# Nachricht in den Chat schreiben\r",
"self",
".",
"chat_WriteTextMessage",
"(",
"messageText",
"=",
"str",
"(",
"messageText",
")",
".",
"format",
"(",
"target",
"=",
"self",
".",
"GameTargetName",
",",
"pointsname",
"=",
"self",
".",
"Parent",
".",
"GetCurrencyName",
"(",
")",
")",
")",
"return"
] | [
1227,
4
] | [
1255,
14
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
AnnotationTokenizer.t_EMPFINDUNG | (self, t) | return t | r'empfindung | r'empfindung | def t_EMPFINDUNG(self, t):
r'empfindung'
return t | [
"def",
"t_EMPFINDUNG",
"(",
"self",
",",
"t",
")",
":",
"return",
"t"
] | [
381,
4
] | [
383,
16
] | null | python | de | ['de', 'de', 'de'] | False | true | null |
RoleReactClient.on_raw_reaction_add | (self, payload) | Dir wurde die Rolle erfolgreich gegeben.. | Dir wurde die Rolle erfolgreich gegeben.. | async def on_raw_reaction_add(self, payload):
"""Dir wurde die Rolle erfolgreich gegeben.."""
# Make sure that the message the user is reacting to is the one we care about
if payload.message_id != self.role_message_id:
return
try:
role_id = self.emoji_to_role[payload.emoji]
except KeyError:
# If the emoji isn't the one we care about then exit as well.
return
guild = self.get_guild(payload.guild_id)
if guild is None:
# Check if we're still in the guild and it's cached.
return
role = guild.get_role(role_id)
if role is None:
# Make sure the role still exists and is valid.
return
try:
# Finally add the role
await payload.member.add_roles(role)
except discord.HTTPException:
# If we want to do something in case of errors we'd do it here.
pass | [
"async",
"def",
"on_raw_reaction_add",
"(",
"self",
",",
"payload",
")",
":",
"# Make sure that the message the user is reacting to is the one we care about",
"if",
"payload",
".",
"message_id",
"!=",
"self",
".",
"role_message_id",
":",
"return",
"try",
":",
"role_id",
"=",
"self",
".",
"emoji_to_role",
"[",
"payload",
".",
"emoji",
"]",
"except",
"KeyError",
":",
"# If the emoji isn't the one we care about then exit as well.",
"return",
"guild",
"=",
"self",
".",
"get_guild",
"(",
"payload",
".",
"guild_id",
")",
"if",
"guild",
"is",
"None",
":",
"# Check if we're still in the guild and it's cached.",
"return",
"role",
"=",
"guild",
".",
"get_role",
"(",
"role_id",
")",
"if",
"role",
"is",
"None",
":",
"# Make sure the role still exists and is valid.",
"return",
"try",
":",
"# Finally add the role",
"await",
"payload",
".",
"member",
".",
"add_roles",
"(",
"role",
")",
"except",
"discord",
".",
"HTTPException",
":",
"# If we want to do something in case of errors we'd do it here.",
"pass"
] | [
20,
4
] | [
47,
16
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
|
HeistSystem.DB_check_PlayerExist | (self, playerName) | Prüft, ob der Spieler bereits in der Datenbank eingetragen wurde | Prüft, ob der Spieler bereits in der Datenbank eingetragen wurde | def DB_check_PlayerExist(self, playerName):
''' Prüft, ob der Spieler bereits in der Datenbank eingetragen wurde '''
thisActionName = "DB_check_PlayerExist"
sql = "SELECT count(userName) FROM game_heist_gamedata WHERE userName = ? AND gameID = ?"
val = (playerName, self.GameID)
try:
result = self.GameDB.execute(sql, val).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())))
return 0
# Spieler nimmt bereits am Spiel teil
if not result == 0:
return True
# Spieler noch nicht in der Datenbank
else:
return False | [
"def",
"DB_check_PlayerExist",
"(",
"self",
",",
"playerName",
")",
":",
"thisActionName",
"=",
"\"DB_check_PlayerExist\"",
"sql",
"=",
"\"SELECT count(userName) FROM game_heist_gamedata WHERE userName = ? AND gameID = ?\"",
"val",
"=",
"(",
"playerName",
",",
"self",
".",
"GameID",
")",
"try",
":",
"result",
"=",
"self",
".",
"GameDB",
".",
"execute",
"(",
"sql",
",",
"val",
")",
".",
"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",
"(",
")",
")",
")",
")",
"return",
"0",
"# Spieler nimmt bereits am Spiel teil\r",
"if",
"not",
"result",
"==",
"0",
":",
"return",
"True",
"# Spieler noch nicht in der Datenbank\r",
"else",
":",
"return",
"False"
] | [
838,
4
] | [
864,
24
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
|
ispBase.check_acceptance | ( self, df, md={}, check=[], withSoll=False ) | return acceptance | Überprüft die angegebenen Felder auf die Erfüllung der Toleranz Angaben
Erweitert das Dataframe um <field>_acceptance und <field>_passed (Icon)
gibt das gesamt Ergebnis zurück
Parameters
----------
df : DataFrame
Pandas DataFrame mit den in 'field' angegebenen Feldern
md : dict
metadata mit tolerance angaben für die Energie in md["energy"]
check : dict
field: str
Name des Feldes
tolerance: str
Bezeichner des toleranz Bereichs in md.current.tolerance
wird tolerance nicht angegeben wird default verwendet
withSoll: boolean
true - zusätzlich value einfügen wenn in toleranz angegeben
Returns
-------
int : acceptance aller Felder
Varianten::
5 - green - very Good (True)
4 - green - Good
3 - yellow - Sufficient
2 - orange - Insufficient
1 - red - Fail (False)
999 - (n.a.) Not applicable
| Überprüft die angegebenen Felder auf die Erfüllung der Toleranz Angaben
Erweitert das Dataframe um <field>_acceptance und <field>_passed (Icon)
gibt das gesamt Ergebnis zurück | def check_acceptance( self, df, md={}, check=[], withSoll=False ):
"""Überprüft die angegebenen Felder auf die Erfüllung der Toleranz Angaben
Erweitert das Dataframe um <field>_acceptance und <field>_passed (Icon)
gibt das gesamt Ergebnis zurück
Parameters
----------
df : DataFrame
Pandas DataFrame mit den in 'field' angegebenen Feldern
md : dict
metadata mit tolerance angaben für die Energie in md["energy"]
check : dict
field: str
Name des Feldes
tolerance: str
Bezeichner des toleranz Bereichs in md.current.tolerance
wird tolerance nicht angegeben wird default verwendet
withSoll: boolean
true - zusätzlich value einfügen wenn in toleranz angegeben
Returns
-------
int : acceptance aller Felder
Varianten::
5 - green - very Good (True)
4 - green - Good
3 - yellow - Sufficient
2 - orange - Insufficient
1 - red - Fail (False)
999 - (n.a.) Not applicable
"""
#print( "check_acceptance", df, md.current, check )
fullCheck = []
for ci in check:
tolerance = "default"
if "tolerance" in ci:
tolerance = ci['tolerance']
if withSoll:
try:
sollValue = md.current.tolerance.get("soll").get("value", np.nan)
except:
sollValue = np.nan
if sollValue:
df[ ci['field'] + "_soll" ] = sollValue
df[ ci['field'] + "_acceptance" ] = df[ ci['field'] ].apply(
self.check_tolerance,
args=[md.current.get( "tolerance", None ), tolerance ]
)
# und in passed anzeigen
#df[ ci['field'] + "_passed" ] = df[ ci['field'] + "_acceptance" ].apply( lambda x: 999 if 888 else self.icons[ x ] )
df[ ci['field'] + "_passed" ] = df[ ci['field'] + "_acceptance" ].apply( self.getIcon )
# das feld in fullCheck einfügen
fullCheck.append( ci['field'] + "_acceptance")
minAll = df[ fullCheck ].min(axis=None, skipna=True)
acceptance = minAll.min()
#print("check_acceptance",df, acceptance )
return acceptance | [
"def",
"check_acceptance",
"(",
"self",
",",
"df",
",",
"md",
"=",
"{",
"}",
",",
"check",
"=",
"[",
"]",
",",
"withSoll",
"=",
"False",
")",
":",
"#print( \"check_acceptance\", df, md.current, check )",
"fullCheck",
"=",
"[",
"]",
"for",
"ci",
"in",
"check",
":",
"tolerance",
"=",
"\"default\"",
"if",
"\"tolerance\"",
"in",
"ci",
":",
"tolerance",
"=",
"ci",
"[",
"'tolerance'",
"]",
"if",
"withSoll",
":",
"try",
":",
"sollValue",
"=",
"md",
".",
"current",
".",
"tolerance",
".",
"get",
"(",
"\"soll\"",
")",
".",
"get",
"(",
"\"value\"",
",",
"np",
".",
"nan",
")",
"except",
":",
"sollValue",
"=",
"np",
".",
"nan",
"if",
"sollValue",
":",
"df",
"[",
"ci",
"[",
"'field'",
"]",
"+",
"\"_soll\"",
"]",
"=",
"sollValue",
"df",
"[",
"ci",
"[",
"'field'",
"]",
"+",
"\"_acceptance\"",
"]",
"=",
"df",
"[",
"ci",
"[",
"'field'",
"]",
"]",
".",
"apply",
"(",
"self",
".",
"check_tolerance",
",",
"args",
"=",
"[",
"md",
".",
"current",
".",
"get",
"(",
"\"tolerance\"",
",",
"None",
")",
",",
"tolerance",
"]",
")",
"# und in passed anzeigen",
"#df[ ci['field'] + \"_passed\" ] = df[ ci['field'] + \"_acceptance\" ].apply( lambda x: 999 if 888 else self.icons[ x ] )",
"df",
"[",
"ci",
"[",
"'field'",
"]",
"+",
"\"_passed\"",
"]",
"=",
"df",
"[",
"ci",
"[",
"'field'",
"]",
"+",
"\"_acceptance\"",
"]",
".",
"apply",
"(",
"self",
".",
"getIcon",
")",
"# das feld in fullCheck einfügen",
"fullCheck",
".",
"append",
"(",
"ci",
"[",
"'field'",
"]",
"+",
"\"_acceptance\"",
")",
"minAll",
"=",
"df",
"[",
"fullCheck",
"]",
".",
"min",
"(",
"axis",
"=",
"None",
",",
"skipna",
"=",
"True",
")",
"acceptance",
"=",
"minAll",
".",
"min",
"(",
")",
"#print(\"check_acceptance\",df, acceptance )",
"return",
"acceptance"
] | [
568,
4
] | [
633,
25
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
Setzer.setzen0_alles | (self) | Alle Eingänge und Ausgänge auf 0 setzen | Alle Eingänge und Ausgänge auf 0 setzen | def setzen0_alles(self):
""" Alle Eingänge und Ausgänge auf 0 setzen """
self.setzen0_eingaenge()
self.setzen0_ausgaenge() | [
"def",
"setzen0_alles",
"(",
"self",
")",
":",
"self",
".",
"setzen0_eingaenge",
"(",
")",
"self",
".",
"setzen0_ausgaenge",
"(",
")"
] | [
40,
4
] | [
43,
32
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
|
option | (values: dict, data: StepData) | Führt die aufgeführten `"transform"`-Funktionen aus, je nachdem ob ein bestimmter Wert `"true"` oder `"false"` ist.
Wenn der Wert, der in `"check"` steht `"true"` ist, werden die `"transform"`-Funktionen ausgeführt,
die unter `"on_true"` stehen.
Wenn der Wert, der in `"check"` steht `"false"` ist, werden die `"transform"`-Funktionen ausgeführt,
die unter `"on_false"` stehen.
:param values: Werte aus der JSON-Datei
:param data: Daten aus der API
| Führt die aufgeführten `"transform"`-Funktionen aus, je nachdem ob ein bestimmter Wert `"true"` oder `"false"` ist. | def option(values: dict, data: StepData):
"""Führt die aufgeführten `"transform"`-Funktionen aus, je nachdem ob ein bestimmter Wert `"true"` oder `"false"` ist.
Wenn der Wert, der in `"check"` steht `"true"` ist, werden die `"transform"`-Funktionen ausgeführt,
die unter `"on_true"` stehen.
Wenn der Wert, der in `"check"` steht `"false"` ist, werden die `"transform"`-Funktionen ausgeführt,
die unter `"on_false"` stehen.
:param values: Werte aus der JSON-Datei
:param data: Daten aus der API
"""
values["transform"] = execute_type_option(values, data)
transform(values, data) | [
"def",
"option",
"(",
"values",
":",
"dict",
",",
"data",
":",
"StepData",
")",
":",
"values",
"[",
"\"transform\"",
"]",
"=",
"execute_type_option",
"(",
"values",
",",
"data",
")",
"transform",
"(",
"values",
",",
"data",
")"
] | [
441,
0
] | [
454,
27
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
|
Geometry.is_airgap | (self, center, radius, startangle, endangle, circle, atol) | return (ok, borders) | Die Funktion untersucht, ob sich der Parameter circle in einem
Luftspalt befindet.
| Die Funktion untersucht, ob sich der Parameter circle in einem
Luftspalt befindet.
| def is_airgap(self, center, radius, startangle, endangle, circle, atol):
""" Die Funktion untersucht, ob sich der Parameter circle in einem
Luftspalt befindet.
"""
ok = True
borders = 0
for e in self.elements(Shape):
for p in e.intersect_circle(circle, 0.0, atol, True):
if not self.is_border_line(center,
startangle, endangle,
e, atol):
logger.warning("BAD: Point %s", p)
self.airgaps.append(Point(p))
self.airgaps.append(e)
ok = False
else:
borders += 1
return (ok, borders) | [
"def",
"is_airgap",
"(",
"self",
",",
"center",
",",
"radius",
",",
"startangle",
",",
"endangle",
",",
"circle",
",",
"atol",
")",
":",
"ok",
"=",
"True",
"borders",
"=",
"0",
"for",
"e",
"in",
"self",
".",
"elements",
"(",
"Shape",
")",
":",
"for",
"p",
"in",
"e",
".",
"intersect_circle",
"(",
"circle",
",",
"0.0",
",",
"atol",
",",
"True",
")",
":",
"if",
"not",
"self",
".",
"is_border_line",
"(",
"center",
",",
"startangle",
",",
"endangle",
",",
"e",
",",
"atol",
")",
":",
"logger",
".",
"warning",
"(",
"\"BAD: Point %s\"",
",",
"p",
")",
"self",
".",
"airgaps",
".",
"append",
"(",
"Point",
"(",
"p",
")",
")",
"self",
".",
"airgaps",
".",
"append",
"(",
"e",
")",
"ok",
"=",
"False",
"else",
":",
"borders",
"+=",
"1",
"return",
"(",
"ok",
",",
"borders",
")"
] | [
2446,
4
] | [
2463,
28
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
Jahr.__init__ | (self, jahr: int, zeitrechnung: Zeitrechnung = A_Z) | Klasse zum verwalten einer Jahreszahl einer Zeitrechnung
@jahr: int: Das Jahr, das gespeichert werden soll
@zeitrechnung: Zeitrechnung: Die Zeitrechnung des Jahres, Standard ist die Allgemeine Zeitrechnung
:raises TypeError: Wird geworfen, wenn keine Zeitrechnung gegeben wurde
:raises JahrKeineGanzeZahl: Wird geworfen, wenn das Jahr keine ganze Zahl ist
| Klasse zum verwalten einer Jahreszahl einer Zeitrechnung | def __init__(self, jahr: int, zeitrechnung: Zeitrechnung = A_Z):
"""Klasse zum verwalten einer Jahreszahl einer Zeitrechnung
@jahr: int: Das Jahr, das gespeichert werden soll
@zeitrechnung: Zeitrechnung: Die Zeitrechnung des Jahres, Standard ist die Allgemeine Zeitrechnung
:raises TypeError: Wird geworfen, wenn keine Zeitrechnung gegeben wurde
:raises JahrKeineGanzeZahl: Wird geworfen, wenn das Jahr keine ganze Zahl ist
"""
self.__jahr: [int, None] = None
self.__zeitrechnung: Zeitrechnung = zeitrechnung
self.jahr = jahr
self.zeitrechnung = zeitrechnung
pass | [
"def",
"__init__",
"(",
"self",
",",
"jahr",
":",
"int",
",",
"zeitrechnung",
":",
"Zeitrechnung",
"=",
"A_Z",
")",
":",
"self",
".",
"__jahr",
":",
"[",
"int",
",",
"None",
"]",
"=",
"None",
"self",
".",
"__zeitrechnung",
":",
"Zeitrechnung",
"=",
"zeitrechnung",
"self",
".",
"jahr",
"=",
"jahr",
"self",
".",
"zeitrechnung",
"=",
"zeitrechnung",
"pass"
] | [
6,
4
] | [
20,
12
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
|
IntelHexParser.load_hex_data | (self, file) | liest die Daten aus einer Datei im Intel-Hex Format | liest die Daten aus einer Datei im Intel-Hex Format | def load_hex_data(self, file):
""" liest die Daten aus einer Datei im Intel-Hex Format """
segmentdata = []
currentAddr = 0
startAddr = 0
for line in file:
l = line.strip("\n\r")
# Leerzeilen herausfiltern
if len(l) == 0:
continue
if l[0] != ':' or len(l) < 11:
raise HexParserException("File Format Error.")
length = int(l[1:3], 16)
address = int(l[3:7], 16)
linetype = int(l[7:9], 16)
#checksum = int(l[-2:], 16)
if len(l) != (11 + 2*length):
raise HexParserException("Invaild Line Length.")
# Checksumme ueberpruefen
bb = [int(l[i:i+2], 16) for i in range(1, len(l), 2)]
crc = functools.reduce(lambda x, y: x+y, bb, 0)
crc &= 0x0FF
if crc != 0:
raise HexParserException("Checksum Error.")
if linetype == 0x00:
if currentAddr != address:
if segmentdata:
self.segments.append( Segment(startAddr, ''.join(segmentdata)) )
startAddr = currentAddr = address
segmentdata = []
for i in range(length):
segmentdata.append( chr(int(l[9+2*i:11+2*i],16)) )
currentAddr = length + currentAddr
elif linetype == 0x01:
# Ende der Hexdaten
if length == 0:
break
else:
raise HexParserException("Invalid End-of-File Record")
elif linetype in (0x02, 0x03, 0x04):
pass
else:
sys.stderr.write("Ignored unknown field (type 0x%02x) in ihex file.\n" % linetype)
if segmentdata:
self.segments.append( Segment(startAddr, ''.join(segmentdata)) ) | [
"def",
"load_hex_data",
"(",
"self",
",",
"file",
")",
":",
"segmentdata",
"=",
"[",
"]",
"currentAddr",
"=",
"0",
"startAddr",
"=",
"0",
"for",
"line",
"in",
"file",
":",
"l",
"=",
"line",
".",
"strip",
"(",
"\"\\n\\r\"",
")",
"# Leerzeilen herausfiltern",
"if",
"len",
"(",
"l",
")",
"==",
"0",
":",
"continue",
"if",
"l",
"[",
"0",
"]",
"!=",
"':'",
"or",
"len",
"(",
"l",
")",
"<",
"11",
":",
"raise",
"HexParserException",
"(",
"\"File Format Error.\"",
")",
"length",
"=",
"int",
"(",
"l",
"[",
"1",
":",
"3",
"]",
",",
"16",
")",
"address",
"=",
"int",
"(",
"l",
"[",
"3",
":",
"7",
"]",
",",
"16",
")",
"linetype",
"=",
"int",
"(",
"l",
"[",
"7",
":",
"9",
"]",
",",
"16",
")",
"#checksum = int(l[-2:], 16)",
"if",
"len",
"(",
"l",
")",
"!=",
"(",
"11",
"+",
"2",
"*",
"length",
")",
":",
"raise",
"HexParserException",
"(",
"\"Invaild Line Length.\"",
")",
"# Checksumme ueberpruefen",
"bb",
"=",
"[",
"int",
"(",
"l",
"[",
"i",
":",
"i",
"+",
"2",
"]",
",",
"16",
")",
"for",
"i",
"in",
"range",
"(",
"1",
",",
"len",
"(",
"l",
")",
",",
"2",
")",
"]",
"crc",
"=",
"functools",
".",
"reduce",
"(",
"lambda",
"x",
",",
"y",
":",
"x",
"+",
"y",
",",
"bb",
",",
"0",
")",
"crc",
"&=",
"0x0FF",
"if",
"crc",
"!=",
"0",
":",
"raise",
"HexParserException",
"(",
"\"Checksum Error.\"",
")",
"if",
"linetype",
"==",
"0x00",
":",
"if",
"currentAddr",
"!=",
"address",
":",
"if",
"segmentdata",
":",
"self",
".",
"segments",
".",
"append",
"(",
"Segment",
"(",
"startAddr",
",",
"''",
".",
"join",
"(",
"segmentdata",
")",
")",
")",
"startAddr",
"=",
"currentAddr",
"=",
"address",
"segmentdata",
"=",
"[",
"]",
"for",
"i",
"in",
"range",
"(",
"length",
")",
":",
"segmentdata",
".",
"append",
"(",
"chr",
"(",
"int",
"(",
"l",
"[",
"9",
"+",
"2",
"*",
"i",
":",
"11",
"+",
"2",
"*",
"i",
"]",
",",
"16",
")",
")",
")",
"currentAddr",
"=",
"length",
"+",
"currentAddr",
"elif",
"linetype",
"==",
"0x01",
":",
"# Ende der Hexdaten",
"if",
"length",
"==",
"0",
":",
"break",
"else",
":",
"raise",
"HexParserException",
"(",
"\"Invalid End-of-File Record\"",
")",
"elif",
"linetype",
"in",
"(",
"0x02",
",",
"0x03",
",",
"0x04",
")",
":",
"pass",
"else",
":",
"sys",
".",
"stderr",
".",
"write",
"(",
"\"Ignored unknown field (type 0x%02x) in ihex file.\\n\"",
"%",
"linetype",
")",
"if",
"segmentdata",
":",
"self",
".",
"segments",
".",
"append",
"(",
"Segment",
"(",
"startAddr",
",",
"''",
".",
"join",
"(",
"segmentdata",
")",
")",
")"
] | [
55,
4
] | [
108,
76
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
|
Zeitrechnung.__init__ | (self, name: str, kuerzel: str, delta: int) | Klasse zum verwalten einer Zeitrechnung
@name: str: Der Name der Zeitrechnung
@kuerzel: str: Die Abkuerzung der Zeitrechnung
@delta: int: der Jahresunterschied zur Allgemeinen Zeitrechnung
| Klasse zum verwalten einer Zeitrechnung | def __init__(self, name: str, kuerzel: str, delta: int):
"""Klasse zum verwalten einer Zeitrechnung
@name: str: Der Name der Zeitrechnung
@kuerzel: str: Die Abkuerzung der Zeitrechnung
@delta: int: der Jahresunterschied zur Allgemeinen Zeitrechnung
"""
# Der Name der Zeitrechnung
self.__name: str = name
# Die Abkuerzung der Zeitrechnung
self.__kuerzel: str = kuerzel
# Der Unterschied an Jahren von dieser zur Allgemeinen Zeitrechnung
self.__delta: int = delta
pass | [
"def",
"__init__",
"(",
"self",
",",
"name",
":",
"str",
",",
"kuerzel",
":",
"str",
",",
"delta",
":",
"int",
")",
":",
"# Der Name der Zeitrechnung",
"self",
".",
"__name",
":",
"str",
"=",
"name",
"# Die Abkuerzung der Zeitrechnung",
"self",
".",
"__kuerzel",
":",
"str",
"=",
"kuerzel",
"# Der Unterschied an Jahren von dieser zur Allgemeinen Zeitrechnung",
"self",
".",
"__delta",
":",
"int",
"=",
"delta",
"pass"
] | [
4,
4
] | [
19,
12
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
|
lese_basiszinzsatz_und_persoenlichen_steuersatz | (configname) | return basiszinsen, pers_satz | Lese Basiszinzsatz und persönlichen Steuersatz aus INI-Datei
:param configname: Name der INI-Datei
:type configname: str
:return: Werte
:rtype: dict, float
| Lese Basiszinzsatz und persönlichen Steuersatz aus INI-Datei | def lese_basiszinzsatz_und_persoenlichen_steuersatz(configname):
""" Lese Basiszinzsatz und persönlichen Steuersatz aus INI-Datei
:param configname: Name der INI-Datei
:type configname: str
:return: Werte
:rtype: dict, float
"""
basis_config = configparser.ConfigParser()
basis_config.read([configname, ])
# Basiszinssätze einlesen
basiszinsen = None
secs = basis_config.sections()
if not BASISZINS_SECTION in secs:
print("Fehler: Keine Basiszinsen in der Konfigurationsdatei", configname)
sys.exit(1)
else:
basiszinsen = lese_abschnitt_basiszinsen(
basis_config[BASISZINS_SECTION])
# Persönlicher Steuersatz
pers_satz = 26.375 # Standardwert
if PERS_STEUERSATZ_SECTION in secs:
s = basis_config[PERS_STEUERSATZ_SECTION].get(PRES_STEUERSATZ_KEY, raw=True)
pers_satz = prozent_conv(s)
return basiszinsen, pers_satz | [
"def",
"lese_basiszinzsatz_und_persoenlichen_steuersatz",
"(",
"configname",
")",
":",
"basis_config",
"=",
"configparser",
".",
"ConfigParser",
"(",
")",
"basis_config",
".",
"read",
"(",
"[",
"configname",
",",
"]",
")",
"# Basiszinssätze einlesen",
"basiszinsen",
"=",
"None",
"secs",
"=",
"basis_config",
".",
"sections",
"(",
")",
"if",
"not",
"BASISZINS_SECTION",
"in",
"secs",
":",
"print",
"(",
"\"Fehler: Keine Basiszinsen in der Konfigurationsdatei\"",
",",
"configname",
")",
"sys",
".",
"exit",
"(",
"1",
")",
"else",
":",
"basiszinsen",
"=",
"lese_abschnitt_basiszinsen",
"(",
"basis_config",
"[",
"BASISZINS_SECTION",
"]",
")",
"# Persönlicher Steuersatz",
"pers_satz",
"=",
"26.375",
"# Standardwert",
"if",
"PERS_STEUERSATZ_SECTION",
"in",
"secs",
":",
"s",
"=",
"basis_config",
"[",
"PERS_STEUERSATZ_SECTION",
"]",
".",
"get",
"(",
"PRES_STEUERSATZ_KEY",
",",
"raw",
"=",
"True",
")",
"pers_satz",
"=",
"prozent_conv",
"(",
"s",
")",
"return",
"basiszinsen",
",",
"pers_satz"
] | [
227,
0
] | [
257,
33
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
PdfGenerator.icon | (self, name="", options="", area:dict={}, attrs:dict={}, render=None) | return self._text( text, area, attrs, render ) | Ein Material Design Icon einfügen.
Beispiel::
icon( "mdi-check-outline", "x4")
Parameters
----------
name : str
Name des Icons
options: str
Zusätzliche class Eigenschaften
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
Returns
-------
str : html
Der html Code für das erzeugte Icon
| Ein Material Design Icon einfügen. | def icon(self, name="", options="", area:dict={}, attrs:dict={}, render=None):
"""Ein Material Design Icon einfügen.
Beispiel::
icon( "mdi-check-outline", "x4")
Parameters
----------
name : str
Name des Icons
options: str
Zusätzliche class Eigenschaften
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
Returns
-------
str : html
Der html Code für das erzeugte Icon
"""
text = '<i class="mdi {} {}"></i>'.format( name, options )
return self._text( text, area, attrs, render ) | [
"def",
"icon",
"(",
"self",
",",
"name",
"=",
"\"\"",
",",
"options",
"=",
"\"\"",
",",
"area",
":",
"dict",
"=",
"{",
"}",
",",
"attrs",
":",
"dict",
"=",
"{",
"}",
",",
"render",
"=",
"None",
")",
":",
"text",
"=",
"'<i class=\"mdi {} {}\"></i>'",
".",
"format",
"(",
"name",
",",
"options",
")",
"return",
"self",
".",
"_text",
"(",
"text",
",",
"area",
",",
"attrs",
",",
"render",
")"
] | [
1307,
4
] | [
1333,
54
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
lower_case | (values: dict, data: StepData) | Jedes Wort in der Liste wird komplett in Kleinbuchstaben geschrieben.
:param values: Werte aus der JSON-Datei
:param data: Daten aus der API
:return:
| Jedes Wort in der Liste wird komplett in Kleinbuchstaben geschrieben. | def lower_case(values: dict, data: StepData):
"""Jedes Wort in der Liste wird komplett in Kleinbuchstaben geschrieben.
:param values: Werte aus der JSON-Datei
:param data: Daten aus der API
:return:
"""
for idx, key in data.loop_key(values["keys"], values):
value = data.get_data(key, values)
new_key = get_new_keys(values, idx)
new_value = [each.lower() for each in value]
data.insert_data(new_key, new_value, values) | [
"def",
"lower_case",
"(",
"values",
":",
"dict",
",",
"data",
":",
"StepData",
")",
":",
"for",
"idx",
",",
"key",
"in",
"data",
".",
"loop_key",
"(",
"values",
"[",
"\"keys\"",
"]",
",",
"values",
")",
":",
"value",
"=",
"data",
".",
"get_data",
"(",
"key",
",",
"values",
")",
"new_key",
"=",
"get_new_keys",
"(",
"values",
",",
"idx",
")",
"new_value",
"=",
"[",
"each",
".",
"lower",
"(",
")",
"for",
"each",
"in",
"value",
"]",
"data",
".",
"insert_data",
"(",
"new_key",
",",
"new_value",
",",
"values",
")"
] | [
669,
0
] | [
681,
52
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
|
read_csv | (path, max_rows=-1, delimiter=',') | Lies CSV zeilenweise ein
Arguments:
path (str): Pfad zur CSV-Datei
max_rows (int, default=-1): Maximale Anzahl an Zeilen.
Beim Default-Wert wird die ganze Datei eingelesen.
Yields:
row (list): Zeile der CSV-Datei
| Lies CSV zeilenweise ein | def read_csv(path, max_rows=-1, delimiter=','):
"""Lies CSV zeilenweise ein
Arguments:
path (str): Pfad zur CSV-Datei
max_rows (int, default=-1): Maximale Anzahl an Zeilen.
Beim Default-Wert wird die ganze Datei eingelesen.
Yields:
row (list): Zeile der CSV-Datei
"""
with open(path, 'r', newline='', encoding='utf-8') as f_in:
csv_reader = csv.reader(f_in, delimiter=delimiter)
next(csv_reader)
for i, row in enumerate(csv_reader):
if i == max_rows:
break
yield row | [
"def",
"read_csv",
"(",
"path",
",",
"max_rows",
"=",
"-",
"1",
",",
"delimiter",
"=",
"','",
")",
":",
"with",
"open",
"(",
"path",
",",
"'r'",
",",
"newline",
"=",
"''",
",",
"encoding",
"=",
"'utf-8'",
")",
"as",
"f_in",
":",
"csv_reader",
"=",
"csv",
".",
"reader",
"(",
"f_in",
",",
"delimiter",
"=",
"delimiter",
")",
"next",
"(",
"csv_reader",
")",
"for",
"i",
",",
"row",
"in",
"enumerate",
"(",
"csv_reader",
")",
":",
"if",
"i",
"==",
"max_rows",
":",
"break",
"yield",
"row"
] | [
19,
0
] | [
38,
21
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
|
suite | ( testClass:None ) | return suite | Fügt alle Funktionen, die mit test_ beginnen aus der angegeben Klasse der suite hinzu
Parameters
----------
testClass : unittest.TestCase
Zu testende Klasse
Returns
-------
suite : unittest.TestSuite
| Fügt alle Funktionen, die mit test_ beginnen aus der angegeben Klasse der suite hinzu
| def suite( testClass:None ):
'''Fügt alle Funktionen, die mit test_ beginnen aus der angegeben Klasse der suite hinzu
Parameters
----------
testClass : unittest.TestCase
Zu testende Klasse
Returns
-------
suite : unittest.TestSuite
'''
if not testClass:
testClass = ispTest
suite = unittest.TestSuite( )
logger.setLevel( logging.ERROR ) # ERROR DEBUG WARNING
if testClass:
#suite.addTest( testClass('test_config_jinja') )
#suite.addTest( testClass('check_weasyprint') )
#suite.addTest( testClass('test_webapp_db_tests_C') )
#suite.addTest( testClass('test_webapp_db_tests_B') )
#return suite
for m in dir( testClass ):
if m.startswith('test_config_'):
suite.addTest( testClass(m), )
pass
elif m.startswith('test_webapp_base_'):
suite.addTest( testClass(m), )
pass
elif m.startswith('test_webapp_dummy_'):
suite.addTest( testClass(m), )
pass
elif m.startswith('test_webapp_db_'):
suite.addTest( testClass(m), )
pass
elif m.startswith('test_isp_mpdf_'):
suite.addTest( testClass(m), )
pass
return suite | [
"def",
"suite",
"(",
"testClass",
":",
"None",
")",
":",
"if",
"not",
"testClass",
":",
"testClass",
"=",
"ispTest",
"suite",
"=",
"unittest",
".",
"TestSuite",
"(",
")",
"logger",
".",
"setLevel",
"(",
"logging",
".",
"ERROR",
")",
"# ERROR DEBUG WARNING ",
"if",
"testClass",
":",
"#suite.addTest( testClass('test_config_jinja') )",
"#suite.addTest( testClass('check_weasyprint') )",
"#suite.addTest( testClass('test_webapp_db_tests_C') )",
"#suite.addTest( testClass('test_webapp_db_tests_B') )",
"#return suite",
"for",
"m",
"in",
"dir",
"(",
"testClass",
")",
":",
"if",
"m",
".",
"startswith",
"(",
"'test_config_'",
")",
":",
"suite",
".",
"addTest",
"(",
"testClass",
"(",
"m",
")",
",",
")",
"pass",
"elif",
"m",
".",
"startswith",
"(",
"'test_webapp_base_'",
")",
":",
"suite",
".",
"addTest",
"(",
"testClass",
"(",
"m",
")",
",",
")",
"pass",
"elif",
"m",
".",
"startswith",
"(",
"'test_webapp_dummy_'",
")",
":",
"suite",
".",
"addTest",
"(",
"testClass",
"(",
"m",
")",
",",
")",
"pass",
"elif",
"m",
".",
"startswith",
"(",
"'test_webapp_db_'",
")",
":",
"suite",
".",
"addTest",
"(",
"testClass",
"(",
"m",
")",
",",
")",
"pass",
"elif",
"m",
".",
"startswith",
"(",
"'test_isp_mpdf_'",
")",
":",
"suite",
".",
"addTest",
"(",
"testClass",
"(",
"m",
")",
",",
")",
"pass",
"return",
"suite"
] | [
2560,
0
] | [
2607,
16
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
most_common | (values: dict, data: StepData) | Sortiert die Wörter nach der Häufigkeit, optional mit Häufigkeit.
:param values: Werte aus der JSON-Datei
:param data: Daten aus der API
:return:
| Sortiert die Wörter nach der Häufigkeit, optional mit Häufigkeit. | def most_common(values: dict, data: StepData):
"""Sortiert die Wörter nach der Häufigkeit, optional mit Häufigkeit.
:param values: Werte aus der JSON-Datei
:param data: Daten aus der API
:return:
"""
for idx, key in data.loop_key(values["keys"], values):
value = data.get_data(key, values)
new_key = get_new_keys(values, idx)
most_c_list = Counter(value).most_common()
if data.get_data(values.get("include_count", False), values, bool):
new_value = most_c_list
else:
new_value = [elm[0] for elm in most_c_list]
data.insert_data(new_key, new_value, values) | [
"def",
"most_common",
"(",
"values",
":",
"dict",
",",
"data",
":",
"StepData",
")",
":",
"for",
"idx",
",",
"key",
"in",
"data",
".",
"loop_key",
"(",
"values",
"[",
"\"keys\"",
"]",
",",
"values",
")",
":",
"value",
"=",
"data",
".",
"get_data",
"(",
"key",
",",
"values",
")",
"new_key",
"=",
"get_new_keys",
"(",
"values",
",",
"idx",
")",
"most_c_list",
"=",
"Counter",
"(",
"value",
")",
".",
"most_common",
"(",
")",
"if",
"data",
".",
"get_data",
"(",
"values",
".",
"get",
"(",
"\"include_count\"",
",",
"False",
")",
",",
"values",
",",
"bool",
")",
":",
"new_value",
"=",
"most_c_list",
"else",
":",
"new_value",
"=",
"[",
"elm",
"[",
"0",
"]",
"for",
"elm",
"in",
"most_c_list",
"]",
"data",
".",
"insert_data",
"(",
"new_key",
",",
"new_value",
",",
"values",
")"
] | [
543,
0
] | [
561,
52
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
|
objectsum | (objektliste, feldliste) | return objectfunc(sum, objektliste, feldliste) | Für jedes property in `feldliste` der Objekte in `objektliste` die Summe ermitteln. | Für jedes property in `feldliste` der Objekte in `objektliste` die Summe ermitteln. | def objectsum(objektliste, feldliste):
"""Für jedes property in `feldliste` der Objekte in `objektliste` die Summe ermitteln."""
return objectfunc(sum, objektliste, feldliste) | [
"def",
"objectsum",
"(",
"objektliste",
",",
"feldliste",
")",
":",
"return",
"objectfunc",
"(",
"sum",
",",
"objektliste",
",",
"feldliste",
")"
] | [
179,
0
] | [
182,
50
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
ispSAFRS.appInfo | (cls, title:str="", detail:str="", status_code:int=None) | App-Info Informationen anfügen.
Parameters
----------
title : str, optional
Message Bereich. The default is "".
detail : str, optional
Info Bereich. The default is "".
status_code: int, optional
Wenn gesetzt der http statuscode
Returns
-------
None.
| App-Info Informationen anfügen. | def appInfo(cls, title:str="", detail:str="", status_code:int=None):
"""App-Info Informationen anfügen.
Parameters
----------
title : str, optional
Message Bereich. The default is "".
detail : str, optional
Info Bereich. The default is "".
status_code: int, optional
Wenn gesetzt der http statuscode
Returns
-------
None.
"""
cls._int_add_meta( "App-Info", title, detail, status_code ) | [
"def",
"appInfo",
"(",
"cls",
",",
"title",
":",
"str",
"=",
"\"\"",
",",
"detail",
":",
"str",
"=",
"\"\"",
",",
"status_code",
":",
"int",
"=",
"None",
")",
":",
"cls",
".",
"_int_add_meta",
"(",
"\"App-Info\"",
",",
"title",
",",
"detail",
",",
"status_code",
")"
] | [
853,
4
] | [
870,
67
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
|
ImageTaggingCNN._classifier_block | (self, input, name_of_output, num_of_output_neurons, num_of_neurons=1024) | return Dense(
units=num_of_output_neurons,
activation='softmax',
name=name_of_output)(x) | Erzeugt 3 FC Layer mit ReLU in den ersten 2 und Softmax Activation im Letzten Layer
:tensor|list input: Die Tensoren aus vorherigen Layer
:string name_of_output: Name des Output Layers
:int num_of_output_neurons: Die Anzahl der zu Klassifizierenden Klassen
:int num_of_neurons: Die Anzahl der Neuronen der hidden Layer
| Erzeugt 3 FC Layer mit ReLU in den ersten 2 und Softmax Activation im Letzten Layer | def _classifier_block(self, input, name_of_output, num_of_output_neurons, num_of_neurons=1024):
""" Erzeugt 3 FC Layer mit ReLU in den ersten 2 und Softmax Activation im Letzten Layer
:tensor|list input: Die Tensoren aus vorherigen Layer
:string name_of_output: Name des Output Layers
:int num_of_output_neurons: Die Anzahl der zu Klassifizierenden Klassen
:int num_of_neurons: Die Anzahl der Neuronen der hidden Layer
"""
x = Dense(
units=num_of_neurons,
activation='relu')(input)
x = Dense(
units=num_of_neurons,
activation='relu')(x)
return Dense(
units=num_of_output_neurons,
activation='softmax',
name=name_of_output)(x) | [
"def",
"_classifier_block",
"(",
"self",
",",
"input",
",",
"name_of_output",
",",
"num_of_output_neurons",
",",
"num_of_neurons",
"=",
"1024",
")",
":",
"x",
"=",
"Dense",
"(",
"units",
"=",
"num_of_neurons",
",",
"activation",
"=",
"'relu'",
")",
"(",
"input",
")",
"x",
"=",
"Dense",
"(",
"units",
"=",
"num_of_neurons",
",",
"activation",
"=",
"'relu'",
")",
"(",
"x",
")",
"return",
"Dense",
"(",
"units",
"=",
"num_of_output_neurons",
",",
"activation",
"=",
"'softmax'",
",",
"name",
"=",
"name_of_output",
")",
"(",
"x",
")"
] | [
71,
4
] | [
88,
35
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
WebAppTest.test_other_Matrix | (self) | Gibt eine Liste alle Testbeschreibungen (config) mit Anleitungen
| Gibt eine Liste alle Testbeschreibungen (config) mit Anleitungen
| def test_other_Matrix(self):
''' Gibt eine Liste alle Testbeschreibungen (config) mit Anleitungen
'''
url = '/api/gqa/matrix'
# als json
response = self.app.get( url, query_string = {} )
self.assertEqual(response.status_code, 200, "Api Rückgabe fehlerhaft")
# als html
response = self.app.get( url, query_string = {"format": "html"} )
self.assertEqual(response.status_code, 200, "Api Rückgabe fehlerhaft") | [
"def",
"test_other_Matrix",
"(",
"self",
")",
":",
"url",
"=",
"'/api/gqa/matrix'",
"# als json",
"response",
"=",
"self",
".",
"app",
".",
"get",
"(",
"url",
",",
"query_string",
"=",
"{",
"}",
")",
"self",
".",
"assertEqual",
"(",
"response",
".",
"status_code",
",",
"200",
",",
"\"Api Rückgabe fehlerhaft\")",
" ",
"# als html",
"response",
"=",
"self",
".",
"app",
".",
"get",
"(",
"url",
",",
"query_string",
"=",
"{",
"\"format\"",
":",
"\"html\"",
"}",
")",
"self",
".",
"assertEqual",
"(",
"response",
".",
"status_code",
",",
"200",
",",
"\"Api Rückgabe fehlerhaft\")",
" "
] | [
438,
4
] | [
449,
79
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
|
open_con | () | return con | Öffnet DB-Verbindung außerhalb des Flask-Kontexts.
Dieese Methode wird u.a. für den DB-Scheduler benötigt, welcher unabhängig vom Flask-Server ausgeführt wird.
| Öffnet DB-Verbindung außerhalb des Flask-Kontexts. | def open_con():
""" Öffnet DB-Verbindung außerhalb des Flask-Kontexts.
Dieese Methode wird u.a. für den DB-Scheduler benötigt, welcher unabhängig vom Flask-Server ausgeführt wird.
"""
con = sqlite3.connect(
DATABASE_LOCATION,
detect_types=sqlite3.PARSE_DECLTYPES,
)
con.row_factory = sqlite3.Row
return con | [
"def",
"open_con",
"(",
")",
":",
"con",
"=",
"sqlite3",
".",
"connect",
"(",
"DATABASE_LOCATION",
",",
"detect_types",
"=",
"sqlite3",
".",
"PARSE_DECLTYPES",
",",
")",
"con",
".",
"row_factory",
"=",
"sqlite3",
".",
"Row",
"return",
"con"
] | [
13,
0
] | [
23,
14
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
ProgressBar.__str__ | (self) | return str(self.progbar) | Gibt den aktuellen Fortschrittsbalken aus.
Die Laenge des zurueckgegebenen Strings entspricht dem Wert von "width" der
beim erzeugen des Objekts mitgegeben wurde (Standardwert ist 80).
| Gibt den aktuellen Fortschrittsbalken aus. | def __str__(self):
""" Gibt den aktuellen Fortschrittsbalken aus.
Die Laenge des zurueckgegebenen Strings entspricht dem Wert von "width" der
beim erzeugen des Objekts mitgegeben wurde (Standardwert ist 80).
"""
return str(self.progbar) | [
"def",
"__str__",
"(",
"self",
")",
":",
"return",
"str",
"(",
"self",
".",
"progbar",
")"
] | [
68,
4
] | [
74,
32
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
int_or_0 | (data, default=0) | Wandelt "None" in default, lässt alle anderen werte unverändert.
>>> int_or_0(5)
5
>>> int_or_0(None)
0
>>> int_or_0(0)
0
>>> int_or_0(-1)
-1
>>> int_or_0([])
0
>>> int_or_0(tuple())
0
>>> int_or_0(None, default=0xaffe)
45054
| Wandelt "None" in default, lässt alle anderen werte unverändert. | def int_or_0(data, default=0):
"""Wandelt "None" in default, lässt alle anderen werte unverändert.
>>> int_or_0(5)
5
>>> int_or_0(None)
0
>>> int_or_0(0)
0
>>> int_or_0(-1)
-1
>>> int_or_0([])
0
>>> int_or_0(tuple())
0
>>> int_or_0(None, default=0xaffe)
45054
"""
if not data:
return default
try:
if isinstance(data, (ListType, TupleType)):
return int(data[0])
return int(float(data))
except (TypeError, ValueError):
return default | [
"def",
"int_or_0",
"(",
"data",
",",
"default",
"=",
"0",
")",
":",
"if",
"not",
"data",
":",
"return",
"default",
"try",
":",
"if",
"isinstance",
"(",
"data",
",",
"(",
"ListType",
",",
"TupleType",
")",
")",
":",
"return",
"int",
"(",
"data",
"[",
"0",
"]",
")",
"return",
"int",
"(",
"float",
"(",
"data",
")",
")",
"except",
"(",
"TypeError",
",",
"ValueError",
")",
":",
"return",
"default"
] | [
27,
0
] | [
54,
22
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
|
HeistSystem.game_StartHeist | (self, data) | return | Starte das Spiel und/oder fügt neue Spieler hinzu | Starte das Spiel und/oder fügt neue Spieler hinzu | def game_StartHeist(self, data):
''' Starte das Spiel und/oder fügt neue Spieler hinzu '''
thisActionName = "game_StartHeist"
# Spiel ist im Cooldown und es läuft kein Heist - Abbruch
if self.CD.IsOnCooldown(scriptname=self.ScriptName, command=self.ClassName) and (self.GameStartTimestamp == ""):
# Letzte Benachrichtigung ist bereits die eingestellte Zeit vergangen
if not self.CD.IsOnCooldown(scriptname=self.ScriptName, command=self.ClassName + " Supress Message"):
# Nachricht über Cooldown in den Chat schreiben
self.WriteMessage_IsOnCooldown()
# Setze Cooldown-Zeit zur Unterdrückung zu vieler Nachrichten im Chat
self.CD.AddCooldown(scriptname=self.ScriptName,
command=self.ClassName + " Supress Message",
cooldownTime=int(15)
)
return
# Spielerdaten überprüfen
playerData = self.game_NewPlayerData(data=data)
playerExist = self.DB_check_PlayerExist(playerName=data.User)
# Das Kommando wurde falsch aufgerufen - Abbruch
if not playerData:
self.WriteMessage_WrongCommandOption(data=data)
return
# Spieler hat nicht genügend Punkte um am Einsatz teilzunehmen - Abbruch
if playerData["playerStake"] > playerData["currentPlayerPoints"]:
self.WriteMessage_NotEnoughPoints(data=data)
return
# Spieler setzt weniger ein, als das eingestellte Minimum - Abbruch
if not (playerData["belowStake"] == True):
self.Writemessage_StakeBelowMinimum(data=data)
return
### ALLE PRÜFUNGEN WURDEN ERFOLGREICH DURCHGEFÜHRT ###
# --- SPIEL IST BEREITS AKTIV ---
if not (self.GameStartTimestamp == ""):
# Spieler ist noch nicht beigetreten
if not playerExist:
# Spieler muss den Einsatz reduzieren, da über dem maximalen Wert
if playerData["maximumStake"]:
self.WriteMessage_StakeOverMaximum(data=data)
return
# Neuen Spieler in Datenbank eintragen
self.DB_insert_NewPlayer(playerData=playerData)
self.Logger.WriteLog(
" {0} - Neuer Teilnehmer: {1}".format(
thisActionName,
playerData["playerDisplayName"]
))
# Punkte vom Konto des Users abziehen
self.Parent.RemovePoints(playerData["playerName"],
playerData["playerDisplayName"],
playerData["playerStake"])
# Benachrichtigung im Chat
self.Writemessage_NewPlayerEntry(playerData=playerData)
return
# --- NEUES SPIEL STARTEN ---
else:
# Spieler muss den Einsatz reduzieren, da über dem maximalen Wert
if playerData["maximumStake"]:
self.WriteMessage_StakeOverMaximum(data=data)
return
# Zeitstempel in Variable übernehmen
self.GameStartTimestamp = time.time()
# Ziel in Variable übernehmen
self.GameTargetName = self.RandomTarget_ByName()
# GameID in Variable übernehmen
self.GameID = int(self.DB_get_LastID()) + 1
# Ältere Spieldaten löschen
self.DB_delete_Data()
self.Logger.WriteLog(
" {0} - Neues Spiel von {1} gestartet".format(
thisActionName,
playerData["playerDisplayName"]
))
# Neuen Spieler in Datenbank eintragen
self.DB_insert_NewPlayer(playerData=playerData)
# Punkte vom Konto des Users abziehen
self.Parent.RemovePoints(playerData["playerName"],
playerData["playerDisplayName"],
playerData["playerStake"])
# Nachricht in den Chat schreiben
self.Writemessage_NewGameStart(data=data)
return | [
"def",
"game_StartHeist",
"(",
"self",
",",
"data",
")",
":",
"thisActionName",
"=",
"\"game_StartHeist\"",
"# Spiel ist im Cooldown und es läuft kein Heist - Abbruch\r",
"if",
"self",
".",
"CD",
".",
"IsOnCooldown",
"(",
"scriptname",
"=",
"self",
".",
"ScriptName",
",",
"command",
"=",
"self",
".",
"ClassName",
")",
"and",
"(",
"self",
".",
"GameStartTimestamp",
"==",
"\"\"",
")",
":",
"# Letzte Benachrichtigung ist bereits die eingestellte Zeit vergangen\r",
"if",
"not",
"self",
".",
"CD",
".",
"IsOnCooldown",
"(",
"scriptname",
"=",
"self",
".",
"ScriptName",
",",
"command",
"=",
"self",
".",
"ClassName",
"+",
"\" Supress Message\"",
")",
":",
"# Nachricht über Cooldown in den Chat schreiben\r",
"self",
".",
"WriteMessage_IsOnCooldown",
"(",
")",
"# Setze Cooldown-Zeit zur Unterdrückung zu vieler Nachrichten im Chat\r",
"self",
".",
"CD",
".",
"AddCooldown",
"(",
"scriptname",
"=",
"self",
".",
"ScriptName",
",",
"command",
"=",
"self",
".",
"ClassName",
"+",
"\" Supress Message\"",
",",
"cooldownTime",
"=",
"int",
"(",
"15",
")",
")",
"return",
"# Spielerdaten überprüfen\r",
"playerData",
"=",
"self",
".",
"game_NewPlayerData",
"(",
"data",
"=",
"data",
")",
"playerExist",
"=",
"self",
".",
"DB_check_PlayerExist",
"(",
"playerName",
"=",
"data",
".",
"User",
")",
"# Das Kommando wurde falsch aufgerufen - Abbruch\r",
"if",
"not",
"playerData",
":",
"self",
".",
"WriteMessage_WrongCommandOption",
"(",
"data",
"=",
"data",
")",
"return",
"# Spieler hat nicht genügend Punkte um am Einsatz teilzunehmen - Abbruch\r",
"if",
"playerData",
"[",
"\"playerStake\"",
"]",
">",
"playerData",
"[",
"\"currentPlayerPoints\"",
"]",
":",
"self",
".",
"WriteMessage_NotEnoughPoints",
"(",
"data",
"=",
"data",
")",
"return",
"# Spieler setzt weniger ein, als das eingestellte Minimum - Abbruch\r",
"if",
"not",
"(",
"playerData",
"[",
"\"belowStake\"",
"]",
"==",
"True",
")",
":",
"self",
".",
"Writemessage_StakeBelowMinimum",
"(",
"data",
"=",
"data",
")",
"return",
"### ALLE PRÜFUNGEN WURDEN ERFOLGREICH DURCHGEFÜHRT ###\r",
"# --- SPIEL IST BEREITS AKTIV ---\r",
"if",
"not",
"(",
"self",
".",
"GameStartTimestamp",
"==",
"\"\"",
")",
":",
"# Spieler ist noch nicht beigetreten\r",
"if",
"not",
"playerExist",
":",
"# Spieler muss den Einsatz reduzieren, da über dem maximalen Wert\r",
"if",
"playerData",
"[",
"\"maximumStake\"",
"]",
":",
"self",
".",
"WriteMessage_StakeOverMaximum",
"(",
"data",
"=",
"data",
")",
"return",
"# Neuen Spieler in Datenbank eintragen\r",
"self",
".",
"DB_insert_NewPlayer",
"(",
"playerData",
"=",
"playerData",
")",
"self",
".",
"Logger",
".",
"WriteLog",
"(",
"\" {0} - Neuer Teilnehmer: {1}\"",
".",
"format",
"(",
"thisActionName",
",",
"playerData",
"[",
"\"playerDisplayName\"",
"]",
")",
")",
"# Punkte vom Konto des Users abziehen\r",
"self",
".",
"Parent",
".",
"RemovePoints",
"(",
"playerData",
"[",
"\"playerName\"",
"]",
",",
"playerData",
"[",
"\"playerDisplayName\"",
"]",
",",
"playerData",
"[",
"\"playerStake\"",
"]",
")",
"# Benachrichtigung im Chat\r",
"self",
".",
"Writemessage_NewPlayerEntry",
"(",
"playerData",
"=",
"playerData",
")",
"return",
"# --- NEUES SPIEL STARTEN ---\r",
"else",
":",
"# Spieler muss den Einsatz reduzieren, da über dem maximalen Wert\r",
"if",
"playerData",
"[",
"\"maximumStake\"",
"]",
":",
"self",
".",
"WriteMessage_StakeOverMaximum",
"(",
"data",
"=",
"data",
")",
"return",
"# Zeitstempel in Variable übernehmen\r",
"self",
".",
"GameStartTimestamp",
"=",
"time",
".",
"time",
"(",
")",
"# Ziel in Variable übernehmen\r",
"self",
".",
"GameTargetName",
"=",
"self",
".",
"RandomTarget_ByName",
"(",
")",
"# GameID in Variable übernehmen\r",
"self",
".",
"GameID",
"=",
"int",
"(",
"self",
".",
"DB_get_LastID",
"(",
")",
")",
"+",
"1",
"# Ältere Spieldaten löschen\r",
"self",
".",
"DB_delete_Data",
"(",
")",
"self",
".",
"Logger",
".",
"WriteLog",
"(",
"\" {0} - Neues Spiel von {1} gestartet\"",
".",
"format",
"(",
"thisActionName",
",",
"playerData",
"[",
"\"playerDisplayName\"",
"]",
")",
")",
"# Neuen Spieler in Datenbank eintragen\r",
"self",
".",
"DB_insert_NewPlayer",
"(",
"playerData",
"=",
"playerData",
")",
"# Punkte vom Konto des Users abziehen\r",
"self",
".",
"Parent",
".",
"RemovePoints",
"(",
"playerData",
"[",
"\"playerName\"",
"]",
",",
"playerData",
"[",
"\"playerDisplayName\"",
"]",
",",
"playerData",
"[",
"\"playerStake\"",
"]",
")",
"# Nachricht in den Chat schreiben\r",
"self",
".",
"Writemessage_NewGameStart",
"(",
"data",
"=",
"data",
")",
"return"
] | [
1498,
4
] | [
1605,
14
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
StepData.loop_dict | (self, loop_root: dict, values: dict) | return map(lambda value: self.save_loop(value[0], value[1], values), loop_root.items()) | Zum Durchlaufen eines Dictionaries.
Setzt bei jedem Durchlauf die Variablen `_loop` und `_idx`.
`_loop` entspricht dem aktuellen wert und `_idx` dem aktuelle Dictionary-Key.
:param loop_root: Dictionary, das durchlaufen werden soll.
:param values: Werte aus der JSON-Datei
:return: Iterator über das Dictionary, welcher Seiteneffekte besitzt, mit (idx, value).
:rtype: map
| Zum Durchlaufen eines Dictionaries. | def loop_dict(self, loop_root: dict, values: dict):
""" Zum Durchlaufen eines Dictionaries.
Setzt bei jedem Durchlauf die Variablen `_loop` und `_idx`.
`_loop` entspricht dem aktuellen wert und `_idx` dem aktuelle Dictionary-Key.
:param loop_root: Dictionary, das durchlaufen werden soll.
:param values: Werte aus der JSON-Datei
:return: Iterator über das Dictionary, welcher Seiteneffekte besitzt, mit (idx, value).
:rtype: map
"""
return map(lambda value: self.save_loop(value[0], value[1], values), loop_root.items()) | [
"def",
"loop_dict",
"(",
"self",
",",
"loop_root",
":",
"dict",
",",
"values",
":",
"dict",
")",
":",
"return",
"map",
"(",
"lambda",
"value",
":",
"self",
".",
"save_loop",
"(",
"value",
"[",
"0",
"]",
",",
"value",
"[",
"1",
"]",
",",
"values",
")",
",",
"loop_root",
".",
"items",
"(",
")",
")"
] | [
73,
4
] | [
84,
95
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
iso2date | ( value:str=None, toDate:bool=False ) | return result | Wandelt über fromisoformat oder strptime einen String in ein ``datetime`` oder ``date`` Object um.
Versucht zuerst eine Umwandlung über fromisoformat
Bei Fehlern wird versucht es mit strptime umzuwandeln umzuwandeln
Beispiele für Value::
2018-04-15 - datetime.datetime(2018, 4, 15, 0, 0)
2018-04-15 14:36 - datetime.datetime(2018, 4, 15, 14, 36)
2018-04-15 14:36:25 - datetime.datetime(2018, 4, 15, 14, 36, 25)
20180415 - datetime.datetime(2018, 4, 15, 0, 0)
20180415 14:36:25 - datetime.datetime(2018, 4, 15, 14, 36, 25)
20180415 14:36 - datetime.datetime(2018, 4, 15, 14, 36)
20180415 14 - datetime.datetime(2018, 4, 15)
mit toDate=True
2018-04-15 14:36:25 - datetime.date(2018, 4, 15)
20180415 14:36:25 - datetime.date(2018, 4, 15)
Parameters
----------
value : str
String mit Datumsangaben.
toDate : bool
Gibt bei true ein date Object statt datetime zurück. Default is False.
Returns
-------
datetime|None
Umgewandelter ISO String oder None
| Wandelt über fromisoformat oder strptime einen String in ein ``datetime`` oder ``date`` Object um. | def iso2date( value:str=None, toDate:bool=False ):
"""Wandelt über fromisoformat oder strptime einen String in ein ``datetime`` oder ``date`` Object um.
Versucht zuerst eine Umwandlung über fromisoformat
Bei Fehlern wird versucht es mit strptime umzuwandeln umzuwandeln
Beispiele für Value::
2018-04-15 - datetime.datetime(2018, 4, 15, 0, 0)
2018-04-15 14:36 - datetime.datetime(2018, 4, 15, 14, 36)
2018-04-15 14:36:25 - datetime.datetime(2018, 4, 15, 14, 36, 25)
20180415 - datetime.datetime(2018, 4, 15, 0, 0)
20180415 14:36:25 - datetime.datetime(2018, 4, 15, 14, 36, 25)
20180415 14:36 - datetime.datetime(2018, 4, 15, 14, 36)
20180415 14 - datetime.datetime(2018, 4, 15)
mit toDate=True
2018-04-15 14:36:25 - datetime.date(2018, 4, 15)
20180415 14:36:25 - datetime.date(2018, 4, 15)
Parameters
----------
value : str
String mit Datumsangaben.
toDate : bool
Gibt bei true ein date Object statt datetime zurück. Default is False.
Returns
-------
datetime|None
Umgewandelter ISO String oder None
"""
result = None
if value and isinstance(value, str):
try:
result = datetime.fromisoformat( value )
except ValueError:
pass
if not result:
if len(value) >= 17:
try:
result = datetime.strptime(value[:17], "%Y%m%d %H:%M:%S")
except ValueError:
pass
if not result and len(value) >= 14:
try:
result = datetime.strptime(value[:14], "%Y%m%d %H:%M")
except ValueError:
pass
if not result and len(value) >= 8:
try:
result = datetime.strptime(value[:8], "%Y%m%d")
except ValueError:
pass
if result and toDate:
result = result.date()
return result | [
"def",
"iso2date",
"(",
"value",
":",
"str",
"=",
"None",
",",
"toDate",
":",
"bool",
"=",
"False",
")",
":",
"result",
"=",
"None",
"if",
"value",
"and",
"isinstance",
"(",
"value",
",",
"str",
")",
":",
"try",
":",
"result",
"=",
"datetime",
".",
"fromisoformat",
"(",
"value",
")",
"except",
"ValueError",
":",
"pass",
"if",
"not",
"result",
":",
"if",
"len",
"(",
"value",
")",
">=",
"17",
":",
"try",
":",
"result",
"=",
"datetime",
".",
"strptime",
"(",
"value",
"[",
":",
"17",
"]",
",",
"\"%Y%m%d %H:%M:%S\"",
")",
"except",
"ValueError",
":",
"pass",
"if",
"not",
"result",
"and",
"len",
"(",
"value",
")",
">=",
"14",
":",
"try",
":",
"result",
"=",
"datetime",
".",
"strptime",
"(",
"value",
"[",
":",
"14",
"]",
",",
"\"%Y%m%d %H:%M\"",
")",
"except",
"ValueError",
":",
"pass",
"if",
"not",
"result",
"and",
"len",
"(",
"value",
")",
">=",
"8",
":",
"try",
":",
"result",
"=",
"datetime",
".",
"strptime",
"(",
"value",
"[",
":",
"8",
"]",
",",
"\"%Y%m%d\"",
")",
"except",
"ValueError",
":",
"pass",
"if",
"result",
"and",
"toDate",
":",
"result",
"=",
"result",
".",
"date",
"(",
")",
"return",
"result"
] | [
110,
0
] | [
170,
17
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
open_con_f | () | return flask.g.db | Öffnet DB-Verbindung innerhalb des Flask-Kontexts.
Diese Methode wird in den Endpunkt-Handler-Methoden verwendet.
| Öffnet DB-Verbindung innerhalb des Flask-Kontexts. | def open_con_f():
""" Öffnet DB-Verbindung innerhalb des Flask-Kontexts.
Diese Methode wird in den Endpunkt-Handler-Methoden verwendet.
"""
if 'db' not in flask.g:
flask.g.db = sqlite3.connect(
DATABASE_LOCATION,
detect_types=sqlite3.PARSE_DECLTYPES
)
flask.g.db.row_factory = sqlite3.Row
return flask.g.db | [
"def",
"open_con_f",
"(",
")",
":",
"if",
"'db'",
"not",
"in",
"flask",
".",
"g",
":",
"flask",
".",
"g",
".",
"db",
"=",
"sqlite3",
".",
"connect",
"(",
"DATABASE_LOCATION",
",",
"detect_types",
"=",
"sqlite3",
".",
"PARSE_DECLTYPES",
")",
"flask",
".",
"g",
".",
"db",
".",
"row_factory",
"=",
"sqlite3",
".",
"Row",
"return",
"flask",
".",
"g",
".",
"db"
] | [
26,
0
] | [
37,
21
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
ispBaseWebApp.addRoutes | ( self ) | Überschreibbare Funktion um zusätzliche routen einzubinden.
Sample::
def addRoutes( self ):
@self.app.route('/test/<path:filepath>')
def test_route( filepath:str='' ):
return "testroute"
| Überschreibbare Funktion um zusätzliche routen einzubinden. | def addRoutes( self ):
"""Überschreibbare Funktion um zusätzliche routen einzubinden.
Sample::
def addRoutes( self ):
@self.app.route('/test/<path:filepath>')
def test_route( filepath:str='' ):
return "testroute"
"""
pass | [
"def",
"addRoutes",
"(",
"self",
")",
":",
"pass"
] | [
518,
4
] | [
527,
12
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
|
MessagingService._create_service_task | (self) | return MessageHandlerTask(scheduler_mgr.framework_id) | See :meth:`scheduler.tasks.services.service.Service._create_service_task` | See :meth:`scheduler.tasks.services.service.Service._create_service_task` | def _create_service_task(self):
"""See :meth:`scheduler.tasks.services.service.Service._create_service_task`"""
return MessageHandlerTask(scheduler_mgr.framework_id) | [
"def",
"_create_service_task",
"(",
"self",
")",
":",
"return",
"MessageHandlerTask",
"(",
"scheduler_mgr",
".",
"framework_id",
")"
] | [
30,
4
] | [
33,
61
] | null | python | de | ['de', 'de', 'de'] | False | true | null |
qis.check_klausuren | (self, username, password) | return austehende_klausuren, rows | Öffnet die QIS Website und sucht die offenen Klausuren heraus
Args:
username (string): Die FH-ID für das QIS z.B.: ab1234s
password (string): Passwort für die FH Dienste
Returns:
int, <list>: Anzahl der offenen Klausuren, Datenreihen mit Klausurinformationen
| Öffnet die QIS Website und sucht die offenen Klausuren heraus | def check_klausuren(self, username, password):
"""Öffnet die QIS Website und sucht die offenen Klausuren heraus
Args:
username (string): Die FH-ID für das QIS z.B.: ab1234s
password (string): Passwort für die FH Dienste
Returns:
int, <list>: Anzahl der offenen Klausuren, Datenreihen mit Klausurinformationen
"""
print("Starte QIS - Reader ...")
dr = qis.start_browser()
dr.get(url=self.url)
userBox = dr.find_element_by_id("asdf")
userBox.send_keys(username)
passwordBox = dr.find_element_by_id("fdsa")
passwordBox.send_keys(password)
button = dr.find_element_by_id("loginForm:login")
button.click()
#dr.implicitly_wait(2)
print("Erfolgreich eingeloggt..")
exam_button = dr.find_element_by_link_text('Info über angemeldete Prüfungen')
exam_button.click()
#dr.implicitly_wait(2)
dr.find_element_by_xpath('//*[@title="angemeldete Prüfungen anzeigen für Bachelor - Fahrzeug- und Antriebstechnik (PO-Version 2018) "]').click()
#Muss auf jeweiligen Studiengang angepasst werde. Hierzu im QIS das HTML Objekt untersuchen
print("Daten werden gesammelt ..")
#dr.implicitly_wait(2)
time.sleep(1)
soup = bs(dr.page_source, 'lxml')
table = soup.find_all('table')[1]
table_body = table.find('tbody')
rows = table_body.find_all('tr')
austehende_klausuren = len(rows) - 2 #Minus 2 wegen table headers
dr.close()
return austehende_klausuren, rows | [
"def",
"check_klausuren",
"(",
"self",
",",
"username",
",",
"password",
")",
":",
"print",
"(",
"\"Starte QIS - Reader ...\"",
")",
"dr",
"=",
"qis",
".",
"start_browser",
"(",
")",
"dr",
".",
"get",
"(",
"url",
"=",
"self",
".",
"url",
")",
"userBox",
"=",
"dr",
".",
"find_element_by_id",
"(",
"\"asdf\"",
")",
"userBox",
".",
"send_keys",
"(",
"username",
")",
"passwordBox",
"=",
"dr",
".",
"find_element_by_id",
"(",
"\"fdsa\"",
")",
"passwordBox",
".",
"send_keys",
"(",
"password",
")",
"button",
"=",
"dr",
".",
"find_element_by_id",
"(",
"\"loginForm:login\"",
")",
"button",
".",
"click",
"(",
")",
"#dr.implicitly_wait(2)",
"print",
"(",
"\"Erfolgreich eingeloggt..\"",
")",
"exam_button",
"=",
"dr",
".",
"find_element_by_link_text",
"(",
"'Info über angemeldete Prüfungen')",
"",
"exam_button",
".",
"click",
"(",
")",
"#dr.implicitly_wait(2)",
"dr",
".",
"find_element_by_xpath",
"(",
"'//*[@title=\"angemeldete Prüfungen anzeigen für Bachelor - Fahrzeug- und Antriebstechnik (PO-Version 2018) \"]').",
"c",
"l",
"ick()",
"",
"",
"#Muss auf jeweiligen Studiengang angepasst werde. Hierzu im QIS das HTML Objekt untersuchen",
"print",
"(",
"\"Daten werden gesammelt ..\"",
")",
"#dr.implicitly_wait(2)",
"time",
".",
"sleep",
"(",
"1",
")",
"soup",
"=",
"bs",
"(",
"dr",
".",
"page_source",
",",
"'lxml'",
")",
"table",
"=",
"soup",
".",
"find_all",
"(",
"'table'",
")",
"[",
"1",
"]",
"table_body",
"=",
"table",
".",
"find",
"(",
"'tbody'",
")",
"rows",
"=",
"table_body",
".",
"find_all",
"(",
"'tr'",
")",
"austehende_klausuren",
"=",
"len",
"(",
"rows",
")",
"-",
"2",
"#Minus 2 wegen table headers",
"dr",
".",
"close",
"(",
")",
"return",
"austehende_klausuren",
",",
"rows"
] | [
22,
4
] | [
74,
41
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
ispBase.check_tolerance | (self, value, tolerance=None, name="default", row=None ) | return acceptance | Toleranzangaben für value im Bereich name prüfen
und den Wert für acceptance zurückgeben
* 5 - green - very Good (True)
* 4 - green - Good
* 3 - yellow - Sufficient
* 2 - orange - Insufficient
* 1 - red - Fail (False)
* 999 - (n.a.) Not applicable
Parameters
----------
value: int|real
zu prüfender Wert
tolerance: DotMap
info des testaufrufs::
{
name: {
f: formel mit {value}
value: wert
range: [min, max]
operator: [ eq, ne, lt, gt, le, ge]
}
}
Returns
-------
acceptance: int
Varianten::
5 - green - very Good (True)
4 - green - Good
3 - yellow - Sufficient
2 - orange - Insufficient
1 - red - Fail (False)
999 - (n.a.) Not applicable
| Toleranzangaben für value im Bereich name prüfen
und den Wert für acceptance zurückgeben | def check_tolerance(self, value, tolerance=None, name="default", row=None ):
""" Toleranzangaben für value im Bereich name prüfen
und den Wert für acceptance zurückgeben
* 5 - green - very Good (True)
* 4 - green - Good
* 3 - yellow - Sufficient
* 2 - orange - Insufficient
* 1 - red - Fail (False)
* 999 - (n.a.) Not applicable
Parameters
----------
value: int|real
zu prüfender Wert
tolerance: DotMap
info des testaufrufs::
{
name: {
f: formel mit {value}
value: wert
range: [min, max]
operator: [ eq, ne, lt, gt, le, ge]
}
}
Returns
-------
acceptance: int
Varianten::
5 - green - very Good (True)
4 - green - Good
3 - yellow - Sufficient
2 - orange - Insufficient
1 - red - Fail (False)
999 - (n.a.) Not applicable
"""
if not isinstance( value, (int, float) ) or np.isnan( value ) or pd.isnull( value ):
return 999
# erstmal ok
acceptance = 5
if tolerance:
for t in ["warning", "error"]:
try:
f = tolerance.get( name ).get( t ).get("f", None)
except : # pragma: no cover
f = None
if f:
try:
# die formel auswerten und icon ggf überschreiben
if eval( f.format( value=value ) ):
if t == "warning":
acceptance = 3
else:
acceptance = 1
except : # pragma: no cover
acceptance = 0
#print( f.format( value=row ) )
#print("check_tolerance", value, acceptance, tolerance )
return acceptance | [
"def",
"check_tolerance",
"(",
"self",
",",
"value",
",",
"tolerance",
"=",
"None",
",",
"name",
"=",
"\"default\"",
",",
"row",
"=",
"None",
")",
":",
"if",
"not",
"isinstance",
"(",
"value",
",",
"(",
"int",
",",
"float",
")",
")",
"or",
"np",
".",
"isnan",
"(",
"value",
")",
"or",
"pd",
".",
"isnull",
"(",
"value",
")",
":",
"return",
"999",
"# erstmal ok",
"acceptance",
"=",
"5",
"if",
"tolerance",
":",
"for",
"t",
"in",
"[",
"\"warning\"",
",",
"\"error\"",
"]",
":",
"try",
":",
"f",
"=",
"tolerance",
".",
"get",
"(",
"name",
")",
".",
"get",
"(",
"t",
")",
".",
"get",
"(",
"\"f\"",
",",
"None",
")",
"except",
":",
"# pragma: no cover",
"f",
"=",
"None",
"if",
"f",
":",
"try",
":",
"# die formel auswerten und icon ggf überschreiben",
"if",
"eval",
"(",
"f",
".",
"format",
"(",
"value",
"=",
"value",
")",
")",
":",
"if",
"t",
"==",
"\"warning\"",
":",
"acceptance",
"=",
"3",
"else",
":",
"acceptance",
"=",
"1",
"except",
":",
"# pragma: no cover",
"acceptance",
"=",
"0",
"#print( f.format( value=row ) )",
"#print(\"check_tolerance\", value, acceptance, tolerance )",
"return",
"acceptance"
] | [
324,
4
] | [
390,
25
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
plotImage.axTicks | (self, ax, limits:dict={}) | Achsen Beschriftung und Limits ändern.
ohne Angaben in dict Achse entfernen
- xStep, yStep : dict - mit pos:label werden diese gesetzt
- xStep, yStep : int,float - wird der Abstand aus breite/step gebildet
Parameters
----------
ax: axis
das axis element auf das die Änderungen angewandt werden sollen
limits: dict
Elemente: X1, X2, Y1, Y2, xStep, yStep
| Achsen Beschriftung und Limits ändern.
ohne Angaben in dict Achse entfernen
- xStep, yStep : dict - mit pos:label werden diese gesetzt
- xStep, yStep : int,float - wird der Abstand aus breite/step gebildet
Parameters
----------
ax: axis
das axis element auf das die Änderungen angewandt werden sollen
limits: dict
Elemente: X1, X2, Y1, Y2, xStep, yStep
| def axTicks(self, ax, limits:dict={}):
"""Achsen Beschriftung und Limits ändern.
ohne Angaben in dict Achse entfernen
- xStep, yStep : dict - mit pos:label werden diese gesetzt
- xStep, yStep : int,float - wird der Abstand aus breite/step gebildet
Parameters
----------
ax: axis
das axis element auf das die Änderungen angewandt werden sollen
limits: dict
Elemente: X1, X2, Y1, Y2, xStep, yStep
"""
# gibt es Angaben für x
if "X1" in limits and "X2" in limits and "xStep" in limits:
l_min = limits["X1"]
l_max = limits["X2"]
l_step = limits["xStep"]
px_min = self.mm2dots_X( l_min )
px_max = self.mm2dots_X( l_max )
if type(l_step) is dict:
# ticklabels bestimmen
labels = l_step.values()
# ticks bestimmen
ticks = []
for t in l_step.keys():
ticks.append( self.mm2dots_X( float(t) ) )
else:
# ticklabels bestimmen
l_width = abs(l_min) + abs(l_max)
step = (l_width / l_step)
labels = np.arange(l_min, l_max + l_width / step, l_width / step )
# ticks bestimmen
t_width = abs(px_max - px_min)
ticks = np.arange(px_min, px_max + t_width / step , t_width / step )
# FixedFormatter should only be used together with FixedLocator
# ticks setzen
ax.get_xaxis().set_ticks( ticks )
# label setzen
ax.get_xaxis().set_ticklabels( labels )
else:
# x-Achse entfernen
ax.get_xaxis().set_ticklabels([])
ax.get_xaxis().set_ticks( [] )
# gibt es Angaben für y
if "Y1" in limits and "Y2" in limits and "yStep" in limits:
l_min = limits["Y1"]
l_max = limits["Y2"]
l_step = limits["yStep"]
px_min = self.mm2dots_Y( l_min )
px_max = self.mm2dots_Y( l_max )
if type(l_step) is dict:
# ticklabels bestimmen
labels = l_step.values()
# ticks bestimmen
ticks = []
for t in l_step.keys():
ticks.append( self.mm2dots_Y( float(t) ) )
else:
# ticklabels bestimmen
l_width = abs(l_min) + abs(l_max)
step = (l_width / l_step)
labels = np.arange(l_min, l_max + l_width / step, l_width / step )
# ticks bestimmen
t_width = abs(px_max - px_min)
ticks = np.arange(px_min, px_max + t_width / step , t_width / step )
# ticks setzen
ax.get_yaxis().set_ticks( ticks )
# label setzen
ax.get_yaxis().set_ticklabels( labels )
else:
# y-Achse entfernen
ax.get_yaxis().set_ticklabels([])
ax.get_yaxis().set_ticks( [] ) | [
"def",
"axTicks",
"(",
"self",
",",
"ax",
",",
"limits",
":",
"dict",
"=",
"{",
"}",
")",
":",
"# gibt es Angaben für x",
"if",
"\"X1\"",
"in",
"limits",
"and",
"\"X2\"",
"in",
"limits",
"and",
"\"xStep\"",
"in",
"limits",
":",
"l_min",
"=",
"limits",
"[",
"\"X1\"",
"]",
"l_max",
"=",
"limits",
"[",
"\"X2\"",
"]",
"l_step",
"=",
"limits",
"[",
"\"xStep\"",
"]",
"px_min",
"=",
"self",
".",
"mm2dots_X",
"(",
"l_min",
")",
"px_max",
"=",
"self",
".",
"mm2dots_X",
"(",
"l_max",
")",
"if",
"type",
"(",
"l_step",
")",
"is",
"dict",
":",
"# ticklabels bestimmen",
"labels",
"=",
"l_step",
".",
"values",
"(",
")",
"# ticks bestimmen",
"ticks",
"=",
"[",
"]",
"for",
"t",
"in",
"l_step",
".",
"keys",
"(",
")",
":",
"ticks",
".",
"append",
"(",
"self",
".",
"mm2dots_X",
"(",
"float",
"(",
"t",
")",
")",
")",
"else",
":",
"# ticklabels bestimmen",
"l_width",
"=",
"abs",
"(",
"l_min",
")",
"+",
"abs",
"(",
"l_max",
")",
"step",
"=",
"(",
"l_width",
"/",
"l_step",
")",
"labels",
"=",
"np",
".",
"arange",
"(",
"l_min",
",",
"l_max",
"+",
"l_width",
"/",
"step",
",",
"l_width",
"/",
"step",
")",
"# ticks bestimmen",
"t_width",
"=",
"abs",
"(",
"px_max",
"-",
"px_min",
")",
"ticks",
"=",
"np",
".",
"arange",
"(",
"px_min",
",",
"px_max",
"+",
"t_width",
"/",
"step",
",",
"t_width",
"/",
"step",
")",
"# FixedFormatter should only be used together with FixedLocator",
"# ticks setzen",
"ax",
".",
"get_xaxis",
"(",
")",
".",
"set_ticks",
"(",
"ticks",
")",
"# label setzen",
"ax",
".",
"get_xaxis",
"(",
")",
".",
"set_ticklabels",
"(",
"labels",
")",
"else",
":",
"# x-Achse entfernen",
"ax",
".",
"get_xaxis",
"(",
")",
".",
"set_ticklabels",
"(",
"[",
"]",
")",
"ax",
".",
"get_xaxis",
"(",
")",
".",
"set_ticks",
"(",
"[",
"]",
")",
"# gibt es Angaben für y",
"if",
"\"Y1\"",
"in",
"limits",
"and",
"\"Y2\"",
"in",
"limits",
"and",
"\"yStep\"",
"in",
"limits",
":",
"l_min",
"=",
"limits",
"[",
"\"Y1\"",
"]",
"l_max",
"=",
"limits",
"[",
"\"Y2\"",
"]",
"l_step",
"=",
"limits",
"[",
"\"yStep\"",
"]",
"px_min",
"=",
"self",
".",
"mm2dots_Y",
"(",
"l_min",
")",
"px_max",
"=",
"self",
".",
"mm2dots_Y",
"(",
"l_max",
")",
"if",
"type",
"(",
"l_step",
")",
"is",
"dict",
":",
"# ticklabels bestimmen",
"labels",
"=",
"l_step",
".",
"values",
"(",
")",
"# ticks bestimmen",
"ticks",
"=",
"[",
"]",
"for",
"t",
"in",
"l_step",
".",
"keys",
"(",
")",
":",
"ticks",
".",
"append",
"(",
"self",
".",
"mm2dots_Y",
"(",
"float",
"(",
"t",
")",
")",
")",
"else",
":",
"# ticklabels bestimmen",
"l_width",
"=",
"abs",
"(",
"l_min",
")",
"+",
"abs",
"(",
"l_max",
")",
"step",
"=",
"(",
"l_width",
"/",
"l_step",
")",
"labels",
"=",
"np",
".",
"arange",
"(",
"l_min",
",",
"l_max",
"+",
"l_width",
"/",
"step",
",",
"l_width",
"/",
"step",
")",
"# ticks bestimmen",
"t_width",
"=",
"abs",
"(",
"px_max",
"-",
"px_min",
")",
"ticks",
"=",
"np",
".",
"arange",
"(",
"px_min",
",",
"px_max",
"+",
"t_width",
"/",
"step",
",",
"t_width",
"/",
"step",
")",
"# ticks setzen",
"ax",
".",
"get_yaxis",
"(",
")",
".",
"set_ticks",
"(",
"ticks",
")",
"# label setzen",
"ax",
".",
"get_yaxis",
"(",
")",
".",
"set_ticklabels",
"(",
"labels",
")",
"else",
":",
"# y-Achse entfernen",
"ax",
".",
"get_yaxis",
"(",
")",
".",
"set_ticklabels",
"(",
"[",
"]",
")",
"ax",
".",
"get_yaxis",
"(",
")",
".",
"set_ticks",
"(",
"[",
"]",
")"
] | [
156,
4
] | [
243,
42
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
|
handle_output | (daten) | aendere den Ausgang eines Pins | aendere den Ausgang eines Pins | def handle_output(daten):
"""aendere den Ausgang eines Pins"""
# falls die Daten als String ankommen, konvertiere sie in ein Dictionary
if type(daten) == str:
daten = json.loads(daten)
global konfiguration
if validiere_daten(daten, "pin", "status"):
pin = daten["pin"]
status = daten["status"]
# aendere den Status des Pins, falls dieser als Ausgang konfiguriert wurde
# und benachrichtige alle Benutzer
if (pin_konfiguration := konfiguration["pins"].get(pin)) and pin_konfiguration["richtung"] == GPIO.OUT:
GPIO.output(pin, status)
pin_konfiguration["status"] = status
socketio.emit("output", daten)
else:
emit("fehler", {"text": "Der GPIO Pin wurde nicht als Ausgang gewaehlt"}) | [
"def",
"handle_output",
"(",
"daten",
")",
":",
"# falls die Daten als String ankommen, konvertiere sie in ein Dictionary",
"if",
"type",
"(",
"daten",
")",
"==",
"str",
":",
"daten",
"=",
"json",
".",
"loads",
"(",
"daten",
")",
"global",
"konfiguration",
"if",
"validiere_daten",
"(",
"daten",
",",
"\"pin\"",
",",
"\"status\"",
")",
":",
"pin",
"=",
"daten",
"[",
"\"pin\"",
"]",
"status",
"=",
"daten",
"[",
"\"status\"",
"]",
"# aendere den Status des Pins, falls dieser als Ausgang konfiguriert wurde",
"# und benachrichtige alle Benutzer",
"if",
"(",
"pin_konfiguration",
":=",
"konfiguration",
"[",
"\"pins\"",
"]",
".",
"get",
"(",
"pin",
")",
")",
"and",
"pin_konfiguration",
"[",
"\"richtung\"",
"]",
"==",
"GPIO",
".",
"OUT",
":",
"GPIO",
".",
"output",
"(",
"pin",
",",
"status",
")",
"pin_konfiguration",
"[",
"\"status\"",
"]",
"=",
"status",
"socketio",
".",
"emit",
"(",
"\"output\"",
",",
"daten",
")",
"else",
":",
"emit",
"(",
"\"fehler\"",
",",
"{",
"\"text\"",
":",
"\"Der GPIO Pin wurde nicht als Ausgang gewaehlt\"",
"}",
")"
] | [
122,
0
] | [
138,
85
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
|
prozent | (prozentwert, grundwert) | return (float(prozentwert) / grundwert) * 100.0 | Kleiner Helfer zur robusten Prozentrechnung
>>> prozent(3, 6)
50.0
>>> prozent(3, 0)
0
>>> prozent(0, 6)
0
| Kleiner Helfer zur robusten Prozentrechnung | def prozent(prozentwert, grundwert):
"""Kleiner Helfer zur robusten Prozentrechnung
>>> prozent(3, 6)
50.0
>>> prozent(3, 0)
0
>>> prozent(0, 6)
0
"""
if not (prozentwert and grundwert):
return 0
return (float(prozentwert) / grundwert) * 100.0 | [
"def",
"prozent",
"(",
"prozentwert",
",",
"grundwert",
")",
":",
"if",
"not",
"(",
"prozentwert",
"and",
"grundwert",
")",
":",
"return",
"0",
"return",
"(",
"float",
"(",
"prozentwert",
")",
"/",
"grundwert",
")",
"*",
"100.0"
] | [
185,
0
] | [
197,
51
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
Zeitrechnung.convert | (self, jahr: int, ziel: "Zeitrechnung") | return jahr - self.delta + ziel.delta | Konvertiert ein Jahr in eine andere Zeitrechnung:
@jahr: int: das Jahr das konvertiert werden soll
@zeitrechnung: Zeitrechnung: Die Zeitrechnung, zu der das Jahr konvertiert werden soll
:raise TypeError: Wenn das Jahr keine ganze Zahl ist
:return int
| Konvertiert ein Jahr in eine andere Zeitrechnung: | def convert(self, jahr: int, ziel: "Zeitrechnung") -> int:
"""Konvertiert ein Jahr in eine andere Zeitrechnung:
@jahr: int: das Jahr das konvertiert werden soll
@zeitrechnung: Zeitrechnung: Die Zeitrechnung, zu der das Jahr konvertiert werden soll
:raise TypeError: Wenn das Jahr keine ganze Zahl ist
:return int
"""
# TODO: Konvertierungsmethode pruefen
if type(jahr) != int:
try:
jahr = int(jahr)
except ValueError:
raise TypeError("Das Jahr muss ein int sein")
return jahr - self.delta + ziel.delta | [
"def",
"convert",
"(",
"self",
",",
"jahr",
":",
"int",
",",
"ziel",
":",
"\"Zeitrechnung\"",
")",
"->",
"int",
":",
"# TODO: Konvertierungsmethode pruefen",
"if",
"type",
"(",
"jahr",
")",
"!=",
"int",
":",
"try",
":",
"jahr",
"=",
"int",
"(",
"jahr",
")",
"except",
"ValueError",
":",
"raise",
"TypeError",
"(",
"\"Das Jahr muss ein int sein\"",
")",
"return",
"jahr",
"-",
"self",
".",
"delta",
"+",
"ziel",
".",
"delta"
] | [
27,
4
] | [
44,
45
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
percentages | (sumdir, basis, feldliste) | Fügt zu `sumdir` die prozentsaetze der keys in `feldliste` zur basis `basis` zu.
>>> sumdir = dict(gesammt=10, dieter=5, klaus=3)
>>> percentages(sumdir, 'gesammt', 'dieter klaus')
>>> sorted(sumdir.items())
[('dieter', 5), ('dieterp', 50.0), ('gesammt', 10), ('klaus', 3), ('klausp', 30.0)]
| Fügt zu `sumdir` die prozentsaetze der keys in `feldliste` zur basis `basis` zu. | def percentages(sumdir, basis, feldliste):
"""Fügt zu `sumdir` die prozentsaetze der keys in `feldliste` zur basis `basis` zu.
>>> sumdir = dict(gesammt=10, dieter=5, klaus=3)
>>> percentages(sumdir, 'gesammt', 'dieter klaus')
>>> sorted(sumdir.items())
[('dieter', 5), ('dieterp', 50.0), ('gesammt', 10), ('klaus', 3), ('klausp', 30.0)]
"""
if hasattr(feldliste, 'split'):
feldliste = feldliste.split()
for feldname in feldliste:
if sumdir.get(basis, 0):
sumdir["%sp" % feldname] = prozent(sumdir[feldname], sumdir[basis])
else:
sumdir["%sp" % feldname] = None | [
"def",
"percentages",
"(",
"sumdir",
",",
"basis",
",",
"feldliste",
")",
":",
"if",
"hasattr",
"(",
"feldliste",
",",
"'split'",
")",
":",
"feldliste",
"=",
"feldliste",
".",
"split",
"(",
")",
"for",
"feldname",
"in",
"feldliste",
":",
"if",
"sumdir",
".",
"get",
"(",
"basis",
",",
"0",
")",
":",
"sumdir",
"[",
"\"%sp\"",
"%",
"feldname",
"]",
"=",
"prozent",
"(",
"sumdir",
"[",
"feldname",
"]",
",",
"sumdir",
"[",
"basis",
"]",
")",
"else",
":",
"sumdir",
"[",
"\"%sp\"",
"%",
"feldname",
"]",
"=",
"None"
] | [
200,
0
] | [
214,
43
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
|
CoolDownHelper.AddCooldown | ( self, scriptname, command, cooldownTime ) | return | Globalen Cooldown setzen | Globalen Cooldown setzen | def AddCooldown( self, scriptname, command, cooldownTime ):
'''Globalen Cooldown setzen'''
thisActionName = "AddCooldown"
self.Parent.AddCooldown( scriptname, command.lower(), cooldownTime )
if ( self.Debug ):
self.Logger.WriteDebug( command, "Setze globalen Cooldown auf {0}.".format( TimePrettyFormatString(int( cooldownTime ) ) ) )
self.Logger.WriteLog( command + ": Setze globalen Cooldown auf {0}.".format( TimePrettyFormatString(int( cooldownTime ) ) ) )
return | [
"def",
"AddCooldown",
"(",
"self",
",",
"scriptname",
",",
"command",
",",
"cooldownTime",
")",
":",
"thisActionName",
"=",
"\"AddCooldown\"",
"self",
".",
"Parent",
".",
"AddCooldown",
"(",
"scriptname",
",",
"command",
".",
"lower",
"(",
")",
",",
"cooldownTime",
")",
"if",
"(",
"self",
".",
"Debug",
")",
":",
"self",
".",
"Logger",
".",
"WriteDebug",
"(",
"command",
",",
"\"Setze globalen Cooldown auf {0}.\"",
".",
"format",
"(",
"TimePrettyFormatString",
"(",
"int",
"(",
"cooldownTime",
")",
")",
")",
")",
"self",
".",
"Logger",
".",
"WriteLog",
"(",
"command",
"+",
"\": Setze globalen Cooldown auf {0}.\"",
".",
"format",
"(",
"TimePrettyFormatString",
"(",
"int",
"(",
"cooldownTime",
")",
")",
")",
")",
"return"
] | [
61,
4
] | [
72,
14
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
ispTest.test_webapp_base_statics | ( self ) | Webapp Aufruf auf Statische Inhalte
| Webapp Aufruf auf Statische Inhalte
| def test_webapp_base_statics( self ):
''' Webapp Aufruf auf Statische Inhalte
'''
# index auf zwei arten aufrufen
response = self.app.get( "/" )
#self.assertEqual(response.status_code, 200, "Api Status nicht 200")
index = response.data
response = self.app.get( "/render/index", query_string = {
"zahl":"012",
"bool":True,
"test":1,
"_ispcp": json.dumps( {"name":"B"} )
} )
self.assertEqual(response.status_code, 200, "Api Status nicht 200")
self.assertEqual(index, response.data, "index und render/index nicht gleich")
# render auf nicht auf nicht vorhandenes Template in ui
response = self.app.get( "/render/keintemplate" )
self.assertEqual(response.status_code, 404, "render auf nicht auf nicht vorhandenes Template in ui")
# load auf nicht vorhandene Datei testen
response = self.app.get( "/globals/js/keinedatei" )
self.assertEqual(response.status_code, 404, "load auf nicht vorhandene Datei")
# in ui eine unittest_route.phtml erzeugen
route_file = os.path.join( ABSPATH , "..", "ui", "unittest_route.phtml")
with open(route_file, 'w') as f:
f.write( "value={{ value }}" )
# ohne parameter
response = self.app.get( "/unittest_route" )
self.assertEqual(response.status_code, 200, "Api Status nicht 200")
self.assertEqual(response.data, b"value=None", "Inhalt ist nicht value=None;_ispcp=")
# zwei gleiche parameter (nur der erste wird verwendet)
response = self.app.get( "/unittest_route?value=12&value=1" )
self.assertEqual(response.status_code, 200, "Api Status nicht 200")
self.assertEqual(response.data, b"value=12", "Inhalt ist nicht value=12;_ispcp= FirstValueURIParser")
# unittest_route.phtml in ui wieder entfernen
os.remove( route_file )
# in ui eine unittest_route_ispcp.phtml erzeugen
route_file1 = os.path.join( ABSPATH , "..", "ui", "unittest_route_ispcp.phtml")
with open(route_file1, 'w') as f:
f.write( "{{ params }}" )
# Parameter als dict
response = self.app.get( '/unittest_route_ispcp' , query_string = {
"name":"A",
"uuid":1,
"id":1,
"_ispcp": json.dumps( {"name":"B"} )
} )
self.assertEqual(response.status_code, 200, "Api Status nicht 200")
self.assertDictEqual( json.loads( response.data.decode('utf-8') ), {"uuid": "1", "id": "1", "name": "B"}, "Inhalt ist nicht mit dict")
# unittest_route_ispcp.phtml in ui wieder entfernen
os.remove(route_file1)
#
# mit fehler bei _ispcp
response = self.app.get( "/render/index", query_string = {
"zahl":"012",
"bool":True,
"test":1,
"_ispcp": "name"
} )
self.assertEqual(response.status_code, 200, "Api Status nicht 200") | [
"def",
"test_webapp_base_statics",
"(",
"self",
")",
":",
"# index auf zwei arten aufrufen",
"response",
"=",
"self",
".",
"app",
".",
"get",
"(",
"\"/\"",
")",
"#self.assertEqual(response.status_code, 200, \"Api Status nicht 200\")",
"index",
"=",
"response",
".",
"data",
"response",
"=",
"self",
".",
"app",
".",
"get",
"(",
"\"/render/index\"",
",",
"query_string",
"=",
"{",
"\"zahl\"",
":",
"\"012\"",
",",
"\"bool\"",
":",
"True",
",",
"\"test\"",
":",
"1",
",",
"\"_ispcp\"",
":",
"json",
".",
"dumps",
"(",
"{",
"\"name\"",
":",
"\"B\"",
"}",
")",
"}",
")",
"self",
".",
"assertEqual",
"(",
"response",
".",
"status_code",
",",
"200",
",",
"\"Api Status nicht 200\"",
")",
"self",
".",
"assertEqual",
"(",
"index",
",",
"response",
".",
"data",
",",
"\"index und render/index nicht gleich\"",
")",
"# render auf nicht auf nicht vorhandenes Template in ui ",
"response",
"=",
"self",
".",
"app",
".",
"get",
"(",
"\"/render/keintemplate\"",
")",
"self",
".",
"assertEqual",
"(",
"response",
".",
"status_code",
",",
"404",
",",
"\"render auf nicht auf nicht vorhandenes Template in ui\"",
")",
"# load auf nicht vorhandene Datei testen",
"response",
"=",
"self",
".",
"app",
".",
"get",
"(",
"\"/globals/js/keinedatei\"",
")",
"self",
".",
"assertEqual",
"(",
"response",
".",
"status_code",
",",
"404",
",",
"\"load auf nicht vorhandene Datei\"",
")",
"# in ui eine unittest_route.phtml erzeugen ",
"route_file",
"=",
"os",
".",
"path",
".",
"join",
"(",
"ABSPATH",
",",
"\"..\"",
",",
"\"ui\"",
",",
"\"unittest_route.phtml\"",
")",
"with",
"open",
"(",
"route_file",
",",
"'w'",
")",
"as",
"f",
":",
"f",
".",
"write",
"(",
"\"value={{ value }}\"",
")",
"# ohne parameter",
"response",
"=",
"self",
".",
"app",
".",
"get",
"(",
"\"/unittest_route\"",
")",
"self",
".",
"assertEqual",
"(",
"response",
".",
"status_code",
",",
"200",
",",
"\"Api Status nicht 200\"",
")",
"self",
".",
"assertEqual",
"(",
"response",
".",
"data",
",",
"b\"value=None\"",
",",
"\"Inhalt ist nicht value=None;_ispcp=\"",
")",
"# zwei gleiche parameter (nur der erste wird verwendet)",
"response",
"=",
"self",
".",
"app",
".",
"get",
"(",
"\"/unittest_route?value=12&value=1\"",
")",
"self",
".",
"assertEqual",
"(",
"response",
".",
"status_code",
",",
"200",
",",
"\"Api Status nicht 200\"",
")",
"self",
".",
"assertEqual",
"(",
"response",
".",
"data",
",",
"b\"value=12\"",
",",
"\"Inhalt ist nicht value=12;_ispcp= FirstValueURIParser\"",
")",
"# unittest_route.phtml in ui wieder entfernen",
"os",
".",
"remove",
"(",
"route_file",
")",
"# in ui eine unittest_route_ispcp.phtml erzeugen ",
"route_file1",
"=",
"os",
".",
"path",
".",
"join",
"(",
"ABSPATH",
",",
"\"..\"",
",",
"\"ui\"",
",",
"\"unittest_route_ispcp.phtml\"",
")",
"with",
"open",
"(",
"route_file1",
",",
"'w'",
")",
"as",
"f",
":",
"f",
".",
"write",
"(",
"\"{{ params }}\"",
")",
"# Parameter als dict",
"response",
"=",
"self",
".",
"app",
".",
"get",
"(",
"'/unittest_route_ispcp'",
",",
"query_string",
"=",
"{",
"\"name\"",
":",
"\"A\"",
",",
"\"uuid\"",
":",
"1",
",",
"\"id\"",
":",
"1",
",",
"\"_ispcp\"",
":",
"json",
".",
"dumps",
"(",
"{",
"\"name\"",
":",
"\"B\"",
"}",
")",
"}",
")",
"self",
".",
"assertEqual",
"(",
"response",
".",
"status_code",
",",
"200",
",",
"\"Api Status nicht 200\"",
")",
"self",
".",
"assertDictEqual",
"(",
"json",
".",
"loads",
"(",
"response",
".",
"data",
".",
"decode",
"(",
"'utf-8'",
")",
")",
",",
"{",
"\"uuid\"",
":",
"\"1\"",
",",
"\"id\"",
":",
"\"1\"",
",",
"\"name\"",
":",
"\"B\"",
"}",
",",
"\"Inhalt ist nicht mit dict\"",
")",
"# unittest_route_ispcp.phtml in ui wieder entfernen",
"os",
".",
"remove",
"(",
"route_file1",
")",
"#",
"# mit fehler bei _ispcp",
"response",
"=",
"self",
".",
"app",
".",
"get",
"(",
"\"/render/index\"",
",",
"query_string",
"=",
"{",
"\"zahl\"",
":",
"\"012\"",
",",
"\"bool\"",
":",
"True",
",",
"\"test\"",
":",
"1",
",",
"\"_ispcp\"",
":",
"\"name\"",
"}",
")",
"self",
".",
"assertEqual",
"(",
"response",
".",
"status_code",
",",
"200",
",",
"\"Api Status nicht 200\"",
")"
] | [
1425,
4
] | [
1502,
75
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
|
checkField.doJT_9_1_2 | (self, fileData) | return self.pdf.finish(), result | Jahrestest: 9.1.2. ()
Abhängigkeit der Variation des Dosisquerprofils vom Tragarm-Rotationswinkel
DIN 6847-5:2013; DIN EN 60976: 2011-02
30x30 Feld bei im Bereich 80% der Feldbreite max-min/Wert im Zentralstrahl Bereich von 2mm"
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: 9.1.2. ()
Abhängigkeit der Variation des Dosisquerprofils vom Tragarm-Rotationswinkel
DIN 6847-5:2013; DIN EN 60976: 2011-02
30x30 Feld bei im Bereich 80% der Feldbreite max-min/Wert im Zentralstrahl Bereich von 2mm" | def doJT_9_1_2(self, fileData):
"""Jahrestest: 9.1.2. ()
Abhängigkeit der Variation des Dosisquerprofils vom Tragarm-Rotationswinkel
DIN 6847-5:2013; DIN EN 60976: 2011-02
30x30 Feld bei im Bereich 80% der Feldbreite max-min/Wert im Zentralstrahl Bereich von 2mm"
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"],
"series_groupby": ["day"],
"querys" : {
"fields" : "check_subtag != 'base'",
# "field_count": self.metadata.current.get("fields", 0), # 4
},
"manual": {
"filename": self.metadata.info["anleitung"],
"attrs": {"class":"layout-fill-width", "margin-bottom": "5mm"},
},
"_clip" : { "width":"50mm", "height":"45mm" },
"_formel": { "margin-top":"15mm", "width":"21mm", "height":"11mm"},
"_table": { "width":105, "height": 45, "left":75, "top":215 },
"_chart" : {"width" : 90, "height" : 70},
"profileSize" : { "width" : 90, "height" : 70 },
"profileTitle" : "Gantry: {gantry}°",
"table_fields" : [
{'field': 'gantry', 'label':'Gantry', 'format':'{0:.1f}' },
{'field': 'crossline', 'label':'crossline [%]', 'format':'{0:.1f}' },
# {'field': 'crossline_soll', 'label':'c-soll [%]', 'format':'{0:.1f}' },
{'field': 'c_soll', 'label':'c-soll [%]', 'format':'{0:.1f}' },
{'field': 'crossline_acceptance', 'label':'c-abw.[%]', 'format':'{0:.3f}' },
{'field': 'inline', 'label':'inline [%]', 'format':'{0:.1f}' },
# {'field': 'inline_soll', 'label':'i-soll [%]', 'format':'{0:.1f}' },
{'field': 'i_soll', 'label':'i-soll [%]', 'format':'{0:.1f}' },
{'field': 'inline_acceptance', 'label':'i-abw.[%]', 'format':'{0:.3f}' },
# {'field': 'i_diff', 'label':'i-abw.[%]', 'format':'{0:.3f}' }
]
} ), self.metadata )
# tolerance Werte bereitstellen
#toleranz = {}
#if "toleranz" in md["testConfig"] and md["energy"] in md["testConfig"]["toleranz"]:
# toleranz = md["testConfig"]["toleranz"][ md["energy"] ]
def evaluate( df_group ):
"""Datumsweise Auswertung
"""
# get base and fields check number of data
ok, df_base, df_fields = self.evaluationPrepare(df_group, md, result)
if not ok:
return
data = []
# alle Felder durchgehen
for info in df_group.itertuples():
checkField = qa_field( self.getFullData( info ), normalize="none" )
# Analyse nach DIN (max-min)/center rückgabe in valueiec
profile = checkField.getProfileData()
# crossplane und inplane
c = profile["flatness"]["horizontal"]
i = profile["flatness"]["vertical"]
# key für tolerance
#sollKeyC = "{gantry:1.0f}-cl".format( **checkField.infos )
#sollKeyI = "{gantry:1.0f}-il".format( **checkField.infos )
#sollKey = "{gantry:1.0f}-cl".format( **checkField.infos )
# Bild anzeigen
img = checkField.plotProfile( profile["flatness"], metadata=md )
self.pdf.image(img, md["_chart"], {"padding":"2mm 0 2mm 0"} )
data.append( {
'gantry' : checkField.infos["gantry"],
'crossline': c["value"],
'c_soll' : 5,
#'c_soll' : toleranz.get( sollKeyC, np.nan ),
'inline': i["value"],
'i_soll' : 5,
#'i_soll' : toleranz.get( sollKeyI, np.nan ),
} )
# 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 ) )
# Grafik und Formel anzeigen
self.pdf.image( "qa/Profile.svg", attrs=md["_clip"])
self.pdf.mathtext( r"$\frac{D_{max} - D_{min}} {D_{CAX}}$", attrs=md["_formel"] )
# dataframe erstellen
df = pd.DataFrame( data )
# berechnete Splaten einfügen
#df['c_diff'] = (df.crossline - df.c_soll ) / df.c_soll * 100
#df['i_diff'] = (df.inline - df.i_soll ) / df.i_soll * 100
#
# Abweichung ausrechnen und Passed setzen
#
check = [
{ "field": 'crossline', 'tolerance':'default' },
{ "field": 'inline', 'tolerance':'default' }
]
acceptance = self.check_acceptance( df, md, check, withSoll=True )
#print( df.columns )
# 'gantry', 'crossline', 'inline', 'crossline_soll',
# 'crossline_acceptance', 'crossline_passed', 'inline_soll',
# 'inline_acceptance', 'inline_passed'
#
# Ergebnis in result merken
#
result.append( self.createResult( df, md, check,
df_group['AcquisitionDateTime'].iloc[0].strftime("%Y%m%d"),
len( result ), # bisherige Ergebnisse in result
acceptance
) )
#
# Tabelle erzeugen
#
self.pdf.pandas( df,
area=md["_table"],
attrs={"class":"layout-fill-width", "margin-top": "5mm"},
fields=md["table_fields"]
)
# Gesamt check - das schlechteste aus der tabelle
self.pdf.resultIcon( acceptance )
#
# call evaluate with sorted and grouped fields
fileData.sort_values(md["series_sort_values"]).groupby( md["series_groupby"] ).apply( evaluate )
# fileData.sort_values(["gantry"]).groupby( [ 'day' ] ).apply( groupBySeries )
# abschließen pdfdaten und result zurückgeben
return self.pdf.finish(), result | [
"def",
"doJT_9_1_2",
"(",
"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\"",
"]",
",",
"\"series_groupby\"",
":",
"[",
"\"day\"",
"]",
",",
"\"querys\"",
":",
"{",
"\"fields\"",
":",
"\"check_subtag != 'base'\"",
",",
"# \"field_count\": self.metadata.current.get(\"fields\", 0), # 4",
"}",
",",
"\"manual\"",
":",
"{",
"\"filename\"",
":",
"self",
".",
"metadata",
".",
"info",
"[",
"\"anleitung\"",
"]",
",",
"\"attrs\"",
":",
"{",
"\"class\"",
":",
"\"layout-fill-width\"",
",",
"\"margin-bottom\"",
":",
"\"5mm\"",
"}",
",",
"}",
",",
"\"_clip\"",
":",
"{",
"\"width\"",
":",
"\"50mm\"",
",",
"\"height\"",
":",
"\"45mm\"",
"}",
",",
"\"_formel\"",
":",
"{",
"\"margin-top\"",
":",
"\"15mm\"",
",",
"\"width\"",
":",
"\"21mm\"",
",",
"\"height\"",
":",
"\"11mm\"",
"}",
",",
"\"_table\"",
":",
"{",
"\"width\"",
":",
"105",
",",
"\"height\"",
":",
"45",
",",
"\"left\"",
":",
"75",
",",
"\"top\"",
":",
"215",
"}",
",",
"\"_chart\"",
":",
"{",
"\"width\"",
":",
"90",
",",
"\"height\"",
":",
"70",
"}",
",",
"\"profileSize\"",
":",
"{",
"\"width\"",
":",
"90",
",",
"\"height\"",
":",
"70",
"}",
",",
"\"profileTitle\"",
":",
"\"Gantry: {gantry}°\",",
"",
"\"table_fields\"",
":",
"[",
"{",
"'field'",
":",
"'gantry'",
",",
"'label'",
":",
"'Gantry'",
",",
"'format'",
":",
"'{0:.1f}'",
"}",
",",
"{",
"'field'",
":",
"'crossline'",
",",
"'label'",
":",
"'crossline [%]'",
",",
"'format'",
":",
"'{0:.1f}'",
"}",
",",
"# {'field': 'crossline_soll', 'label':'c-soll [%]', 'format':'{0:.1f}' },",
"{",
"'field'",
":",
"'c_soll'",
",",
"'label'",
":",
"'c-soll [%]'",
",",
"'format'",
":",
"'{0:.1f}'",
"}",
",",
"{",
"'field'",
":",
"'crossline_acceptance'",
",",
"'label'",
":",
"'c-abw.[%]'",
",",
"'format'",
":",
"'{0:.3f}'",
"}",
",",
"{",
"'field'",
":",
"'inline'",
",",
"'label'",
":",
"'inline [%]'",
",",
"'format'",
":",
"'{0:.1f}'",
"}",
",",
"# {'field': 'inline_soll', 'label':'i-soll [%]', 'format':'{0:.1f}' },",
"{",
"'field'",
":",
"'i_soll'",
",",
"'label'",
":",
"'i-soll [%]'",
",",
"'format'",
":",
"'{0:.1f}'",
"}",
",",
"{",
"'field'",
":",
"'inline_acceptance'",
",",
"'label'",
":",
"'i-abw.[%]'",
",",
"'format'",
":",
"'{0:.3f}'",
"}",
",",
"# {'field': 'i_diff', 'label':'i-abw.[%]', 'format':'{0:.3f}' }",
"]",
"}",
")",
",",
"self",
".",
"metadata",
")",
"# tolerance Werte bereitstellen",
"#toleranz = {}",
"#if \"toleranz\" in md[\"testConfig\"] and md[\"energy\"] in md[\"testConfig\"][\"toleranz\"]:",
"# toleranz = md[\"testConfig\"][\"toleranz\"][ md[\"energy\"] ]",
"def",
"evaluate",
"(",
"df_group",
")",
":",
"\"\"\"Datumsweise Auswertung\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",
"=",
"[",
"]",
"# alle Felder durchgehen",
"for",
"info",
"in",
"df_group",
".",
"itertuples",
"(",
")",
":",
"checkField",
"=",
"qa_field",
"(",
"self",
".",
"getFullData",
"(",
"info",
")",
",",
"normalize",
"=",
"\"none\"",
")",
"# Analyse nach DIN (max-min)/center rückgabe in valueiec",
"profile",
"=",
"checkField",
".",
"getProfileData",
"(",
")",
"# crossplane und inplane",
"c",
"=",
"profile",
"[",
"\"flatness\"",
"]",
"[",
"\"horizontal\"",
"]",
"i",
"=",
"profile",
"[",
"\"flatness\"",
"]",
"[",
"\"vertical\"",
"]",
"# key für tolerance",
"#sollKeyC = \"{gantry:1.0f}-cl\".format( **checkField.infos )",
"#sollKeyI = \"{gantry:1.0f}-il\".format( **checkField.infos )",
"#sollKey = \"{gantry:1.0f}-cl\".format( **checkField.infos )",
"# Bild anzeigen",
"img",
"=",
"checkField",
".",
"plotProfile",
"(",
"profile",
"[",
"\"flatness\"",
"]",
",",
"metadata",
"=",
"md",
")",
"self",
".",
"pdf",
".",
"image",
"(",
"img",
",",
"md",
"[",
"\"_chart\"",
"]",
",",
"{",
"\"padding\"",
":",
"\"2mm 0 2mm 0\"",
"}",
")",
"data",
".",
"append",
"(",
"{",
"'gantry'",
":",
"checkField",
".",
"infos",
"[",
"\"gantry\"",
"]",
",",
"'crossline'",
":",
"c",
"[",
"\"value\"",
"]",
",",
"'c_soll'",
":",
"5",
",",
"#'c_soll' : toleranz.get( sollKeyC, np.nan ),",
"'inline'",
":",
"i",
"[",
"\"value\"",
"]",
",",
"'i_soll'",
":",
"5",
",",
"#'i_soll' : toleranz.get( sollKeyI, np.nan ),",
"}",
")",
"# 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",
")",
")",
"# Grafik und Formel anzeigen",
"self",
".",
"pdf",
".",
"image",
"(",
"\"qa/Profile.svg\"",
",",
"attrs",
"=",
"md",
"[",
"\"_clip\"",
"]",
")",
"self",
".",
"pdf",
".",
"mathtext",
"(",
"r\"$\\frac{D_{max} - D_{min}} {D_{CAX}}$\"",
",",
"attrs",
"=",
"md",
"[",
"\"_formel\"",
"]",
")",
"# dataframe erstellen",
"df",
"=",
"pd",
".",
"DataFrame",
"(",
"data",
")",
"# berechnete Splaten einfügen",
"#df['c_diff'] = (df.crossline - df.c_soll ) / df.c_soll * 100",
"#df['i_diff'] = (df.inline - df.i_soll ) / df.i_soll * 100",
"#",
"# Abweichung ausrechnen und Passed setzen",
"#",
"check",
"=",
"[",
"{",
"\"field\"",
":",
"'crossline'",
",",
"'tolerance'",
":",
"'default'",
"}",
",",
"{",
"\"field\"",
":",
"'inline'",
",",
"'tolerance'",
":",
"'default'",
"}",
"]",
"acceptance",
"=",
"self",
".",
"check_acceptance",
"(",
"df",
",",
"md",
",",
"check",
",",
"withSoll",
"=",
"True",
")",
"#print( df.columns )",
"# 'gantry', 'crossline', 'inline', 'crossline_soll',",
"# 'crossline_acceptance', 'crossline_passed', 'inline_soll',",
"# 'inline_acceptance', 'inline_passed'",
"#",
"# Ergebnis in result merken",
"#",
"result",
".",
"append",
"(",
"self",
".",
"createResult",
"(",
"df",
",",
"md",
",",
"check",
",",
"df_group",
"[",
"'AcquisitionDateTime'",
"]",
".",
"iloc",
"[",
"0",
"]",
".",
"strftime",
"(",
"\"%Y%m%d\"",
")",
",",
"len",
"(",
"result",
")",
",",
"# bisherige Ergebnisse in result",
"acceptance",
")",
")",
"#",
"# Tabelle erzeugen",
"#",
"self",
".",
"pdf",
".",
"pandas",
"(",
"df",
",",
"area",
"=",
"md",
"[",
"\"_table\"",
"]",
",",
"attrs",
"=",
"{",
"\"class\"",
":",
"\"layout-fill-width\"",
",",
"\"margin-top\"",
":",
"\"5mm\"",
"}",
",",
"fields",
"=",
"md",
"[",
"\"table_fields\"",
"]",
")",
"# Gesamt check - das schlechteste aus der tabelle",
"self",
".",
"pdf",
".",
"resultIcon",
"(",
"acceptance",
")",
"#",
"# call evaluate with sorted and grouped fields",
"fileData",
".",
"sort_values",
"(",
"md",
"[",
"\"series_sort_values\"",
"]",
")",
".",
"groupby",
"(",
"md",
"[",
"\"series_groupby\"",
"]",
")",
".",
"apply",
"(",
"evaluate",
")",
"# fileData.sort_values([\"gantry\"]).groupby( [ 'day' ] ).apply( groupBySeries )",
"# abschließen pdfdaten und result zurückgeben",
"return",
"self",
".",
"pdf",
".",
"finish",
"(",
")",
",",
"result"
] | [
970,
4
] | [
1136,
40
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
HeistSystem.game_PayReward | (self, winnerdata) | return resultData | Auszahlen des erbeuteten Gewinns | Auszahlen des erbeuteten Gewinns | def game_PayReward(self, winnerdata):
''' Auszahlen des erbeuteten Gewinns '''
resultData = []
tempDict = {}
for winner in winnerdata:
# Gewinn errechnen
payout = winner["userStake"] * \
float(self.Settings.Game_Result_Multiplier)
# Wert auf die nächste Zahl aufrunden
payout = math.ceil(payout)
# Daten in Dictionary übernehmen
tempDict = {
"userName": winner["userName"],
"userDisplayName": self.Parent.GetDisplayName(
winner["userName"]),
"userPayout": int(payout)
}
# Punkte an User übergeben
self.Parent.AddPoints(tempDict["userName"],
tempDict["userDisplayName"],
tempDict["userPayout"])
resultData.append(tempDict)
return resultData | [
"def",
"game_PayReward",
"(",
"self",
",",
"winnerdata",
")",
":",
"resultData",
"=",
"[",
"]",
"tempDict",
"=",
"{",
"}",
"for",
"winner",
"in",
"winnerdata",
":",
"# Gewinn errechnen\r",
"payout",
"=",
"winner",
"[",
"\"userStake\"",
"]",
"*",
"float",
"(",
"self",
".",
"Settings",
".",
"Game_Result_Multiplier",
")",
"# Wert auf die nächste Zahl aufrunden\r",
"payout",
"=",
"math",
".",
"ceil",
"(",
"payout",
")",
"# Daten in Dictionary übernehmen\r",
"tempDict",
"=",
"{",
"\"userName\"",
":",
"winner",
"[",
"\"userName\"",
"]",
",",
"\"userDisplayName\"",
":",
"self",
".",
"Parent",
".",
"GetDisplayName",
"(",
"winner",
"[",
"\"userName\"",
"]",
")",
",",
"\"userPayout\"",
":",
"int",
"(",
"payout",
")",
"}",
"# Punkte an User übergeben\r",
"self",
".",
"Parent",
".",
"AddPoints",
"(",
"tempDict",
"[",
"\"userName\"",
"]",
",",
"tempDict",
"[",
"\"userDisplayName\"",
"]",
",",
"tempDict",
"[",
"\"userPayout\"",
"]",
")",
"resultData",
".",
"append",
"(",
"tempDict",
")",
"return",
"resultData"
] | [
1465,
4
] | [
1494,
25
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
HeistSystem.Writemessage_NewGameStart | (self, data) | return | Schreibt die Benachrichtigung über den Start eines neuen Spiels in den Chat | Schreibt die Benachrichtigung über den Start eines neuen Spiels in den Chat | def Writemessage_NewGameStart(self, data):
''' Schreibt die Benachrichtigung über den Start eines neuen Spiels in den Chat '''
thisActionName = "Writemessage_NewGameStart"
# Benachrichtigung aus der Datenbank auslesen
messageText = self.RandomMessage_ByType(
messageType=self.MessageType_NewGameStart
)
# Nachricht in den Chat schreiben
self.chat_WriteTextMessage(
messageText=str(messageText).format(
user=data.UserName,
command=self.Settings.Game_Command,
target=self.GameTargetName,
time=myTime.TimePrettyFormatString(
int(self.Settings.Game_UntilStart_Time)
),
maxpoints=TransformLocale_Decimals(
self.Settings.Game_Settings_MaxStake
),
pointsname=self.Parent.GetCurrencyName()
)
)
return | [
"def",
"Writemessage_NewGameStart",
"(",
"self",
",",
"data",
")",
":",
"thisActionName",
"=",
"\"Writemessage_NewGameStart\"",
"# Benachrichtigung aus der Datenbank auslesen\r",
"messageText",
"=",
"self",
".",
"RandomMessage_ByType",
"(",
"messageType",
"=",
"self",
".",
"MessageType_NewGameStart",
")",
"# Nachricht in den Chat schreiben\r",
"self",
".",
"chat_WriteTextMessage",
"(",
"messageText",
"=",
"str",
"(",
"messageText",
")",
".",
"format",
"(",
"user",
"=",
"data",
".",
"UserName",
",",
"command",
"=",
"self",
".",
"Settings",
".",
"Game_Command",
",",
"target",
"=",
"self",
".",
"GameTargetName",
",",
"time",
"=",
"myTime",
".",
"TimePrettyFormatString",
"(",
"int",
"(",
"self",
".",
"Settings",
".",
"Game_UntilStart_Time",
")",
")",
",",
"maxpoints",
"=",
"TransformLocale_Decimals",
"(",
"self",
".",
"Settings",
".",
"Game_Settings_MaxStake",
")",
",",
"pointsname",
"=",
"self",
".",
"Parent",
".",
"GetCurrencyName",
"(",
")",
")",
")",
"return"
] | [
1134,
4
] | [
1159,
14
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
qa_wl._getThresholdMask | (self, img, proz ) | return threshold_img | Eine Bildmaske erstellen
img : image.array
proz : [ min, max]
| Eine Bildmaske erstellen
img : image.array
proz : [ min, max]
| def _getThresholdMask(self, img, proz ):
""" Eine Bildmaske erstellen
img : image.array
proz : [ min, max]
"""
min_value, max_value = np.percentile(img, proz)
threshold_value = (max_value - min_value)/2 + min_value
array = np.where(img >= threshold_value, 1, 0)
threshold_img = ArrayImage(array)
return threshold_img | [
"def",
"_getThresholdMask",
"(",
"self",
",",
"img",
",",
"proz",
")",
":",
"min_value",
",",
"max_value",
"=",
"np",
".",
"percentile",
"(",
"img",
",",
"proz",
")",
"threshold_value",
"=",
"(",
"max_value",
"-",
"min_value",
")",
"/",
"2",
"+",
"min_value",
"array",
"=",
"np",
".",
"where",
"(",
"img",
">=",
"threshold_value",
",",
"1",
",",
"0",
")",
"threshold_img",
"=",
"ArrayImage",
"(",
"array",
")",
"return",
"threshold_img"
] | [
127,
4
] | [
138,
28
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
create | (cbow_model, bm25_model, max_args=-1) | Erstelle einen neuen Index, der in einer CSV gespeichert wird
Args:
cbow_model (:obj:`Word2Vec`): Embedding Modell
bm25_model (:obj:`BM25Kapi`): BM25 Modell
max_args (int, optional): Anzahl der Argumente, die indiziert
werden sollen
| Erstelle einen neuen Index, der in einer CSV gespeichert wird | def create(cbow_model, bm25_model, max_args=-1):
"""Erstelle einen neuen Index, der in einer CSV gespeichert wird
Args:
cbow_model (:obj:`Word2Vec`): Embedding Modell
bm25_model (:obj:`BM25Kapi`): BM25 Modell
max_args (int, optional): Anzahl der Argumente, die indiziert
werden sollen
"""
vector_size = cbow_model.vector_size
with open(setup.INDEX_PATH, 'w', encoding='utf-8', newline='') as f_out:
writer = csv.writer(f_out, **setup.INDEX_CONFIG)
for row in tqdm(TrainArgsIterator(max_args=max_args)):
arg_id, arg_text = row
bm25_index = bm25_model.arg_ids.index(arg_id)
doc_frec = bm25_model.doc_freqs[bm25_index]
doc_len = bm25_model.doc_len[bm25_index]
arg_emb, unk = Argument.to_vec(arg_text, cbow_model, vector_size)
writer.writerow([
arg_id,
json.dumps(doc_frec),
[round(i, 14) for i in arg_emb.tolist()],
doc_len,
]) | [
"def",
"create",
"(",
"cbow_model",
",",
"bm25_model",
",",
"max_args",
"=",
"-",
"1",
")",
":",
"vector_size",
"=",
"cbow_model",
".",
"vector_size",
"with",
"open",
"(",
"setup",
".",
"INDEX_PATH",
",",
"'w'",
",",
"encoding",
"=",
"'utf-8'",
",",
"newline",
"=",
"''",
")",
"as",
"f_out",
":",
"writer",
"=",
"csv",
".",
"writer",
"(",
"f_out",
",",
"*",
"*",
"setup",
".",
"INDEX_CONFIG",
")",
"for",
"row",
"in",
"tqdm",
"(",
"TrainArgsIterator",
"(",
"max_args",
"=",
"max_args",
")",
")",
":",
"arg_id",
",",
"arg_text",
"=",
"row",
"bm25_index",
"=",
"bm25_model",
".",
"arg_ids",
".",
"index",
"(",
"arg_id",
")",
"doc_frec",
"=",
"bm25_model",
".",
"doc_freqs",
"[",
"bm25_index",
"]",
"doc_len",
"=",
"bm25_model",
".",
"doc_len",
"[",
"bm25_index",
"]",
"arg_emb",
",",
"unk",
"=",
"Argument",
".",
"to_vec",
"(",
"arg_text",
",",
"cbow_model",
",",
"vector_size",
")",
"writer",
".",
"writerow",
"(",
"[",
"arg_id",
",",
"json",
".",
"dumps",
"(",
"doc_frec",
")",
",",
"[",
"round",
"(",
"i",
",",
"14",
")",
"for",
"i",
"in",
"arg_emb",
".",
"tolist",
"(",
")",
"]",
",",
"doc_len",
",",
"]",
")"
] | [
30,
0
] | [
58,
14
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
|
main | () | Main erledigt nur das Eingabehandling
| Main erledigt nur das Eingabehandling
| def main():
""" Main erledigt nur das Eingabehandling
"""
epilog = """Example:
\tmyscript -h - Shows {help}-Info!""".format(
help=colored('{}'.format("Help"), "green"))
parser = argparse.ArgumentParser(
description='Template for future scripts ({})'.format(
colored('v{}'.format(version), "green")),
epilog=epilog, formatter_class=argparse.RawTextHelpFormatter)
parser.add_argument('param', nargs='*',
help='Add this param for demonstration')
parser.add_argument('-i', '--info', action='store_true',
help='Shows Script infos')
parser.add_argument('--dry-run', action='store_true', dest='dry_run',
help='Does nothing, only shows cmdline output')
args = parser.parse_args()
if args.info:
show_script_infos()
return
if not args or len(sys.argv) == 1 or args.param is None:
parser.print_help()
parser.exit()
return
global dry_run
dry_run = args.dry_run
if args.param is not None and len(args.param) != 0:
call_bash_command(args.param[0])
return | [
"def",
"main",
"(",
")",
":",
"epilog",
"=",
"\"\"\"Example:\n \\tmyscript -h - Shows {help}-Info!\"\"\"",
".",
"format",
"(",
"help",
"=",
"colored",
"(",
"'{}'",
".",
"format",
"(",
"\"Help\"",
")",
",",
"\"green\"",
")",
")",
"parser",
"=",
"argparse",
".",
"ArgumentParser",
"(",
"description",
"=",
"'Template for future scripts ({})'",
".",
"format",
"(",
"colored",
"(",
"'v{}'",
".",
"format",
"(",
"version",
")",
",",
"\"green\"",
")",
")",
",",
"epilog",
"=",
"epilog",
",",
"formatter_class",
"=",
"argparse",
".",
"RawTextHelpFormatter",
")",
"parser",
".",
"add_argument",
"(",
"'param'",
",",
"nargs",
"=",
"'*'",
",",
"help",
"=",
"'Add this param for demonstration'",
")",
"parser",
".",
"add_argument",
"(",
"'-i'",
",",
"'--info'",
",",
"action",
"=",
"'store_true'",
",",
"help",
"=",
"'Shows Script infos'",
")",
"parser",
".",
"add_argument",
"(",
"'--dry-run'",
",",
"action",
"=",
"'store_true'",
",",
"dest",
"=",
"'dry_run'",
",",
"help",
"=",
"'Does nothing, only shows cmdline output'",
")",
"args",
"=",
"parser",
".",
"parse_args",
"(",
")",
"if",
"args",
".",
"info",
":",
"show_script_infos",
"(",
")",
"return",
"if",
"not",
"args",
"or",
"len",
"(",
"sys",
".",
"argv",
")",
"==",
"1",
"or",
"args",
".",
"param",
"is",
"None",
":",
"parser",
".",
"print_help",
"(",
")",
"parser",
".",
"exit",
"(",
")",
"return",
"global",
"dry_run",
"dry_run",
"=",
"args",
".",
"dry_run",
"if",
"args",
".",
"param",
"is",
"not",
"None",
"and",
"len",
"(",
"args",
".",
"param",
")",
"!=",
"0",
":",
"call_bash_command",
"(",
"args",
".",
"param",
"[",
"0",
"]",
")",
"return"
] | [
82,
0
] | [
121,
14
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
|
tri | (length) | Zeichnet ein gleichseitiges Dreieck
rund um den Mittelpunkt des Dreiecks. | Zeichnet ein gleichseitiges Dreieck
rund um den Mittelpunkt des Dreiecks. | def tri(length):
"""Zeichnet ein gleichseitiges Dreieck
rund um den Mittelpunkt des Dreiecks."""
triangle(0, -length,
-length*sqrt(3)/2, length/2,
length*sqrt(3)/2, length/2) | [
"def",
"tri",
"(",
"length",
")",
":",
"triangle",
"(",
"0",
",",
"-",
"length",
",",
"-",
"length",
"*",
"sqrt",
"(",
"3",
")",
"/",
"2",
",",
"length",
"/",
"2",
",",
"length",
"*",
"sqrt",
"(",
"3",
")",
"/",
"2",
",",
"length",
"/",
"2",
")"
] | [
12,
0
] | [
17,
40
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
|
Arc.intersect_line | (self, line, rtol=1e-03, atol=1e-03, include_end=False) | return remaining_points | Von einem Arc-Objekt und einem Line-Objekt werden die
Schnittpunkte bestimmt und in einer Liste ausgegeben
| Von einem Arc-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 Arc-Objekt und einem Line-Objekt werden die
Schnittpunkte bestimmt und in einer Liste ausgegeben
"""
points = super(Arc, self).intersect_line(line, rtol, atol, include_end)
# all possible points have been found
# Lets see if they are on a arc
remaining_points = []
for p in points:
if self.is_point_inside(p, rtol, atol, include_end):
remaining_points.append(p)
return remaining_points | [
"def",
"intersect_line",
"(",
"self",
",",
"line",
",",
"rtol",
"=",
"1e-03",
",",
"atol",
"=",
"1e-03",
",",
"include_end",
"=",
"False",
")",
":",
"points",
"=",
"super",
"(",
"Arc",
",",
"self",
")",
".",
"intersect_line",
"(",
"line",
",",
"rtol",
",",
"atol",
",",
"include_end",
")",
"# all possible points have been found",
"# Lets see if they are on a arc",
"remaining_points",
"=",
"[",
"]",
"for",
"p",
"in",
"points",
":",
"if",
"self",
".",
"is_point_inside",
"(",
"p",
",",
"rtol",
",",
"atol",
",",
"include_end",
")",
":",
"remaining_points",
".",
"append",
"(",
"p",
")",
"return",
"remaining_points"
] | [
680,
4
] | [
692,
31
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
input | (values: dict, data: StepData, name: str, save_key, ignore_testing=False) | Hier können Daten angegeben werden, die einfach hinzugefügt werden.
:param values: Werte aus der JSON-Datei
:param data: Daten aus der API
:param name: Testdatei, die geladen werden soll.
:param save_key: Key, unter dem die Daten gespeichert werden.
:param ignore_testing: Ob der Request durchgeführt werden soll, obwohl testing `true` ist.
| Hier können Daten angegeben werden, die einfach hinzugefügt werden. | def input(values: dict, data: StepData, name: str, save_key, ignore_testing=False):
"""Hier können Daten angegeben werden, die einfach hinzugefügt werden.
:param values: Werte aus der JSON-Datei
:param data: Daten aus der API
:param name: Testdatei, die geladen werden soll.
:param save_key: Key, unter dem die Daten gespeichert werden.
:param ignore_testing: Ob der Request durchgeführt werden soll, obwohl testing `true` ist.
"""
res = data.deep_format(values["data"], values=values)
data.insert_data(save_key, res, values) | [
"def",
"input",
"(",
"values",
":",
"dict",
",",
"data",
":",
"StepData",
",",
"name",
":",
"str",
",",
"save_key",
",",
"ignore_testing",
"=",
"False",
")",
":",
"res",
"=",
"data",
".",
"deep_format",
"(",
"values",
"[",
"\"data\"",
"]",
",",
"values",
"=",
"values",
")",
"data",
".",
"insert_data",
"(",
"save_key",
",",
"res",
",",
"values",
")"
] | [
60,
0
] | [
71,
43
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
|
get_quarterspan | (date) | return startdate, enddate | Gibt den ersten und den letzten Tag des Quartals zurück in dem `date` liegt
>>> get_quarterspan(datetime.date(1978, 6, 12))
(datetime.date(1978, 4, 1), datetime.date(1978, 6, 30))
| Gibt den ersten und den letzten Tag des Quartals zurück in dem `date` liegt | def get_quarterspan(date):
"""Gibt den ersten und den letzten Tag des Quartals zurück in dem `date` liegt
>>> get_quarterspan(datetime.date(1978, 6, 12))
(datetime.date(1978, 4, 1), datetime.date(1978, 6, 30))
"""
startdate = date_trunc('quarter', date)
# The date 100 days after the beginning of a quarter is always right inside the next quarter
enddate = date_trunc('quarter', startdate + datetime.timedelta(days=100)) - datetime.timedelta(days=1)
return startdate, enddate | [
"def",
"get_quarterspan",
"(",
"date",
")",
":",
"startdate",
"=",
"date_trunc",
"(",
"'quarter'",
",",
"date",
")",
"# The date 100 days after the beginning of a quarter is always right inside the next quarter",
"enddate",
"=",
"date_trunc",
"(",
"'quarter'",
",",
"startdate",
"+",
"datetime",
".",
"timedelta",
"(",
"days",
"=",
"100",
")",
")",
"-",
"datetime",
".",
"timedelta",
"(",
"days",
"=",
"1",
")",
"return",
"startdate",
",",
"enddate"
] | [
173,
0
] | [
183,
29
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
CoolDownHelper.IsOnUserCooldown | ( self, scriptname, command, user ) | return thisResponse | Cooldown für User abfragen | Cooldown für User abfragen | def IsOnUserCooldown( self, scriptname, command, user ):
'''Cooldown für User abfragen'''
thisActionName = "IsOnCooldown"
UserDisplayName = self.Parent.GetDisplayName( user )
thisResponse = False
if self.Parent.IsOnUserCooldown( scriptname, command.lower(), user ):
thisResponse = True
if ( self.Debug ):
self.Logger.WriteDebug( command, "User '{0}' im Cooldown? - {1}".format(UserDisplayName,
thisResponse))
# self.Logger.WriteLog( command + ": User '{0}' im Cooldown? - {1}".format(UserDisplayName,
# thisResponse))
return thisResponse | [
"def",
"IsOnUserCooldown",
"(",
"self",
",",
"scriptname",
",",
"command",
",",
"user",
")",
":",
"thisActionName",
"=",
"\"IsOnCooldown\"",
"UserDisplayName",
"=",
"self",
".",
"Parent",
".",
"GetDisplayName",
"(",
"user",
")",
"thisResponse",
"=",
"False",
"if",
"self",
".",
"Parent",
".",
"IsOnUserCooldown",
"(",
"scriptname",
",",
"command",
".",
"lower",
"(",
")",
",",
"user",
")",
":",
"thisResponse",
"=",
"True",
"if",
"(",
"self",
".",
"Debug",
")",
":",
"self",
".",
"Logger",
".",
"WriteDebug",
"(",
"command",
",",
"\"User '{0}' im Cooldown? - {1}\"",
".",
"format",
"(",
"UserDisplayName",
",",
"thisResponse",
")",
")",
"# self.Logger.WriteLog( command + \": User '{0}' im Cooldown? - {1}\".format(UserDisplayName,\r",
"# thisResponse))\r",
"return",
"thisResponse"
] | [
43,
4
] | [
59,
27
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
convert | (values: dict, data: StepData) | Konvertiert ein Datentyp in einen anderen Datentyp.
:param values: Werte aus der JSON-Datei
:param data: Daten aus der API
:return:
| Konvertiert ein Datentyp in einen anderen Datentyp. | def convert(values: dict, data: StepData):
"""Konvertiert ein Datentyp in einen anderen Datentyp.
:param values: Werte aus der JSON-Datei
:param data: Daten aus der API
:return:
"""
new_type = locate(values["to"])
for idx, key in data.loop_key(values["keys"], values):
new_key = get_new_keys(values, idx)
value = new_type(data.get_data(key, values))
data.insert_data(new_key, value, values) | [
"def",
"convert",
"(",
"values",
":",
"dict",
",",
"data",
":",
"StepData",
")",
":",
"new_type",
"=",
"locate",
"(",
"values",
"[",
"\"to\"",
"]",
")",
"for",
"idx",
",",
"key",
"in",
"data",
".",
"loop_key",
"(",
"values",
"[",
"\"keys\"",
"]",
",",
"values",
")",
":",
"new_key",
"=",
"get_new_keys",
"(",
"values",
",",
"idx",
")",
"value",
"=",
"new_type",
"(",
"data",
".",
"get_data",
"(",
"key",
",",
"values",
")",
")",
"data",
".",
"insert_data",
"(",
"new_key",
",",
"value",
",",
"values",
")"
] | [
503,
0
] | [
515,
48
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
|
ispBase.getMetaErrorString | ( self, meta:dict={} ) | return meta_str | Erzeugt einen String aus Metadata für Fehler Angaben
Parameters
----------
meta : DotMap, optional
Metadata. The default is {}.
Returns
-------
meta_str : str
| Erzeugt einen String aus Metadata für Fehler Angaben | def getMetaErrorString( self, meta:dict={} ):
"""Erzeugt einen String aus Metadata für Fehler Angaben
Parameters
----------
meta : DotMap, optional
Metadata. The default is {}.
Returns
-------
meta_str : str
"""
current = {
"testTag":"ispBase.checkFields",
"year": "",
"month": "",
"unit":"",
"energy":""
}
if isinstance( meta, dict ) and isinstance( meta["current"], dict ):
current.update( meta.current )
# string zusammenstellen
meta_str = "{testTag} {unit}-{energy} {year}/{month}".format( **current )
return meta_str | [
"def",
"getMetaErrorString",
"(",
"self",
",",
"meta",
":",
"dict",
"=",
"{",
"}",
")",
":",
"current",
"=",
"{",
"\"testTag\"",
":",
"\"ispBase.checkFields\"",
",",
"\"year\"",
":",
"\"\"",
",",
"\"month\"",
":",
"\"\"",
",",
"\"unit\"",
":",
"\"\"",
",",
"\"energy\"",
":",
"\"\"",
"}",
"if",
"isinstance",
"(",
"meta",
",",
"dict",
")",
"and",
"isinstance",
"(",
"meta",
"[",
"\"current\"",
"]",
",",
"dict",
")",
":",
"current",
".",
"update",
"(",
"meta",
".",
"current",
")",
"# string zusammenstellen",
"meta_str",
"=",
"\"{testTag} {unit}-{energy} {year}/{month}\"",
".",
"format",
"(",
"*",
"*",
"current",
")",
"return",
"meta_str"
] | [
177,
4
] | [
204,
23
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
MQTTclass.emit | (self, record) | Die Funktion emit muss für die Verwendung als logger vorhanden sein.
Do whatever it takes to actually log the specified logging record.
This version is intended to be implemented by subclasses and so
raises a NotImplementedError.
https://docs.python.org/3/library/logging.html#logging.LogRecord
| Die Funktion emit muss für die Verwendung als logger vorhanden sein. | def emit(self, record):
"""Die Funktion emit muss für die Verwendung als logger vorhanden sein.
Do whatever it takes to actually log the specified logging record.
This version is intended to be implemented by subclasses and so
raises a NotImplementedError.
https://docs.python.org/3/library/logging.html#logging.LogRecord
"""
#formatter = "%(asctime)s — %(name)s — %(levelname)s — %(funcName)s:%(lineno)d — %(message)s"
'''
'<LogRecord: %s, %s, %s, %s, "%s">'%(self.name, self.levelno,
self.pathname, self.lineno, self.msg)
'''
ts = time.strftime("%Y%m%d %H:%M:%S", time.localtime(time.time()) )
# gibt es einen MQTT Handler dann über ihn loggen
if self._mqttc:
msg = {
"topic" : "logging/" + record.levelname,
"payload" : {
"time": ts,
"name" : record.name,
"level" : record.levelname,
"pathname" : record.pathname,
"filename" : record.filename,
"module" : record.module,
"funcName": record.funcName,
"lineno": record.lineno,
"exc_info" : record.exc_info,
"msg" : record.msg,
"args" : record.args,
}
}
try:
self.publish( msg )
except: # pragma: no cover
print( "logging.emit: Error bei publish", msg ) | [
"def",
"emit",
"(",
"self",
",",
"record",
")",
":",
"#formatter = \"%(asctime)s — %(name)s — %(levelname)s — %(funcName)s:%(lineno)d — %(message)s\"",
"'''\n '<LogRecord: %s, %s, %s, %s, \"%s\">'%(self.name, self.levelno,\n self.pathname, self.lineno, self.msg)\n '''",
"ts",
"=",
"time",
".",
"strftime",
"(",
"\"%Y%m%d %H:%M:%S\"",
",",
"time",
".",
"localtime",
"(",
"time",
".",
"time",
"(",
")",
")",
")",
"# gibt es einen MQTT Handler dann über ihn loggen",
"if",
"self",
".",
"_mqttc",
":",
"msg",
"=",
"{",
"\"topic\"",
":",
"\"logging/\"",
"+",
"record",
".",
"levelname",
",",
"\"payload\"",
":",
"{",
"\"time\"",
":",
"ts",
",",
"\"name\"",
":",
"record",
".",
"name",
",",
"\"level\"",
":",
"record",
".",
"levelname",
",",
"\"pathname\"",
":",
"record",
".",
"pathname",
",",
"\"filename\"",
":",
"record",
".",
"filename",
",",
"\"module\"",
":",
"record",
".",
"module",
",",
"\"funcName\"",
":",
"record",
".",
"funcName",
",",
"\"lineno\"",
":",
"record",
".",
"lineno",
",",
"\"exc_info\"",
":",
"record",
".",
"exc_info",
",",
"\"msg\"",
":",
"record",
".",
"msg",
",",
"\"args\"",
":",
"record",
".",
"args",
",",
"}",
"}",
"try",
":",
"self",
".",
"publish",
"(",
"msg",
")",
"except",
":",
"# pragma: no cover",
"print",
"(",
"\"logging.emit: Error bei publish\"",
",",
"msg",
")"
] | [
793,
4
] | [
833,
63
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
|
ariaClass.getTestData | ( self,
PatientId=None,
AcquisitionYear=None,
AcquisitionMonth=None,
AcquisitionDay=None,
testTags:list=None, addWhere:str="" ) | return data | Alle Felder für ein Gerät, einen testTag und das angegebene Jahr holen
und data aufbereiten
| Alle Felder für ein Gerät, einen testTag und das angegebene Jahr holen | def getTestData( self,
PatientId=None,
AcquisitionYear=None,
AcquisitionMonth=None,
AcquisitionDay=None,
testTags:list=None, addWhere:str="" ):
""" Alle Felder für ein Gerät, einen testTag und das angegebene Jahr holen
und data aufbereiten
"""
imagedatas, sql = self.getImages(
PatientId = PatientId,
AcquisitionYear=AcquisitionYear,
AcquisitionMonth=AcquisitionMonth,
AcquisitionDay=AcquisitionDay,
testTags=testTags
)
data = {}
for imagedata in imagedatas:
# bereitetet die Datenbank Informationen auf
info = self.getImageInfos( imagedata )
# test auf testTag um ungültige auszuschließen z.B.suche nach 10.3 findet auch 10.3.1
# da in der SQL mit CHARINDEX gesucht wird werden auch Teile gefunden
ok = False
for tt in testTags:
if tt in info["testTags"]:
ok = True
if not ok:
continue
if not info["energy"] in data:
data[ info["energy"] ] = {}
data[ info["energy"] ][ info["SliceUID"] ] = info
return data | [
"def",
"getTestData",
"(",
"self",
",",
"PatientId",
"=",
"None",
",",
"AcquisitionYear",
"=",
"None",
",",
"AcquisitionMonth",
"=",
"None",
",",
"AcquisitionDay",
"=",
"None",
",",
"testTags",
":",
"list",
"=",
"None",
",",
"addWhere",
":",
"str",
"=",
"\"\"",
")",
":",
"imagedatas",
",",
"sql",
"=",
"self",
".",
"getImages",
"(",
"PatientId",
"=",
"PatientId",
",",
"AcquisitionYear",
"=",
"AcquisitionYear",
",",
"AcquisitionMonth",
"=",
"AcquisitionMonth",
",",
"AcquisitionDay",
"=",
"AcquisitionDay",
",",
"testTags",
"=",
"testTags",
")",
"data",
"=",
"{",
"}",
"for",
"imagedata",
"in",
"imagedatas",
":",
"# bereitetet die Datenbank Informationen auf",
"info",
"=",
"self",
".",
"getImageInfos",
"(",
"imagedata",
")",
"# test auf testTag um ungültige auszuschließen z.B.suche nach 10.3 findet auch 10.3.1",
"# da in der SQL mit CHARINDEX gesucht wird werden auch Teile gefunden",
"ok",
"=",
"False",
"for",
"tt",
"in",
"testTags",
":",
"if",
"tt",
"in",
"info",
"[",
"\"testTags\"",
"]",
":",
"ok",
"=",
"True",
"if",
"not",
"ok",
":",
"continue",
"if",
"not",
"info",
"[",
"\"energy\"",
"]",
"in",
"data",
":",
"data",
"[",
"info",
"[",
"\"energy\"",
"]",
"]",
"=",
"{",
"}",
"data",
"[",
"info",
"[",
"\"energy\"",
"]",
"]",
"[",
"info",
"[",
"\"SliceUID\"",
"]",
"]",
"=",
"info",
"return",
"data"
] | [
190,
4
] | [
229,
19
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
dicomClass.initAE | ( self ) | return status | Application Entity bereitstellen
Status Codes: Non-service specific - 0xC000 to 0xC0FF
Verwendete evt_handlers::
* EVT_ESTABLISHED
* EVT_REJECTED
* EVT_RELEASED
Returns
-------
status : hex
- 0x0000 - alles OK
- 0xC0FF -Verbindung fehlgeschlagen
| Application Entity bereitstellen
Status Codes: Non-service specific - 0xC000 to 0xC0FF | def initAE( self ):
"""Application Entity bereitstellen
Status Codes: Non-service specific - 0xC000 to 0xC0FF
Verwendete evt_handlers::
* EVT_ESTABLISHED
* EVT_REJECTED
* EVT_RELEASED
Returns
-------
status : hex
- 0x0000 - alles OK
- 0xC0FF -Verbindung fehlgeschlagen
"""
# print( "dicomClass.initAE: ", self.config.dicom[self.server] )
# Initialise the Application Entity
assoc = None
try:
# Initialise the Application Entity
self.ae = AE( ae_title=self.config.dicom[self.server]["aet"] )
# Study Suche verwenden
self.ae.add_requested_context( StudyRootQueryRetrieveInformationModelFind )
# Add a requested presentation context
self.ae.add_requested_context( StudyRootQueryRetrieveInformationModelMove )
# Add the storage SCP's supported presentation contexts
self.ae.supported_contexts = StoragePresentationContexts
self.ae.add_supported_context( RTImageStorage )
# bei den handlern wird nicht auf EVT_REJECTED geprüft, da offline ja möglich ist
handlers=[
( evt.EVT_ESTABLISHED , self.handle_event),
#( evt.EVT_REJECTED , self.handle_event),
( evt.EVT_RELEASED, self.handle_event),
]
# Associate with peer AE at IP 127.0.0.1 and port 11112
assoc = self.ae.associate(
self.config.dicom[self.server]['server_ip'],
self.config.dicom[self.server]['server_port'],
ae_title=self.config.dicom[self.server]['aec'],
evt_handlers=handlers
)
except:
pass
self.assoc = None
status = 0xC0FF
if assoc and assoc.is_established:
self.assoc = assoc
status = 0x0000
logger.debug('dicomClass.initAE: Verbindung hergestellt')
else:
logger.warning('dicomClass.initAE: Association rejected, aborted or never connected')
return status | [
"def",
"initAE",
"(",
"self",
")",
":",
"# print( \"dicomClass.initAE: \", self.config.dicom[self.server] ) ",
"# Initialise the Application Entity",
"assoc",
"=",
"None",
"try",
":",
"# Initialise the Application Entity",
"self",
".",
"ae",
"=",
"AE",
"(",
"ae_title",
"=",
"self",
".",
"config",
".",
"dicom",
"[",
"self",
".",
"server",
"]",
"[",
"\"aet\"",
"]",
")",
"# Study Suche verwenden",
"self",
".",
"ae",
".",
"add_requested_context",
"(",
"StudyRootQueryRetrieveInformationModelFind",
")",
"# Add a requested presentation context",
"self",
".",
"ae",
".",
"add_requested_context",
"(",
"StudyRootQueryRetrieveInformationModelMove",
")",
"# Add the storage SCP's supported presentation contexts",
"self",
".",
"ae",
".",
"supported_contexts",
"=",
"StoragePresentationContexts",
"self",
".",
"ae",
".",
"add_supported_context",
"(",
"RTImageStorage",
")",
"# bei den handlern wird nicht auf EVT_REJECTED geprüft, da offline ja möglich ist",
"handlers",
"=",
"[",
"(",
"evt",
".",
"EVT_ESTABLISHED",
",",
"self",
".",
"handle_event",
")",
",",
"#( evt.EVT_REJECTED , self.handle_event),",
"(",
"evt",
".",
"EVT_RELEASED",
",",
"self",
".",
"handle_event",
")",
",",
"]",
"# Associate with peer AE at IP 127.0.0.1 and port 11112",
"assoc",
"=",
"self",
".",
"ae",
".",
"associate",
"(",
"self",
".",
"config",
".",
"dicom",
"[",
"self",
".",
"server",
"]",
"[",
"'server_ip'",
"]",
",",
"self",
".",
"config",
".",
"dicom",
"[",
"self",
".",
"server",
"]",
"[",
"'server_port'",
"]",
",",
"ae_title",
"=",
"self",
".",
"config",
".",
"dicom",
"[",
"self",
".",
"server",
"]",
"[",
"'aec'",
"]",
",",
"evt_handlers",
"=",
"handlers",
")",
"except",
":",
"pass",
"self",
".",
"assoc",
"=",
"None",
"status",
"=",
"0xC0FF",
"if",
"assoc",
"and",
"assoc",
".",
"is_established",
":",
"self",
".",
"assoc",
"=",
"assoc",
"status",
"=",
"0x0000",
"logger",
".",
"debug",
"(",
"'dicomClass.initAE: Verbindung hergestellt'",
")",
"else",
":",
"logger",
".",
"warning",
"(",
"'dicomClass.initAE: Association rejected, aborted or never connected'",
")",
"return",
"status"
] | [
138,
4
] | [
203,
21
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
update_toprecordings | () | Rufe alle top bewerteten otr Aufzeichnungen ab:
https://www.onlinetvrecorder.com/v2/?go=list&tab=toplist&tlview=all&listid=104&start=0
in 20er Paketen wird der content durchsucht und bei hohen Bewertungen das Recording in eine neue Partition verschoben
| Rufe alle top bewerteten otr Aufzeichnungen ab:
https://www.onlinetvrecorder.com/v2/?go=list&tab=toplist&tlview=all&listid=104&start=0
in 20er Paketen wird der content durchsucht und bei hohen Bewertungen das Recording in eine neue Partition verschoben
| def update_toprecordings():
""" Rufe alle top bewerteten otr Aufzeichnungen ab:
https://www.onlinetvrecorder.com/v2/?go=list&tab=toplist&tlview=all&listid=104&start=0
in 20er Paketen wird der content durchsucht und bei hohen Bewertungen das Recording in eine neue Partition verschoben
"""
log.debug('try to update toprecordings webcontent...')
stopflag = False
start = 0
toplist = []
while not stopflag:
""" download webcontent into content"""
with urllib.request.urlopen('https://www.onlinetvrecorder.com/v2/?go=list&tab=toplist&tlview=all&listid=104&start=' + str(start)) as response:
content = response.read()
""" für jeden Eintrag in ID= searchrow """
content = str(content.decode('utf-8', 'ignore')).split("<tr id='serchrow")
for index in range(1,len(content)):
lines = content[index].split('<td oncontextmenu="showNewTabMenu(')
""" epg id """
epg_id = lines[1].split(',')[0]
rating = lines[8].split('Beliebtheit: ')[1].split("'")[0]
previewimagelink = lines[10].split('<img src=')[1].split(' width=')[0]
primarykey = datetime.strptime(lines[4].split('>')[1].split('<')[0], '%d.%m.%y').date().strftime('%Y_%m_%d')
log.debug('parsed recording: {} with rating: {} and preview = {}'.format(epg_id, rating, previewimagelink))
if rating in ['sehr hoch', 'hoch']:
entity = Recording(db.tableservice, PartitionKey = primarykey, RowKey = epg_id)
entity.rating = rating
entity.previewimagelink = previewimagelink
if entity.exists():
top = entity.copyto('top')
if not top.exists():
top.save(False)
log.info('recording {} moved or is already moved successfully ({}, {!s}, at {})'.format(epg_id,top.titel, top.beginn, top.sender))
else:
log.info('epg not found: {} with rating: {} and preview = {}'.format(epg_id, rating, previewimagelink))
else:
stopflag = True
start = start + 20
log.info('toprecordings successfully retireved!') | [
"def",
"update_toprecordings",
"(",
")",
":",
"log",
".",
"debug",
"(",
"'try to update toprecordings webcontent...'",
")",
"stopflag",
"=",
"False",
"start",
"=",
"0",
"toplist",
"=",
"[",
"]",
"while",
"not",
"stopflag",
":",
"\"\"\" download webcontent into content\"\"\"",
"with",
"urllib",
".",
"request",
".",
"urlopen",
"(",
"'https://www.onlinetvrecorder.com/v2/?go=list&tab=toplist&tlview=all&listid=104&start='",
"+",
"str",
"(",
"start",
")",
")",
"as",
"response",
":",
"content",
"=",
"response",
".",
"read",
"(",
")",
"\"\"\" für jeden Eintrag in ID= searchrow \"\"\"",
"content",
"=",
"str",
"(",
"content",
".",
"decode",
"(",
"'utf-8'",
",",
"'ignore'",
")",
")",
".",
"split",
"(",
"\"<tr id='serchrow\"",
")",
"for",
"index",
"in",
"range",
"(",
"1",
",",
"len",
"(",
"content",
")",
")",
":",
"lines",
"=",
"content",
"[",
"index",
"]",
".",
"split",
"(",
"'<td oncontextmenu=\"showNewTabMenu('",
")",
"\"\"\" epg id \"\"\"",
"epg_id",
"=",
"lines",
"[",
"1",
"]",
".",
"split",
"(",
"','",
")",
"[",
"0",
"]",
"rating",
"=",
"lines",
"[",
"8",
"]",
".",
"split",
"(",
"'Beliebtheit: '",
")",
"[",
"1",
"]",
".",
"split",
"(",
"\"'\"",
")",
"[",
"0",
"]",
"previewimagelink",
"=",
"lines",
"[",
"10",
"]",
".",
"split",
"(",
"'<img src='",
")",
"[",
"1",
"]",
".",
"split",
"(",
"' width='",
")",
"[",
"0",
"]",
"primarykey",
"=",
"datetime",
".",
"strptime",
"(",
"lines",
"[",
"4",
"]",
".",
"split",
"(",
"'>'",
")",
"[",
"1",
"]",
".",
"split",
"(",
"'<'",
")",
"[",
"0",
"]",
",",
"'%d.%m.%y'",
")",
".",
"date",
"(",
")",
".",
"strftime",
"(",
"'%Y_%m_%d'",
")",
"log",
".",
"debug",
"(",
"'parsed recording: {} with rating: {} and preview = {}'",
".",
"format",
"(",
"epg_id",
",",
"rating",
",",
"previewimagelink",
")",
")",
"if",
"rating",
"in",
"[",
"'sehr hoch'",
",",
"'hoch'",
"]",
":",
"entity",
"=",
"Recording",
"(",
"db",
".",
"tableservice",
",",
"PartitionKey",
"=",
"primarykey",
",",
"RowKey",
"=",
"epg_id",
")",
"entity",
".",
"rating",
"=",
"rating",
"entity",
".",
"previewimagelink",
"=",
"previewimagelink",
"if",
"entity",
".",
"exists",
"(",
")",
":",
"top",
"=",
"entity",
".",
"copyto",
"(",
"'top'",
")",
"if",
"not",
"top",
".",
"exists",
"(",
")",
":",
"top",
".",
"save",
"(",
"False",
")",
"log",
".",
"info",
"(",
"'recording {} moved or is already moved successfully ({}, {!s}, at {})'",
".",
"format",
"(",
"epg_id",
",",
"top",
".",
"titel",
",",
"top",
".",
"beginn",
",",
"top",
".",
"sender",
")",
")",
"else",
":",
"log",
".",
"info",
"(",
"'epg not found: {} with rating: {} and preview = {}'",
".",
"format",
"(",
"epg_id",
",",
"rating",
",",
"previewimagelink",
")",
")",
"else",
":",
"stopflag",
"=",
"True",
"start",
"=",
"start",
"+",
"20",
"log",
".",
"info",
"(",
"'toprecordings successfully retireved!'",
")"
] | [
111,
0
] | [
160,
53
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
|
testBase.run_test | (self, params) | Einen Test über die Api durchführen
Parameters
----------
params : dict
DESCRIPTION.
Returns
-------
None.
| Einen Test über die Api durchführen | def run_test(self, params):
''' Einen Test über die Api durchführen
Parameters
----------
params : dict
DESCRIPTION.
Returns
-------
None.
'''
url = '/api/gqa/run'
# Unittest verwenden, damit das Ergebnis und nicht alle Daten des Jahres geliefert werden
params["unittest"] = True
response = self.app.get( url, query_string = params )
self.assertEqual(response.status_code, 200, "Api Rückgabe fehlerhaft")
result = response.json["data"]
appError = response.json['App-Error']
appInfo = response.json['App-Info']
self.assertGreater(
len( result ), 0,
"keine Test Rückgabe: '{unit}', '{testid}'".format( **params )
)
# es dürfen keine App-Error Angaben vorliegen
self.assertListEqual(
appError, [],
"App-Error: {}".format( json.dumps(appError) )
)
# pro pdffile die test_results im Ergebnis prüfen wenn es eine results datei gibt
if self.gqa_data_ready:
for pdf_name, data in result.items():
self.check_pdf_data( data["pdfData"] )
# pro test im pdffile
for test in data["result"]:
#print("run_test - test", test )
#testid = self.testIds
try:
orgData = self.gqa.loc[ test["unit"], test["energy"], test["test"], test["date"], test["group"] ].to_dict( )
except:
orgData = {}
self.assertNotEqual(
orgData, {},
"keine Vergleichsdaten vorhanden: '{unit}', '{energy}', '{test}', '{date}', {group}".format( **test )
)
self.assertListEqual(
orgData["data"],
test["data"],
"Datenfehler im Testresult: '{unit}', '{energy}', '{test}', '{date}', {group}'".format( **test )
) | [
"def",
"run_test",
"(",
"self",
",",
"params",
")",
":",
"url",
"=",
"'/api/gqa/run'",
"# Unittest verwenden, damit das Ergebnis und nicht alle Daten des Jahres geliefert werden",
"params",
"[",
"\"unittest\"",
"]",
"=",
"True",
"response",
"=",
"self",
".",
"app",
".",
"get",
"(",
"url",
",",
"query_string",
"=",
"params",
")",
"self",
".",
"assertEqual",
"(",
"response",
".",
"status_code",
",",
"200",
",",
"\"Api Rückgabe fehlerhaft\")",
"",
"result",
"=",
"response",
".",
"json",
"[",
"\"data\"",
"]",
"appError",
"=",
"response",
".",
"json",
"[",
"'App-Error'",
"]",
"appInfo",
"=",
"response",
".",
"json",
"[",
"'App-Info'",
"]",
"self",
".",
"assertGreater",
"(",
"len",
"(",
"result",
")",
",",
"0",
",",
"\"keine Test Rückgabe: '{unit}', '{testid}'\".",
"f",
"ormat(",
" ",
"*",
"p",
"arams ",
"",
")",
"# es dürfen keine App-Error Angaben vorliegen",
"self",
".",
"assertListEqual",
"(",
"appError",
",",
"[",
"]",
",",
"\"App-Error: {}\"",
".",
"format",
"(",
"json",
".",
"dumps",
"(",
"appError",
")",
")",
")",
"# pro pdffile die test_results im Ergebnis prüfen wenn es eine results datei gibt",
"if",
"self",
".",
"gqa_data_ready",
":",
"for",
"pdf_name",
",",
"data",
"in",
"result",
".",
"items",
"(",
")",
":",
"self",
".",
"check_pdf_data",
"(",
"data",
"[",
"\"pdfData\"",
"]",
")",
"# pro test im pdffile",
"for",
"test",
"in",
"data",
"[",
"\"result\"",
"]",
":",
"#print(\"run_test - test\", test )",
"#testid = self.testIds",
"try",
":",
"orgData",
"=",
"self",
".",
"gqa",
".",
"loc",
"[",
"test",
"[",
"\"unit\"",
"]",
",",
"test",
"[",
"\"energy\"",
"]",
",",
"test",
"[",
"\"test\"",
"]",
",",
"test",
"[",
"\"date\"",
"]",
",",
"test",
"[",
"\"group\"",
"]",
"]",
".",
"to_dict",
"(",
")",
"except",
":",
"orgData",
"=",
"{",
"}",
"self",
".",
"assertNotEqual",
"(",
"orgData",
",",
"{",
"}",
",",
"\"keine Vergleichsdaten vorhanden: '{unit}', '{energy}', '{test}', '{date}', {group}\"",
".",
"format",
"(",
"*",
"*",
"test",
")",
")",
"self",
".",
"assertListEqual",
"(",
"orgData",
"[",
"\"data\"",
"]",
",",
"test",
"[",
"\"data\"",
"]",
",",
"\"Datenfehler im Testresult: '{unit}', '{energy}', '{test}', '{date}', {group}'\"",
".",
"format",
"(",
"*",
"*",
"test",
")",
")"
] | [
148,
4
] | [
209,
21
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
|
capitalize | (values: dict, data: StepData) | Der erste Buchstabe jedes Worts in der Liste wird groß geschrieben.
:param values: Werte aus der JSON-Datei
:param data: Daten aus der API
:return:
| Der erste Buchstabe jedes Worts in der Liste wird groß geschrieben. | def capitalize(values: dict, data: StepData):
"""Der erste Buchstabe jedes Worts in der Liste wird groß geschrieben.
:param values: Werte aus der JSON-Datei
:param data: Daten aus der API
:return:
"""
for idx, key in data.loop_key(values["keys"], values):
value = data.get_data(key, values)
new_key = get_new_keys(values, idx)
new_value = [each.capitalize() for each in value]
data.insert_data(new_key, new_value, values) | [
"def",
"capitalize",
"(",
"values",
":",
"dict",
",",
"data",
":",
"StepData",
")",
":",
"for",
"idx",
",",
"key",
"in",
"data",
".",
"loop_key",
"(",
"values",
"[",
"\"keys\"",
"]",
",",
"values",
")",
":",
"value",
"=",
"data",
".",
"get_data",
"(",
"key",
",",
"values",
")",
"new_key",
"=",
"get_new_keys",
"(",
"values",
",",
"idx",
")",
"new_value",
"=",
"[",
"each",
".",
"capitalize",
"(",
")",
"for",
"each",
"in",
"value",
"]",
"data",
".",
"insert_data",
"(",
"new_key",
",",
"new_value",
",",
"values",
")"
] | [
701,
0
] | [
713,
52
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
|
WriteDataToFile | ( file, text ) | return True | Schreibe Text in eine Datei und überschreibe den bestehenden Inhalt | Schreibe Text in eine Datei und überschreibe den bestehenden Inhalt | def WriteDataToFile( file, text ):
''' Schreibe Text in eine Datei und überschreibe den bestehenden Inhalt '''
thisActionName = "WriteDataToFile"
try:
with codecs.open( file, encoding="utf-8", mode="w") as f:
text = f.write( str( text ) )
f.close()
except:
return False
return True | [
"def",
"WriteDataToFile",
"(",
"file",
",",
"text",
")",
":",
"thisActionName",
"=",
"\"WriteDataToFile\"",
"try",
":",
"with",
"codecs",
".",
"open",
"(",
"file",
",",
"encoding",
"=",
"\"utf-8\"",
",",
"mode",
"=",
"\"w\"",
")",
"as",
"f",
":",
"text",
"=",
"f",
".",
"write",
"(",
"str",
"(",
"text",
")",
")",
"f",
".",
"close",
"(",
")",
"except",
":",
"return",
"False",
"return",
"True"
] | [
271,
0
] | [
282,
15
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
PdfGenerator.newPage | ( self, render=None ) | return element_html | Einen Seitenumbruch einfügen.
Parameters
----------
render : bool
sofort rendern oder nur zurückgeben ohne Angabe wird self.autoRender verwendet
Returns
-------
element_html : str
HTML für den erzeugten Seitenumbruch
| Einen Seitenumbruch einfügen. | def newPage( self, render=None ):
"""Einen Seitenumbruch einfügen.
Parameters
----------
render : bool
sofort rendern oder nur zurückgeben ohne Angabe wird self.autoRender verwendet
Returns
-------
element_html : str
HTML für den erzeugten Seitenumbruch
"""
if render == None:
render = self.autoRender
element_html = '<p class="page_break" style="page-break-after: always;"></p>'
if render:
self._html(element_html)
return element_html | [
"def",
"newPage",
"(",
"self",
",",
"render",
"=",
"None",
")",
":",
"if",
"render",
"==",
"None",
":",
"render",
"=",
"self",
".",
"autoRender",
"element_html",
"=",
"'<p class=\"page_break\" style=\"page-break-after: always;\"></p>'",
"if",
"render",
":",
"self",
".",
"_html",
"(",
"element_html",
")",
"return",
"element_html"
] | [
783,
4
] | [
803,
27
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
identisch | (a, b) | return abs(a-b) < 0.003 | Teste ob Werte identisch sind, berücksichtige Rundungsfehler
:param a: Wert 1
:type a: float
:param b: Wert 2
:type b: fload
:return: ist identisch
:rtype: bool
| Teste ob Werte identisch sind, berücksichtige Rundungsfehler | def identisch(a, b):
""" Teste ob Werte identisch sind, berücksichtige Rundungsfehler
:param a: Wert 1
:type a: float
:param b: Wert 2
:type b: fload
:return: ist identisch
:rtype: bool
"""
return abs(a-b) < 0.003 | [
"def",
"identisch",
"(",
"a",
",",
"b",
")",
":",
"return",
"abs",
"(",
"a",
"-",
"b",
")",
"<",
"0.003"
] | [
155,
0
] | [
165,
27
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
seperator | (values: dict, data: StepData) | Fügt Trennzeichen in einen Integer hinzu.
:param values: Werte aus der JSON-Datei
:param data: Daten aus der API
| Fügt Trennzeichen in einen Integer hinzu. | def seperator(values: dict, data: StepData):
"""Fügt Trennzeichen in einen Integer hinzu.
:param values: Werte aus der JSON-Datei
:param data: Daten aus der API
"""
for idx, key in data.loop_key(values["keys"], values):
value = int(data.get_data(key, values))
new_key = get_new_keys(values, idx)
new_value = '{:,}'.format(value).replace(',', data.format(values["seperator"], values))
data.insert_data(new_key, new_value, values) | [
"def",
"seperator",
"(",
"values",
":",
"dict",
",",
"data",
":",
"StepData",
")",
":",
"for",
"idx",
",",
"key",
"in",
"data",
".",
"loop_key",
"(",
"values",
"[",
"\"keys\"",
"]",
",",
"values",
")",
":",
"value",
"=",
"int",
"(",
"data",
".",
"get_data",
"(",
"key",
",",
"values",
")",
")",
"new_key",
"=",
"get_new_keys",
"(",
"values",
",",
"idx",
")",
"new_value",
"=",
"'{:,}'",
".",
"format",
"(",
"value",
")",
".",
"replace",
"(",
"','",
",",
"data",
".",
"format",
"(",
"values",
"[",
"\"seperator\"",
"]",
",",
"values",
")",
")",
"data",
".",
"insert_data",
"(",
"new_key",
",",
"new_value",
",",
"values",
")"
] | [
210,
0
] | [
221,
52
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
|
delete_memory_files | (job_name: str, name: str, count: int) | Löscht Memory-Dateien sobald zu viele vorhanden sind.
:param job_name: Name des Jobs von der die Funktion aufgerufen wurde.
:param name: Name des Dictionaries, das exportiert wurde.
:param count: Anzahl an Memory-Dateien, die vorhanden sein sollen (danach wird gelöscht).
| Löscht Memory-Dateien sobald zu viele vorhanden sind. | def delete_memory_files(job_name: str, name: str, count: int):
"""Löscht Memory-Dateien sobald zu viele vorhanden sind.
:param job_name: Name des Jobs von der die Funktion aufgerufen wurde.
:param name: Name des Dictionaries, das exportiert wurde.
:param count: Anzahl an Memory-Dateien, die vorhanden sein sollen (danach wird gelöscht).
"""
files = os.listdir(get_resource_path(os.path.join(MEMORY_LOCATION, job_name, name)))
files.sort(reverse=True)
for idx, file in enumerate(files):
if idx >= count:
os.remove(get_resource_path(os.path.join(MEMORY_LOCATION, job_name, name, file)))
logger.info(
f"Old memory file {file} has been deleted.") | [
"def",
"delete_memory_files",
"(",
"job_name",
":",
"str",
",",
"name",
":",
"str",
",",
"count",
":",
"int",
")",
":",
"files",
"=",
"os",
".",
"listdir",
"(",
"get_resource_path",
"(",
"os",
".",
"path",
".",
"join",
"(",
"MEMORY_LOCATION",
",",
"job_name",
",",
"name",
")",
")",
")",
"files",
".",
"sort",
"(",
"reverse",
"=",
"True",
")",
"for",
"idx",
",",
"file",
"in",
"enumerate",
"(",
"files",
")",
":",
"if",
"idx",
">=",
"count",
":",
"os",
".",
"remove",
"(",
"get_resource_path",
"(",
"os",
".",
"path",
".",
"join",
"(",
"MEMORY_LOCATION",
",",
"job_name",
",",
"name",
",",
"file",
")",
")",
")",
"logger",
".",
"info",
"(",
"f\"Old memory file {file} has been deleted.\"",
")"
] | [
133,
0
] | [
146,
60
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
|
Circle.intersect_circle | (self, circle, rtol=1e-03, atol=1e-03,
include_end=False) | return [p1, p2] | Von zwei Circle-Objekten werden die Schnittpunkte bestimmt
und in einer Liste ausgegeben
| Von zwei Circle-Objekten werden die Schnittpunkte bestimmt
und in einer Liste ausgegeben
| def intersect_circle(self, circle, rtol=1e-03, atol=1e-03,
include_end=False):
""" Von zwei Circle-Objekten werden die Schnittpunkte bestimmt
und in einer Liste ausgegeben
"""
d = distance(self.center, circle.center)
arc = alpha_triangle(circle.radius, self.radius, d)
if np.isnan(arc):
if not np.isclose(d, circle.radius + self.radius,
rtol, atol):
return []
arc = 0.0
arc_C = alpha_line(self.center, circle.center)
p1 = point(self.center, self.radius, arc_C+arc)
p2 = point(self.center, self.radius, arc_C-arc)
if points_are_close(p1, p2, rtol, atol):
# Tangente
if include_end:
return [p1]
else:
return []
return [p1, p2] | [
"def",
"intersect_circle",
"(",
"self",
",",
"circle",
",",
"rtol",
"=",
"1e-03",
",",
"atol",
"=",
"1e-03",
",",
"include_end",
"=",
"False",
")",
":",
"d",
"=",
"distance",
"(",
"self",
".",
"center",
",",
"circle",
".",
"center",
")",
"arc",
"=",
"alpha_triangle",
"(",
"circle",
".",
"radius",
",",
"self",
".",
"radius",
",",
"d",
")",
"if",
"np",
".",
"isnan",
"(",
"arc",
")",
":",
"if",
"not",
"np",
".",
"isclose",
"(",
"d",
",",
"circle",
".",
"radius",
"+",
"self",
".",
"radius",
",",
"rtol",
",",
"atol",
")",
":",
"return",
"[",
"]",
"arc",
"=",
"0.0",
"arc_C",
"=",
"alpha_line",
"(",
"self",
".",
"center",
",",
"circle",
".",
"center",
")",
"p1",
"=",
"point",
"(",
"self",
".",
"center",
",",
"self",
".",
"radius",
",",
"arc_C",
"+",
"arc",
")",
"p2",
"=",
"point",
"(",
"self",
".",
"center",
",",
"self",
".",
"radius",
",",
"arc_C",
"-",
"arc",
")",
"if",
"points_are_close",
"(",
"p1",
",",
"p2",
",",
"rtol",
",",
"atol",
")",
":",
"# Tangente",
"if",
"include_end",
":",
"return",
"[",
"p1",
"]",
"else",
":",
"return",
"[",
"]",
"return",
"[",
"p1",
",",
"p2",
"]"
] | [
441,
4
] | [
463,
23
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
GUI.setzen1_digitale_eingaenge | (self) | Digitale Eingänge auf 1 setzen | Digitale Eingänge auf 1 setzen | def setzen1_digitale_eingaenge(self):
""" Digitale Eingänge auf 1 setzen """
setzer = Setzer()
setzer.setzen1_digitale_eingaenge()
self.aktualisieren_eingangswerte() | [
"def",
"setzen1_digitale_eingaenge",
"(",
"self",
")",
":",
"setzer",
"=",
"Setzer",
"(",
")",
"setzer",
".",
"setzen1_digitale_eingaenge",
"(",
")",
"self",
".",
"aktualisieren_eingangswerte",
"(",
")"
] | [
212,
4
] | [
216,
42
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
|
PdfGenerator.resultIcon | (self, acceptance=None, area:dict=None, render=None, iconOnly=False, size="x4", addClass="") | Erzeugt ein acceptance Icon und verwendet die IBA Notation.
Zusätzlich kann noch True statt 5 bzw. False für 1 verwendet werden.
Wird area nicht angegeben so wird das Icon wird in der rechten unteren Ecke erzeugt
Parameters
----------
acceptance : int
5 - green - very Good (True)
4 - green - Good
3 - yellow - Sufficient
2 - orange - Insufficient
1 - red - Fail (False)
alles andere - (n.a.) Not applicable
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
iconOnly : bool
nur das icon zurückgeben
size : str
icon größe x1 bis x6 default: x4
Returns
-------
str : html
| Erzeugt ein acceptance Icon und verwendet die IBA Notation. | def resultIcon(self, acceptance=None, area:dict=None, render=None, iconOnly=False, size="x4", addClass=""):
"""Erzeugt ein acceptance Icon und verwendet die IBA Notation.
Zusätzlich kann noch True statt 5 bzw. False für 1 verwendet werden.
Wird area nicht angegeben so wird das Icon wird in der rechten unteren Ecke erzeugt
Parameters
----------
acceptance : int
5 - green - very Good (True)
4 - green - Good
3 - yellow - Sufficient
2 - orange - Insufficient
1 - red - Fail (False)
alles andere - (n.a.) Not applicable
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
iconOnly : bool
nur das icon zurückgeben
size : str
icon größe x1 bis x6 default: x4
Returns
-------
str : html
"""
if not area:
area = { "bottom":0, "right":0 }
if type(acceptance) == bool:
if acceptance:
acceptance = 5
else:
acceptance = 1
try:
acceptance = int(acceptance)
except:
acceptance = None
if acceptance==5:
options="mdi-check-outline green-text"
elif acceptance==4:
options="mdi-check-outline lime-text"
elif acceptance==3:
options="mdi-alert-circle-outline amber-text"
elif acceptance==2:
options="mdi-alert-circle-outline orange-text"
elif acceptance==1:
options="mdi-close-outline red-text"
else:
options="mdi-block-helper"
text = '<i class="mdi {} {} resultIcon {}"></i>'.format( options, size, addClass )
if iconOnly:
return text
else:
return self._text( text, area=area, render=render ) | [
"def",
"resultIcon",
"(",
"self",
",",
"acceptance",
"=",
"None",
",",
"area",
":",
"dict",
"=",
"None",
",",
"render",
"=",
"None",
",",
"iconOnly",
"=",
"False",
",",
"size",
"=",
"\"x4\"",
",",
"addClass",
"=",
"\"\"",
")",
":",
"if",
"not",
"area",
":",
"area",
"=",
"{",
"\"bottom\"",
":",
"0",
",",
"\"right\"",
":",
"0",
"}",
"if",
"type",
"(",
"acceptance",
")",
"==",
"bool",
":",
"if",
"acceptance",
":",
"acceptance",
"=",
"5",
"else",
":",
"acceptance",
"=",
"1",
"try",
":",
"acceptance",
"=",
"int",
"(",
"acceptance",
")",
"except",
":",
"acceptance",
"=",
"None",
"if",
"acceptance",
"==",
"5",
":",
"options",
"=",
"\"mdi-check-outline green-text\"",
"elif",
"acceptance",
"==",
"4",
":",
"options",
"=",
"\"mdi-check-outline lime-text\"",
"elif",
"acceptance",
"==",
"3",
":",
"options",
"=",
"\"mdi-alert-circle-outline amber-text\"",
"elif",
"acceptance",
"==",
"2",
":",
"options",
"=",
"\"mdi-alert-circle-outline orange-text\"",
"elif",
"acceptance",
"==",
"1",
":",
"options",
"=",
"\"mdi-close-outline red-text\"",
"else",
":",
"options",
"=",
"\"mdi-block-helper\"",
"text",
"=",
"'<i class=\"mdi {} {} resultIcon {}\"></i>'",
".",
"format",
"(",
"options",
",",
"size",
",",
"addClass",
")",
"if",
"iconOnly",
":",
"return",
"text",
"else",
":",
"return",
"self",
".",
"_text",
"(",
"text",
",",
"area",
"=",
"area",
",",
"render",
"=",
"render",
")"
] | [
1335,
4
] | [
1397,
63
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
|
collect_arguments | (queries, cbow_model, bm25_model, max_args=-1) | Lade den Index und werte die Argumente abhängig vond er Query aus
Args:
queries (:obj:`list` of :obj:`str`): Eingaben, nach denen gesucht werden soll
cbow_model (:obj:`Word2Vec`): Word Embedding Modell
bm25_model (:obj:`BM25Kapi`): BM25 Index
alpha (float): Einfluss BM25 und Word Embedding
max_args (int): Menge der Argumente
Returns:
:obj:`tuple` of two :obj:`np.array`: erster array 2 dim. BM25 scores,
zweiter array 2 dim. Dualsim scores
| Lade den Index und werte die Argumente abhängig vond er Query aus | def collect_arguments(queries, cbow_model, bm25_model, max_args=-1):
""" Lade den Index und werte die Argumente abhängig vond er Query aus
Args:
queries (:obj:`list` of :obj:`str`): Eingaben, nach denen gesucht werden soll
cbow_model (:obj:`Word2Vec`): Word Embedding Modell
bm25_model (:obj:`BM25Kapi`): BM25 Index
alpha (float): Einfluss BM25 und Word Embedding
max_args (int): Menge der Argumente
Returns:
:obj:`tuple` of two :obj:`np.array`: erster array 2 dim. BM25 scores,
zweiter array 2 dim. Dualsim scores
"""
dual_embedding = DualEmbedding(cbow_model)
processed_queries = dual_embedding.get_processed_queries(queries)
bm25_scores = []
desim_scores = []
arg_ids = []
with open(setup.INDEX_PATH, 'r', encoding='utf-8', newline='') as f_in:
reader = csv.reader(f_in, **setup.INDEX_CONFIG)
for i, row in tqdm(enumerate(reader)):
try:
arg_id, doc_freq, arg_emb, doc_len = [
row[0],
json.loads(row[1]),
np.asarray(json.loads(row[2])),
int(row[3])
]
except Exception as e:
print(e)
print("\t> Folgende Zeile konnte nicht verarbeitet werden:")
print("\t>", row)
continue
try:
desim_queries_scores = []
bm25_queries_scores = []
for query_terms, query_matrix in processed_queries:
desim_query_score = dual_embedding.desim(
query_matrix, arg_emb
)
bm25_query_score = bm25_model.get_single_score(
query_terms,
doc_freq,
doc_len,
)
desim_queries_scores.append(desim_query_score)
bm25_queries_scores.append(bm25_query_score)
arg_ids.append(arg_id)
bm25_scores.append(bm25_queries_scores)
desim_scores.append(desim_queries_scores)
except RuntimeWarning as e:
print(arg_id, e)
if i + 1 == max_args:
break
bm25_scores = np.array(bm25_scores)
desim_scores = np.array(desim_scores)
arg_ids = np.asarray(arg_ids)
print('\nBM25 Scores: ', bm25_scores.shape)
print('Desim Scores: ', desim_scores.shape)
print('Arg IDs: ', arg_ids.shape, '\n')
print(f'Min BM25: {bm25_scores.min()}')
print(f'Max BM25: {bm25_scores.max()}')
print(f'Min Desim: {desim_scores.min()}')
print(f'Max Desim: {desim_scores.max()}\n')
bm25_norm = normalize(bm25_scores, norm='max', axis=0)
desim_norm = normalize(desim_scores, norm='max', axis=0)
print(f'norm Min BM25: {bm25_norm.min()}')
print(f'norm Max BM25: {bm25_norm.max()}')
print(f'norm Min Desim: {desim_norm.min()}')
print(f'norm Max Desim: {desim_norm.max()}\n')
print(f'Shape BM25: {bm25_norm.shape}')
print(f'Shape Desim: {desim_norm.shape}\n')
bm25_norm = np.transpose(bm25_norm)
desim_norm = np.transpose(desim_norm)
return arg_ids, bm25_norm, desim_norm | [
"def",
"collect_arguments",
"(",
"queries",
",",
"cbow_model",
",",
"bm25_model",
",",
"max_args",
"=",
"-",
"1",
")",
":",
"dual_embedding",
"=",
"DualEmbedding",
"(",
"cbow_model",
")",
"processed_queries",
"=",
"dual_embedding",
".",
"get_processed_queries",
"(",
"queries",
")",
"bm25_scores",
"=",
"[",
"]",
"desim_scores",
"=",
"[",
"]",
"arg_ids",
"=",
"[",
"]",
"with",
"open",
"(",
"setup",
".",
"INDEX_PATH",
",",
"'r'",
",",
"encoding",
"=",
"'utf-8'",
",",
"newline",
"=",
"''",
")",
"as",
"f_in",
":",
"reader",
"=",
"csv",
".",
"reader",
"(",
"f_in",
",",
"*",
"*",
"setup",
".",
"INDEX_CONFIG",
")",
"for",
"i",
",",
"row",
"in",
"tqdm",
"(",
"enumerate",
"(",
"reader",
")",
")",
":",
"try",
":",
"arg_id",
",",
"doc_freq",
",",
"arg_emb",
",",
"doc_len",
"=",
"[",
"row",
"[",
"0",
"]",
",",
"json",
".",
"loads",
"(",
"row",
"[",
"1",
"]",
")",
",",
"np",
".",
"asarray",
"(",
"json",
".",
"loads",
"(",
"row",
"[",
"2",
"]",
")",
")",
",",
"int",
"(",
"row",
"[",
"3",
"]",
")",
"]",
"except",
"Exception",
"as",
"e",
":",
"print",
"(",
"e",
")",
"print",
"(",
"\"\\t> Folgende Zeile konnte nicht verarbeitet werden:\"",
")",
"print",
"(",
"\"\\t>\"",
",",
"row",
")",
"continue",
"try",
":",
"desim_queries_scores",
"=",
"[",
"]",
"bm25_queries_scores",
"=",
"[",
"]",
"for",
"query_terms",
",",
"query_matrix",
"in",
"processed_queries",
":",
"desim_query_score",
"=",
"dual_embedding",
".",
"desim",
"(",
"query_matrix",
",",
"arg_emb",
")",
"bm25_query_score",
"=",
"bm25_model",
".",
"get_single_score",
"(",
"query_terms",
",",
"doc_freq",
",",
"doc_len",
",",
")",
"desim_queries_scores",
".",
"append",
"(",
"desim_query_score",
")",
"bm25_queries_scores",
".",
"append",
"(",
"bm25_query_score",
")",
"arg_ids",
".",
"append",
"(",
"arg_id",
")",
"bm25_scores",
".",
"append",
"(",
"bm25_queries_scores",
")",
"desim_scores",
".",
"append",
"(",
"desim_queries_scores",
")",
"except",
"RuntimeWarning",
"as",
"e",
":",
"print",
"(",
"arg_id",
",",
"e",
")",
"if",
"i",
"+",
"1",
"==",
"max_args",
":",
"break",
"bm25_scores",
"=",
"np",
".",
"array",
"(",
"bm25_scores",
")",
"desim_scores",
"=",
"np",
".",
"array",
"(",
"desim_scores",
")",
"arg_ids",
"=",
"np",
".",
"asarray",
"(",
"arg_ids",
")",
"print",
"(",
"'\\nBM25 Scores: '",
",",
"bm25_scores",
".",
"shape",
")",
"print",
"(",
"'Desim Scores: '",
",",
"desim_scores",
".",
"shape",
")",
"print",
"(",
"'Arg IDs: '",
",",
"arg_ids",
".",
"shape",
",",
"'\\n'",
")",
"print",
"(",
"f'Min BM25: {bm25_scores.min()}'",
")",
"print",
"(",
"f'Max BM25: {bm25_scores.max()}'",
")",
"print",
"(",
"f'Min Desim: {desim_scores.min()}'",
")",
"print",
"(",
"f'Max Desim: {desim_scores.max()}\\n'",
")",
"bm25_norm",
"=",
"normalize",
"(",
"bm25_scores",
",",
"norm",
"=",
"'max'",
",",
"axis",
"=",
"0",
")",
"desim_norm",
"=",
"normalize",
"(",
"desim_scores",
",",
"norm",
"=",
"'max'",
",",
"axis",
"=",
"0",
")",
"print",
"(",
"f'norm Min BM25: {bm25_norm.min()}'",
")",
"print",
"(",
"f'norm Max BM25: {bm25_norm.max()}'",
")",
"print",
"(",
"f'norm Min Desim: {desim_norm.min()}'",
")",
"print",
"(",
"f'norm Max Desim: {desim_norm.max()}\\n'",
")",
"print",
"(",
"f'Shape BM25: {bm25_norm.shape}'",
")",
"print",
"(",
"f'Shape Desim: {desim_norm.shape}\\n'",
")",
"bm25_norm",
"=",
"np",
".",
"transpose",
"(",
"bm25_norm",
")",
"desim_norm",
"=",
"np",
".",
"transpose",
"(",
"desim_norm",
")",
"return",
"arg_ids",
",",
"bm25_norm",
",",
"desim_norm"
] | [
61,
0
] | [
153,
45
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
|
ispTest.test_webapp_base_extras | ( self ) | Website Aufruf für zusätzliche Inhalte
| Website Aufruf für zusätzliche Inhalte
| def test_webapp_base_extras( self ):
''' Website Aufruf für zusätzliche Inhalte
'''
# htmlcov laden geht nur wenn es schon erzeugt wurde
htmlcov_path = osp.join( ABSPATH , "..", ".htmlcov")
if osp.isdir( htmlcov_path ):
response = self.app.get( "/coverage" )
self.assertEqual(response.status_code, 200, "Api Status nicht 200")
response = self.app.get( "/coverage/coverage.css" )
self.assertEqual(response.status_code, 200, "Api Status nicht 200")
else:
print( "(coverage) Test erst nach dem Erstellen möglich." )
# über resources laden
response = self.app.get( "resources/logo.png" )
self.assertEqual(response.status_code, 200, "Api Status nicht 200")
# über fonts laden aber mit Fehler für coverage
response = self.app.get( "fonts/irgendwas" )
self.assertEqual(response.status_code, 404, "Api Status nicht 404")
# über dbadminframe laden
response = self.app.get( "dbadminframe" )
self.assertEqual(response.status_code, 200, "Api Status nicht 200")
# docs iframe laden
response = self.app.get( "/docs" )
self.assertEqual(response.status_code, 200, "Api Status nicht 200")
# /docs/ wird zu /docs also auch iframe laden
response = self.app.get( "/docs/" )
self.assertEqual(response.status_code, 200, "Api Status nicht 200")
# docs laden (beim ersten Aufruf erzeugen)
response = self.app.get( "/docs/index.html" )
# es kommt vor das erst beim 2. Aufruf alles erzeugt wird
if response.status_code == 404:
# 2. Versuch
response = self.app.get( "/docs/index.html" )
# jetzt OK
self.assertEqual(response.status_code, 200, "docs Aufruf Api Status nicht 200. Wurde docs erzeugt?")
# dbadmin laden
response = self.app.get( "/dbadmin" )
self.assertEqual(response.status_code, 200, "Api Status nicht 200")
# neue webapp ohne parameter
webbapp =ispBaseWebApp( )
self.assertEqual(webbapp._config.get("server.webserver.TESTING"), True, "Testing ist nicht True")
# neue webapp mit dict nur mit TESTING Angabe
webbapp =ispBaseWebApp( {"server" : {"webserver" : { "TESTING": True } } } )
self.assertEqual(webbapp._config.get("server.webserver.TESTING"), True, "Testing ist nicht True") | [
"def",
"test_webapp_base_extras",
"(",
"self",
")",
":",
"# htmlcov laden geht nur wenn es schon erzeugt wurde ",
"htmlcov_path",
"=",
"osp",
".",
"join",
"(",
"ABSPATH",
",",
"\"..\"",
",",
"\".htmlcov\"",
")",
"if",
"osp",
".",
"isdir",
"(",
"htmlcov_path",
")",
":",
"response",
"=",
"self",
".",
"app",
".",
"get",
"(",
"\"/coverage\"",
")",
"self",
".",
"assertEqual",
"(",
"response",
".",
"status_code",
",",
"200",
",",
"\"Api Status nicht 200\"",
")",
"response",
"=",
"self",
".",
"app",
".",
"get",
"(",
"\"/coverage/coverage.css\"",
")",
"self",
".",
"assertEqual",
"(",
"response",
".",
"status_code",
",",
"200",
",",
"\"Api Status nicht 200\"",
")",
"else",
":",
"print",
"(",
"\"(coverage) Test erst nach dem Erstellen möglich.\" ",
"",
"# über resources laden",
"response",
"=",
"self",
".",
"app",
".",
"get",
"(",
"\"resources/logo.png\"",
")",
"self",
".",
"assertEqual",
"(",
"response",
".",
"status_code",
",",
"200",
",",
"\"Api Status nicht 200\"",
")",
"# über fonts laden aber mit Fehler für coverage",
"response",
"=",
"self",
".",
"app",
".",
"get",
"(",
"\"fonts/irgendwas\"",
")",
"self",
".",
"assertEqual",
"(",
"response",
".",
"status_code",
",",
"404",
",",
"\"Api Status nicht 404\"",
")",
"# über dbadminframe laden",
"response",
"=",
"self",
".",
"app",
".",
"get",
"(",
"\"dbadminframe\"",
")",
"self",
".",
"assertEqual",
"(",
"response",
".",
"status_code",
",",
"200",
",",
"\"Api Status nicht 200\"",
")",
"# docs iframe laden ",
"response",
"=",
"self",
".",
"app",
".",
"get",
"(",
"\"/docs\"",
")",
"self",
".",
"assertEqual",
"(",
"response",
".",
"status_code",
",",
"200",
",",
"\"Api Status nicht 200\"",
")",
"# /docs/ wird zu /docs also auch iframe laden",
"response",
"=",
"self",
".",
"app",
".",
"get",
"(",
"\"/docs/\"",
")",
"self",
".",
"assertEqual",
"(",
"response",
".",
"status_code",
",",
"200",
",",
"\"Api Status nicht 200\"",
")",
"# docs laden (beim ersten Aufruf erzeugen)",
"response",
"=",
"self",
".",
"app",
".",
"get",
"(",
"\"/docs/index.html\"",
")",
"# es kommt vor das erst beim 2. Aufruf alles erzeugt wird",
"if",
"response",
".",
"status_code",
"==",
"404",
":",
"# 2. Versuch",
"response",
"=",
"self",
".",
"app",
".",
"get",
"(",
"\"/docs/index.html\"",
")",
"# jetzt OK",
"self",
".",
"assertEqual",
"(",
"response",
".",
"status_code",
",",
"200",
",",
"\"docs Aufruf Api Status nicht 200. Wurde docs erzeugt?\"",
")",
"# dbadmin laden",
"response",
"=",
"self",
".",
"app",
".",
"get",
"(",
"\"/dbadmin\"",
")",
"self",
".",
"assertEqual",
"(",
"response",
".",
"status_code",
",",
"200",
",",
"\"Api Status nicht 200\"",
")",
"# neue webapp ohne parameter",
"webbapp",
"=",
"ispBaseWebApp",
"(",
")",
"self",
".",
"assertEqual",
"(",
"webbapp",
".",
"_config",
".",
"get",
"(",
"\"server.webserver.TESTING\"",
")",
",",
"True",
",",
"\"Testing ist nicht True\"",
")",
"# neue webapp mit dict nur mit TESTING Angabe",
"webbapp",
"=",
"ispBaseWebApp",
"(",
"{",
"\"server\"",
":",
"{",
"\"webserver\"",
":",
"{",
"\"TESTING\"",
":",
"True",
"}",
"}",
"}",
")",
"self",
".",
"assertEqual",
"(",
"webbapp",
".",
"_config",
".",
"get",
"(",
"\"server.webserver.TESTING\"",
")",
",",
"True",
",",
"\"Testing ist nicht True\"",
")"
] | [
1505,
4
] | [
1559,
105
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
|
ispConfig.__getitem__ | (self, k) | Zugriff auf die Klassenattribute mit _.
sonst wird aus self._config geholt
Defines behavior for when an item is accessed, using the notation self[key].
This is also part of both the mutable and immutable container protocols.
It should also raise appropriate exceptions::
TypeError if the type of the key is wrong and KeyError if there is no corresponding value for the key.
Parameters
----------
k : str
Name des gesuchten Attributs aus dem dict des Object oder der _config.
Returns
-------
Wert des Attributs
| Zugriff auf die Klassenattribute mit _. | def __getitem__(self, k):
"""Zugriff auf die Klassenattribute mit _.
sonst wird aus self._config geholt
Defines behavior for when an item is accessed, using the notation self[key].
This is also part of both the mutable and immutable container protocols.
It should also raise appropriate exceptions::
TypeError if the type of the key is wrong and KeyError if there is no corresponding value for the key.
Parameters
----------
k : str
Name des gesuchten Attributs aus dem dict des Object oder der _config.
Returns
-------
Wert des Attributs
"""
if k[0] == "_":
return self.__dict__[k]
else:
return self._config[k] | [
"def",
"__getitem__",
"(",
"self",
",",
"k",
")",
":",
"if",
"k",
"[",
"0",
"]",
"==",
"\"_\"",
":",
"return",
"self",
".",
"__dict__",
"[",
"k",
"]",
"else",
":",
"return",
"self",
".",
"_config",
"[",
"k",
"]"
] | [
375,
4
] | [
399,
34
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
|
OpenLogDir | () | return | Oeffnet das Log-Verzeichnis | Oeffnet das Log-Verzeichnis | def OpenLogDir():
''' Oeffnet das Log-Verzeichnis'''
global myLogDir
# Logfile-Verzeichnis öffnen
os.startfile(myLogDir)
return | [
"def",
"OpenLogDir",
"(",
")",
":",
"global",
"myLogDir",
"# Logfile-Verzeichnis öffnen\r",
"os",
".",
"startfile",
"(",
"myLogDir",
")",
"return"
] | [
201,
0
] | [
208,
10
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
ariaClass.getImageInfos | (self, imageRow:dict=None ) | return infos | Bestimmt die Infos der Aufnahme.
Parameters
----------
imageRow : dict
{
gerät - <string>
studyID - <string>
filename - <string>
filepath - <string>
id - <string>
energy - <string>
gantry - <float %1.1f>
collimator - <float %1.1f>
type - <string> - (offen, kamm, x1zu, x2zu, tips)
}
dateinamen z.B.
{
'PatientId': '_xxxQA VB',
'CourseId': 'Jahrestest',
'PlanSetupId': '4Quadrant',
'RadiationId': 'X6 Q1',
'Energy': 6000,
'GantryAngle': 0.01990341513203,
'CollRtn': 359.999840036008,
'AcquisitionDateTime': datetime.datetime(2019, 3, 20, 19, 7, 9, 510000),
'SliceUID': '1.2.246.352.62.1.5343640968774208147.13210826594556886954',
'ResourceSer': 1301,
'PatientSupportAngle': 0.03125,
'FileName': '%%imagedir1\\Patients\\_716\\SliceRT\\1820744_id1432516'
}
Energy aus SliceRT.Energy, Doserate -> SliceRT.MetersetExposure
| Bestimmt die Infos der Aufnahme. | def getImageInfos(self, imageRow:dict=None ):
""" Bestimmt die Infos der Aufnahme.
Parameters
----------
imageRow : dict
{
gerät - <string>
studyID - <string>
filename - <string>
filepath - <string>
id - <string>
energy - <string>
gantry - <float %1.1f>
collimator - <float %1.1f>
type - <string> - (offen, kamm, x1zu, x2zu, tips)
}
dateinamen z.B.
{
'PatientId': '_xxxQA VB',
'CourseId': 'Jahrestest',
'PlanSetupId': '4Quadrant',
'RadiationId': 'X6 Q1',
'Energy': 6000,
'GantryAngle': 0.01990341513203,
'CollRtn': 359.999840036008,
'AcquisitionDateTime': datetime.datetime(2019, 3, 20, 19, 7, 9, 510000),
'SliceUID': '1.2.246.352.62.1.5343640968774208147.13210826594556886954',
'ResourceSer': 1301,
'PatientSupportAngle': 0.03125,
'FileName': '%%imagedir1\\Patients\\_716\\SliceRT\\1820744_id1432516'
}
Energy aus SliceRT.Energy, Doserate -> SliceRT.MetersetExposure
"""
# in der DICOM datei steht 'RT Image Storage' und nicht RTIMAGE
if imageRow["SliceModality"] == 'RTIMAGE':
imageRow["SliceModality"] = 'RT Image Storage'
f = Path( imageRow["FileName"].replace("\\", "/" ) )
# kolli 360° ist 0°
colli = float("{:1.1f}".format(imageRow["CollRtn"]) ) # BeamLimitingAngle
if colli == 360:
colli = 0.0
# gantry 360° ist 0°
gantry = float("{:1.1f}".format(imageRow["GantryRtn"]) ) # GantryAngle, GantryRtn
if gantry == 360:
gantry = 0.0
# TischRotation 360° ist 0°
table = float("{:1.1f}".format(imageRow["PatientSupportAngle"]) ) #
if table == 360:
table = 0.0
# Energie und Doserate aus AcqNote bestimmen
desc = re.split("[\r\n|,]", imageRow["AcqNote"])
energy = ""
doserate = 0
if len(desc) <= 2:
logger.warning( "aria.getImageInfos:AcqNote: {}".format( imageRow["FileName"] ) )
else:
try:
energy = desc[0].replace( " [MV]", "" ).strip()
doserate = int( desc[1].replace( " [MU/min]", "" ).strip() )
except:
pass
# type zuerst nach neuer zeile oder leerzeichen Splitten
comment = (lambda v: v.split() if v else [] )( imageRow["Comment"] )
testTags = []
subTags = []
varianten = {}
for t in comment:
tags = t.split(":")
_tag = tags[0]
_sub = None
if len( tags ) > 1:
# mit subtag verwenden
_sub = tags[1]
'''
else:
# ohne subtag versuchen ihn für MLC plan zu bestimmen
logger.warning( "ariaClass.get_SubTag_from_MLCPlanType: {} ".format(comment ) )
_sub = self.get_SubTag_from_MLCPlanType( imageRow )
logger.warning( "ariaClass.get_SubTag_from_MLCPlanType: {} ".format(_sub ) )
'''
# testTag und subTag merken
testTags.append( _tag )
subTags.append( _sub )
# Varianten merken
varianten[ _tag ] = _sub
gating = ""
if "gating" in subTags:
gating = "gating"
infos = self.infoFields.copy()
infos.update( {
'id': imageRow["SliceUID"],
'PatientId': imageRow["PatientId"],
'RadiationId': imageRow["RadiationId"],
'RadiationSer': imageRow["RadiationSer"],
'CourseId': imageRow["CourseId"], # gibt es in der imageClass nicht
'PlanSetupId': imageRow["PlanSetupId"], # gibt es in der imageClass nicht
'SliceRTType': imageRow["SliceRTType"],
'ImageId': imageRow["ImageId"],
'SeriesId': imageRow["SeriesId"],
'SeriesNumber' : imageRow["SeriesNumber"],
'CreationDate' : imageRow["CreationDate"],
'studyID': '', # FIXME: studyID
'filepath': str( f ) ,
'filename': f.name,
'Kennung' : imageRow["PlanSetupId"] + ":" + imageRow["RadiationId"] + ":" + imageRow["ImageId"],
'SOPClassUID': imageRow["SliceModality"],
'AcquisitionDateTime': imageRow["AcquisitionDateTime"],
'acquisition': imageRow["AcquisitionDateTime"].strftime("%Y-%m-%d %H:%M:%S"),
'AcquisitionYear': int(imageRow["AcquisitionDateTime"].strftime("%Y")),
'AcquisitionMonth': int(imageRow["AcquisitionDateTime"].strftime("%m")),
'day' : imageRow["AcquisitionDateTime"].strftime("%Y-%m-%d"),
'Tag' : imageRow["AcquisitionDateTime"].strftime("%d.%m.%Y"),
'unit': imageRow["RadiationMachineName"],
'energy': energy,
'doserate': doserate,
'MetersetExposure' : imageRow["MetersetExposure"],
'ME': int( round( imageRow["MetersetExposure"] ) ),
'Technique': imageRow["TechniqueLabel"],
'gantry' : gantry, # GantryRtn
'GantryRtnDirection' : imageRow["GantryRtnDirection"], # NONE, CW, CC
'GantryRtnExt' : imageRow["GantryRtnExt"], # EN, NN
'StopAngle' : imageRow["StopAngle"],
'collimator': colli, # BeamLimitingAngle
'CollMode' : imageRow["CollMode"], # Symmetry, AsymmetryX&Y, AsymmetryX (bei MLC)
'table' : table, # PatientSupportAngle
'SID': imageRow["SAD"],
'MLCPlanType': imageRow["MLCPlanType"],
'IndexParameterType': imageRow["IndexParameterType"],
'X1': float("{:1.1f}".format( imageRow["CollX1"] ) ) * 10, # in mm
'X2': float("{:1.1f}".format( imageRow["CollX2"] ) ) * 10, # in mm
'Y1': float("{:1.1f}".format( imageRow["CollY1"] ) ) * 10, # in mm
'Y2': float("{:1.1f}".format( imageRow["CollY2"] ) ) * 10, # in mm
'SliceUID' : imageRow["SliceUID"], # SOP Instance UID
'SeriesUID' : imageRow["SeriesUID"], # Series Instance UID
'StudyUID': imageRow["StudyUID"], #StudyInstanceUID
'FrameOfReferenceUID': imageRow["FrameOfReferenceUID"],
'gating': gating,
'testTags': testTags,
'subTags': subTags,
'varianten': varianten
})
return infos | [
"def",
"getImageInfos",
"(",
"self",
",",
"imageRow",
":",
"dict",
"=",
"None",
")",
":",
"# in der DICOM datei steht 'RT Image Storage' und nicht RTIMAGE",
"if",
"imageRow",
"[",
"\"SliceModality\"",
"]",
"==",
"'RTIMAGE'",
":",
"imageRow",
"[",
"\"SliceModality\"",
"]",
"=",
"'RT Image Storage'",
"f",
"=",
"Path",
"(",
"imageRow",
"[",
"\"FileName\"",
"]",
".",
"replace",
"(",
"\"\\\\\"",
",",
"\"/\"",
")",
")",
"# kolli 360° ist 0°",
"colli",
"=",
"float",
"(",
"\"{:1.1f}\"",
".",
"format",
"(",
"imageRow",
"[",
"\"CollRtn\"",
"]",
")",
")",
"# BeamLimitingAngle",
"if",
"colli",
"==",
"360",
":",
"colli",
"=",
"0.0",
"# gantry 360° ist 0°",
"gantry",
"=",
"float",
"(",
"\"{:1.1f}\"",
".",
"format",
"(",
"imageRow",
"[",
"\"GantryRtn\"",
"]",
")",
")",
"# GantryAngle, GantryRtn",
"if",
"gantry",
"==",
"360",
":",
"gantry",
"=",
"0.0",
"# TischRotation 360° ist 0°",
"table",
"=",
"float",
"(",
"\"{:1.1f}\"",
".",
"format",
"(",
"imageRow",
"[",
"\"PatientSupportAngle\"",
"]",
")",
")",
"#",
"if",
"table",
"==",
"360",
":",
"table",
"=",
"0.0",
"# Energie und Doserate aus AcqNote bestimmen",
"desc",
"=",
"re",
".",
"split",
"(",
"\"[\\r\\n|,]\"",
",",
"imageRow",
"[",
"\"AcqNote\"",
"]",
")",
"energy",
"=",
"\"\"",
"doserate",
"=",
"0",
"if",
"len",
"(",
"desc",
")",
"<=",
"2",
":",
"logger",
".",
"warning",
"(",
"\"aria.getImageInfos:AcqNote: {}\"",
".",
"format",
"(",
"imageRow",
"[",
"\"FileName\"",
"]",
")",
")",
"else",
":",
"try",
":",
"energy",
"=",
"desc",
"[",
"0",
"]",
".",
"replace",
"(",
"\" [MV]\"",
",",
"\"\"",
")",
".",
"strip",
"(",
")",
"doserate",
"=",
"int",
"(",
"desc",
"[",
"1",
"]",
".",
"replace",
"(",
"\" [MU/min]\"",
",",
"\"\"",
")",
".",
"strip",
"(",
")",
")",
"except",
":",
"pass",
"# type zuerst nach neuer zeile oder leerzeichen Splitten",
"comment",
"=",
"(",
"lambda",
"v",
":",
"v",
".",
"split",
"(",
")",
"if",
"v",
"else",
"[",
"]",
")",
"(",
"imageRow",
"[",
"\"Comment\"",
"]",
")",
"testTags",
"=",
"[",
"]",
"subTags",
"=",
"[",
"]",
"varianten",
"=",
"{",
"}",
"for",
"t",
"in",
"comment",
":",
"tags",
"=",
"t",
".",
"split",
"(",
"\":\"",
")",
"_tag",
"=",
"tags",
"[",
"0",
"]",
"_sub",
"=",
"None",
"if",
"len",
"(",
"tags",
")",
">",
"1",
":",
"# mit subtag verwenden",
"_sub",
"=",
"tags",
"[",
"1",
"]",
"'''\n else:\n # ohne subtag versuchen ihn für MLC plan zu bestimmen\n logger.warning( \"ariaClass.get_SubTag_from_MLCPlanType: {} \".format(comment ) )\n _sub = self.get_SubTag_from_MLCPlanType( imageRow )\n logger.warning( \"ariaClass.get_SubTag_from_MLCPlanType: {} \".format(_sub ) )\n '''",
"# testTag und subTag merken",
"testTags",
".",
"append",
"(",
"_tag",
")",
"subTags",
".",
"append",
"(",
"_sub",
")",
"# Varianten merken",
"varianten",
"[",
"_tag",
"]",
"=",
"_sub",
"gating",
"=",
"\"\"",
"if",
"\"gating\"",
"in",
"subTags",
":",
"gating",
"=",
"\"gating\"",
"infos",
"=",
"self",
".",
"infoFields",
".",
"copy",
"(",
")",
"infos",
".",
"update",
"(",
"{",
"'id'",
":",
"imageRow",
"[",
"\"SliceUID\"",
"]",
",",
"'PatientId'",
":",
"imageRow",
"[",
"\"PatientId\"",
"]",
",",
"'RadiationId'",
":",
"imageRow",
"[",
"\"RadiationId\"",
"]",
",",
"'RadiationSer'",
":",
"imageRow",
"[",
"\"RadiationSer\"",
"]",
",",
"'CourseId'",
":",
"imageRow",
"[",
"\"CourseId\"",
"]",
",",
"# gibt es in der imageClass nicht",
"'PlanSetupId'",
":",
"imageRow",
"[",
"\"PlanSetupId\"",
"]",
",",
"# gibt es in der imageClass nicht",
"'SliceRTType'",
":",
"imageRow",
"[",
"\"SliceRTType\"",
"]",
",",
"'ImageId'",
":",
"imageRow",
"[",
"\"ImageId\"",
"]",
",",
"'SeriesId'",
":",
"imageRow",
"[",
"\"SeriesId\"",
"]",
",",
"'SeriesNumber'",
":",
"imageRow",
"[",
"\"SeriesNumber\"",
"]",
",",
"'CreationDate'",
":",
"imageRow",
"[",
"\"CreationDate\"",
"]",
",",
"'studyID'",
":",
"''",
",",
"# FIXME: studyID",
"'filepath'",
":",
"str",
"(",
"f",
")",
",",
"'filename'",
":",
"f",
".",
"name",
",",
"'Kennung'",
":",
"imageRow",
"[",
"\"PlanSetupId\"",
"]",
"+",
"\":\"",
"+",
"imageRow",
"[",
"\"RadiationId\"",
"]",
"+",
"\":\"",
"+",
"imageRow",
"[",
"\"ImageId\"",
"]",
",",
"'SOPClassUID'",
":",
"imageRow",
"[",
"\"SliceModality\"",
"]",
",",
"'AcquisitionDateTime'",
":",
"imageRow",
"[",
"\"AcquisitionDateTime\"",
"]",
",",
"'acquisition'",
":",
"imageRow",
"[",
"\"AcquisitionDateTime\"",
"]",
".",
"strftime",
"(",
"\"%Y-%m-%d %H:%M:%S\"",
")",
",",
"'AcquisitionYear'",
":",
"int",
"(",
"imageRow",
"[",
"\"AcquisitionDateTime\"",
"]",
".",
"strftime",
"(",
"\"%Y\"",
")",
")",
",",
"'AcquisitionMonth'",
":",
"int",
"(",
"imageRow",
"[",
"\"AcquisitionDateTime\"",
"]",
".",
"strftime",
"(",
"\"%m\"",
")",
")",
",",
"'day'",
":",
"imageRow",
"[",
"\"AcquisitionDateTime\"",
"]",
".",
"strftime",
"(",
"\"%Y-%m-%d\"",
")",
",",
"'Tag'",
":",
"imageRow",
"[",
"\"AcquisitionDateTime\"",
"]",
".",
"strftime",
"(",
"\"%d.%m.%Y\"",
")",
",",
"'unit'",
":",
"imageRow",
"[",
"\"RadiationMachineName\"",
"]",
",",
"'energy'",
":",
"energy",
",",
"'doserate'",
":",
"doserate",
",",
"'MetersetExposure'",
":",
"imageRow",
"[",
"\"MetersetExposure\"",
"]",
",",
"'ME'",
":",
"int",
"(",
"round",
"(",
"imageRow",
"[",
"\"MetersetExposure\"",
"]",
")",
")",
",",
"'Technique'",
":",
"imageRow",
"[",
"\"TechniqueLabel\"",
"]",
",",
"'gantry'",
":",
"gantry",
",",
"# GantryRtn",
"'GantryRtnDirection'",
":",
"imageRow",
"[",
"\"GantryRtnDirection\"",
"]",
",",
"# NONE, CW, CC",
"'GantryRtnExt'",
":",
"imageRow",
"[",
"\"GantryRtnExt\"",
"]",
",",
"# EN, NN",
"'StopAngle'",
":",
"imageRow",
"[",
"\"StopAngle\"",
"]",
",",
"'collimator'",
":",
"colli",
",",
"# BeamLimitingAngle",
"'CollMode'",
":",
"imageRow",
"[",
"\"CollMode\"",
"]",
",",
"# Symmetry, AsymmetryX&Y, AsymmetryX (bei MLC)",
"'table'",
":",
"table",
",",
"# PatientSupportAngle",
"'SID'",
":",
"imageRow",
"[",
"\"SAD\"",
"]",
",",
"'MLCPlanType'",
":",
"imageRow",
"[",
"\"MLCPlanType\"",
"]",
",",
"'IndexParameterType'",
":",
"imageRow",
"[",
"\"IndexParameterType\"",
"]",
",",
"'X1'",
":",
"float",
"(",
"\"{:1.1f}\"",
".",
"format",
"(",
"imageRow",
"[",
"\"CollX1\"",
"]",
")",
")",
"*",
"10",
",",
"# in mm",
"'X2'",
":",
"float",
"(",
"\"{:1.1f}\"",
".",
"format",
"(",
"imageRow",
"[",
"\"CollX2\"",
"]",
")",
")",
"*",
"10",
",",
"# in mm",
"'Y1'",
":",
"float",
"(",
"\"{:1.1f}\"",
".",
"format",
"(",
"imageRow",
"[",
"\"CollY1\"",
"]",
")",
")",
"*",
"10",
",",
"# in mm",
"'Y2'",
":",
"float",
"(",
"\"{:1.1f}\"",
".",
"format",
"(",
"imageRow",
"[",
"\"CollY2\"",
"]",
")",
")",
"*",
"10",
",",
"# in mm",
"'SliceUID'",
":",
"imageRow",
"[",
"\"SliceUID\"",
"]",
",",
"# SOP Instance UID",
"'SeriesUID'",
":",
"imageRow",
"[",
"\"SeriesUID\"",
"]",
",",
"# Series Instance UID",
"'StudyUID'",
":",
"imageRow",
"[",
"\"StudyUID\"",
"]",
",",
"#StudyInstanceUID",
"'FrameOfReferenceUID'",
":",
"imageRow",
"[",
"\"FrameOfReferenceUID\"",
"]",
",",
"'gating'",
":",
"gating",
",",
"'testTags'",
":",
"testTags",
",",
"'subTags'",
":",
"subTags",
",",
"'varianten'",
":",
"varianten",
"}",
")",
"return",
"infos"
] | [
325,
4
] | [
488,
20
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
ispBaseWebApp.parseRequestParams | ( self, queryParams:dict={}, defaults:dict={} ) | return params | Parsed zusätzliche query parameter für routeRender.
Parameters
----------
queryParams: dict
{ '_ispcp': '{"jahr":2018}'}
defaults: dict
vorgaben, die durch angegebene Parameter erweitert bzw. überschrieben werden
Returns
-------
dict:
Überprüfte und zusammengefasste Parameter
| Parsed zusätzliche query parameter für routeRender. | def parseRequestParams( self, queryParams:dict={}, defaults:dict={} ):
"""Parsed zusätzliche query parameter für routeRender.
Parameters
----------
queryParams: dict
{ '_ispcp': '{"jahr":2018}'}
defaults: dict
vorgaben, die durch angegebene Parameter erweitert bzw. überschrieben werden
Returns
-------
dict:
Überprüfte und zusammengefasste Parameter
"""
# params mit defaults vorbelegen
params = defaults.copy()
#print( ">params", params)
#logger.debug( "parseRequestParams: bei json parse in url content" )
#
# Vorarbeiten <_urlContentParamsKey> auswerten und aus queryParams entfernen
#
urlContentParams = None
if self._urlContentParamsKey in queryParams:
urlContentParams = queryParams[ self._urlContentParamsKey ]
del queryParams[ self._urlContentParamsKey ]
#
# 1. alle url parameter (queryParams) außer <_urlContentParamsKey> einfach verwenden
#
params.update( queryParams )
#
# 2. wenn ein valider jsonstring oder ein dict in <_urlContentParamsKey>
#
if urlContentParams:
if type( urlContentParams ) == str:
try:
rparams = json.loads( urlContentParams )
params.update( rparams )
except:
# print( "json.loads error", urlContentParams )
logger.debug( "parseRequestParams: bei json parse in url content" )
#self.sendAppInfo( "parseRequestParams", "bei json parse in url content" )
pass
elif type( urlContentParams ) == dict: # pragma: no cover
# kann nur passieren wenn render nicht über den Webserver aufgerufen wird
params.update( urlContentParams )
#print( "params>", params)
return params | [
"def",
"parseRequestParams",
"(",
"self",
",",
"queryParams",
":",
"dict",
"=",
"{",
"}",
",",
"defaults",
":",
"dict",
"=",
"{",
"}",
")",
":",
"# params mit defaults vorbelegen",
"params",
"=",
"defaults",
".",
"copy",
"(",
")",
"#print( \">params\", params)",
"#logger.debug( \"parseRequestParams: bei json parse in url content\" )",
"#",
"# Vorarbeiten <_urlContentParamsKey> auswerten und aus queryParams entfernen",
"#",
"urlContentParams",
"=",
"None",
"if",
"self",
".",
"_urlContentParamsKey",
"in",
"queryParams",
":",
"urlContentParams",
"=",
"queryParams",
"[",
"self",
".",
"_urlContentParamsKey",
"]",
"del",
"queryParams",
"[",
"self",
".",
"_urlContentParamsKey",
"]",
"#",
"# 1. alle url parameter (queryParams) außer <_urlContentParamsKey> einfach verwenden",
"#",
"params",
".",
"update",
"(",
"queryParams",
")",
"#",
"# 2. wenn ein valider jsonstring oder ein dict in <_urlContentParamsKey>",
"#",
"if",
"urlContentParams",
":",
"if",
"type",
"(",
"urlContentParams",
")",
"==",
"str",
":",
"try",
":",
"rparams",
"=",
"json",
".",
"loads",
"(",
"urlContentParams",
")",
"params",
".",
"update",
"(",
"rparams",
")",
"except",
":",
"# print( \"json.loads error\", urlContentParams )",
"logger",
".",
"debug",
"(",
"\"parseRequestParams: bei json parse in url content\"",
")",
"#self.sendAppInfo( \"parseRequestParams\", \"bei json parse in url content\" )",
"pass",
"elif",
"type",
"(",
"urlContentParams",
")",
"==",
"dict",
":",
"# pragma: no cover",
"# kann nur passieren wenn render nicht über den Webserver aufgerufen wird",
"params",
".",
"update",
"(",
"urlContentParams",
")",
"#print( \"params>\", params)",
"return",
"params"
] | [
529,
4
] | [
583,
21
] | null | python | de | ['de', 'de', 'de'] | True | true | null |
general.csharp | (self, ctx) | Wie soll man da überhaupt durchblicken??? | Wie soll man da überhaupt durchblicken??? | async def csharp(self, ctx):
'''Wie soll man da überhaupt durchblicken???'''
await ctx.message.delete()
await ctx.send(':interrobang: Meintest du C, C++, C# oder Objective-C? https://i.imgflip.com/235kvm.jpg') | [
"async",
"def",
"csharp",
"(",
"self",
",",
"ctx",
")",
":",
"await",
"ctx",
".",
"message",
".",
"delete",
"(",
")",
"await",
"ctx",
".",
"send",
"(",
"':interrobang: Meintest du C, C++, C# oder Objective-C? https://i.imgflip.com/235kvm.jpg'",
")"
] | [
221,
4
] | [
224,
113
] | 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.