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&param=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&param=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&param=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&param=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
Edit dataset card