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 |
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Joueur.enlever_vie | (self) | Enleve de la vie au joueur si il prend des dégats
| Enleve de la vie au joueur si il prend des dégats
| def enlever_vie(self):
""" Enleve de la vie au joueur si il prend des dégats
"""
if self.hitbox.collision("Monstre") and not self.blesser:
if not self.hitbox_objet.collision("Monstre"):
self.son = pg.mixer.Sound(cj.son["blessure"])
self.channel_joueur.play(self.son)
self.blesser = True
self.vie -= 1
elif not self.hitbox.collision("Monstre") and self.blesser:
self.blesser = False | [
"def",
"enlever_vie",
"(",
"self",
")",
":",
"if",
"self",
".",
"hitbox",
".",
"collision",
"(",
"\"Monstre\"",
")",
"and",
"not",
"self",
".",
"blesser",
":",
"if",
"not",
"self",
".",
"hitbox_objet",
".",
"collision",
"(",
"\"Monstre\"",
")",
":",
"self",
".",
"son",
"=",
"pg",
".",
"mixer",
".",
"Sound",
"(",
"cj",
".",
"son",
"[",
"\"blessure\"",
"]",
")",
"self",
".",
"channel_joueur",
".",
"play",
"(",
"self",
".",
"son",
")",
"self",
".",
"blesser",
"=",
"True",
"self",
".",
"vie",
"-=",
"1",
"elif",
"not",
"self",
".",
"hitbox",
".",
"collision",
"(",
"\"Monstre\"",
")",
"and",
"self",
".",
"blesser",
":",
"self",
".",
"blesser",
"=",
"False"
] | [
84,
4
] | [
95,
32
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
|
calcul_masse_totale_passagers | (df_ans) | return df_ans['Poids'].sum() | Renvoie la masse totale de tous les passagers d'une instance.
Args:
df_ans (DataFrame): DataFrame renvoyé par la fonction exporter_resultats
définie dans le notebook
Returns:
float
| Renvoie la masse totale de tous les passagers d'une instance. | def calcul_masse_totale_passagers(df_ans):
"""Renvoie la masse totale de tous les passagers d'une instance.
Args:
df_ans (DataFrame): DataFrame renvoyé par la fonction exporter_resultats
définie dans le notebook
Returns:
float
"""
return df_ans['Poids'].sum() | [
"def",
"calcul_masse_totale_passagers",
"(",
"df_ans",
")",
":",
"return",
"df_ans",
"[",
"'Poids'",
"]",
".",
"sum",
"(",
")"
] | [
228,
0
] | [
238,
32
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
supprime_dernier_caractere | (valeur1) | Supprime le dernier caractère dans la valeur1. | Supprime le dernier caractère dans la valeur1. | def supprime_dernier_caractere(valeur1):
"""Supprime le dernier caractère dans la valeur1."""
if len(valeur1) > 1:
return valeur1[:len(valeur1) - 1]
else:
return "0" | [
"def",
"supprime_dernier_caractere",
"(",
"valeur1",
")",
":",
"if",
"len",
"(",
"valeur1",
")",
">",
"1",
":",
"return",
"valeur1",
"[",
":",
"len",
"(",
"valeur1",
")",
"-",
"1",
"]",
"else",
":",
"return",
"\"0\""
] | [
74,
0
] | [
80,
18
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
|
domoticz_add_virtual_harware | () | return idx | Fonction de création du virtual hardware (matériel/dummy)
| Fonction de création du virtual hardware (matériel/dummy)
| def domoticz_add_virtual_harware():
''' Fonction de création du virtual hardware (matériel/dummy)
'''
myurl=url_domoticz+'command¶m=addhardware&htype=15&port=1&name=Cozytouch_V'+str(version)+'&enabled=true'
req=requests.get(myurl)
if debug:
print(u' '.join((u'GET-> ',myurl,' : ',str(req.status_code))).encode('utf-8'))
# Réponse HTTP 200 OK
if req.status_code==200 :
data=json.loads(req.text)
# Lecture de l'idx attribué
idx=(data[u'idx'])
else :
http_error(req.status_code,req.reason) # Appel fonction sur erreur HTTP
idx=0
print(' **** domoticz cozytouch hardware index : ',str(idx))
return idx | [
"def",
"domoticz_add_virtual_harware",
"(",
")",
":",
"myurl",
"=",
"url_domoticz",
"+",
"'command¶m=addhardware&htype=15&port=1&name=Cozytouch_V'",
"+",
"str",
"(",
"version",
")",
"+",
"'&enabled=true'",
"req",
"=",
"requests",
".",
"get",
"(",
"myurl",
")",
"if",
"debug",
":",
"print",
"(",
"u' '",
".",
"join",
"(",
"(",
"u'GET-> '",
",",
"myurl",
",",
"' : '",
",",
"str",
"(",
"req",
".",
"status_code",
")",
")",
")",
".",
"encode",
"(",
"'utf-8'",
")",
")",
"# Réponse HTTP 200 OK",
"if",
"req",
".",
"status_code",
"==",
"200",
":",
"data",
"=",
"json",
".",
"loads",
"(",
"req",
".",
"text",
")",
"# Lecture de l'idx attribué",
"idx",
"=",
"(",
"data",
"[",
"u'idx'",
"]",
")",
"else",
":",
"http_error",
"(",
"req",
".",
"status_code",
",",
"req",
".",
"reason",
")",
"# Appel fonction sur erreur HTTP",
"idx",
"=",
"0",
"print",
"(",
"' **** domoticz cozytouch hardware index : '",
",",
"str",
"(",
"idx",
")",
")",
"return",
"idx"
] | [
273,
0
] | [
291,
14
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
domoticz_read_user_variable | (idx) | Fonction de lecture d'une variable utilisateur
renvoie la variable lue selon l'idx
| Fonction de lecture d'une variable utilisateur
renvoie la variable lue selon l'idx
| def domoticz_read_user_variable(idx):
''' Fonction de lecture d'une variable utilisateur
renvoie la variable lue selon l'idx
'''
idx=str(idx)
myurl=url_domoticz+'command¶m=getuservariables'
req=requests.get(myurl)
if debug:
print(u' '.join((u'GET-> ',myurl,' : ',str(req.status_code))).encode('utf-8'))
# Réponse HTTP 200 OK
if req.status_code==200 :
data=json.loads(req.text)
# Lecture de la valeur de la variable
# Les données sont dans un dictionnaire ( [] ) d'où le [0]
select=(data[u'result'][0][u'Value'])
return select
else:
http_error(req.status_code,req.reason) # Appel fonction sur erreur HTTP
return None | [
"def",
"domoticz_read_user_variable",
"(",
"idx",
")",
":",
"idx",
"=",
"str",
"(",
"idx",
")",
"myurl",
"=",
"url_domoticz",
"+",
"'command¶m=getuservariables'",
"req",
"=",
"requests",
".",
"get",
"(",
"myurl",
")",
"if",
"debug",
":",
"print",
"(",
"u' '",
".",
"join",
"(",
"(",
"u'GET-> '",
",",
"myurl",
",",
"' : '",
",",
"str",
"(",
"req",
".",
"status_code",
")",
")",
")",
".",
"encode",
"(",
"'utf-8'",
")",
")",
"# Réponse HTTP 200 OK",
"if",
"req",
".",
"status_code",
"==",
"200",
":",
"data",
"=",
"json",
".",
"loads",
"(",
"req",
".",
"text",
")",
"# Lecture de la valeur de la variable",
"# Les données sont dans un dictionnaire ( [] ) d'où le [0]",
"select",
"=",
"(",
"data",
"[",
"u'result'",
"]",
"[",
"0",
"]",
"[",
"u'Value'",
"]",
")",
"return",
"select",
"else",
":",
"http_error",
"(",
"req",
".",
"status_code",
",",
"req",
".",
"reason",
")",
"# Appel fonction sur erreur HTTP",
"return",
"None"
] | [
200,
0
] | [
220,
19
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
|
Crud.set_field_prop | (self, element, prop, value) | Ajouter/mettre à jour une propriété d'un champ du formulaire courant | Ajouter/mettre à jour une propriété d'un champ du formulaire courant | def set_field_prop(self, element, prop, value):
""" Ajouter/mettre à jour une propriété d'un champ du formulaire courant """
self.application["tables"][self.ctx["table_id"]]["forms"][self.ctx["form_id"]]["elements"][element][prop] = value | [
"def",
"set_field_prop",
"(",
"self",
",",
"element",
",",
"prop",
",",
"value",
")",
":",
"self",
".",
"application",
"[",
"\"tables\"",
"]",
"[",
"self",
".",
"ctx",
"[",
"\"table_id\"",
"]",
"]",
"[",
"\"forms\"",
"]",
"[",
"self",
".",
"ctx",
"[",
"\"form_id\"",
"]",
"]",
"[",
"\"elements\"",
"]",
"[",
"element",
"]",
"[",
"prop",
"]",
"=",
"value"
] | [
567,
4
] | [
569,
121
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
|
is_cout_calcul._get_pricelist | (self,product) | return pricelist | Recherche pricelist du fournisseur par défaut | Recherche pricelist du fournisseur par défaut | def _get_pricelist(self,product):
"""Recherche pricelist du fournisseur par défaut"""
cr = self._cr
seller=False
if product.seller_ids:
seller=product.seller_ids[0]
pricelist=False
if seller:
partner=seller.name
SQL="""
SELECT get_product_pricelist_purchase(id)
FROM res_partner
WHERE id="""+str(partner.id)+"""
"""
cr.execute(SQL)
result = cr.fetchall()
for row in result:
pricelist=self.env['product.pricelist'].browse(row[0])
return pricelist | [
"def",
"_get_pricelist",
"(",
"self",
",",
"product",
")",
":",
"cr",
"=",
"self",
".",
"_cr",
"seller",
"=",
"False",
"if",
"product",
".",
"seller_ids",
":",
"seller",
"=",
"product",
".",
"seller_ids",
"[",
"0",
"]",
"pricelist",
"=",
"False",
"if",
"seller",
":",
"partner",
"=",
"seller",
".",
"name",
"SQL",
"=",
"\"\"\"\n SELECT get_product_pricelist_purchase(id)\n FROM res_partner\n WHERE id=\"\"\"",
"+",
"str",
"(",
"partner",
".",
"id",
")",
"+",
"\"\"\"\n \"\"\"",
"cr",
".",
"execute",
"(",
"SQL",
")",
"result",
"=",
"cr",
".",
"fetchall",
"(",
")",
"for",
"row",
"in",
"result",
":",
"pricelist",
"=",
"self",
".",
"env",
"[",
"'product.pricelist'",
"]",
".",
"browse",
"(",
"row",
"[",
"0",
"]",
")",
"return",
"pricelist"
] | [
167,
4
] | [
185,
24
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
base | (x, b) | return d | calcule les chiffres de en base b | calcule les chiffres de en base b | def base(x, b):
""" calcule les chiffres de en base b """
d = []
while x != 0:
x, r = divmod(x, b)
d.append(r)
return d | [
"def",
"base",
"(",
"x",
",",
"b",
")",
":",
"d",
"=",
"[",
"]",
"while",
"x",
"!=",
"0",
":",
"x",
",",
"r",
"=",
"divmod",
"(",
"x",
",",
"b",
")",
"d",
".",
"append",
"(",
"r",
")",
"return",
"d"
] | [
46,
0
] | [
52,
12
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
Vecteur.norme | (self) | return math.sqrt(self.norme2()) | retourne la norme du vecteur | retourne la norme du vecteur | def norme(self):
"""retourne la norme du vecteur"""
return math.sqrt(self.norme2()) | [
"def",
"norme",
"(",
"self",
")",
":",
"return",
"math",
".",
"sqrt",
"(",
"self",
".",
"norme2",
"(",
")",
")"
] | [
85,
4
] | [
87,
39
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
cozytouch_GET | (json) | return None | Fonction d'interrogation HTTP GET avec l'url par défaut
json: nom de fonction JSON à transmettre au serveur
| Fonction d'interrogation HTTP GET avec l'url par défaut
json: nom de fonction JSON à transmettre au serveur
| def cozytouch_GET(json):
''' Fonction d'interrogation HTTP GET avec l'url par défaut
json: nom de fonction JSON à transmettre au serveur
'''
headers = {
'cache-control': "no-cache",
'Host' : "ha110-1.overkiz.com",
'Connection':"Keep-Alive",
}
myurl=url_cozytouch+json
cookies=var_restore('cookies')
req = requests.get(myurl,headers=headers,cookies=cookies)
if debug:
print(u' '.join((u'GET-> ',myurl,' : ',str(req.status_code))).encode('utf-8'))
if req.status_code==200 : # Réponse HTTP 200 : OK
data=req.json()
return data
http_error(req.status_code,req.reason) # Appel fonction sur erreur HTTP
time.sleep(1) # Tempo entre requetes
return None | [
"def",
"cozytouch_GET",
"(",
"json",
")",
":",
"headers",
"=",
"{",
"'cache-control'",
":",
"\"no-cache\"",
",",
"'Host'",
":",
"\"ha110-1.overkiz.com\"",
",",
"'Connection'",
":",
"\"Keep-Alive\"",
",",
"}",
"myurl",
"=",
"url_cozytouch",
"+",
"json",
"cookies",
"=",
"var_restore",
"(",
"'cookies'",
")",
"req",
"=",
"requests",
".",
"get",
"(",
"myurl",
",",
"headers",
"=",
"headers",
",",
"cookies",
"=",
"cookies",
")",
"if",
"debug",
":",
"print",
"(",
"u' '",
".",
"join",
"(",
"(",
"u'GET-> '",
",",
"myurl",
",",
"' : '",
",",
"str",
"(",
"req",
".",
"status_code",
")",
")",
")",
".",
"encode",
"(",
"'utf-8'",
")",
")",
"if",
"req",
".",
"status_code",
"==",
"200",
":",
"# Réponse HTTP 200 : OK",
"data",
"=",
"req",
".",
"json",
"(",
")",
"return",
"data",
"http_error",
"(",
"req",
".",
"status_code",
",",
"req",
".",
"reason",
")",
"# Appel fonction sur erreur HTTP",
"time",
".",
"sleep",
"(",
"1",
")",
"# Tempo entre requetes",
"return",
"None"
] | [
405,
0
] | [
426,
15
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
ManagerClient.run | (self) | Initialise la connexion au serveur. Attent les messages venant du
serveur pour les envoyer à traiter. Attend également que des messages
soit à envoyer au serveur pour les pousser au gestionnaire de connexion. | Initialise la connexion au serveur. Attent les messages venant du
serveur pour les envoyer à traiter. Attend également que des messages
soit à envoyer au serveur pour les pousser au gestionnaire de connexion. | def run(self) :
""" Initialise la connexion au serveur. Attent les messages venant du
serveur pour les envoyer à traiter. Attend également que des messages
soit à envoyer au serveur pour les pousser au gestionnaire de connexion."""
sys.stdout.write("[started] client manager !\n")
sys.stdout.flush()
while self.client_life is True :
# Msg from server
for msg in self.network_service.input_message_list :
self.input_processing(msg)
self.network_service.delmsg(msg)
# Manage window
if self.window is not None :
for msg in self.window.output_message :
self.output_processing(msg)
self.window.output_message.remove(msg)
if self.window.exists :
self.window.update()
else :
self.window = None
# Msg from keyboard
if self.shortcut_service.alert :
self.output_processing("i_am_in_alert")
self.shortcut_service.alert = False
# Msg to server
for msg in self.new_message_for_server_list :
self.network_service.addmsg(msg)
self.new_message_for_server_list.remove(msg)
sleep(0.1) | [
"def",
"run",
"(",
"self",
")",
":",
"sys",
".",
"stdout",
".",
"write",
"(",
"\"[started] client manager !\\n\"",
")",
"sys",
".",
"stdout",
".",
"flush",
"(",
")",
"while",
"self",
".",
"client_life",
"is",
"True",
":",
"# Msg from server",
"for",
"msg",
"in",
"self",
".",
"network_service",
".",
"input_message_list",
":",
"self",
".",
"input_processing",
"(",
"msg",
")",
"self",
".",
"network_service",
".",
"delmsg",
"(",
"msg",
")",
"# Manage window",
"if",
"self",
".",
"window",
"is",
"not",
"None",
":",
"for",
"msg",
"in",
"self",
".",
"window",
".",
"output_message",
":",
"self",
".",
"output_processing",
"(",
"msg",
")",
"self",
".",
"window",
".",
"output_message",
".",
"remove",
"(",
"msg",
")",
"if",
"self",
".",
"window",
".",
"exists",
":",
"self",
".",
"window",
".",
"update",
"(",
")",
"else",
":",
"self",
".",
"window",
"=",
"None",
"# Msg from keyboard",
"if",
"self",
".",
"shortcut_service",
".",
"alert",
":",
"self",
".",
"output_processing",
"(",
"\"i_am_in_alert\"",
")",
"self",
".",
"shortcut_service",
".",
"alert",
"=",
"False",
"# Msg to server",
"for",
"msg",
"in",
"self",
".",
"new_message_for_server_list",
":",
"self",
".",
"network_service",
".",
"addmsg",
"(",
"msg",
")",
"self",
".",
"new_message_for_server_list",
".",
"remove",
"(",
"msg",
")",
"sleep",
"(",
"0.1",
")"
] | [
25,
4
] | [
53,
22
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
|
Events.add_points | (self, points: int) | Ajoute ou enlève un certain nombre de points au score
La principale utilité de cette fonction est de pouvoir check le nombre de points à chaque changement | Ajoute ou enlève un certain nombre de points au score
La principale utilité de cette fonction est de pouvoir check le nombre de points à chaque changement | async def add_points(self, points: int):
"""Ajoute ou enlève un certain nombre de points au score
La principale utilité de cette fonction est de pouvoir check le nombre de points à chaque changement"""
self.points += points
if self.points < 0:
self.points = 0 | [
"async",
"def",
"add_points",
"(",
"self",
",",
"points",
":",
"int",
")",
":",
"self",
".",
"points",
"+=",
"points",
"if",
"self",
".",
"points",
"<",
"0",
":",
"self",
".",
"points",
"=",
"0"
] | [
274,
4
] | [
279,
27
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
|
gagnant_ligne | (lig, col, grille) | return | Renvoie True si le coup joué (lig,col) forme une ligne de 4 jetons
False sinon
| Renvoie True si le coup joué (lig,col) forme une ligne de 4 jetons
False sinon
| def gagnant_ligne(lig, col, grille):
"""Renvoie True si le coup joué (lig,col) forme une ligne de 4 jetons
False sinon
"""
return | [
"def",
"gagnant_ligne",
"(",
"lig",
",",
"col",
",",
"grille",
")",
":",
"return"
] | [
68,
0
] | [
72,
10
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
fusionne_blocs | (bloc1, bloc2) | return resultat | Fusionne 2 blocs de texte. | Fusionne 2 blocs de texte. | def fusionne_blocs(bloc1, bloc2):
"""Fusionne 2 blocs de texte."""
resultat = ""
max1, max2 = 0, 0
# Fusionne les lignes
while len(bloc1) > 0 and len(bloc2) > 0:
i = bloc1.find("\n")
resultat += bloc1[:i]
max1 = max(max1, len(bloc1[:i]))
bloc1 = bloc1[i+1:]
i = bloc2.find("\n")
resultat += bloc2[:i+1]
max2 = max(max2, len(bloc2[:i]))
bloc2 = bloc2[i+1:]
# Restant à gauche
while len(bloc1) > 0:
i = bloc1.find("\n")
resultat += bloc1[:i]
resultat += max2 * " " + "\n"
bloc1 = bloc1[i+1:]
# Restant à droite
while len(bloc2) > 0:
i = bloc2.find("\n")
resultat += max1 * " "
resultat += bloc2[:i+1]
bloc2 = bloc2[i+1:]
return resultat | [
"def",
"fusionne_blocs",
"(",
"bloc1",
",",
"bloc2",
")",
":",
"resultat",
"=",
"\"\"",
"max1",
",",
"max2",
"=",
"0",
",",
"0",
"# Fusionne les lignes",
"while",
"len",
"(",
"bloc1",
")",
">",
"0",
"and",
"len",
"(",
"bloc2",
")",
">",
"0",
":",
"i",
"=",
"bloc1",
".",
"find",
"(",
"\"\\n\"",
")",
"resultat",
"+=",
"bloc1",
"[",
":",
"i",
"]",
"max1",
"=",
"max",
"(",
"max1",
",",
"len",
"(",
"bloc1",
"[",
":",
"i",
"]",
")",
")",
"bloc1",
"=",
"bloc1",
"[",
"i",
"+",
"1",
":",
"]",
"i",
"=",
"bloc2",
".",
"find",
"(",
"\"\\n\"",
")",
"resultat",
"+=",
"bloc2",
"[",
":",
"i",
"+",
"1",
"]",
"max2",
"=",
"max",
"(",
"max2",
",",
"len",
"(",
"bloc2",
"[",
":",
"i",
"]",
")",
")",
"bloc2",
"=",
"bloc2",
"[",
"i",
"+",
"1",
":",
"]",
"# Restant à gauche",
"while",
"len",
"(",
"bloc1",
")",
">",
"0",
":",
"i",
"=",
"bloc1",
".",
"find",
"(",
"\"\\n\"",
")",
"resultat",
"+=",
"bloc1",
"[",
":",
"i",
"]",
"resultat",
"+=",
"max2",
"*",
"\" \"",
"+",
"\"\\n\"",
"bloc1",
"=",
"bloc1",
"[",
"i",
"+",
"1",
":",
"]",
"# Restant à droite",
"while",
"len",
"(",
"bloc2",
")",
">",
"0",
":",
"i",
"=",
"bloc2",
".",
"find",
"(",
"\"\\n\"",
")",
"resultat",
"+=",
"max1",
"*",
"\" \"",
"resultat",
"+=",
"bloc2",
"[",
":",
"i",
"+",
"1",
"]",
"bloc2",
"=",
"bloc2",
"[",
"i",
"+",
"1",
":",
"]",
"return",
"resultat"
] | [
110,
0
] | [
141,
19
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
Admin.best_ideas | (self, ctx: MyContext, number:int=10) | Donne la liste des 10 meilleures idées | Donne la liste des 10 meilleures idées | async def best_ideas(self, ctx: MyContext, number:int=10):
"""Donne la liste des 10 meilleures idées"""
bot_msg = await ctx.send("Chargement des idées...")
server = self.bot.get_guild(356067272730607628)
if server is None:
return await ctx.send("Serveur introuvable")
channel = server.get_channel(488769306524385301)
if channel is None:
return await ctx.send("Salon introuvable")
liste = list()
async for msg in channel.history(limit=500):
if len(msg.reactions) > 0:
up = 0
down = 0
for x in msg.reactions:
users = [x for x in await x.users().flatten() if not x.bot]
if x.emoji == '👍':
up = len(users)
elif x.emoji == '👎':
down = len(users)
if len(msg.embeds) > 0:
liste.append((up-down,ctx.bot.utcnow()-msg.created_at,msg.embeds[0].fields[0].value,up,down))
else:
liste.append((up-down,ctx.bot.utcnow()-msg.created_at,msg.content,up,down))
liste.sort(reverse=True)
count = len(liste)
liste = liste[:number]
title = "Liste des {} meilleures idées (sur {}) :".format(len(liste),count)
text = str()
if ctx.guild is not None:
color = ctx.guild.me.color
else:
color = discord.Colour(8311585)
for x in liste:
text += "\n**[{} - {}]** {} ".format(x[3],x[4],x[2])
try:
if ctx.can_send_embed:
emb = ctx.bot.get_cog('Embeds').Embed(title=title,desc=text,color=color).update_timestamp()
return await bot_msg.edit(content=None,embed=emb.discord_embed())
await bot_msg.edit(content=title+text)
except discord.HTTPException:
await ctx.send("Le message est trop long pour être envoyé !") | [
"async",
"def",
"best_ideas",
"(",
"self",
",",
"ctx",
":",
"MyContext",
",",
"number",
":",
"int",
"=",
"10",
")",
":",
"bot_msg",
"=",
"await",
"ctx",
".",
"send",
"(",
"\"Chargement des idées...\")",
"",
"server",
"=",
"self",
".",
"bot",
".",
"get_guild",
"(",
"356067272730607628",
")",
"if",
"server",
"is",
"None",
":",
"return",
"await",
"ctx",
".",
"send",
"(",
"\"Serveur introuvable\"",
")",
"channel",
"=",
"server",
".",
"get_channel",
"(",
"488769306524385301",
")",
"if",
"channel",
"is",
"None",
":",
"return",
"await",
"ctx",
".",
"send",
"(",
"\"Salon introuvable\"",
")",
"liste",
"=",
"list",
"(",
")",
"async",
"for",
"msg",
"in",
"channel",
".",
"history",
"(",
"limit",
"=",
"500",
")",
":",
"if",
"len",
"(",
"msg",
".",
"reactions",
")",
">",
"0",
":",
"up",
"=",
"0",
"down",
"=",
"0",
"for",
"x",
"in",
"msg",
".",
"reactions",
":",
"users",
"=",
"[",
"x",
"for",
"x",
"in",
"await",
"x",
".",
"users",
"(",
")",
".",
"flatten",
"(",
")",
"if",
"not",
"x",
".",
"bot",
"]",
"if",
"x",
".",
"emoji",
"==",
"'👍':",
"",
"up",
"=",
"len",
"(",
"users",
")",
"elif",
"x",
".",
"emoji",
"==",
"'👎':",
"",
"down",
"=",
"len",
"(",
"users",
")",
"if",
"len",
"(",
"msg",
".",
"embeds",
")",
">",
"0",
":",
"liste",
".",
"append",
"(",
"(",
"up",
"-",
"down",
",",
"ctx",
".",
"bot",
".",
"utcnow",
"(",
")",
"-",
"msg",
".",
"created_at",
",",
"msg",
".",
"embeds",
"[",
"0",
"]",
".",
"fields",
"[",
"0",
"]",
".",
"value",
",",
"up",
",",
"down",
")",
")",
"else",
":",
"liste",
".",
"append",
"(",
"(",
"up",
"-",
"down",
",",
"ctx",
".",
"bot",
".",
"utcnow",
"(",
")",
"-",
"msg",
".",
"created_at",
",",
"msg",
".",
"content",
",",
"up",
",",
"down",
")",
")",
"liste",
".",
"sort",
"(",
"reverse",
"=",
"True",
")",
"count",
"=",
"len",
"(",
"liste",
")",
"liste",
"=",
"liste",
"[",
":",
"number",
"]",
"title",
"=",
"\"Liste des {} meilleures idées (sur {}) :\".",
"f",
"ormat(",
"l",
"en(",
"l",
"iste)",
",",
"c",
"ount)",
"",
"text",
"=",
"str",
"(",
")",
"if",
"ctx",
".",
"guild",
"is",
"not",
"None",
":",
"color",
"=",
"ctx",
".",
"guild",
".",
"me",
".",
"color",
"else",
":",
"color",
"=",
"discord",
".",
"Colour",
"(",
"8311585",
")",
"for",
"x",
"in",
"liste",
":",
"text",
"+=",
"\"\\n**[{} - {}]** {} \"",
".",
"format",
"(",
"x",
"[",
"3",
"]",
",",
"x",
"[",
"4",
"]",
",",
"x",
"[",
"2",
"]",
")",
"try",
":",
"if",
"ctx",
".",
"can_send_embed",
":",
"emb",
"=",
"ctx",
".",
"bot",
".",
"get_cog",
"(",
"'Embeds'",
")",
".",
"Embed",
"(",
"title",
"=",
"title",
",",
"desc",
"=",
"text",
",",
"color",
"=",
"color",
")",
".",
"update_timestamp",
"(",
")",
"return",
"await",
"bot_msg",
".",
"edit",
"(",
"content",
"=",
"None",
",",
"embed",
"=",
"emb",
".",
"discord_embed",
"(",
")",
")",
"await",
"bot_msg",
".",
"edit",
"(",
"content",
"=",
"title",
"+",
"text",
")",
"except",
"discord",
".",
"HTTPException",
":",
"await",
"ctx",
".",
"send",
"(",
"\"Le message est trop long pour être envoyé !\")",
""
] | [
670,
4
] | [
711,
75
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
|
MenuDemo.buildMenu | (self) | return self.menu | Construction du menu | Construction du menu | def buildMenu(self):
"""Construction du menu"""
self.menu = Menu(self.loop)
_menu1 = "Fichier"
self.menu.addMenu(_menu1, "Help", self.menu_cb) # Adding a menu is quite easy
self.menu.addMenu(_menu1, "Item 2", self.menu_cb) # Here the callback is always the same,
self.menu.addMenu(_menu1, "Item 3", self.menu_cb) # but you use different ones in real life :)
self.menu.addMenu(_menu1, "Quitter (C-x)", self.exit_cb, 'ctrl x') # You can also add a shortcut
_menu2 = "Menu 2"
self.menu.addMenu(_menu2, "Item 1", self.menu_cb)
self.menu.addMenu(_menu2, "Item 2", self.menu_cb)
self.menu.addMenu(_menu2, "Item 3", self.menu_cb)
return self.menu | [
"def",
"buildMenu",
"(",
"self",
")",
":",
"self",
".",
"menu",
"=",
"Menu",
"(",
"self",
".",
"loop",
")",
"_menu1",
"=",
"\"Fichier\"",
"self",
".",
"menu",
".",
"addMenu",
"(",
"_menu1",
",",
"\"Help\"",
",",
"self",
".",
"menu_cb",
")",
"# Adding a menu is quite easy",
"self",
".",
"menu",
".",
"addMenu",
"(",
"_menu1",
",",
"\"Item 2\"",
",",
"self",
".",
"menu_cb",
")",
"# Here the callback is always the same,",
"self",
".",
"menu",
".",
"addMenu",
"(",
"_menu1",
",",
"\"Item 3\"",
",",
"self",
".",
"menu_cb",
")",
"# but you use different ones in real life :)",
"self",
".",
"menu",
".",
"addMenu",
"(",
"_menu1",
",",
"\"Quitter (C-x)\"",
",",
"self",
".",
"exit_cb",
",",
"'ctrl x'",
")",
"# You can also add a shortcut",
"_menu2",
"=",
"\"Menu 2\"",
"self",
".",
"menu",
".",
"addMenu",
"(",
"_menu2",
",",
"\"Item 1\"",
",",
"self",
".",
"menu_cb",
")",
"self",
".",
"menu",
".",
"addMenu",
"(",
"_menu2",
",",
"\"Item 2\"",
",",
"self",
".",
"menu_cb",
")",
"self",
".",
"menu",
".",
"addMenu",
"(",
"_menu2",
",",
"\"Item 3\"",
",",
"self",
".",
"menu_cb",
")",
"return",
"self",
".",
"menu"
] | [
91,
4
] | [
103,
24
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
filtreMoyen | (data, fenetre) | return filtrer | écart à la moyenne sur la fenetre de fenetre points. data est un array ou une liste monodimensionnelle | écart à la moyenne sur la fenetre de fenetre points. data est un array ou une liste monodimensionnelle | def filtreMoyen(data, fenetre):
'''écart à la moyenne sur la fenetre de fenetre points. data est un array ou une liste monodimensionnelle '''
fenetre = fenetre//2
S = sum(data[0:fenetre])
nb = fenetre
N = len(data)
filtrer = np.empty(len(data))
for i in range(N):
if i - fenetre >= 0:
S -= data[i-fenetre]
nb -= 1
if i + fenetre < N:
S += data[i+fenetre]
nb += 1
filtrer[i] = data[i] - S/nb
return filtrer | [
"def",
"filtreMoyen",
"(",
"data",
",",
"fenetre",
")",
":",
"fenetre",
"=",
"fenetre",
"//",
"2",
"S",
"=",
"sum",
"(",
"data",
"[",
"0",
":",
"fenetre",
"]",
")",
"nb",
"=",
"fenetre",
"N",
"=",
"len",
"(",
"data",
")",
"filtrer",
"=",
"np",
".",
"empty",
"(",
"len",
"(",
"data",
")",
")",
"for",
"i",
"in",
"range",
"(",
"N",
")",
":",
"if",
"i",
"-",
"fenetre",
">=",
"0",
":",
"S",
"-=",
"data",
"[",
"i",
"-",
"fenetre",
"]",
"nb",
"-=",
"1",
"if",
"i",
"+",
"fenetre",
"<",
"N",
":",
"S",
"+=",
"data",
"[",
"i",
"+",
"fenetre",
"]",
"nb",
"+=",
"1",
"filtrer",
"[",
"i",
"]",
"=",
"data",
"[",
"i",
"]",
"-",
"S",
"/",
"nb",
"return",
"filtrer"
] | [
105,
0
] | [
120,
18
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
rectangle_sup | (f, a, b, n_eval = False) | return rectangle(f, a, b, b) | Méthode des rectangles supérieurs | Méthode des rectangles supérieurs | def rectangle_sup(f, a, b, n_eval = False):
"Méthode des rectangles supérieurs"
if n_eval:
return 1
return rectangle(f, a, b, b) | [
"def",
"rectangle_sup",
"(",
"f",
",",
"a",
",",
"b",
",",
"n_eval",
"=",
"False",
")",
":",
"if",
"n_eval",
":",
"return",
"1",
"return",
"rectangle",
"(",
"f",
",",
"a",
",",
"b",
",",
"b",
")"
] | [
30,
0
] | [
34,
29
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
updateSiteInfo | (feature) | Callback séparée possible pour site info car pas de boucle. | Callback séparée possible pour site info car pas de boucle. | def updateSiteInfo(feature):
"""Callback séparée possible pour site info car pas de boucle."""
if feature:
return f"Site sélectionné: {feature['properties']['id']}"
else:
return "Pas de sélection site" | [
"def",
"updateSiteInfo",
"(",
"feature",
")",
":",
"if",
"feature",
":",
"return",
"f\"Site sélectionné: {feature['properties']['id']}\"",
"else",
":",
"return",
"\"Pas de sélection site\""
] | [
71,
0
] | [
76,
39
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
|
reinitialise | () | return "", "0", "" | Réinitialise l'ancienne valeur0, la valeur1 courante, et l'opération. | Réinitialise l'ancienne valeur0, la valeur1 courante, et l'opération. | def reinitialise():
"""Réinitialise l'ancienne valeur0, la valeur1 courante, et l'opération."""
return "", "0", "" | [
"def",
"reinitialise",
"(",
")",
":",
"return",
"\"\"",
",",
"\"0\"",
",",
"\"\""
] | [
94,
0
] | [
96,
22
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
derivate_sequence_polynomials | (poly_list) | return deriv_list | Retourne la liste des dérivées des polynômes de degré 3 correspondant à une liste de points | Retourne la liste des dérivées des polynômes de degré 3 correspondant à une liste de points | def derivate_sequence_polynomials(poly_list):
""" Retourne la liste des dérivées des polynômes de degré 3 correspondant à une liste de points """
deriv_list = []
for i in range(len(poly_list)):
deriv_list.append(derivate_poly_3(poly_list[i]))
return deriv_list | [
"def",
"derivate_sequence_polynomials",
"(",
"poly_list",
")",
":",
"deriv_list",
"=",
"[",
"]",
"for",
"i",
"in",
"range",
"(",
"len",
"(",
"poly_list",
")",
")",
":",
"deriv_list",
".",
"append",
"(",
"derivate_poly_3",
"(",
"poly_list",
"[",
"i",
"]",
")",
")",
"return",
"deriv_list"
] | [
133,
0
] | [
138,
19
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
read_and_preprocess | (date) | return df | Renvoie le DataFrame correspondant à l'instance
à la date donnée.
| Renvoie le DataFrame correspondant à l'instance
à la date donnée.
| def read_and_preprocess(date):
"""Renvoie le DataFrame correspondant à l'instance
à la date donnée.
"""
df = pd.read_csv(get_filepath(date))
# Conversion en TimeStamp
df['TransitTime'] = pd.to_datetime(df['TransitTime']).dt.time
return df | [
"def",
"read_and_preprocess",
"(",
"date",
")",
":",
"df",
"=",
"pd",
".",
"read_csv",
"(",
"get_filepath",
"(",
"date",
")",
")",
"# Conversion en TimeStamp",
"df",
"[",
"'TransitTime'",
"]",
"=",
"pd",
".",
"to_datetime",
"(",
"df",
"[",
"'TransitTime'",
"]",
")",
".",
"dt",
".",
"time",
"return",
"df"
] | [
6,
0
] | [
15,
13
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
OscAug.sFade | (self, x, y) | Ajustement du fadein et fadeout | Ajustement du fadein et fadeout | def sFade(self, x, y):
"Ajustement du fadein et fadeout"
self.fade.fadein = x
self.fade.fadeout = y | [
"def",
"sFade",
"(",
"self",
",",
"x",
",",
"y",
")",
":",
"self",
".",
"fade",
".",
"fadein",
"=",
"x",
"self",
".",
"fade",
".",
"fadeout",
"=",
"y"
] | [
73,
4
] | [
76,
29
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
|
Crud.get_table_values | (self, dico=None, elements=None) | return dico | Remplir "dict" avec les valeurs des éléments de la table courante | Remplir "dict" avec les valeurs des éléments de la table courante | def get_table_values(self, dico=None, elements=None):
""" Remplir "dict" avec les valeurs des éléments de la table courante """
if dico is None : dico = {}
if elements is None : elements = self.get_table_elements()
for element in elements:
crudel = elements[element].get("crudel")
if crudel is not None:
dico[element] = crudel.get_value()
return dico | [
"def",
"get_table_values",
"(",
"self",
",",
"dico",
"=",
"None",
",",
"elements",
"=",
"None",
")",
":",
"if",
"dico",
"is",
"None",
":",
"dico",
"=",
"{",
"}",
"if",
"elements",
"is",
"None",
":",
"elements",
"=",
"self",
".",
"get_table_elements",
"(",
")",
"for",
"element",
"in",
"elements",
":",
"crudel",
"=",
"elements",
"[",
"element",
"]",
".",
"get",
"(",
"\"crudel\"",
")",
"if",
"crudel",
"is",
"not",
"None",
":",
"dico",
"[",
"element",
"]",
"=",
"crudel",
".",
"get_value",
"(",
")",
"return",
"dico"
] | [
481,
4
] | [
489,
19
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
Vecteur.__eq__ | (self, v) | return self.diff_abs(v) < 1e-10 | définit l'égalité entre deux vecteurs | définit l'égalité entre deux vecteurs | def __eq__(self, v):
"""définit l'égalité entre deux vecteurs"""
if v is None:
return False
return self.diff_abs(v) < 1e-10 | [
"def",
"__eq__",
"(",
"self",
",",
"v",
")",
":",
"if",
"v",
"is",
"None",
":",
"return",
"False",
"return",
"self",
".",
"diff_abs",
"(",
"v",
")",
"<",
"1e-10"
] | [
137,
4
] | [
141,
39
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
affiche_erreur | (texte) | Affiche le texte d'erreur en entrée dans un popup | Affiche le texte d'erreur en entrée dans un popup | def affiche_erreur(texte):
"""Affiche le texte d'erreur en entrée dans un popup"""
sg.popup_ok(texte) | [
"def",
"affiche_erreur",
"(",
"texte",
")",
":",
"sg",
".",
"popup_ok",
"(",
"texte",
")"
] | [
10,
0
] | [
13,
22
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
|
Admin.enable_module | (self, ctx: MyContext, module: str, enabling: bool=True) | Active ou désactive un module (xp/rss/alerts)
Cette option affecte tous les serveurs | Active ou désactive un module (xp/rss/alerts)
Cette option affecte tous les serveurs | async def enable_module(self, ctx: MyContext, module: str, enabling: bool=True):
"""Active ou désactive un module (xp/rss/alerts)
Cette option affecte tous les serveurs"""
if module=='xp':
self.bot.xp_enabled = enabling
if enabling:
await ctx.send("L'xp est mainenant activée")
else:
await ctx.send("L'xp est mainenant désactivée")
elif module=='rss':
self.bot.rss_enabled = enabling
if enabling:
await ctx.send("Les flux RSS sont mainenant activée")
else:
await ctx.send("Les flux RSS sont mainenant désactivée")
elif module == 'alerts':
self.bot.alerts_enabled = enabling
if enabling:
await ctx.send("Le système d'alertes est mainenant activé")
else:
await ctx.send("Le système d'alertes est mainenant désactivé")
else:
await ctx.send('Module introuvable') | [
"async",
"def",
"enable_module",
"(",
"self",
",",
"ctx",
":",
"MyContext",
",",
"module",
":",
"str",
",",
"enabling",
":",
"bool",
"=",
"True",
")",
":",
"if",
"module",
"==",
"'xp'",
":",
"self",
".",
"bot",
".",
"xp_enabled",
"=",
"enabling",
"if",
"enabling",
":",
"await",
"ctx",
".",
"send",
"(",
"\"L'xp est mainenant activée\")",
"",
"else",
":",
"await",
"ctx",
".",
"send",
"(",
"\"L'xp est mainenant désactivée\")",
"",
"elif",
"module",
"==",
"'rss'",
":",
"self",
".",
"bot",
".",
"rss_enabled",
"=",
"enabling",
"if",
"enabling",
":",
"await",
"ctx",
".",
"send",
"(",
"\"Les flux RSS sont mainenant activée\")",
"",
"else",
":",
"await",
"ctx",
".",
"send",
"(",
"\"Les flux RSS sont mainenant désactivée\")",
"",
"elif",
"module",
"==",
"'alerts'",
":",
"self",
".",
"bot",
".",
"alerts_enabled",
"=",
"enabling",
"if",
"enabling",
":",
"await",
"ctx",
".",
"send",
"(",
"\"Le système d'alertes est mainenant activé\")",
"",
"else",
":",
"await",
"ctx",
".",
"send",
"(",
"\"Le système d'alertes est mainenant désactivé\")",
"",
"else",
":",
"await",
"ctx",
".",
"send",
"(",
"'Module introuvable'",
")"
] | [
562,
4
] | [
584,
48
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
|
DatasetList.post | (self, request) | return response | Créer un nouveau jeu de données. | Créer un nouveau jeu de données. | def post(self, request):
"""Créer un nouveau jeu de données."""
request.POST._mutable = True
try:
dataset = handle_pust_request(request)
except Http404:
raise Http404()
except GenericException as e:
return JsonResponse({'error': e.details}, status=400)
response = HttpResponse(status=201)
response['Content-Location'] = dataset.api_location
return response | [
"def",
"post",
"(",
"self",
",",
"request",
")",
":",
"request",
".",
"POST",
".",
"_mutable",
"=",
"True",
"try",
":",
"dataset",
"=",
"handle_pust_request",
"(",
"request",
")",
"except",
"Http404",
":",
"raise",
"Http404",
"(",
")",
"except",
"GenericException",
"as",
"e",
":",
"return",
"JsonResponse",
"(",
"{",
"'error'",
":",
"e",
".",
"details",
"}",
",",
"status",
"=",
"400",
")",
"response",
"=",
"HttpResponse",
"(",
"status",
"=",
"201",
")",
"response",
"[",
"'Content-Location'",
"]",
"=",
"dataset",
".",
"api_location",
"return",
"response"
] | [
353,
4
] | [
364,
23
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
teardown_db | (exception) | Permet de fermet la connection à la base de données lorsque le serveur HTTP est arreté | Permet de fermet la connection à la base de données lorsque le serveur HTTP est arreté | def teardown_db(exception):
"""Permet de fermet la connection à la base de données lorsque le serveur HTTP est arreté"""
db = g.pop("db", None)
if db is not None:
db.connection.close() | [
"def",
"teardown_db",
"(",
"exception",
")",
":",
"db",
"=",
"g",
".",
"pop",
"(",
"\"db\"",
",",
"None",
")",
"if",
"db",
"is",
"not",
"None",
":",
"db",
".",
"connection",
".",
"close",
"(",
")"
] | [
29,
0
] | [
33,
29
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
|
Admin.add_ignoring | (self, ctx: MyContext, ID:int) | Ajoute un serveur ou un utilisateur dans la liste des utilisateurs/serveurs ignorés | Ajoute un serveur ou un utilisateur dans la liste des utilisateurs/serveurs ignorés | async def add_ignoring(self, ctx: MyContext, ID:int):
"""Ajoute un serveur ou un utilisateur dans la liste des utilisateurs/serveurs ignorés"""
serv = ctx.bot.get_guild(ID)
try:
usr = await ctx.bot.fetch_user(ID)
except:
usr = None
scog = ctx.bot.get_cog('Servers')
try:
config = await ctx.bot.get_cog('Utilities').get_bot_infos()
if serv is not None and usr is not None:
await ctx.send("Serveur trouvé : {}\nUtilisateur trouvé : {}".format(serv.name,usr))
elif serv is not None:
servs = config['banned_guilds'].split(';')
if str(serv.id) in servs:
servs.remove(str(serv.id))
await scog.edit_bot_infos(self.bot.user.id,[('banned_guilds',';'.join(servs))])
await ctx.send("Le serveur {} n'est plus blacklisté".format(serv.name))
else:
servs.append(str(serv.id))
await scog.edit_bot_infos(self.bot.user.id,[('banned_guilds',';'.join(servs))])
await ctx.send("Le serveur {} a bien été blacklist".format(serv.name))
elif usr is not None:
usrs = config['banned_users'].split(';')
if str(usr.id) in usrs:
usrs.remove(str(usr.id))
await scog.edit_bot_infos(self.bot.user.id,[('banned_users',';'.join(usrs))])
await ctx.send("L'utilisateur {} n'est plus blacklisté".format(usr))
else:
usrs.append(str(usr.id))
await scog.edit_bot_infos(self.bot.user.id,[('banned_users',';'.join(usrs))])
await ctx.send("L'utilisateur {} a bien été blacklist".format(usr))
else:
await ctx.send("Impossible de trouver cet utilisateur/ce serveur")
ctx.bot.get_cog('Utilities').config = None
except Exception as e:
await ctx.bot.get_cog('Errors').on_command_error(ctx,e) | [
"async",
"def",
"add_ignoring",
"(",
"self",
",",
"ctx",
":",
"MyContext",
",",
"ID",
":",
"int",
")",
":",
"serv",
"=",
"ctx",
".",
"bot",
".",
"get_guild",
"(",
"ID",
")",
"try",
":",
"usr",
"=",
"await",
"ctx",
".",
"bot",
".",
"fetch_user",
"(",
"ID",
")",
"except",
":",
"usr",
"=",
"None",
"scog",
"=",
"ctx",
".",
"bot",
".",
"get_cog",
"(",
"'Servers'",
")",
"try",
":",
"config",
"=",
"await",
"ctx",
".",
"bot",
".",
"get_cog",
"(",
"'Utilities'",
")",
".",
"get_bot_infos",
"(",
")",
"if",
"serv",
"is",
"not",
"None",
"and",
"usr",
"is",
"not",
"None",
":",
"await",
"ctx",
".",
"send",
"(",
"\"Serveur trouvé : {}\\nUtilisateur trouvé : {}\".f",
"o",
"rmat(s",
"e",
"rv.n",
"a",
"me,u",
"s",
"r))",
"",
"",
"elif",
"serv",
"is",
"not",
"None",
":",
"servs",
"=",
"config",
"[",
"'banned_guilds'",
"]",
".",
"split",
"(",
"';'",
")",
"if",
"str",
"(",
"serv",
".",
"id",
")",
"in",
"servs",
":",
"servs",
".",
"remove",
"(",
"str",
"(",
"serv",
".",
"id",
")",
")",
"await",
"scog",
".",
"edit_bot_infos",
"(",
"self",
".",
"bot",
".",
"user",
".",
"id",
",",
"[",
"(",
"'banned_guilds'",
",",
"';'",
".",
"join",
"(",
"servs",
")",
")",
"]",
")",
"await",
"ctx",
".",
"send",
"(",
"\"Le serveur {} n'est plus blacklisté\".",
"f",
"ormat(",
"s",
"erv.",
"n",
"ame)",
")",
"",
"else",
":",
"servs",
".",
"append",
"(",
"str",
"(",
"serv",
".",
"id",
")",
")",
"await",
"scog",
".",
"edit_bot_infos",
"(",
"self",
".",
"bot",
".",
"user",
".",
"id",
",",
"[",
"(",
"'banned_guilds'",
",",
"';'",
".",
"join",
"(",
"servs",
")",
")",
"]",
")",
"await",
"ctx",
".",
"send",
"(",
"\"Le serveur {} a bien été blacklist\".f",
"o",
"rmat(s",
"e",
"rv.n",
"a",
"me))",
"",
"",
"elif",
"usr",
"is",
"not",
"None",
":",
"usrs",
"=",
"config",
"[",
"'banned_users'",
"]",
".",
"split",
"(",
"';'",
")",
"if",
"str",
"(",
"usr",
".",
"id",
")",
"in",
"usrs",
":",
"usrs",
".",
"remove",
"(",
"str",
"(",
"usr",
".",
"id",
")",
")",
"await",
"scog",
".",
"edit_bot_infos",
"(",
"self",
".",
"bot",
".",
"user",
".",
"id",
",",
"[",
"(",
"'banned_users'",
",",
"';'",
".",
"join",
"(",
"usrs",
")",
")",
"]",
")",
"await",
"ctx",
".",
"send",
"(",
"\"L'utilisateur {} n'est plus blacklisté\".",
"f",
"ormat(",
"u",
"sr)",
")",
"",
"else",
":",
"usrs",
".",
"append",
"(",
"str",
"(",
"usr",
".",
"id",
")",
")",
"await",
"scog",
".",
"edit_bot_infos",
"(",
"self",
".",
"bot",
".",
"user",
".",
"id",
",",
"[",
"(",
"'banned_users'",
",",
"';'",
".",
"join",
"(",
"usrs",
")",
")",
"]",
")",
"await",
"ctx",
".",
"send",
"(",
"\"L'utilisateur {} a bien été blacklist\".f",
"o",
"rmat(u",
"s",
"r))",
"",
"",
"else",
":",
"await",
"ctx",
".",
"send",
"(",
"\"Impossible de trouver cet utilisateur/ce serveur\"",
")",
"ctx",
".",
"bot",
".",
"get_cog",
"(",
"'Utilities'",
")",
".",
"config",
"=",
"None",
"except",
"Exception",
"as",
"e",
":",
"await",
"ctx",
".",
"bot",
".",
"get_cog",
"(",
"'Errors'",
")",
".",
"on_command_error",
"(",
"ctx",
",",
"e",
")"
] | [
494,
4
] | [
530,
67
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
|
chemin_critique | (m) | return chemin | Renvoie le chemin critique en utilisant PERT.
Utilise Bellman-Ford sur l'opposé de la matrice d'adjacence.
La matrice d'adjacence doit représenter un DAG.
Par convention, le début est supposé être le 1er sommer, et
la fin est supoosée être le dernier sommet.
| Renvoie le chemin critique en utilisant PERT.
Utilise Bellman-Ford sur l'opposé de la matrice d'adjacence.
La matrice d'adjacence doit représenter un DAG.
Par convention, le début est supposé être le 1er sommer, et
la fin est supoosée être le dernier sommet.
| def chemin_critique(m):
"""Renvoie le chemin critique en utilisant PERT.
Utilise Bellman-Ford sur l'opposé de la matrice d'adjacence.
La matrice d'adjacence doit représenter un DAG.
Par convention, le début est supposé être le 1er sommer, et
la fin est supoosée être le dernier sommet.
"""
# Construit une matrice d'adjacence avec les poids opposés
m_p = oppose_poids(m)
# Calcule l'arbre des plus courts chemins
dist_a, arc_vers = bellman_ford_impl(m_p, 0)
# Le chemin vers la fin est le chemin critique
fin = len(m) - 1
chemin = chemin_vers(fin, dist_a, arc_vers)
return chemin | [
"def",
"chemin_critique",
"(",
"m",
")",
":",
"# Construit une matrice d'adjacence avec les poids opposés",
"m_p",
"=",
"oppose_poids",
"(",
"m",
")",
"# Calcule l'arbre des plus courts chemins",
"dist_a",
",",
"arc_vers",
"=",
"bellman_ford_impl",
"(",
"m_p",
",",
"0",
")",
"# Le chemin vers la fin est le chemin critique",
"fin",
"=",
"len",
"(",
"m",
")",
"-",
"1",
"chemin",
"=",
"chemin_vers",
"(",
"fin",
",",
"dist_a",
",",
"arc_vers",
")",
"return",
"chemin"
] | [
255,
0
] | [
273,
17
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
play_note | () | Rejoue les enveloppes d'amplitude et de décalage de fréquences | Rejoue les enveloppes d'amplitude et de décalage de fréquences | def play_note():
"Rejoue les enveloppes d'amplitude et de décalage de fréquences"
amp.play()
sft.play() | [
"def",
"play_note",
"(",
")",
":",
"amp",
".",
"play",
"(",
")",
"sft",
".",
"play",
"(",
")"
] | [
51,
0
] | [
54,
14
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
|
insere_noeud_dans_arbre_binaire | (arbre, valeur) | return noeud | Insère un nouveau noeud dans un arbre binaire. | Insère un nouveau noeud dans un arbre binaire. | def insere_noeud_dans_arbre_binaire(arbre, valeur):
"""Insère un nouveau noeud dans un arbre binaire."""
if arbre.noeud == None:
arbre.noeud = Noeud(valeur=valeur)
return arbre.noeud
noeud = arbre.noeud
while noeud.valeur != valeur:
if valeur < noeud.valeur:
if noeud.gauche == None:
noeud.gauche = Noeud(valeur=valeur)
noeud = noeud.gauche
else:
if noeud.droite == None:
noeud.droite = Noeud(valeur=valeur)
noeud = noeud.droite
return noeud | [
"def",
"insere_noeud_dans_arbre_binaire",
"(",
"arbre",
",",
"valeur",
")",
":",
"if",
"arbre",
".",
"noeud",
"==",
"None",
":",
"arbre",
".",
"noeud",
"=",
"Noeud",
"(",
"valeur",
"=",
"valeur",
")",
"return",
"arbre",
".",
"noeud",
"noeud",
"=",
"arbre",
".",
"noeud",
"while",
"noeud",
".",
"valeur",
"!=",
"valeur",
":",
"if",
"valeur",
"<",
"noeud",
".",
"valeur",
":",
"if",
"noeud",
".",
"gauche",
"==",
"None",
":",
"noeud",
".",
"gauche",
"=",
"Noeud",
"(",
"valeur",
"=",
"valeur",
")",
"noeud",
"=",
"noeud",
".",
"gauche",
"else",
":",
"if",
"noeud",
".",
"droite",
"==",
"None",
":",
"noeud",
".",
"droite",
"=",
"Noeud",
"(",
"valeur",
"=",
"valeur",
")",
"noeud",
"=",
"noeud",
".",
"droite",
"return",
"noeud"
] | [
30,
0
] | [
47,
16
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
system_auxB | (x,xj,xjj,y,yj,yjj) | return (yjj - yj)/(xjj - xj) - (yj - y)/ (xj - x) | Code les équations (3.3.7) des "numericals recipes" (juste membre de droite) | Code les équations (3.3.7) des "numericals recipes" (juste membre de droite) | def system_auxB(x,xj,xjj,y,yj,yjj):
""" Code les équations (3.3.7) des "numericals recipes" (juste membre de droite) """
return (yjj - yj)/(xjj - xj) - (yj - y)/ (xj - x) | [
"def",
"system_auxB",
"(",
"x",
",",
"xj",
",",
"xjj",
",",
"y",
",",
"yj",
",",
"yjj",
")",
":",
"return",
"(",
"yjj",
"-",
"yj",
")",
"/",
"(",
"xjj",
"-",
"xj",
")",
"-",
"(",
"yj",
"-",
"y",
")",
"/",
"(",
"xj",
"-",
"x",
")"
] | [
87,
0
] | [
89,
51
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
inv_mat | (n) | return np.linalg.inv(matrice) | Inverse une matrice carrée aléatoire de taille n | Inverse une matrice carrée aléatoire de taille n | def inv_mat(n):
'''Inverse une matrice carrée aléatoire de taille n'''
np.random.seed(0) # O(1)
matrice = np.random.rand(n, n) # O(n^2)
return np.linalg.inv(matrice) | [
"def",
"inv_mat",
"(",
"n",
")",
":",
"np",
".",
"random",
".",
"seed",
"(",
"0",
")",
"# O(1)",
"matrice",
"=",
"np",
".",
"random",
".",
"rand",
"(",
"n",
",",
"n",
")",
"# O(n^2)",
"return",
"np",
".",
"linalg",
".",
"inv",
"(",
"matrice",
")"
] | [
7,
0
] | [
11,
33
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
ACP_film | () | Affichage des film en fonction des Axes Factoriel
import matplotlib.pyplot as plt
#positionnement des individus dans le premier plan
fig, axes = plt.subplots(figsize=(150,150))
axes.set_xlim(-6,6) #même limites en abscisse
axes.set_ylim(-6,6) #et en ordonnée
#placement des étiquettes des observations
for i in range(n):
#print("note:",movie_ratings["imdb_ratings"][i])
red = ((-255/10) * (movie_ratings["imdb_ratings"][i])+255)/255
#print("red :", red)
green = ((255/10) * (movie_ratings["imdb_ratings"][i]))/255
#print("green", green)
blue = 0
plt.annotate(test.index[i],(coord[i,0],coord[i,1]),color=(red,green,blue))
#ajouter les axes
plt.plot([-6,6],[0,0],color='silver',linestyle='-',linewidth=1)
plt.plot([0,0],[-6,6],color='silver',linestyle='-',linewidth=1)
#affichage
plt.show()
| Affichage des film en fonction des Axes Factoriel
import matplotlib.pyplot as plt
#positionnement des individus dans le premier plan
fig, axes = plt.subplots(figsize=(150,150))
axes.set_xlim(-6,6) #même limites en abscisse
axes.set_ylim(-6,6) #et en ordonnée
#placement des étiquettes des observations
for i in range(n):
#print("note:",movie_ratings["imdb_ratings"][i])
red = ((-255/10) * (movie_ratings["imdb_ratings"][i])+255)/255
#print("red :", red)
green = ((255/10) * (movie_ratings["imdb_ratings"][i]))/255
#print("green", green)
blue = 0
plt.annotate(test.index[i],(coord[i,0],coord[i,1]),color=(red,green,blue))
#ajouter les axes
plt.plot([-6,6],[0,0],color='silver',linestyle='-',linewidth=1)
plt.plot([0,0],[-6,6],color='silver',linestyle='-',linewidth=1)
#affichage
plt.show()
| def ACP_film():
import numpy as np
movie_ratings = pd.read_csv(r'Data_csv\movie_ratings_1980_2020_final.csv')
movie_ratings = movie_ratings.drop(["Unnamed: 0"],axis=1)
movie_ratings = movie_ratings.set_index('movie')
movie_ratings = movie_ratings.drop(["mv_page"],axis=1)
movie_ratings = movie_ratings.drop(["rank"],axis=1)
movie_ratings['years'] = movie_ratings['year'].astype(str).str[:4]
movie_ratings = movie_ratings.drop(["year"],axis=1)
movie_ratings['runtime'] = movie_ratings['runtime'].fillna(movie_ratings['runtime'].mean())
movie_ratings = trait.replace_metascore(movie_ratings)
movie_ratings = trait.add_0_win_nom(movie_ratings)
movie_ratings['budget'] = movie_ratings['budget'].fillna(movie_ratings['budget'].mean())
movie_ratings['gross'] = movie_ratings['gross'].fillna(movie_ratings['gross'].mean())
movie_ratings['category'] = movie_ratings['category'].replace({"R":1}).replace({"PG-13":3}).replace({"PG":2})
movie_ratings = act.imputation_previous_value(movie_ratings)
movie_ratings = movie_ratings.dropna()
# y_years = movie_ratings.iloc[:,16]
# encoder = LabelEncoder()
# normal_y = encoder.fit_transform(y_years)
# movie_ratings['years'] = normal_y
movie_ratings = act.labelisation(movie_ratings,4,5,6,7,8,9)
#movie_ratings = trait.clean_dataframe(movie_ratings)
test = movie_ratings
#Partie Analyse
#scikit-learn
import sklearn
#classe pour standardisation
from sklearn.preprocessing import StandardScaler
#instanciation
sc = StandardScaler()
#transformation – centrage-réduction
Z = sc.fit_transform(test)
#écart-type
print (np.nanstd(Z))
#classe pour l'ACP
from sklearn.decomposition import PCA
#instanciation
acp = PCA()
acp.fit(Z)
#affichage des paramètres
print("Pourcentage de variance expliquée : ")
print(acp.explained_variance_ratio_)
#print("Composantes principales : ")
#print(acp.components_)
#calculs
coord = acp.fit_transform(Z)
#nombre de composantes calculées
#print(acp.n_components_)
# 0 imdb_ratings 10629 non-null float64
# 1 metascore 10629 non-null float64
# 2 votes 10629 non-null float64
# 3 category 10629 non-null float64
# 4 genres1 10629 non-null object
# 5 genres2 10629 non-null object
# 6 genres3 10629 non-null object
# 7 stars1 10629 non-null object
# 8 stars2 10629 non-null object
# 9 stars3 10629 non-null object
# 10 nb_oscar 10629 non-null float64
# 11 win 10629 non-null float64
# 12 nom 10629 non-null float64
# 13 runtime 10629 non-null float64
# 14 budget 10629 non-null float64
# 15 gross 10629 non-null float64
# 16 years 10629 non-null object
n = test.shape[0]
p = test.shape[1]
#variance expliquée pour avoir des infos sur les valeurs propres (première est toujours supèrieur à1)
eigval = (n-1)/n*acp.explained_variance_
print(eigval)
#proportion de variance expliquée
print(acp.explained_variance_ratio_)
#scree plot : Critère de coude
import matplotlib.pyplot as plt
plt.plot(np.arange(1,p+1),eigval)
plt.title("Scree plot")
plt.ylabel("Eigen values")
plt.xlabel("Factor number")
plt.show()
#cumul de variance expliquée
plt.plot(np.arange(1,p+1),np.cumsum(acp.explained_variance_ratio_))
plt.title("Explained variance vs. # of factors")
plt.ylabel("Cumsum explained variance ratio")
plt.xlabel("Factor number")
plt.show()
''' Affichage des film en fonction des Axes Factoriel
import matplotlib.pyplot as plt
#positionnement des individus dans le premier plan
fig, axes = plt.subplots(figsize=(150,150))
axes.set_xlim(-6,6) #même limites en abscisse
axes.set_ylim(-6,6) #et en ordonnée
#placement des étiquettes des observations
for i in range(n):
#print("note:",movie_ratings["imdb_ratings"][i])
red = ((-255/10) * (movie_ratings["imdb_ratings"][i])+255)/255
#print("red :", red)
green = ((255/10) * (movie_ratings["imdb_ratings"][i]))/255
#print("green", green)
blue = 0
plt.annotate(test.index[i],(coord[i,0],coord[i,1]),color=(red,green,blue))
#ajouter les axes
plt.plot([-6,6],[0,0],color='silver',linestyle='-',linewidth=1)
plt.plot([0,0],[-6,6],color='silver',linestyle='-',linewidth=1)
#affichage
plt.show()
'''
import numpy as np
#contribution des individus dans l'inertie totale
di = np.sum(Z**2,axis=1)
print(pd.DataFrame({'ID':test.index,'d_i':di}))
#qualité de représentation des individus - COS2
cos2 = coord**2
for j in range(p):
cos2[:,j] = cos2[:,j]/di
print(pd.DataFrame({'id':test.index,'COS2_1':cos2[:,0],'COS2_2':cos2[:,1]}))
#contributions aux axes
ctr = coord**2
for j in range(p):
ctr[:,j] = ctr[:,j]/(n*eigval[j])
print(pd.DataFrame({'id':test.index,'CTR_1':ctr[:,0],'CTR_2':ctr[:,1]}))
#racine carrée des valeurs propres
sqrt_eigval = np.sqrt(eigval)
#corrélation des variables avec les axes
corvar = np.zeros((p,p))
for k in range(p):
corvar[:,k] = acp.components_[k,:] * sqrt_eigval[k]
#afficher la matrice des corrélations variables x facteurs
print(corvar)
#on affiche pour les deux premiers axes
print(pd.DataFrame({'id':test.columns,'COR_1':corvar[:,0],'COR_2':corvar[:,1]}))
#cercle des corrélations
fig, axes = plt.subplots(figsize=(8,8))
axes.set_xlim(-1,1)
axes.set_ylim(-1,1)
#affichage des étiquettes (noms des variables)
for j in range(p):
plt.annotate(test.columns[j],(corvar[j,0],corvar[j,1]))
#ajouter les axes
plt.plot([-1,1],[0,0],color='silver',linestyle='-',linewidth=1)
plt.plot([0,0],[-1,1],color='silver',linestyle='-',linewidth=1)
#ajouter un cercle
cercle = plt.Circle((0,0),1,color='blue',fill=False)
axes.add_artist(cercle)
#affichage
plt.show()
#cosinus carré des variables
cos2var = corvar**2
print(pd.DataFrame({'id':test.columns,'COS2_1':cos2var[:,0],'COS2_2':cos2var[:,1]}))
#contributions
ctrvar = cos2var
for k in range(p):
ctrvar[:,k] = ctrvar[:,k]/eigval[k]
#on n'affiche que pour les deux premiers axes
print(pd.DataFrame({'id':test.columns,'CTR_1':ctrvar[:,0],'CTR_2':ctrvar[:,1]})) | [
"def",
"ACP_film",
"(",
")",
":",
"import",
"numpy",
"as",
"np",
"movie_ratings",
"=",
"pd",
".",
"read_csv",
"(",
"r'Data_csv\\movie_ratings_1980_2020_final.csv'",
")",
"movie_ratings",
"=",
"movie_ratings",
".",
"drop",
"(",
"[",
"\"Unnamed: 0\"",
"]",
",",
"axis",
"=",
"1",
")",
"movie_ratings",
"=",
"movie_ratings",
".",
"set_index",
"(",
"'movie'",
")",
"movie_ratings",
"=",
"movie_ratings",
".",
"drop",
"(",
"[",
"\"mv_page\"",
"]",
",",
"axis",
"=",
"1",
")",
"movie_ratings",
"=",
"movie_ratings",
".",
"drop",
"(",
"[",
"\"rank\"",
"]",
",",
"axis",
"=",
"1",
")",
"movie_ratings",
"[",
"'years'",
"]",
"=",
"movie_ratings",
"[",
"'year'",
"]",
".",
"astype",
"(",
"str",
")",
".",
"str",
"[",
":",
"4",
"]",
"movie_ratings",
"=",
"movie_ratings",
".",
"drop",
"(",
"[",
"\"year\"",
"]",
",",
"axis",
"=",
"1",
")",
"movie_ratings",
"[",
"'runtime'",
"]",
"=",
"movie_ratings",
"[",
"'runtime'",
"]",
".",
"fillna",
"(",
"movie_ratings",
"[",
"'runtime'",
"]",
".",
"mean",
"(",
")",
")",
"movie_ratings",
"=",
"trait",
".",
"replace_metascore",
"(",
"movie_ratings",
")",
"movie_ratings",
"=",
"trait",
".",
"add_0_win_nom",
"(",
"movie_ratings",
")",
"movie_ratings",
"[",
"'budget'",
"]",
"=",
"movie_ratings",
"[",
"'budget'",
"]",
".",
"fillna",
"(",
"movie_ratings",
"[",
"'budget'",
"]",
".",
"mean",
"(",
")",
")",
"movie_ratings",
"[",
"'gross'",
"]",
"=",
"movie_ratings",
"[",
"'gross'",
"]",
".",
"fillna",
"(",
"movie_ratings",
"[",
"'gross'",
"]",
".",
"mean",
"(",
")",
")",
"movie_ratings",
"[",
"'category'",
"]",
"=",
"movie_ratings",
"[",
"'category'",
"]",
".",
"replace",
"(",
"{",
"\"R\"",
":",
"1",
"}",
")",
".",
"replace",
"(",
"{",
"\"PG-13\"",
":",
"3",
"}",
")",
".",
"replace",
"(",
"{",
"\"PG\"",
":",
"2",
"}",
")",
"movie_ratings",
"=",
"act",
".",
"imputation_previous_value",
"(",
"movie_ratings",
")",
"movie_ratings",
"=",
"movie_ratings",
".",
"dropna",
"(",
")",
"# y_years = movie_ratings.iloc[:,16]\r",
"# encoder = LabelEncoder()\r",
"# normal_y = encoder.fit_transform(y_years)\r",
"# movie_ratings['years'] = normal_y\r",
"movie_ratings",
"=",
"act",
".",
"labelisation",
"(",
"movie_ratings",
",",
"4",
",",
"5",
",",
"6",
",",
"7",
",",
"8",
",",
"9",
")",
"#movie_ratings = trait.clean_dataframe(movie_ratings) \r",
"test",
"=",
"movie_ratings",
"#Partie Analyse \r",
"#scikit-learn\r",
"import",
"sklearn",
"#classe pour standardisation\r",
"from",
"sklearn",
".",
"preprocessing",
"import",
"StandardScaler",
"#instanciation\r",
"sc",
"=",
"StandardScaler",
"(",
")",
"#transformation – centrage-réduction\r",
"Z",
"=",
"sc",
".",
"fit_transform",
"(",
"test",
")",
"#écart-type\r",
"print",
"(",
"np",
".",
"nanstd",
"(",
"Z",
")",
")",
"#classe pour l'ACP\r",
"from",
"sklearn",
".",
"decomposition",
"import",
"PCA",
"#instanciation\r",
"acp",
"=",
"PCA",
"(",
")",
"acp",
".",
"fit",
"(",
"Z",
")",
"#affichage des paramètres\r",
"print",
"(",
"\"Pourcentage de variance expliquée : \")",
" ",
"print",
"(",
"acp",
".",
"explained_variance_ratio_",
")",
"#print(\"Composantes principales : \") \r",
"#print(acp.components_) \r",
"#calculs\r",
"coord",
"=",
"acp",
".",
"fit_transform",
"(",
"Z",
")",
"#nombre de composantes calculées\r",
"#print(acp.n_components_) \r",
"# 0 imdb_ratings 10629 non-null float64\r",
"# 1 metascore 10629 non-null float64\r",
"# 2 votes 10629 non-null float64\r",
"# 3 category 10629 non-null float64\r",
"# 4 genres1 10629 non-null object \r",
"# 5 genres2 10629 non-null object \r",
"# 6 genres3 10629 non-null object \r",
"# 7 stars1 10629 non-null object \r",
"# 8 stars2 10629 non-null object \r",
"# 9 stars3 10629 non-null object \r",
"# 10 nb_oscar 10629 non-null float64\r",
"# 11 win 10629 non-null float64\r",
"# 12 nom 10629 non-null float64\r",
"# 13 runtime 10629 non-null float64\r",
"# 14 budget 10629 non-null float64\r",
"# 15 gross 10629 non-null float64\r",
"# 16 years 10629 non-null object \r",
"n",
"=",
"test",
".",
"shape",
"[",
"0",
"]",
"p",
"=",
"test",
".",
"shape",
"[",
"1",
"]",
"#variance expliquée pour avoir des infos sur les valeurs propres (première est toujours supèrieur à1)\r",
"eigval",
"=",
"(",
"n",
"-",
"1",
")",
"/",
"n",
"*",
"acp",
".",
"explained_variance_",
"print",
"(",
"eigval",
")",
"#proportion de variance expliquée\r",
"print",
"(",
"acp",
".",
"explained_variance_ratio_",
")",
"#scree plot : Critère de coude\r",
"import",
"matplotlib",
".",
"pyplot",
"as",
"plt",
"plt",
".",
"plot",
"(",
"np",
".",
"arange",
"(",
"1",
",",
"p",
"+",
"1",
")",
",",
"eigval",
")",
"plt",
".",
"title",
"(",
"\"Scree plot\"",
")",
"plt",
".",
"ylabel",
"(",
"\"Eigen values\"",
")",
"plt",
".",
"xlabel",
"(",
"\"Factor number\"",
")",
"plt",
".",
"show",
"(",
")",
"#cumul de variance expliquée\r",
"plt",
".",
"plot",
"(",
"np",
".",
"arange",
"(",
"1",
",",
"p",
"+",
"1",
")",
",",
"np",
".",
"cumsum",
"(",
"acp",
".",
"explained_variance_ratio_",
")",
")",
"plt",
".",
"title",
"(",
"\"Explained variance vs. # of factors\"",
")",
"plt",
".",
"ylabel",
"(",
"\"Cumsum explained variance ratio\"",
")",
"plt",
".",
"xlabel",
"(",
"\"Factor number\"",
")",
"plt",
".",
"show",
"(",
")",
"import",
"numpy",
"as",
"np",
"#contribution des individus dans l'inertie totale\r",
"di",
"=",
"np",
".",
"sum",
"(",
"Z",
"**",
"2",
",",
"axis",
"=",
"1",
")",
"print",
"(",
"pd",
".",
"DataFrame",
"(",
"{",
"'ID'",
":",
"test",
".",
"index",
",",
"'d_i'",
":",
"di",
"}",
")",
")",
"#qualité de représentation des individus - COS2\r",
"cos2",
"=",
"coord",
"**",
"2",
"for",
"j",
"in",
"range",
"(",
"p",
")",
":",
"cos2",
"[",
":",
",",
"j",
"]",
"=",
"cos2",
"[",
":",
",",
"j",
"]",
"/",
"di",
"print",
"(",
"pd",
".",
"DataFrame",
"(",
"{",
"'id'",
":",
"test",
".",
"index",
",",
"'COS2_1'",
":",
"cos2",
"[",
":",
",",
"0",
"]",
",",
"'COS2_2'",
":",
"cos2",
"[",
":",
",",
"1",
"]",
"}",
")",
")",
"#contributions aux axes\r",
"ctr",
"=",
"coord",
"**",
"2",
"for",
"j",
"in",
"range",
"(",
"p",
")",
":",
"ctr",
"[",
":",
",",
"j",
"]",
"=",
"ctr",
"[",
":",
",",
"j",
"]",
"/",
"(",
"n",
"*",
"eigval",
"[",
"j",
"]",
")",
"print",
"(",
"pd",
".",
"DataFrame",
"(",
"{",
"'id'",
":",
"test",
".",
"index",
",",
"'CTR_1'",
":",
"ctr",
"[",
":",
",",
"0",
"]",
",",
"'CTR_2'",
":",
"ctr",
"[",
":",
",",
"1",
"]",
"}",
")",
")",
"#racine carrée des valeurs propres\r",
"sqrt_eigval",
"=",
"np",
".",
"sqrt",
"(",
"eigval",
")",
"#corrélation des variables avec les axes\r",
"corvar",
"=",
"np",
".",
"zeros",
"(",
"(",
"p",
",",
"p",
")",
")",
"for",
"k",
"in",
"range",
"(",
"p",
")",
":",
"corvar",
"[",
":",
",",
"k",
"]",
"=",
"acp",
".",
"components_",
"[",
"k",
",",
":",
"]",
"*",
"sqrt_eigval",
"[",
"k",
"]",
"#afficher la matrice des corrélations variables x facteurs\r",
"print",
"(",
"corvar",
")",
"#on affiche pour les deux premiers axes\r",
"print",
"(",
"pd",
".",
"DataFrame",
"(",
"{",
"'id'",
":",
"test",
".",
"columns",
",",
"'COR_1'",
":",
"corvar",
"[",
":",
",",
"0",
"]",
",",
"'COR_2'",
":",
"corvar",
"[",
":",
",",
"1",
"]",
"}",
")",
")",
"#cercle des corrélations\r",
"fig",
",",
"axes",
"=",
"plt",
".",
"subplots",
"(",
"figsize",
"=",
"(",
"8",
",",
"8",
")",
")",
"axes",
".",
"set_xlim",
"(",
"-",
"1",
",",
"1",
")",
"axes",
".",
"set_ylim",
"(",
"-",
"1",
",",
"1",
")",
"#affichage des étiquettes (noms des variables)\r",
"for",
"j",
"in",
"range",
"(",
"p",
")",
":",
"plt",
".",
"annotate",
"(",
"test",
".",
"columns",
"[",
"j",
"]",
",",
"(",
"corvar",
"[",
"j",
",",
"0",
"]",
",",
"corvar",
"[",
"j",
",",
"1",
"]",
")",
")",
"#ajouter les axes\r",
"plt",
".",
"plot",
"(",
"[",
"-",
"1",
",",
"1",
"]",
",",
"[",
"0",
",",
"0",
"]",
",",
"color",
"=",
"'silver'",
",",
"linestyle",
"=",
"'-'",
",",
"linewidth",
"=",
"1",
")",
"plt",
".",
"plot",
"(",
"[",
"0",
",",
"0",
"]",
",",
"[",
"-",
"1",
",",
"1",
"]",
",",
"color",
"=",
"'silver'",
",",
"linestyle",
"=",
"'-'",
",",
"linewidth",
"=",
"1",
")",
"#ajouter un cercle\r",
"cercle",
"=",
"plt",
".",
"Circle",
"(",
"(",
"0",
",",
"0",
")",
",",
"1",
",",
"color",
"=",
"'blue'",
",",
"fill",
"=",
"False",
")",
"axes",
".",
"add_artist",
"(",
"cercle",
")",
"#affichage\r",
"plt",
".",
"show",
"(",
")",
"#cosinus carré des variables\r",
"cos2var",
"=",
"corvar",
"**",
"2",
"print",
"(",
"pd",
".",
"DataFrame",
"(",
"{",
"'id'",
":",
"test",
".",
"columns",
",",
"'COS2_1'",
":",
"cos2var",
"[",
":",
",",
"0",
"]",
",",
"'COS2_2'",
":",
"cos2var",
"[",
":",
",",
"1",
"]",
"}",
")",
")",
"#contributions\r",
"ctrvar",
"=",
"cos2var",
"for",
"k",
"in",
"range",
"(",
"p",
")",
":",
"ctrvar",
"[",
":",
",",
"k",
"]",
"=",
"ctrvar",
"[",
":",
",",
"k",
"]",
"/",
"eigval",
"[",
"k",
"]",
"#on n'affiche que pour les deux premiers axes\r",
"print",
"(",
"pd",
".",
"DataFrame",
"(",
"{",
"'id'",
":",
"test",
".",
"columns",
",",
"'CTR_1'",
":",
"ctrvar",
"[",
":",
",",
"0",
"]",
",",
"'CTR_2'",
":",
"ctrvar",
"[",
":",
",",
"1",
"]",
"}",
")",
")"
] | [
20,
0
] | [
230,
84
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
|
centreGravite | (atomsPositions, helice) | return xGrav/totalMass, yGrav/totalMass, zGrav/totalMass | Calcule le centre de gravité de l'hélice à partir de getAtomsPositionsBetween
| Calcule le centre de gravité de l'hélice à partir de getAtomsPositionsBetween
| def centreGravite(atomsPositions, helice):
"""Calcule le centre de gravité de l'hélice à partir de getAtomsPositionsBetween
"""
# ATTENTION: les masses atomiques de O1- et N1+ ne sont peut être pas les bonnes
atomicMass = {'C': 12.0107, 'H': 1.00784, 'O': 15.999,
'O1-': 15.999, 'S': 16, 'N': 14.0067, 'N1+': 14.0067}
xGrav, yGrav, zGrav = 0, 0, 0
totalMass = 0
# to test if we are in the helice or not
isBetween = False
for coos, name in atomsPositions.items():
if (coos == helice[0]):
isBetween = True
if (coos == helice[1]):
return xGrav/totalMass, yGrav/totalMass, zGrav/totalMass
if isBetween:
xGrav += coos[0]*atomicMass[name]
yGrav += coos[1]*atomicMass[name]
zGrav += coos[2]*atomicMass[name]
totalMass += atomicMass[name]
return xGrav/totalMass, yGrav/totalMass, zGrav/totalMass | [
"def",
"centreGravite",
"(",
"atomsPositions",
",",
"helice",
")",
":",
"# ATTENTION: les masses atomiques de O1- et N1+ ne sont peut être pas les bonnes",
"atomicMass",
"=",
"{",
"'C'",
":",
"12.0107",
",",
"'H'",
":",
"1.00784",
",",
"'O'",
":",
"15.999",
",",
"'O1-'",
":",
"15.999",
",",
"'S'",
":",
"16",
",",
"'N'",
":",
"14.0067",
",",
"'N1+'",
":",
"14.0067",
"}",
"xGrav",
",",
"yGrav",
",",
"zGrav",
"=",
"0",
",",
"0",
",",
"0",
"totalMass",
"=",
"0",
"# to test if we are in the helice or not",
"isBetween",
"=",
"False",
"for",
"coos",
",",
"name",
"in",
"atomsPositions",
".",
"items",
"(",
")",
":",
"if",
"(",
"coos",
"==",
"helice",
"[",
"0",
"]",
")",
":",
"isBetween",
"=",
"True",
"if",
"(",
"coos",
"==",
"helice",
"[",
"1",
"]",
")",
":",
"return",
"xGrav",
"/",
"totalMass",
",",
"yGrav",
"/",
"totalMass",
",",
"zGrav",
"/",
"totalMass",
"if",
"isBetween",
":",
"xGrav",
"+=",
"coos",
"[",
"0",
"]",
"*",
"atomicMass",
"[",
"name",
"]",
"yGrav",
"+=",
"coos",
"[",
"1",
"]",
"*",
"atomicMass",
"[",
"name",
"]",
"zGrav",
"+=",
"coos",
"[",
"2",
"]",
"*",
"atomicMass",
"[",
"name",
"]",
"totalMass",
"+=",
"atomicMass",
"[",
"name",
"]",
"return",
"xGrav",
"/",
"totalMass",
",",
"yGrav",
"/",
"totalMass",
",",
"zGrav",
"/",
"totalMass"
] | [
19,
0
] | [
46,
60
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
int16 | (string) | return int(string, 16) | Conversion de type pour parser. | Conversion de type pour parser. | def int16(string):
"""Conversion de type pour parser."""
return int(string, 16) | [
"def",
"int16",
"(",
"string",
")",
":",
"return",
"int",
"(",
"string",
",",
"16",
")"
] | [
21,
0
] | [
23,
26
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
Accord.Concordance | (self) | Normalisation logarithmique, de maniere a rendre egales les concordances des unissons de n notes | Normalisation logarithmique, de maniere a rendre egales les concordances des unissons de n notes | def Concordance(self):
""" Normalisation logarithmique, de maniere a rendre egales les concordances des unissons de n notes"""
self.concordance = np.sum(self.listeConcordanceDesIntervallesDansAccord)
n = self.nombreDeNotes
self.concordance = self.concordance/(self.nombreDeNotes*(self.nombreDeNotes - 1)/2) | [
"def",
"Concordance",
"(",
"self",
")",
":",
"self",
".",
"concordance",
"=",
"np",
".",
"sum",
"(",
"self",
".",
"listeConcordanceDesIntervallesDansAccord",
")",
"n",
"=",
"self",
".",
"nombreDeNotes",
"self",
".",
"concordance",
"=",
"self",
".",
"concordance",
"/",
"(",
"self",
".",
"nombreDeNotes",
"*",
"(",
"self",
".",
"nombreDeNotes",
"-",
"1",
")",
"/",
"2",
")"
] | [
348,
2
] | [
354,
89
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
|
OscAug.sig | (self) | return self.objs | Retourne le signal audio de la classe, pour le post-traitement. | Retourne le signal audio de la classe, pour le post-traitement. | def sig(self):
"Retourne le signal audio de la classe, pour le post-traitement."
return self.objs | [
"def",
"sig",
"(",
"self",
")",
":",
"return",
"self",
".",
"objs"
] | [
78,
4
] | [
80,
24
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
Moderation.configure_muted_role | (self, guild: discord.Guild, role: discord.Role = None) | return role, count | Ajoute le rôle muted au serveur, avec les permissions nécessaires | Ajoute le rôle muted au serveur, avec les permissions nécessaires | async def configure_muted_role(self, guild: discord.Guild, role: discord.Role = None):
"""Ajoute le rôle muted au serveur, avec les permissions nécessaires"""
if not guild.me.guild_permissions.manage_roles:
return None, 0
if role is None:
role = await guild.create_role(name="muted")
count = 0 # nbr of errors
try:
for x in guild.by_category():
category, channelslist = x[0], x[1]
for channel in channelslist:
if channel is None:
continue
if len(channel.changed_roles) != 0 and not channel.permissions_synced:
try:
await channel.set_permissions(role, send_messages=False)
for r in channel.changed_roles:
if r.managed and len(r.members) == 1 and r.members[0].bot:
# if it's an integrated bot role
continue
obj = channel.overwrites_for(r)
if obj.send_messages:
obj.send_messages = None
await channel.set_permissions(r, overwrite=obj)
except discord.errors.Forbidden:
count += 1
if category is not None and category.permissions_for(guild.me).manage_roles:
await category.set_permissions(role, send_messages=False)
except Exception as e:
await self.bot.get_cog('Errors').on_error(e, None)
count = len(guild.channels)
await self.bot.get_cog('Servers').modify_server(guild.id, values=[('muted_role',role.id)])
return role, count | [
"async",
"def",
"configure_muted_role",
"(",
"self",
",",
"guild",
":",
"discord",
".",
"Guild",
",",
"role",
":",
"discord",
".",
"Role",
"=",
"None",
")",
":",
"if",
"not",
"guild",
".",
"me",
".",
"guild_permissions",
".",
"manage_roles",
":",
"return",
"None",
",",
"0",
"if",
"role",
"is",
"None",
":",
"role",
"=",
"await",
"guild",
".",
"create_role",
"(",
"name",
"=",
"\"muted\"",
")",
"count",
"=",
"0",
"# nbr of errors",
"try",
":",
"for",
"x",
"in",
"guild",
".",
"by_category",
"(",
")",
":",
"category",
",",
"channelslist",
"=",
"x",
"[",
"0",
"]",
",",
"x",
"[",
"1",
"]",
"for",
"channel",
"in",
"channelslist",
":",
"if",
"channel",
"is",
"None",
":",
"continue",
"if",
"len",
"(",
"channel",
".",
"changed_roles",
")",
"!=",
"0",
"and",
"not",
"channel",
".",
"permissions_synced",
":",
"try",
":",
"await",
"channel",
".",
"set_permissions",
"(",
"role",
",",
"send_messages",
"=",
"False",
")",
"for",
"r",
"in",
"channel",
".",
"changed_roles",
":",
"if",
"r",
".",
"managed",
"and",
"len",
"(",
"r",
".",
"members",
")",
"==",
"1",
"and",
"r",
".",
"members",
"[",
"0",
"]",
".",
"bot",
":",
"# if it's an integrated bot role",
"continue",
"obj",
"=",
"channel",
".",
"overwrites_for",
"(",
"r",
")",
"if",
"obj",
".",
"send_messages",
":",
"obj",
".",
"send_messages",
"=",
"None",
"await",
"channel",
".",
"set_permissions",
"(",
"r",
",",
"overwrite",
"=",
"obj",
")",
"except",
"discord",
".",
"errors",
".",
"Forbidden",
":",
"count",
"+=",
"1",
"if",
"category",
"is",
"not",
"None",
"and",
"category",
".",
"permissions_for",
"(",
"guild",
".",
"me",
")",
".",
"manage_roles",
":",
"await",
"category",
".",
"set_permissions",
"(",
"role",
",",
"send_messages",
"=",
"False",
")",
"except",
"Exception",
"as",
"e",
":",
"await",
"self",
".",
"bot",
".",
"get_cog",
"(",
"'Errors'",
")",
".",
"on_error",
"(",
"e",
",",
"None",
")",
"count",
"=",
"len",
"(",
"guild",
".",
"channels",
")",
"await",
"self",
".",
"bot",
".",
"get_cog",
"(",
"'Servers'",
")",
".",
"modify_server",
"(",
"guild",
".",
"id",
",",
"values",
"=",
"[",
"(",
"'muted_role'",
",",
"role",
".",
"id",
")",
"]",
")",
"return",
"role",
",",
"count"
] | [
1368,
4
] | [
1400,
26
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
corde.force_point | (self, i) | return x,y | calcule les forces qui s'exerce en un point,
retourne un couple x,y | calcule les forces qui s'exerce en un point,
retourne un couple x,y | def force_point (self, i) :
"""calcule les forces qui s'exerce en un point,
retourne un couple x,y"""
x,y = 0,0
# poids
y -= self.g * self.list [i].m
# voisin de gauche
dx, dy = self.list [i].difference (self.list [i-1])
d = math.sqrt (dx *dx + dy *dy)
if d > self.l :
dx = (d - self.l) / d * dx
dy = (d - self.l) / d * dy
x += self.k * dx
y += self.k * dy
# voisin de droite
dx, dy = self.list [i].difference (self.list [i+1])
d = math.sqrt (dx *dx + dy *dy)
if d > self.l :
dx = (d - self.l) / d * dx
dy = (d - self.l) / d * dy
x += self.k * dx
y += self.k * dy
# freinage
x += - self.f * self.vitesse [i].x
y += - self.f * self.vitesse [i].y
return x,y | [
"def",
"force_point",
"(",
"self",
",",
"i",
")",
":",
"x",
",",
"y",
"=",
"0",
",",
"0",
"# poids",
"y",
"-=",
"self",
".",
"g",
"*",
"self",
".",
"list",
"[",
"i",
"]",
".",
"m",
"# voisin de gauche",
"dx",
",",
"dy",
"=",
"self",
".",
"list",
"[",
"i",
"]",
".",
"difference",
"(",
"self",
".",
"list",
"[",
"i",
"-",
"1",
"]",
")",
"d",
"=",
"math",
".",
"sqrt",
"(",
"dx",
"*",
"dx",
"+",
"dy",
"*",
"dy",
")",
"if",
"d",
">",
"self",
".",
"l",
":",
"dx",
"=",
"(",
"d",
"-",
"self",
".",
"l",
")",
"/",
"d",
"*",
"dx",
"dy",
"=",
"(",
"d",
"-",
"self",
".",
"l",
")",
"/",
"d",
"*",
"dy",
"x",
"+=",
"self",
".",
"k",
"*",
"dx",
"y",
"+=",
"self",
".",
"k",
"*",
"dy",
"# voisin de droite",
"dx",
",",
"dy",
"=",
"self",
".",
"list",
"[",
"i",
"]",
".",
"difference",
"(",
"self",
".",
"list",
"[",
"i",
"+",
"1",
"]",
")",
"d",
"=",
"math",
".",
"sqrt",
"(",
"dx",
"*",
"dx",
"+",
"dy",
"*",
"dy",
")",
"if",
"d",
">",
"self",
".",
"l",
":",
"dx",
"=",
"(",
"d",
"-",
"self",
".",
"l",
")",
"/",
"d",
"*",
"dx",
"dy",
"=",
"(",
"d",
"-",
"self",
".",
"l",
")",
"/",
"d",
"*",
"dy",
"x",
"+=",
"self",
".",
"k",
"*",
"dx",
"y",
"+=",
"self",
".",
"k",
"*",
"dy",
"# freinage",
"x",
"+=",
"-",
"self",
".",
"f",
"*",
"self",
".",
"vitesse",
"[",
"i",
"]",
".",
"x",
"y",
"+=",
"-",
"self",
".",
"f",
"*",
"self",
".",
"vitesse",
"[",
"i",
"]",
".",
"y",
"return",
"x",
",",
"y"
] | [
143,
4
] | [
169,
18
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
StreamRecorder.startRecord | (self, ts, length) | lance un enregistrement de t seconde dans un thread séparé | lance un enregistrement de t seconde dans un thread séparé | def startRecord(self, ts, length):
'''lance un enregistrement de t seconde dans un thread séparé'''
if self._recording:
raise streamError.RecordingSreamError()
if self._inlet == None:
raise streamError.UnConnctedStreamError("enregistrement")
self._recording = True
self._recordlength = length
self.ts = ts
self.th = th.Thread(target = self._record)
self.th.start() | [
"def",
"startRecord",
"(",
"self",
",",
"ts",
",",
"length",
")",
":",
"if",
"self",
".",
"_recording",
":",
"raise",
"streamError",
".",
"RecordingSreamError",
"(",
")",
"if",
"self",
".",
"_inlet",
"==",
"None",
":",
"raise",
"streamError",
".",
"UnConnctedStreamError",
"(",
"\"enregistrement\"",
")",
"self",
".",
"_recording",
"=",
"True",
"self",
".",
"_recordlength",
"=",
"length",
"self",
".",
"ts",
"=",
"ts",
"self",
".",
"th",
"=",
"th",
".",
"Thread",
"(",
"target",
"=",
"self",
".",
"_record",
")",
"self",
".",
"th",
".",
"start",
"(",
")"
] | [
65,
4
] | [
75,
23
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
|
f_open_img | (default_lbl,default_noimg,lbl) | attributions : bouton 'Importer une image' du fichier 'master_window.py' (l.afpt)
description : permet d'ouvrir et de sélectionner depuis l'explorateur de fichiers une image puis de la charger dans la fenêtre | attributions : bouton 'Importer une image' du fichier 'master_window.py' (l.afpt)
description : permet d'ouvrir et de sélectionner depuis l'explorateur de fichiers une image puis de la charger dans la fenêtre | def f_open_img(default_lbl,default_noimg,lbl):
"""attributions : bouton 'Importer une image' du fichier 'master_window.py' (l.afpt)
description : permet d'ouvrir et de sélectionner depuis l'explorateur de fichiers une image puis de la charger dans la fenêtre"""
global default_im, im # permet à la variable default_im d'être aussi utilisée en dehors de cette fonction
# askopenfilename est une fonction de filedialog (module tkinter) qui permet de choisir un fichier depuis l'exporateur de fichier puis de récup son chemin d'accès
#
# ici on stocke le chemin d'accès dans la variable filename
#
# title sera le nom de la fenêtre de l'explorateur de fichier
# initialdir = os.getcwd() permet d'indiquer que l'explorateur de fichier doit s'ouvrir au chemin d'accès où se trouve l'utilisateur
# filetypes définit les extensions que l'utilisateur peut choisir
filename = filedialog.askopenfilename(title="Ouvrir un fichier",initialdir= os.getcwd(),filetype=((".png","*.png"), (".jpg","*.jpg"), (".jfif","*.jfif"), ("Tous les fichiers","*")))
try: # le fichier choisit par l'utilisateur pourrait être dans un format non accepté par Pillow d'où le try:
default_im = Image.open(filename) # default_im est l'image qui ne subira pas les modifications de sorte à avoir un aperçu de l'image de base
# Ici on va venir réajuster la taille de l'image pour qu'elle tienne dans le label default_lbl
if default_im.width > 420:
diff = default_im.width - 420
if default_im.height > diff:
default_im = default_im.resize((420 , default_im.height - diff))
else:
default_im = default_im.resize((420 , default_im.height))
if default_im.height > 300:
diff = default_im.height - 300
if default_im.width > diff:
default_im= default_im.resize((default_im.width - diff , 300))
else:
default_im= default_im.resize((default_im.width , 300))
if default_im.width <= 150:
diff = 150 - default_im.width
default_im = default_im.resize((150 , default_im.height + diff))
if default_im.height <= 30:
diff = 30 - default_im.height
default_im = default_im.resize((default_im.width + diff , 30))
default_noimg.pack_forget() # on enlève le label avec marqué "Pas d'image"
default_photoim = ImageTk.PhotoImage(default_im) # on charge l'image en élément ImageTk qu'on stocke dans default_photoim
default_lbl.configure(image=default_photoim,bg='grey') # on rajoute la photoimage au label default_lbl
default_lbl.image = default_photoim
#####################################################
im = Image.open(filename) # ici on charge la photo sélectionnée et on la stocke dans 'im'
# on vient redimensionner l'image pour qu'elle tienne dans le label 'lbl'
if im.width > 1170:
diff = im.width - 1170
if im.height > diff:
im = im.resize((1170 , im.height - diff))
else:
im = im.resize((1170 , int(im.height/2)))
if im.height > 820:
diff = im.height - 820
if im.width > diff:
im = im.resize((im.width - diff , 820))
else:
im = im.resize((int(im.width/2) , 820))
if im.width <= 300:
diff = 300 - im.width
im = im.resize((300 , im.height + diff))
if im.height <= 60:
diff = 60 - im.height
im = im.resize((im.width + diff , 60))
im.filename = filename
photoim = ImageTk.PhotoImage(im) # on charge l'image en élément photoImage du module ImageTk qu'on stocke dans 'photoim'
lbl.configure(image=photoim,bg='grey',height=im.height+10,width=im.width+10,text="") # on rajoute la photoimage au label 'slbl'
lbl.image = photoim
except PIL.UnidentifiedImageError: # en cas d'erreur du à une mauvaise extension, on l'indique à l'utilisateur via une alerte
messagebox.showwarning('Erreur','Le format choisi est incorrecte')
except AttributeError: # erreur qui semble être levée quand on annule l'importation d'une image
pass
except Exception as err: # en cas d'autres erreur, on l'envoie dans le fichier logs.txt
# ainsi l'utilisateur peut accèder à un suivi des erreurs qui auraient eu lieu
with open('logs.txt','r') as f: # on ouvre 'logs.txt' en lecture et on récupère le nombre de lignes
lines = 0
for line in f:
lines+=1
f.close()
if lines > 100: # si il y'a déjà 100 lignes d'écrites, on ouvre en écriture
# puis on referme, cela va écraser tout le contenu déjà présent
with open('logs.txt','w') as temp:
temp.close()
with open('logs.txt','a') as f: # enfin on ouvre en mode append
d = dt.datetime.now().strftime("%d/%m/%Y %H:%M") # on récupère la date sous ce format : 01/01/2000 12:00
# puis on indique la date et l'erreur et on ferme le fichier
f.write(f'[{d}] Error on open_img() : {err}\n------------------------------------------------------------------------------------------------------------------------------------------\n\n')
f.close() | [
"def",
"f_open_img",
"(",
"default_lbl",
",",
"default_noimg",
",",
"lbl",
")",
":",
"global",
"default_im",
",",
"im",
"# permet à la variable default_im d'être aussi utilisée en dehors de cette fonction ",
"# askopenfilename est une fonction de filedialog (module tkinter) qui permet de choisir un fichier depuis l'exporateur de fichier puis de récup son chemin d'accès ",
"# ",
"# ici on stocke le chemin d'accès dans la variable filename",
"# ",
"# title sera le nom de la fenêtre de l'explorateur de fichier",
"# initialdir = os.getcwd() permet d'indiquer que l'explorateur de fichier doit s'ouvrir au chemin d'accès où se trouve l'utilisateur",
"# filetypes définit les extensions que l'utilisateur peut choisir",
"filename",
"=",
"filedialog",
".",
"askopenfilename",
"(",
"title",
"=",
"\"Ouvrir un fichier\"",
",",
"initialdir",
"=",
"os",
".",
"getcwd",
"(",
")",
",",
"filetype",
"=",
"(",
"(",
"\".png\"",
",",
"\"*.png\"",
")",
",",
"(",
"\".jpg\"",
",",
"\"*.jpg\"",
")",
",",
"(",
"\".jfif\"",
",",
"\"*.jfif\"",
")",
",",
"(",
"\"Tous les fichiers\"",
",",
"\"*\"",
")",
")",
")",
"try",
":",
"# le fichier choisit par l'utilisateur pourrait être dans un format non accepté par Pillow d'où le try:",
"default_im",
"=",
"Image",
".",
"open",
"(",
"filename",
")",
"# default_im est l'image qui ne subira pas les modifications de sorte à avoir un aperçu de l'image de base",
"# Ici on va venir réajuster la taille de l'image pour qu'elle tienne dans le label default_lbl",
"if",
"default_im",
".",
"width",
">",
"420",
":",
"diff",
"=",
"default_im",
".",
"width",
"-",
"420",
"if",
"default_im",
".",
"height",
">",
"diff",
":",
"default_im",
"=",
"default_im",
".",
"resize",
"(",
"(",
"420",
",",
"default_im",
".",
"height",
"-",
"diff",
")",
")",
"else",
":",
"default_im",
"=",
"default_im",
".",
"resize",
"(",
"(",
"420",
",",
"default_im",
".",
"height",
")",
")",
"if",
"default_im",
".",
"height",
">",
"300",
":",
"diff",
"=",
"default_im",
".",
"height",
"-",
"300",
"if",
"default_im",
".",
"width",
">",
"diff",
":",
"default_im",
"=",
"default_im",
".",
"resize",
"(",
"(",
"default_im",
".",
"width",
"-",
"diff",
",",
"300",
")",
")",
"else",
":",
"default_im",
"=",
"default_im",
".",
"resize",
"(",
"(",
"default_im",
".",
"width",
",",
"300",
")",
")",
"if",
"default_im",
".",
"width",
"<=",
"150",
":",
"diff",
"=",
"150",
"-",
"default_im",
".",
"width",
"default_im",
"=",
"default_im",
".",
"resize",
"(",
"(",
"150",
",",
"default_im",
".",
"height",
"+",
"diff",
")",
")",
"if",
"default_im",
".",
"height",
"<=",
"30",
":",
"diff",
"=",
"30",
"-",
"default_im",
".",
"height",
"default_im",
"=",
"default_im",
".",
"resize",
"(",
"(",
"default_im",
".",
"width",
"+",
"diff",
",",
"30",
")",
")",
"default_noimg",
".",
"pack_forget",
"(",
")",
"# on enlève le label avec marqué \"Pas d'image\"",
"default_photoim",
"=",
"ImageTk",
".",
"PhotoImage",
"(",
"default_im",
")",
"# on charge l'image en élément ImageTk qu'on stocke dans default_photoim",
"default_lbl",
".",
"configure",
"(",
"image",
"=",
"default_photoim",
",",
"bg",
"=",
"'grey'",
")",
"# on rajoute la photoimage au label default_lbl ",
"default_lbl",
".",
"image",
"=",
"default_photoim",
"#####################################################",
"im",
"=",
"Image",
".",
"open",
"(",
"filename",
")",
"# ici on charge la photo sélectionnée et on la stocke dans 'im'",
"# on vient redimensionner l'image pour qu'elle tienne dans le label 'lbl'",
"if",
"im",
".",
"width",
">",
"1170",
":",
"diff",
"=",
"im",
".",
"width",
"-",
"1170",
"if",
"im",
".",
"height",
">",
"diff",
":",
"im",
"=",
"im",
".",
"resize",
"(",
"(",
"1170",
",",
"im",
".",
"height",
"-",
"diff",
")",
")",
"else",
":",
"im",
"=",
"im",
".",
"resize",
"(",
"(",
"1170",
",",
"int",
"(",
"im",
".",
"height",
"/",
"2",
")",
")",
")",
"if",
"im",
".",
"height",
">",
"820",
":",
"diff",
"=",
"im",
".",
"height",
"-",
"820",
"if",
"im",
".",
"width",
">",
"diff",
":",
"im",
"=",
"im",
".",
"resize",
"(",
"(",
"im",
".",
"width",
"-",
"diff",
",",
"820",
")",
")",
"else",
":",
"im",
"=",
"im",
".",
"resize",
"(",
"(",
"int",
"(",
"im",
".",
"width",
"/",
"2",
")",
",",
"820",
")",
")",
"if",
"im",
".",
"width",
"<=",
"300",
":",
"diff",
"=",
"300",
"-",
"im",
".",
"width",
"im",
"=",
"im",
".",
"resize",
"(",
"(",
"300",
",",
"im",
".",
"height",
"+",
"diff",
")",
")",
"if",
"im",
".",
"height",
"<=",
"60",
":",
"diff",
"=",
"60",
"-",
"im",
".",
"height",
"im",
"=",
"im",
".",
"resize",
"(",
"(",
"im",
".",
"width",
"+",
"diff",
",",
"60",
")",
")",
"im",
".",
"filename",
"=",
"filename",
"photoim",
"=",
"ImageTk",
".",
"PhotoImage",
"(",
"im",
")",
"# on charge l'image en élément photoImage du module ImageTk qu'on stocke dans 'photoim'",
"lbl",
".",
"configure",
"(",
"image",
"=",
"photoim",
",",
"bg",
"=",
"'grey'",
",",
"height",
"=",
"im",
".",
"height",
"+",
"10",
",",
"width",
"=",
"im",
".",
"width",
"+",
"10",
",",
"text",
"=",
"\"\"",
")",
"# on rajoute la photoimage au label 'slbl' ",
"lbl",
".",
"image",
"=",
"photoim",
"except",
"PIL",
".",
"UnidentifiedImageError",
":",
"# en cas d'erreur du à une mauvaise extension, on l'indique à l'utilisateur via une alerte",
"messagebox",
".",
"showwarning",
"(",
"'Erreur'",
",",
"'Le format choisi est incorrecte'",
")",
"except",
"AttributeError",
":",
"# erreur qui semble être levée quand on annule l'importation d'une image",
"pass",
"except",
"Exception",
"as",
"err",
":",
"# en cas d'autres erreur, on l'envoie dans le fichier logs.txt",
"# ainsi l'utilisateur peut accèder à un suivi des erreurs qui auraient eu lieu",
"with",
"open",
"(",
"'logs.txt'",
",",
"'r'",
")",
"as",
"f",
":",
"# on ouvre 'logs.txt' en lecture et on récupère le nombre de lignes",
"lines",
"=",
"0",
"for",
"line",
"in",
"f",
":",
"lines",
"+=",
"1",
"f",
".",
"close",
"(",
")",
"if",
"lines",
">",
"100",
":",
"# si il y'a déjà 100 lignes d'écrites, on ouvre en écriture ",
"# puis on referme, cela va écraser tout le contenu déjà présent",
"with",
"open",
"(",
"'logs.txt'",
",",
"'w'",
")",
"as",
"temp",
":",
"temp",
".",
"close",
"(",
")",
"with",
"open",
"(",
"'logs.txt'",
",",
"'a'",
")",
"as",
"f",
":",
"# enfin on ouvre en mode append ",
"d",
"=",
"dt",
".",
"datetime",
".",
"now",
"(",
")",
".",
"strftime",
"(",
"\"%d/%m/%Y %H:%M\"",
")",
"# on récupère la date sous ce format : 01/01/2000 12:00",
"# puis on indique la date et l'erreur et on ferme le fichier",
"f",
".",
"write",
"(",
"f'[{d}] Error on open_img() : {err}\\n------------------------------------------------------------------------------------------------------------------------------------------\\n\\n'",
")",
"f",
".",
"close",
"(",
")"
] | [
93,
0
] | [
196,
21
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
|
jouer_coup | (joueur, coup, grille) | return grille | Ajoute un jeton pour le joueur <joueur> dans la colonne <coup> dans
la grille et renvoie la ligne où celui-ci a été joué
| Ajoute un jeton pour le joueur <joueur> dans la colonne <coup> dans
la grille et renvoie la ligne où celui-ci a été joué | def jouer_coup(joueur, coup, grille):
"""Ajoute un jeton pour le joueur <joueur> dans la colonne <coup> dans
la grille et renvoie la ligne où celui-ci a été joué
"""
i = 6
while not grille[int(coup)][i] == 0 and i > 0:
i -= 1
grille[int(coup)][i] = "O" if joueur == 0 else "X"
return grille | [
"def",
"jouer_coup",
"(",
"joueur",
",",
"coup",
",",
"grille",
")",
":",
"i",
"=",
"6",
"while",
"not",
"grille",
"[",
"int",
"(",
"coup",
")",
"]",
"[",
"i",
"]",
"==",
"0",
"and",
"i",
">",
"0",
":",
"i",
"-=",
"1",
"grille",
"[",
"int",
"(",
"coup",
")",
"]",
"[",
"i",
"]",
"=",
"\"O\"",
"if",
"joueur",
"==",
"0",
"else",
"\"X\"",
"return",
"grille"
] | [
48,
0
] | [
59,
17
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
AlmaRecords.create_reminder | (self, bib_id, error_type, msg) | Attache une alerte à i=une notice bibliographique
Args:
bib_id (string): mmsid
type (string) : type de l'alerte
Returns:
staus: Sucess ou ERROR
response: Upadtaed Record or Error message
| Attache une alerte à i=une notice bibliographique | def create_reminder(self, bib_id, error_type, msg):
"""Attache une alerte à i=une notice bibliographique
Args:
bib_id (string): mmsid
type (string) : type de l'alerte
Returns:
staus: Sucess ou ERROR
response: Upadtaed Record or Error message
"""
today = date.today()
reminder = {
"link": "string",
"entity": {
"link": "string",
"entity_type": {
"value": "BIB_MMS"
},
"entity_id": bib_id
},
"type": {
"value": error_type
},
"status": {
"value": "NEW"
},
"text": msg,
"reminder_date": today.strftime("%Y-%m-%d")
}
data = json.dumps(reminder)
status, response = self.request('POST', 'reminders',
{'bib_id': bib_id},
data=data, content_type='json', accept='json')
if status == 'Error':
return status, response
else:
return status, self.extract_content(response) | [
"def",
"create_reminder",
"(",
"self",
",",
"bib_id",
",",
"error_type",
",",
"msg",
")",
":",
"today",
"=",
"date",
".",
"today",
"(",
")",
"reminder",
"=",
"{",
"\"link\"",
":",
"\"string\"",
",",
"\"entity\"",
":",
"{",
"\"link\"",
":",
"\"string\"",
",",
"\"entity_type\"",
":",
"{",
"\"value\"",
":",
"\"BIB_MMS\"",
"}",
",",
"\"entity_id\"",
":",
"bib_id",
"}",
",",
"\"type\"",
":",
"{",
"\"value\"",
":",
"error_type",
"}",
",",
"\"status\"",
":",
"{",
"\"value\"",
":",
"\"NEW\"",
"}",
",",
"\"text\"",
":",
"msg",
",",
"\"reminder_date\"",
":",
"today",
".",
"strftime",
"(",
"\"%Y-%m-%d\"",
")",
"}",
"data",
"=",
"json",
".",
"dumps",
"(",
"reminder",
")",
"status",
",",
"response",
"=",
"self",
".",
"request",
"(",
"'POST'",
",",
"'reminders'",
",",
"{",
"'bib_id'",
":",
"bib_id",
"}",
",",
"data",
"=",
"data",
",",
"content_type",
"=",
"'json'",
",",
"accept",
"=",
"'json'",
")",
"if",
"status",
"==",
"'Error'",
":",
"return",
"status",
",",
"response",
"else",
":",
"return",
"status",
",",
"self",
".",
"extract_content",
"(",
"response",
")"
] | [
161,
4
] | [
199,
61
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
|
Game._position_to_id | (self, x, y) | return x + y * self.n | Donne l'identifiant de la position entre 0 et 15 | Donne l'identifiant de la position entre 0 et 15 | def _position_to_id(self, x, y):
"""Donne l'identifiant de la position entre 0 et 15"""
return x + y * self.n | [
"def",
"_position_to_id",
"(",
"self",
",",
"x",
",",
"y",
")",
":",
"return",
"x",
"+",
"y",
"*",
"self",
".",
"n"
] | [
31,
4
] | [
33,
29
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
Admin.adm_backup | (self, ctx: MyContext) | Exécute une sauvegarde complète du code | Exécute une sauvegarde complète du code | async def adm_backup(self, ctx: MyContext):
"""Exécute une sauvegarde complète du code"""
await self.backup_auto(ctx) | [
"async",
"def",
"adm_backup",
"(",
"self",
",",
"ctx",
":",
"MyContext",
")",
":",
"await",
"self",
".",
"backup_auto",
"(",
"ctx",
")"
] | [
343,
4
] | [
345,
35
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
|
Application.new_game | (self) | nouveau jeu | nouveau jeu | def new_game(self):
""" nouveau jeu """
# créer l'univers
self.univers = cli_01.create_universe()
# séparer la liste de planetes
self.planetes = [x for x in self.univers if isinstance(x, cli_01.Planet)]
# séparer le capitaine (tant qu'à faire)
toto = [x for x in self.univers if isinstance(x, cli_01.Captain)]
self.captain = toto[0]
# print(type(self.captain))
self.draw_map()
self.update_gui() | [
"def",
"new_game",
"(",
"self",
")",
":",
"# créer l'univers",
"self",
".",
"univers",
"=",
"cli_01",
".",
"create_universe",
"(",
")",
"# séparer la liste de planetes",
"self",
".",
"planetes",
"=",
"[",
"x",
"for",
"x",
"in",
"self",
".",
"univers",
"if",
"isinstance",
"(",
"x",
",",
"cli_01",
".",
"Planet",
")",
"]",
"# séparer le capitaine (tant qu'à faire)",
"toto",
"=",
"[",
"x",
"for",
"x",
"in",
"self",
".",
"univers",
"if",
"isinstance",
"(",
"x",
",",
"cli_01",
".",
"Captain",
")",
"]",
"self",
".",
"captain",
"=",
"toto",
"[",
"0",
"]",
"# print(type(self.captain))",
"self",
".",
"draw_map",
"(",
")",
"self",
".",
"update_gui",
"(",
")"
] | [
287,
4
] | [
298,
25
] | null | python | fr | ['fr', 'fr', 'fr'] | False | true | null |
|
trace_ellipse | (xc, yc, a, b) | return [(x + xc, y + yc) for (x, y) in ellipse] | dessine une ellipse de centre xc,yc, de demi axe horizontal a,
de demi-axe vertical b, l'ellipse a pour �quation x�/a� + y�/b� = 1
si l'origine est plac�e en xc,yc,
l'�quation de la tangente au point x0, y0 est : x x0 / a� + y y0 / b� = 0,
ou x x0 b� + y y0 a� = 0 | dessine une ellipse de centre xc,yc, de demi axe horizontal a,
de demi-axe vertical b, l'ellipse a pour �quation x�/a� + y�/b� = 1
si l'origine est plac�e en xc,yc,
l'�quation de la tangente au point x0, y0 est : x x0 / a� + y y0 / b� = 0,
ou x x0 b� + y y0 a� = 0 | def trace_ellipse(xc, yc, a, b):
"""dessine une ellipse de centre xc,yc, de demi axe horizontal a,
de demi-axe vertical b, l'ellipse a pour �quation x�/a� + y�/b� = 1
si l'origine est plac�e en xc,yc,
l'�quation de la tangente au point x0, y0 est : x x0 / a� + y y0 / b� = 0,
ou x x0 b� + y y0 a� = 0"""
# on �vite les cas litigieux
if a == 0:
return [(xc, yc + y) for y in xrange(-b, b)]
if b == 0:
return [(xc + x, yc) for x in xrange(-a, a)]
bb = b * b
aa = a * a
# on trace l'ellipse de centre 0,0
ellipse = []
# premier huiti�me
vx = a * bb
vy = 0
x = a
y = 0
bl = vx / 2
while vx >= vy and x >= 0:
ellipse.append((x, y))
y += 1
vy += aa # vy = y * aa
bl -= vy
if bl < 0:
x -= 1
vx -= bb # vx = x * bb
bl += vx
# second huiti�me
while x >= 0:
ellipse.append((x, y))
x -= 1
vx -= bb # vx = x * bb
bl += vx
if bl > 0:
y += 1
vy += aa # vy = y * aa
bl -= vy
# second quart, sym�trique par rapport � l'axe des ordonn�es
ellipse2 = [(-x, y) for (x, y) in ellipse]
ellipse2.reverse()
ellipse.extend(ellipse2)
# troisi�me et quatri�me quarts : sym�trique par rapport � l'axe des
# abscisse
ellipse2 = [(x, -y) for (x, y) in ellipse]
ellipse2.reverse()
ellipse.extend(ellipse2)
return [(x + xc, y + yc) for (x, y) in ellipse] | [
"def",
"trace_ellipse",
"(",
"xc",
",",
"yc",
",",
"a",
",",
"b",
")",
":",
"# on �vite les cas litigieux",
"if",
"a",
"==",
"0",
":",
"return",
"[",
"(",
"xc",
",",
"yc",
"+",
"y",
")",
"for",
"y",
"in",
"xrange",
"(",
"-",
"b",
",",
"b",
")",
"]",
"if",
"b",
"==",
"0",
":",
"return",
"[",
"(",
"xc",
"+",
"x",
",",
"yc",
")",
"for",
"x",
"in",
"xrange",
"(",
"-",
"a",
",",
"a",
")",
"]",
"bb",
"=",
"b",
"*",
"b",
"aa",
"=",
"a",
"*",
"a",
"# on trace l'ellipse de centre 0,0",
"ellipse",
"=",
"[",
"]",
"# premier huiti�me",
"vx",
"=",
"a",
"*",
"bb",
"vy",
"=",
"0",
"x",
"=",
"a",
"y",
"=",
"0",
"bl",
"=",
"vx",
"/",
"2",
"while",
"vx",
">=",
"vy",
"and",
"x",
">=",
"0",
":",
"ellipse",
".",
"append",
"(",
"(",
"x",
",",
"y",
")",
")",
"y",
"+=",
"1",
"vy",
"+=",
"aa",
"# vy = y * aa",
"bl",
"-=",
"vy",
"if",
"bl",
"<",
"0",
":",
"x",
"-=",
"1",
"vx",
"-=",
"bb",
"# vx = x * bb",
"bl",
"+=",
"vx",
"# second huiti�me",
"while",
"x",
">=",
"0",
":",
"ellipse",
".",
"append",
"(",
"(",
"x",
",",
"y",
")",
")",
"x",
"-=",
"1",
"vx",
"-=",
"bb",
"# vx = x * bb",
"bl",
"+=",
"vx",
"if",
"bl",
">",
"0",
":",
"y",
"+=",
"1",
"vy",
"+=",
"aa",
"# vy = y * aa",
"bl",
"-=",
"vy",
"# second quart, sym�trique par rapport � l'axe des ordonn�es",
"ellipse2",
"=",
"[",
"(",
"-",
"x",
",",
"y",
")",
"for",
"(",
"x",
",",
"y",
")",
"in",
"ellipse",
"]",
"ellipse2",
".",
"reverse",
"(",
")",
"ellipse",
".",
"extend",
"(",
"ellipse2",
")",
"# troisi�me et quatri�me quarts : sym�trique par rapport � l'axe des",
"# abscisse",
"ellipse2",
"=",
"[",
"(",
"x",
",",
"-",
"y",
")",
"for",
"(",
"x",
",",
"y",
")",
"in",
"ellipse",
"]",
"ellipse2",
".",
"reverse",
"(",
")",
"ellipse",
".",
"extend",
"(",
"ellipse2",
")",
"return",
"[",
"(",
"x",
"+",
"xc",
",",
"y",
"+",
"yc",
")",
"for",
"(",
"x",
",",
"y",
")",
"in",
"ellipse",
"]"
] | [
8,
0
] | [
65,
51
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
make_encounters | (graph, i) | Assess all encounters made by i in one day | Détermine toutes les rencontres faites par i en un jour | Assess all encounters made by i in one day | Détermine toutes les rencontres faites par i en un jour | def make_encounters(graph, i):
""" Assess all encounters made by i in one day | Détermine toutes les rencontres faites par i en un jour """
for edge in graph.adj[i]:
j = edge['node']
if j < i:
continue # only check one way of the edge | on ne regarde qu'un sens de chaque arête
# if i and/or j are in quarantine, reduce the probability that they meet | si i et/ou j sont confinés, réduction de leur proba de rencontre
factor = 1
if graph.individuals[i].in_quarantine():
factor *= quarantineFactor
if graph.individuals[j].in_quarantine():
factor *= quarantineFactor
if random.random() < edge['proba'] / factor:
if random.random() < pCloseContact: # if this is a close contact
# if i and j have the app, we save their encounter | si i et j ont l'appli, on note la rencontre
if graph.individuals[i].app and graph.individuals[j].app and random.random() < pDetection: # contact detections are symmetric in our model
graph.encounters[i][-1].append(j)
graph.encounters[j][-1].append(i)
contamination(graph, i, j, True)
else:
contamination(graph, i, j, False) | [
"def",
"make_encounters",
"(",
"graph",
",",
"i",
")",
":",
"for",
"edge",
"in",
"graph",
".",
"adj",
"[",
"i",
"]",
":",
"j",
"=",
"edge",
"[",
"'node'",
"]",
"if",
"j",
"<",
"i",
":",
"continue",
"# only check one way of the edge | on ne regarde qu'un sens de chaque arête",
"# if i and/or j are in quarantine, reduce the probability that they meet | si i et/ou j sont confinés, réduction de leur proba de rencontre",
"factor",
"=",
"1",
"if",
"graph",
".",
"individuals",
"[",
"i",
"]",
".",
"in_quarantine",
"(",
")",
":",
"factor",
"*=",
"quarantineFactor",
"if",
"graph",
".",
"individuals",
"[",
"j",
"]",
".",
"in_quarantine",
"(",
")",
":",
"factor",
"*=",
"quarantineFactor",
"if",
"random",
".",
"random",
"(",
")",
"<",
"edge",
"[",
"'proba'",
"]",
"/",
"factor",
":",
"if",
"random",
".",
"random",
"(",
")",
"<",
"pCloseContact",
":",
"# if this is a close contact",
"# if i and j have the app, we save their encounter | si i et j ont l'appli, on note la rencontre",
"if",
"graph",
".",
"individuals",
"[",
"i",
"]",
".",
"app",
"and",
"graph",
".",
"individuals",
"[",
"j",
"]",
".",
"app",
"and",
"random",
".",
"random",
"(",
")",
"<",
"pDetection",
":",
"# contact detections are symmetric in our model",
"graph",
".",
"encounters",
"[",
"i",
"]",
"[",
"-",
"1",
"]",
".",
"append",
"(",
"j",
")",
"graph",
".",
"encounters",
"[",
"j",
"]",
"[",
"-",
"1",
"]",
".",
"append",
"(",
"i",
")",
"contamination",
"(",
"graph",
",",
"i",
",",
"j",
",",
"True",
")",
"else",
":",
"contamination",
"(",
"graph",
",",
"i",
",",
"j",
",",
"False",
")"
] | [
387,
0
] | [
410,
49
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
|
modify | () | attributions : bouton 'Modifier une photo' l. afpt
description : appelle la fonction 'f_modify()' du fichier 'fonctions.py'
| attributions : bouton 'Modifier une photo' l. afpt
description : appelle la fonction 'f_modify()' du fichier 'fonctions.py'
| def modify():
"""attributions : bouton 'Modifier une photo' l. afpt
description : appelle la fonction 'f_modify()' du fichier 'fonctions.py'
"""
f_modify(default_lbl,default_noimg,lbl,import_button,modify_button,delete_button,frame2,frame4,frame5,master) | [
"def",
"modify",
"(",
")",
":",
"f_modify",
"(",
"default_lbl",
",",
"default_noimg",
",",
"lbl",
",",
"import_button",
",",
"modify_button",
",",
"delete_button",
",",
"frame2",
",",
"frame4",
",",
"frame5",
",",
"master",
")"
] | [
30,
0
] | [
34,
113
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
|
InterfaceJeu.initGrille | (self) | Initialisation de la grille | Initialisation de la grille | def initGrille(self):
"""Initialisation de la grille"""
L = H = 0
for i, ligne in enumerate(self.board.matrix):
for j, _ in enumerate(ligne):
tag = str(j)+"-"+str(i) #Création du tag de chaque carreau
self.canvas.create_rectangle(PIX_L_INTERFACE/2+L,
PIX_H_INTERFACE/2+H,
PIX_L_INTERFACE/2+L+TAILLE_CARREAU,
PIX_H_INTERFACE/2+H+TAILLE_CARREAU,
tags = tag)
L += TAILLE_CARREAU
if self.parent.DEBUG:
print("Tag : {}".format(tag))
H += TAILLE_CARREAU
L = 0 | [
"def",
"initGrille",
"(",
"self",
")",
":",
"L",
"=",
"H",
"=",
"0",
"for",
"i",
",",
"ligne",
"in",
"enumerate",
"(",
"self",
".",
"board",
".",
"matrix",
")",
":",
"for",
"j",
",",
"_",
"in",
"enumerate",
"(",
"ligne",
")",
":",
"tag",
"=",
"str",
"(",
"j",
")",
"+",
"\"-\"",
"+",
"str",
"(",
"i",
")",
"#Création du tag de chaque carreau",
"self",
".",
"canvas",
".",
"create_rectangle",
"(",
"PIX_L_INTERFACE",
"/",
"2",
"+",
"L",
",",
"PIX_H_INTERFACE",
"/",
"2",
"+",
"H",
",",
"PIX_L_INTERFACE",
"/",
"2",
"+",
"L",
"+",
"TAILLE_CARREAU",
",",
"PIX_H_INTERFACE",
"/",
"2",
"+",
"H",
"+",
"TAILLE_CARREAU",
",",
"tags",
"=",
"tag",
")",
"L",
"+=",
"TAILLE_CARREAU",
"if",
"self",
".",
"parent",
".",
"DEBUG",
":",
"print",
"(",
"\"Tag : {}\"",
".",
"format",
"(",
"tag",
")",
")",
"H",
"+=",
"TAILLE_CARREAU",
"L",
"=",
"0"
] | [
379,
1
] | [
394,
8
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
|
res_partner.test_date_dispo | (self, date, partner, avec_jours_feries=False) | return res | Test si la date indiquée tombe sur un jour ouvert du partner
| Test si la date indiquée tombe sur un jour ouvert du partner
| def test_date_dispo(self, date, partner, avec_jours_feries=False):
""" Test si la date indiquée tombe sur un jour ouvert du partner
"""
res=True
if date:
num_day = int(time.strftime('%w', time.strptime(date, '%Y-%m-%d'))) #Jour de la semaine (avec dimanche=0)
if num_day in self.num_closing_days(partner):
res=False
if date in self.get_leave_dates(partner, avec_jours_feries):
res=False
return res | [
"def",
"test_date_dispo",
"(",
"self",
",",
"date",
",",
"partner",
",",
"avec_jours_feries",
"=",
"False",
")",
":",
"res",
"=",
"True",
"if",
"date",
":",
"num_day",
"=",
"int",
"(",
"time",
".",
"strftime",
"(",
"'%w'",
",",
"time",
".",
"strptime",
"(",
"date",
",",
"'%Y-%m-%d'",
")",
")",
")",
"#Jour de la semaine (avec dimanche=0)\r",
"if",
"num_day",
"in",
"self",
".",
"num_closing_days",
"(",
"partner",
")",
":",
"res",
"=",
"False",
"if",
"date",
"in",
"self",
".",
"get_leave_dates",
"(",
"partner",
",",
"avec_jours_feries",
")",
":",
"res",
"=",
"False",
"return",
"res"
] | [
337,
4
] | [
347,
18
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
Odrive.Rounds_To_Angle | (self, rounds) | return(angle) | Convertie un nombre de tours de roue a parcourir en un angle (en degres) | Convertie un nombre de tours de roue a parcourir en un angle (en degres) | def Rounds_To_Angle(self, rounds):
"""Convertie un nombre de tours de roue a parcourir en un angle (en degres)"""
angle = (rounds * 360 * self.Diameter) / self.entre_axe
return(angle) | [
"def",
"Rounds_To_Angle",
"(",
"self",
",",
"rounds",
")",
":",
"angle",
"=",
"(",
"rounds",
"*",
"360",
"*",
"self",
".",
"Diameter",
")",
"/",
"self",
".",
"entre_axe",
"return",
"(",
"angle",
")"
] | [
94,
1
] | [
97,
15
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
LinkRigid.__init__ | (self, m1, m2) | Classe écrite pour UNE masse à chaque bout de la tige et pas plus
TODO: généralisation... | Classe écrite pour UNE masse à chaque bout de la tige et pas plus
TODO: généralisation... | def __init__(self, m1, m2):
''' Classe écrite pour UNE masse à chaque bout de la tige et pas plus
TODO: généralisation... '''
self.linktype = 1
self.length = norm(m1.OM-m2.OM)
self.force1 = pygame.math.Vector2((0, 0))
self.force2 = pygame.math.Vector2((0, 0))
super().__init__(m1, m2)
self.linkForm.visible = True
self.rigid = True
self.correctCI() # pour réajuster les vitesses si pas compatibes avec tige rigide
self.update() | [
"def",
"__init__",
"(",
"self",
",",
"m1",
",",
"m2",
")",
":",
"self",
".",
"linktype",
"=",
"1",
"self",
".",
"length",
"=",
"norm",
"(",
"m1",
".",
"OM",
"-",
"m2",
".",
"OM",
")",
"self",
".",
"force1",
"=",
"pygame",
".",
"math",
".",
"Vector2",
"(",
"(",
"0",
",",
"0",
")",
")",
"self",
".",
"force2",
"=",
"pygame",
".",
"math",
".",
"Vector2",
"(",
"(",
"0",
",",
"0",
")",
")",
"super",
"(",
")",
".",
"__init__",
"(",
"m1",
",",
"m2",
")",
"self",
".",
"linkForm",
".",
"visible",
"=",
"True",
"self",
".",
"rigid",
"=",
"True",
"self",
".",
"correctCI",
"(",
")",
"# pour réajuster les vitesses si pas compatibes avec tige rigide\r",
"self",
".",
"update",
"(",
")"
] | [
50,
4
] | [
62,
21
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
|
decouverte_devices | () | Fonction de découverte des devices Cozytouch
Scanne les devices présents dans l'api cozytouch et gère les ajouts à Domoticz
| Fonction de découverte des devices Cozytouch
Scanne les devices présents dans l'api cozytouch et gère les ajouts à Domoticz
| def decouverte_devices():
''' Fonction de découverte des devices Cozytouch
Scanne les devices présents dans l'api cozytouch et gère les ajouts à Domoticz
'''
print("**** Decouverte devices ****")
# Renvoi toutes les données du cozytouch
data = cozytouch_GET('getSetup')
if debug==2:
f1=open('./dump_cozytouch.txt', 'w+')
f1.write((json.dumps(data, indent=4, separators=(',', ': '))))
f1.close()
# Lecture données Gateway Cozytouch (pour info)
select=(data[u'setup'][u'gateways'][0])
if select[u'alive']:
cozytouch_gateway_etat="on"
else:
cozytouch_gateway_etat="off"
if debug:
print("\nGateway Cozytouch : etat "+cozytouch_gateway_etat+" / connexion : "+select[u'connectivity'][u'status']+" / version : "+str(select[u'connectivity'][u'protocolVersion']))
# Restauration de la liste des devices
save_devices = var_restore('save_devices')
# Restauration de l'idx hardware cozytouch dans domoticz
save_idx = var_restore('save_idx')
'''
Cas de la liste vide, au premier démarrage du script par ex.
On passe en revue les devices de l'API Cozytouch et on l'ajoute à une liste
si sa classe est connu dans le dictionnaire Cozytouch
'''
if not save_devices : # si la liste est vide on passe à la création des devices
print("**** Demarrage procedure d'ajout devices Cozytouch **** ")
liste=[] # on crée une liste vide
domoticz_write_log(u'Cozytouch : Recherche des devices connectes ... ')
# Initialisation variables
x = 0
p = 0
oid = 0
# On boucle sur chaque device trouvé :
for a in data[u'setup'][u'devices']:
url = a[u'deviceURL']
name = a[u'controllableName']
oid = a[u'placeOID']
if name == dict_cozytouch_devtypes.get(u'radiateur'): # on vérifie si le nom du device est connu
label = read_label_from_cozytouch(data,x,oid)
liste= ajout_radiateur(save_idx,liste,url,x,label) # ajout du device à la liste
p+=1 # incrément position dans dictionnaire des devices
elif name == dict_cozytouch_devtypes.get(u'chauffe eau'):
liste = ajout_chauffe_eau (save_idx,liste,url,x,(data[u'setup'][u'rootPlace'][u'label'])) # label rootplace
p+=1
elif name == dict_cozytouch_devtypes.get(u'module fil pilote'):
liste= ajout_module_fil_pilote (save_idx,liste,url,x,read_label_from_cozytouch(data,x,oid))
p+=1
elif name == dict_cozytouch_devtypes.get(u'PAC main control'):
liste= ajout_PAC_main_control (save_idx,liste,url,x,read_label_from_cozytouch(data,x))
p+=1
elif name == dict_cozytouch_devtypes.get(u'PAC zone control'):
liste= ajout_PAC_zone_control (save_idx,liste,url,x,read_label_from_cozytouch(data,x))
p+=1
elif name == dict_cozytouch_devtypes.get(u'DHWP_THERM_V3_IO') or name == dict_cozytouch_devtypes.get(u'DHWP_THERM_IO') or name == dict_cozytouch_devtypes.get(u'DHWP_THERM_V2_MURAL_IO') :
liste= Add_DHWP_THERM (save_idx,liste,url,x,(data[u'setup'][u'rootPlace'][u'label']),name) # label sur rootplace
p+=1
elif name == dict_cozytouch_devtypes.get(u'bridge cozytouch'):
label = u'localisation inconnue'
liste= ajout_bridge_cozytouch (save_idx,liste,url,x,label)
p+=1
else :
domoticz_write_log(u'Cozytouch : Device avec classe '+name+u' inconnu')
x+=1 # incrément device dans data json cozytouch
# Fin de la boucle :
# Sauvegarde des devices ajoutés
var_save(liste,'save_devices')
'''
Cas de liste non vide
On passe en revue les devices l'API Cozytouch
si sa classe est connue dans le dictionnaire Cozytouch on met à jour les données
'''
if save_devices != 0 : # si la liste contient des devices
print("\n**** Demarrage mise a jour devices ****")
# Initialisation variables
liste_inconnu = []
x = 0
p = 0
# On boucle sur chaque device trouvé :
for a in data[u'setup'][u'devices']:
url = a[u'deviceURL']
name = a[u'controllableName']
# On boucle sur les éléments du dictionnaire de devices
for element in save_devices :
if element.has_key(u'url') : # si la clé url est présente dans le dictionnaire
if element.get(u'url') == url : # si l'url du device est stocké dans le dictionnaire
maj_device(data,name,p,x) # mise à jour du device
p+=1 # incrément position dans le dictionnaire
for inconnu in liste_inconnu :
if inconnu == url :
liste_inconnu.remove(url) # on retire l'url inconnu à la liste
break
else : # sinon on reboucle
liste_inconnu.append(url)
else : # sinon on reboucle
continue
x+=1 | [
"def",
"decouverte_devices",
"(",
")",
":",
"print",
"(",
"\"**** Decouverte devices ****\"",
")",
"# Renvoi toutes les données du cozytouch",
"data",
"=",
"cozytouch_GET",
"(",
"'getSetup'",
")",
"if",
"debug",
"==",
"2",
":",
"f1",
"=",
"open",
"(",
"'./dump_cozytouch.txt'",
",",
"'w+'",
")",
"f1",
".",
"write",
"(",
"(",
"json",
".",
"dumps",
"(",
"data",
",",
"indent",
"=",
"4",
",",
"separators",
"=",
"(",
"','",
",",
"': '",
")",
")",
")",
")",
"f1",
".",
"close",
"(",
")",
"# Lecture données Gateway Cozytouch (pour info)",
"select",
"=",
"(",
"data",
"[",
"u'setup'",
"]",
"[",
"u'gateways'",
"]",
"[",
"0",
"]",
")",
"if",
"select",
"[",
"u'alive'",
"]",
":",
"cozytouch_gateway_etat",
"=",
"\"on\"",
"else",
":",
"cozytouch_gateway_etat",
"=",
"\"off\"",
"if",
"debug",
":",
"print",
"(",
"\"\\nGateway Cozytouch : etat \"",
"+",
"cozytouch_gateway_etat",
"+",
"\" / connexion : \"",
"+",
"select",
"[",
"u'connectivity'",
"]",
"[",
"u'status'",
"]",
"+",
"\" / version : \"",
"+",
"str",
"(",
"select",
"[",
"u'connectivity'",
"]",
"[",
"u'protocolVersion'",
"]",
")",
")",
"# Restauration de la liste des devices",
"save_devices",
"=",
"var_restore",
"(",
"'save_devices'",
")",
"# Restauration de l'idx hardware cozytouch dans domoticz",
"save_idx",
"=",
"var_restore",
"(",
"'save_idx'",
")",
"'''\n Cas de la liste vide, au premier démarrage du script par ex.\n On passe en revue les devices de l'API Cozytouch et on l'ajoute à une liste\n si sa classe est connu dans le dictionnaire Cozytouch\n '''",
"if",
"not",
"save_devices",
":",
"# si la liste est vide on passe à la création des devices",
"print",
"(",
"\"**** Demarrage procedure d'ajout devices Cozytouch **** \"",
")",
"liste",
"=",
"[",
"]",
"# on crée une liste vide",
"domoticz_write_log",
"(",
"u'Cozytouch : Recherche des devices connectes ... '",
")",
"# Initialisation variables",
"x",
"=",
"0",
"p",
"=",
"0",
"oid",
"=",
"0",
"# On boucle sur chaque device trouvé :",
"for",
"a",
"in",
"data",
"[",
"u'setup'",
"]",
"[",
"u'devices'",
"]",
":",
"url",
"=",
"a",
"[",
"u'deviceURL'",
"]",
"name",
"=",
"a",
"[",
"u'controllableName'",
"]",
"oid",
"=",
"a",
"[",
"u'placeOID'",
"]",
"if",
"name",
"==",
"dict_cozytouch_devtypes",
".",
"get",
"(",
"u'radiateur'",
")",
":",
"# on vérifie si le nom du device est connu",
"label",
"=",
"read_label_from_cozytouch",
"(",
"data",
",",
"x",
",",
"oid",
")",
"liste",
"=",
"ajout_radiateur",
"(",
"save_idx",
",",
"liste",
",",
"url",
",",
"x",
",",
"label",
")",
"# ajout du device à la liste",
"p",
"+=",
"1",
"# incrément position dans dictionnaire des devices",
"elif",
"name",
"==",
"dict_cozytouch_devtypes",
".",
"get",
"(",
"u'chauffe eau'",
")",
":",
"liste",
"=",
"ajout_chauffe_eau",
"(",
"save_idx",
",",
"liste",
",",
"url",
",",
"x",
",",
"(",
"data",
"[",
"u'setup'",
"]",
"[",
"u'rootPlace'",
"]",
"[",
"u'label'",
"]",
")",
")",
"# label rootplace",
"p",
"+=",
"1",
"elif",
"name",
"==",
"dict_cozytouch_devtypes",
".",
"get",
"(",
"u'module fil pilote'",
")",
":",
"liste",
"=",
"ajout_module_fil_pilote",
"(",
"save_idx",
",",
"liste",
",",
"url",
",",
"x",
",",
"read_label_from_cozytouch",
"(",
"data",
",",
"x",
",",
"oid",
")",
")",
"p",
"+=",
"1",
"elif",
"name",
"==",
"dict_cozytouch_devtypes",
".",
"get",
"(",
"u'PAC main control'",
")",
":",
"liste",
"=",
"ajout_PAC_main_control",
"(",
"save_idx",
",",
"liste",
",",
"url",
",",
"x",
",",
"read_label_from_cozytouch",
"(",
"data",
",",
"x",
")",
")",
"p",
"+=",
"1",
"elif",
"name",
"==",
"dict_cozytouch_devtypes",
".",
"get",
"(",
"u'PAC zone control'",
")",
":",
"liste",
"=",
"ajout_PAC_zone_control",
"(",
"save_idx",
",",
"liste",
",",
"url",
",",
"x",
",",
"read_label_from_cozytouch",
"(",
"data",
",",
"x",
")",
")",
"p",
"+=",
"1",
"elif",
"name",
"==",
"dict_cozytouch_devtypes",
".",
"get",
"(",
"u'DHWP_THERM_V3_IO'",
")",
"or",
"name",
"==",
"dict_cozytouch_devtypes",
".",
"get",
"(",
"u'DHWP_THERM_IO'",
")",
"or",
"name",
"==",
"dict_cozytouch_devtypes",
".",
"get",
"(",
"u'DHWP_THERM_V2_MURAL_IO'",
")",
":",
"liste",
"=",
"Add_DHWP_THERM",
"(",
"save_idx",
",",
"liste",
",",
"url",
",",
"x",
",",
"(",
"data",
"[",
"u'setup'",
"]",
"[",
"u'rootPlace'",
"]",
"[",
"u'label'",
"]",
")",
",",
"name",
")",
"# label sur rootplace",
"p",
"+=",
"1",
"elif",
"name",
"==",
"dict_cozytouch_devtypes",
".",
"get",
"(",
"u'bridge cozytouch'",
")",
":",
"label",
"=",
"u'localisation inconnue'",
"liste",
"=",
"ajout_bridge_cozytouch",
"(",
"save_idx",
",",
"liste",
",",
"url",
",",
"x",
",",
"label",
")",
"p",
"+=",
"1",
"else",
":",
"domoticz_write_log",
"(",
"u'Cozytouch : Device avec classe '",
"+",
"name",
"+",
"u' inconnu'",
")",
"x",
"+=",
"1",
"# incrément device dans data json cozytouch",
"# Fin de la boucle :",
"# Sauvegarde des devices ajoutés",
"var_save",
"(",
"liste",
",",
"'save_devices'",
")",
"'''\n Cas de liste non vide\n On passe en revue les devices l'API Cozytouch\n si sa classe est connue dans le dictionnaire Cozytouch on met à jour les données\n '''",
"if",
"save_devices",
"!=",
"0",
":",
"# si la liste contient des devices",
"print",
"(",
"\"\\n**** Demarrage mise a jour devices ****\"",
")",
"# Initialisation variables",
"liste_inconnu",
"=",
"[",
"]",
"x",
"=",
"0",
"p",
"=",
"0",
"# On boucle sur chaque device trouvé :",
"for",
"a",
"in",
"data",
"[",
"u'setup'",
"]",
"[",
"u'devices'",
"]",
":",
"url",
"=",
"a",
"[",
"u'deviceURL'",
"]",
"name",
"=",
"a",
"[",
"u'controllableName'",
"]",
"# On boucle sur les éléments du dictionnaire de devices",
"for",
"element",
"in",
"save_devices",
":",
"if",
"element",
".",
"has_key",
"(",
"u'url'",
")",
":",
"# si la clé url est présente dans le dictionnaire",
"if",
"element",
".",
"get",
"(",
"u'url'",
")",
"==",
"url",
":",
"# si l'url du device est stocké dans le dictionnaire",
"maj_device",
"(",
"data",
",",
"name",
",",
"p",
",",
"x",
")",
"# mise à jour du device",
"p",
"+=",
"1",
"# incrément position dans le dictionnaire",
"for",
"inconnu",
"in",
"liste_inconnu",
":",
"if",
"inconnu",
"==",
"url",
":",
"liste_inconnu",
".",
"remove",
"(",
"url",
")",
"# on retire l'url inconnu à la liste",
"break",
"else",
":",
"# sinon on reboucle",
"liste_inconnu",
".",
"append",
"(",
"url",
")",
"else",
":",
"# sinon on reboucle",
"continue",
"x",
"+=",
"1"
] | [
577,
0
] | [
701,
16
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
|
Admin.admin_flag | (self, ctx:MyContext, add:str, flag:str, users:commands.Greedy[discord.User]) | Ajoute ou retire un attribut à un utilisateur
Flag valides : support, premium, contributor, partner | Ajoute ou retire un attribut à un utilisateur
Flag valides : support, premium, contributor, partner | async def admin_flag(self, ctx:MyContext, add:str, flag:str, users:commands.Greedy[discord.User]):
"""Ajoute ou retire un attribut à un utilisateur
Flag valides : support, premium, contributor, partner"""
if add not in ['add', 'remove']:
return await ctx.send("Action invalide")
for user in users:
if flag not in UserFlag.FLAGS.values():
await ctx.send("Flag invalide")
return
userflags: list = await self.bot.get_cog("Users").get_userflags(user)
if userflags:
if flag in userflags and add == 'add':
await ctx.send(f"L'utilisateur {user} a déjà ce flag")
return
if flag not in userflags and add == 'remove':
return await ctx.send(f"L'utilisateur {user} n'a pas ce flag")
if add == "add":
userflags.append(flag)
else:
userflags.remove(flag)
await self.bot.get_cog('Utilities').change_db_userinfo(user.id, 'user_flags', UserFlag().flagsToInt(userflags))
if add == "add":
await ctx.send(f"L'utilisateur {user} a maintenant le flag `{flag}`",delete_after=3.0)
elif add == "remove":
await ctx.send(f"L'utilisateur {user} n'a plus le flag `{flag}`",delete_after=3.0)
try:
await ctx.message.detele()
except:
pass | [
"async",
"def",
"admin_flag",
"(",
"self",
",",
"ctx",
":",
"MyContext",
",",
"add",
":",
"str",
",",
"flag",
":",
"str",
",",
"users",
":",
"commands",
".",
"Greedy",
"[",
"discord",
".",
"User",
"]",
")",
":",
"if",
"add",
"not",
"in",
"[",
"'add'",
",",
"'remove'",
"]",
":",
"return",
"await",
"ctx",
".",
"send",
"(",
"\"Action invalide\"",
")",
"for",
"user",
"in",
"users",
":",
"if",
"flag",
"not",
"in",
"UserFlag",
".",
"FLAGS",
".",
"values",
"(",
")",
":",
"await",
"ctx",
".",
"send",
"(",
"\"Flag invalide\"",
")",
"return",
"userflags",
":",
"list",
"=",
"await",
"self",
".",
"bot",
".",
"get_cog",
"(",
"\"Users\"",
")",
".",
"get_userflags",
"(",
"user",
")",
"if",
"userflags",
":",
"if",
"flag",
"in",
"userflags",
"and",
"add",
"==",
"'add'",
":",
"await",
"ctx",
".",
"send",
"(",
"f\"L'utilisateur {user} a déjà ce flag\")",
"",
"return",
"if",
"flag",
"not",
"in",
"userflags",
"and",
"add",
"==",
"'remove'",
":",
"return",
"await",
"ctx",
".",
"send",
"(",
"f\"L'utilisateur {user} n'a pas ce flag\"",
")",
"if",
"add",
"==",
"\"add\"",
":",
"userflags",
".",
"append",
"(",
"flag",
")",
"else",
":",
"userflags",
".",
"remove",
"(",
"flag",
")",
"await",
"self",
".",
"bot",
".",
"get_cog",
"(",
"'Utilities'",
")",
".",
"change_db_userinfo",
"(",
"user",
".",
"id",
",",
"'user_flags'",
",",
"UserFlag",
"(",
")",
".",
"flagsToInt",
"(",
"userflags",
")",
")",
"if",
"add",
"==",
"\"add\"",
":",
"await",
"ctx",
".",
"send",
"(",
"f\"L'utilisateur {user} a maintenant le flag `{flag}`\"",
",",
"delete_after",
"=",
"3.0",
")",
"elif",
"add",
"==",
"\"remove\"",
":",
"await",
"ctx",
".",
"send",
"(",
"f\"L'utilisateur {user} n'a plus le flag `{flag}`\"",
",",
"delete_after",
"=",
"3.0",
")",
"try",
":",
"await",
"ctx",
".",
"message",
".",
"detele",
"(",
")",
"except",
":",
"pass"
] | [
588,
4
] | [
617,
20
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
|
ListeAccords.ConcordanceCoherenceConcordanceOrdre3Liste | (self) | Transforme chaque verticalite en objet Accord, calcule la concordance, la coherence et les concordances multiples, et stocke les resultats
sous forme de liste d'Accords"
| Transforme chaque verticalite en objet Accord, calcule la concordance, la coherence et les concordances multiples, et stocke les resultats
sous forme de liste d'Accords"
| def ConcordanceCoherenceConcordanceOrdre3Liste (self):
''' Transforme chaque verticalite en objet Accord, calcule la concordance, la coherence et les concordances multiples, et stocke les resultats
sous forme de liste d'Accords"
'''
self.Normalisation()
for verticality in self.tree.iterateVerticalities():
v = Accord(verticality, self.K, self.decr, self.sig, self.normalisation, self.temperament,self.noteDeReferencePourLeTunning)
if verticality.bassTimespan!=None :
v.identifiant = verticality.bassTimespan.element.id
v.ListeHauteursAvecMultiplicite()
v.ListeConcordanceDesIntervallesDansAccord()
v.NombreDeNotes()
if v.nombreDeNotes>=2:
v.Concordance()
v.Dissonance()
if v.nombreDeNotes>=3:
v.Tension()
v.ConcordanceTotale()
self.grandeursHarmoniques.append(v) | [
"def",
"ConcordanceCoherenceConcordanceOrdre3Liste",
"(",
"self",
")",
":",
"self",
".",
"Normalisation",
"(",
")",
"for",
"verticality",
"in",
"self",
".",
"tree",
".",
"iterateVerticalities",
"(",
")",
":",
"v",
"=",
"Accord",
"(",
"verticality",
",",
"self",
".",
"K",
",",
"self",
".",
"decr",
",",
"self",
".",
"sig",
",",
"self",
".",
"normalisation",
",",
"self",
".",
"temperament",
",",
"self",
".",
"noteDeReferencePourLeTunning",
")",
"if",
"verticality",
".",
"bassTimespan",
"!=",
"None",
":",
"v",
".",
"identifiant",
"=",
"verticality",
".",
"bassTimespan",
".",
"element",
".",
"id",
"v",
".",
"ListeHauteursAvecMultiplicite",
"(",
")",
"v",
".",
"ListeConcordanceDesIntervallesDansAccord",
"(",
")",
"v",
".",
"NombreDeNotes",
"(",
")",
"if",
"v",
".",
"nombreDeNotes",
">=",
"2",
":",
"v",
".",
"Concordance",
"(",
")",
"v",
".",
"Dissonance",
"(",
")",
"if",
"v",
".",
"nombreDeNotes",
">=",
"3",
":",
"v",
".",
"Tension",
"(",
")",
"v",
".",
"ConcordanceTotale",
"(",
")",
"self",
".",
"grandeursHarmoniques",
".",
"append",
"(",
"v",
")"
] | [
90,
2
] | [
113,
45
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
|
ListenShortcut.read_time | (self) | return open(self.time_file, 'r').read() | Lis le fichier dans lequel est enregistré
l'heure du dernier appuie sur la touche | Lis le fichier dans lequel est enregistré
l'heure du dernier appuie sur la touche | def read_time(self) :
""" Lis le fichier dans lequel est enregistré
l'heure du dernier appuie sur la touche"""
return open(self.time_file, 'r').read() | [
"def",
"read_time",
"(",
"self",
")",
":",
"return",
"open",
"(",
"self",
".",
"time_file",
",",
"'r'",
")",
".",
"read",
"(",
")"
] | [
52,
4
] | [
55,
47
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
Welcomer.on_member_remove | (self, member:discord.Member) | Fonction principale appelée lorsqu'un membre quitte un serveur | Fonction principale appelée lorsqu'un membre quitte un serveur | async def on_member_remove(self, member:discord.Member):
"""Fonction principale appelée lorsqu'un membre quitte un serveur"""
if self.bot.database_online:
await self.bot.get_cog("Servers").update_memberChannel(member.guild)
await self.send_msg(member,"leave")
await self.bot.get_cog('Events').check_user_left(member) | [
"async",
"def",
"on_member_remove",
"(",
"self",
",",
"member",
":",
"discord",
".",
"Member",
")",
":",
"if",
"self",
".",
"bot",
".",
"database_online",
":",
"await",
"self",
".",
"bot",
".",
"get_cog",
"(",
"\"Servers\"",
")",
".",
"update_memberChannel",
"(",
"member",
".",
"guild",
")",
"await",
"self",
".",
"send_msg",
"(",
"member",
",",
"\"leave\"",
")",
"await",
"self",
".",
"bot",
".",
"get_cog",
"(",
"'Events'",
")",
".",
"check_user_left",
"(",
"member",
")"
] | [
40,
4
] | [
45,
68
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
|
Statistic.length_of_documents_by_class | (self) | return dic_length | a rajouter dans visualisation
data = pd.DataFrame({'Classe':classe ,'Longueur des documents':longueur_des_doc})
fig, ax = plt.subplots()
plt.xticks(rotation=90)
sns.boxplot(x='Classe', y='Longueur des documents', data=data, palette='Set2',notch=True,showfliers=True, showmeans=True, meanline=True)
ax.set_ylim(0, 200)
plt.savefig('/home/mercadier/these/resultat/image/longueur-doc-by-classe.png')
| a rajouter dans visualisation
data = pd.DataFrame({'Classe':classe ,'Longueur des documents':longueur_des_doc})
fig, ax = plt.subplots()
plt.xticks(rotation=90)
sns.boxplot(x='Classe', y='Longueur des documents', data=data, palette='Set2',notch=True,showfliers=True, showmeans=True, meanline=True)
ax.set_ylim(0, 200)
plt.savefig('/home/mercadier/these/resultat/image/longueur-doc-by-classe.png')
| def length_of_documents_by_class(self):
dic_length={}
length_of_doc=[]
classe=[]
for lab in self.list_labels:
dic_length[lab]= []
for doc,cl in zip(self.documents,self.labels):
sentence=doc.split(" ")
length_of_doc.append(len(sentence))
classe.append(cl)
dic_length[cl].append(len(sentence))
for lab in self.list_labels:
tab=np.array(dic_length[lab])
dic_length[lab]=np.mean(tab)
'''a rajouter dans visualisation
data = pd.DataFrame({'Classe':classe ,'Longueur des documents':longueur_des_doc})
fig, ax = plt.subplots()
plt.xticks(rotation=90)
sns.boxplot(x='Classe', y='Longueur des documents', data=data, palette='Set2',notch=True,showfliers=True, showmeans=True, meanline=True)
ax.set_ylim(0, 200)
plt.savefig('/home/mercadier/these/resultat/image/longueur-doc-by-classe.png')
'''
return dic_length | [
"def",
"length_of_documents_by_class",
"(",
"self",
")",
":",
"dic_length",
"=",
"{",
"}",
"length_of_doc",
"=",
"[",
"]",
"classe",
"=",
"[",
"]",
"for",
"lab",
"in",
"self",
".",
"list_labels",
":",
"dic_length",
"[",
"lab",
"]",
"=",
"[",
"]",
"for",
"doc",
",",
"cl",
"in",
"zip",
"(",
"self",
".",
"documents",
",",
"self",
".",
"labels",
")",
":",
"sentence",
"=",
"doc",
".",
"split",
"(",
"\" \"",
")",
"length_of_doc",
".",
"append",
"(",
"len",
"(",
"sentence",
")",
")",
"classe",
".",
"append",
"(",
"cl",
")",
"dic_length",
"[",
"cl",
"]",
".",
"append",
"(",
"len",
"(",
"sentence",
")",
")",
"for",
"lab",
"in",
"self",
".",
"list_labels",
":",
"tab",
"=",
"np",
".",
"array",
"(",
"dic_length",
"[",
"lab",
"]",
")",
"dic_length",
"[",
"lab",
"]",
"=",
"np",
".",
"mean",
"(",
"tab",
")",
"return",
"dic_length"
] | [
103,
1
] | [
126,
19
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
current_color | (*args) | Definition de la couleur courante
- soit en r, v, b dans [O, 255]
- soit par son nom (white, black, red, green, blue, ...)
| Definition de la couleur courante
- soit en r, v, b dans [O, 255]
- soit par son nom (white, black, red, green, blue, ...)
| def current_color(*args):
"""Definition de la couleur courante
- soit en r, v, b dans [O, 255]
- soit par son nom (white, black, red, green, blue, ...)
"""
global __ccol
# initialisation a noir en cas d'erreur
__ccol = "black"
# 1 parametre : le nom de la couleur
if len(args) == 1:
if isinstance(args[0], str):
__ccol = args[0]
else:
__erreur("[current_color] le paramètre n'est pas une chaine")
# 3 parametres : code RVB sur [0, 255]
elif len(args) == 3:
if isinstance(args[0], int) and isinstance(args[1], int) and isinstance(args[2], int):
tc = [0, 0, 0]
tc[0], tc[1], tc[2] = int(args[0]), int(args[1]), int(args[2])
if -1 < tc[0] < 256 and -1 < tc[1] < 256 and -1 < tc[2] < 256:
# concatenation avec suppression du prefixe 0x et
# ajout d'un zero pour les nombres inf. a 16
__ccol = '#'
for i in range(3):
if tc[i] < 16:
__ccol += '0' + hex(tc[i])[2:]
else:
__ccol += hex(tc[i])[2:]
else:
__erreur("[current_color] composantes RVB pas entre 0 et 255")
else:
__erreur("[current_color] l'un des paramètres n'est pas un entier")
# erreur : nombre de parametres incorrect
else:
__erreur("[current_color] nombre de paramètres incorrect (1 ou 3)") | [
"def",
"current_color",
"(",
"*",
"args",
")",
":",
"global",
"__ccol",
"# initialisation a noir en cas d'erreur",
"__ccol",
"=",
"\"black\"",
"# 1 parametre : le nom de la couleur",
"if",
"len",
"(",
"args",
")",
"==",
"1",
":",
"if",
"isinstance",
"(",
"args",
"[",
"0",
"]",
",",
"str",
")",
":",
"__ccol",
"=",
"args",
"[",
"0",
"]",
"else",
":",
"__erreur",
"(",
"\"[current_color] le paramètre n'est pas une chaine\")",
"",
"# 3 parametres : code RVB sur [0, 255]",
"elif",
"len",
"(",
"args",
")",
"==",
"3",
":",
"if",
"isinstance",
"(",
"args",
"[",
"0",
"]",
",",
"int",
")",
"and",
"isinstance",
"(",
"args",
"[",
"1",
"]",
",",
"int",
")",
"and",
"isinstance",
"(",
"args",
"[",
"2",
"]",
",",
"int",
")",
":",
"tc",
"=",
"[",
"0",
",",
"0",
",",
"0",
"]",
"tc",
"[",
"0",
"]",
",",
"tc",
"[",
"1",
"]",
",",
"tc",
"[",
"2",
"]",
"=",
"int",
"(",
"args",
"[",
"0",
"]",
")",
",",
"int",
"(",
"args",
"[",
"1",
"]",
")",
",",
"int",
"(",
"args",
"[",
"2",
"]",
")",
"if",
"-",
"1",
"<",
"tc",
"[",
"0",
"]",
"<",
"256",
"and",
"-",
"1",
"<",
"tc",
"[",
"1",
"]",
"<",
"256",
"and",
"-",
"1",
"<",
"tc",
"[",
"2",
"]",
"<",
"256",
":",
"# concatenation avec suppression du prefixe 0x et",
"# ajout d'un zero pour les nombres inf. a 16",
"__ccol",
"=",
"'#'",
"for",
"i",
"in",
"range",
"(",
"3",
")",
":",
"if",
"tc",
"[",
"i",
"]",
"<",
"16",
":",
"__ccol",
"+=",
"'0'",
"+",
"hex",
"(",
"tc",
"[",
"i",
"]",
")",
"[",
"2",
":",
"]",
"else",
":",
"__ccol",
"+=",
"hex",
"(",
"tc",
"[",
"i",
"]",
")",
"[",
"2",
":",
"]",
"else",
":",
"__erreur",
"(",
"\"[current_color] composantes RVB pas entre 0 et 255\"",
")",
"else",
":",
"__erreur",
"(",
"\"[current_color] l'un des paramètres n'est pas un entier\")",
"",
"# erreur : nombre de parametres incorrect",
"else",
":",
"__erreur",
"(",
"\"[current_color] nombre de paramètres incorrect (1 ou 3)\")",
""
] | [
134,
0
] | [
169,
76
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
|
Crud.get_app | (self) | return self.ctx.get("app") | Obtenir le nom de l'application courante | Obtenir le nom de l'application courante | def get_app(self):
""" Obtenir le nom de l'application courante """
return self.ctx.get("app") | [
"def",
"get_app",
"(",
"self",
")",
":",
"return",
"self",
".",
"ctx",
".",
"get",
"(",
"\"app\"",
")"
] | [
271,
4
] | [
273,
34
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
box | (px1, py1, px2, py2) | return id | affichage d'un rectangle plein dans la couleur courante
defini par le sommet inf. gauche (px1, py1)
et le sommet sup. droit (px2, py2)
retour de l'identificateur unique de l'objet cree
| affichage d'un rectangle plein dans la couleur courante
defini par le sommet inf. gauche (px1, py1)
et le sommet sup. droit (px2, py2)
retour de l'identificateur unique de l'objet cree
| def box(px1, py1, px2, py2):
"""affichage d'un rectangle plein dans la couleur courante
defini par le sommet inf. gauche (px1, py1)
et le sommet sup. droit (px2, py2)
retour de l'identificateur unique de l'objet cree
"""
# changement de repere
py1, py2 = __ha - py1, __ha - py2
id = __canv.create_rectangle(px1, py1, px2, py2, fill=__ccol, width=0)
return id | [
"def",
"box",
"(",
"px1",
",",
"py1",
",",
"px2",
",",
"py2",
")",
":",
"# changement de repere",
"py1",
",",
"py2",
"=",
"__ha",
"-",
"py1",
",",
"__ha",
"-",
"py2",
"id",
"=",
"__canv",
".",
"create_rectangle",
"(",
"px1",
",",
"py1",
",",
"px2",
",",
"py2",
",",
"fill",
"=",
"__ccol",
",",
"width",
"=",
"0",
")",
"return",
"id"
] | [
232,
0
] | [
241,
13
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
Admin.update_config | (self, ctx: MyContext, send: str=None) | Préparer/lancer un message de mise à jour
Ajouter 'send' en argument déclenche la procédure pour l'envoyer à tous les serveurs | Préparer/lancer un message de mise à jour
Ajouter 'send' en argument déclenche la procédure pour l'envoyer à tous les serveurs | async def update_config(self, ctx: MyContext, send: str=None):
"""Préparer/lancer un message de mise à jour
Ajouter 'send' en argument déclenche la procédure pour l'envoyer à tous les serveurs"""
if send == 'send':
await self.send_updates(ctx)
return
def check(m):
return m.author == ctx.author and m.channel == ctx.channel
msg = None
for x in self.update.keys():
await ctx.send("Message en {} ?".format(x))
try:
msg = await ctx.bot.wait_for('message', check=check,timeout=60)
except asyncio.TimeoutError:
return await ctx.send('Trop tard !')
if msg.content.lower() in ['none','annuler','stop','oups']:
return await ctx.send('Annulé !')
self.update[x] = msg.content
if msg:
await ctx.bot.get_cog('Utilities').add_check_reaction(msg) | [
"async",
"def",
"update_config",
"(",
"self",
",",
"ctx",
":",
"MyContext",
",",
"send",
":",
"str",
"=",
"None",
")",
":",
"if",
"send",
"==",
"'send'",
":",
"await",
"self",
".",
"send_updates",
"(",
"ctx",
")",
"return",
"def",
"check",
"(",
"m",
")",
":",
"return",
"m",
".",
"author",
"==",
"ctx",
".",
"author",
"and",
"m",
".",
"channel",
"==",
"ctx",
".",
"channel",
"msg",
"=",
"None",
"for",
"x",
"in",
"self",
".",
"update",
".",
"keys",
"(",
")",
":",
"await",
"ctx",
".",
"send",
"(",
"\"Message en {} ?\"",
".",
"format",
"(",
"x",
")",
")",
"try",
":",
"msg",
"=",
"await",
"ctx",
".",
"bot",
".",
"wait_for",
"(",
"'message'",
",",
"check",
"=",
"check",
",",
"timeout",
"=",
"60",
")",
"except",
"asyncio",
".",
"TimeoutError",
":",
"return",
"await",
"ctx",
".",
"send",
"(",
"'Trop tard !'",
")",
"if",
"msg",
".",
"content",
".",
"lower",
"(",
")",
"in",
"[",
"'none'",
",",
"'annuler'",
",",
"'stop'",
",",
"'oups'",
"]",
":",
"return",
"await",
"ctx",
".",
"send",
"(",
"'Annulé !')",
"",
"self",
".",
"update",
"[",
"x",
"]",
"=",
"msg",
".",
"content",
"if",
"msg",
":",
"await",
"ctx",
".",
"bot",
".",
"get_cog",
"(",
"'Utilities'",
")",
".",
"add_check_reaction",
"(",
"msg",
")"
] | [
147,
4
] | [
166,
70
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
|
Piece.__init__ | (self, shape) | Initialise la pièce
Keyword arguments:
shape -- tableau 2D décrivant la forme de la pièce
| Initialise la pièce | def __init__(self, shape):
"""Initialise la pièce
Keyword arguments:
shape -- tableau 2D décrivant la forme de la pièce
"""
self.shape = shape | [
"def",
"__init__",
"(",
"self",
",",
"shape",
")",
":",
"self",
".",
"shape",
"=",
"shape"
] | [
125,
1
] | [
131,
20
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
|
getDifferentsAtoms | (atomsCoords) | return atoms | renvoie une liste de tous les différents atomes rencontrés dans le dictionnaire atomsCoords
Juste pour voir les données que nous aurons besoin dans le dictionnaire 'atomicMass'
| renvoie une liste de tous les différents atomes rencontrés dans le dictionnaire atomsCoords
Juste pour voir les données que nous aurons besoin dans le dictionnaire 'atomicMass'
| def getDifferentsAtoms(atomsCoords):
"""renvoie une liste de tous les différents atomes rencontrés dans le dictionnaire atomsCoords
Juste pour voir les données que nous aurons besoin dans le dictionnaire 'atomicMass'
"""
atoms = set()
for coo, atom in atomsCoords.items():
atoms.add(atom)
return atoms | [
"def",
"getDifferentsAtoms",
"(",
"atomsCoords",
")",
":",
"atoms",
"=",
"set",
"(",
")",
"for",
"coo",
",",
"atom",
"in",
"atomsCoords",
".",
"items",
"(",
")",
":",
"atoms",
".",
"add",
"(",
"atom",
")",
"return",
"atoms"
] | [
9,
0
] | [
16,
16
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
TransformationCarat | ListeUnicode): | return "".join(ListeUnicode) | Fonction qui convertit la liste de numéros Unicode en une chaine de caractères
correspondant à chacun des numéros convertis et mis bout à bout | Fonction qui convertit la liste de numéros Unicode en une chaine de caractères
correspondant à chacun des numéros convertis et mis bout à bout | def TransformationCaratères(ListeUnicode):
"""Fonction qui convertit la liste de numéros Unicode en une chaine de caractères
correspondant à chacun des numéros convertis et mis bout à bout"""
for index in range(len(ListeUnicode)):
#Boucle de sécurité : Si jamais on doit convertir des nombres
#ne rentrant pas dans la table de caractères Unicode
if ListeUnicode[index] > 1114111 :
# Les caractères Unicode vont de 0 à 1114111.
# Si, à cause du cryptage, la valeur viendrait à quitter cette plage de donnée, cela provoquerait une erreur
# On fait donc en sorte que les cactères restent toujours dans cette plage de donnée.
ListeUnicode[index] = ListeUnicode[index] - 1114111
elif ListeUnicode[index] < 0 :
ListeUnicode[index] = ListeUnicode[index] + 1114111
ListeUnicode[index] = chr(ListeUnicode[index])
# chr(x) est la fonction qui pour toute valeur Unicode x nous renvoie son charactère Unicode (sous type str)
# Cette fonction transforme donc la suite de charactère chiffrés sous forme Unicode en message
return "".join(ListeUnicode) | [
"def",
"TransformationCarat",
"èr",
"es(",
"L",
"isteUnicode)",
":",
"",
"for",
"index",
"in",
"range",
"(",
"len",
"(",
"ListeUnicode",
")",
")",
":",
"#Boucle de sécurité : Si jamais on doit convertir des nombres ",
"#ne rentrant pas dans la table de caractères Unicode",
"if",
"ListeUnicode",
"[",
"index",
"]",
">",
"1114111",
":",
"# Les caractères Unicode vont de 0 à 1114111.",
"# Si, à cause du cryptage, la valeur viendrait à quitter cette plage de donnée, cela provoquerait une erreur",
"# On fait donc en sorte que les cactères restent toujours dans cette plage de donnée.",
"ListeUnicode",
"[",
"index",
"]",
"=",
"ListeUnicode",
"[",
"index",
"]",
"-",
"1114111",
"elif",
"ListeUnicode",
"[",
"index",
"]",
"<",
"0",
":",
"ListeUnicode",
"[",
"index",
"]",
"=",
"ListeUnicode",
"[",
"index",
"]",
"+",
"1114111",
"ListeUnicode",
"[",
"index",
"]",
"=",
"chr",
"(",
"ListeUnicode",
"[",
"index",
"]",
")",
"# chr(x) est la fonction qui pour toute valeur Unicode x nous renvoie son charactère Unicode (sous type str)",
"# Cette fonction transforme donc la suite de charactère chiffrés sous forme Unicode en message",
"return",
"\"\"",
".",
"join",
"(",
"ListeUnicode",
")"
] | [
26,
0
] | [
52,
32
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
Vecteur.__str__ | (self) | return "(%3.2f,%3.2f,%3.2f)" % (self.x, self.y, self.z) | pour l'affichage | pour l'affichage | def __str__(self):
"""pour l'affichage"""
return "(%3.2f,%3.2f,%3.2f)" % (self.x, self.y, self.z) | [
"def",
"__str__",
"(",
"self",
")",
":",
"return",
"\"(%3.2f,%3.2f,%3.2f)\"",
"%",
"(",
"self",
".",
"x",
",",
"self",
".",
"y",
",",
"self",
".",
"z",
")"
] | [
13,
4
] | [
15,
63
] | null | python | fr | ['fr', 'fr', 'fr'] | False | true | null |
effectue_la_suppression | (arbre, precedent, precedent_direction, noeud) | Une fois que le noeud à supprimé est trouvé, on doit le supprimer. | Une fois que le noeud à supprimé est trouvé, on doit le supprimer. | def effectue_la_suppression(arbre, precedent, precedent_direction, noeud):
"""Une fois que le noeud à supprimé est trouvé, on doit le supprimer."""
# Cas où il n'y a pas de descendant
if noeud.gauche == None and noeud.droite == None:
met_a_jour(arbre, precedent, precedent_direction, None)
# Cas où il y a un unique descendant
elif noeud.gauche == None:
met_a_jour(arbre, precedent, precedent_direction, noeud.droite)
elif noeud.droite == None:
met_a_jour(arbre, precedent, precedent_direction, noeud.gauche)
# Cas où il y a plusieurs descendants
else:
petit_noeud = plus_petite(noeud.droite)
petite_valeur = petit_noeud.valeur
supprime_noeud(arbre, petite_valeur)
noeud.valeur = petite_valeur | [
"def",
"effectue_la_suppression",
"(",
"arbre",
",",
"precedent",
",",
"precedent_direction",
",",
"noeud",
")",
":",
"# Cas où il n'y a pas de descendant",
"if",
"noeud",
".",
"gauche",
"==",
"None",
"and",
"noeud",
".",
"droite",
"==",
"None",
":",
"met_a_jour",
"(",
"arbre",
",",
"precedent",
",",
"precedent_direction",
",",
"None",
")",
"# Cas où il y a un unique descendant",
"elif",
"noeud",
".",
"gauche",
"==",
"None",
":",
"met_a_jour",
"(",
"arbre",
",",
"precedent",
",",
"precedent_direction",
",",
"noeud",
".",
"droite",
")",
"elif",
"noeud",
".",
"droite",
"==",
"None",
":",
"met_a_jour",
"(",
"arbre",
",",
"precedent",
",",
"precedent_direction",
",",
"noeud",
".",
"gauche",
")",
"# Cas où il y a plusieurs descendants",
"else",
":",
"petit_noeud",
"=",
"plus_petite",
"(",
"noeud",
".",
"droite",
")",
"petite_valeur",
"=",
"petit_noeud",
".",
"valeur",
"supprime_noeud",
"(",
"arbre",
",",
"petite_valeur",
")",
"noeud",
".",
"valeur",
"=",
"petite_valeur"
] | [
212,
0
] | [
229,
36
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
|
SegmentBord.calcul_bord2 | (self) | return r | calcule précisément la second extrémité, parcourt la demi-droite
jusqu'à sortir de l'image, le dernier point est la seconde extrémité | calcule précisément la second extrémité, parcourt la demi-droite
jusqu'à sortir de l'image, le dernier point est la seconde extrémité | def calcul_bord2(self):
"""calcule précisément la second extrémité, parcourt la demi-droite
jusqu'à sortir de l'image, le dernier point est la seconde extrémité"""
a = self.a.arrondi()
p = copy.copy(self.a)
n = self.directeur()
i = 0
while a.x >= 0 and a.y >= 0 and a.x < self.dim.x and a.y < self.dim.y:
p += n
a = p.arrondi()
i += 1
self.b.x = a.x
self.b.y = a.y
r = -1
if self.b.x < 0:
self.b.x = 0
r = 2
if self.b.x >= self.dim.x:
self.b.x = self.dim.x - 1
r = 0
if self.b.y < 0:
self.b.y = 0
r = 3
if self.b.y >= self.dim.y:
self.b.y = self.dim.y - 1
r = 1
return r | [
"def",
"calcul_bord2",
"(",
"self",
")",
":",
"a",
"=",
"self",
".",
"a",
".",
"arrondi",
"(",
")",
"p",
"=",
"copy",
".",
"copy",
"(",
"self",
".",
"a",
")",
"n",
"=",
"self",
".",
"directeur",
"(",
")",
"i",
"=",
"0",
"while",
"a",
".",
"x",
">=",
"0",
"and",
"a",
".",
"y",
">=",
"0",
"and",
"a",
".",
"x",
"<",
"self",
".",
"dim",
".",
"x",
"and",
"a",
".",
"y",
"<",
"self",
".",
"dim",
".",
"y",
":",
"p",
"+=",
"n",
"a",
"=",
"p",
".",
"arrondi",
"(",
")",
"i",
"+=",
"1",
"self",
".",
"b",
".",
"x",
"=",
"a",
".",
"x",
"self",
".",
"b",
".",
"y",
"=",
"a",
".",
"y",
"r",
"=",
"-",
"1",
"if",
"self",
".",
"b",
".",
"x",
"<",
"0",
":",
"self",
".",
"b",
".",
"x",
"=",
"0",
"r",
"=",
"2",
"if",
"self",
".",
"b",
".",
"x",
">=",
"self",
".",
"dim",
".",
"x",
":",
"self",
".",
"b",
".",
"x",
"=",
"self",
".",
"dim",
".",
"x",
"-",
"1",
"r",
"=",
"0",
"if",
"self",
".",
"b",
".",
"y",
"<",
"0",
":",
"self",
".",
"b",
".",
"y",
"=",
"0",
"r",
"=",
"3",
"if",
"self",
".",
"b",
".",
"y",
">=",
"self",
".",
"dim",
".",
"y",
":",
"self",
".",
"b",
".",
"y",
"=",
"self",
".",
"dim",
".",
"y",
"-",
"1",
"r",
"=",
"1",
"return",
"r"
] | [
217,
4
] | [
245,
16
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
sphere_reflet.__init__ | (self, centre, rayon, couleur, reflet) | initialisation, reflet est un coefficient de r�flexion | initialisation, reflet est un coefficient de r�flexion | def __init__ (self, centre, rayon, couleur, reflet):
"""initialisation, reflet est un coefficient de r�flexion"""
obj.sphere.__init__ (self, centre, rayon, couleur)
self.reflet = reflet | [
"def",
"__init__",
"(",
"self",
",",
"centre",
",",
"rayon",
",",
"couleur",
",",
"reflet",
")",
":",
"obj",
".",
"sphere",
".",
"__init__",
"(",
"self",
",",
"centre",
",",
"rayon",
",",
"couleur",
")",
"self",
".",
"reflet",
"=",
"reflet"
] | [
59,
4
] | [
62,
28
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
|
init_matrix | (x,y) | return res | Initialise la matrice M pour résoudre le système (3.3.7) et obtenir y'' | Initialise la matrice M pour résoudre le système (3.3.7) et obtenir y'' | def init_matrix(x,y):
""" Initialise la matrice M pour résoudre le système (3.3.7) et obtenir y'' """
n = len(x)
res = np.zeros([n,n])
res[0,0] = 1
res[n-1,n-1] = 1
for i in range(1,n-1):
for j in range(0,2):
res[i,i-1+j] = system_aux(x[i-1], x[i], x[i+1], y[i-1], y[i], y[i+1])[j]
return res | [
"def",
"init_matrix",
"(",
"x",
",",
"y",
")",
":",
"n",
"=",
"len",
"(",
"x",
")",
"res",
"=",
"np",
".",
"zeros",
"(",
"[",
"n",
",",
"n",
"]",
")",
"res",
"[",
"0",
",",
"0",
"]",
"=",
"1",
"res",
"[",
"n",
"-",
"1",
",",
"n",
"-",
"1",
"]",
"=",
"1",
"for",
"i",
"in",
"range",
"(",
"1",
",",
"n",
"-",
"1",
")",
":",
"for",
"j",
"in",
"range",
"(",
"0",
",",
"2",
")",
":",
"res",
"[",
"i",
",",
"i",
"-",
"1",
"+",
"j",
"]",
"=",
"system_aux",
"(",
"x",
"[",
"i",
"-",
"1",
"]",
",",
"x",
"[",
"i",
"]",
",",
"x",
"[",
"i",
"+",
"1",
"]",
",",
"y",
"[",
"i",
"-",
"1",
"]",
",",
"y",
"[",
"i",
"]",
",",
"y",
"[",
"i",
"+",
"1",
"]",
")",
"[",
"j",
"]",
"return",
"res"
] | [
91,
0
] | [
100,
12
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
ListeAccords.Normalisation | (self) | Calcule la concordance d'ordre n de l'unisson a n notes, pour n allant de 2 a 8 | Calcule la concordance d'ordre n de l'unisson a n notes, pour n allant de 2 a 8 | def Normalisation(self):
""" Calcule la concordance d'ordre n de l'unisson a n notes, pour n allant de 2 a 8"""
self.normalisation[0] = np.sum(self.spectre(100)*self.spectre(100))
self.normalisation[1] = (np.sum(self.spectre(100)*self.spectre(100)*self.spectre(100)))**(2/3)
self.normalisation[2] = (np.sum(self.spectre(100)*self.spectre(100)*self.spectre(100)*self.spectre(100)))**(2/4)
self.normalisation[3] = (np.sum(self.spectre(100)*self.spectre(100)*self.spectre(100)*self.spectre(100)*self.spectre(100)))**(2/5)
self.normalisation[4] = (np.sum(self.spectre(100)*self.spectre(100)*self.spectre(100)*self.spectre(100)*self.spectre(100)*self.spectre(100)))**(2/6)
self.normalisation[5] = (np.sum(self.spectre(100)*self.spectre(100)*self.spectre(100)*self.spectre(100)*self.spectre(100)*self.spectre(100)*self.spectre(100)))**(2/7)
self.normalisation[6] = (np.sum(self.spectre(100)*self.spectre(100)*self.spectre(100)*self.spectre(100)*self.spectre(100)*self.spectre(100)*self.spectre(100)*self.spectre(100)))**(2/8) | [
"def",
"Normalisation",
"(",
"self",
")",
":",
"self",
".",
"normalisation",
"[",
"0",
"]",
"=",
"np",
".",
"sum",
"(",
"self",
".",
"spectre",
"(",
"100",
")",
"*",
"self",
".",
"spectre",
"(",
"100",
")",
")",
"self",
".",
"normalisation",
"[",
"1",
"]",
"=",
"(",
"np",
".",
"sum",
"(",
"self",
".",
"spectre",
"(",
"100",
")",
"*",
"self",
".",
"spectre",
"(",
"100",
")",
"*",
"self",
".",
"spectre",
"(",
"100",
")",
")",
")",
"**",
"(",
"2",
"/",
"3",
")",
"self",
".",
"normalisation",
"[",
"2",
"]",
"=",
"(",
"np",
".",
"sum",
"(",
"self",
".",
"spectre",
"(",
"100",
")",
"*",
"self",
".",
"spectre",
"(",
"100",
")",
"*",
"self",
".",
"spectre",
"(",
"100",
")",
"*",
"self",
".",
"spectre",
"(",
"100",
")",
")",
")",
"**",
"(",
"2",
"/",
"4",
")",
"self",
".",
"normalisation",
"[",
"3",
"]",
"=",
"(",
"np",
".",
"sum",
"(",
"self",
".",
"spectre",
"(",
"100",
")",
"*",
"self",
".",
"spectre",
"(",
"100",
")",
"*",
"self",
".",
"spectre",
"(",
"100",
")",
"*",
"self",
".",
"spectre",
"(",
"100",
")",
"*",
"self",
".",
"spectre",
"(",
"100",
")",
")",
")",
"**",
"(",
"2",
"/",
"5",
")",
"self",
".",
"normalisation",
"[",
"4",
"]",
"=",
"(",
"np",
".",
"sum",
"(",
"self",
".",
"spectre",
"(",
"100",
")",
"*",
"self",
".",
"spectre",
"(",
"100",
")",
"*",
"self",
".",
"spectre",
"(",
"100",
")",
"*",
"self",
".",
"spectre",
"(",
"100",
")",
"*",
"self",
".",
"spectre",
"(",
"100",
")",
"*",
"self",
".",
"spectre",
"(",
"100",
")",
")",
")",
"**",
"(",
"2",
"/",
"6",
")",
"self",
".",
"normalisation",
"[",
"5",
"]",
"=",
"(",
"np",
".",
"sum",
"(",
"self",
".",
"spectre",
"(",
"100",
")",
"*",
"self",
".",
"spectre",
"(",
"100",
")",
"*",
"self",
".",
"spectre",
"(",
"100",
")",
"*",
"self",
".",
"spectre",
"(",
"100",
")",
"*",
"self",
".",
"spectre",
"(",
"100",
")",
"*",
"self",
".",
"spectre",
"(",
"100",
")",
"*",
"self",
".",
"spectre",
"(",
"100",
")",
")",
")",
"**",
"(",
"2",
"/",
"7",
")",
"self",
".",
"normalisation",
"[",
"6",
"]",
"=",
"(",
"np",
".",
"sum",
"(",
"self",
".",
"spectre",
"(",
"100",
")",
"*",
"self",
".",
"spectre",
"(",
"100",
")",
"*",
"self",
".",
"spectre",
"(",
"100",
")",
"*",
"self",
".",
"spectre",
"(",
"100",
")",
"*",
"self",
".",
"spectre",
"(",
"100",
")",
"*",
"self",
".",
"spectre",
"(",
"100",
")",
"*",
"self",
".",
"spectre",
"(",
"100",
")",
"*",
"self",
".",
"spectre",
"(",
"100",
")",
")",
")",
"**",
"(",
"2",
"/",
"8",
")"
] | [
68,
2
] | [
78,
190
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
|
CNN.save | (self) | Enregistre le modèle pour inférence dans le futur. | Enregistre le modèle pour inférence dans le futur. | def save(self):
"""Enregistre le modèle pour inférence dans le futur."""
torch.save(self.state_dict(), './models/model_' + self.name_model + '_' + str(self.input_window) + '_days_to_' + str(self.output_window) + '_hours.pt') | [
"def",
"save",
"(",
"self",
")",
":",
"torch",
".",
"save",
"(",
"self",
".",
"state_dict",
"(",
")",
",",
"'./models/model_'",
"+",
"self",
".",
"name_model",
"+",
"'_'",
"+",
"str",
"(",
"self",
".",
"input_window",
")",
"+",
"'_days_to_'",
"+",
"str",
"(",
"self",
".",
"output_window",
")",
"+",
"'_hours.pt'",
")"
] | [
75,
4
] | [
77,
159
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
|
Joueur.interface | (self) | Affiche les information (uniquement vie pour l'instant)
| Affiche les information (uniquement vie pour l'instant)
| def interface(self):
""" Affiche les information (uniquement vie pour l'instant)
"""
pg.draw.rect(cp.ecran, (105, 0, 0), pg.Rect(0, 0, self.vie*20, 10))
police = pg.font.SysFont("arial", 10)
texte = police.render("Vie", True, (255, 255, 255))
cp.ecran.blit(texte, (0,-2)) | [
"def",
"interface",
"(",
"self",
")",
":",
"pg",
".",
"draw",
".",
"rect",
"(",
"cp",
".",
"ecran",
",",
"(",
"105",
",",
"0",
",",
"0",
")",
",",
"pg",
".",
"Rect",
"(",
"0",
",",
"0",
",",
"self",
".",
"vie",
"*",
"20",
",",
"10",
")",
")",
"police",
"=",
"pg",
".",
"font",
".",
"SysFont",
"(",
"\"arial\"",
",",
"10",
")",
"texte",
"=",
"police",
".",
"render",
"(",
"\"Vie\"",
",",
"True",
",",
"(",
"255",
",",
"255",
",",
"255",
")",
")",
"cp",
".",
"ecran",
".",
"blit",
"(",
"texte",
",",
"(",
"0",
",",
"-",
"2",
")",
")"
] | [
182,
4
] | [
188,
36
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
|
Organisation.get_members | (self) | return [e.user for e in profiles] | Retourner la liste des utilisateurs membres de l'organisation. | Retourner la liste des utilisateurs membres de l'organisation. | def get_members(self):
"""Retourner la liste des utilisateurs membres de l'organisation."""
Profile = apps.get_model(app_label='idgo_admin', model_name='Profile')
profiles = Profile.objects.filter(organisation=self, membership=True, is_active=True)
return [e.user for e in profiles] | [
"def",
"get_members",
"(",
"self",
")",
":",
"Profile",
"=",
"apps",
".",
"get_model",
"(",
"app_label",
"=",
"'idgo_admin'",
",",
"model_name",
"=",
"'Profile'",
")",
"profiles",
"=",
"Profile",
".",
"objects",
".",
"filter",
"(",
"organisation",
"=",
"self",
",",
"membership",
"=",
"True",
",",
"is_active",
"=",
"True",
")",
"return",
"[",
"e",
".",
"user",
"for",
"e",
"in",
"profiles",
"]"
] | [
284,
4
] | [
288,
41
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
recalcule_bellman_ford | (m, s, dist_a, arc_vers, queue) | Recalcule la distance minimale en considérant les successeurs de s.
m - matrice d'adjacence pondérée.
s - sommet dans les successeurs sont considérés.
dist_a - liste des distances minimales aux autres sommets.
arc_vers - liste des arcs conservés pour aller à un sommet donné.
queue - queue pour le parcours en largeur.
| Recalcule la distance minimale en considérant les successeurs de s.
m - matrice d'adjacence pondérée.
s - sommet dans les successeurs sont considérés.
dist_a - liste des distances minimales aux autres sommets.
arc_vers - liste des arcs conservés pour aller à un sommet donné.
queue - queue pour le parcours en largeur.
| def recalcule_bellman_ford(m, s, dist_a, arc_vers, queue):
"""Recalcule la distance minimale en considérant les successeurs de s.
m - matrice d'adjacence pondérée.
s - sommet dans les successeurs sont considérés.
dist_a - liste des distances minimales aux autres sommets.
arc_vers - liste des arcs conservés pour aller à un sommet donné.
queue - queue pour le parcours en largeur.
"""
adj = adjacents(m, s)
for arc in adj:
w = arc.but
if dist_a[w] == None or dist_a[w] > dist_a[s] + arc.poids:
dist_a[w] = dist_a[s] + arc.poids
arc_vers[w] = arc
if w not in queue:
queue.append(w) | [
"def",
"recalcule_bellman_ford",
"(",
"m",
",",
"s",
",",
"dist_a",
",",
"arc_vers",
",",
"queue",
")",
":",
"adj",
"=",
"adjacents",
"(",
"m",
",",
"s",
")",
"for",
"arc",
"in",
"adj",
":",
"w",
"=",
"arc",
".",
"but",
"if",
"dist_a",
"[",
"w",
"]",
"==",
"None",
"or",
"dist_a",
"[",
"w",
"]",
">",
"dist_a",
"[",
"s",
"]",
"+",
"arc",
".",
"poids",
":",
"dist_a",
"[",
"w",
"]",
"=",
"dist_a",
"[",
"s",
"]",
"+",
"arc",
".",
"poids",
"arc_vers",
"[",
"w",
"]",
"=",
"arc",
"if",
"w",
"not",
"in",
"queue",
":",
"queue",
".",
"append",
"(",
"w",
")"
] | [
171,
0
] | [
187,
31
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
|
placements_to_df | (placements, date, AVION) | return df_output | Renvoie le DataFrame associé aux passagers déjà placé et avec
la même structure que celui déjà construit dans le modèle statique.
Args:
placements (dict)
date (string)
AVION (string)
Returns:
DataFrame
| Renvoie le DataFrame associé aux passagers déjà placé et avec
la même structure que celui déjà construit dans le modèle statique. | def placements_to_df(placements, date, AVION):
"""Renvoie le DataFrame associé aux passagers déjà placé et avec
la même structure que celui déjà construit dans le modèle statique.
Args:
placements (dict)
date (string)
AVION (string)
Returns:
DataFrame
"""
df_input = read_and_preprocess(date)
list_categories = ["Femmes", "Hommes", "Enfants", "WCHR"]
categorie_to_poids = {"Femmes": 65, "Hommes": 80, "Enfants": 35, "WCHR": 70}
data = []
if len(placements) == 0:
df_output = pd.DataFrame(columns=[
"ID Groupe",
"ID Passager",
"Catégorie",
"Classe",
"Transit Time",
"Poids",
"x",
"y",
"Siège"
])
else:
for id_groupe, row in df_input.iterrows(): # Pour chaque ligne de notre instance de départ...
idx_passager = 0 # compte le numéro du passager dans le groupe
for categorie in list_categories:
for _ in range(row[categorie]): # Pour chaque passager du groupe et pour chaque catégorie...
if (id_groupe, idx_passager) in placements: # Si le passager en question a déjà été placé...
# On récupère les coordonnées de la place choisie :
x, y = placements[(id_groupe, idx_passager)]
passager_dict = {
"ID Groupe": id_groupe,
"ID Passager": idx_passager,
"Catégorie": categorie.lower() if categorie != 'WCHR' else categorie,
"Classe": row["Classe"],
"Transit Time": row["TransitTime"],
"Poids": categorie_to_poids[categorie],
"x": x,
"y": y,
"Siège": coordToSiege(x, y, AVION)
}
data.append(passager_dict)
else:
pass
idx_passager += 1
df_output = pd.DataFrame.from_records(data)
return df_output | [
"def",
"placements_to_df",
"(",
"placements",
",",
"date",
",",
"AVION",
")",
":",
"df_input",
"=",
"read_and_preprocess",
"(",
"date",
")",
"list_categories",
"=",
"[",
"\"Femmes\"",
",",
"\"Hommes\"",
",",
"\"Enfants\"",
",",
"\"WCHR\"",
"]",
"categorie_to_poids",
"=",
"{",
"\"Femmes\"",
":",
"65",
",",
"\"Hommes\"",
":",
"80",
",",
"\"Enfants\"",
":",
"35",
",",
"\"WCHR\"",
":",
"70",
"}",
"data",
"=",
"[",
"]",
"if",
"len",
"(",
"placements",
")",
"==",
"0",
":",
"df_output",
"=",
"pd",
".",
"DataFrame",
"(",
"columns",
"=",
"[",
"\"ID Groupe\"",
",",
"\"ID Passager\"",
",",
"\"Catégorie\",",
"",
"\"Classe\"",
",",
"\"Transit Time\"",
",",
"\"Poids\"",
",",
"\"x\"",
",",
"\"y\"",
",",
"\"Siège\"",
"]",
")",
"else",
":",
"for",
"id_groupe",
",",
"row",
"in",
"df_input",
".",
"iterrows",
"(",
")",
":",
"# Pour chaque ligne de notre instance de départ...",
"idx_passager",
"=",
"0",
"# compte le numéro du passager dans le groupe",
"for",
"categorie",
"in",
"list_categories",
":",
"for",
"_",
"in",
"range",
"(",
"row",
"[",
"categorie",
"]",
")",
":",
"# Pour chaque passager du groupe et pour chaque catégorie...",
"if",
"(",
"id_groupe",
",",
"idx_passager",
")",
"in",
"placements",
":",
"# Si le passager en question a déjà été placé...",
"# On récupère les coordonnées de la place choisie :",
"x",
",",
"y",
"=",
"placements",
"[",
"(",
"id_groupe",
",",
"idx_passager",
")",
"]",
"passager_dict",
"=",
"{",
"\"ID Groupe\"",
":",
"id_groupe",
",",
"\"ID Passager\"",
":",
"idx_passager",
",",
"\"Catégorie\":",
" ",
"ategorie.",
"l",
"ower(",
")",
" ",
"f ",
"ategorie ",
"= ",
"WCHR' ",
"lse ",
"ategorie,",
"",
"\"Classe\"",
":",
"row",
"[",
"\"Classe\"",
"]",
",",
"\"Transit Time\"",
":",
"row",
"[",
"\"TransitTime\"",
"]",
",",
"\"Poids\"",
":",
"categorie_to_poids",
"[",
"categorie",
"]",
",",
"\"x\"",
":",
"x",
",",
"\"y\"",
":",
"y",
",",
"\"Siège\":",
" ",
"oordToSiege(",
"x",
",",
" ",
",",
" ",
"VION)",
"",
"}",
"data",
".",
"append",
"(",
"passager_dict",
")",
"else",
":",
"pass",
"idx_passager",
"+=",
"1",
"df_output",
"=",
"pd",
".",
"DataFrame",
".",
"from_records",
"(",
"data",
")",
"return",
"df_output"
] | [
285,
0
] | [
348,
20
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
Checker.load_feed | (self) | Lecture du flux ATOM et parsing XML | Lecture du flux ATOM et parsing XML | def load_feed(self):
"""Lecture du flux ATOM et parsing XML"""
data = requests.get(self.url)
if data.status_code == 200:
self.feeddata = lxml.etree.parse(io.StringIO(data.text)) | [
"def",
"load_feed",
"(",
"self",
")",
":",
"data",
"=",
"requests",
".",
"get",
"(",
"self",
".",
"url",
")",
"if",
"data",
".",
"status_code",
"==",
"200",
":",
"self",
".",
"feeddata",
"=",
"lxml",
".",
"etree",
".",
"parse",
"(",
"io",
".",
"StringIO",
"(",
"data",
".",
"text",
")",
")"
] | [
38,
4
] | [
42,
68
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
|
parcours_sommets | (m, f) | La fonction f est appelée sur chaque sommet. | La fonction f est appelée sur chaque sommet. | def parcours_sommets(m, f):
"""La fonction f est appelée sur chaque sommet."""
for i in range(len(m)):
f(i) | [
"def",
"parcours_sommets",
"(",
"m",
",",
"f",
")",
":",
"for",
"i",
"in",
"range",
"(",
"len",
"(",
"m",
")",
")",
":",
"f",
"(",
"i",
")"
] | [
31,
0
] | [
34,
12
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
|
getFreqArray | (data, freqS, fenetre, minFreq, maxFreq) | return (t, freq[fmin:fmax], abs(np.fft.rfft(buffer, norm = 'ortho'))[:,fmin:fmax]) | renvoie la carte temps-fréquence. sous la forme (temps, frequences, mesures[temps][freq])
Prend en argumant un couple du type (timestamps, datas) où timestamp et data sont des listes
fenetre est la taille de la fenetre temporel prise autour du temps pour le calcule de la fft
freqS est la fréquence à laquelle il faut faire des fft sur le signal | renvoie la carte temps-fréquence. sous la forme (temps, frequences, mesures[temps][freq])
Prend en argumant un couple du type (timestamps, datas) où timestamp et data sont des listes
fenetre est la taille de la fenetre temporel prise autour du temps pour le calcule de la fft
freqS est la fréquence à laquelle il faut faire des fft sur le signal | def getFreqArray(data, freqS, fenetre, minFreq, maxFreq):
'''renvoie la carte temps-fréquence. sous la forme (temps, frequences, mesures[temps][freq])
Prend en argumant un couple du type (timestamps, datas) où timestamp et data sont des listes
fenetre est la taille de la fenetre temporel prise autour du temps pour le calcule de la fft
freqS est la fréquence à laquelle il faut faire des fft sur le signal '''
fen = fenetre/2
freqE = len(data[0])/(data[0][-1] - data[0][0])
n = int(fenetre*freqE)
t = np.arange(data[0][0] + fen, data[0][-1] - fen, 1./freqS)
buffer = np.zeros((len(t),n))
l = [0 for _ in range(len(t))]
for i in range(len(data[0])):
for a in range(len(t)):
if l[a] < n and (t[a] - fen < data[0][i] or n-l[a] >= len(data[0])-i):
buffer[a, l[a]] = data[1][i]
l[a] += 1
freq = np.fft.rfftfreq(n, 1./freqE)
fmin = 0
fmax = 0
for i in freq:
if i > minFreq:
break
fmin += 1
for i in freq:
fmax += 1
if i > maxFreq:
break
return (t, freq[fmin:fmax], abs(np.fft.rfft(buffer, norm = 'ortho'))[:,fmin:fmax]) | [
"def",
"getFreqArray",
"(",
"data",
",",
"freqS",
",",
"fenetre",
",",
"minFreq",
",",
"maxFreq",
")",
":",
"fen",
"=",
"fenetre",
"/",
"2",
"freqE",
"=",
"len",
"(",
"data",
"[",
"0",
"]",
")",
"/",
"(",
"data",
"[",
"0",
"]",
"[",
"-",
"1",
"]",
"-",
"data",
"[",
"0",
"]",
"[",
"0",
"]",
")",
"n",
"=",
"int",
"(",
"fenetre",
"*",
"freqE",
")",
"t",
"=",
"np",
".",
"arange",
"(",
"data",
"[",
"0",
"]",
"[",
"0",
"]",
"+",
"fen",
",",
"data",
"[",
"0",
"]",
"[",
"-",
"1",
"]",
"-",
"fen",
",",
"1.",
"/",
"freqS",
")",
"buffer",
"=",
"np",
".",
"zeros",
"(",
"(",
"len",
"(",
"t",
")",
",",
"n",
")",
")",
"l",
"=",
"[",
"0",
"for",
"_",
"in",
"range",
"(",
"len",
"(",
"t",
")",
")",
"]",
"for",
"i",
"in",
"range",
"(",
"len",
"(",
"data",
"[",
"0",
"]",
")",
")",
":",
"for",
"a",
"in",
"range",
"(",
"len",
"(",
"t",
")",
")",
":",
"if",
"l",
"[",
"a",
"]",
"<",
"n",
"and",
"(",
"t",
"[",
"a",
"]",
"-",
"fen",
"<",
"data",
"[",
"0",
"]",
"[",
"i",
"]",
"or",
"n",
"-",
"l",
"[",
"a",
"]",
">=",
"len",
"(",
"data",
"[",
"0",
"]",
")",
"-",
"i",
")",
":",
"buffer",
"[",
"a",
",",
"l",
"[",
"a",
"]",
"]",
"=",
"data",
"[",
"1",
"]",
"[",
"i",
"]",
"l",
"[",
"a",
"]",
"+=",
"1",
"freq",
"=",
"np",
".",
"fft",
".",
"rfftfreq",
"(",
"n",
",",
"1.",
"/",
"freqE",
")",
"fmin",
"=",
"0",
"fmax",
"=",
"0",
"for",
"i",
"in",
"freq",
":",
"if",
"i",
">",
"minFreq",
":",
"break",
"fmin",
"+=",
"1",
"for",
"i",
"in",
"freq",
":",
"fmax",
"+=",
"1",
"if",
"i",
">",
"maxFreq",
":",
"break",
"return",
"(",
"t",
",",
"freq",
"[",
"fmin",
":",
"fmax",
"]",
",",
"abs",
"(",
"np",
".",
"fft",
".",
"rfft",
"(",
"buffer",
",",
"norm",
"=",
"'ortho'",
")",
")",
"[",
":",
",",
"fmin",
":",
"fmax",
"]",
")"
] | [
18,
0
] | [
45,
86
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
M2CRB
Dataset Summary
M2CRB contains pairs of text and code data with multiple natural and programming language pairs. Namely: Spanish, Portuguese, German, and French, each paired with code snippets for: Python, Java, and JavaScript. The data is curated via an automated filtering pipeline from source files within The Stack followed by human verification to ensure accurate language classification I.e., humans were asked to filter out data for which natural language did not correspond to a target language.
Supported Tasks
M2CRB is a multilingual evaluation dataset for code-to-text and/or text-to-code models, both on information retrieval or conditional generation evaluations.
Currently Supported Languages
NATURAL_LANGUAGE_SET = {"es", "fr", "pt", "de"}
PROGRAMMING_LANGUAGE_SET = {"python", "java", "javascript"}
How to get the data with a given language combination
from datasets import load_dataset
def get_dataset(prog_lang, nat_lang):
test_data = load_dataset("blindsubmissions/M2CRB")
test_data = test_data.filter(
lambda example: example["docstring_language"] == nat_lang
and example["language"] == prog_lang
)
return test_data
Dataset Structure
Data Instances
Each data instance corresponds to function/methods occurring in licensed files that compose The Stack. That is, files with permissive licences collected from GitHub.
Relevant Data Fields
- identifier (string): Function/method name.
- parameters (string): Function parameters.
- return_statement (string): Return statement if found during parsing.
- docstring (string): Complete docstring content.
- docstring_summary (string): Summary/processed docstring dropping args and return statements.
- function (string): Actual function/method content.
- argument_list (null): List of arguments.
- language (string): Programming language of the function.
- docstring_language (string): Natural language of the docstring.
- type (string): Return type if found during parsing.
Summary of data curation pipeline
- Filtering out repositories that appear in CodeSearchNet.
- Filtering the files that belong to the programming languages of interest.
- Pre-filtering the files that likely contain text in the natural languages of interest.
- AST parsing with Tree-sitter.
- Perform language identification of docstrings in the resulting set of functions/methods.
- Perform human verification/validation of the underlying language of docstrings.
Social Impact of the dataset
M2CRB is released with the aim to increase the coverage of the NLP for code research community by providing data from scarce combinations of languages. We expect this data to help enable more accurate information retrieval systems and text-to-code or code-to-text summarization on languages other than English.
As a subset of The Stack, this dataset inherits de-risking efforts carried out when that dataset was built, though we highlight risks exist and malicious use of the data could exist such as, for instance, to aid on creation of malicious code. We highlight however that this is a risk shared by any code dataset made openly available.
Moreover, we remark that while unlikely due to human filtering, the data may contain harmful or offensive language, which could be learned by the models.
Discussion of Biases
The data is collected from GitHub and naturally occurring text on that platform. As a consequence, certain language combinations are more or less likely to contain well documented code and, as such, resulting data will not be uniformly represented in terms of their natural and programing languages.
Known limitations
While we cover 16 scarce combinations of programming and natural languages, our evaluation dataset can be expanded to further improve its coverage. Moreover, we use text naturally occurring as comments or docstrings as opposed to human annotators. As such, resulting data will have high variance in terms of quality and depending on practices of sub-communities of software developers. However, we remark that the task our evaluation dataset defines is reflective of what searching on a real codebase would look like. Finally, we note that some imbalance on data is observed due to the same reason since certain language combinations are more or less likely to contain well documented code.
Maintenance plan:
The data will be kept up to date by following The Stack releases. We should rerun our pipeline for every new release and add non-overlapping new content to both training and testing partitions of our data.
This is so that we carry over opt-out updates and include fresh repos.
Update plan:
Short term:
- Cover all 6 programming languages from CodeSearchNet.
Long-term
- Add an extra test set containing human-generated text/code pairs so the gap between in-the-wild and controlled performances can be measured.
- Include extra natural languages.
Licensing Information
M2CRB is a subset filtered and pre-processed from The Stack, a collection of source code from repositories with various licenses. Any use of all or part of the code gathered in M2CRB must abide by the terms of the original licenses.
- Downloads last month
- 33