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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
v | (n, p) | return s | formule de Legendre: exposant de p dans n! | formule de Legendre: exposant de p dans n! | def v(n, p):
""" formule de Legendre: exposant de p dans n! """
# https://fr.wikipedia.org/wiki/Formule_de_Legendre
s = 0
while n != 0:
n //= p
s += n
return s | [
"def",
"v",
"(",
"n",
",",
"p",
")",
":",
"# https://fr.wikipedia.org/wiki/Formule_de_Legendre",
"s",
"=",
"0",
"while",
"n",
"!=",
"0",
":",
"n",
"//=",
"p",
"s",
"+=",
"n",
"return",
"s"
] | [
84,
0
] | [
91,
12
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
parcourt_arbre | (arbre, f) | Appelle f(noeud.valeur) pour chaque noeud de l'arbre. | Appelle f(noeud.valeur) pour chaque noeud de l'arbre. | def parcourt_arbre(arbre, f):
"""Appelle f(noeud.valeur) pour chaque noeud de l'arbre."""
def parcourt_arbre_recursif(noeud, f):
if noeud != None:
f(noeud.valeur)
parcourt_arbre_recursif(noeud.gauche, f)
parcourt_arbre_recursif(noeud.droite, f)
parcourt_arbre_recursif(arbre.noeud, f) | [
"def",
"parcourt_arbre",
"(",
"arbre",
",",
"f",
")",
":",
"def",
"parcourt_arbre_recursif",
"(",
"noeud",
",",
"f",
")",
":",
"if",
"noeud",
"!=",
"None",
":",
"f",
"(",
"noeud",
".",
"valeur",
")",
"parcourt_arbre_recursif",
"(",
"noeud",
".",
"gauche",
",",
"f",
")",
"parcourt_arbre_recursif",
"(",
"noeud",
".",
"droite",
",",
"f",
")",
"parcourt_arbre_recursif",
"(",
"arbre",
".",
"noeud",
",",
"f",
")"
] | [
91,
0
] | [
99,
43
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
|
make_incrementor | (n) | return lambda x: x + n | Fonction d'incrémentation.
Retourne une fonction qui incrémente n.
| Fonction d'incrémentation. | def make_incrementor(n):
"""Fonction d'incrémentation.
Retourne une fonction qui incrémente n.
"""
return lambda x: x + n | [
"def",
"make_incrementor",
"(",
"n",
")",
":",
"return",
"lambda",
"x",
":",
"x",
"+",
"n"
] | [
8,
0
] | [
13,
26
] | null | python | fr | ['fr', 'fr', 'fr'] | False | true | null |
Accord.ListeConcordanceDesIntervallesDansAccord | (self) | Cree la liste des concordances des intervalles qui constituent l'accord, et le fixe comme parametre, ceci afin d'eviter
les redondances dans les calculs de la concordance | Cree la liste des concordances des intervalles qui constituent l'accord, et le fixe comme parametre, ceci afin d'eviter
les redondances dans les calculs de la concordance | def ListeConcordanceDesIntervallesDansAccord(self):
'''Cree la liste des concordances des intervalles qui constituent l'accord, et le fixe comme parametre, ceci afin d'eviter
les redondances dans les calculs de la concordance '''
for i, pitch1 in enumerate(self.listeHauteursAvecMultiplicite):
for j, pitch2 in enumerate(self.listeHauteursAvecMultiplicite):
if (i<j):
self.listeConcordanceDesIntervallesDansAccord.append(np.sum(self.spectre(self.frequenceAvecTemperament(pitch1))*self.spectre(self.frequenceAvecTemperament(pitch2)))) | [
"def",
"ListeConcordanceDesIntervallesDansAccord",
"(",
"self",
")",
":",
"for",
"i",
",",
"pitch1",
"in",
"enumerate",
"(",
"self",
".",
"listeHauteursAvecMultiplicite",
")",
":",
"for",
"j",
",",
"pitch2",
"in",
"enumerate",
"(",
"self",
".",
"listeHauteursAvecMultiplicite",
")",
":",
"if",
"(",
"i",
"<",
"j",
")",
":",
"self",
".",
"listeConcordanceDesIntervallesDansAccord",
".",
"append",
"(",
"np",
".",
"sum",
"(",
"self",
".",
"spectre",
"(",
"self",
".",
"frequenceAvecTemperament",
"(",
"pitch1",
")",
")",
"*",
"self",
".",
"spectre",
"(",
"self",
".",
"frequenceAvecTemperament",
"(",
"pitch2",
")",
")",
")",
")"
] | [
324,
2
] | [
332,
183
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
|
source_code | () | attributions : option "Code Source" du sous menu "Aide" (ligne afpt.)
description : ouvre à l'aide du module webbrowser le lien vers le dépot github | attributions : option "Code Source" du sous menu "Aide" (ligne afpt.)
description : ouvre à l'aide du module webbrowser le lien vers le dépot github | def source_code():
"""attributions : option "Code Source" du sous menu "Aide" (ligne afpt.)
description : ouvre à l'aide du module webbrowser le lien vers le dépot github"""
web.open_new_tab('https://github.com/AXXIAR/PhotoShapy') | [
"def",
"source_code",
"(",
")",
":",
"web",
".",
"open_new_tab",
"(",
"'https://github.com/AXXIAR/PhotoShapy'",
")"
] | [
272,
0
] | [
276,
60
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
|
res_partner.get_leave_dates | (self, partner, avec_jours_feries=False) | return leave_dates | Retourner les jours de congés du partner
| Retourner les jours de congés du partner
| def get_leave_dates(self, partner, avec_jours_feries=False):
""" Retourner les jours de congés du partner
"""
leave_dates = []
if partner.calendar_line:
for line in partner.calendar_line:
delta = datetime.datetime.strptime(line.date_to, DATETIME_FORMAT) - datetime.datetime.strptime(line.date_from, DATETIME_FORMAT)
for i in range(delta.days + 1):
date = datetime.datetime.strptime(line.date_from, DATETIME_FORMAT) + datetime.timedelta(days=i)
leave_dates.append(date.strftime('%Y-%m-%d'))
if avec_jours_feries:
jours_feries=self.get_jours_feries(partner)
for date in jours_feries:
if date not in leave_dates:
leave_dates.append(date)
return leave_dates | [
"def",
"get_leave_dates",
"(",
"self",
",",
"partner",
",",
"avec_jours_feries",
"=",
"False",
")",
":",
"leave_dates",
"=",
"[",
"]",
"if",
"partner",
".",
"calendar_line",
":",
"for",
"line",
"in",
"partner",
".",
"calendar_line",
":",
"delta",
"=",
"datetime",
".",
"datetime",
".",
"strptime",
"(",
"line",
".",
"date_to",
",",
"DATETIME_FORMAT",
")",
"-",
"datetime",
".",
"datetime",
".",
"strptime",
"(",
"line",
".",
"date_from",
",",
"DATETIME_FORMAT",
")",
"for",
"i",
"in",
"range",
"(",
"delta",
".",
"days",
"+",
"1",
")",
":",
"date",
"=",
"datetime",
".",
"datetime",
".",
"strptime",
"(",
"line",
".",
"date_from",
",",
"DATETIME_FORMAT",
")",
"+",
"datetime",
".",
"timedelta",
"(",
"days",
"=",
"i",
")",
"leave_dates",
".",
"append",
"(",
"date",
".",
"strftime",
"(",
"'%Y-%m-%d'",
")",
")",
"if",
"avec_jours_feries",
":",
"jours_feries",
"=",
"self",
".",
"get_jours_feries",
"(",
"partner",
")",
"for",
"date",
"in",
"jours_feries",
":",
"if",
"date",
"not",
"in",
"leave_dates",
":",
"leave_dates",
".",
"append",
"(",
"date",
")",
"return",
"leave_dates"
] | [
308,
4
] | [
323,
26
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
gagnant_colonne | (lig, col, grille) | return | Renvoie True si le coup joué (lig,col) forme une colonne de 4 jetons
False sinon
| Renvoie True si le coup joué (lig,col) forme une colonne de 4 jetons
False sinon
| def gagnant_colonne(lig, col, grille):
"""Renvoie True si le coup joué (lig,col) forme une colonne de 4 jetons
False sinon
"""
return | [
"def",
"gagnant_colonne",
"(",
"lig",
",",
"col",
",",
"grille",
")",
":",
"return"
] | [
62,
0
] | [
66,
10
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
Map.vider_monstres | (self) | Supprime tout les monstres
Utilisé lors d'un changement de map
| Supprime tout les monstres
Utilisé lors d'un changement de map
| def vider_monstres(self):
""" Supprime tout les monstres
Utilisé lors d'un changement de map
"""
cp.entites_liste = [] | [
"def",
"vider_monstres",
"(",
"self",
")",
":",
"cp",
".",
"entites_liste",
"=",
"[",
"]"
] | [
154,
4
] | [
158,
29
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
|
Detecte_pic | (L,ndigits=2) | return List | Fonction qui renvois la liste des pics observé dans un array d'opinion
Argument :
L: np.array des opinions
ndigits : précision de détection des pics (valeur par défaut ndigit=2)
Sortie : liste de la valeurs des pics observés | Fonction qui renvois la liste des pics observé dans un array d'opinion | def Detecte_pic(L,ndigits=2):
'''Fonction qui renvois la liste des pics observé dans un array d'opinion
Argument :
L: np.array des opinions
ndigits : précision de détection des pics (valeur par défaut ndigit=2)
Sortie : liste de la valeurs des pics observés'''
List=[]
L=L.flatten()
for car in L :
car=np.round(car,decimals=ndigits)
if (not car in List) :
List.append(car)
return List | [
"def",
"Detecte_pic",
"(",
"L",
",",
"ndigits",
"=",
"2",
")",
":",
"List",
"=",
"[",
"]",
"L",
"=",
"L",
".",
"flatten",
"(",
")",
"for",
"car",
"in",
"L",
":",
"car",
"=",
"np",
".",
"round",
"(",
"car",
",",
"decimals",
"=",
"ndigits",
")",
"if",
"(",
"not",
"car",
"in",
"List",
")",
":",
"List",
".",
"append",
"(",
"car",
")",
"return",
"List"
] | [
217,
0
] | [
232,
15
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
english_to_norvegian | (english_text) | return norvegien_text | traduit anglais en norvegien | traduit anglais en norvegien | def english_to_norvegian(english_text):
""" traduit anglais en norvegien"""
if english_text is None:
norvegien_text=None
else:
l_t = get_language_translator(apikey, version, url)
translation = l_t.translate(
text=english_text,
model_id='en-nb').get_result()
norvegien_text = translation['translations'][0]['translation']
return norvegien_text | [
"def",
"english_to_norvegian",
"(",
"english_text",
")",
":",
"if",
"english_text",
"is",
"None",
":",
"norvegien_text",
"=",
"None",
"else",
":",
"l_t",
"=",
"get_language_translator",
"(",
"apikey",
",",
"version",
",",
"url",
")",
"translation",
"=",
"l_t",
".",
"translate",
"(",
"text",
"=",
"english_text",
",",
"model_id",
"=",
"'en-nb'",
")",
".",
"get_result",
"(",
")",
"norvegien_text",
"=",
"translation",
"[",
"'translations'",
"]",
"[",
"0",
"]",
"[",
"'translation'",
"]",
"return",
"norvegien_text"
] | [
58,
0
] | [
68,
25
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
supprime_noeud | (arbre, valeur) | Supprime le noeud avec la valeur indiquée. | Supprime le noeud avec la valeur indiquée. | def supprime_noeud(arbre, valeur):
"""Supprime le noeud avec la valeur indiquée."""
# On cherche le noeud à supprimer
noeud = arbre.noeud
precedent = None
precedent_direction = GAUCHE
while True:
if noeud == None:
raise ValueError("Erreur : valeur non trouvée")
# On vient de trouver le noeud à supprimer
if noeud.valeur == valeur:
effectue_la_suppression(arbre, precedent, precedent_direction, noeud)
# Fin de la recherche
break
# On passe à la suite dans la recherche
if valeur < noeud.valeur:
precedent = noeud
precedent_direction = GAUCHE
noeud = noeud.gauche
else:
precedent = noeud
precedent_direction = DROITE
noeud = noeud.droite | [
"def",
"supprime_noeud",
"(",
"arbre",
",",
"valeur",
")",
":",
"# On cherche le noeud à supprimer",
"noeud",
"=",
"arbre",
".",
"noeud",
"precedent",
"=",
"None",
"precedent_direction",
"=",
"GAUCHE",
"while",
"True",
":",
"if",
"noeud",
"==",
"None",
":",
"raise",
"ValueError",
"(",
"\"Erreur : valeur non trouvée\")",
"",
"# On vient de trouver le noeud à supprimer",
"if",
"noeud",
".",
"valeur",
"==",
"valeur",
":",
"effectue_la_suppression",
"(",
"arbre",
",",
"precedent",
",",
"precedent_direction",
",",
"noeud",
")",
"# Fin de la recherche",
"break",
"# On passe à la suite dans la recherche",
"if",
"valeur",
"<",
"noeud",
".",
"valeur",
":",
"precedent",
"=",
"noeud",
"precedent_direction",
"=",
"GAUCHE",
"noeud",
"=",
"noeud",
".",
"gauche",
"else",
":",
"precedent",
"=",
"noeud",
"precedent_direction",
"=",
"DROITE",
"noeud",
"=",
"noeud",
".",
"droite"
] | [
231,
0
] | [
256,
32
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
|
WindowClient.addmessage | (self, message, separator="\n") | Ajoute un message complet à celui déjà présent
dans la fenêtre | Ajoute un message complet à celui déjà présent
dans la fenêtre | def addmessage(self, message, separator="\n") :
""" Ajoute un message complet à celui déjà présent
dans la fenêtre"""
self.message = "{}{}{}".format(self.message, separator, message)
self.textupdate() | [
"def",
"addmessage",
"(",
"self",
",",
"message",
",",
"separator",
"=",
"\"\\n\"",
")",
":",
"self",
".",
"message",
"=",
"\"{}{}{}\"",
".",
"format",
"(",
"self",
".",
"message",
",",
"separator",
",",
"message",
")",
"self",
".",
"textupdate",
"(",
")"
] | [
66,
4
] | [
70,
25
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
|
curve_function | (f, lambd, hmax) | return copy_f | Retourne le polynôme de f(x) appliqué à lambda (partie supérieure de l'aile) | Retourne le polynôme de f(x) appliqué à lambda (partie supérieure de l'aile) | def curve_function(f, lambd, hmax):
""" Retourne le polynôme de f(x) appliqué à lambda (partie supérieure de l'aile)"""
copy_f = []
for i in range (len(f)):
copy_f.append((np.poly1d((1-lambd) * f[i]) + lambd*3*hmax))
return copy_f | [
"def",
"curve_function",
"(",
"f",
",",
"lambd",
",",
"hmax",
")",
":",
"copy_f",
"=",
"[",
"]",
"for",
"i",
"in",
"range",
"(",
"len",
"(",
"f",
")",
")",
":",
"copy_f",
".",
"append",
"(",
"(",
"np",
".",
"poly1d",
"(",
"(",
"1",
"-",
"lambd",
")",
"*",
"f",
"[",
"i",
"]",
")",
"+",
"lambd",
"*",
"3",
"*",
"hmax",
")",
")",
"return",
"copy_f"
] | [
36,
0
] | [
41,
15
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
sum_3_5 | (n) | return 3 * t(n // 3) + 5 * t(n // 5) - 15 * t(n // 15) | somme des multiples de 3, de 5, en enlevant ceux de 3*5 (déjà comptés) | somme des multiples de 3, de 5, en enlevant ceux de 3*5 (déjà comptés) | def sum_3_5(n):
""" somme des multiples de 3, de 5, en enlevant ceux de 3*5 (déjà comptés) """
return 3 * t(n // 3) + 5 * t(n // 5) - 15 * t(n // 15) | [
"def",
"sum_3_5",
"(",
"n",
")",
":",
"return",
"3",
"*",
"t",
"(",
"n",
"//",
"3",
")",
"+",
"5",
"*",
"t",
"(",
"n",
"//",
"5",
")",
"-",
"15",
"*",
"t",
"(",
"n",
"//",
"15",
")"
] | [
14,
0
] | [
16,
58
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
Admin.admin_sconfig_see | (self, ctx: MyContext, guild: discord.Guild, option=None) | Affiche les options d'un serveur | Affiche les options d'un serveur | async def admin_sconfig_see(self, ctx: MyContext, guild: discord.Guild, option=None):
"""Affiche les options d'un serveur"""
if not ctx.bot.database_online:
await ctx.send("Impossible d'afficher cette commande, la base de donnée est hors ligne :confused:")
return
try:
await self.bot.get_cog("Servers").send_see(guild,ctx.channel,option,ctx.message,guild)
except Exception as e:
await self.bot.get_cog("Errors").on_command_error(ctx,e)
else:
await ctx.send("Serveur introuvable") | [
"async",
"def",
"admin_sconfig_see",
"(",
"self",
",",
"ctx",
":",
"MyContext",
",",
"guild",
":",
"discord",
".",
"Guild",
",",
"option",
"=",
"None",
")",
":",
"if",
"not",
"ctx",
".",
"bot",
".",
"database_online",
":",
"await",
"ctx",
".",
"send",
"(",
"\"Impossible d'afficher cette commande, la base de donnée est hors ligne :confused:\")",
"",
"return",
"try",
":",
"await",
"self",
".",
"bot",
".",
"get_cog",
"(",
"\"Servers\"",
")",
".",
"send_see",
"(",
"guild",
",",
"ctx",
".",
"channel",
",",
"option",
",",
"ctx",
".",
"message",
",",
"guild",
")",
"except",
"Exception",
"as",
"e",
":",
"await",
"self",
".",
"bot",
".",
"get_cog",
"(",
"\"Errors\"",
")",
".",
"on_command_error",
"(",
"ctx",
",",
"e",
")",
"else",
":",
"await",
"ctx",
".",
"send",
"(",
"\"Serveur introuvable\"",
")"
] | [
395,
4
] | [
405,
49
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
|
is_cout_calcul.action_calcul_prix_achat2 | (self) | Fonction initiale appellée au début du calcul | Fonction initiale appellée au début du calcul | def action_calcul_prix_achat2(self):
"""Fonction initiale appellée au début du calcul"""
self.action_calcul_prix_achat_thread() | [
"def",
"action_calcul_prix_achat2",
"(",
"self",
")",
":",
"self",
".",
"action_calcul_prix_achat_thread",
"(",
")"
] | [
385,
4
] | [
387,
46
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
|
Admin.send_updates | (self, ctx:MyContext) | Lance un message de mise à jour | Lance un message de mise à jour | async def send_updates(self, ctx:MyContext):
"""Lance un message de mise à jour"""
if self.bot.zombie_mode:
return
if None in self.update.values():
return await ctx.send("Les textes ne sont pas complets !")
text = "Vos messages contiennent"
msg = None
if max([len(x) for x in self.update.values()]) > 1900//len(self.update.keys()):
for k,v in self.update.items():
text += "\n{}:``\n{}\n```".format(k,v)
msg = await ctx.send(text)
text = ''
else:
text += "\n"+"\n".join(["{}:\n```\n{}\n```".format(k,v) for k,v in self.update.items()])
msg = await ctx.send(text)
if not msg:
return
await ctx.bot.get_cog('Utilities').add_check_reaction(msg)
def check(reaction, user):
return user == ctx.author and reaction.message.id==msg.id
try:
await self.bot.wait_for('reaction_add', timeout=30.0, check=check)
except asyncio.TimeoutError:
return await ctx.send('Trop long !')
count = 0
for guild in ctx.bot.guilds:
channels = await ctx.bot.get_config(guild.id,'bot_news')
if channels is None or len(channels) == 0:
continue
channels = [guild.get_channel(int(x)) for x in channels.split(';') if len(x)>5 and x.isnumeric()]
lang = await ctx.bot.get_config(guild.id,'language')
if type(lang)!=int:
lang = 0
lang = ctx.bot.get_cog('Languages').languages[lang]
if lang not in self.update.keys():
lang = 'en'
mentions_str = await self.bot.get_config(guild.id,'update_mentions')
if mentions_str is None:
mentions = []
else:
mentions = []
for r in mentions_str.split(';'):
try:
mentions.append(guild.get_role(int(r)))
except:
pass
mentions = [x.mention for x in mentions if x is not None]
for chan in channels:
if chan is None:
continue
try:
await chan.send(self.update[lang]+"\n\n"+" ".join(mentions), allowed_mentions=discord.AllowedMentions(everyone=False, roles=True))
except Exception as e:
await ctx.bot.get_cog('Errors').on_error(e,ctx)
else:
count += 1
if guild.id == 356067272730607628:
fr_chan = guild.get_channel(494870602146906113)
if fr_chan not in channels:
await fr_chan.send(self.update['fr']+"\n\n"+" ".join(mentions), allowed_mentions=discord.AllowedMentions(everyone=False, roles=True))
count += 1
await ctx.send("Message envoyé dans {} salons !".format(count))
# add changelog in the database
cnx = self.bot.cnx_frm
cursor = cnx.cursor()
version = self.bot.get_cog('Info').bot_version
query = "INSERT INTO `changelogs` (`version`, `release_date`, `fr`, `en`, `beta`) VALUES (%(v)s, %(r)s, %(fr)s, %(en)s, %(b)s) ON DUPLICATE KEY UPDATE `fr` = '%(fr)s', `en` = '%(en)s';"
cursor.execute(query, { 'v': version, 'r': ctx.message.created_at, 'fr': self.update['fr'], 'en': self.update['en'], 'b': self.bot.beta })
cnx.commit()
cursor.close()
for k in self.update.keys():
self.update[k] = None | [
"async",
"def",
"send_updates",
"(",
"self",
",",
"ctx",
":",
"MyContext",
")",
":",
"if",
"self",
".",
"bot",
".",
"zombie_mode",
":",
"return",
"if",
"None",
"in",
"self",
".",
"update",
".",
"values",
"(",
")",
":",
"return",
"await",
"ctx",
".",
"send",
"(",
"\"Les textes ne sont pas complets !\"",
")",
"text",
"=",
"\"Vos messages contiennent\"",
"msg",
"=",
"None",
"if",
"max",
"(",
"[",
"len",
"(",
"x",
")",
"for",
"x",
"in",
"self",
".",
"update",
".",
"values",
"(",
")",
"]",
")",
">",
"1900",
"//",
"len",
"(",
"self",
".",
"update",
".",
"keys",
"(",
")",
")",
":",
"for",
"k",
",",
"v",
"in",
"self",
".",
"update",
".",
"items",
"(",
")",
":",
"text",
"+=",
"\"\\n{}:``\\n{}\\n```\"",
".",
"format",
"(",
"k",
",",
"v",
")",
"msg",
"=",
"await",
"ctx",
".",
"send",
"(",
"text",
")",
"text",
"=",
"''",
"else",
":",
"text",
"+=",
"\"\\n\"",
"+",
"\"\\n\"",
".",
"join",
"(",
"[",
"\"{}:\\n```\\n{}\\n```\"",
".",
"format",
"(",
"k",
",",
"v",
")",
"for",
"k",
",",
"v",
"in",
"self",
".",
"update",
".",
"items",
"(",
")",
"]",
")",
"msg",
"=",
"await",
"ctx",
".",
"send",
"(",
"text",
")",
"if",
"not",
"msg",
":",
"return",
"await",
"ctx",
".",
"bot",
".",
"get_cog",
"(",
"'Utilities'",
")",
".",
"add_check_reaction",
"(",
"msg",
")",
"def",
"check",
"(",
"reaction",
",",
"user",
")",
":",
"return",
"user",
"==",
"ctx",
".",
"author",
"and",
"reaction",
".",
"message",
".",
"id",
"==",
"msg",
".",
"id",
"try",
":",
"await",
"self",
".",
"bot",
".",
"wait_for",
"(",
"'reaction_add'",
",",
"timeout",
"=",
"30.0",
",",
"check",
"=",
"check",
")",
"except",
"asyncio",
".",
"TimeoutError",
":",
"return",
"await",
"ctx",
".",
"send",
"(",
"'Trop long !'",
")",
"count",
"=",
"0",
"for",
"guild",
"in",
"ctx",
".",
"bot",
".",
"guilds",
":",
"channels",
"=",
"await",
"ctx",
".",
"bot",
".",
"get_config",
"(",
"guild",
".",
"id",
",",
"'bot_news'",
")",
"if",
"channels",
"is",
"None",
"or",
"len",
"(",
"channels",
")",
"==",
"0",
":",
"continue",
"channels",
"=",
"[",
"guild",
".",
"get_channel",
"(",
"int",
"(",
"x",
")",
")",
"for",
"x",
"in",
"channels",
".",
"split",
"(",
"';'",
")",
"if",
"len",
"(",
"x",
")",
">",
"5",
"and",
"x",
".",
"isnumeric",
"(",
")",
"]",
"lang",
"=",
"await",
"ctx",
".",
"bot",
".",
"get_config",
"(",
"guild",
".",
"id",
",",
"'language'",
")",
"if",
"type",
"(",
"lang",
")",
"!=",
"int",
":",
"lang",
"=",
"0",
"lang",
"=",
"ctx",
".",
"bot",
".",
"get_cog",
"(",
"'Languages'",
")",
".",
"languages",
"[",
"lang",
"]",
"if",
"lang",
"not",
"in",
"self",
".",
"update",
".",
"keys",
"(",
")",
":",
"lang",
"=",
"'en'",
"mentions_str",
"=",
"await",
"self",
".",
"bot",
".",
"get_config",
"(",
"guild",
".",
"id",
",",
"'update_mentions'",
")",
"if",
"mentions_str",
"is",
"None",
":",
"mentions",
"=",
"[",
"]",
"else",
":",
"mentions",
"=",
"[",
"]",
"for",
"r",
"in",
"mentions_str",
".",
"split",
"(",
"';'",
")",
":",
"try",
":",
"mentions",
".",
"append",
"(",
"guild",
".",
"get_role",
"(",
"int",
"(",
"r",
")",
")",
")",
"except",
":",
"pass",
"mentions",
"=",
"[",
"x",
".",
"mention",
"for",
"x",
"in",
"mentions",
"if",
"x",
"is",
"not",
"None",
"]",
"for",
"chan",
"in",
"channels",
":",
"if",
"chan",
"is",
"None",
":",
"continue",
"try",
":",
"await",
"chan",
".",
"send",
"(",
"self",
".",
"update",
"[",
"lang",
"]",
"+",
"\"\\n\\n\"",
"+",
"\" \"",
".",
"join",
"(",
"mentions",
")",
",",
"allowed_mentions",
"=",
"discord",
".",
"AllowedMentions",
"(",
"everyone",
"=",
"False",
",",
"roles",
"=",
"True",
")",
")",
"except",
"Exception",
"as",
"e",
":",
"await",
"ctx",
".",
"bot",
".",
"get_cog",
"(",
"'Errors'",
")",
".",
"on_error",
"(",
"e",
",",
"ctx",
")",
"else",
":",
"count",
"+=",
"1",
"if",
"guild",
".",
"id",
"==",
"356067272730607628",
":",
"fr_chan",
"=",
"guild",
".",
"get_channel",
"(",
"494870602146906113",
")",
"if",
"fr_chan",
"not",
"in",
"channels",
":",
"await",
"fr_chan",
".",
"send",
"(",
"self",
".",
"update",
"[",
"'fr'",
"]",
"+",
"\"\\n\\n\"",
"+",
"\" \"",
".",
"join",
"(",
"mentions",
")",
",",
"allowed_mentions",
"=",
"discord",
".",
"AllowedMentions",
"(",
"everyone",
"=",
"False",
",",
"roles",
"=",
"True",
")",
")",
"count",
"+=",
"1",
"await",
"ctx",
".",
"send",
"(",
"\"Message envoyé dans {} salons !\".",
"f",
"ormat(",
"c",
"ount)",
")",
"",
"# add changelog in the database",
"cnx",
"=",
"self",
".",
"bot",
".",
"cnx_frm",
"cursor",
"=",
"cnx",
".",
"cursor",
"(",
")",
"version",
"=",
"self",
".",
"bot",
".",
"get_cog",
"(",
"'Info'",
")",
".",
"bot_version",
"query",
"=",
"\"INSERT INTO `changelogs` (`version`, `release_date`, `fr`, `en`, `beta`) VALUES (%(v)s, %(r)s, %(fr)s, %(en)s, %(b)s) ON DUPLICATE KEY UPDATE `fr` = '%(fr)s', `en` = '%(en)s';\"",
"cursor",
".",
"execute",
"(",
"query",
",",
"{",
"'v'",
":",
"version",
",",
"'r'",
":",
"ctx",
".",
"message",
".",
"created_at",
",",
"'fr'",
":",
"self",
".",
"update",
"[",
"'fr'",
"]",
",",
"'en'",
":",
"self",
".",
"update",
"[",
"'en'",
"]",
",",
"'b'",
":",
"self",
".",
"bot",
".",
"beta",
"}",
")",
"cnx",
".",
"commit",
"(",
")",
"cursor",
".",
"close",
"(",
")",
"for",
"k",
"in",
"self",
".",
"update",
".",
"keys",
"(",
")",
":",
"self",
".",
"update",
"[",
"k",
"]",
"=",
"None"
] | [
168,
4
] | [
241,
33
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
|
gen_dataset | () | Créer les deux fichier : historique_precipitation_clean.csv et projection_precipitation_clean.csv
| Créer les deux fichier : historique_precipitation_clean.csv et projection_precipitation_clean.csv
| def gen_dataset():
'''Créer les deux fichier : historique_precipitation_clean.csv et projection_precipitation_clean.csv
'''
def abreviation2nombre(abr):
lst_abr = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']
return(lst_abr.index(abr)+1)
dir_precipitation = DATASET_FOLDER+'precipitation/'
df_hist = pd.DataFrame()
df_pred = pd.DataFrame()
for i, entry in enumerate(os.scandir(dir_precipitation)):
print(f'\r{i+1}/899', end='')
if '.csv' in entry.name:
df = pd.read_csv(dir_precipitation+entry.name, sep=r', ', engine='python')
if 'historical' in entry.name:
# S'il y a un problème de vigule on nettoit le dataframe
if df.Country.all() in ['The', 'State of', 'United Republic of', 'Democratic People’s Republic of']:
df.reset_index(inplace=True)
# On récuppère le nom réel
df['new_Country'] = df[['Statistics', 'Country']].apply(lambda x: x[0]+', '+x[1], axis=1)
df.drop('Country', axis=1, inplace=True)
df.rename(columns={'index': 'Rainfall - (MM)',
'Rainfall - (MM)': 'Year',
'Year': 'Statistics',
'Statistics': 'tmp',
'new_Country': 'Country'}, inplace=True)
df.drop('tmp', axis=1, inplace=True)
df_hist = df_hist.append(df)
else:
# S'il y a un problème de vigule on nettoit le dataframe
if df.Country.all() in ['State of', 'United Republic of']:
df.reset_index(inplace=True)
# On récuppère le nom réel
df['new_Country'] = df[['Statistics', 'Country']].apply(lambda x: x[0]+', '+x[1], axis=1)
df.drop('Country', axis=1, inplace=True)
df.rename(columns={'index': 'Monthly Precipitation - (MM)',
'Monthly Precipitation - (MM)': 'Year',
'Year': 'Model',
'Model': 'Statistics',
'Statistics': 'tmp',
'new_Country': 'Country'}, inplace=True)
df.drop('tmp', axis=1, inplace=True)
df_pred = df_pred.append(df)
# On créé une variable pour pouvoir faire le tri sur les mois
df_pred['Month'] = df_pred['Statistics'].str[:4].apply(lambda x: abreviation2nombre(x.strip()))
df_pred.sort_values(['Country','Year','Model','Month'], inplace=True)
# On rajoute la variable 'Region'
add_region(df_pred)
df_pred.to_csv(f'{DATASET_FOLDER}projection_precipitation_clean.csv', index=False)
# On créé une variable pour pouvoir faire le tri sur les mois
df_hist['Month'] = df_hist['Statistics'].str[:4].apply(lambda x: abreviation2nombre(x.strip()))
# On rajoute la variable 'Region'
add_region(df_hist)
df_hist.sort_values(['Country','Year','Month'], inplace=True)
df_hist.to_csv(f'{DATASET_FOLDER}historical_precipitation_clean.csv', index=False) | [
"def",
"gen_dataset",
"(",
")",
":",
"def",
"abreviation2nombre",
"(",
"abr",
")",
":",
"lst_abr",
"=",
"[",
"'Jan'",
",",
"'Feb'",
",",
"'Mar'",
",",
"'Apr'",
",",
"'May'",
",",
"'Jun'",
",",
"'Jul'",
",",
"'Aug'",
",",
"'Sep'",
",",
"'Oct'",
",",
"'Nov'",
",",
"'Dec'",
"]",
"return",
"(",
"lst_abr",
".",
"index",
"(",
"abr",
")",
"+",
"1",
")",
"dir_precipitation",
"=",
"DATASET_FOLDER",
"+",
"'precipitation/'",
"df_hist",
"=",
"pd",
".",
"DataFrame",
"(",
")",
"df_pred",
"=",
"pd",
".",
"DataFrame",
"(",
")",
"for",
"i",
",",
"entry",
"in",
"enumerate",
"(",
"os",
".",
"scandir",
"(",
"dir_precipitation",
")",
")",
":",
"print",
"(",
"f'\\r{i+1}/899'",
",",
"end",
"=",
"''",
")",
"if",
"'.csv'",
"in",
"entry",
".",
"name",
":",
"df",
"=",
"pd",
".",
"read_csv",
"(",
"dir_precipitation",
"+",
"entry",
".",
"name",
",",
"sep",
"=",
"r', '",
",",
"engine",
"=",
"'python'",
")",
"if",
"'historical'",
"in",
"entry",
".",
"name",
":",
"# S'il y a un problème de vigule on nettoit le dataframe",
"if",
"df",
".",
"Country",
".",
"all",
"(",
")",
"in",
"[",
"'The'",
",",
"'State of'",
",",
"'United Republic of'",
",",
"'Democratic People’s Republic of']:",
"",
"",
"df",
".",
"reset_index",
"(",
"inplace",
"=",
"True",
")",
"# On récuppère le nom réel",
"df",
"[",
"'new_Country'",
"]",
"=",
"df",
"[",
"[",
"'Statistics'",
",",
"'Country'",
"]",
"]",
".",
"apply",
"(",
"lambda",
"x",
":",
"x",
"[",
"0",
"]",
"+",
"', '",
"+",
"x",
"[",
"1",
"]",
",",
"axis",
"=",
"1",
")",
"df",
".",
"drop",
"(",
"'Country'",
",",
"axis",
"=",
"1",
",",
"inplace",
"=",
"True",
")",
"df",
".",
"rename",
"(",
"columns",
"=",
"{",
"'index'",
":",
"'Rainfall - (MM)'",
",",
"'Rainfall - (MM)'",
":",
"'Year'",
",",
"'Year'",
":",
"'Statistics'",
",",
"'Statistics'",
":",
"'tmp'",
",",
"'new_Country'",
":",
"'Country'",
"}",
",",
"inplace",
"=",
"True",
")",
"df",
".",
"drop",
"(",
"'tmp'",
",",
"axis",
"=",
"1",
",",
"inplace",
"=",
"True",
")",
"df_hist",
"=",
"df_hist",
".",
"append",
"(",
"df",
")",
"else",
":",
"# S'il y a un problème de vigule on nettoit le dataframe",
"if",
"df",
".",
"Country",
".",
"all",
"(",
")",
"in",
"[",
"'State of'",
",",
"'United Republic of'",
"]",
":",
"df",
".",
"reset_index",
"(",
"inplace",
"=",
"True",
")",
"# On récuppère le nom réel",
"df",
"[",
"'new_Country'",
"]",
"=",
"df",
"[",
"[",
"'Statistics'",
",",
"'Country'",
"]",
"]",
".",
"apply",
"(",
"lambda",
"x",
":",
"x",
"[",
"0",
"]",
"+",
"', '",
"+",
"x",
"[",
"1",
"]",
",",
"axis",
"=",
"1",
")",
"df",
".",
"drop",
"(",
"'Country'",
",",
"axis",
"=",
"1",
",",
"inplace",
"=",
"True",
")",
"df",
".",
"rename",
"(",
"columns",
"=",
"{",
"'index'",
":",
"'Monthly Precipitation - (MM)'",
",",
"'Monthly Precipitation - (MM)'",
":",
"'Year'",
",",
"'Year'",
":",
"'Model'",
",",
"'Model'",
":",
"'Statistics'",
",",
"'Statistics'",
":",
"'tmp'",
",",
"'new_Country'",
":",
"'Country'",
"}",
",",
"inplace",
"=",
"True",
")",
"df",
".",
"drop",
"(",
"'tmp'",
",",
"axis",
"=",
"1",
",",
"inplace",
"=",
"True",
")",
"df_pred",
"=",
"df_pred",
".",
"append",
"(",
"df",
")",
"# On créé une variable pour pouvoir faire le tri sur les mois",
"df_pred",
"[",
"'Month'",
"]",
"=",
"df_pred",
"[",
"'Statistics'",
"]",
".",
"str",
"[",
":",
"4",
"]",
".",
"apply",
"(",
"lambda",
"x",
":",
"abreviation2nombre",
"(",
"x",
".",
"strip",
"(",
")",
")",
")",
"df_pred",
".",
"sort_values",
"(",
"[",
"'Country'",
",",
"'Year'",
",",
"'Model'",
",",
"'Month'",
"]",
",",
"inplace",
"=",
"True",
")",
"# On rajoute la variable 'Region'",
"add_region",
"(",
"df_pred",
")",
"df_pred",
".",
"to_csv",
"(",
"f'{DATASET_FOLDER}projection_precipitation_clean.csv'",
",",
"index",
"=",
"False",
")",
"# On créé une variable pour pouvoir faire le tri sur les mois",
"df_hist",
"[",
"'Month'",
"]",
"=",
"df_hist",
"[",
"'Statistics'",
"]",
".",
"str",
"[",
":",
"4",
"]",
".",
"apply",
"(",
"lambda",
"x",
":",
"abreviation2nombre",
"(",
"x",
".",
"strip",
"(",
")",
")",
")",
"# On rajoute la variable 'Region'",
"add_region",
"(",
"df_hist",
")",
"df_hist",
".",
"sort_values",
"(",
"[",
"'Country'",
",",
"'Year'",
",",
"'Month'",
"]",
",",
"inplace",
"=",
"True",
")",
"df_hist",
".",
"to_csv",
"(",
"f'{DATASET_FOLDER}historical_precipitation_clean.csv'",
",",
"index",
"=",
"False",
")"
] | [
33,
0
] | [
106,
86
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
|
Points.dot | (self, no) | return self.x * no.x + self.y * no.y + self.z * no.z | produit scalaire | produit scalaire | def dot(self, no):
""" produit scalaire """
return self.x * no.x + self.y * no.y + self.z * no.z | [
"def",
"dot",
"(",
"self",
",",
"no",
")",
":",
"return",
"self",
".",
"x",
"*",
"no",
".",
"x",
"+",
"self",
".",
"y",
"*",
"no",
".",
"y",
"+",
"self",
".",
"z",
"*",
"no",
".",
"z"
] | [
16,
4
] | [
18,
60
] | null | python | fr | ['fr', 'fr', 'fr'] | False | true | null |
dessine_son | (mem,t,fourier,ind,a,b) | dessine une partie du son, limite la taille a 512 | dessine une partie du son, limite la taille a 512 | def dessine_son(mem,t,fourier,ind,a,b):
"""dessine une partie du son, limite la taille a 512"""
m = len (mem)
if m > 256 : m = 256
x = [ i for i in xrange (ind,ind+m) ]
y1 = [ mem[i] for i in xrange (ind,ind+m) ]
y2 = [ t[i] for i in xrange (ind,ind+m) ]
pylab.figure (1)
p1 = pylab.plot (x,y1)
p2 = pylab.plot (x,y2)
pylab.title ("Fourier")
pylab.xlabel ("frequence")
pylab.ylabel ("amplitude")
pylab.legend ( ("son", "son + filtre"))
m = len (fourier)
if m > 256 : m = 256
#x = [ i for i in xrange (0,m) ]
pylab.figure (2)
x = [ i for i in xrange (0,m) ]
y1 = [ abs(fourier[i]) for i in xrange (0,m) ]
y2 = []
for i in x :
if a <= i <= b : y2.append (450000.0)
else : y2.append (0.0)
p3 = pylab.plot (x,y1)
p4 = pylab.plot (x,y2)
pylab.legend ( ("fourrier", "filtre"))
pylab.show() | [
"def",
"dessine_son",
"(",
"mem",
",",
"t",
",",
"fourier",
",",
"ind",
",",
"a",
",",
"b",
")",
":",
"m",
"=",
"len",
"(",
"mem",
")",
"if",
"m",
">",
"256",
":",
"m",
"=",
"256",
"x",
"=",
"[",
"i",
"for",
"i",
"in",
"xrange",
"(",
"ind",
",",
"ind",
"+",
"m",
")",
"]",
"y1",
"=",
"[",
"mem",
"[",
"i",
"]",
"for",
"i",
"in",
"xrange",
"(",
"ind",
",",
"ind",
"+",
"m",
")",
"]",
"y2",
"=",
"[",
"t",
"[",
"i",
"]",
"for",
"i",
"in",
"xrange",
"(",
"ind",
",",
"ind",
"+",
"m",
")",
"]",
"pylab",
".",
"figure",
"(",
"1",
")",
"p1",
"=",
"pylab",
".",
"plot",
"(",
"x",
",",
"y1",
")",
"p2",
"=",
"pylab",
".",
"plot",
"(",
"x",
",",
"y2",
")",
"pylab",
".",
"title",
"(",
"\"Fourier\"",
")",
"pylab",
".",
"xlabel",
"(",
"\"frequence\"",
")",
"pylab",
".",
"ylabel",
"(",
"\"amplitude\"",
")",
"pylab",
".",
"legend",
"(",
"(",
"\"son\"",
",",
"\"son + filtre\"",
")",
")",
"m",
"=",
"len",
"(",
"fourier",
")",
"if",
"m",
">",
"256",
":",
"m",
"=",
"256",
"#x = [ i for i in xrange (0,m) ] ",
"pylab",
".",
"figure",
"(",
"2",
")",
"x",
"=",
"[",
"i",
"for",
"i",
"in",
"xrange",
"(",
"0",
",",
"m",
")",
"]",
"y1",
"=",
"[",
"abs",
"(",
"fourier",
"[",
"i",
"]",
")",
"for",
"i",
"in",
"xrange",
"(",
"0",
",",
"m",
")",
"]",
"y2",
"=",
"[",
"]",
"for",
"i",
"in",
"x",
":",
"if",
"a",
"<=",
"i",
"<=",
"b",
":",
"y2",
".",
"append",
"(",
"450000.0",
")",
"else",
":",
"y2",
".",
"append",
"(",
"0.0",
")",
"p3",
"=",
"pylab",
".",
"plot",
"(",
"x",
",",
"y1",
")",
"p4",
"=",
"pylab",
".",
"plot",
"(",
"x",
",",
"y2",
")",
"pylab",
".",
"legend",
"(",
"(",
"\"fourrier\"",
",",
"\"filtre\"",
")",
")",
"pylab",
".",
"show",
"(",
")"
] | [
46,
0
] | [
74,
16
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
|
res_partner.get_working_day | (self, date, num_day, jours_fermes, leave_dates) | Déterminer la date d'expédition en fonction des jours de fermeture de l'usine ou des jours de congés de l'usine
| Déterminer la date d'expédition en fonction des jours de fermeture de l'usine ou des jours de congés de l'usine
| def get_working_day(self, date, num_day, jours_fermes, leave_dates):
""" Déterminer la date d'expédition en fonction des jours de fermeture de l'usine ou des jours de congés de l'usine
"""
if int(num_day) not in jours_fermes and date not in leave_dates:
return date
else:
date = datetime.datetime.strptime(date, '%Y-%m-%d') - datetime.timedelta(days=1)
date = date.strftime('%Y-%m-%d')
num_day = time.strftime('%w', time.strptime(date, '%Y-%m-%d'))
return self.get_working_day(date, num_day, jours_fermes, leave_dates) | [
"def",
"get_working_day",
"(",
"self",
",",
"date",
",",
"num_day",
",",
"jours_fermes",
",",
"leave_dates",
")",
":",
"if",
"int",
"(",
"num_day",
")",
"not",
"in",
"jours_fermes",
"and",
"date",
"not",
"in",
"leave_dates",
":",
"return",
"date",
"else",
":",
"date",
"=",
"datetime",
".",
"datetime",
".",
"strptime",
"(",
"date",
",",
"'%Y-%m-%d'",
")",
"-",
"datetime",
".",
"timedelta",
"(",
"days",
"=",
"1",
")",
"date",
"=",
"date",
".",
"strftime",
"(",
"'%Y-%m-%d'",
")",
"num_day",
"=",
"time",
".",
"strftime",
"(",
"'%w'",
",",
"time",
".",
"strptime",
"(",
"date",
",",
"'%Y-%m-%d'",
")",
")",
"return",
"self",
".",
"get_working_day",
"(",
"date",
",",
"num_day",
",",
"jours_fermes",
",",
"leave_dates",
")"
] | [
364,
4
] | [
373,
81
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
|
changeDateOfUpdate | (x: str) | Change le format de la date de mise à jour :
Paramètres
----------
x : string
Retours
-------
x : string
Exemples
-------
changeDateOfMonth('6:00:00 CT\\r\\n13 Jun 2021') -> 2021-06-13 | Change le format de la date de mise à jour : | def changeDateOfUpdate(x: str):
"""Change le format de la date de mise à jour :
Paramètres
----------
x : string
Retours
-------
x : string
Exemples
-------
changeDateOfMonth('6:00:00 CT\\r\\n13 Jun 2021') -> 2021-06-13"""
try:
return datetime.strptime(x, "%H:%M:%S CT\r\n%d %b %Y").strftime("%Y-%m-%d")
except ValueError:
return x | [
"def",
"changeDateOfUpdate",
"(",
"x",
":",
"str",
")",
":",
"try",
":",
"return",
"datetime",
".",
"strptime",
"(",
"x",
",",
"\"%H:%M:%S CT\\r\\n%d %b %Y\"",
")",
".",
"strftime",
"(",
"\"%Y-%m-%d\"",
")",
"except",
"ValueError",
":",
"return",
"x"
] | [
47,
0
] | [
65,
16
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
|
OscAug.setofrq | (self, x) | Change la frequence de l'oscillateur | Change la frequence de l'oscillateur | def setofrq(self, x):
"Change la frequence de l'oscillateur"
self.freq.value = x | [
"def",
"setofrq",
"(",
"self",
",",
"x",
")",
":",
"self",
".",
"freq",
".",
"value",
"=",
"x"
] | [
69,
4
] | [
71,
27
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
|
ListeAccords.offsetList | (self) | return l | Donne la liste de tous les offsets des verticalites | Donne la liste de tous les offsets des verticalites | def offsetList (self):
'''Donne la liste de tous les offsets des verticalites'''
l = []
for verticality in self.tree.iterateVerticalities():
v = Accord(verticality)
l.append(v.offset)
return l | [
"def",
"offsetList",
"(",
"self",
")",
":",
"l",
"=",
"[",
"]",
"for",
"verticality",
"in",
"self",
".",
"tree",
".",
"iterateVerticalities",
"(",
")",
":",
"v",
"=",
"Accord",
"(",
"verticality",
")",
"l",
".",
"append",
"(",
"v",
".",
"offset",
")",
"return",
"l"
] | [
177,
2
] | [
185,
14
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
df_to_PI | (df, avion) | return PI | Renvoie un dictionnaire PI de même structure que la variable de décision PI
Gurobi.
Args:
df (DataFrame)
Returns:
PI (dict)
| Renvoie un dictionnaire PI de même structure que la variable de décision PI
Gurobi. | def df_to_PI(df, avion):
"""Renvoie un dictionnaire PI de même structure que la variable de décision PI
Gurobi.
Args:
df (DataFrame)
Returns:
PI (dict)
"""
PI = dict()
list_x_possibles = list(range(avion["x_max"]+2))
list_y_possibles = list(range(avion["y_max"]+2))
for idx_passager, row in df.iterrows():
for x in list_x_possibles:
for y in list_y_possibles:
if (x, y) == (row["x"], row["y"]):
PI[x, y, idx_passager] = 1
else:
PI[x, y, idx_passager] = 0
return PI | [
"def",
"df_to_PI",
"(",
"df",
",",
"avion",
")",
":",
"PI",
"=",
"dict",
"(",
")",
"list_x_possibles",
"=",
"list",
"(",
"range",
"(",
"avion",
"[",
"\"x_max\"",
"]",
"+",
"2",
")",
")",
"list_y_possibles",
"=",
"list",
"(",
"range",
"(",
"avion",
"[",
"\"y_max\"",
"]",
"+",
"2",
")",
")",
"for",
"idx_passager",
",",
"row",
"in",
"df",
".",
"iterrows",
"(",
")",
":",
"for",
"x",
"in",
"list_x_possibles",
":",
"for",
"y",
"in",
"list_y_possibles",
":",
"if",
"(",
"x",
",",
"y",
")",
"==",
"(",
"row",
"[",
"\"x\"",
"]",
",",
"row",
"[",
"\"y\"",
"]",
")",
":",
"PI",
"[",
"x",
",",
"y",
",",
"idx_passager",
"]",
"=",
"1",
"else",
":",
"PI",
"[",
"x",
",",
"y",
",",
"idx_passager",
"]",
"=",
"0",
"return",
"PI"
] | [
108,
0
] | [
134,
13
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
get_markers_passagers | (df_ans) | return marker_list | Renvoie la liste marker_list à donner en argument lors du tracé Plotly
pour plus facilement identifier les passagers.
Args:
df_ans (DataFrame): DataFrame renvoyé par la fonction exporter_resultats
définie dans le notebook
Returns:
list
| Renvoie la liste marker_list à donner en argument lors du tracé Plotly
pour plus facilement identifier les passagers. | def get_markers_passagers(df_ans):
"""Renvoie la liste marker_list à donner en argument lors du tracé Plotly
pour plus facilement identifier les passagers.
Args:
df_ans (DataFrame): DataFrame renvoyé par la fonction exporter_resultats
définie dans le notebook
Returns:
list
"""
marker_list = []
for idx, passager in df_ans.iterrows():
if passager["Classe"] == "Business" or passager["Classe"] == 'J':
dot = "-dot"
else:
dot = ""
if passager["Catégorie"] == "femmes":
marker_list.append('circle'+dot)
elif passager["Catégorie"] == "hommes":
marker_list.append('hexagon'+dot)
elif passager["Catégorie"] == "enfants":
marker_list.append('star'+dot)
elif passager["Catégorie"] == "WHCR" or passager["Catégorie"] == "WCHR":
marker_list.append('star-square'+dot)
return marker_list | [
"def",
"get_markers_passagers",
"(",
"df_ans",
")",
":",
"marker_list",
"=",
"[",
"]",
"for",
"idx",
",",
"passager",
"in",
"df_ans",
".",
"iterrows",
"(",
")",
":",
"if",
"passager",
"[",
"\"Classe\"",
"]",
"==",
"\"Business\"",
"or",
"passager",
"[",
"\"Classe\"",
"]",
"==",
"'J'",
":",
"dot",
"=",
"\"-dot\"",
"else",
":",
"dot",
"=",
"\"\"",
"if",
"passager",
"[",
"\"Catégorie\"]",
" ",
"= ",
"femmes\":",
"",
"marker_list",
".",
"append",
"(",
"'circle'",
"+",
"dot",
")",
"elif",
"passager",
"[",
"\"Catégorie\"]",
" ",
"= ",
"hommes\":",
"",
"marker_list",
".",
"append",
"(",
"'hexagon'",
"+",
"dot",
")",
"elif",
"passager",
"[",
"\"Catégorie\"]",
" ",
"= ",
"enfants\":",
"",
"marker_list",
".",
"append",
"(",
"'star'",
"+",
"dot",
")",
"elif",
"passager",
"[",
"\"Catégorie\"]",
" ",
"= ",
"WHCR\" ",
"r ",
"assager[",
"\"",
"Catégorie\"] ",
"=",
" \"",
"CHR\":",
"",
"marker_list",
".",
"append",
"(",
"'star-square'",
"+",
"dot",
")",
"return",
"marker_list"
] | [
264,
0
] | [
291,
22
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
Scene.construit_rayon | (self, pixel) | return r | construit le rayon correspondant au pixel pixel | construit le rayon correspondant au pixel pixel | def construit_rayon(self, pixel):
"""construit le rayon correspondant au pixel pixel"""
x = (pixel.x - self.dim[0] / 2) * \
math.tan(self.alpha / 2) / min(self.dim)
y = (pixel.y - self.dim[1] / 2) * \
math.tan(self.alpha / 2) / min(self.dim)
v = Vecteur(x, y, 1)
r = Rayon(self.repere.origine, self.repere.coordonnees(v),
pixel, Couleur(1, 1, 1))
return r | [
"def",
"construit_rayon",
"(",
"self",
",",
"pixel",
")",
":",
"x",
"=",
"(",
"pixel",
".",
"x",
"-",
"self",
".",
"dim",
"[",
"0",
"]",
"/",
"2",
")",
"*",
"math",
".",
"tan",
"(",
"self",
".",
"alpha",
"/",
"2",
")",
"/",
"min",
"(",
"self",
".",
"dim",
")",
"y",
"=",
"(",
"pixel",
".",
"y",
"-",
"self",
".",
"dim",
"[",
"1",
"]",
"/",
"2",
")",
"*",
"math",
".",
"tan",
"(",
"self",
".",
"alpha",
"/",
"2",
")",
"/",
"min",
"(",
"self",
".",
"dim",
")",
"v",
"=",
"Vecteur",
"(",
"x",
",",
"y",
",",
"1",
")",
"r",
"=",
"Rayon",
"(",
"self",
".",
"repere",
".",
"origine",
",",
"self",
".",
"repere",
".",
"coordonnees",
"(",
"v",
")",
",",
"pixel",
",",
"Couleur",
"(",
"1",
",",
"1",
",",
"1",
")",
")",
"return",
"r"
] | [
88,
4
] | [
97,
16
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
set_freq | (addr, freq) | Fonction qui met à jour la fréquence de la sinusoïde | Fonction qui met à jour la fréquence de la sinusoïde | def set_freq(addr, freq):
"Fonction qui met à jour la fréquence de la sinusoïde"
a.setFreq(freq) | [
"def",
"set_freq",
"(",
"addr",
",",
"freq",
")",
":",
"a",
".",
"setFreq",
"(",
"freq",
")"
] | [
14,
0
] | [
16,
19
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
|
_DisplayReservation.get_display_infos | (self) | return tpl | Affiche les infos sur les affichages pour une réserversation | Affiche les infos sur les affichages pour une réserversation | def get_display_infos(self):
"""Affiche les infos sur les affichages pour une réserversation"""
tpl = mark_safe(u'<div style="margin-top: 5px;">{}, {} <span class="label label-info">{}</span></div>'.format(escape(self.display.title), _(u'gérée par'), escape(self.display.unit.name)))
return tpl | [
"def",
"get_display_infos",
"(",
"self",
")",
":",
"tpl",
"=",
"mark_safe",
"(",
"u'<div style=\"margin-top: 5px;\">{}, {} <span class=\"label label-info\">{}</span></div>'",
".",
"format",
"(",
"escape",
"(",
"self",
".",
"display",
".",
"title",
")",
",",
"_",
"(",
"u'gérée par'),",
" ",
"e",
"cape(s",
"e",
"lf.d",
"i",
"splay.u",
"n",
"it.n",
"a",
"me))",
")",
"",
"",
"return",
"tpl"
] | [
401,
4
] | [
406,
18
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
oppose_poids | (m) | return resultat | Renvoie une matrice d'adjacence dont les poids sont opposés. | Renvoie une matrice d'adjacence dont les poids sont opposés. | def oppose_poids(m):
"""Renvoie une matrice d'adjacence dont les poids sont opposés."""
resultat = []
for i in range(len(m)):
ligne = []
for j in range(len(m)):
if m[i][j] == None:
ligne.append(None)
else:
ligne.append(-m[i][j])
resultat.append(ligne)
return resultat | [
"def",
"oppose_poids",
"(",
"m",
")",
":",
"resultat",
"=",
"[",
"]",
"for",
"i",
"in",
"range",
"(",
"len",
"(",
"m",
")",
")",
":",
"ligne",
"=",
"[",
"]",
"for",
"j",
"in",
"range",
"(",
"len",
"(",
"m",
")",
")",
":",
"if",
"m",
"[",
"i",
"]",
"[",
"j",
"]",
"==",
"None",
":",
"ligne",
".",
"append",
"(",
"None",
")",
"else",
":",
"ligne",
".",
"append",
"(",
"-",
"m",
"[",
"i",
"]",
"[",
"j",
"]",
")",
"resultat",
".",
"append",
"(",
"ligne",
")",
"return",
"resultat"
] | [
226,
0
] | [
239,
19
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
EulerPhi | (n) | return phi | calcul de l'Indicatrice d'Euler φ(n) ou totient(n) | calcul de l'Indicatrice d'Euler φ(n) ou totient(n) | def EulerPhi(n):
""" calcul de l'Indicatrice d'Euler φ(n) ou totient(n) """
phi = n
i = 2
while i * i <= n:
if n % i == 0:
phi -= phi // i
while n % i == 0:
n = n // i
if i != 2:
i += 2
else:
i += 1
if n > 1:
phi -= phi // n
return phi | [
"def",
"EulerPhi",
"(",
"n",
")",
":",
"phi",
"=",
"n",
"i",
"=",
"2",
"while",
"i",
"*",
"i",
"<=",
"n",
":",
"if",
"n",
"%",
"i",
"==",
"0",
":",
"phi",
"-=",
"phi",
"//",
"i",
"while",
"n",
"%",
"i",
"==",
"0",
":",
"n",
"=",
"n",
"//",
"i",
"if",
"i",
"!=",
"2",
":",
"i",
"+=",
"2",
"else",
":",
"i",
"+=",
"1",
"if",
"n",
">",
"1",
":",
"phi",
"-=",
"phi",
"//",
"n",
"return",
"phi"
] | [
27,
0
] | [
42,
14
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
parcours_arcs | (m, f) | La fonction f est appelée avec les couples de sommets formant des arcs. | La fonction f est appelée avec les couples de sommets formant des arcs. | def parcours_arcs(m, f):
"""La fonction f est appelée avec les couples de sommets formant des arcs."""
for i in range(len(m)):
for j in range(len(m[i])):
if m[i][j] != 0:
f(i, j) | [
"def",
"parcours_arcs",
"(",
"m",
",",
"f",
")",
":",
"for",
"i",
"in",
"range",
"(",
"len",
"(",
"m",
")",
")",
":",
"for",
"j",
"in",
"range",
"(",
"len",
"(",
"m",
"[",
"i",
"]",
")",
")",
":",
"if",
"m",
"[",
"i",
"]",
"[",
"j",
"]",
"!=",
"0",
":",
"f",
"(",
"i",
",",
"j",
")"
] | [
36,
0
] | [
41,
23
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
|
Checker.infos_entries_post_date | (self, date) | Affiche les informations sur les entrées postérieure à la date demandée | Affiche les informations sur les entrées postérieure à la date demandée | def infos_entries_post_date(self, date):
"""Affiche les informations sur les entrées postérieure à la date demandée"""
print()
entries = self.entries_post_date(date)
print("Nombre d'entrées avec une date supérieure à {} : {}".format(date, len(entries)))
[infos_entries(entry) for entry in entries] | [
"def",
"infos_entries_post_date",
"(",
"self",
",",
"date",
")",
":",
"print",
"(",
")",
"entries",
"=",
"self",
".",
"entries_post_date",
"(",
"date",
")",
"print",
"(",
"\"Nombre d'entrées avec une date supérieure à {} : {}\".fo",
"r",
"mat(da",
"t",
"e, l",
"e",
"(en",
"t",
"ries)))",
"",
"",
"",
"[",
"infos_entries",
"(",
"entry",
")",
"for",
"entry",
"in",
"entries",
"]"
] | [
103,
4
] | [
108,
51
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
|
Vecteur.renorme | (self) | renorme ce vecteur | renorme ce vecteur | def renorme(self):
"""renorme ce vecteur"""
n = self.norme()
if n > 0:
return self / n
else:
return copy.copy(self) | [
"def",
"renorme",
"(",
"self",
")",
":",
"n",
"=",
"self",
".",
"norme",
"(",
")",
"if",
"n",
">",
"0",
":",
"return",
"self",
"/",
"n",
"else",
":",
"return",
"copy",
".",
"copy",
"(",
"self",
")"
] | [
89,
4
] | [
95,
34
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
|
rechercheFormation | () | return render_template("rechercheFormation.html", list_type = list_type, list_commune = list_commune) | Controleur de la route '/rechercheFormation' | Controleur de la route '/rechercheFormation' | def rechercheFormation():
"Controleur de la route '/rechercheFormation' "
conn = sqlite3.connect('monavenir.db')
conn.row_factory = sqlite3.Row #pour récupérer les lignes sous forme de dictionnaire
cur = conn.cursor()
cur.execute("SELECT DISTINCT type FROM superieur ;")
list_type = cur.fetchall()
cur.execute("SELECT DISTINCT commune FROM superieur ;")
list_commune = cur.fetchall()
conn.close()
return render_template("rechercheFormation.html", list_type = list_type, list_commune = list_commune) | [
"def",
"rechercheFormation",
"(",
")",
":",
"conn",
"=",
"sqlite3",
".",
"connect",
"(",
"'monavenir.db'",
")",
"conn",
".",
"row_factory",
"=",
"sqlite3",
".",
"Row",
"#pour récupérer les lignes sous forme de dictionnaire \r",
"cur",
"=",
"conn",
".",
"cursor",
"(",
")",
"cur",
".",
"execute",
"(",
"\"SELECT DISTINCT type FROM superieur ;\"",
")",
"list_type",
"=",
"cur",
".",
"fetchall",
"(",
")",
"cur",
".",
"execute",
"(",
"\"SELECT DISTINCT commune FROM superieur ;\"",
")",
"list_commune",
"=",
"cur",
".",
"fetchall",
"(",
")",
"conn",
".",
"close",
"(",
")",
"return",
"render_template",
"(",
"\"rechercheFormation.html\"",
",",
"list_type",
"=",
"list_type",
",",
"list_commune",
"=",
"list_commune",
")"
] | [
70,
0
] | [
80,
106
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
discretizeData | (data) | return newData | Discrétisation automatique utilisant numpy
Arguments:
data {pandas.dataframe} -- le dataframe dont certaines colonnes seront à discrétisées
Returns:
pandas.dataframe -- le nouveau dataframe discréité
| Discrétisation automatique utilisant numpy | def discretizeData(data):
"""Discrétisation automatique utilisant numpy
Arguments:
data {pandas.dataframe} -- le dataframe dont certaines colonnes seront à discrétisées
Returns:
pandas.dataframe -- le nouveau dataframe discréité
"""
newData = data.copy()
for k in newData.keys():
if len(newData[k].unique()) > 5:
newData[k] = data.apply(lambda row: np.digitize(row[k], np.histogram_bin_edges(newData[k], bins="fd")),
axis=1)
return newData | [
"def",
"discretizeData",
"(",
"data",
")",
":",
"newData",
"=",
"data",
".",
"copy",
"(",
")",
"for",
"k",
"in",
"newData",
".",
"keys",
"(",
")",
":",
"if",
"len",
"(",
"newData",
"[",
"k",
"]",
".",
"unique",
"(",
")",
")",
">",
"5",
":",
"newData",
"[",
"k",
"]",
"=",
"data",
".",
"apply",
"(",
"lambda",
"row",
":",
"np",
".",
"digitize",
"(",
"row",
"[",
"k",
"]",
",",
"np",
".",
"histogram_bin_edges",
"(",
"newData",
"[",
"k",
"]",
",",
"bins",
"=",
"\"fd\"",
")",
")",
",",
"axis",
"=",
"1",
")",
"return",
"newData"
] | [
46,
0
] | [
60,
16
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
Odrive.Length_to_rounds | (self, length) | return(nb_rounds) | Convertie un distance (en mm) a parcourir en nombre de tours de roue | Convertie un distance (en mm) a parcourir en nombre de tours de roue | def Length_to_rounds(self, length):
"""Convertie un distance (en mm) a parcourir en nombre de tours de roue"""
nb_rounds = length / (self.Diameter * math.pi)
#print("nb_rounds = ", nb_rounds)
return(nb_rounds) | [
"def",
"Length_to_rounds",
"(",
"self",
",",
"length",
")",
":",
"nb_rounds",
"=",
"length",
"/",
"(",
"self",
".",
"Diameter",
"*",
"math",
".",
"pi",
")",
"#print(\"nb_rounds = \", nb_rounds)",
"return",
"(",
"nb_rounds",
")"
] | [
76,
1
] | [
80,
19
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
draw_buffer_map | (peaks, km, y_class="y_class_dbscan_only_gaussian_param") | return None | ce n'est qu'une carte qui me permettait de voir les 2 types de peak rapidement,
il faudrait juste intégrer les buffer dans la carte de Quentin K | ce n'est qu'une carte qui me permettait de voir les 2 types de peak rapidement,
il faudrait juste intégrer les buffer dans la carte de Quentin K | def draw_buffer_map(peaks, km, y_class="y_class_dbscan_only_gaussian_param"):
""" ce n'est qu'une carte qui me permettait de voir les 2 types de peak rapidement,
il faudrait juste intégrer les buffer dans la carte de Quentin K"""
_, km_buffer_normal, km_buffer_abnormal = compute_buffers(peaks, km, y_class)
m = folium.Map(location=[39.9526, -75.1652], zoom_start=3)
folium.GeoJson(km_buffer_normal.to_crs(epsg=4326), name='normal', style_function=lambda x: style1).add_to(m)
folium.GeoJson(km_buffer_abnormal.to_crs(epsg=4326), name='abnormal', style_function=lambda x: style2).add_to(m)
HeatMap(data=co2[['latitude', 'longitude']], radius=3, blur=2, gradient={1: "red"}).add_to(m)
mc = MarkerCluster()
for idx, row in centrales.iterrows():
if not math.isnan(row['longitude']) and not math.isnan(row['latitude']):
mc.add_child(Marker([row['latitude'], row['longitude']], color="green"))
m.add_child(mc)
cit = MarkerCluster()
for idx, row in cities.iterrows():
if not math.isnan(row['longitude']) and not math.isnan(row['latitude']):
mc.add_child(Marker([row['latitude'], row['longitude']], color="orange"))
m.add_child(cit)
m.save("dataset/output/cities_peak.html")
# webbrowser.open("dataset/output/cities_peak.html", new=2)
return None | [
"def",
"draw_buffer_map",
"(",
"peaks",
",",
"km",
",",
"y_class",
"=",
"\"y_class_dbscan_only_gaussian_param\"",
")",
":",
"_",
",",
"km_buffer_normal",
",",
"km_buffer_abnormal",
"=",
"compute_buffers",
"(",
"peaks",
",",
"km",
",",
"y_class",
")",
"m",
"=",
"folium",
".",
"Map",
"(",
"location",
"=",
"[",
"39.9526",
",",
"-",
"75.1652",
"]",
",",
"zoom_start",
"=",
"3",
")",
"folium",
".",
"GeoJson",
"(",
"km_buffer_normal",
".",
"to_crs",
"(",
"epsg",
"=",
"4326",
")",
",",
"name",
"=",
"'normal'",
",",
"style_function",
"=",
"lambda",
"x",
":",
"style1",
")",
".",
"add_to",
"(",
"m",
")",
"folium",
".",
"GeoJson",
"(",
"km_buffer_abnormal",
".",
"to_crs",
"(",
"epsg",
"=",
"4326",
")",
",",
"name",
"=",
"'abnormal'",
",",
"style_function",
"=",
"lambda",
"x",
":",
"style2",
")",
".",
"add_to",
"(",
"m",
")",
"HeatMap",
"(",
"data",
"=",
"co2",
"[",
"[",
"'latitude'",
",",
"'longitude'",
"]",
"]",
",",
"radius",
"=",
"3",
",",
"blur",
"=",
"2",
",",
"gradient",
"=",
"{",
"1",
":",
"\"red\"",
"}",
")",
".",
"add_to",
"(",
"m",
")",
"mc",
"=",
"MarkerCluster",
"(",
")",
"for",
"idx",
",",
"row",
"in",
"centrales",
".",
"iterrows",
"(",
")",
":",
"if",
"not",
"math",
".",
"isnan",
"(",
"row",
"[",
"'longitude'",
"]",
")",
"and",
"not",
"math",
".",
"isnan",
"(",
"row",
"[",
"'latitude'",
"]",
")",
":",
"mc",
".",
"add_child",
"(",
"Marker",
"(",
"[",
"row",
"[",
"'latitude'",
"]",
",",
"row",
"[",
"'longitude'",
"]",
"]",
",",
"color",
"=",
"\"green\"",
")",
")",
"m",
".",
"add_child",
"(",
"mc",
")",
"cit",
"=",
"MarkerCluster",
"(",
")",
"for",
"idx",
",",
"row",
"in",
"cities",
".",
"iterrows",
"(",
")",
":",
"if",
"not",
"math",
".",
"isnan",
"(",
"row",
"[",
"'longitude'",
"]",
")",
"and",
"not",
"math",
".",
"isnan",
"(",
"row",
"[",
"'latitude'",
"]",
")",
":",
"mc",
".",
"add_child",
"(",
"Marker",
"(",
"[",
"row",
"[",
"'latitude'",
"]",
",",
"row",
"[",
"'longitude'",
"]",
"]",
",",
"color",
"=",
"\"orange\"",
")",
")",
"m",
".",
"add_child",
"(",
"cit",
")",
"m",
".",
"save",
"(",
"\"dataset/output/cities_peak.html\"",
")",
"# webbrowser.open(\"dataset/output/cities_peak.html\", new=2)",
"return",
"None"
] | [
53,
0
] | [
75,
15
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
print_polynomial | (poly, mini, maxi, eps = epsilon, color = 'b') | Affiche un polynôme entre les bornes mini et maxi avec une précision souhaitée | Affiche un polynôme entre les bornes mini et maxi avec une précision souhaitée | def print_polynomial(poly, mini, maxi, eps = epsilon, color = 'b'):
""" Affiche un polynôme entre les bornes mini et maxi avec une précision souhaitée """
x = np.arange(mini, maxi, eps)
y = []
for i in range(len(x)):
y.append(poly(x[i]))
mp.plot(x, y, color) | [
"def",
"print_polynomial",
"(",
"poly",
",",
"mini",
",",
"maxi",
",",
"eps",
"=",
"epsilon",
",",
"color",
"=",
"'b'",
")",
":",
"x",
"=",
"np",
".",
"arange",
"(",
"mini",
",",
"maxi",
",",
"eps",
")",
"y",
"=",
"[",
"]",
"for",
"i",
"in",
"range",
"(",
"len",
"(",
"x",
")",
")",
":",
"y",
".",
"append",
"(",
"poly",
"(",
"x",
"[",
"i",
"]",
")",
")",
"mp",
".",
"plot",
"(",
"x",
",",
"y",
",",
"color",
")"
] | [
151,
0
] | [
157,
22
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
|
Events.update_duration | (self, ID: int, new_duration: int) | return True | Modifie la durée d'une tâche | Modifie la durée d'une tâche | async def update_duration(self, ID: int, new_duration: int):
"""Modifie la durée d'une tâche"""
cnx = self.bot.cnx_frm
cursor = cnx.cursor()
query = ("UPDATE `timed` SET `duration`={} WHERE `ID`={}".format(new_duration,ID))
cursor.execute(query)
cnx.commit()
cursor.close()
return True | [
"async",
"def",
"update_duration",
"(",
"self",
",",
"ID",
":",
"int",
",",
"new_duration",
":",
"int",
")",
":",
"cnx",
"=",
"self",
".",
"bot",
".",
"cnx_frm",
"cursor",
"=",
"cnx",
".",
"cursor",
"(",
")",
"query",
"=",
"(",
"\"UPDATE `timed` SET `duration`={} WHERE `ID`={}\"",
".",
"format",
"(",
"new_duration",
",",
"ID",
")",
")",
"cursor",
".",
"execute",
"(",
"query",
")",
"cnx",
".",
"commit",
"(",
")",
"cursor",
".",
"close",
"(",
")",
"return",
"True"
] | [
462,
4
] | [
470,
19
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
main | (etab, quartier, z_year_score_threshold, alpha, start_training_date, begin_date, end_date, verbose=False) | return model, X_pred | Constitution du dataset / fit du modèle / prediction out of sample | Constitution du dataset / fit du modèle / prediction out of sample | def main(etab, quartier, z_year_score_threshold, alpha, start_training_date, begin_date, end_date, verbose=False):
"""Constitution du dataset / fit du modèle / prediction out of sample"""
columns_from_global = [
"nos",
"ind",
"greves_manquantes",
"menu",
"ferie",
"veille_ferie",
"retour_ferie",
"vacances",
"retour_vacances",
"veille_vacances",
"inc_grippe",
"inc_gastro",
"inc_varicelle",
"fete_musulmane",
"ramadan",
"fete_chretienne",
"fete_juive",
"jour",
"semaine",
"mois",
"annee_scolaire",
"repas_noel",
"porc",
"viande",
"bio",
"poisson",
"4_derniers_jours",
]
columns_for_model = [
"reel",
"effectif",
"z_year_score",
#"jour",
"repas_noel",
"poisson",
"viande",
"4_derniers_jours",
]
path_data = "data_processed"
filename_data_per_school = "complete_data_per_school.pk" # Données de repas / effectifs par école
filename_data_global = "global.pk" # Données exogènes pour enrichissements
path_data_per_school = os.path.join(path_data, filename_data_per_school)
path_data_global = os.path.join(path_data, filename_data_global)
data = pd.read_pickle(path_data_per_school)
data_global = pd.read_pickle(path_data_global)
## Récupérations des données
if (etab is None) & (quartier is None):
df = create_df_global(data, data_global, columns_from_global)
type_ = "global"
name = "global"
elif etab is not None:
df = create_df_etab(data=data, data_global=data_global, columns_from_global=columns_from_global, etab=etab)
type_ = "etab"
name = etab
elif quartier is not None:
df = create_df_quartier(data=data, data_global=data_global, columns_from_global=columns_from_global,
quartier=quartier)
type_ = "quartier"
name = quartier
if verbose:
print(df.shape[0], "lignes", type_, ":", name)
print(f"date_min : {df.index.min().date()}", f"\ndate_max : {df.index.max().date()}")
## Suppression lignes réel nulles et mercredi
df = delete_rows_null_reel(df=df)
df = delete_rows_wednesday(df=df)
# Calcul du z_year_score et censure
if verbose:
print(df.shape[0], "lignes avant censure par le z_year_score")
df["z_year_score"] = (df.reel - df.groupby("annee_scolaire").transform(np.mean).reel) / df.groupby(
"annee_scolaire").transform(np.std).reel
# df = df[df.z_year_score.map(np.abs) < z_year_score_threshold]
if verbose:
print(df.shape[0], "lignes après censure par le z_year_score")
df = select_columns(df=df, selected_columns=columns_for_model + ["prevision"])
# Création des dummies et Sélection sur le z_year_score
X = df.dropna().drop("prevision", axis=1)
#X = create_day_with_fish_columns(X=X)
X["poisson"] = X["poisson"] * X["effectif"]
X["viande"] = X["viande"] * X["effectif"]
X = create_month_columns(X)
X = create_repas_noel_column(X=X)
print("X columns", X.columns)
# on enlève quatre derniers jours de l'années des mois de juin et/ou juillet pour éviter les colinéarités
X["month_6"] = X["month_6"] * X["4_derniers_jours"].apply(lambda x: 1 - x)
X["month_7"] = X["month_7"] * X["4_derniers_jours"].apply(lambda x: 1 - x)
# 4 derniers jours
X["4_derniers_jours"] = X["4_derniers_jours"] * X["effectif"]
# X et Y pour modélisation (on garde le z_year_score pour faire la censure sur le train mais pas sur le test)
Y = X[["reel", "z_year_score"]].sort_index()
X = X.drop(["reel"], axis=1).sort_index()
# Date de début et de fin du train
start_training_date = datetime.datetime.strptime(start_training_date, "%Y-%m-%d")
begin_date = datetime.datetime.strptime(begin_date, "%Y-%m-%d")
end_date = datetime.datetime.strptime(end_date, "%Y-%m-%d")
# Sélection du train
X_train, Y_train = X[(X.index > start_training_date) & (X.index <= begin_date)], Y[
(Y.index > start_training_date) & (Y.index <= begin_date)]
# Censure grâce au z_year score
X_train, Y_train = X_train[X_train.z_year_score.map(np.abs) < z_year_score_threshold], Y_train[
Y_train.z_year_score.map(np.abs) < z_year_score_threshold]
# On enlève la colonne z_year_score
X_train, Y_train = X_train.drop(["z_year_score"], axis=1), Y_train.drop(["z_year_score"], axis=1)
# Le test est toute la portion après le train jusqu'à la date de fin
X, Y = X.drop(["z_year_score"], axis=1), Y.drop(["z_year_score"], axis=1)
X_test, Y_test = X[(begin_date < X.index) & (X.index <= end_date)], Y[
(begin_date < Y.index) & (Y.index <= end_date)]
#print("columns X", X_train.columns)
#print("types", X_train.dtypes)
model = fit_ols(Y_train, X_train)
X_pred = get_output_model(X_test, Y_test, df, model, alpha=alpha)
if verbose:
X_pred[["pred", "reel"]].plot()
plt.show()
return model, X_pred | [
"def",
"main",
"(",
"etab",
",",
"quartier",
",",
"z_year_score_threshold",
",",
"alpha",
",",
"start_training_date",
",",
"begin_date",
",",
"end_date",
",",
"verbose",
"=",
"False",
")",
":",
"columns_from_global",
"=",
"[",
"\"nos\"",
",",
"\"ind\"",
",",
"\"greves_manquantes\"",
",",
"\"menu\"",
",",
"\"ferie\"",
",",
"\"veille_ferie\"",
",",
"\"retour_ferie\"",
",",
"\"vacances\"",
",",
"\"retour_vacances\"",
",",
"\"veille_vacances\"",
",",
"\"inc_grippe\"",
",",
"\"inc_gastro\"",
",",
"\"inc_varicelle\"",
",",
"\"fete_musulmane\"",
",",
"\"ramadan\"",
",",
"\"fete_chretienne\"",
",",
"\"fete_juive\"",
",",
"\"jour\"",
",",
"\"semaine\"",
",",
"\"mois\"",
",",
"\"annee_scolaire\"",
",",
"\"repas_noel\"",
",",
"\"porc\"",
",",
"\"viande\"",
",",
"\"bio\"",
",",
"\"poisson\"",
",",
"\"4_derniers_jours\"",
",",
"]",
"columns_for_model",
"=",
"[",
"\"reel\"",
",",
"\"effectif\"",
",",
"\"z_year_score\"",
",",
"#\"jour\",",
"\"repas_noel\"",
",",
"\"poisson\"",
",",
"\"viande\"",
",",
"\"4_derniers_jours\"",
",",
"]",
"path_data",
"=",
"\"data_processed\"",
"filename_data_per_school",
"=",
"\"complete_data_per_school.pk\"",
"# Données de repas / effectifs par école",
"filename_data_global",
"=",
"\"global.pk\"",
"# Données exogènes pour enrichissements",
"path_data_per_school",
"=",
"os",
".",
"path",
".",
"join",
"(",
"path_data",
",",
"filename_data_per_school",
")",
"path_data_global",
"=",
"os",
".",
"path",
".",
"join",
"(",
"path_data",
",",
"filename_data_global",
")",
"data",
"=",
"pd",
".",
"read_pickle",
"(",
"path_data_per_school",
")",
"data_global",
"=",
"pd",
".",
"read_pickle",
"(",
"path_data_global",
")",
"## Récupérations des données",
"if",
"(",
"etab",
"is",
"None",
")",
"&",
"(",
"quartier",
"is",
"None",
")",
":",
"df",
"=",
"create_df_global",
"(",
"data",
",",
"data_global",
",",
"columns_from_global",
")",
"type_",
"=",
"\"global\"",
"name",
"=",
"\"global\"",
"elif",
"etab",
"is",
"not",
"None",
":",
"df",
"=",
"create_df_etab",
"(",
"data",
"=",
"data",
",",
"data_global",
"=",
"data_global",
",",
"columns_from_global",
"=",
"columns_from_global",
",",
"etab",
"=",
"etab",
")",
"type_",
"=",
"\"etab\"",
"name",
"=",
"etab",
"elif",
"quartier",
"is",
"not",
"None",
":",
"df",
"=",
"create_df_quartier",
"(",
"data",
"=",
"data",
",",
"data_global",
"=",
"data_global",
",",
"columns_from_global",
"=",
"columns_from_global",
",",
"quartier",
"=",
"quartier",
")",
"type_",
"=",
"\"quartier\"",
"name",
"=",
"quartier",
"if",
"verbose",
":",
"print",
"(",
"df",
".",
"shape",
"[",
"0",
"]",
",",
"\"lignes\"",
",",
"type_",
",",
"\":\"",
",",
"name",
")",
"print",
"(",
"f\"date_min : {df.index.min().date()}\"",
",",
"f\"\\ndate_max : {df.index.max().date()}\"",
")",
"## Suppression lignes réel nulles et mercredi",
"df",
"=",
"delete_rows_null_reel",
"(",
"df",
"=",
"df",
")",
"df",
"=",
"delete_rows_wednesday",
"(",
"df",
"=",
"df",
")",
"# Calcul du z_year_score et censure",
"if",
"verbose",
":",
"print",
"(",
"df",
".",
"shape",
"[",
"0",
"]",
",",
"\"lignes avant censure par le z_year_score\"",
")",
"df",
"[",
"\"z_year_score\"",
"]",
"=",
"(",
"df",
".",
"reel",
"-",
"df",
".",
"groupby",
"(",
"\"annee_scolaire\"",
")",
".",
"transform",
"(",
"np",
".",
"mean",
")",
".",
"reel",
")",
"/",
"df",
".",
"groupby",
"(",
"\"annee_scolaire\"",
")",
".",
"transform",
"(",
"np",
".",
"std",
")",
".",
"reel",
"# df = df[df.z_year_score.map(np.abs) < z_year_score_threshold]",
"if",
"verbose",
":",
"print",
"(",
"df",
".",
"shape",
"[",
"0",
"]",
",",
"\"lignes après censure par le z_year_score\")",
"",
"df",
"=",
"select_columns",
"(",
"df",
"=",
"df",
",",
"selected_columns",
"=",
"columns_for_model",
"+",
"[",
"\"prevision\"",
"]",
")",
"# Création des dummies et Sélection sur le z_year_score",
"X",
"=",
"df",
".",
"dropna",
"(",
")",
".",
"drop",
"(",
"\"prevision\"",
",",
"axis",
"=",
"1",
")",
"#X = create_day_with_fish_columns(X=X)",
"X",
"[",
"\"poisson\"",
"]",
"=",
"X",
"[",
"\"poisson\"",
"]",
"*",
"X",
"[",
"\"effectif\"",
"]",
"X",
"[",
"\"viande\"",
"]",
"=",
"X",
"[",
"\"viande\"",
"]",
"*",
"X",
"[",
"\"effectif\"",
"]",
"X",
"=",
"create_month_columns",
"(",
"X",
")",
"X",
"=",
"create_repas_noel_column",
"(",
"X",
"=",
"X",
")",
"print",
"(",
"\"X columns\"",
",",
"X",
".",
"columns",
")",
"# on enlève quatre derniers jours de l'années des mois de juin et/ou juillet pour éviter les colinéarités",
"X",
"[",
"\"month_6\"",
"]",
"=",
"X",
"[",
"\"month_6\"",
"]",
"*",
"X",
"[",
"\"4_derniers_jours\"",
"]",
".",
"apply",
"(",
"lambda",
"x",
":",
"1",
"-",
"x",
")",
"X",
"[",
"\"month_7\"",
"]",
"=",
"X",
"[",
"\"month_7\"",
"]",
"*",
"X",
"[",
"\"4_derniers_jours\"",
"]",
".",
"apply",
"(",
"lambda",
"x",
":",
"1",
"-",
"x",
")",
"# 4 derniers jours",
"X",
"[",
"\"4_derniers_jours\"",
"]",
"=",
"X",
"[",
"\"4_derniers_jours\"",
"]",
"*",
"X",
"[",
"\"effectif\"",
"]",
"# X et Y pour modélisation (on garde le z_year_score pour faire la censure sur le train mais pas sur le test)",
"Y",
"=",
"X",
"[",
"[",
"\"reel\"",
",",
"\"z_year_score\"",
"]",
"]",
".",
"sort_index",
"(",
")",
"X",
"=",
"X",
".",
"drop",
"(",
"[",
"\"reel\"",
"]",
",",
"axis",
"=",
"1",
")",
".",
"sort_index",
"(",
")",
"# Date de début et de fin du train",
"start_training_date",
"=",
"datetime",
".",
"datetime",
".",
"strptime",
"(",
"start_training_date",
",",
"\"%Y-%m-%d\"",
")",
"begin_date",
"=",
"datetime",
".",
"datetime",
".",
"strptime",
"(",
"begin_date",
",",
"\"%Y-%m-%d\"",
")",
"end_date",
"=",
"datetime",
".",
"datetime",
".",
"strptime",
"(",
"end_date",
",",
"\"%Y-%m-%d\"",
")",
"# Sélection du train",
"X_train",
",",
"Y_train",
"=",
"X",
"[",
"(",
"X",
".",
"index",
">",
"start_training_date",
")",
"&",
"(",
"X",
".",
"index",
"<=",
"begin_date",
")",
"]",
",",
"Y",
"[",
"(",
"Y",
".",
"index",
">",
"start_training_date",
")",
"&",
"(",
"Y",
".",
"index",
"<=",
"begin_date",
")",
"]",
"# Censure grâce au z_year score",
"X_train",
",",
"Y_train",
"=",
"X_train",
"[",
"X_train",
".",
"z_year_score",
".",
"map",
"(",
"np",
".",
"abs",
")",
"<",
"z_year_score_threshold",
"]",
",",
"Y_train",
"[",
"Y_train",
".",
"z_year_score",
".",
"map",
"(",
"np",
".",
"abs",
")",
"<",
"z_year_score_threshold",
"]",
"# On enlève la colonne z_year_score",
"X_train",
",",
"Y_train",
"=",
"X_train",
".",
"drop",
"(",
"[",
"\"z_year_score\"",
"]",
",",
"axis",
"=",
"1",
")",
",",
"Y_train",
".",
"drop",
"(",
"[",
"\"z_year_score\"",
"]",
",",
"axis",
"=",
"1",
")",
"# Le test est toute la portion après le train jusqu'à la date de fin",
"X",
",",
"Y",
"=",
"X",
".",
"drop",
"(",
"[",
"\"z_year_score\"",
"]",
",",
"axis",
"=",
"1",
")",
",",
"Y",
".",
"drop",
"(",
"[",
"\"z_year_score\"",
"]",
",",
"axis",
"=",
"1",
")",
"X_test",
",",
"Y_test",
"=",
"X",
"[",
"(",
"begin_date",
"<",
"X",
".",
"index",
")",
"&",
"(",
"X",
".",
"index",
"<=",
"end_date",
")",
"]",
",",
"Y",
"[",
"(",
"begin_date",
"<",
"Y",
".",
"index",
")",
"&",
"(",
"Y",
".",
"index",
"<=",
"end_date",
")",
"]",
"#print(\"columns X\", X_train.columns)",
"#print(\"types\", X_train.dtypes)",
"model",
"=",
"fit_ols",
"(",
"Y_train",
",",
"X_train",
")",
"X_pred",
"=",
"get_output_model",
"(",
"X_test",
",",
"Y_test",
",",
"df",
",",
"model",
",",
"alpha",
"=",
"alpha",
")",
"if",
"verbose",
":",
"X_pred",
"[",
"[",
"\"pred\"",
",",
"\"reel\"",
"]",
"]",
".",
"plot",
"(",
")",
"plt",
".",
"show",
"(",
")",
"return",
"model",
",",
"X_pred"
] | [
176,
0
] | [
317,
24
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
cases_reine | (col,lig) | return ligne + colonne + diag_1 + diag_2 | Retourne la liste des indices (col,lig) des cases où peut se
déplacer un fou positionnée sur la case (col, lig)
Ex: dame en (6,1)
- - - - - - - - - -
| x x x |
| x x x x x x D x |
| x x x |
| x x |
| x x |
| x x |
| x x |
| x x |
- - - - - - - - - -
| Retourne la liste des indices (col,lig) des cases où peut se
déplacer un fou positionnée sur la case (col, lig) | def cases_reine(col,lig):
"""Retourne la liste des indices (col,lig) des cases où peut se
déplacer un fou positionnée sur la case (col, lig)
Ex: dame en (6,1)
- - - - - - - - - -
| x x x |
| x x x x x x D x |
| x x x |
| x x |
| x x |
| x x |
| x x |
| x x |
- - - - - - - - - -
"""
ligne = [(col, x) for x in range(0, 8) if not x == lig]
colonne = [(y, lig) for y in range(0, 8) if not y == col]
diag_1 = [(x, y) for x in range(0, 8) for y in range(0, 8) if x - col == y - lig and not x == col]
diag_2 = [(x, y) for x in range(0, 8) for y in range(0, 8) if x - col == lig - y and not x == col]
return ligne + colonne + diag_1 + diag_2 | [
"def",
"cases_reine",
"(",
"col",
",",
"lig",
")",
":",
"ligne",
"=",
"[",
"(",
"col",
",",
"x",
")",
"for",
"x",
"in",
"range",
"(",
"0",
",",
"8",
")",
"if",
"not",
"x",
"==",
"lig",
"]",
"colonne",
"=",
"[",
"(",
"y",
",",
"lig",
")",
"for",
"y",
"in",
"range",
"(",
"0",
",",
"8",
")",
"if",
"not",
"y",
"==",
"col",
"]",
"diag_1",
"=",
"[",
"(",
"x",
",",
"y",
")",
"for",
"x",
"in",
"range",
"(",
"0",
",",
"8",
")",
"for",
"y",
"in",
"range",
"(",
"0",
",",
"8",
")",
"if",
"x",
"-",
"col",
"==",
"y",
"-",
"lig",
"and",
"not",
"x",
"==",
"col",
"]",
"diag_2",
"=",
"[",
"(",
"x",
",",
"y",
")",
"for",
"x",
"in",
"range",
"(",
"0",
",",
"8",
")",
"for",
"y",
"in",
"range",
"(",
"0",
",",
"8",
")",
"if",
"x",
"-",
"col",
"==",
"lig",
"-",
"y",
"and",
"not",
"x",
"==",
"col",
"]",
"return",
"ligne",
"+",
"colonne",
"+",
"diag_1",
"+",
"diag_2"
] | [
51,
0
] | [
74,
44
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
text | (px, py, pch) | return id | affichage d'un texte pch a partir de la position (px, py) aligne a gauche
retour de l'identificateur unique de l'objet cree
| affichage d'un texte pch a partir de la position (px, py) aligne a gauche
retour de l'identificateur unique de l'objet cree
| def text(px, py, pch):
"""affichage d'un texte pch a partir de la position (px, py) aligne a gauche
retour de l'identificateur unique de l'objet cree
"""
# changement de repere
py = __ha - py
id = __canv.create_text(px, py, text=pch, fill=__ccol, anchor='sw')
return id | [
"def",
"text",
"(",
"px",
",",
"py",
",",
"pch",
")",
":",
"# changement de repere",
"py",
"=",
"__ha",
"-",
"py",
"id",
"=",
"__canv",
".",
"create_text",
"(",
"px",
",",
"py",
",",
"text",
"=",
"pch",
",",
"fill",
"=",
"__ccol",
",",
"anchor",
"=",
"'sw'",
")",
"return",
"id"
] | [
308,
0
] | [
315,
13
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
init_vector_B | (x,y) | return np.asmatrix(res) | Initialise le vecteur B pour le système M.X = B | Initialise le vecteur B pour le système M.X = B | def init_vector_B(x,y):
""" Initialise le vecteur B pour le système M.X = B """
dim = len(x)
res = np.zeros([dim,1])
res[0,0] = 0
res[dim-1,0] = 0
for i in range (1,dim-1):
res[i,0] = system_auxB(x[i-1],x[i],x[i+1],y[i-1],y[i],y[i+1])
return np.asmatrix(res) | [
"def",
"init_vector_B",
"(",
"x",
",",
"y",
")",
":",
"dim",
"=",
"len",
"(",
"x",
")",
"res",
"=",
"np",
".",
"zeros",
"(",
"[",
"dim",
",",
"1",
"]",
")",
"res",
"[",
"0",
",",
"0",
"]",
"=",
"0",
"res",
"[",
"dim",
"-",
"1",
",",
"0",
"]",
"=",
"0",
"for",
"i",
"in",
"range",
"(",
"1",
",",
"dim",
"-",
"1",
")",
":",
"res",
"[",
"i",
",",
"0",
"]",
"=",
"system_auxB",
"(",
"x",
"[",
"i",
"-",
"1",
"]",
",",
"x",
"[",
"i",
"]",
",",
"x",
"[",
"i",
"+",
"1",
"]",
",",
"y",
"[",
"i",
"-",
"1",
"]",
",",
"y",
"[",
"i",
"]",
",",
"y",
"[",
"i",
"+",
"1",
"]",
")",
"return",
"np",
".",
"asmatrix",
"(",
"res",
")"
] | [
105,
0
] | [
113,
25
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
Crud.sql_delete_record | (self, key_value) | Suppression d'un enregistrement de la vue courante | Suppression d'un enregistrement de la vue courante | def sql_delete_record(self, key_value):
""" Suppression d'un enregistrement de la vue courante """
sql = "DELETE FROM " + self.get_table_id() + " WHERE " + self.get_key_id() + " = :" + self.get_key_id()
params = {}
params[self.get_key_id()] = key_value
# print sql, params
self.exec_sql(self.get_basename(), sql, params) | [
"def",
"sql_delete_record",
"(",
"self",
",",
"key_value",
")",
":",
"sql",
"=",
"\"DELETE FROM \"",
"+",
"self",
".",
"get_table_id",
"(",
")",
"+",
"\" WHERE \"",
"+",
"self",
".",
"get_key_id",
"(",
")",
"+",
"\" = :\"",
"+",
"self",
".",
"get_key_id",
"(",
")",
"params",
"=",
"{",
"}",
"params",
"[",
"self",
".",
"get_key_id",
"(",
")",
"]",
"=",
"key_value",
"# print sql, params",
"self",
".",
"exec_sql",
"(",
"self",
".",
"get_basename",
"(",
")",
",",
"sql",
",",
"params",
")"
] | [
682,
4
] | [
688,
55
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
|
creer_arbre_rouge_noir_avec_liste | (liste) | return arbre | Convertie une liste en arbre rouge-noir. | Convertie une liste en arbre rouge-noir. | def creer_arbre_rouge_noir_avec_liste(liste):
"""Convertie une liste en arbre rouge-noir."""
arbre = ArbreRougeNoir()
for element in liste:
insere_noeud_dans_arbre_rouge_noir(arbre, element)
return arbre | [
"def",
"creer_arbre_rouge_noir_avec_liste",
"(",
"liste",
")",
":",
"arbre",
"=",
"ArbreRougeNoir",
"(",
")",
"for",
"element",
"in",
"liste",
":",
"insere_noeud_dans_arbre_rouge_noir",
"(",
"arbre",
",",
"element",
")",
"return",
"arbre"
] | [
83,
0
] | [
89,
16
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
Admin.db_reload | (self, ctx: MyContext) | Reconnecte le bot à la base de donnée | Reconnecte le bot à la base de donnée | async def db_reload(self, ctx: MyContext):
"""Reconnecte le bot à la base de donnée"""
try:
self.bot.cnx_frm.close()
self.bot.connect_database_frm()
self.bot.cnx_xp.close()
self.bot.connect_database_xp()
if self.bot.cnx_frm is not None and self.bot.cnx_xp is not None:
if utils := self.bot.get_cog("Utilities"):
await utils.add_check_reaction(ctx.message)
if xp := self.bot.get_cog("Xp"):
await xp.reload_sus()
except Exception as e:
await self.bot.get_cog('Errors').on_command_error(ctx,e) | [
"async",
"def",
"db_reload",
"(",
"self",
",",
"ctx",
":",
"MyContext",
")",
":",
"try",
":",
"self",
".",
"bot",
".",
"cnx_frm",
".",
"close",
"(",
")",
"self",
".",
"bot",
".",
"connect_database_frm",
"(",
")",
"self",
".",
"bot",
".",
"cnx_xp",
".",
"close",
"(",
")",
"self",
".",
"bot",
".",
"connect_database_xp",
"(",
")",
"if",
"self",
".",
"bot",
".",
"cnx_frm",
"is",
"not",
"None",
"and",
"self",
".",
"bot",
".",
"cnx_xp",
"is",
"not",
"None",
":",
"if",
"utils",
":=",
"self",
".",
"bot",
".",
"get_cog",
"(",
"\"Utilities\"",
")",
":",
"await",
"utils",
".",
"add_check_reaction",
"(",
"ctx",
".",
"message",
")",
"if",
"xp",
":=",
"self",
".",
"bot",
".",
"get_cog",
"(",
"\"Xp\"",
")",
":",
"await",
"xp",
".",
"reload_sus",
"(",
")",
"except",
"Exception",
"as",
"e",
":",
"await",
"self",
".",
"bot",
".",
"get_cog",
"(",
"'Errors'",
")",
".",
"on_command_error",
"(",
"ctx",
",",
"e",
")"
] | [
409,
4
] | [
422,
68
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
|
goldbach | (n) | teste la conjecture de Golbach en tentant de décomposer n pair (>2) en 2 nb premiers | teste la conjecture de Golbach en tentant de décomposer n pair (>2) en 2 nb premiers | def goldbach(n):
"""teste la conjecture de Golbach en tentant de décomposer n pair (>2) en 2 nb premiers"""
x = 3
while True:
# calcul de y et test de primalité
y = n-x
if gmpy2.is_prime(y,20):
return (n,[int(x),int(y)])
# On prend le nombre premier suivant
x = gmpy2.next_prime(x) | [
"def",
"goldbach",
"(",
"n",
")",
":",
"x",
"=",
"3",
"while",
"True",
":",
"# calcul de y et test de primalité",
"y",
"=",
"n",
"-",
"x",
"if",
"gmpy2",
".",
"is_prime",
"(",
"y",
",",
"20",
")",
":",
"return",
"(",
"n",
",",
"[",
"int",
"(",
"x",
")",
",",
"int",
"(",
"y",
")",
"]",
")",
"# On prend le nombre premier suivant",
"x",
"=",
"gmpy2",
".",
"next_prime",
"(",
"x",
")"
] | [
29,
0
] | [
40,
31
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
|
OrganisationList.get | (self, request) | return JsonResponse(organisations, safe=False) | Voir les organisations. | Voir les organisations. | def get(self, request):
"""Voir les organisations."""
organisations = handler_get_request(request)
return JsonResponse(organisations, safe=False) | [
"def",
"get",
"(",
"self",
",",
"request",
")",
":",
"organisations",
"=",
"handler_get_request",
"(",
"request",
")",
"return",
"JsonResponse",
"(",
"organisations",
",",
"safe",
"=",
"False",
")"
] | [
180,
4
] | [
183,
54
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
Groupe.get_nombre_passagers | (self) | return len(self.list_passagers) | Renvoie le nombre de passagers dans le groupe considéré.
| Renvoie le nombre de passagers dans le groupe considéré.
| def get_nombre_passagers(self):
"""Renvoie le nombre de passagers dans le groupe considéré.
"""
return len(self.list_passagers) | [
"def",
"get_nombre_passagers",
"(",
"self",
")",
":",
"return",
"len",
"(",
"self",
".",
"list_passagers",
")"
] | [
162,
4
] | [
165,
39
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
consulterCompte | () | return render_template("compte.html") | Controleur de la route '/consulterCompte' | Controleur de la route '/consulterCompte' | def consulterCompte():
"Controleur de la route '/consulterCompte' "
return render_template("compte.html") | [
"def",
"consulterCompte",
"(",
")",
":",
"return",
"render_template",
"(",
"\"compte.html\"",
")"
] | [
184,
0
] | [
186,
41
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
Welcomer.check_owner_server | (self, member: discord.Member) | Vérifie si un nouvel arrivant est un propriétaire de serveur | Vérifie si un nouvel arrivant est un propriétaire de serveur | async def check_owner_server(self, member: discord.Member):
"""Vérifie si un nouvel arrivant est un propriétaire de serveur"""
servers = [x for x in self.bot.guilds if x.owner == member and x.member_count > 10]
if len(servers) > 0:
role = member.guild.get_role(486905171738361876)
if role is None:
self.bot.log.warning('[check_owner_server] Owner role not found')
return
if role not in member.roles:
await member.add_roles(role,reason="This user support me") | [
"async",
"def",
"check_owner_server",
"(",
"self",
",",
"member",
":",
"discord",
".",
"Member",
")",
":",
"servers",
"=",
"[",
"x",
"for",
"x",
"in",
"self",
".",
"bot",
".",
"guilds",
"if",
"x",
".",
"owner",
"==",
"member",
"and",
"x",
".",
"member_count",
">",
"10",
"]",
"if",
"len",
"(",
"servers",
")",
">",
"0",
":",
"role",
"=",
"member",
".",
"guild",
".",
"get_role",
"(",
"486905171738361876",
")",
"if",
"role",
"is",
"None",
":",
"self",
".",
"bot",
".",
"log",
".",
"warning",
"(",
"'[check_owner_server] Owner role not found'",
")",
"return",
"if",
"role",
"not",
"in",
"member",
".",
"roles",
":",
"await",
"member",
".",
"add_roles",
"(",
"role",
",",
"reason",
"=",
"\"This user support me\"",
")"
] | [
82,
4
] | [
91,
74
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
|
accounting_import_step0 | (request) | return redirect('accounting_main.views.accounting_import_step1', key) | Phase 0 de l'import: Crée une nouvelle session d'import | Phase 0 de l'import: Crée une nouvelle session d'import | def accounting_import_step0(request):
"""Phase 0 de l'import: Crée une nouvelle session d'import"""
from accounting_main.models import AccountingLine
if not AccountingLine.static_rights_can('IMPORT', request.user):
raise Http404
key = str(uuid.uuid4())
session_key = 'T2_ACCOUNTING_IMPORT_{}'.format(key)
request.session[session_key] = {'is_valid': True, 'has_data': False}
return redirect('accounting_main.views.accounting_import_step1', key) | [
"def",
"accounting_import_step0",
"(",
"request",
")",
":",
"from",
"accounting_main",
".",
"models",
"import",
"AccountingLine",
"if",
"not",
"AccountingLine",
".",
"static_rights_can",
"(",
"'IMPORT'",
",",
"request",
".",
"user",
")",
":",
"raise",
"Http404",
"key",
"=",
"str",
"(",
"uuid",
".",
"uuid4",
"(",
")",
")",
"session_key",
"=",
"'T2_ACCOUNTING_IMPORT_{}'",
".",
"format",
"(",
"key",
")",
"request",
".",
"session",
"[",
"session_key",
"]",
"=",
"{",
"'is_valid'",
":",
"True",
",",
"'has_data'",
":",
"False",
"}",
"return",
"redirect",
"(",
"'accounting_main.views.accounting_import_step1'",
",",
"key",
")"
] | [
123,
0
] | [
136,
73
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
rotation_matrix | (phi, theta, psi) | return np.dot(Rz_matrix(phi), np.dot(Rx_matrix(theta), Rz_matrix(psi))) | Retourne la matrice de rotation décrite par les angles.
| Retourne la matrice de rotation décrite par les angles.
| def rotation_matrix(phi, theta, psi):
"""Retourne la matrice de rotation décrite par les angles.
"""
return np.dot(Rz_matrix(phi), np.dot(Rx_matrix(theta), Rz_matrix(psi))) | [
"def",
"rotation_matrix",
"(",
"phi",
",",
"theta",
",",
"psi",
")",
":",
"return",
"np",
".",
"dot",
"(",
"Rz_matrix",
"(",
"phi",
")",
",",
"np",
".",
"dot",
"(",
"Rx_matrix",
"(",
"theta",
")",
",",
"Rz_matrix",
"(",
"psi",
")",
")",
")"
] | [
46,
0
] | [
49,
75
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
Events.remove_task | (self, ID:int) | return True | Enlève une tâche exécutée | Enlève une tâche exécutée | async def remove_task(self, ID:int):
"""Enlève une tâche exécutée"""
cnx = self.bot.cnx_frm
cursor = cnx.cursor()
query = ("DELETE FROM `timed` WHERE `timed`.`ID` = {}".format(ID))
cursor.execute(query)
cnx.commit()
cursor.close()
return True | [
"async",
"def",
"remove_task",
"(",
"self",
",",
"ID",
":",
"int",
")",
":",
"cnx",
"=",
"self",
".",
"bot",
".",
"cnx_frm",
"cursor",
"=",
"cnx",
".",
"cursor",
"(",
")",
"query",
"=",
"(",
"\"DELETE FROM `timed` WHERE `timed`.`ID` = {}\"",
".",
"format",
"(",
"ID",
")",
")",
"cursor",
".",
"execute",
"(",
"query",
")",
"cnx",
".",
"commit",
"(",
")",
"cursor",
".",
"close",
"(",
")",
"return",
"True"
] | [
472,
4
] | [
480,
19
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
est_premier | (n) | teste si le nombre est premier | teste si le nombre est premier | def est_premier(n):
""" teste si le nombre est premier """
if n <= 1:
return False
elif n == 2:
return True
elif n % 2 == 0:
return False
else:
i = 3
while i * i <= n:
if n % i == 0:
return False
i = i + 2
return True | [
"def",
"est_premier",
"(",
"n",
")",
":",
"if",
"n",
"<=",
"1",
":",
"return",
"False",
"elif",
"n",
"==",
"2",
":",
"return",
"True",
"elif",
"n",
"%",
"2",
"==",
"0",
":",
"return",
"False",
"else",
":",
"i",
"=",
"3",
"while",
"i",
"*",
"i",
"<=",
"n",
":",
"if",
"n",
"%",
"i",
"==",
"0",
":",
"return",
"False",
"i",
"=",
"i",
"+",
"2",
"return",
"True"
] | [
7,
0
] | [
21,
19
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
|
get_all_scenes | () | return activeScenes, scene_name | Récupération des scènes | Récupération des scènes | def get_all_scenes():
"""Récupération des scènes"""
# Liste des objets scènes
activeScenes = gl.getSceneList()
# Liste des noms de scènes
scene_name = []
for scn in activeScenes:
scene_name.append(scn.name)
return activeScenes, scene_name | [
"def",
"get_all_scenes",
"(",
")",
":",
"# Liste des objets scènes",
"activeScenes",
"=",
"gl",
".",
"getSceneList",
"(",
")",
"# Liste des noms de scènes",
"scene_name",
"=",
"[",
"]",
"for",
"scn",
"in",
"activeScenes",
":",
"scene_name",
".",
"append",
"(",
"scn",
".",
"name",
")",
"return",
"activeScenes",
",",
"scene_name"
] | [
18,
0
] | [
28,
35
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
Variance | (Mat) | return Toreturn | Renvois le vecteur des variances des colones d'un np.array | Renvois le vecteur des variances des colones d'un np.array | def Variance(Mat):
'''Renvois le vecteur des variances des colones d'un np.array'''
n=len(Mat)
Toreturn=np.zeros(n)
for i in range(n):
Toreturn[i]=np.var(Mat[i])
return Toreturn | [
"def",
"Variance",
"(",
"Mat",
")",
":",
"n",
"=",
"len",
"(",
"Mat",
")",
"Toreturn",
"=",
"np",
".",
"zeros",
"(",
"n",
")",
"for",
"i",
"in",
"range",
"(",
"n",
")",
":",
"Toreturn",
"[",
"i",
"]",
"=",
"np",
".",
"var",
"(",
"Mat",
"[",
"i",
"]",
")",
"return",
"Toreturn"
] | [
246,
0
] | [
254,
19
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
circle | (px, py, pr, pep=1) | return id | affichage d'un cercle de centre (px, py), de rayon pr et d'epaisseur pep
retour de l'identificateur unique de l'objet cree
| affichage d'un cercle de centre (px, py), de rayon pr et d'epaisseur pep
retour de l'identificateur unique de l'objet cree
| def circle(px, py, pr, pep=1):
"""affichage d'un cercle de centre (px, py), de rayon pr et d'epaisseur pep
retour de l'identificateur unique de l'objet cree
"""
# changement de repere
py = __ha - py
id = __canv.create_oval(
px - pr, py - pr, px + pr, py + pr, outline=__ccol, width=pep)
return id | [
"def",
"circle",
"(",
"px",
",",
"py",
",",
"pr",
",",
"pep",
"=",
"1",
")",
":",
"# changement de repere",
"py",
"=",
"__ha",
"-",
"py",
"id",
"=",
"__canv",
".",
"create_oval",
"(",
"px",
"-",
"pr",
",",
"py",
"-",
"pr",
",",
"px",
"+",
"pr",
",",
"py",
"+",
"pr",
",",
"outline",
"=",
"__ccol",
",",
"width",
"=",
"pep",
")",
"return",
"id"
] | [
246,
0
] | [
254,
13
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
Joueur.lire_touches | (self) | Lis ce que le joueur fait
On agit en conséquence, ex: si le joueur appuie en haut le
sprite va en haut, etc.
| Lis ce que le joueur fait
On agit en conséquence, ex: si le joueur appuie en haut le
sprite va en haut, etc.
| def lire_touches(self):
"""Lis ce que le joueur fait
On agit en conséquence, ex: si le joueur appuie en haut le
sprite va en haut, etc.
"""
touches = pg.key.get_pressed() # Touches enfoncées
if not self.libre: # Si le personnage est occupé
return # Quitter la fonction
if self.hitbox.mask is None: # Si le hitbox est pas défini
return # Quitter la fonction pour éviter un déplacement précoce
for touche in cj.touches: # Je parcours les touches enfoncées
if touches[touche]: # Si la touche est définie dans constantes
touche = cj.touches[touche] # touche = sa liste correspondante
if touche[2] is not None: # Si l'animation change la direction
self.direction = touche[2] # Modif direction
if self.mouvement != touche[3]: # Si le mouvement change
self.mouvement = touche[3] # Changer le mouvement du perso
self.compteur = 0 # Recommencer les animations
self.frame = 0 # Réinitialiser les frames
self.libre = touche[4] # Changer disponibilité du perso
# Capturer les déplacements
x = touche[0] # Nombre de pixels en x
y = touche[1] # Nombre de pixels en x
# Déplacer le hitbox pour tester la position
cp.map.bouger_hitbox(x, y)
if self.hitbox.collision("tuile"): # Si il y a collision:
# Annuler le déplacement de la hitbox de la map
cp.map.bouger_hitbox(-x, -y)
else: # Sinon, si il y a pas collision
cp.map.bouger(x, y)
break # Casser la boucle: Touche trouvée. On évite les autres
else: # Si la boucle n'est pas cassée: Aucune touche trouvée
self.mouvement = "base" # On dit qu'il n'y a aucun mouvement
self.libre = True | [
"def",
"lire_touches",
"(",
"self",
")",
":",
"touches",
"=",
"pg",
".",
"key",
".",
"get_pressed",
"(",
")",
"# Touches enfoncées",
"if",
"not",
"self",
".",
"libre",
":",
"# Si le personnage est occupé",
"return",
"# Quitter la fonction",
"if",
"self",
".",
"hitbox",
".",
"mask",
"is",
"None",
":",
"# Si le hitbox est pas défini",
"return",
"# Quitter la fonction pour éviter un déplacement précoce",
"for",
"touche",
"in",
"cj",
".",
"touches",
":",
"# Je parcours les touches enfoncées",
"if",
"touches",
"[",
"touche",
"]",
":",
"# Si la touche est définie dans constantes",
"touche",
"=",
"cj",
".",
"touches",
"[",
"touche",
"]",
"# touche = sa liste correspondante",
"if",
"touche",
"[",
"2",
"]",
"is",
"not",
"None",
":",
"# Si l'animation change la direction",
"self",
".",
"direction",
"=",
"touche",
"[",
"2",
"]",
"# Modif direction",
"if",
"self",
".",
"mouvement",
"!=",
"touche",
"[",
"3",
"]",
":",
"# Si le mouvement change",
"self",
".",
"mouvement",
"=",
"touche",
"[",
"3",
"]",
"# Changer le mouvement du perso",
"self",
".",
"compteur",
"=",
"0",
"# Recommencer les animations",
"self",
".",
"frame",
"=",
"0",
"# Réinitialiser les frames",
"self",
".",
"libre",
"=",
"touche",
"[",
"4",
"]",
"# Changer disponibilité du perso",
"# Capturer les déplacements",
"x",
"=",
"touche",
"[",
"0",
"]",
"# Nombre de pixels en x",
"y",
"=",
"touche",
"[",
"1",
"]",
"# Nombre de pixels en x",
"# Déplacer le hitbox pour tester la position",
"cp",
".",
"map",
".",
"bouger_hitbox",
"(",
"x",
",",
"y",
")",
"if",
"self",
".",
"hitbox",
".",
"collision",
"(",
"\"tuile\"",
")",
":",
"# Si il y a collision:",
"# Annuler le déplacement de la hitbox de la map",
"cp",
".",
"map",
".",
"bouger_hitbox",
"(",
"-",
"x",
",",
"-",
"y",
")",
"else",
":",
"# Sinon, si il y a pas collision",
"cp",
".",
"map",
".",
"bouger",
"(",
"x",
",",
"y",
")",
"break",
"# Casser la boucle: Touche trouvée. On évite les autres",
"else",
":",
"# Si la boucle n'est pas cassée: Aucune touche trouvée",
"self",
".",
"mouvement",
"=",
"\"base\"",
"# On dit qu'il n'y a aucun mouvement",
"self",
".",
"libre",
"=",
"True"
] | [
45,
4
] | [
82,
29
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
|
Errors.senf_err_msg | (self, msg: str) | return True | Envoie un message dans le salon d'erreur | Envoie un message dans le salon d'erreur | async def senf_err_msg(self, msg: str):
"""Envoie un message dans le salon d'erreur"""
salon = self.bot.get_channel(626039503714254858)
if salon is None:
return False
if len(msg) > 2000:
if msg.endswith("```"):
msg = msg[:1997]+"```"
else:
msg = msg[:2000]
await salon.send(msg)
return True | [
"async",
"def",
"senf_err_msg",
"(",
"self",
",",
"msg",
":",
"str",
")",
":",
"salon",
"=",
"self",
".",
"bot",
".",
"get_channel",
"(",
"626039503714254858",
")",
"if",
"salon",
"is",
"None",
":",
"return",
"False",
"if",
"len",
"(",
"msg",
")",
">",
"2000",
":",
"if",
"msg",
".",
"endswith",
"(",
"\"```\"",
")",
":",
"msg",
"=",
"msg",
"[",
":",
"1997",
"]",
"+",
"\"```\"",
"else",
":",
"msg",
"=",
"msg",
"[",
":",
"2000",
"]",
"await",
"salon",
".",
"send",
"(",
"msg",
")",
"return",
"True"
] | [
188,
4
] | [
199,
19
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
print_sequence_polynomials | (poly_list, abs_list, ord_list, eps = epsilon, color = 'b') | Affiche une liste de polynômes correspondant à une liste de points | Affiche une liste de polynômes correspondant à une liste de points | def print_sequence_polynomials(poly_list, abs_list, ord_list, eps = epsilon, color = 'b'):
""" Affiche une liste de polynômes correspondant à une liste de points """
for i in range(len(poly_list)):
print_polynomial (poly_list[i], min(abs_list[i], abs_list[i+1]), max(abs_list[i], abs_list[i+1]) ,eps, color)
mp.ylim([-3*max(ey),3*max(ey)]) | [
"def",
"print_sequence_polynomials",
"(",
"poly_list",
",",
"abs_list",
",",
"ord_list",
",",
"eps",
"=",
"epsilon",
",",
"color",
"=",
"'b'",
")",
":",
"for",
"i",
"in",
"range",
"(",
"len",
"(",
"poly_list",
")",
")",
":",
"print_polynomial",
"(",
"poly_list",
"[",
"i",
"]",
",",
"min",
"(",
"abs_list",
"[",
"i",
"]",
",",
"abs_list",
"[",
"i",
"+",
"1",
"]",
")",
",",
"max",
"(",
"abs_list",
"[",
"i",
"]",
",",
"abs_list",
"[",
"i",
"+",
"1",
"]",
")",
",",
"eps",
",",
"color",
")",
"mp",
".",
"ylim",
"(",
"[",
"-",
"3",
"*",
"max",
"(",
"ey",
")",
",",
"3",
"*",
"max",
"(",
"ey",
")",
"]",
")"
] | [
144,
0
] | [
148,
33
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
|
Xp.calc_xp | (self, msg: discord.Message) | return min(round(len(content)*self.xp_per_char), self.max_xp_per_msg) | Calcule le nombre d'xp correspondant à un message | Calcule le nombre d'xp correspondant à un message | async def calc_xp(self, msg: discord.Message):
"""Calcule le nombre d'xp correspondant à un message"""
content = msg.clean_content
matches = re.finditer(r"<a?(:\w+:)\d+>", content, re.MULTILINE)
for _, match in enumerate(matches, start=1):
content = content.replace(match.group(0),match.group(1))
matches = re.finditer(r'((?:http|www)[^\s]+)', content, re.MULTILINE)
for _, match in enumerate(matches, start=1):
content = content.replace(match.group(0),"")
return min(round(len(content)*self.xp_per_char), self.max_xp_per_msg) | [
"async",
"def",
"calc_xp",
"(",
"self",
",",
"msg",
":",
"discord",
".",
"Message",
")",
":",
"content",
"=",
"msg",
".",
"clean_content",
"matches",
"=",
"re",
".",
"finditer",
"(",
"r\"<a?(:\\w+:)\\d+>\"",
",",
"content",
",",
"re",
".",
"MULTILINE",
")",
"for",
"_",
",",
"match",
"in",
"enumerate",
"(",
"matches",
",",
"start",
"=",
"1",
")",
":",
"content",
"=",
"content",
".",
"replace",
"(",
"match",
".",
"group",
"(",
"0",
")",
",",
"match",
".",
"group",
"(",
"1",
")",
")",
"matches",
"=",
"re",
".",
"finditer",
"(",
"r'((?:http|www)[^\\s]+)'",
",",
"content",
",",
"re",
".",
"MULTILINE",
")",
"for",
"_",
",",
"match",
"in",
"enumerate",
"(",
"matches",
",",
"start",
"=",
"1",
")",
":",
"content",
"=",
"content",
".",
"replace",
"(",
"match",
".",
"group",
"(",
"0",
")",
",",
"\"\"",
")",
"return",
"min",
"(",
"round",
"(",
"len",
"(",
"content",
")",
"*",
"self",
".",
"xp_per_char",
")",
",",
"self",
".",
"max_xp_per_msg",
")"
] | [
258,
4
] | [
267,
77
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
Crud.get_form_values | (self, elements, dico=None) | return dico | Remplir "dict" avec les valeurs des champs du formulaire courant | Remplir "dict" avec les valeurs des champs du formulaire courant | def get_form_values(self, elements, dico=None):
""" Remplir "dict" avec les valeurs des champs du formulaire courant """
if dico is None:
dico = {}
for element in elements:
crudel = elements[element].get("crudel")
dico[element] = crudel.get_value()
return dico | [
"def",
"get_form_values",
"(",
"self",
",",
"elements",
",",
"dico",
"=",
"None",
")",
":",
"if",
"dico",
"is",
"None",
":",
"dico",
"=",
"{",
"}",
"for",
"element",
"in",
"elements",
":",
"crudel",
"=",
"elements",
"[",
"element",
"]",
".",
"get",
"(",
"\"crudel\"",
")",
"dico",
"[",
"element",
"]",
"=",
"crudel",
".",
"get_value",
"(",
")",
"return",
"dico"
] | [
506,
4
] | [
513,
19
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
OscAug.out | (self, chnl=0) | return self | Out basique pour objet de type trame | Out basique pour objet de type trame | def out(self, chnl=0):
"Out basique pour objet de type trame"
self.objs.out(chnl)
self.fade.play()
return self | [
"def",
"out",
"(",
"self",
",",
"chnl",
"=",
"0",
")",
":",
"self",
".",
"objs",
".",
"out",
"(",
"chnl",
")",
"self",
".",
"fade",
".",
"play",
"(",
")",
"return",
"self"
] | [
46,
4
] | [
50,
19
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
Crud.set_view_prop | (self, prop, value) | Ajouter/mettre à jour une propriété de la vue courante | Ajouter/mettre à jour une propriété de la vue courante | def set_view_prop(self, prop, value):
""" Ajouter/mettre à jour une propriété de la vue courante """
self.application["tables"][self.ctx["table_id"]]["views"][self.ctx["view_id"]][prop] = value | [
"def",
"set_view_prop",
"(",
"self",
",",
"prop",
",",
"value",
")",
":",
"self",
".",
"application",
"[",
"\"tables\"",
"]",
"[",
"self",
".",
"ctx",
"[",
"\"table_id\"",
"]",
"]",
"[",
"\"views\"",
"]",
"[",
"self",
".",
"ctx",
"[",
"\"view_id\"",
"]",
"]",
"[",
"prop",
"]",
"=",
"value"
] | [
498,
4
] | [
500,
100
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
|
Organisation.get_referents | (self) | return [e.profile.user for e in entries if e.profile.is_active] | Retourner la liste des utilisateurs référents de l'organisation. | Retourner la liste des utilisateurs référents de l'organisation. | def get_referents(self):
"""Retourner la liste des utilisateurs référents de l'organisation."""
Nexus = apps.get_model(app_label='idgo_admin', model_name='LiaisonsReferents')
entries = Nexus.objects.filter(organisation=self, validated_on__isnull=False)
return [e.profile.user for e in entries if e.profile.is_active] | [
"def",
"get_referents",
"(",
"self",
")",
":",
"Nexus",
"=",
"apps",
".",
"get_model",
"(",
"app_label",
"=",
"'idgo_admin'",
",",
"model_name",
"=",
"'LiaisonsReferents'",
")",
"entries",
"=",
"Nexus",
".",
"objects",
".",
"filter",
"(",
"organisation",
"=",
"self",
",",
"validated_on__isnull",
"=",
"False",
")",
"return",
"[",
"e",
".",
"profile",
".",
"user",
"for",
"e",
"in",
"entries",
"if",
"e",
".",
"profile",
".",
"is_active",
"]"
] | [
296,
4
] | [
300,
71
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
Game._id_to_position | (self, id) | return (id % self.n, id // self.n) | Réciproque de la fonction précédente | Réciproque de la fonction précédente | def _id_to_position(self, id):
"""Réciproque de la fonction précédente"""
return (id % self.n, id // self.n) | [
"def",
"_id_to_position",
"(",
"self",
",",
"id",
")",
":",
"return",
"(",
"id",
"%",
"self",
".",
"n",
",",
"id",
"//",
"self",
".",
"n",
")"
] | [
35,
4
] | [
37,
42
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
Storage.get_relations | (self) | return result | Récupère la liste des relations | Récupère la liste des relations | def get_relations(self):
"""Récupère la liste des relations"""
cursor = self.connection.cursor()
cursor.execute("SELECT * FROM relations")
result = cursor.fetchall()
return result | [
"def",
"get_relations",
"(",
"self",
")",
":",
"cursor",
"=",
"self",
".",
"connection",
".",
"cursor",
"(",
")",
"cursor",
".",
"execute",
"(",
"\"SELECT * FROM relations\"",
")",
"result",
"=",
"cursor",
".",
"fetchall",
"(",
")",
"return",
"result"
] | [
47,
4
] | [
52,
21
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
create_day_with_fish_columns | (X) | return X | Cette fonction permet de créer les dummies variables * effectif : jour_avec/sans_poisson
Pour les lundis, mardis et jeudis. | Cette fonction permet de créer les dummies variables * effectif : jour_avec/sans_poisson
Pour les lundis, mardis et jeudis. | def create_day_with_fish_columns(X):
"""Cette fonction permet de créer les dummies variables * effectif : jour_avec/sans_poisson
Pour les lundis, mardis et jeudis."""
# On crée des dummies pour chaque jour
X = pd.concat([pd.get_dummies(X["jour"]), X], axis=1)
# Produits de : dummy jour / dummy poisson et effectif
for day in ["Lundi", "Mardi", "Jeudi"]:
X[day + "_avec_poisson"] = X[day] * X["poisson"] * X["effectif"]
X[day + "_sans_poisson"] = X[day] * X["poisson"].apply(lambda x: 1 - x) * X["effectif"]
# Supprimer colonnes non utilisées
for col in ["jour", "Vendredi", "Lundi", "Mardi", "Jeudi", "poisson"]:
X.drop(col, axis=1, inplace=True)
return X | [
"def",
"create_day_with_fish_columns",
"(",
"X",
")",
":",
"# On crée des dummies pour chaque jour",
"X",
"=",
"pd",
".",
"concat",
"(",
"[",
"pd",
".",
"get_dummies",
"(",
"X",
"[",
"\"jour\"",
"]",
")",
",",
"X",
"]",
",",
"axis",
"=",
"1",
")",
"# Produits de : dummy jour / dummy poisson et effectif",
"for",
"day",
"in",
"[",
"\"Lundi\"",
",",
"\"Mardi\"",
",",
"\"Jeudi\"",
"]",
":",
"X",
"[",
"day",
"+",
"\"_avec_poisson\"",
"]",
"=",
"X",
"[",
"day",
"]",
"*",
"X",
"[",
"\"poisson\"",
"]",
"*",
"X",
"[",
"\"effectif\"",
"]",
"X",
"[",
"day",
"+",
"\"_sans_poisson\"",
"]",
"=",
"X",
"[",
"day",
"]",
"*",
"X",
"[",
"\"poisson\"",
"]",
".",
"apply",
"(",
"lambda",
"x",
":",
"1",
"-",
"x",
")",
"*",
"X",
"[",
"\"effectif\"",
"]",
"# Supprimer colonnes non utilisées",
"for",
"col",
"in",
"[",
"\"jour\"",
",",
"\"Vendredi\"",
",",
"\"Lundi\"",
",",
"\"Mardi\"",
",",
"\"Jeudi\"",
",",
"\"poisson\"",
"]",
":",
"X",
".",
"drop",
"(",
"col",
",",
"axis",
"=",
"1",
",",
"inplace",
"=",
"True",
")",
"return",
"X"
] | [
79,
0
] | [
95,
12
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
french_to_english | (french_text) | return english_text | traduit francais en anglais | traduit francais en anglais | def french_to_english(french_text):
""" traduit francais en anglais"""
if french_text is None:
english_text=None
else:
l_t = get_language_translator(apikey, version, url)
translation = l_t.translate(
text=french_text,
model_id='fr-en').get_result()
english_text = translation['translations'][0]['translation']
return english_text | [
"def",
"french_to_english",
"(",
"french_text",
")",
":",
"if",
"french_text",
"is",
"None",
":",
"english_text",
"=",
"None",
"else",
":",
"l_t",
"=",
"get_language_translator",
"(",
"apikey",
",",
"version",
",",
"url",
")",
"translation",
"=",
"l_t",
".",
"translate",
"(",
"text",
"=",
"french_text",
",",
"model_id",
"=",
"'fr-en'",
")",
".",
"get_result",
"(",
")",
"english_text",
"=",
"translation",
"[",
"'translations'",
"]",
"[",
"0",
"]",
"[",
"'translation'",
"]",
"return",
"english_text"
] | [
34,
0
] | [
44,
23
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
changeDateOfMonth | (x: str) | Change le format de la date du mois
Paramètres
----------
x : string
Retours
-------
x : string
Exemples
-------
changeDateOfMonth('JUL 2021') -> '2021-07 | Change le format de la date du mois | def changeDateOfMonth(x: str):
"""Change le format de la date du mois
Paramètres
----------
x : string
Retours
-------
x : string
Exemples
-------
changeDateOfMonth('JUL 2021') -> '2021-07'"""
try:
return datetime.strptime(x, "%b %Y").strftime("%Y-%m")
except ValueError:
return x | [
"def",
"changeDateOfMonth",
"(",
"x",
":",
"str",
")",
":",
"try",
":",
"return",
"datetime",
".",
"strptime",
"(",
"x",
",",
"\"%b %Y\"",
")",
".",
"strftime",
"(",
"\"%Y-%m\"",
")",
"except",
"ValueError",
":",
"return",
"x"
] | [
26,
0
] | [
44,
16
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
|
length_lambda_down | (poly_list, abs_list) | return length_result | retourne la longueur d'une ligne d'air de l'aile (partie inférieure) | retourne la longueur d'une ligne d'air de l'aile (partie inférieure) | def length_lambda_down(poly_list, abs_list):
""" retourne la longueur d'une ligne d'air de l'aile (partie inférieure)"""
length_result = 0
derivate_list = sp.derivate_sequence_polynomials(poly_list)
for i in range (len (abs_list)-1):
length_result += pcl.length(derivate_list[i], pcl.uniform_subdivision,abs_list[i], abs_list[i+1], 2, pcl.simpson)
return length_result | [
"def",
"length_lambda_down",
"(",
"poly_list",
",",
"abs_list",
")",
":",
"length_result",
"=",
"0",
"derivate_list",
"=",
"sp",
".",
"derivate_sequence_polynomials",
"(",
"poly_list",
")",
"for",
"i",
"in",
"range",
"(",
"len",
"(",
"abs_list",
")",
"-",
"1",
")",
":",
"length_result",
"+=",
"pcl",
".",
"length",
"(",
"derivate_list",
"[",
"i",
"]",
",",
"pcl",
".",
"uniform_subdivision",
",",
"abs_list",
"[",
"i",
"]",
",",
"abs_list",
"[",
"i",
"+",
"1",
"]",
",",
"2",
",",
"pcl",
".",
"simpson",
")",
"return",
"length_result"
] | [
82,
0
] | [
88,
22
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
chemin_vers | (s, dist_a, arc_vers) | return chemin | Renvoie le chemin vers le sommet s. | Renvoie le chemin vers le sommet s. | def chemin_vers(s, dist_a, arc_vers):
"""Renvoie le chemin vers le sommet s."""
if dist_a[s] == None:
return None
chemin = []
arc = arc_vers[s]
while arc != None:
predecesseur = arc.origine
chemin.insert(0, predecesseur)
arc = arc_vers[predecesseur]
return chemin | [
"def",
"chemin_vers",
"(",
"s",
",",
"dist_a",
",",
"arc_vers",
")",
":",
"if",
"dist_a",
"[",
"s",
"]",
"==",
"None",
":",
"return",
"None",
"chemin",
"=",
"[",
"]",
"arc",
"=",
"arc_vers",
"[",
"s",
"]",
"while",
"arc",
"!=",
"None",
":",
"predecesseur",
"=",
"arc",
".",
"origine",
"chemin",
".",
"insert",
"(",
"0",
",",
"predecesseur",
")",
"arc",
"=",
"arc_vers",
"[",
"predecesseur",
"]",
"return",
"chemin"
] | [
241,
0
] | [
253,
17
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
Admin.send_guilds_list | (self, ctx: MyContext) | Obtenir la liste de tout les serveurs | Obtenir la liste de tout les serveurs | async def send_guilds_list(self, ctx: MyContext):
"""Obtenir la liste de tout les serveurs"""
text = str()
for x in sorted(ctx.bot.guilds, key=operator.attrgetter('me.joined_at')):
text += "- {} (`{}` - {} membres)\n".format(x.name,x.owner,len(x.members))
if len(text) > 1900:
await ctx.send(text)
text = ""
if len(text) > 0:
await ctx.send(text) | [
"async",
"def",
"send_guilds_list",
"(",
"self",
",",
"ctx",
":",
"MyContext",
")",
":",
"text",
"=",
"str",
"(",
")",
"for",
"x",
"in",
"sorted",
"(",
"ctx",
".",
"bot",
".",
"guilds",
",",
"key",
"=",
"operator",
".",
"attrgetter",
"(",
"'me.joined_at'",
")",
")",
":",
"text",
"+=",
"\"- {} (`{}` - {} membres)\\n\"",
".",
"format",
"(",
"x",
".",
"name",
",",
"x",
".",
"owner",
",",
"len",
"(",
"x",
".",
"members",
")",
")",
"if",
"len",
"(",
"text",
")",
">",
"1900",
":",
"await",
"ctx",
".",
"send",
"(",
"text",
")",
"text",
"=",
"\"\"",
"if",
"len",
"(",
"text",
")",
">",
"0",
":",
"await",
"ctx",
".",
"send",
"(",
"text",
")"
] | [
277,
4
] | [
286,
32
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
|
placements_to_json | (placements) | return json.dumps(placements_new, indent=2) | Utilitaire pour avoir un dictionnaire avec des strings et non des tuples.
Permet de debug.
| Utilitaire pour avoir un dictionnaire avec des strings et non des tuples.
Permet de debug.
| def placements_to_json(placements):
"""Utilitaire pour avoir un dictionnaire avec des strings et non des tuples.
Permet de debug.
"""
# print(placements)
placements_new = {f"({str(key[0])}, {str(key[1])})": f"({str(val[0])}, {str(val[1])})" for key, val in placements.items()}
return json.dumps(placements_new, indent=2) | [
"def",
"placements_to_json",
"(",
"placements",
")",
":",
"# print(placements)",
"placements_new",
"=",
"{",
"f\"({str(key[0])}, {str(key[1])})\"",
":",
"f\"({str(val[0])}, {str(val[1])})\"",
"for",
"key",
",",
"val",
"in",
"placements",
".",
"items",
"(",
")",
"}",
"return",
"json",
".",
"dumps",
"(",
"placements_new",
",",
"indent",
"=",
"2",
")"
] | [
245,
0
] | [
251,
47
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
Odrive.Display_position | (self,duration_in_sec) | Affiche la position estimee par le Odrive durant le temps indiquee en argument - Thread blocking | Affiche la position estimee par le Odrive durant le temps indiquee en argument - Thread blocking | def Display_position(self,duration_in_sec):
"""Affiche la position estimee par le Odrive durant le temps indiquee en argument - Thread blocking"""
for i in range(duration_in_sec):
print(self.motor0.encoder.pos_estimate) # Estimated position by Odrive (readonly)
print(self.motor1.encoder.pos_estimate)
sleep(1) | [
"def",
"Display_position",
"(",
"self",
",",
"duration_in_sec",
")",
":",
"for",
"i",
"in",
"range",
"(",
"duration_in_sec",
")",
":",
"print",
"(",
"self",
".",
"motor0",
".",
"encoder",
".",
"pos_estimate",
")",
"# Estimated position by Odrive (readonly)",
"print",
"(",
"self",
".",
"motor1",
".",
"encoder",
".",
"pos_estimate",
")",
"sleep",
"(",
"1",
")"
] | [
198,
1
] | [
203,
11
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
|
ResourceList.get | (self, request, dataset_name) | return JsonResponse(
[serialize(resource) for resource in resources], safe=False) | Voir les ressources du jeu de données. | Voir les ressources du jeu de données. | def get(self, request, dataset_name):
"""Voir les ressources du jeu de données."""
resources = handler_get_request(request, dataset_name)
return JsonResponse(
[serialize(resource) for resource in resources], safe=False) | [
"def",
"get",
"(",
"self",
",",
"request",
",",
"dataset_name",
")",
":",
"resources",
"=",
"handler_get_request",
"(",
"request",
",",
"dataset_name",
")",
"return",
"JsonResponse",
"(",
"[",
"serialize",
"(",
"resource",
")",
"for",
"resource",
"in",
"resources",
"]",
",",
"safe",
"=",
"False",
")"
] | [
298,
4
] | [
302,
72
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
InfoCog.all_commands | (self, ctx: Context) | Un commande d'aide générale listant toute les commandes. | Un commande d'aide générale listant toute les commandes. | async def all_commands(self, ctx: Context):
"""Un commande d'aide générale listant toute les commandes."""
available_commands: List[Command] = [
command for command in self.client.commands
if await can_ctx_run(ctx, command)
]
embed = discord.Embed(
title='All commands',
description=(
f"> `{len(available_commands)}` commandes disponibles"
),
colour=0x363F61
)
for c, command in enumerate(
sorted(available_commands, key=lambda x: x.name)
):
embed.add_field(
name=f"{c + 1}. {command.name}",
value=command.help
)
await ctx.send(embed=embed) | [
"async",
"def",
"all_commands",
"(",
"self",
",",
"ctx",
":",
"Context",
")",
":",
"available_commands",
":",
"List",
"[",
"Command",
"]",
"=",
"[",
"command",
"for",
"command",
"in",
"self",
".",
"client",
".",
"commands",
"if",
"await",
"can_ctx_run",
"(",
"ctx",
",",
"command",
")",
"]",
"embed",
"=",
"discord",
".",
"Embed",
"(",
"title",
"=",
"'All commands'",
",",
"description",
"=",
"(",
"f\"> `{len(available_commands)}` commandes disponibles\"",
")",
",",
"colour",
"=",
"0x363F61",
")",
"for",
"c",
",",
"command",
"in",
"enumerate",
"(",
"sorted",
"(",
"available_commands",
",",
"key",
"=",
"lambda",
"x",
":",
"x",
".",
"name",
")",
")",
":",
"embed",
".",
"add_field",
"(",
"name",
"=",
"f\"{c + 1}. {command.name}\"",
",",
"value",
"=",
"command",
".",
"help",
")",
"await",
"ctx",
".",
"send",
"(",
"embed",
"=",
"embed",
")"
] | [
18,
4
] | [
42,
35
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
|
EquipamentoAcesso.remove | (cls, authenticated_user, id_equipamento, id_tipo_acesso) | Efetua a remoção de um tipo de acesso
@param id_equipamento: Identificador do equipamento da informação de acesso a equipamento a ser excluída
@param id_tipo_acesso: Identificador do tipo de acesso da informação de acesso a equipamento a ser excluída
@return: nothing
@raise EquipamentoAcesso.DoesNotExist: Informação de acesso a equipamento informada é inexistente
@raise EquipamentoError: Falha ao alterar informação de acesso a equipamento.
| Efetua a remoção de um tipo de acesso
| def remove(cls, authenticated_user, id_equipamento, id_tipo_acesso):
"""Efetua a remoção de um tipo de acesso
@param id_equipamento: Identificador do equipamento da informação de acesso a equipamento a ser excluída
@param id_tipo_acesso: Identificador do tipo de acesso da informação de acesso a equipamento a ser excluída
@return: nothing
@raise EquipamentoAcesso.DoesNotExist: Informação de acesso a equipamento informada é inexistente
@raise EquipamentoError: Falha ao alterar informação de acesso a equipamento.
"""
try:
# Obtém a informação de acesso a equipamento a ser excluída
equipamento_acesso = EquipamentoAcesso.objects.get(
equipamento__id=id_equipamento, tipo_acesso__id=id_tipo_acesso)
return equipamento_acesso.delete()
except EquipamentoAcesso.DoesNotExist as e:
raise e
except Exception as e:
EquipamentoAcesso.log.error(
u'Falha ao excluir informação de acesso a equipamento.')
raise EquipamentoError(
e, u'Falha ao excluir informação de acesso a equipamento.') | [
"def",
"remove",
"(",
"cls",
",",
"authenticated_user",
",",
"id_equipamento",
",",
"id_tipo_acesso",
")",
":",
"try",
":",
"# Obtém a informação de acesso a equipamento a ser excluída",
"equipamento_acesso",
"=",
"EquipamentoAcesso",
".",
"objects",
".",
"get",
"(",
"equipamento__id",
"=",
"id_equipamento",
",",
"tipo_acesso__id",
"=",
"id_tipo_acesso",
")",
"return",
"equipamento_acesso",
".",
"delete",
"(",
")",
"except",
"EquipamentoAcesso",
".",
"DoesNotExist",
"as",
"e",
":",
"raise",
"e",
"except",
"Exception",
"as",
"e",
":",
"EquipamentoAcesso",
".",
"log",
".",
"error",
"(",
"u'Falha ao excluir informação de acesso a equipamento.')",
"",
"raise",
"EquipamentoError",
"(",
"e",
",",
"u'Falha ao excluir informação de acesso a equipamento.')",
""
] | [
1789,
4
] | [
1810,
77
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Button.__init__ | (self, ai_settings, screen, msg) | Inicializa os atributos do botão | Inicializa os atributos do botão | def __init__(self, ai_settings, screen, msg):
"""Inicializa os atributos do botão"""
self.screen = screen
self.screen_rect = screen.get_rect()
# Define as dimensões e as propriedades do botão
self.width, self.height = 500, 50
self.button_color = (0, 0, 0)
self.text_color = (255, 255, 255)
self.font = pygame.font.SysFont(None, 48, italic=True)
# Constrói o objeto rect do botão e o centraliza
self.rect = pygame.Rect(0, 0, self.width, self.height)
self.rect.center = self.screen_rect.center
# A mensagem do botão deve ser preparada apenas uma vez
self.prep_msg(msg) | [
"def",
"__init__",
"(",
"self",
",",
"ai_settings",
",",
"screen",
",",
"msg",
")",
":",
"self",
".",
"screen",
"=",
"screen",
"self",
".",
"screen_rect",
"=",
"screen",
".",
"get_rect",
"(",
")",
"# Define as dimensões e as propriedades do botão",
"self",
".",
"width",
",",
"self",
".",
"height",
"=",
"500",
",",
"50",
"self",
".",
"button_color",
"=",
"(",
"0",
",",
"0",
",",
"0",
")",
"self",
".",
"text_color",
"=",
"(",
"255",
",",
"255",
",",
"255",
")",
"self",
".",
"font",
"=",
"pygame",
".",
"font",
".",
"SysFont",
"(",
"None",
",",
"48",
",",
"italic",
"=",
"True",
")",
"# Constrói o objeto rect do botão e o centraliza",
"self",
".",
"rect",
"=",
"pygame",
".",
"Rect",
"(",
"0",
",",
"0",
",",
"self",
".",
"width",
",",
"self",
".",
"height",
")",
"self",
".",
"rect",
".",
"center",
"=",
"self",
".",
"screen_rect",
".",
"center",
"# A mensagem do botão deve ser preparada apenas uma vez",
"self",
".",
"prep_msg",
"(",
"msg",
")"
] | [
5,
4
] | [
21,
26
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
ModelBasedReflexAgentProgram | (rules, update_state) | return program | Esse agente toma ação com base no percepto e estado. | Esse agente toma ação com base no percepto e estado. | def ModelBasedReflexAgentProgram(rules, update_state):
"Esse agente toma ação com base no percepto e estado."
def program(percept):
program.state = update_state(program.state, program.action, percept)
rule = rule_match(program.state, rules)
action = rule.action
return action
program.state = program.action = None
return program | [
"def",
"ModelBasedReflexAgentProgram",
"(",
"rules",
",",
"update_state",
")",
":",
"def",
"program",
"(",
"percept",
")",
":",
"program",
".",
"state",
"=",
"update_state",
"(",
"program",
".",
"state",
",",
"program",
".",
"action",
",",
"percept",
")",
"rule",
"=",
"rule_match",
"(",
"program",
".",
"state",
",",
"rules",
")",
"action",
"=",
"rule",
".",
"action",
"return",
"action",
"program",
".",
"state",
"=",
"program",
".",
"action",
"=",
"None",
"return",
"program"
] | [
105,
0
] | [
113,
18
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
GrupoL3.create_v3 | (self, env) | Efetua a inclusão de um novo o Ambiente.
| Efetua a inclusão de um novo o Ambiente.
| def create_v3(self, env):
"""Efetua a inclusão de um novo o Ambiente.
"""
log.debug("create L3 environment")
try:
try:
GrupoL3.objects.get(nome__iexact=env.get('name'))
raise AmbienteDuplicatedError(None, u'Ambiente L3 duplicado.')
except Exception:
self.log.debug('Ambiente L3 não duplicado.')
self.nome = env.get('name')
return self.save()
except Exception, e:
self.log.error(u'Falha ao inserir um Ambiente L3. Error: %s' % e)
raise AmbienteError(
'Falha ao inserir um Ambiente L3. Error: %s' % e) | [
"def",
"create_v3",
"(",
"self",
",",
"env",
")",
":",
"log",
".",
"debug",
"(",
"\"create L3 environment\"",
")",
"try",
":",
"try",
":",
"GrupoL3",
".",
"objects",
".",
"get",
"(",
"nome__iexact",
"=",
"env",
".",
"get",
"(",
"'name'",
")",
")",
"raise",
"AmbienteDuplicatedError",
"(",
"None",
",",
"u'Ambiente L3 duplicado.'",
")",
"except",
"Exception",
":",
"self",
".",
"log",
".",
"debug",
"(",
"'Ambiente L3 não duplicado.')",
"",
"self",
".",
"nome",
"=",
"env",
".",
"get",
"(",
"'name'",
")",
"return",
"self",
".",
"save",
"(",
")",
"except",
"Exception",
",",
"e",
":",
"self",
".",
"log",
".",
"error",
"(",
"u'Falha ao inserir um Ambiente L3. Error: %s'",
"%",
"e",
")",
"raise",
"AmbienteError",
"(",
"'Falha ao inserir um Ambiente L3. Error: %s'",
"%",
"e",
")"
] | [
283,
4
] | [
303,
65
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Motors.__init__ | (self, left_motor_topic, right_motor_topic) | Cria um novo objeto para controlar os dois motores de um carrinho
Args:
left_motor_topic (string): Nome do tópico do motor esquerdo
right_motor_topic (string): Nome do tópico do motor direito
| Cria um novo objeto para controlar os dois motores de um carrinho | def __init__(self, left_motor_topic, right_motor_topic):
"""Cria um novo objeto para controlar os dois motores de um carrinho
Args:
left_motor_topic (string): Nome do tópico do motor esquerdo
right_motor_topic (string): Nome do tópico do motor direito
"""
self.left_motor_topic = left_motor_topic
self.right_motor_topic = right_motor_topic | [
"def",
"__init__",
"(",
"self",
",",
"left_motor_topic",
",",
"right_motor_topic",
")",
":",
"self",
".",
"left_motor_topic",
"=",
"left_motor_topic",
"self",
".",
"right_motor_topic",
"=",
"right_motor_topic"
] | [
6,
4
] | [
14,
50
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Restaurante.incrementando_pessoas_atendidas | (self, adicional_atendido) | Soma a quantidade especificada ao valor de pessoas atendidas. | Soma a quantidade especificada ao valor de pessoas atendidas. | def incrementando_pessoas_atendidas(self, adicional_atendido):
"""Soma a quantidade especificada ao valor de pessoas atendidas."""
self.pessoas_atendidas += adicional_atendido | [
"def",
"incrementando_pessoas_atendidas",
"(",
"self",
",",
"adicional_atendido",
")",
":",
"self",
".",
"pessoas_atendidas",
"+=",
"adicional_atendido"
] | [
47,
4
] | [
49,
52
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
read_text | (N) | return positions, np.array(uT_serialized)[1:-1].reshape((N - 1, 1)) | Le o arquivo de teste disponibilizado no moodle, e retorna o vetor U e a posição das fontes | Le o arquivo de teste disponibilizado no moodle, e retorna o vetor U e a posição das fontes | def read_text(N):
''''Le o arquivo de teste disponibilizado no moodle, e retorna o vetor U e a posição das fontes'''
mod = 2048 // N
f = open("teste.txt", "r")
positions = f.readline().split()
for i in range(len(positions)):
positions[i] = float(positions[i])
uT = f.read().splitlines()
uT_serialized = []
for i in range(len(uT)):
if i % mod == 0:
uT_serialized.append(float(uT[i]))
f.close()
return positions, np.array(uT_serialized)[1:-1].reshape((N - 1, 1)) | [
"def",
"read_text",
"(",
"N",
")",
":",
"mod",
"=",
"2048",
"//",
"N",
"f",
"=",
"open",
"(",
"\"teste.txt\"",
",",
"\"r\"",
")",
"positions",
"=",
"f",
".",
"readline",
"(",
")",
".",
"split",
"(",
")",
"for",
"i",
"in",
"range",
"(",
"len",
"(",
"positions",
")",
")",
":",
"positions",
"[",
"i",
"]",
"=",
"float",
"(",
"positions",
"[",
"i",
"]",
")",
"uT",
"=",
"f",
".",
"read",
"(",
")",
".",
"splitlines",
"(",
")",
"uT_serialized",
"=",
"[",
"]",
"for",
"i",
"in",
"range",
"(",
"len",
"(",
"uT",
")",
")",
":",
"if",
"i",
"%",
"mod",
"==",
"0",
":",
"uT_serialized",
".",
"append",
"(",
"float",
"(",
"uT",
"[",
"i",
"]",
")",
")",
"f",
".",
"close",
"(",
")",
"return",
"positions",
",",
"np",
".",
"array",
"(",
"uT_serialized",
")",
"[",
"1",
":",
"-",
"1",
"]",
".",
"reshape",
"(",
"(",
"N",
"-",
"1",
",",
"1",
")",
")"
] | [
154,
0
] | [
172,
71
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
UndirectedWeightedGraph.vertices | (self) | return vv | Retorna um iterator para iterar sobre o cojunto de vértices | Retorna um iterator para iterar sobre o cojunto de vértices | def vertices(self):
''' Retorna um iterator para iterar sobre o cojunto de vértices '''
vv = _VerticeView(self.__edges)
return vv | [
"def",
"vertices",
"(",
"self",
")",
":",
"vv",
"=",
"_VerticeView",
"(",
"self",
".",
"__edges",
")",
"return",
"vv"
] | [
155,
4
] | [
158,
17
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
GrupoEquipamentoResource.handle_put | (self, request, user, *args, **kwargs) | Trata as requisições de PUT para alterar um grupo de equipamento.
URL: egrupo/<id_grupo>/
| Trata as requisições de PUT para alterar um grupo de equipamento. | def handle_put(self, request, user, *args, **kwargs):
"""Trata as requisições de PUT para alterar um grupo de equipamento.
URL: egrupo/<id_grupo>/
"""
try:
egroup_id = kwargs.get('id_grupo')
if not is_valid_int_greater_zero_param(egroup_id):
self.log.error(
u'The egroup_id parameter is not a valid value: %s.', egroup_id)
raise InvalidValueError(None, 'egroup_id', egroup_id)
egrp = EGrupo.get_by_pk(egroup_id)
if not has_perm(user, AdminPermission.EQUIPMENT_GROUP_MANAGEMENT, AdminPermission.WRITE_OPERATION):
return self.not_authorized()
xml_map, attrs_map = loads(request.raw_post_data)
self.log.debug('XML_MAP: %s', xml_map)
networkapi_map = xml_map.get('networkapi')
if networkapi_map is None:
return self.response_error(3, u'Não existe valor para a tag networkapi do XML de requisição.')
egroup_map = networkapi_map.get('grupo')
if egroup_map is None:
return self.response_error(3, u'Não existe valor para a tag grupo do XML de requisição.')
name = egroup_map.get('nome')
if not is_valid_string_maxsize(name, 100):
self.log.error(u'Parameter name is invalid. Value: %s', name)
raise InvalidValueError(None, 'name', name)
with distributedlock(LOCK_GROUP_EQUIPMENT % egroup_id):
# Destroy equipment's cache
equip_id_list = []
for equipament in egrp.equipamento_set.all():
equip_id_list.append(equipament.id)
destroy_cache_function(equip_id_list, True)
EGrupo.update(user, egroup_id, nome=name)
return self.response(dumps_networkapi({}))
except InvalidValueError, e:
return self.response_error(269, e.param, e.value)
except EGrupoNotFoundError:
return self.response_error(102)
except EGrupoNameDuplicatedError:
return self.response_error(254, name)
except XMLError, x:
self.log.error(u'Erro ao ler o XML da requisicao.')
return self.response_error(3, x)
except GrupoError:
return self.response_error(1) | [
"def",
"handle_put",
"(",
"self",
",",
"request",
",",
"user",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"try",
":",
"egroup_id",
"=",
"kwargs",
".",
"get",
"(",
"'id_grupo'",
")",
"if",
"not",
"is_valid_int_greater_zero_param",
"(",
"egroup_id",
")",
":",
"self",
".",
"log",
".",
"error",
"(",
"u'The egroup_id parameter is not a valid value: %s.'",
",",
"egroup_id",
")",
"raise",
"InvalidValueError",
"(",
"None",
",",
"'egroup_id'",
",",
"egroup_id",
")",
"egrp",
"=",
"EGrupo",
".",
"get_by_pk",
"(",
"egroup_id",
")",
"if",
"not",
"has_perm",
"(",
"user",
",",
"AdminPermission",
".",
"EQUIPMENT_GROUP_MANAGEMENT",
",",
"AdminPermission",
".",
"WRITE_OPERATION",
")",
":",
"return",
"self",
".",
"not_authorized",
"(",
")",
"xml_map",
",",
"attrs_map",
"=",
"loads",
"(",
"request",
".",
"raw_post_data",
")",
"self",
".",
"log",
".",
"debug",
"(",
"'XML_MAP: %s'",
",",
"xml_map",
")",
"networkapi_map",
"=",
"xml_map",
".",
"get",
"(",
"'networkapi'",
")",
"if",
"networkapi_map",
"is",
"None",
":",
"return",
"self",
".",
"response_error",
"(",
"3",
",",
"u'Não existe valor para a tag networkapi do XML de requisição.')",
"",
"egroup_map",
"=",
"networkapi_map",
".",
"get",
"(",
"'grupo'",
")",
"if",
"egroup_map",
"is",
"None",
":",
"return",
"self",
".",
"response_error",
"(",
"3",
",",
"u'Não existe valor para a tag grupo do XML de requisição.')",
"",
"name",
"=",
"egroup_map",
".",
"get",
"(",
"'nome'",
")",
"if",
"not",
"is_valid_string_maxsize",
"(",
"name",
",",
"100",
")",
":",
"self",
".",
"log",
".",
"error",
"(",
"u'Parameter name is invalid. Value: %s'",
",",
"name",
")",
"raise",
"InvalidValueError",
"(",
"None",
",",
"'name'",
",",
"name",
")",
"with",
"distributedlock",
"(",
"LOCK_GROUP_EQUIPMENT",
"%",
"egroup_id",
")",
":",
"# Destroy equipment's cache",
"equip_id_list",
"=",
"[",
"]",
"for",
"equipament",
"in",
"egrp",
".",
"equipamento_set",
".",
"all",
"(",
")",
":",
"equip_id_list",
".",
"append",
"(",
"equipament",
".",
"id",
")",
"destroy_cache_function",
"(",
"equip_id_list",
",",
"True",
")",
"EGrupo",
".",
"update",
"(",
"user",
",",
"egroup_id",
",",
"nome",
"=",
"name",
")",
"return",
"self",
".",
"response",
"(",
"dumps_networkapi",
"(",
"{",
"}",
")",
")",
"except",
"InvalidValueError",
",",
"e",
":",
"return",
"self",
".",
"response_error",
"(",
"269",
",",
"e",
".",
"param",
",",
"e",
".",
"value",
")",
"except",
"EGrupoNotFoundError",
":",
"return",
"self",
".",
"response_error",
"(",
"102",
")",
"except",
"EGrupoNameDuplicatedError",
":",
"return",
"self",
".",
"response_error",
"(",
"254",
",",
"name",
")",
"except",
"XMLError",
",",
"x",
":",
"self",
".",
"log",
".",
"error",
"(",
"u'Erro ao ler o XML da requisicao.'",
")",
"return",
"self",
".",
"response_error",
"(",
"3",
",",
"x",
")",
"except",
"GrupoError",
":",
"return",
"self",
".",
"response_error",
"(",
"1",
")"
] | [
106,
4
] | [
161,
41
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
CallbackARQ.envia | (self, quadro) | Recebe dados de cima e envia para baixo | Recebe dados de cima e envia para baixo | def envia(self, quadro):
''' Recebe dados de cima e envia para baixo '''
e = Evento(TipoEvento.Payload, quadro) # Dados vindos da aplicação
self.mecanismoARQ(e) | [
"def",
"envia",
"(",
"self",
",",
"quadro",
")",
":",
"e",
"=",
"Evento",
"(",
"TipoEvento",
".",
"Payload",
",",
"quadro",
")",
"# Dados vindos da aplicação",
"self",
".",
"mecanismoARQ",
"(",
"e",
")"
] | [
136,
4
] | [
139,
28
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
OverlapCommunity.carrega_sementes | (self) | carrega as sementes para uma lista | carrega as sementes para uma lista | def carrega_sementes(self):
"""carrega as sementes para uma lista"""
arq = open(self.nome_arq_sementes, "r")
for i in arq:
self.sementes_predefinidas.append(i.split('\n')[0]) | [
"def",
"carrega_sementes",
"(",
"self",
")",
":",
"arq",
"=",
"open",
"(",
"self",
".",
"nome_arq_sementes",
",",
"\"r\"",
")",
"for",
"i",
"in",
"arq",
":",
"self",
".",
"sementes_predefinidas",
".",
"append",
"(",
"i",
".",
"split",
"(",
"'\\n'",
")",
"[",
"0",
"]",
")"
] | [
68,
4
] | [
72,
63
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
devolver_session_id | (whatsapp) | esta função sempre devolve uma session_id, se o usuário já tem ele devolve
caso ele não tenha, é criado uma nova e devolvido | esta função sempre devolve uma session_id, se o usuário já tem ele devolve
caso ele não tenha, é criado uma nova e devolvido | def devolver_session_id(whatsapp):
"""esta função sempre devolve uma session_id, se o usuário já tem ele devolve
caso ele não tenha, é criado uma nova e devolvido"""
if conferir_session_id(whatsapp) != None:
return conferir_session_id(whatsapp)
else:
session_id = criar_sessao()
adicionar_session_id(whatsapp, session_id)
return session_id | [
"def",
"devolver_session_id",
"(",
"whatsapp",
")",
":",
"if",
"conferir_session_id",
"(",
"whatsapp",
")",
"!=",
"None",
":",
"return",
"conferir_session_id",
"(",
"whatsapp",
")",
"else",
":",
"session_id",
"=",
"criar_sessao",
"(",
")",
"adicionar_session_id",
"(",
"whatsapp",
",",
"session_id",
")",
"return",
"session_id"
] | [
36,
0
] | [
45,
25
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
leiaInRange | (numero=0,n1=0,n2=1,outRange='ERRO! Número Fora Do Alcance.',cor=False): | [Verifica se Um Número Está Dentro de um Range.]
Args:
numero (int, optional): [Númaero à Ser Verificado.]. Defaults to 0.
n1 (int, optional): [começo do range]. Defaults to 0.
n2 (int, optional): [final do range]. Defaults to 1.
outRange (str, optional): [Mensagem se o número Estiver Fora do Range]. Defaults to 'ERRO! Número Fora Do Alcance.'.
cor (bool, optional): [Adicionar ou Não Cores]. Defaults to False.
Returns:
[bool]: [retorna True ou False]
Criado por:
Murilo_Henrique060
| [Verifica se Um Número Está Dentro de um Range.] | def leiaInRange(numero=0,n1=0,n2=1,outRange='ERRO! Número Fora Do Alcance.',cor=False):
"""[Verifica se Um Número Está Dentro de um Range.]
Args:
numero (int, optional): [Númaero à Ser Verificado.]. Defaults to 0.
n1 (int, optional): [começo do range]. Defaults to 0.
n2 (int, optional): [final do range]. Defaults to 1.
outRange (str, optional): [Mensagem se o número Estiver Fora do Range]. Defaults to 'ERRO! Número Fora Do Alcance.'.
cor (bool, optional): [Adicionar ou Não Cores]. Defaults to False.
Returns:
[bool]: [retorna True ou False]
Criado por:
Murilo_Henrique060
"""
if cor:
from colorama import init
init()
v = 0
for n in range(n1,n2+1):
if n == numero:
v += 1
if v != 1:
print(outRange)
return False
else:
return True | [
"def",
"leiaInRange",
"(",
"numero",
"=",
"0",
",",
"n1",
"=",
"0",
",",
"n2",
"=",
"1",
",",
"outRange",
"=",
"'ERRO! Número Fora Do Alcance.',",
"c",
"or=",
"F",
"alse)",
":",
"",
"if",
"cor",
":",
"from",
"colorama",
"import",
"init",
"init",
"(",
")",
"v",
"=",
"0",
"for",
"n",
"in",
"range",
"(",
"n1",
",",
"n2",
"+",
"1",
")",
":",
"if",
"n",
"==",
"numero",
":",
"v",
"+=",
"1",
"if",
"v",
"!=",
"1",
":",
"print",
"(",
"outRange",
")",
"return",
"False",
"else",
":",
"return",
"True"
] | [
36,
0
] | [
62,
19
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
DistanceSensor.__init__ | (self, topic_name) | Cria um novo objeto para fazer a leitura do sensor de distância
Args:
topic_name (string): Nome do tópico do sensor de distância
| Cria um novo objeto para fazer a leitura do sensor de distância | def __init__(self, topic_name):
"""Cria um novo objeto para fazer a leitura do sensor de distância
Args:
topic_name (string): Nome do tópico do sensor de distância
"""
self.range = 0
self.max_range = 0
self.min_range = 0
self.topic_name = topic_name | [
"def",
"__init__",
"(",
"self",
",",
"topic_name",
")",
":",
"self",
".",
"range",
"=",
"0",
"self",
".",
"max_range",
"=",
"0",
"self",
".",
"min_range",
"=",
"0",
"self",
".",
"topic_name",
"=",
"topic_name"
] | [
4,
4
] | [
13,
36
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
CityCouncilAgenda.last_collected_item_date | (cls) | Retorna primeiro dia do ano do mais recente item coletado. | Retorna primeiro dia do ano do mais recente item coletado. | def last_collected_item_date(cls):
"""Retorna primeiro dia do ano do mais recente item coletado."""
try:
latest = cls.objects.latest()
if latest.date:
return date(latest.date.year, 1, 1)
except cls.DoesNotExist:
return | [
"def",
"last_collected_item_date",
"(",
"cls",
")",
":",
"try",
":",
"latest",
"=",
"cls",
".",
"objects",
".",
"latest",
"(",
")",
"if",
"latest",
".",
"date",
":",
"return",
"date",
"(",
"latest",
".",
"date",
".",
"year",
",",
"1",
",",
"1",
")",
"except",
"cls",
".",
"DoesNotExist",
":",
"return"
] | [
148,
4
] | [
155,
18
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Cachorro.sentar | (self) | Simula um cachorro sentando em resposta a um comando. | Simula um cachorro sentando em resposta a um comando. | def sentar(self):
"""Simula um cachorro sentando em resposta a um comando."""
print(self.nome.title() + " está sentando agora.") | [
"def",
"sentar",
"(",
"self",
")",
":",
"print",
"(",
"self",
".",
"nome",
".",
"title",
"(",
")",
"+",
"\" está sentando agora.\")",
""
] | [
9,
4
] | [
11,
59
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Cave.__init__ | (self, size=(4, 4)) | Inicializa uma nova instância da classe Cave. | Inicializa uma nova instância da classe Cave. | def __init__(self, size=(4, 4)):
"""Inicializa uma nova instância da classe Cave."""
self.size = size
# A caverna contém uma matriz de quartos
w, h = self.size
self._rooms = [[Room() for x in range(w)] for y in range(h)]
unsafe = [(x, y) for x in range(w) for y in range(h) if (x, y) != (0, 0)]
# Coloca o Wumpus na caverna
x, y = random.choice(unsafe)
self._rooms[y][x].wumpus = Status.Present
# Coloca o ouro na caverna
x, y = random.choice(unsafe)
self._rooms[y][x].gold = Status.Present
# Coloca poços na caverna (com probabilidade 0,2)
for x, y in unsafe:
if random.random() <= 0.2:
self._rooms[y][x].pit = Status.Present | [
"def",
"__init__",
"(",
"self",
",",
"size",
"=",
"(",
"4",
",",
"4",
")",
")",
":",
"self",
".",
"size",
"=",
"size",
"# A caverna contém uma matriz de quartos",
"w",
",",
"h",
"=",
"self",
".",
"size",
"self",
".",
"_rooms",
"=",
"[",
"[",
"Room",
"(",
")",
"for",
"x",
"in",
"range",
"(",
"w",
")",
"]",
"for",
"y",
"in",
"range",
"(",
"h",
")",
"]",
"unsafe",
"=",
"[",
"(",
"x",
",",
"y",
")",
"for",
"x",
"in",
"range",
"(",
"w",
")",
"for",
"y",
"in",
"range",
"(",
"h",
")",
"if",
"(",
"x",
",",
"y",
")",
"!=",
"(",
"0",
",",
"0",
")",
"]",
"# Coloca o Wumpus na caverna",
"x",
",",
"y",
"=",
"random",
".",
"choice",
"(",
"unsafe",
")",
"self",
".",
"_rooms",
"[",
"y",
"]",
"[",
"x",
"]",
".",
"wumpus",
"=",
"Status",
".",
"Present",
"# Coloca o ouro na caverna",
"x",
",",
"y",
"=",
"random",
".",
"choice",
"(",
"unsafe",
")",
"self",
".",
"_rooms",
"[",
"y",
"]",
"[",
"x",
"]",
".",
"gold",
"=",
"Status",
".",
"Present",
"# Coloca poços na caverna (com probabilidade 0,2)",
"for",
"x",
",",
"y",
"in",
"unsafe",
":",
"if",
"random",
".",
"random",
"(",
")",
"<=",
"0.2",
":",
"self",
".",
"_rooms",
"[",
"y",
"]",
"[",
"x",
"]",
".",
"pit",
"=",
"Status",
".",
"Present"
] | [
311,
2
] | [
333,
46
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Anuncio.clean | (self) | Realiza validações entre campos do model | Realiza validações entre campos do model | def clean(self) -> None:
"""Realiza validações entre campos do model"""
if self.data_inicio and self.data_termino and self.data_inicio > self.data_termino:
raise ValidationError('A data de início não deve ser maior que a data de término do anúncio.') | [
"def",
"clean",
"(",
"self",
")",
"->",
"None",
":",
"if",
"self",
".",
"data_inicio",
"and",
"self",
".",
"data_termino",
"and",
"self",
".",
"data_inicio",
">",
"self",
".",
"data_termino",
":",
"raise",
"ValidationError",
"(",
"'A data de início não deve ser maior que a data de término do anúncio.')",
""
] | [
71,
4
] | [
74,
110
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
is_valid_ip | (address) | return re.match(pattern, address) | Verifica se address é um endereço ip válido. | Verifica se address é um endereço ip válido. | def is_valid_ip(address):
"""Verifica se address é um endereço ip válido."""
if address is None:
return address
pattern = r'\b(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\b'
return re.match(pattern, address) | [
"def",
"is_valid_ip",
"(",
"address",
")",
":",
"if",
"address",
"is",
"None",
":",
"return",
"address",
"pattern",
"=",
"r'\\b(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\b'",
"return",
"re",
".",
"match",
"(",
"pattern",
",",
"address",
")"
] | [
56,
0
] | [
63,
37
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
Die.roll_die | (self) | return x | Exibe um número aleatório entre 1 e o número de lados do dado. | Exibe um número aleatório entre 1 e o número de lados do dado. | def roll_die(self):
"""Exibe um número aleatório entre 1 e o número de lados do dado."""
from random import randint
x = randint(1, self.sides)
return x | [
"def",
"roll_die",
"(",
"self",
")",
":",
"from",
"random",
"import",
"randint",
"x",
"=",
"randint",
"(",
"1",
",",
"self",
".",
"sides",
")",
"return",
"x"
] | [
18,
4
] | [
22,
16
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
guerra | (ctx, *, text) | Cria uma mensagem para os participantes reagirem se vão ou não vão | Cria uma mensagem para os participantes reagirem se vão ou não vão | async def guerra(ctx, *, text):
'''Cria uma mensagem para os participantes reagirem se vão ou não vão '''
message = await ctx.send(text)
global message_id
message_id = message.id
os.environ['BOT_MESSAGE_ID'] = str(message_id)
global attend
global renegades
global pa_list
attend = []
renegades = []
pa_list = []
for emoji in ('👍', pepe_mage):
await message.add_reaction(emoji) | [
"async",
"def",
"guerra",
"(",
"ctx",
",",
"*",
",",
"text",
")",
":",
"message",
"=",
"await",
"ctx",
".",
"send",
"(",
"text",
")",
"global",
"message_id",
"message_id",
"=",
"message",
".",
"id",
"os",
".",
"environ",
"[",
"'BOT_MESSAGE_ID'",
"]",
"=",
"str",
"(",
"message_id",
")",
"global",
"attend",
"global",
"renegades",
"global",
"pa_list",
"attend",
"=",
"[",
"]",
"renegades",
"=",
"[",
"]",
"pa_list",
"=",
"[",
"]",
"for",
"emoji",
"in",
"(",
"'👍', p",
"e",
"e_mage):",
"",
"",
"await",
"message",
".",
"add_reaction",
"(",
"emoji",
")"
] | [
80,
0
] | [
96,
35
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.