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 list | start_point list | end_point list | 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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
World.disable_gravity | (self, masslist=[]) | Desactive la gravité pour les mass de masslist
ou pour toutes les masses si masslist est vide | Desactive la gravité pour les mass de masslist
ou pour toutes les masses si masslist est vide | def disable_gravity(self, masslist=[]):
'''Desactive la gravité pour les mass de masslist
ou pour toutes les masses si masslist est vide'''
if masslist == []:
masslist = self.mass
for mass in masslist:
for i in range(len(mass.linklist)):
lien, num = mass.linklist[i]
if num == 1:
if lien.mass2 == self.earth:
del mass.linklist[i]
self.link.remove(lien)
else:
if lien.mass1 == self.earth:
del mass.linklist[i]
self.link.remove(lien) | [
"def",
"disable_gravity",
"(",
"self",
",",
"masslist",
"=",
"[",
"]",
")",
":",
"if",
"masslist",
"==",
"[",
"]",
":",
"masslist",
"=",
"self",
".",
"mass",
"for",
"mass",
"in",
"masslist",
":",
"for",
"i",
"in",
"range",
"(",
"len",
"(",
"mass",
... | [
159,
4
] | [
174,
46
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
Map.charger_hitboxs | (self) | Crée les rectangles de collisions de la map
Permets de charger les rectangles de collision de la map
(Peut génèrer des latences !)
| Crée les rectangles de collisions de la map
Permets de charger les rectangles de collision de la map
(Peut génèrer des latences !)
| def charger_hitboxs(self):
""" Crée les rectangles de collisions de la map
Permets de charger les rectangles de collision de la map
(Peut génèrer des latences !)
"""
for groupe in cc.groupes: # Je parcours les groupes de collision
cc.groupes[groupe] = pg.sprite.Group() # Je les réinitialise
for i in range(3): # Je parcours les 3 premières couches de la map
for y in range(self.y): # Parcours les colonnes
for x in range(self.x): # Je parcours les lignes
if self.matrices[i][y][x] in ct.tuiles: # Si la tuile existe
if self.matrices[i][y][x] in ct.collisions: # Si on lui a assigné des collisions
x_tuile = self.x_camera + x*32 # Position de la tuile (abscisses)
y_tuile = self.y_camera + y*32 # Position de la tuile (ordonnée)
tuile = ct.tuiles[self.matrices[i][y][x]] # On extrait l'image
mask = pg.mask.from_surface(tuile) # On fait le mask a partir de cette image
rect = pg.Rect(x_tuile, y_tuile, 32, 32) # On créé le rectangle associé a l'image
col.Hitbox("tuile", rect, mask) | [
"def",
"charger_hitboxs",
"(",
"self",
")",
":",
"for",
"groupe",
"in",
"cc",
".",
"groupes",
":",
"# Je parcours les groupes de collision",
"cc",
".",
"groupes",
"[",
"groupe",
"]",
"=",
"pg",
".",
"sprite",
".",
"Group",
"(",
")",
"# Je les réinitialise",
... | [
134,
4
] | [
152,
59
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
corde.__str__ | (self) | return s | affiche chaque point de la corde | affiche chaque point de la corde | def __str__ (self):
"""affiche chaque point de la corde"""
s = ""
l = 0
for i in xrange (0, len (self.list)) :
s += "point " + str (i) + " : " + str (self.list [i])
if i < len (self.list) -1 :
x,y = self.list [i].difference (self.list [i+1])
d = math.sqrt (x*x + y*y)
s += "\t segment : %4.0f" % d
s += " ( %4.0f )" % self.l
if i != 0 and i != len (self.list)-1 :
x,y = self.force_point (i)
s += "\t force en ce point (%f,%f) " % (x,y)
s += "\n"
if i > 0 :
x,y = self.list [i].difference (self.list [i-1])
l += math.sqrt (x*x + y*y)
s += "longueur de la corde " + str (l) + "\n"
s += "longueur attendue " + str ((len (self.list)-1) * self.l) + "\n"
return s | [
"def",
"__str__",
"(",
"self",
")",
":",
"s",
"=",
"\"\"",
"l",
"=",
"0",
"for",
"i",
"in",
"xrange",
"(",
"0",
",",
"len",
"(",
"self",
".",
"list",
")",
")",
":",
"s",
"+=",
"\"point \"",
"+",
"str",
"(",
"i",
")",
"+",
"\" : \"",
"+",
"s... | [
193,
4
] | [
213,
16
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
getting_started | () | attributions : option "Prise en main" du sous menu "Aide" l.afpt
description : récupère la largeur et hauteur de l'écran de l'utilisateur, puis appelle la fonction 'f_getting_started()
du fichier 'fonctions.py' en lui passant en argument la largeur et hauteur de la fenêtre | attributions : option "Prise en main" du sous menu "Aide" l.afpt
description : récupère la largeur et hauteur de l'écran de l'utilisateur, puis appelle la fonction 'f_getting_started()
du fichier 'fonctions.py' en lui passant en argument la largeur et hauteur de la fenêtre | def getting_started():
"""attributions : option "Prise en main" du sous menu "Aide" l.afpt
description : récupère la largeur et hauteur de l'écran de l'utilisateur, puis appelle la fonction 'f_getting_started()
du fichier 'fonctions.py' en lui passant en argument la largeur et hauteur de la fenêtre"""
masterx=master.winfo_width()
mastery=master.winfo_height()
f_getting_started(masterx,mastery) | [
"def",
"getting_started",
"(",
")",
":",
"masterx",
"=",
"master",
".",
"winfo_width",
"(",
")",
"mastery",
"=",
"master",
".",
"winfo_height",
"(",
")",
"f_getting_started",
"(",
"masterx",
",",
"mastery",
")"
] | [
55,
0
] | [
61,
38
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
Groupe.comprend_enfants | (self) | return any([passager.categorie == 'enfants' for passager in self.list_passagers]) | Renvoie True si le groupe contient au moins un enfant
en son sein et False sinon.
| Renvoie True si le groupe contient au moins un enfant
en son sein et False sinon.
| def comprend_enfants(self):
"""Renvoie True si le groupe contient au moins un enfant
en son sein et False sinon.
"""
return any([passager.categorie == 'enfants' for passager in self.list_passagers]) | [
"def",
"comprend_enfants",
"(",
"self",
")",
":",
"return",
"any",
"(",
"[",
"passager",
".",
"categorie",
"==",
"'enfants'",
"for",
"passager",
"in",
"self",
".",
"list_passagers",
"]",
")"
] | [
167,
4
] | [
171,
89
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
qr_decomposition | (A, mode = "", graph_mode = False) | return Q, R | Décomposition QR d'une matrice
Entrée:
A matrice quelconque.
Sortie:
Tuple (Q, R) des matrices de la décomposition.
| Décomposition QR d'une matrice
Entrée:
A matrice quelconque.
Sortie:
Tuple (Q, R) des matrices de la décomposition.
| def qr_decomposition(A, mode = "", graph_mode = False):
""" Décomposition QR d'une matrice
Entrée:
A matrice quelconque.
Sortie:
Tuple (Q, R) des matrices de la décomposition.
"""
if graph_mode:
it = []
decomp_quality = []
A = np.matrix(A, dtype='f')
N, M = A.shape
Q = np.eye(N, N, dtype='f')
R = np.matrix(A)
for i in range(min(N, M)):
X = R[i:, i]
z = np.zeros([len(X), 1])
if X[0, 0] > 0:
z[0, 0] = npl.norm(X)
else:
z[0, 0] = -npl.norm(X)
Q[:, i:] = householder_product_right(X, z, Q[:, i:])
R[i:, :] = householder_product_left(X, z, R[i:, :])
if graph_mode:
it.append(i)
Z = np.dot(Q, R)
decomp_quality.append(npl.norm(Z - A))
if graph_mode:
return it, decomp_quality
return Q, R | [
"def",
"qr_decomposition",
"(",
"A",
",",
"mode",
"=",
"\"\"",
",",
"graph_mode",
"=",
"False",
")",
":",
"if",
"graph_mode",
":",
"it",
"=",
"[",
"]",
"decomp_quality",
"=",
"[",
"]",
"A",
"=",
"np",
".",
"matrix",
"(",
"A",
",",
"dtype",
"=",
"... | [
11,
0
] | [
40,
12
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
convertir_arbre_vers_graphviz | (arbre, G) | Convertie un arbre binaire en graphe GraphViz | Convertie un arbre binaire en graphe GraphViz | def convertir_arbre_vers_graphviz(arbre, G):
"""Convertie un arbre binaire en graphe GraphViz"""
def ajoute_noeud(valeur):
G.add_node(valeur, shape="circle")
def ajoute_arete(valeur_parent, valeur_enfant):
G.add_edge(valeur_parent, valeur_enfant)
parcourt_arbre(arbre, ajoute_noeud)
parcourt_arbre_avec_parent(arbre, ajoute_arete) | [
"def",
"convertir_arbre_vers_graphviz",
"(",
"arbre",
",",
"G",
")",
":",
"def",
"ajoute_noeud",
"(",
"valeur",
")",
":",
"G",
".",
"add_node",
"(",
"valeur",
",",
"shape",
"=",
"\"circle\"",
")",
"def",
"ajoute_arete",
"(",
"valeur_parent",
",",
"valeur_enf... | [
114,
0
] | [
123,
51
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
nuage_image.html_couple | (self, fichier, l, zoom = None) | �crit un fichier html contenant toutes les images mal class�es,
� partir de la liste erreur construite par la m�thode nuage_points.ppv_nuage | �crit un fichier html contenant toutes les images mal class�es,
� partir de la liste erreur construite par la m�thode nuage_points.ppv_nuage | def html_couple (self, fichier, l, zoom = None) :
"""�crit un fichier html contenant toutes les images mal class�es,
� partir de la liste erreur construite par la m�thode nuage_points.ppv_nuage"""
# nombre de colonnes maximales
maxc = 0
for x in l : maxc = max (maxc, len (x))
f = html.html_file (fichier)
f.open ()
f.table_begin (maxc*2+1)
f.text ("indice")
f.table_next ()
f.text ("label")
f.table_next ()
f.text ("� classer")
f.table_next ()
for n in xrange (1, maxc) :
f.text ("label")
f.table_next ()
f.text ("voisin " + str (n))
f.table_next ()
f.table_next_line ()
n = 0
for x in l :
f.text (str (n))
f.table_next ()
n += 1
for el in x :
im = self.image (el)
f.text (self.ppv.label (el))
f.table_next ()
f.add_image (im, zoom = zoom)
f.table_next ()
f.table_next_line ()
f.table_end ()
f.close () | [
"def",
"html_couple",
"(",
"self",
",",
"fichier",
",",
"l",
",",
"zoom",
"=",
"None",
")",
":",
"# nombre de colonnes maximales",
"maxc",
"=",
"0",
"for",
"x",
"in",
"l",
":",
"maxc",
"=",
"max",
"(",
"maxc",
",",
"len",
"(",
"x",
")",
")",
"f",
... | [
94,
4
] | [
133,
18
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
householder_product_right | (X, Y, M) | return (M - 2 * np.dot(np.dot(M, V), V.T)) | Produit à droite d'une matrice par une matrice de Householder.
Entrée:
X, Y, M respectivement deux vecteurs de mêmes tailles et une matrice.
Sortie:
Produit M*H où H est la matrice de Householder de passage de X vers Y.
| Produit à droite d'une matrice par une matrice de Householder.
Entrée:
X, Y, M respectivement deux vecteurs de mêmes tailles et une matrice.
Sortie:
Produit M*H où H est la matrice de Householder de passage de X vers Y.
| def householder_product_right(X, Y, M):
""" Produit à droite d'une matrice par une matrice de Householder.
Entrée:
X, Y, M respectivement deux vecteurs de mêmes tailles et une matrice.
Sortie:
Produit M*H où H est la matrice de Householder de passage de X vers Y.
"""
V = X - Y
if npl.norm(V) != 0:
V = V / np.linalg.norm(V)
return (M - 2 * np.dot(np.dot(M, V), V.T)) | [
"def",
"householder_product_right",
"(",
"X",
",",
"Y",
",",
"M",
")",
":",
"V",
"=",
"X",
"-",
"Y",
"if",
"npl",
".",
"norm",
"(",
"V",
")",
"!=",
"0",
":",
"V",
"=",
"V",
"/",
"np",
".",
"linalg",
".",
"norm",
"(",
"V",
")",
"return",
"("... | [
45,
0
] | [
57,
46
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
DatasetMDShow.get | (self, request, dataset_name) | Voir la fiche de metadonnées du jeu de données. | Voir la fiche de metadonnées du jeu de données. | def get(self, request, dataset_name):
"""Voir la fiche de metadonnées du jeu de données."""
instance = None
for dataset in handler_get_request(request):
if dataset.slug == dataset_name:
instance = dataset
break
if not instance or (instance and not instance.geonet_id):
raise Http404()
try:
record = geonet.get_record(str(instance.geonet_id))
except Exception as e:
return JsonResponse({'error': e.__str__()}, status=400)
else:
return HttpResponse(record.xml, content_type='application/xml') | [
"def",
"get",
"(",
"self",
",",
"request",
",",
"dataset_name",
")",
":",
"instance",
"=",
"None",
"for",
"dataset",
"in",
"handler_get_request",
"(",
"request",
")",
":",
"if",
"dataset",
".",
"slug",
"==",
"dataset_name",
":",
"instance",
"=",
"dataset",... | [
373,
4
] | [
387,
75
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
Storage.create_new_node | (self, name, x, y, color) | return cursor.lastrowid | Crée un nouveau noeud | Crée un nouveau noeud | def create_new_node(self, name, x, y, color):
"""Crée un nouveau noeud"""
cursor = self.connection.cursor()
cursor.execute(
"INSERT INTO nodes (name, x, y, color) VALUES (?, ?, ?, ?)",
(name, x, y, color),
)
self.connection.commit()
return cursor.lastrowid | [
"def",
"create_new_node",
"(",
"self",
",",
"name",
",",
"x",
",",
"y",
",",
"color",
")",
":",
"cursor",
"=",
"self",
".",
"connection",
".",
"cursor",
"(",
")",
"cursor",
".",
"execute",
"(",
"\"INSERT INTO nodes (name, x, y, color) VALUES (?, ?, ?, ?)\"",
"... | [
54,
4
] | [
62,
31
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
findNearestDate | (date_str: str, df_price: pd.DataFrame, delta: int) | return np.datetime_as_string(nearest_date, unit='D') | Trouve la date la plus proche décalée de delta jours dans l'index d'un dataframe.
Paramètres
----------
date_str : str
La date à trouver
df_price : pandas.Dataframe
Le dataframe dont l'index doit contenir des dates sous un format texte
delta : int
décalage de la date à trouver. Si delta est positif, la date sera plus grande,
sera plus avancée dans le temps
Retours
-------
nearest_date : str
Date la plus proche de celle recherchée qui est contenue dans l'index du dataframe
Exemples
-------
>>> findNearestDate('2021-05-11', df, 3)
2021-05-14 # si cette date est contenue dans l'index
| Trouve la date la plus proche décalée de delta jours dans l'index d'un dataframe. | def findNearestDate(date_str: str, df_price: pd.DataFrame, delta: int):
""" Trouve la date la plus proche décalée de delta jours dans l'index d'un dataframe.
Paramètres
----------
date_str : str
La date à trouver
df_price : pandas.Dataframe
Le dataframe dont l'index doit contenir des dates sous un format texte
delta : int
décalage de la date à trouver. Si delta est positif, la date sera plus grande,
sera plus avancée dans le temps
Retours
-------
nearest_date : str
Date la plus proche de celle recherchée qui est contenue dans l'index du dataframe
Exemples
-------
>>> findNearestDate('2021-05-11', df, 3)
2021-05-14 # si cette date est contenue dans l'index
"""
# Dates du dataframe sous forme de liste
list_dates = pd.to_datetime(df_price.index).values
# On calcule la date la plus proche en valeur absolue
pivot = np.datetime64(pd.to_datetime(date_str) + timedelta(days=delta))
nearest_date = min(list_dates, key=lambda x: abs(x - pivot))
# On la transforme en str dans le même format que dans le dataframe df_price
return np.datetime_as_string(nearest_date, unit='D') | [
"def",
"findNearestDate",
"(",
"date_str",
":",
"str",
",",
"df_price",
":",
"pd",
".",
"DataFrame",
",",
"delta",
":",
"int",
")",
":",
"# Dates du dataframe sous forme de liste",
"list_dates",
"=",
"pd",
".",
"to_datetime",
"(",
"df_price",
".",
"index",
")"... | [
82,
0
] | [
111,
56
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
API_test | (d, p) | Récupère et renvoie une information à Chatfuel | Récupère et renvoie une information à Chatfuel | def API_test(d, p):
""" Récupère et renvoie une information à Chatfuel """
try:
rep= chatfuel.Response([chatfuel.Text(f"d:{d}"),
chatfuel.Text(f"p:{p}")
],
#set_attributes={"a":1,"b":2}#,
# redirect_to_blocks="Menu"
)
except Exception as exc:
rep = chatfuel.ErrorReport(exc)
finally:
return rep | [
"def",
"API_test",
"(",
"d",
",",
"p",
")",
":",
"try",
":",
"rep",
"=",
"chatfuel",
".",
"Response",
"(",
"[",
"chatfuel",
".",
"Text",
"(",
"f\"d:{d}\"",
")",
",",
"chatfuel",
".",
"Text",
"(",
"f\"p:{p}\"",
")",
"]",
",",
"#set_attributes={\"a\":1,\... | [
765,
0
] | [
781,
18
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
interface | () | Controleur de la route '/interface' | Controleur de la route '/interface' | def interface():
"Controleur de la route '/interface' "
if 'profil' in session and session['profil']:
return render_template("{}.html".format(session['profil'])) | [
"def",
"interface",
"(",
")",
":",
"if",
"'profil'",
"in",
"session",
"and",
"session",
"[",
"'profil'",
"]",
":",
"return",
"render_template",
"(",
"\"{}.html\"",
".",
"format",
"(",
"session",
"[",
"'profil'",
"]",
")",
")"
] | [
60,
0
] | [
63,
67
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
cases_roi | (col,lig) | return [(x, y) for x in r1 for y in r2 if (x >= 0 and x <= 7) and (y >= 0 and y <= 7) and not (x, y) == (col, lig)] | Retourne la liste des indices (col,lig) des cases où peut se
déplacer un roi positionné sur la case (col, lig)
Ex: Roi en (4,5)
- - - - - - - - - -
| |
| |
| |
| |
| x x x |
| x R x |
| x x x |
| |
- - - - - - - - - -
| Retourne la liste des indices (col,lig) des cases où peut se
déplacer un roi positionné sur la case (col, lig) | def cases_roi(col,lig):
"""Retourne la liste des indices (col,lig) des cases où peut se
déplacer un roi positionné sur la case (col, lig)
Ex: Roi en (4,5)
- - - - - - - - - -
| |
| |
| |
| |
| x x x |
| x R x |
| x x x |
| |
- - - - - - - - - -
"""
cases = []
r1 = range(col - 1, col + 2)
r2 = range(lig - 1, lig + 2)
return [(x, y) for x in r1 for y in r2 if (x >= 0 and x <= 7) and (y >= 0 and y <= 7) and not (x, y) == (col, lig)] | [
"def",
"cases_roi",
"(",
"col",
",",
"lig",
")",
":",
"cases",
"=",
"[",
"]",
"r1",
"=",
"range",
"(",
"col",
"-",
"1",
",",
"col",
"+",
"2",
")",
"r2",
"=",
"range",
"(",
"lig",
"-",
"1",
",",
"lig",
"+",
"2",
")",
"return",
"[",
"(",
"x... | [
76,
0
] | [
98,
118
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
get_models | () | charge les définitions des challenges | charge les définitions des challenges | def get_models():
""" charge les définitions des challenges """
# les playlists
for i in glob.iglob(os.path.join("offline", "playlists", "*.json")):
with open(i, "r") as f:
data = json.load(f)
playlists[data['slug']] = data
# les contests (y compris master_<domain>)
order = 0
for i in glob.iglob(os.path.join("offline", "contests", "*.json")):
with open(i, "r") as f:
data = json.load(f)
# la description d'un contest
if 'name' in data:
desc = (data['description'] or '').partition('<br')[0]
descriptions[data['slug']] = {'name': data['name'],
'description': desc}
# pour tous les challenges dans un contest
for m in data['models']:
if 'contest_slug' not in m:
continue
order += 1
m['order'] = order # ajoute un numéro pour maintenir l'ordre des chapters
if m['contest_slug'] == 'projecteuler':
m['order'] -= 10000 # met le ProjectEuler+ en tête des contests
models[(m['contest_slug'], m['slug'])] = m | [
"def",
"get_models",
"(",
")",
":",
"# les playlists",
"for",
"i",
"in",
"glob",
".",
"iglob",
"(",
"os",
".",
"path",
".",
"join",
"(",
"\"offline\"",
",",
"\"playlists\"",
",",
"\"*.json\"",
")",
")",
":",
"with",
"open",
"(",
"i",
",",
"\"r\"",
")... | [
25,
0
] | [
54,
54
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
is_cout_calcul.action_calcul_prix_achat_thread | (self,nb_threads="") | Début du calcul en déterminant les threads à utiliser | Début du calcul en déterminant les threads à utiliser | def action_calcul_prix_achat_thread(self,nb_threads=""):
"""Début du calcul en déterminant les threads à utiliser"""
self.mem_couts={}
cr = self._cr
uid=self._uid
user=self.env['res.users'].browse(uid)
if nb_threads=="":
nb_threads=user.company_id.is_nb_threads
if nb_threads>10:
nb_threads=0
debut=datetime.datetime.now()
for obj in self:
obj.niveau_ids.unlink()
self._log("## DEBUT Calcul des prix d'achat ("+str(nb_threads)+" coeurs)")
_logger.info('début unlink')
obj.cout_actualise_ids.unlink()
_logger.info('fin unlink')
calcul_actualise_obj = self.env['is.cout.calcul.actualise']
_logger.info("début get_products")
products=self.get_products(obj)
_logger.info("fin get_products : nb="+str(len(products)))
ct=1
nb=len(products)
_logger.info("début boucle products : nb="+str(nb))
for product in products:
_logger.info(str(ct)+'/'+str(nb)+' : boucle products : '+product.is_code)
ct+=1
#cProfile.runctx("self.nomenclature2(obj,product,0, obj.multiniveaux)",globals(),locals(),"/tmp/test.bin")
self.nomenclature2(obj,product,0, obj.multiniveaux)
_logger.info("fin boucle products")
_logger.info("début création coûts "+_now(debut))
self._creation_couts(nb_threads) # Création ou initialisation des fiches de couts en threads
_logger.info("fin création coûts "+_now(debut))
_logger.info("début boucle couts : nb="+str(nb)+' '+_now(debut))
self._maj_couts(nb_threads) # Mise à jour des coûts en threads
_logger.info("fin boucle couts"+' '+_now(debut))
self._log("## FIN Calcul des prix d'achat ("+str(nb_threads)+" coeurs) "+_now(debut))
obj.state="prix_achat" | [
"def",
"action_calcul_prix_achat_thread",
"(",
"self",
",",
"nb_threads",
"=",
"\"\"",
")",
":",
"self",
".",
"mem_couts",
"=",
"{",
"}",
"cr",
"=",
"self",
".",
"_cr",
"uid",
"=",
"self",
".",
"_uid",
"user",
"=",
"self",
".",
"env",
"[",
"'res.users'... | [
391,
4
] | [
433,
34
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
res_users._login | (self, db, login, password) | return user_id | Permet d'ajouter l'adresse IP de la personne qui se connecte
cela est utilise par les programmes externes | Permet d'ajouter l'adresse IP de la personne qui se connecte
cela est utilise par les programmes externes | def _login(self, db, login, password):
"""Permet d'ajouter l'adresse IP de la personne qui se connecte
cela est utilise par les programmes externes"""
user_id = super(res_users, self)._login(db, login, password)
if request:
ip=request.httprequest.environ.get('REMOTE_ADDR',False)
if ip:
cr = self.pool.cursor()
cr.autocommit(True)
if user_id and ip:
SQL="""
INSERT INTO is_res_users (user_id, heure_connexion, adresse_ip)
VALUES ("""+str(user_id)+""", now() at time zone 'UTC', '"""+str(ip)+"""')
"""
res=cr.execute(SQL)
#res=cr.execute("UPDATE res_users SET is_adresse_ip='"+str(ip)+"' WHERE id="+str(user_id))
cr.close()
return user_id | [
"def",
"_login",
"(",
"self",
",",
"db",
",",
"login",
",",
"password",
")",
":",
"user_id",
"=",
"super",
"(",
"res_users",
",",
"self",
")",
".",
"_login",
"(",
"db",
",",
"login",
",",
"password",
")",
"if",
"request",
":",
"ip",
"=",
"request",... | [
33,
4
] | [
50,
22
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
dataframe_filter | (dataframe, round_conf) | return index_result | permet de retourner que les index de la dataframe qui sont dans le round actuel | permet de retourner que les index de la dataframe qui sont dans le round actuel | def dataframe_filter(dataframe, round_conf):
"permet de retourner que les index de la dataframe qui sont dans le round actuel"
data = dataframe["user_attrs"].values
index_result = list()
for index, line in enumerate(round_conf):
if np.max(np.all(data == line,axis=1)):
index_result.append(np.argmax(np.all(data == line,axis=1)))
return index_result | [
"def",
"dataframe_filter",
"(",
"dataframe",
",",
"round_conf",
")",
":",
"data",
"=",
"dataframe",
"[",
"\"user_attrs\"",
"]",
".",
"values",
"index_result",
"=",
"list",
"(",
")",
"for",
"index",
",",
"line",
"in",
"enumerate",
"(",
"round_conf",
")",
":... | [
83,
0
] | [
91,
23
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
get_list_passagers | (df) | return listePassagers | Renvoie une liste qui à chaque index de groupe
renvoie une liste de ses passagers.
| Renvoie une liste qui à chaque index de groupe
renvoie une liste de ses passagers.
| def get_list_passagers(df):
"""Renvoie une liste qui à chaque index de groupe
renvoie une liste de ses passagers.
"""
# Liste des groupes
listeGroupes = get_list_groupes(df)
# Liste des passagers, récupérée via la liste des groupes
listePassagers = []
for groupe in listeGroupes.keys():
listePassagers += listeGroupes[groupe].list_passagers
return listePassagers | [
"def",
"get_list_passagers",
"(",
"df",
")",
":",
"# Liste des groupes",
"listeGroupes",
"=",
"get_list_groupes",
"(",
"df",
")",
"# Liste des passagers, récupérée via la liste des groupes",
"listePassagers",
"=",
"[",
"]",
"for",
"groupe",
"in",
"listeGroupes",
".",
"k... | [
211,
0
] | [
224,
25
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
filtre_son_extrait | (t,a,b) | calcul de la transformee de Fourier, application du filtre [a,b],
recomposition du signal | calcul de la transformee de Fourier, application du filtre [a,b],
recomposition du signal | def filtre_son_extrait(t,a,b):
"""calcul de la transformee de Fourier, application du filtre [a,b],
recomposition du signal"""
fft = FFT.fft (t)
global fourier
if fourier == None and indice != None : fourier = copy.copy(fft)
for i in xrange(0,len(t)):
if a <= i <= b:
pass
else:
fft [i] = complex(0,0)
tt = FFT.inverse_fft(fft)
for i in xrange(0,len(t)):
t [i] = int(tt [i].real) | [
"def",
"filtre_son_extrait",
"(",
"t",
",",
"a",
",",
"b",
")",
":",
"fft",
"=",
"FFT",
".",
"fft",
"(",
"t",
")",
"global",
"fourier",
"if",
"fourier",
"==",
"None",
"and",
"indice",
"!=",
"None",
":",
"fourier",
"=",
"copy",
".",
"copy",
"(",
"... | [
76,
0
] | [
89,
32
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
InterfaceJeu.initInterface | (self) | Initialisation des composants Tkinter pour le jeu | Initialisation des composants Tkinter pour le jeu | def initInterface(self):
"""Initialisation des composants Tkinter pour le jeu"""
# Label "mode de jeu"
self.modeLabel = tk.Label(self, text="Mode {}".format(self.parent.mode))
self.modeLabel.grid(column=1, row=0)
# Label "score J1"
self.j1 = tk.Frame(self, borderwidth=1, relief=tk.SUNKEN, background="white")
self.j1.grid(column=0, row=0)
tk.Label(self.j1, text="Joueur 1").pack(padx=10, pady=2)
self.scj1 = tk.Label(self.j1, text=self.scoreJ1)
self.scj1.pack()
# Label "score J2"
self.j2= tk.Frame(self, borderwidth=1, relief=tk.SUNKEN, background="white")
self.j2.grid(column=2, row=0)
tk.Label(self.j2, text="Joueur 2:").pack(padx=10, pady=2)
self.scj2 = tk.Label(self.j2, text=self.scoreJ2)
self.scj2.pack()
# Label message d'erreur
self.erreur = tk.Label(self, text="")
self.erreur.grid(column=1, row=1)
# Canvas du jeu
self.canvas = tk.Canvas(self, background='white')
self.canvas.bind("<Button-1>", self.pointeur)
self.canvas.grid(column=1, row=2) | [
"def",
"initInterface",
"(",
"self",
")",
":",
"# Label \"mode de jeu\"",
"self",
".",
"modeLabel",
"=",
"tk",
".",
"Label",
"(",
"self",
",",
"text",
"=",
"\"Mode {}\"",
".",
"format",
"(",
"self",
".",
"parent",
".",
"mode",
")",
")",
"self",
".",
"m... | [
189,
1
] | [
217,
35
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
Admin.idea_valid | (self, ctx: MyContext, ID:int, valid:bool=True) | Marque une idée comme étant ajoutée à la prochaine MàJ | Marque une idée comme étant ajoutée à la prochaine MàJ | async def idea_valid(self, ctx: MyContext, ID:int, valid:bool=True):
"""Marque une idée comme étant ajoutée à la prochaine MàJ"""
try:
chan = ctx.bot.get_channel(548138866591137802) if self.bot.beta else ctx.bot.get_channel(488769306524385301)
if chan is None:
return await ctx.send("Salon introuvable")
try:
msg = await chan.fetch_message(ID)
except Exception as e:
return await ctx.send("`Error:` {}".format(e))
if len(msg.embeds)!=1:
return await ctx.send("Nombre d'embeds invalide")
emb = msg.embeds[0]
if valid:
emb.color = discord.Color(10146593)
else:
emb.color = discord.Color(16106019)
await msg.edit(embed=emb)
await ctx.bot.get_cog('Utilities').add_check_reaction(ctx.message)
except Exception as e:
await self.bot.get_cog('Errors').on_command_error(ctx,e) | [
"async",
"def",
"idea_valid",
"(",
"self",
",",
"ctx",
":",
"MyContext",
",",
"ID",
":",
"int",
",",
"valid",
":",
"bool",
"=",
"True",
")",
":",
"try",
":",
"chan",
"=",
"ctx",
".",
"bot",
".",
"get_channel",
"(",
"548138866591137802",
")",
"if",
... | [
917,
4
] | [
937,
68
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
sync_categories | () | Synchroniser les catégories avec CKAN. | Synchroniser les catégories avec CKAN. | def sync_categories():
"""Synchroniser les catégories avec CKAN."""
for category in Category.objects.all():
if not CkanHandler.is_group_exists(category.slug):
CkanHandler.add_group(category) | [
"def",
"sync_categories",
"(",
")",
":",
"for",
"category",
"in",
"Category",
".",
"objects",
".",
"all",
"(",
")",
":",
"if",
"not",
"CkanHandler",
".",
"is_group_exists",
"(",
"category",
".",
"slug",
")",
":",
"CkanHandler",
".",
"add_group",
"(",
"ca... | [
129,
0
] | [
134,
43
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
dessine_grille | (grille) | return g | Retourne sous forme de chaine de caracteres l'état de la grille de jeu
ainsi que le numéro des colonnes:
-O pour le joueur 1
-X pour le joueur 2
| Retourne sous forme de chaine de caracteres l'état de la grille de jeu
ainsi que le numéro des colonnes:
-O pour le joueur 1
-X pour le joueur 2 | def dessine_grille(grille):
"""Retourne sous forme de chaine de caracteres l'état de la grille de jeu
ainsi que le numéro des colonnes:
-O pour le joueur 1
-X pour le joueur 2
"""
g = ""
g += "—————————————\n"
for i in range(0, 6): g += "|" + str(i + 1)
g += "|\n"
g += "—————————————\n"
for j in range(0, 7):
for i in range(0, 6):
if not grille[i][j] == 0:
g += " " + grille[i][j]
else: g += " -"
g += "\n—————————————\n"
return g | [
"def",
"dessine_grille",
"(",
"grille",
")",
":",
"g",
"=",
"\"\"",
"g",
"+=",
"\"—————————————\\n\"",
"for",
"i",
"in",
"range",
"(",
"0",
",",
"6",
")",
":",
"g",
"+=",
"\"|\"",
"+",
"str",
"(",
"i",
"+",
"1",
")",
"g",
"+=",
"\"|\\n\"",
"g",
... | [
15,
0
] | [
34,
12
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
Facette.point_interieur | (self, p) | return theta >= math.pi * 0.9 | dit si un point appartient à l'intérieur du triangle | dit si un point appartient à l'intérieur du triangle | def point_interieur(self, p):
"""dit si un point appartient à l'intérieur du triangle"""
pa = self.a - p
pb = self.b - p
pc = self.c - p
theta = pa.angle(pb, self.vnorm)
theta += pb.angle(pc, self.vnorm)
theta += pc.angle(pa, self.vnorm)
theta = abs(theta)
return theta >= math.pi * 0.9 | [
"def",
"point_interieur",
"(",
"self",
",",
"p",
")",
":",
"pa",
"=",
"self",
".",
"a",
"-",
"p",
"pb",
"=",
"self",
".",
"b",
"-",
"p",
"pc",
"=",
"self",
".",
"c",
"-",
"p",
"theta",
"=",
"pa",
".",
"angle",
"(",
"pb",
",",
"self",
".",
... | [
30,
4
] | [
39,
37
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
Crud.get_form_prop | (self, prop, default="") | return self.application["tables"][self.ctx["table_id"]]["forms"][self.ctx["form_id"]].get(prop, default) | Obtenir la valeur d'une propriété du formulaire courant | Obtenir la valeur d'une propriété du formulaire courant | def get_form_prop(self, prop, default=""):
""" Obtenir la valeur d'une propriété du formulaire courant """
return self.application["tables"][self.ctx["table_id"]]["forms"][self.ctx["form_id"]].get(prop, default) | [
"def",
"get_form_prop",
"(",
"self",
",",
"prop",
",",
"default",
"=",
"\"\"",
")",
":",
"return",
"self",
".",
"application",
"[",
"\"tables\"",
"]",
"[",
"self",
".",
"ctx",
"[",
"\"table_id\"",
"]",
"]",
"[",
"\"forms\"",
"]",
"[",
"self",
".",
"c... | [
503,
4
] | [
505,
112
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
Odrive.Rounds_To_Length | (self, rounds) | return(length) | Convertie un nombre de tours de roue a parcourir en une distance (en mm) | Convertie un nombre de tours de roue a parcourir en une distance (en mm) | def Rounds_To_Length(self, rounds):
"""Convertie un nombre de tours de roue a parcourir en une distance (en mm)"""
length = rounds * (self.Diameter * math.pi)
#print("nb_rounds = ", nb_rounds)
return(length) | [
"def",
"Rounds_To_Length",
"(",
"self",
",",
"rounds",
")",
":",
"length",
"=",
"rounds",
"*",
"(",
"self",
".",
"Diameter",
"*",
"math",
".",
"pi",
")",
"#print(\"nb_rounds = \", nb_rounds)",
"return",
"(",
"length",
")"
] | [
82,
1
] | [
86,
16
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
Map.charger_images | (self) | Charge dans la variable self.arriere_plan l'image superposée des 3 premieres couches (0, 1, 2)
Charge dans la variable self.premier_plan l'image de la dernière couche (3)
| Charge dans la variable self.arriere_plan l'image superposée des 3 premieres couches (0, 1, 2)
Charge dans la variable self.premier_plan l'image de la dernière couche (3)
| def charger_images(self):
""" Charge dans la variable self.arriere_plan l'image superposée des 3 premieres couches (0, 1, 2)
Charge dans la variable self.premier_plan l'image de la dernière couche (3)
"""
for i in range(4): # Je parcours les couches
for y in range(self.y): # Parcours les colonnes
for x in range(self.x): # Je parcours les lignes
if self.matrices[i][y][x] in ct.tuiles: # Si elle existe
tuile = ct.tuiles[self.matrices[i][y][x]] # On extrait
if i < 3: # Si on parcours les couches 2, 1 et 0
self.arriere_plan.blit(tuile, (x*32, y*32)) # On colle les images sur l'arrière plan tuile par tuile
else:
self.premier_plan.blit(tuile, (x*32, y*32)) | [
"def",
"charger_images",
"(",
"self",
")",
":",
"for",
"i",
"in",
"range",
"(",
"4",
")",
":",
"# Je parcours les couches",
"for",
"y",
"in",
"range",
"(",
"self",
".",
"y",
")",
":",
"# Parcours les colonnes",
"for",
"x",
"in",
"range",
"(",
"self",
"... | [
179,
4
] | [
192,
71
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
Picsou.update_note | (self) | Mise à jour du champ note avec des infos pertinentes pour le trading | Mise à jour du champ note avec des infos pertinentes pour le trading | def update_note(self):
""" Mise à jour du champ note avec des infos pertinentes pour le trading """
ptfs = self.crud.sql_to_dict(self.crud.get_basename(), """
SELECT * FROM ptf where ptf_enabled = '1' order by ptf_id
""", {})
for ptf in ptfs:
quotes = self.crud.sql_to_dict(self.crud.get_basename(), """
SELECT * FROM quotes where id = :id order by date desc limit 1
""", {"id": ptf["ptf_id"]})
if quotes is None : continue
quote = quotes[0]
"""
- P4 : si quotemin < -4 %
- Q0 : si quotemin < 0 et close > close1
"""
note = ""
pmin = (quote["low"] - quote["close1"])/quote["close1"]
if float(pmin) < -0.04 : note = "P4"
if quote["low"] < quote["close1"] and quote["close"] > quote["close1"] :
note += " Q+"
self.crud.exec_sql(self.crud.get_basename(), """
update ptf set ptf_note = :note where ptf_id = :id
""", {"id": ptf["ptf_id"], "note": note})
if note != "" :
self.display("{} : {}".format(ptf["ptf_id"], note)) | [
"def",
"update_note",
"(",
"self",
")",
":",
"ptfs",
"=",
"self",
".",
"crud",
".",
"sql_to_dict",
"(",
"self",
".",
"crud",
".",
"get_basename",
"(",
")",
",",
"\"\"\"\n SELECT * FROM ptf where ptf_enabled = '1' order by ptf_id\n \"\"\"",
",",
"... | [
211,
4
] | [
235,
67
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
regexp | (motif: str, item: str) | return pattern.search(item) is not None | retourne True si le motif regex a été satisfait dans l'item
False sinon
| retourne True si le motif regex a été satisfait dans l'item
False sinon
| def regexp(motif: str, item: str) -> bool:
"""retourne True si le motif regex a été satisfait dans l'item
False sinon
"""
pattern = compile(motif, I)
return pattern.search(item) is not None | [
"def",
"regexp",
"(",
"motif",
":",
"str",
",",
"item",
":",
"str",
")",
"->",
"bool",
":",
"pattern",
"=",
"compile",
"(",
"motif",
",",
"I",
")",
"return",
"pattern",
".",
"search",
"(",
"item",
")",
"is",
"not",
"None"
] | [
16,
0
] | [
21,
43
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
SegmentBord_Commun.__str__ | (self) | return s | permet d'afficher le segment | permet d'afficher le segment | def __str__(self):
"""permet d'afficher le segment"""
s = Segment.__str__(self)
s += " -- dim -- " + self.dim.__str__()
return s | [
"def",
"__str__",
"(",
"self",
")",
":",
"s",
"=",
"Segment",
".",
"__str__",
"(",
"self",
")",
"s",
"+=",
"\" -- dim -- \"",
"+",
"self",
".",
"dim",
".",
"__str__",
"(",
")",
"return",
"s"
] | [
34,
4
] | [
38,
16
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
domoticz_write_log | (message) | return req.status_code | Fonction d'ecriture log dans Domoticz
| Fonction d'ecriture log dans Domoticz
| def domoticz_write_log(message):
"""Fonction d'ecriture log dans Domoticz
"""
myurl=url_domoticz+u'command¶m=addlogmessage&message='+message
req=requests.get(myurl)
if debug:
print(u' '.join((u'GET-> ',myurl,' : ',str(req.status_code))).encode('utf-8'))
if (req.status_code != 200):
http_error(req.status_code,req.reason) # Appel fonction sur erreur HTTP
return req.status_code | [
"def",
"domoticz_write_log",
"(",
"message",
")",
":",
"myurl",
"=",
"url_domoticz",
"+",
"u'command¶m=addlogmessage&message='",
"+",
"message",
"req",
"=",
"requests",
".",
"get",
"(",
"myurl",
")",
"if",
"debug",
":",
"print",
"(",
"u' '",
".",
"join",
... | [
104,
0
] | [
113,
26
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
english_to_french | (english_text) | return french_text | traduit anglais en francais | traduit anglais en francais | def english_to_french(english_text):
""" traduit anglais en francais"""
if english_text is None:
french_text = None
else:
l_t = get_language_translator(apikey, version, url)
translation = l_t.translate(
text=english_text,
model_id='en-fr').get_result()
french_text = translation['translations'][0]['translation']
return french_text | [
"def",
"english_to_french",
"(",
"english_text",
")",
":",
"if",
"english_text",
"is",
"None",
":",
"french_text",
"=",
"None",
"else",
":",
"l_t",
"=",
"get_language_translator",
"(",
"apikey",
",",
"version",
",",
"url",
")",
"translation",
"=",
"l_t",
"."... | [
21,
0
] | [
32,
22
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
FenetrePrincipale.taille_du_jeu | (self, taille) | Gère le menu pour changer la taille du jeu à *taille* | Gère le menu pour changer la taille du jeu à *taille* | def taille_du_jeu(self, taille):
"""Gère le menu pour changer la taille du jeu à *taille*"""
if box.askyesno(
'Redémarrage',
'Voulez vous vraiment recommencer une nouvelle partie avec la taille {} ?'.format(taille)):
self.taille = taille
self.reset() | [
"def",
"taille_du_jeu",
"(",
"self",
",",
"taille",
")",
":",
"if",
"box",
".",
"askyesno",
"(",
"'Redémarrage',",
"",
"'Voulez vous vraiment recommencer une nouvelle partie avec la taille {} ?'",
".",
"format",
"(",
"taille",
")",
")",
":",
"self",
".",
"taille",
... | [
98,
1
] | [
104,
15
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
InterfaceJeu.__init__ | (self, parent, *args, **kwargs) | Initialisation du jeu | Initialisation du jeu | def __init__(self, parent, *args, **kwargs):
"""Initialisation du jeu"""
tk.Frame.__init__(self, parent, *args, **kwargs)
self.parent = parent
# Init variables
self.scoreJ1 = self.scoreJ2 = 0
self.cpt_tour = 1
self.largeur = 6
self.piece_choisie = None
self.board = None
self.listePieces = []
# Init interface
self.initInterface()
# Init plateau de jeu
self.initBoard()
self.initGrille()
self.updateColors()
# Gestion du mode de jeu
if self.parent.mode == "standard":
# Initialisation du tableau de choix des pièces en mode standard
def abandon():
# Mise à jour des scores
if self.cpt_tour == 1:
tk.messagebox.showinfo(
"Victoire !",
"Bravo ! Le joueur 2 à remporté la partie par abandon.")
self.scoreJ2 += 1
else:
tk.messagebox.showinfo(
"Victoire !",
"Bravo ! Le joueur 1 à remporté la partie par abandon.")
self.scoreJ1 += 1
self.scj1.config(text=self.scoreJ1)
self.scj2.config(text=self.scoreJ2)
# Verrouillage du jeu
self.abandonner.config(state=tk.DISABLED)
self.canvas.unbind("<Button-1>")
def tab1(_):
self.piece_choisie=self.listePieces[0]
def tab2(_):
self.piece_choisie=self.listePieces[1]
def tab3(_):
self.piece_choisie=self.listePieces[2]
self.abandonner=tk.Button(self, text="J'abandonne", command=abandon)
self.abandonner.grid(column=2, row=2)
# Création de chaque canvas contenant les pièces à jouer
self.tabpieces0 = tk.Canvas(self,
width=(100), height=(100),
background='thistle2')
self.tabpieces0.grid(column=0, row = 3)
self.tabpieces0.bind("<Button-1>",tab1)
self.tabpieces1 = tk.Canvas(self,
width=(100), height=(100),
background='thistle2')
self.tabpieces1.grid(column=1, row = 3)
self.tabpieces1.bind("<Button-1>",tab2)
self.tabpieces2 = tk.Canvas(self,
width=(100), height=(100),
background='thistle2')
self.tabpieces2.grid(column=2, row = 3)
self.tabpieces2.bind("<Button-1>",tab3)
self.initChoix()
elif self.parent.mode == "random":
# TODO Finir le mode aléatoire
pass | [
"def",
"__init__",
"(",
"self",
",",
"parent",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"tk",
".",
"Frame",
".",
"__init__",
"(",
"self",
",",
"parent",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
"self",
".",
"parent",
"=",
"pa... | [
112,
1
] | [
187,
7
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
parcours_en_largeur | (m, f) | Applique la fonction f à chaque sommet du graphe.
m - matrice d'adjacence.
f - fonction prenant un sommet en argument.
| Applique la fonction f à chaque sommet du graphe.
m - matrice d'adjacence.
f - fonction prenant un sommet en argument.
| def parcours_en_largeur(m, f):
"""Applique la fonction f à chaque sommet du graphe.
m - matrice d'adjacence.
f - fonction prenant un sommet en argument.
"""
marque = [] # On ne souhaite pas traiter plusieurs fois un sommet
queue = [] # On utilise une queue pour traiter d'abord les plus proches
for s in range(len(m)): # Visite chaque sommet pour les graphes non-connexes
if s not in marque: # Evite de traiter 2 fois un sommet
marque.append(s) # Marque le sommet courant à traiter
queue.append(s) # Empile dans la queue des sommets à traiter
while len(queue) != 0: # Tant que la queue est non vide
s_i = queue.pop(0) # On prend le 1er sommet
f(s_i) # On traite s_i
suivants = successeurs(m, s_i) # On prend les successeurs
for suivant in suivants: # On parcourt les successeurs
if suivant not in marque: # Les successeurs non marqués
marque.append(suivant) # sont marqués
queue.append(suivant) | [
"def",
"parcours_en_largeur",
"(",
"m",
",",
"f",
")",
":",
"marque",
"=",
"[",
"]",
"# On ne souhaite pas traiter plusieurs fois un sommet",
"queue",
"=",
"[",
"]",
"# On utilise une queue pour traiter d'abord les plus proches",
"for",
"s",
"in",
"range",
"(",
"len",
... | [
51,
0
] | [
70,
45
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
attendre_clic | (screen) | attend la pression d'un clic de souris pour continuer | attend la pression d'un clic de souris pour continuer | def attendre_clic(screen):
"""attend la pression d'un clic de souris pour continuer"""
reste = True
while reste:
for event in pygame.event.get():
if event.type == pygame.MOUSEBUTTONUP:
reste = False
break | [
"def",
"attendre_clic",
"(",
"screen",
")",
":",
"reste",
"=",
"True",
"while",
"reste",
":",
"for",
"event",
"in",
"pygame",
".",
"event",
".",
"get",
"(",
")",
":",
"if",
"event",
".",
"type",
"==",
"pygame",
".",
"MOUSEBUTTONUP",
":",
"reste",
"="... | [
87,
0
] | [
94,
21
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
RingMod.input | (self) | return self._input | PyoObject. Singal d'entrée à traiter. | PyoObject. Singal d'entrée à traiter. | def input(self):
"""PyoObject. Singal d'entrée à traiter."""
return self._input | [
"def",
"input",
"(",
"self",
")",
":",
"return",
"self",
".",
"_input"
] | [
84,
4
] | [
86,
26
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
create_dict | (nodes, relations) | return result | Crée une liste d'adjacence à partir d'une liste de noeuds et de relations | Crée une liste d'adjacence à partir d'une liste de noeuds et de relations | def create_dict(nodes, relations):
"""Crée une liste d'adjacence à partir d'une liste de noeuds et de relations"""
result = {}
# Pour chaque noeud
for node in nodes:
id = node[0]
neighbours = []
# Pour chaque relation
for relation in relations:
start = relation[0]
end = relation[1]
oriented = relation[2] == 1
# On vérifie si le noeud est concerné par la relation,
if start == id:
# dans ce cas on l'ajoute l'autre noeud concerné dans la liste des voisins
neighbours.append(end)
elif end == id and not oriented:
neighbours.append(start)
# finalement on ajoute le noeud et ses voisins au dictionnaire
result[id] = neighbours
return result | [
"def",
"create_dict",
"(",
"nodes",
",",
"relations",
")",
":",
"result",
"=",
"{",
"}",
"# Pour chaque noeud",
"for",
"node",
"in",
"nodes",
":",
"id",
"=",
"node",
"[",
"0",
"]",
"neighbours",
"=",
"[",
"]",
"# Pour chaque relation",
"for",
"relation",
... | [
3,
0
] | [
23,
17
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
create_df_etab | (data, data_global, columns_from_global, etab) | return df | Cette fonction crée et renvoie la dataframe contenant toutes les observations pour un établissement. | Cette fonction crée et renvoie la dataframe contenant toutes les observations pour un établissement. | def create_df_etab(data, data_global, columns_from_global, etab):
"""Cette fonction crée et renvoie la dataframe contenant toutes les observations pour un établissement."""
df = (
data[data["nom_etab"] == etab]
# Pour pouvoir ensuite grouper sur la date, on la retire de l'index
.reset_index()
.groupby("date")[["prevision", "reel", "effectif"]]
.sum()
# On enrichit avec les variables exogènes
.join(data_global[columns_from_global])
)
return df | [
"def",
"create_df_etab",
"(",
"data",
",",
"data_global",
",",
"columns_from_global",
",",
"etab",
")",
":",
"df",
"=",
"(",
"data",
"[",
"data",
"[",
"\"nom_etab\"",
"]",
"==",
"etab",
"]",
"# Pour pouvoir ensuite grouper sur la date, on la retire de l'index",
".",... | [
26,
0
] | [
38,
13
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
Vecteur.angle | (self, v, norm) | return angle | retourne l'angle entre les vecteur self et v,
retourne un angle compris entre -pi et pi,
norm est la direction du vecteur normal au plan des deux vecteurs | retourne l'angle entre les vecteur self et v,
retourne un angle compris entre -pi et pi,
norm est la direction du vecteur normal au plan des deux vecteurs | def angle(self, v, norm):
"""retourne l'angle entre les vecteur self et v,
retourne un angle compris entre -pi et pi,
norm est la direction du vecteur normal au plan des deux vecteurs"""
cos = self.cosinus(v)
sin = self.sinus(v, norm)
angle = math.atan2(sin, cos)
if angle > math.pi:
angle -= math.pi * 2
return angle | [
"def",
"angle",
"(",
"self",
",",
"v",
",",
"norm",
")",
":",
"cos",
"=",
"self",
".",
"cosinus",
"(",
"v",
")",
"sin",
"=",
"self",
".",
"sinus",
"(",
"v",
",",
"norm",
")",
"angle",
"=",
"math",
".",
"atan2",
"(",
"sin",
",",
"cos",
")",
... | [
119,
4
] | [
128,
20
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
UserShow.put | (self, request, username) | return HttpResponse(status=204) | Mettre à jour un utilisateur. | Mettre à jour un utilisateur. | def put(self, request, username):
"""Mettre à jour un utilisateur."""
request.PUT, request._files = parse_request(request)
request.PUT._mutable = True
if not request.user.profile.is_admin:
raise Http404()
try:
handle_pust_request(request, username=username)
except Http404:
raise Http404()
except GenericException as e:
return JsonResponse({'error': e.details}, status=400)
return HttpResponse(status=204) | [
"def",
"put",
"(",
"self",
",",
"request",
",",
"username",
")",
":",
"request",
".",
"PUT",
",",
"request",
".",
"_files",
"=",
"parse_request",
"(",
"request",
")",
"request",
".",
"PUT",
".",
"_mutable",
"=",
"True",
"if",
"not",
"request",
".",
"... | [
256,
4
] | [
268,
39
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
close | (event) | attributions : option "Quitter" du sous menu "Fichiers" (l.afpt)
description : appelle la fonction 'f_close()' du fichier 'fonctions.py'
paramètres : - event => event est le widget sur lequel l'utilisateur est à l'appel de la fonction | attributions : option "Quitter" du sous menu "Fichiers" (l.afpt)
description : appelle la fonction 'f_close()' du fichier 'fonctions.py'
paramètres : - event => event est le widget sur lequel l'utilisateur est à l'appel de la fonction | def close(event):
"""attributions : option "Quitter" du sous menu "Fichiers" (l.afpt)
description : appelle la fonction 'f_close()' du fichier 'fonctions.py'
paramètres : - event => event est le widget sur lequel l'utilisateur est à l'appel de la fonction"""
f_close(event) | [
"def",
"close",
"(",
"event",
")",
":",
"f_close",
"(",
"event",
")"
] | [
49,
0
] | [
53,
18
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
Couleur.borne | (self) | si une couleur est hors bornes, réajuste la couleur, prend le maximum devient 1,
les autres intensités sont ajustées selon ce facteur d'échelle | si une couleur est hors bornes, réajuste la couleur, prend le maximum devient 1,
les autres intensités sont ajustées selon ce facteur d'échelle | def borne(self):
"""si une couleur est hors bornes, réajuste la couleur, prend le maximum devient 1,
les autres intensités sont ajustées selon ce facteur d'échelle"""
if self.x < 0:
self.x = 0
if self.y < 0:
self.y = 0
if self.z < 0:
self.z = 0
m = max(self.x, self.y)
m = max(m, self.z)
if m > 1:
self.x /= m
self.y /= m
self.z /= m | [
"def",
"borne",
"(",
"self",
")",
":",
"if",
"self",
".",
"x",
"<",
"0",
":",
"self",
".",
"x",
"=",
"0",
"if",
"self",
".",
"y",
"<",
"0",
":",
"self",
".",
"y",
"=",
"0",
"if",
"self",
".",
"z",
"<",
"0",
":",
"self",
".",
"z",
"=",
... | [
158,
4
] | [
172,
23
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
Reloads.rm_cog | (self,ctx,name) | Enlever un cog au bot | Enlever un cog au bot | async def rm_cog(self,ctx,name):
"""Enlever un cog au bot"""
if not ctx.author.id in admins_id:
return
try:
self.bot.unload_extension('fcts.'+name)
await ctx.send("Module '{}' désactivé !".format(name))
self.bot.log.info("Module {} ajouté".format(name))
except Exception as e:
await ctx.send(str(e)) | [
"async",
"def",
"rm_cog",
"(",
"self",
",",
"ctx",
",",
"name",
")",
":",
"if",
"not",
"ctx",
".",
"author",
".",
"id",
"in",
"admins_id",
":",
"return",
"try",
":",
"self",
".",
"bot",
".",
"unload_extension",
"(",
"'fcts.'",
"+",
"name",
")",
"aw... | [
80,
4
] | [
89,
34
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
stack.push | (self, elem) | return 0 | Ajouter un élément non nul à la pile. (O(1)).
Retourne 1 si l'ajout s'est bien déroulé. 0 sinon | Ajouter un élément non nul à la pile. (O(1)).
Retourne 1 si l'ajout s'est bien déroulé. 0 sinon | def push(self, elem):
"""Ajouter un élément non nul à la pile. (O(1)).
Retourne 1 si l'ajout s'est bien déroulé. 0 sinon"""
if elem != None:
self.list.append(elem)
self.size+=1
return 1
return 0 | [
"def",
"push",
"(",
"self",
",",
"elem",
")",
":",
"if",
"elem",
"!=",
"None",
":",
"self",
".",
"list",
".",
"append",
"(",
"elem",
")",
"self",
".",
"size",
"+=",
"1",
"return",
"1",
"return",
"0"
] | [
11,
4
] | [
20,
16
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
set_head_location | () | Le point '19' est au centre de [14, 15] soit au centre des yeux.
Il ne vient pas de COCO !
| Le point '19' est au centre de [14, 15] soit au centre des yeux.
Il ne vient pas de COCO !
| def set_head_location():
""" Le point '19' est au centre de [14, 15] soit au centre des yeux.
Il ne vient pas de COCO !
"""
if gl.points[14] and gl.points[15]:
pos = (gl.spheres[14].worldPosition + gl.spheres[15].worldPosition)/2
gl.spheres[19].worldPosition = [pos[0], pos[1], pos[2]]
gl.spheres[19].worldScale = [1.5*gl.scale, 1.5*gl.scale, 1.5*gl.scale] | [
"def",
"set_head_location",
"(",
")",
":",
"if",
"gl",
".",
"points",
"[",
"14",
"]",
"and",
"gl",
".",
"points",
"[",
"15",
"]",
":",
"pos",
"=",
"(",
"gl",
".",
"spheres",
"[",
"14",
"]",
".",
"worldPosition",
"+",
"gl",
".",
"spheres",
"[",
... | [
75,
0
] | [
82,
79
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
create_month_columns | (X) | return X | Cette fonction permet de créer les dummies * effectif pour les mois | Cette fonction permet de créer les dummies * effectif pour les mois | def create_month_columns(X):
"""Cette fonction permet de créer les dummies * effectif pour les mois"""
# On crée des dummies pour chaque jour
X_month = pd.get_dummies(X.index.to_series().dt.month, drop_first=True, prefix="month")
for col in X_month:
X_month[col] = X_month[col] * X["effectif"]
X_month.index = X.index
X = pd.concat([X_month, X], axis=1)
return X | [
"def",
"create_month_columns",
"(",
"X",
")",
":",
"# On crée des dummies pour chaque jour",
"X_month",
"=",
"pd",
".",
"get_dummies",
"(",
"X",
".",
"index",
".",
"to_series",
"(",
")",
".",
"dt",
".",
"month",
",",
"drop_first",
"=",
"True",
",",
"prefix",... | [
68,
0
] | [
76,
12
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
Welcomer.check_contributor | (self, member: discord.Member) | Vérifie si un nouvel arrivant est un contributeur | Vérifie si un nouvel arrivant est un contributeur | async def check_contributor(self, member: discord.Member):
"""Vérifie si un nouvel arrivant est un contributeur"""
if await self.bot.get_cog('Users').has_userflag(member, 'contributor'):
role = member.guild.get_role(552428810562437126)
if role is not None:
await member.add_roles(role)
else:
self.bot.log.warning('[check_contributor] Contributor role not found') | [
"async",
"def",
"check_contributor",
"(",
"self",
",",
"member",
":",
"discord",
".",
"Member",
")",
":",
"if",
"await",
"self",
".",
"bot",
".",
"get_cog",
"(",
"'Users'",
")",
".",
"has_userflag",
"(",
"member",
",",
"'contributor'",
")",
":",
"role",
... | [
102,
4
] | [
109,
86
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
Couleur.produit_terme | (self, v) | return Couleur(self.x * v.x, self.y * v.y, self.z * v.z) | effectue un produit terme à terme | effectue un produit terme à terme | def produit_terme(self, v):
"""effectue un produit terme à terme"""
return Couleur(self.x * v.x, self.y * v.y, self.z * v.z) | [
"def",
"produit_terme",
"(",
"self",
",",
"v",
")",
":",
"return",
"Couleur",
"(",
"self",
".",
"x",
"*",
"v",
".",
"x",
",",
"self",
".",
"y",
"*",
"v",
".",
"y",
",",
"self",
".",
"z",
"*",
"v",
".",
"z",
")"
] | [
178,
4
] | [
180,
64
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
Segment.normal | (self) | return p | retourne le vecteur normal du segment,
ce vecteur est norme | retourne le vecteur normal du segment,
ce vecteur est norme | def normal(self) -> float:
"""retourne le vecteur normal du segment,
ce vecteur est norme"""
p = Point(self.a.y - self.b.y, self.b.x - self.a.x)
p.normalise()
return p | [
"def",
"normal",
"(",
"self",
")",
"->",
"float",
":",
"p",
"=",
"Point",
"(",
"self",
".",
"a",
".",
"y",
"-",
"self",
".",
"b",
".",
"y",
",",
"self",
".",
"b",
".",
"x",
"-",
"self",
".",
"a",
".",
"x",
")",
"p",
".",
"normalise",
"(",... | [
130,
4
] | [
135,
16
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
Map.afficher_arriere_plan | (self) | Affiche les 3 premières couches de la map
3 premières couches (0,1,2) = Arrière plan
| Affiche les 3 premières couches de la map
3 premières couches (0,1,2) = Arrière plan
| def afficher_arriere_plan(self):
""" Affiche les 3 premières couches de la map
3 premières couches (0,1,2) = Arrière plan
"""
cp.ecran.blit(self.arriere_plan, (self.x_camera,
self.y_camera)) | [
"def",
"afficher_arriere_plan",
"(",
"self",
")",
":",
"cp",
".",
"ecran",
".",
"blit",
"(",
"self",
".",
"arriere_plan",
",",
"(",
"self",
".",
"x_camera",
",",
"self",
".",
"y_camera",
")",
")"
] | [
65,
4
] | [
70,
57
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
Crud.get_view_prop | (self, prop, default="") | return self.application["tables"][self.ctx["table_id"]]["views"][self.ctx["view_id"]].get(prop, default) | Obtenir la valeur d'une propriété de la vue courante | Obtenir la valeur d'une propriété de la vue courante | def get_view_prop(self, prop, default=""):
""" Obtenir la valeur d'une propriété de la vue courante """
return self.application["tables"][self.ctx["table_id"]]["views"][self.ctx["view_id"]].get(prop, default) | [
"def",
"get_view_prop",
"(",
"self",
",",
"prop",
",",
"default",
"=",
"\"\"",
")",
":",
"return",
"self",
".",
"application",
"[",
"\"tables\"",
"]",
"[",
"self",
".",
"ctx",
"[",
"\"table_id\"",
"]",
"]",
"[",
"\"views\"",
"]",
"[",
"self",
".",
"c... | [
492,
4
] | [
494,
112
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
Odrive.Rotation | (self,angle) | Rotation en degres de roue parcourue (trigonometrique) | Rotation en degres de roue parcourue (trigonometrique) | def Rotation(self,angle):
''' Rotation en degres de roue parcourue (trigonometrique)'''
print("Position de depart\nPosition moteur0 = %.2f\nPosition moteur1 = %.2f" % (self.motor0.encoder.pos_estimate,self.motor1.encoder.pos_estimate)) # TODO: To fix
self.consigne = self.angle_to_rounds(angle)
self.motor0.controller.move_incremental(-1.0 * self.consigne, False) # False pour relatif
self.motor1.controller.move_incremental(-1.0 * self.consigne, False) # False pour relatif
self.wait_end_move() | [
"def",
"Rotation",
"(",
"self",
",",
"angle",
")",
":",
"print",
"(",
"\"Position de depart\\nPosition moteur0 = %.2f\\nPosition moteur1 = %.2f\"",
"%",
"(",
"self",
".",
"motor0",
".",
"encoder",
".",
"pos_estimate",
",",
"self",
".",
"motor1",
".",
"encoder",
".... | [
164,
1
] | [
170,
22
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
domoticz_write_device_switch_onoff | (etat, idx) | return req.status_code | Fonction d'écriture device light/switch
| Fonction d'écriture device light/switch
| def domoticz_write_device_switch_onoff(etat, idx):
''' Fonction d'écriture device light/switch
'''
etat=str(etat)
idx=str(idx)
myurl=url_domoticz+'command¶m=switchlight&idx='+idx+'&switchcmd='+etat
req=requests.get(myurl)
if debug:
print(u' '.join((u'GET-> ',myurl,' : ',str(req.status_code))).encode('utf-8'))
if (req.status_code != 200):
http_error(req.status_code,req.reason) # Appel fonction sur erreur HTTP
return req.status_code | [
"def",
"domoticz_write_device_switch_onoff",
"(",
"etat",
",",
"idx",
")",
":",
"etat",
"=",
"str",
"(",
"etat",
")",
"idx",
"=",
"str",
"(",
"idx",
")",
"myurl",
"=",
"url_domoticz",
"+",
"'command¶m=switchlight&idx='",
"+",
"idx",
"+",
"'&switchcmd='",
... | [
130,
0
] | [
142,
26
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
lucas | (n, r, p) | return c | Théorème de Lucas | Théorème de Lucas | def lucas(n, r, p):
""" Théorème de Lucas """
# https://fr.wikipedia.org/wiki/Théorème_de_Lucas
assert n >= r
c = 1
while r != 0:
c = (c * C[n % p][r % p]) % p
n //= p
r //= p
return c | [
"def",
"lucas",
"(",
"n",
",",
"r",
",",
"p",
")",
":",
"# https://fr.wikipedia.org/wiki/Théorème_de_Lucas",
"assert",
"n",
">=",
"r",
"c",
"=",
"1",
"while",
"r",
"!=",
"0",
":",
"c",
"=",
"(",
"c",
"*",
"C",
"[",
"n",
"%",
"p",
"]",
"[",
"r",
... | [
32,
0
] | [
41,
12
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
domoticz_write_device_switch_selector | (level, idx) | return req.status_code | Fonction d'écriture device selector switch
| Fonction d'écriture device selector switch
| def domoticz_write_device_switch_selector(level, idx):
''' Fonction d'écriture device selector switch
'''
level=str(level)
myurl=url_domoticz+'command¶m=switchlight&idx='+idx+'&switchcmd=Set%20Level&level='+level
req=requests.get(myurl)
if debug:
print(u' '.join((u'GET-> ',myurl,' : ',str(req.status_code))).encode('utf-8'))
if (req.status_code != 200):
http_error(req.status_code,req.reason) # Appel fonction sur erreur HTTP
return req.status_code | [
"def",
"domoticz_write_device_switch_selector",
"(",
"level",
",",
"idx",
")",
":",
"level",
"=",
"str",
"(",
"level",
")",
"myurl",
"=",
"url_domoticz",
"+",
"'command¶m=switchlight&idx='",
"+",
"idx",
"+",
"'&switchcmd=Set%20Level&level='",
"+",
"level",
"req"... | [
144,
0
] | [
155,
26
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
Facette.normale | (self, p, rayon) | retourne la normale au point de coordonnée p et connaissant le rayon | retourne la normale au point de coordonnée p et connaissant le rayon | def normale(self, p, rayon):
"""retourne la normale au point de coordonnée p et connaissant le rayon"""
if rayon.direction.scalaire(self.vnorm) < 0:
return self.vnorm
else:
return - self.vnorm | [
"def",
"normale",
"(",
"self",
",",
"p",
",",
"rayon",
")",
":",
"if",
"rayon",
".",
"direction",
".",
"scalaire",
"(",
"self",
".",
"vnorm",
")",
"<",
"0",
":",
"return",
"self",
".",
"vnorm",
"else",
":",
"return",
"-",
"self",
".",
"vnorm"
] | [
52,
4
] | [
57,
31
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
householder_product_left | (X, Y, M) | return M - 2 * np.dot(V, np.dot(V.T, M)) | Produit à gauche d'une matrice par une matrice de Householder.
Entrée:
X, Y, M respectivement deux vecteurs de mêmes tailles et une matrice.
Sortie:
Produit H*M où H est la matrice de Householder de passage de X vers Y.
| Produit à gauche d'une matrice par une matrice de Householder.
Entrée:
X, Y, M respectivement deux vecteurs de mêmes tailles et une matrice.
Sortie:
Produit H*M où H est la matrice de Householder de passage de X vers Y.
| def householder_product_left(X, Y, M):
""" Produit à gauche d'une matrice par une matrice de Householder.
Entrée:
X, Y, M respectivement deux vecteurs de mêmes tailles et une matrice.
Sortie:
Produit H*M où H est la matrice de Householder de passage de X vers Y.
"""
V = X - Y
if npl.norm(V) != 0:
V = V / np.linalg.norm(V)
return M - 2 * np.dot(V, np.dot(V.T, M)) | [
"def",
"householder_product_left",
"(",
"X",
",",
"Y",
",",
"M",
")",
":",
"V",
"=",
"X",
"-",
"Y",
"if",
"npl",
".",
"norm",
"(",
"V",
")",
"!=",
"0",
":",
"V",
"=",
"V",
"/",
"np",
".",
"linalg",
".",
"norm",
"(",
"V",
")",
"return",
"M",... | [
31,
0
] | [
43,
44
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
account_invoice.imprimer_simple_double | (self) | Imprimer en simple ou double exemplaire | Imprimer en simple ou double exemplaire | def imprimer_simple_double(self):
"""Imprimer en simple ou double exemplaire"""
cr , uid, context = self.env.args
db = self._cr.dbname
path="/tmp/factures-" + db + '-'+str(uid)
cde="rm -Rf " + path
os.popen(cde).readlines()
if not os.path.exists(path):
os.makedirs(path)
nb=len(self)
ct=1
paths=[]
for obj in self:
msg = str(ct)+'/'+str(nb)+' - Imprimer en simple ou double exemplaire : '+str(obj.number)
_logger.info(msg)
ct+=1
result = self.env['report'].get_pdf(obj, 'is_plastigray.is_report_invoice')
r = range(1, 2)
if obj.is_mode_envoi_facture=='courrier2':
r = range(1, 3)
for x in r:
file_name = path + '/'+str(obj.number) + '-' + str(x) + '.pdf'
fd = os.open(file_name,os.O_RDWR|os.O_CREAT)
try:
os.write(fd, result)
finally:
os.close(fd)
paths.append(file_name)
# ** Merge des PDF *****************************************************
path_merged=self._merge_pdf(paths)
pdfs = open(path_merged,'rb').read().encode('base64')
# **********************************************************************
# ** Recherche si une pièce jointe est déja associèe *******************
attachment_obj = self.env['ir.attachment']
name = 'factures-' + db + '-' + str(uid) + '.pdf'
attachments = attachment_obj.search([('name','=',name)],limit=1)
# **********************************************************************
# ** Creation ou modification de la pièce jointe ***********************
vals = {
'name': name,
'datas_fname': name,
'type': 'binary',
'datas': pdfs,
}
if attachments:
for attachment in attachments:
attachment.write(vals)
attachment_id=attachment.id
else:
attachment = attachment_obj.create(vals)
attachment_id=attachment.id
#***********************************************************************
#** Envoi du PDF mergé dans le navigateur ******************************
if attachment_id:
return {
'type' : 'ir.actions.act_url',
'url': '/web/binary/saveas?model=ir.attachment&field=datas&id='+str(attachment_id)+'&filename_field=name',
'target': 'new',
} | [
"def",
"imprimer_simple_double",
"(",
"self",
")",
":",
"cr",
",",
"uid",
",",
"context",
"=",
"self",
".",
"env",
".",
"args",
"db",
"=",
"self",
".",
"_cr",
".",
"dbname",
"path",
"=",
"\"/tmp/factures-\"",
"+",
"db",
"+",
"'-'",
"+",
"str",
"(",
... | [
185,
4
] | [
251,
13
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
filtreSignal | (s, fenetreLine, fenetreMoy = 10) | return np.array( [s[0]] +
[moy(filtreMoyen(s[i], fenetreLine), fenetreMoy) for i in range(1, 9)]) | applique le filtreMoyen pour supprimer les déviation linéaire et recentrer avec suppression des bords pour éviter les déviations
puis moyenne pour couper la fréquence 50Hz | applique le filtreMoyen pour supprimer les déviation linéaire et recentrer avec suppression des bords pour éviter les déviations
puis moyenne pour couper la fréquence 50Hz | def filtreSignal(s, fenetreLine, fenetreMoy = 10):
'''applique le filtreMoyen pour supprimer les déviation linéaire et recentrer avec suppression des bords pour éviter les déviations
puis moyenne pour couper la fréquence 50Hz'''
return np.array( [s[0]] +
[moy(filtreMoyen(s[i], fenetreLine), fenetreMoy) for i in range(1, 9)]) | [
"def",
"filtreSignal",
"(",
"s",
",",
"fenetreLine",
",",
"fenetreMoy",
"=",
"10",
")",
":",
"return",
"np",
".",
"array",
"(",
"[",
"s",
"[",
"0",
"]",
"]",
"+",
"[",
"moy",
"(",
"filtreMoyen",
"(",
"s",
"[",
"i",
"]",
",",
"fenetreLine",
")",
... | [
176,
0
] | [
180,
91
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
Admin.main_msg | (self, ctx: MyContext) | Commandes réservées aux administrateurs de ZBot | Commandes réservées aux administrateurs de ZBot | async def main_msg(self, ctx: MyContext):
"""Commandes réservées aux administrateurs de ZBot"""
if ctx.subcommand_passed is None:
text = "Liste des commandes disponibles :"
for cmd in sorted(ctx.command.commands, key=lambda x:x.name):
text+="\n- {} *({})*".format(cmd.name,'...' if cmd.help is None else cmd.help.split('\n')[0])
if isinstance(cmd, commands.core.Group):
for cmds in cmd.commands:
text+="\n - {} *({})*".format(cmds.name,cmds.help.split('\n')[0])
await ctx.send(text) | [
"async",
"def",
"main_msg",
"(",
"self",
",",
"ctx",
":",
"MyContext",
")",
":",
"if",
"ctx",
".",
"subcommand_passed",
"is",
"None",
":",
"text",
"=",
"\"Liste des commandes disponibles :\"",
"for",
"cmd",
"in",
"sorted",
"(",
"ctx",
".",
"command",
".",
... | [
86,
4
] | [
95,
32
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
Storage.create_many_nodes_by_id | (self, nodes) | Crée plusieurs noeuds en spécifiant leur id | Crée plusieurs noeuds en spécifiant leur id | def create_many_nodes_by_id(self, nodes):
"""Crée plusieurs noeuds en spécifiant leur id"""
cursor = self.connection.cursor()
cursor.executemany(
'INSERT INTO nodes (id, x, y, name, color) VALUES (?, ?, ?, ?, "grey")',
nodes,
)
self.connection.commit() | [
"def",
"create_many_nodes_by_id",
"(",
"self",
",",
"nodes",
")",
":",
"cursor",
"=",
"self",
".",
"connection",
".",
"cursor",
"(",
")",
"cursor",
".",
"executemany",
"(",
"'INSERT INTO nodes (id, x, y, name, color) VALUES (?, ?, ?, ?, \"grey\")'",
",",
"nodes",
",",... | [
64,
4
] | [
71,
32
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
Points.cross | (self, no) | return Points(self.y * no.z - self.z * no.y,
self.z * no.x - self.x * no.z,
self.x * no.y - self.y * no.x) | produit vectoriel | produit vectoriel | def cross(self, no):
""" produit vectoriel """
return Points(self.y * no.z - self.z * no.y,
self.z * no.x - self.x * no.z,
self.x * no.y - self.y * no.x) | [
"def",
"cross",
"(",
"self",
",",
"no",
")",
":",
"return",
"Points",
"(",
"self",
".",
"y",
"*",
"no",
".",
"z",
"-",
"self",
".",
"z",
"*",
"no",
".",
"y",
",",
"self",
".",
"z",
"*",
"no",
".",
"x",
"-",
"self",
".",
"x",
"*",
"no",
... | [
20,
4
] | [
24,
52
] | null | python | fr | ['fr', 'fr', 'fr'] | False | true | null |
Crud.get_element_prop | (self, element, prop, default="") | return self.application["tables"][self.ctx["table_id"]]["elements"][element].get(prop, default) | Obtenir la valeur d'une propriété d'un élément (colonne) de la table courante | Obtenir la valeur d'une propriété d'un élément (colonne) de la table courante | def get_element_prop(self, element, prop, default=""):
""" Obtenir la valeur d'une propriété d'un élément (colonne) de la table courante """
return self.application["tables"][self.ctx["table_id"]]["elements"][element].get(prop, default) | [
"def",
"get_element_prop",
"(",
"self",
",",
"element",
",",
"prop",
",",
"default",
"=",
"\"\"",
")",
":",
"return",
"self",
".",
"application",
"[",
"\"tables\"",
"]",
"[",
"self",
".",
"ctx",
"[",
"\"table_id\"",
"]",
"]",
"[",
"\"elements\"",
"]",
... | [
522,
4
] | [
524,
103
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
loadSpotUS | (df_global: pd.DataFrame, date='Dtime', delta=0) | Ajoute le prix spot des USA à la date 'date'
décalées de 'delta'.
Paramètres
----------
df_global : pandas.Dataframe
Le dataframe auquel rajouter la colonne des prix
date : str
Date de départ (Dtime) ou d'arrivée (Atime) du navire
delta : int
décalage de la date 'date'. Si delta est positif, la date sera plus grande,
sera plus avancée dans le temps
| Ajoute le prix spot des USA à la date 'date'
décalées de 'delta'. | def loadSpotUS(df_global: pd.DataFrame, date='Dtime', delta=0):
""" Ajoute le prix spot des USA à la date 'date'
décalées de 'delta'.
Paramètres
----------
df_global : pandas.Dataframe
Le dataframe auquel rajouter la colonne des prix
date : str
Date de départ (Dtime) ou d'arrivée (Atime) du navire
delta : int
décalage de la date 'date'. Si delta est positif, la date sera plus grande,
sera plus avancée dans le temps
"""
if date not in ['Dtime', 'Atime']:
date = 'Dtime'
df_us_spot = pd.read_csv('../data/SpotUS.csv', index_col='Date')
df_global[f'US_Spot_{delta}'] = df_global[date].apply(
lambda x: df_us_spot.loc[findNearestDate(x, df_us_spot, delta), 'Prix US']) | [
"def",
"loadSpotUS",
"(",
"df_global",
":",
"pd",
".",
"DataFrame",
",",
"date",
"=",
"'Dtime'",
",",
"delta",
"=",
"0",
")",
":",
"if",
"date",
"not",
"in",
"[",
"'Dtime'",
",",
"'Atime'",
"]",
":",
"date",
"=",
"'Dtime'",
"df_us_spot",
"=",
"pd",
... | [
138,
0
] | [
156,
83
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
StreamListener.actualizeData | (self) | récupère les nouvelles données. | récupère les nouvelles données. | def actualizeData(self):
'''récupère les nouvelles données.'''
if(self._inlet == None):
raise streamError.UnConnctedStreamError(" récupérer des donneés ")
while True and self._continue:
sample, timestamp = self._inlet.pull_sample(0.0) #8 éléctrodes + timestamp
if(sample == None):
break
sample.insert(0, timestamp)
self._deque.append(sample) | [
"def",
"actualizeData",
"(",
"self",
")",
":",
"if",
"(",
"self",
".",
"_inlet",
"==",
"None",
")",
":",
"raise",
"streamError",
".",
"UnConnctedStreamError",
"(",
"\" récupérer des donneés \") ",
" ",
"while",
"True",
"and",
"self",
".",
"_continue",
":",
... | [
44,
4
] | [
53,
38
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
import_data_from_matrix | (storage, names, text, initial_coords) | Importer une matrice dans la base de données | Importer une matrice dans la base de données | def import_data_from_matrix(storage, names, text, initial_coords):
"""Importer une matrice dans la base de données"""
matrix = eval_matrix(text)
if len(matrix) != len(matrix[0]):
raise RuntimeError("Invalid matrix lenght")
if len(matrix) != len(names):
raise RuntimeError("Too many names provided")
# On crée d'abord tous les noeuds et on les insère dans la base de données
storage.create_many_nodes_by_name(names, initial_coords)
relations = []
# On transforme la matrice en une liste de relations
for i in range(len(matrix[0])):
for j in range(len(matrix)):
if i == j:
continue
related_node = matrix[j][i]
if related_node == 1:
opposite_direction = (names[j], names[i], True)
if opposite_direction in relations:
relations.remove(opposite_direction)
relations.append((names[i], names[j], False))
else:
relations.append((names[i], names[j], True))
replace_names_by_id = lambda relation: (
node_name_to_id(storage, relation[0]),
node_name_to_id(storage, relation[1]),
relation[2],
1,
)
# On remplace les noms des noeuds dans les relations par leurs ids respectifs
result_relation = list(map(replace_names_by_id, relations))
# On insère les relations dans la base de données
storage.create_many_relations(result_relation) | [
"def",
"import_data_from_matrix",
"(",
"storage",
",",
"names",
",",
"text",
",",
"initial_coords",
")",
":",
"matrix",
"=",
"eval_matrix",
"(",
"text",
")",
"if",
"len",
"(",
"matrix",
")",
"!=",
"len",
"(",
"matrix",
"[",
"0",
"]",
")",
":",
"raise",... | [
24,
0
] | [
62,
50
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
Screen.mtopx | (self, dinm) | return int(dinm*self.pxpm) | Convertit les distances en m vers des pixels | Convertit les distances en m vers des pixels | def mtopx(self, dinm):
''' Convertit les distances en m vers des pixels'''
return int(dinm*self.pxpm) | [
"def",
"mtopx",
"(",
"self",
",",
"dinm",
")",
":",
"return",
"int",
"(",
"dinm",
"*",
"self",
".",
"pxpm",
")"
] | [
142,
4
] | [
144,
34
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
loadAll | (param=basic_param) | Charge toutes les colonnes selon les paramètres
Paramètres
----------
param : set
dictionnaire des paramètres
Retours
----------
df_global : pandas.dataframe
si Return == True renvoie le dataframe complet
| Charge toutes les colonnes selon les paramètres | def loadAll(param=basic_param):
""" Charge toutes les colonnes selon les paramètres
Paramètres
----------
param : set
dictionnaire des paramètres
Retours
----------
df_global : pandas.dataframe
si Return == True renvoie le dataframe complet
"""
t1 = time()
df_global = loadTrips()
print("Voyages")
if param['SpotEur']:
date, delta = param['Date_SE'], param['Delta_SE']
for delt in delta:
loadSpotEur(df_global, date, delt)
print("Spot Europe")
if param['SpotUS']:
date, delta = param['Date_SU'], param['Delta_SU']
for delt in delta:
loadSpotUS(df_global, date, delt)
print("Spot US")
if param['FuturesAsia']:
date, delta = param['Date_FA'], param['Delta_FA']
for delt in delta:
df_global = loadFuturesAsia(df_global, date, delt)
print("Futures Asie")
if param['FuturesEur']:
date, delta = param['Date_FE'], param['Delta_FE']
for delt in delta:
df_global = loadFuturesEur(df_global, date, delt)
print("futures Europe")
t2 = time()
print(f"Fini en {round(t2-t1,1)} secondes")
if param['Save']:
df_global.to_csv('../data/loadAll_extended_A.csv')
if param['Return']:
return df_global | [
"def",
"loadAll",
"(",
"param",
"=",
"basic_param",
")",
":",
"t1",
"=",
"time",
"(",
")",
"df_global",
"=",
"loadTrips",
"(",
")",
"print",
"(",
"\"Voyages\"",
")",
"if",
"param",
"[",
"'SpotEur'",
"]",
":",
"date",
",",
"delta",
"=",
"param",
"[",
... | [
291,
0
] | [
338,
24
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
findBestCoeff2 | (X, y, model) | return best_alpha | Trouve le meilleur coefficient pour le lasso
Paramètres
----------
X :
y :
model : string
'l1' ou 'l2'
choix du modèle (Lasso ou Ridge)
Retours
----------
alpha : float
meilleur coefficient dans la liste proposée
| Trouve le meilleur coefficient pour le lasso | def findBestCoeff2(X, y, model):
""" Trouve le meilleur coefficient pour le lasso
Paramètres
----------
X :
y :
model : string
'l1' ou 'l2'
choix du modèle (Lasso ou Ridge)
Retours
----------
alpha : float
meilleur coefficient dans la liste proposée
"""
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=13)
# On applique un prétraitement aux données afin qu'elles soient centrées réduites
standard_scaler = StandardScaler()
standard_scaler.fit(X_train)
X_train = standard_scaler.transform(X_train)
X_test = standard_scaler.transform(X_test)
# define model and alpha values to evaluate
if model == 'l1' :
predictor = Lasso(random_state=13, max_iter=10000)
elif model == 'l2' :
predictor = Ridge(random_state=13, max_iter=10000)
else :
print("Model unvalid: choose between 'l1' (for Lasso) and 'l2' (for Ridge)")
return None
alphas = np.logspace(-4, 0, 30)
# define gridsearch
tuned_parameters = [{'alpha': alphas}]
nb_folds = 5
grid = GridSearchCV(predictor, tuned_parameters, cv=nb_folds, refit=False, verbose=0)
# run gridsearch
grid.fit(X_train, y_train)
# get R2 (default score with Lasso models)
scores = grid.cv_results_['mean_test_score']
scores_std = grid.cv_results_['std_test_score']
# compute standard errors
std_error = scores_std / np.sqrt(nb_folds)
# get optimal alpha
i_max = np.argmax(scores)
best_alpha = alphas[i_max]
# best_score = scores[i_max]
return best_alpha | [
"def",
"findBestCoeff2",
"(",
"X",
",",
"y",
",",
"model",
")",
":",
"X_train",
",",
"X_test",
",",
"y_train",
",",
"y_test",
"=",
"train_test_split",
"(",
"X",
",",
"y",
",",
"test_size",
"=",
"0.2",
",",
"random_state",
"=",
"13",
")",
"# On applique... | [
87,
0
] | [
143,
21
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
stack.getSize | (self) | return self.size | Retourne le nombre d'éléments de la pile | Retourne le nombre d'éléments de la pile | def getSize(self):
"""Retourne le nombre d'éléments de la pile"""
return self.size | [
"def",
"getSize",
"(",
"self",
")",
":",
"return",
"self",
".",
"size"
] | [
7,
4
] | [
9,
24
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
resultatRecherche | () | Controleur de la route '/resultatFRecherche' | Controleur de la route '/resultatFRecherche' | def resultatRecherche():
"Controleur de la route '/resultatFRecherche' "
if request.method == 'POST':
result = request.form
conn = sqlite3.connect('monavenir.db')
conn.row_factory = sqlite3.Row #pour récupérer les lignes sous forme de dictionnaire
cur = conn.cursor()
if result['type'] == 'indifferent':
if result['commune'] != 'indifferent':
cur.execute('SELECT nom, idSuperieur, type, commune FROM superieur WHERE commune = ? ORDER BY type;', (result['commune'],))
else:
cur.execute('SELECT idSuperieur,nom, type, commune FROM superieur ORDER BY commune, type;')
elif result['commune'] == 'indifferent':
cur.execute('SELECT idSuperieur,nom, type, commune FROM superieur WHERE type = ? ORDER BY commune;', (result['type'],))
else:
cur.execute('SELECT idSuperieur,nom, type, commune FROM superieur WHERE commune = ? and type = ?;', (result['commune'] , result['type']))
liste_sup = cur.fetchall()
conn.close()
return render_template("resultatRecherche.html", liste_sup = liste_sup, result = result) | [
"def",
"resultatRecherche",
"(",
")",
":",
"if",
"request",
".",
"method",
"==",
"'POST'",
":",
"result",
"=",
"request",
".",
"form",
"conn",
"=",
"sqlite3",
".",
"connect",
"(",
"'monavenir.db'",
")",
"conn",
".",
"row_factory",
"=",
"sqlite3",
".",
"R... | [
85,
0
] | [
103,
97
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
Point.__str__ | (self) | return '({0},{1})'.format(self.x, self.y) | permet d'afficher un point avec l'instruction print | permet d'afficher un point avec l'instruction print | def __str__(self):
"""permet d'afficher un point avec l'instruction print"""
return '({0},{1})'.format(self.x, self.y) | [
"def",
"__str__",
"(",
"self",
")",
":",
"return",
"'({0},{1})'",
".",
"format",
"(",
"self",
".",
"x",
",",
"self",
".",
"y",
")"
] | [
24,
4
] | [
26,
49
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
ajoute_virgule | (valeur1) | Ajoute une virgule, s'il n'y en a pas déjà. | Ajoute une virgule, s'il n'y en a pas déjà. | def ajoute_virgule(valeur1):
"""Ajoute une virgule, s'il n'y en a pas déjà."""
if valeur1.find(".") == -1:
return valeur1 + "."
else:
return valeur1 | [
"def",
"ajoute_virgule",
"(",
"valeur1",
")",
":",
"if",
"valeur1",
".",
"find",
"(",
"\".\"",
")",
"==",
"-",
"1",
":",
"return",
"valeur1",
"+",
"\".\"",
"else",
":",
"return",
"valeur1"
] | [
82,
0
] | [
88,
22
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
get_id_passager | (id_groupe, idx_passager, date, AVION) | return id_passager | Convertir la représentation (id_groupe, idx_passager) en
la clé unique (id_passager).
| Convertir la représentation (id_groupe, idx_passager) en
la clé unique (id_passager).
| def get_id_passager(id_groupe, idx_passager, date, AVION):
""" Convertir la représentation (id_groupe, idx_passager) en
la clé unique (id_passager).
"""
df = pd.read_csv(os.path.join("output", f"solution_{date}_{AVION}.csv"))
id_passager = df[df['ID Groupe'] == id_groupe].iloc[idx_passager]["ID Passager"]
return id_passager | [
"def",
"get_id_passager",
"(",
"id_groupe",
",",
"idx_passager",
",",
"date",
",",
"AVION",
")",
":",
"df",
"=",
"pd",
".",
"read_csv",
"(",
"os",
".",
"path",
".",
"join",
"(",
"\"output\"",
",",
"f\"solution_{date}_{AVION}.csv\"",
")",
")",
"id_passager",
... | [
161,
0
] | [
169,
22
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
DatasetShow.delete | (self, request, dataset_name) | return HttpResponse(status=204) | Supprimer le jeu de données. | Supprimer le jeu de données. | def delete(self, request, dataset_name):
"""Supprimer le jeu de données."""
instance = None
for dataset in handler_get_request(request):
if dataset.slug == dataset_name:
instance = dataset
break
if not instance:
raise Http404()
instance.delete(current_user=request.user)
send_dataset_delete_mail(request.user, instance)
return HttpResponse(status=204) | [
"def",
"delete",
"(",
"self",
",",
"request",
",",
"dataset_name",
")",
":",
"instance",
"=",
"None",
"for",
"dataset",
"in",
"handler_get_request",
"(",
"request",
")",
":",
"if",
"dataset",
".",
"slug",
"==",
"dataset_name",
":",
"instance",
"=",
"datase... | [
326,
4
] | [
337,
39
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
reponses | () | return render_template("reponses.html") | Controleur de la route '/reponses' | Controleur de la route '/reponses' | def reponses():
"Controleur de la route '/reponses' "
def requeteListeReponsesCandidatures(conn, cur, idEleve):
#renommage nécessaire pour superieur.nom pour affichage dans reponses.html
requete = """
SELECT idSuperieur, superieur.nom AS nomEtab, type, commune, idEleve, statut
FROM (candidature JOIN superieur USING(idSuperieur)) JOIN eleve USING(idEleve)
WHERE idEleve = ? ORDER BY statut;
"""
cur.execute(requete, (idEleve,))
return cur.fetchall()
#connexion à la BDD
conn = sqlite3.connect('monavenir.db')
conn.row_factory = sqlite3.Row #pour récupérer les lignes sous forme de dictionnaire
cur = conn.cursor()
idEleve = session['user']['idEleve'] #on récupère l'idEleve dans le cookie de session
#requete
liste_reponses = requeteListeReponsesCandidatures(conn, cur, idEleve)
#mise à jour du dictionnaire du cookie de session
session['liste_reponses'] = [dict(reponse) for reponse in liste_reponses]
#fermeture de la base de données
cur.close()
conn.close()
#renvoi du template
return render_template("reponses.html") | [
"def",
"reponses",
"(",
")",
":",
"def",
"requeteListeReponsesCandidatures",
"(",
"conn",
",",
"cur",
",",
"idEleve",
")",
":",
"#renommage nécessaire pour superieur.nom pour affichage dans reponses.html\r",
"requete",
"=",
"\"\"\"\r\n SELECT idSuperieur, superieu... | [
307,
0
] | [
333,
43
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
FenetrePrincipale.quitter | (self) | Gère le menu pour quitter le jeu | Gère le menu pour quitter le jeu | def quitter(self):
"""Gère le menu pour quitter le jeu"""
if box.askyesno('Attention', 'Êtes vous sûr de vouloir fermer la fenêtre ?'):
self.parent.destroy() | [
"def",
"quitter",
"(",
"self",
")",
":",
"if",
"box",
".",
"askyesno",
"(",
"'Attention'",
",",
"'Êtes vous sûr de vouloir fermer la fenêtre ?'):",
"",
"",
"self",
".",
"parent",
".",
"destroy",
"(",
")"
] | [
84,
1
] | [
87,
24
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
_RoomReservation.get_room_infos | (self) | return tpl | Affiche les infos sur la salle pour une réservation | Affiche les infos sur la salle pour une réservation | def get_room_infos(self):
"""Affiche les infos sur la salle pour une réservation"""
tpl = mark_safe(u'<div style="margin-top: 5px;">{}, {} <span class="label label-info">{}</span></div>'.format(escape(self.room.title), _(u'gérée par'), escape(self.room.unit.name)))
return tpl | [
"def",
"get_room_infos",
"(",
"self",
")",
":",
"tpl",
"=",
"mark_safe",
"(",
"u'<div style=\"margin-top: 5px;\">{}, {} <span class=\"label label-info\">{}</span></div>'",
".",
"format",
"(",
"escape",
"(",
"self",
".",
"room",
".",
"title",
")",
",",
"_",
"(",
"u'g... | [
226,
4
] | [
231,
18
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
InterfaceJeu.initBoard | (self) | Initialisation du backend & Création de toutes les pièces jouables | Initialisation du backend & Création de toutes les pièces jouables | def initBoard(self):
"""Initialisation du backend & Création de toutes les pièces jouables"""
# Gestion de la taille du plateau
if self.parent.taille == "petit":
self.largeur = 6
elif self.parent.taille == "moyen":
self.largeur = 10
elif self.parent.taille == "grand":
self.largeur = 14
# Init du Board et Canvas
self.board = Board(self.largeur, self.largeur)
self.canvas.config(
width=(PIX_L_INTERFACE+self.largeur*TAILLE_CARREAU),
height=(PIX_H_INTERFACE+self.largeur*TAILLE_CARREAU))
if self.parent.DEBUG:
print("Largeur du plateau: ", self.largeur)
# Ajout des différentes pièces dans la librairie
self.board.addPiece(Piece([
[1, 1],
[1, 1]
])) # Carre
self.board.addPiece(Piece([
[1, 0],
[1, 1],
[0, 1]
])) # ZigZag vertical
self.board.addPiece(Piece([
[1, 1, 0],
[0, 1, 1]
])) # ZigZag horizontal
self.board.addPiece(Piece([
[1, 0],
[1, 0],
[1, 1]
])) # L vertical
self.board.addPiece(Piece([
[1, 1],
[0, 1],
[0, 1]
])) # L vertical
self.board.addPiece(Piece([
[1, 1, 1],
[0, 0, 1]
])) # L horizontal
self.board.addPiece(Piece([
[1, 0, 0],
[1, 1, 1]
])) # L horizontal
self.board.addPiece(Piece([
[1, 0],
[1, 1],
[1, 0]
])) # Triangle vertical
self.board.addPiece(Piece([
[1, 1, 1],
[0, 1, 0]
])) # Triangle horizontal
self.board.addPiece(Piece([
[1, 1, 1]
])) # Ligne
self.board.addPiece(Piece([
[1],
[1],
[1]
])) # Colonne | [
"def",
"initBoard",
"(",
"self",
")",
":",
"# Gestion de la taille du plateau",
"if",
"self",
".",
"parent",
".",
"taille",
"==",
"\"petit\"",
":",
"self",
".",
"largeur",
"=",
"6",
"elif",
"self",
".",
"parent",
".",
"taille",
"==",
"\"moyen\"",
":",
"sel... | [
219,
1
] | [
291,
15
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
figure_1 | () | dessiner une cible | dessiner une cible | def figure_1():
"""dessiner une cible"""
# Effacer d'abord tout dessin préexistant :
# MonCanvas.delete(tk.ALL)
# tracer les deux lignes (vert. et horiz.) :
MonCanvas.create_line(MAXW / 2, 0, MAXW / 2, MAXH, fill='blue')
MonCanvas.create_line(0, MAXH / 2, MAXW, MAXH / 2, fill='blue')
# tracer plusieurs cercles concentriques :
rayon = 15
while rayon < MAXW / 2:
if rayon == MAXP:
cercle(MAXW / 2, MAXH / 2, rayon, color='red')
else:
cercle(MAXW / 2, MAXH / 2, rayon)
rayon += 15 | [
"def",
"figure_1",
"(",
")",
":",
"# Effacer d'abord tout dessin préexistant :",
"# MonCanvas.delete(tk.ALL)",
"# tracer les deux lignes (vert. et horiz.) :",
"MonCanvas",
".",
"create_line",
"(",
"MAXW",
"/",
"2",
",",
"0",
",",
"MAXW",
"/",
"2",
",",
"MAXH",
",",
"f... | [
56,
0
] | [
70,
19
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
cases_fou | (col,lig) | return diag_1 + diag_2 | Retourne la liste des indices (col,lig) des cases où peut se
déplacer un fou positionné sur la case (col, lig)
Ex: fou en (2,3)
- - - - - - - - - -
| x |
| x x |
| x x |
| F |
| x x |
| x x |
| x |
| x |
- - - - - - - - - -
| Retourne la liste des indices (col,lig) des cases où peut se
déplacer un fou positionné sur la case (col, lig) | def cases_fou(col,lig):
"""Retourne la liste des indices (col,lig) des cases où peut se
déplacer un fou positionné sur la case (col, lig)
Ex: fou en (2,3)
- - - - - - - - - -
| x |
| x x |
| x x |
| F |
| x x |
| x x |
| x |
| x |
- - - - - - - - - -
"""
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 diag_1 + diag_2 | [
"def",
"cases_fou",
"(",
"col",
",",
"lig",
")",
":",
"diag_1",
"=",
"[",
"(",
"x",
",",
"y",
")",
"for",
"x",
"in",
"range",
"(",
"0",
",",
"8",
")",
"for",
"y",
"in",
"range",
"(",
"0",
",",
"8",
")",
"if",
"x",
"-",
"col",
"==",
"y",
... | [
8,
0
] | [
27,
26
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
Crud.get_table_elements | (self) | return self.application["tables"][self.ctx["table_id"]]["elements"] | Obtenir la liste des rubriques de la table courante | Obtenir la liste des rubriques de la table courante | def get_table_elements(self):
""" Obtenir la liste des rubriques de la table courante """
return self.application["tables"][self.ctx["table_id"]]["elements"] | [
"def",
"get_table_elements",
"(",
"self",
")",
":",
"return",
"self",
".",
"application",
"[",
"\"tables\"",
"]",
"[",
"self",
".",
"ctx",
"[",
"\"table_id\"",
"]",
"]",
"[",
"\"elements\"",
"]"
] | [
478,
4
] | [
480,
75
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
World.add_Mass | (self, m) | Ajoute la masse et les liens qui lui sont associés au monde | Ajoute la masse et les liens qui lui sont associés au monde | def add_Mass(self, m):
'''Ajoute la masse et les liens qui lui sont associés au monde'''
self.mass.append(m)
if self.gravity:
lien = LinkCsteF(m, self.earth, [0, -m.m*self.g])
self.add_Link(lien)
for link, num in m.linklist:
if link not in self.link:
self.add_Link(link) | [
"def",
"add_Mass",
"(",
"self",
",",
"m",
")",
":",
"self",
".",
"mass",
".",
"append",
"(",
"m",
")",
"if",
"self",
".",
"gravity",
":",
"lien",
"=",
"LinkCsteF",
"(",
"m",
",",
"self",
".",
"earth",
",",
"[",
"0",
",",
"-",
"m",
".",
"m",
... | [
135,
4
] | [
143,
35
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
Crud.remove_selection | (self, row_id) | supprimer un élément de la sélection | supprimer un élément de la sélection | def remove_selection(self, row_id):
""" supprimer un élément de la sélection """
del self.ctx["selected"][row_id] | [
"def",
"remove_selection",
"(",
"self",
",",
"row_id",
")",
":",
"del",
"self",
".",
"ctx",
"[",
"\"selected\"",
"]",
"[",
"row_id",
"]"
] | [
416,
4
] | [
418,
40
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
Admin.idea_add | (self, ctx: MyContext, *, text) | Ajoute une idée à la liste | Ajoute une idée à la liste | async def idea_add(self, ctx: MyContext, *, text):
"""Ajoute une idée à la liste"""
try:
channel = ctx.bot.get_channel(548138866591137802) if self.bot.beta else ctx.bot.get_channel(488769306524385301)
if channel is None:
return await ctx.send("Salon introuvable")
text = text.split('\n')
fr,en = text[0].replace('\\n','\n'), text[1].replace('\\n','\n')
emb = self.bot.get_cog('Embeds').Embed(fields=[{'name':'Français','value':fr},{'name':'English','value':en}],color=16106019).update_timestamp()
msg = await channel.send(embed=emb.discord_embed())
await self.bot.get_cog('Fun').add_vote(msg)
await ctx.bot.get_cog('Utilities').add_check_reaction(ctx.message)
except Exception as e:
await self.bot.get_cog('Errors').on_command_error(ctx,e) | [
"async",
"def",
"idea_add",
"(",
"self",
",",
"ctx",
":",
"MyContext",
",",
"*",
",",
"text",
")",
":",
"try",
":",
"channel",
"=",
"ctx",
".",
"bot",
".",
"get_channel",
"(",
"548138866591137802",
")",
"if",
"self",
".",
"bot",
".",
"beta",
"else",
... | [
901,
4
] | [
914,
68
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
is_edi_cde_cli.getSaleOrder | (self, ref_article_client) | Recherche de la commande ouverte client à partir de la référence article | Recherche de la commande ouverte client à partir de la référence article | def getSaleOrder(self, ref_article_client):
"""Recherche de la commande ouverte client à partir de la référence article"""
for obj in self:
order = self.env['sale.order'].search([
('partner_id.is_code' , '=', obj.partner_id.is_code),
('is_ref_client', '=', ref_article_client),
('is_type_commande' , '=', 'ouverte'),
])
SaleOrder = False
if len(order):
SaleOrder = order[0]
return SaleOrder | [
"def",
"getSaleOrder",
"(",
"self",
",",
"ref_article_client",
")",
":",
"for",
"obj",
"in",
"self",
":",
"order",
"=",
"self",
".",
"env",
"[",
"'sale.order'",
"]",
".",
"search",
"(",
"[",
"(",
"'partner_id.is_code'",
",",
"'='",
",",
"obj",
".",
"pa... | [
423,
4
] | [
434,
28
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
Board.fillMatrix | (self, fillValue) | Rempli le tableau de jeu avec la valeur fillValue | Rempli le tableau de jeu avec la valeur fillValue | def fillMatrix(self, fillValue):
"""Rempli le tableau de jeu avec la valeur fillValue"""
for y in range(len(self.matrix)):
for x in range(len(self.matrix[y])):
self.matrix[y][x] = fillValue | [
"def",
"fillMatrix",
"(",
"self",
",",
"fillValue",
")",
":",
"for",
"y",
"in",
"range",
"(",
"len",
"(",
"self",
".",
"matrix",
")",
")",
":",
"for",
"x",
"in",
"range",
"(",
"len",
"(",
"self",
".",
"matrix",
"[",
"y",
"]",
")",
")",
":",
"... | [
41,
1
] | [
45,
33
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
modinv | (a, m) | return x % m | modular inverse avec Bachet-Bézout | modular inverse avec Bachet-Bézout | def modinv(a, m):
""" modular inverse avec Bachet-Bézout """
# https://fr.wikipedia.org/wiki/Théorème_de_Bachet-Bézout
g, x, _ = egcd(a, m)
assert g == 1
return x % m | [
"def",
"modinv",
"(",
"a",
",",
"m",
")",
":",
"# https://fr.wikipedia.org/wiki/Théorème_de_Bachet-Bézout",
"g",
",",
"x",
",",
"_",
"=",
"egcd",
"(",
"a",
",",
"m",
")",
"assert",
"g",
"==",
"1",
"return",
"x",
"%",
"m"
] | [
65,
0
] | [
70,
16
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
rename_df_col | (df, replacer='_') | return df_new | Description : uniformise le nom des colonnes d'un dataframe en retirant les caractères spéciaux/surabondants
inputs :
- df as dataFrame : tableau de données dont les colonnes sont à renommer de manière plus simple
outputs:
- dataFrame : tableau de données dont les noms de colonnes ont été modifiés
| Description : uniformise le nom des colonnes d'un dataframe en retirant les caractères spéciaux/surabondants
inputs :
- df as dataFrame : tableau de données dont les colonnes sont à renommer de manière plus simple
outputs:
- dataFrame : tableau de données dont les noms de colonnes ont été modifiés
| def rename_df_col(df, replacer='_'):
"""Description : uniformise le nom des colonnes d'un dataframe en retirant les caractères spéciaux/surabondants
inputs :
- df as dataFrame : tableau de données dont les colonnes sont à renommer de manière plus simple
outputs:
- dataFrame : tableau de données dont les noms de colonnes ont été modifiés
"""
rename_dict = {ancien: transfo_col(ancien, replacer=replacer) for ancien in df.columns}
df_new = df.rename(columns=rename_dict)
return df_new | [
"def",
"rename_df_col",
"(",
"df",
",",
"replacer",
"=",
"'_'",
")",
":",
"rename_dict",
"=",
"{",
"ancien",
":",
"transfo_col",
"(",
"ancien",
",",
"replacer",
"=",
"replacer",
")",
"for",
"ancien",
"in",
"df",
".",
"columns",
"}",
"df_new",
"=",
"df"... | [
189,
0
] | [
198,
17
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
Crud.set_table_prop | (self, prop, value) | Ajouter/mettre à jour une propriété de la table courante | Ajouter/mettre à jour une propriété de la table courante | def set_table_prop(self, prop, value):
""" Ajouter/mettre à jour une propriété de la table courante """
self.application["tables"][self.ctx["table_id"]][prop] = value | [
"def",
"set_table_prop",
"(",
"self",
",",
"prop",
",",
"value",
")",
":",
"self",
".",
"application",
"[",
"\"tables\"",
"]",
"[",
"self",
".",
"ctx",
"[",
"\"table_id\"",
"]",
"]",
"[",
"prop",
"]",
"=",
"value"
] | [
475,
4
] | [
477,
70
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
RectangleImage.__init__ | (self, a, b, c, d, nom_image, pygame, invertx=False) | initialisation, si d == None, d est calculé comme étant
le symétrique de b par rapport au milieu du segment [ac],
la texture est une image,
si invertx == True, inverse l'image selon l'axe des x | initialisation, si d == None, d est calculé comme étant
le symétrique de b par rapport au milieu du segment [ac],
la texture est une image,
si invertx == True, inverse l'image selon l'axe des x | def __init__(self, a, b, c, d, nom_image, pygame, invertx=False):
"""initialisation, si d == None, d est calculé comme étant
le symétrique de b par rapport au milieu du segment [ac],
la texture est une image,
si invertx == True, inverse l'image selon l'axe des x"""
Rectangle.__init__(self, a, b, c, d, Couleur(0, 0, 0))
self.image = pygame.image.load(nom_image)
self.nom_image = nom_image
self.invertx = invertx | [
"def",
"__init__",
"(",
"self",
",",
"a",
",",
"b",
",",
"c",
",",
"d",
",",
"nom_image",
",",
"pygame",
",",
"invertx",
"=",
"False",
")",
":",
"Rectangle",
".",
"__init__",
"(",
"self",
",",
"a",
",",
"b",
",",
"c",
",",
"d",
",",
"Couleur",
... | [
14,
4
] | [
22,
30
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
Segment.last | (self) | return self.b | Retourne la seconde extrémité. | Retourne la seconde extrémité. | def last(self):
"""Retourne la seconde extrémité."""
return self.b | [
"def",
"last",
"(",
"self",
")",
":",
"return",
"self",
".",
"b"
] | [
141,
4
] | [
143,
21
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
trapeze | (f, a, b, n_eval = False) | return (b-a)*(f(a)+f(b))/2. | Méthode des trapèzes | Méthode des trapèzes | def trapeze(f, a, b, n_eval = False):
"Méthode des trapèzes"
if n_eval:
return 2
return (b-a)*(f(a)+f(b))/2. | [
"def",
"trapeze",
"(",
"f",
",",
"a",
",",
"b",
",",
"n_eval",
"=",
"False",
")",
":",
"if",
"n_eval",
":",
"return",
"2",
"return",
"(",
"b",
"-",
"a",
")",
"*",
"(",
"f",
"(",
"a",
")",
"+",
"f",
"(",
"b",
")",
")",
"/",
"2."
] | [
43,
0
] | [
47,
28
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
Admin.adm_invites | (self, ctx: MyContext, *, server: typing.Optional[discord.Guild] = None) | Cherche une invitation pour un serveur, ou tous | Cherche une invitation pour un serveur, ou tous | async def adm_invites(self, ctx: MyContext, *, server: typing.Optional[discord.Guild] = None):
"""Cherche une invitation pour un serveur, ou tous"""
if server is not None:
await ctx.author.send(await self.search_invite(server))
else:
liste = list()
for guild in self.bot.guilds:
liste.append(await self.search_invite(guild))
if len("\n".join(liste)) > 1900:
await ctx.author.send("\n".join(liste))
liste = []
if len(liste) > 0:
await ctx.author.send("\n".join(liste))
await self.bot.get_cog('Utilities').suppr(ctx.message) | [
"async",
"def",
"adm_invites",
"(",
"self",
",",
"ctx",
":",
"MyContext",
",",
"*",
",",
"server",
":",
"typing",
".",
"Optional",
"[",
"discord",
".",
"Guild",
"]",
"=",
"None",
")",
":",
"if",
"server",
"is",
"not",
"None",
":",
"await",
"ctx",
"... | [
362,
4
] | [
375,
62
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
ListenShortcut.verify_path | (self) | Vérifie si les fichier et répertoire existent.
Sinon il les créer. | Vérifie si les fichier et répertoire existent.
Sinon il les créer. | def verify_path(self) :
""" Vérifie si les fichier et répertoire existent.
Sinon il les créer."""
if not os.path.exists(os.path.dirname(self.time_file)) :
os.makedirs(os.path.dirname(self.time_file)) | [
"def",
"verify_path",
"(",
"self",
")",
":",
"if",
"not",
"os",
".",
"path",
".",
"exists",
"(",
"os",
".",
"path",
".",
"dirname",
"(",
"self",
".",
"time_file",
")",
")",
":",
"os",
".",
"makedirs",
"(",
"os",
".",
"path",
".",
"dirname",
"(",
... | [
57,
4
] | [
61,
56
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
pointeur | (event) | modifie chaine avec la position du curseur | modifie chaine avec la position du curseur | def pointeur(event):
"""modifie chaine avec la position du curseur"""
texte = 'Detected clic in X=' + str(event.x) + ', Y=' + str(event.y)
chaine.configure(text=texte) | [
"def",
"pointeur",
"(",
"event",
")",
":",
"texte",
"=",
"'Detected clic in X='",
"+",
"str",
"(",
"event",
".",
"x",
")",
"+",
"', Y='",
"+",
"str",
"(",
"event",
".",
"y",
")",
"chaine",
".",
"configure",
"(",
"text",
"=",
"texte",
")"
] | [
80,
0
] | [
83,
32
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
polygon | (*args) | return id | affichage d'un polygone construit a partir d'une liste de coordonnees
retour de l'identificateur unique de l'objet cree
| affichage d'un polygone construit a partir d'une liste de coordonnees
retour de l'identificateur unique de l'objet cree
| def polygon(*args):
"""affichage d'un polygone construit a partir d'une liste de coordonnees
retour de l'identificateur unique de l'objet cree
"""
# 1 parametre : une liste ou un tuple de coordonnees
if len(args) == 1:
if isinstance(args[0], list) or isinstance(args[0], tuple):
# changement de repere
nb = len(args[0])
ll = [0 for i in range(nb)]
for i in range(nb):
if i % 2 != 0:
ll[i] = __ha - args[0][i]
else:
ll[i] = args[0][i]
id = __canv.create_polygon(ll, fill=__ccol)
else:
__erreur("[polygon] le parametre n'est pas une liste ou un tuple")
# N parametres : une suite de coordonnees
elif len(args) > 1:
# changement de repere
nb = len(args)
ll = [0 for i in range(nb)]
for i in range(nb):
if i % 2 != 0:
ll[i] = __ha - args[i]
else:
ll[i] = args[i]
id = __canv.create_polygon(ll, fill=__ccol)
else:
__erreur("[polygon] parametre incorrect")
return id | [
"def",
"polygon",
"(",
"*",
"args",
")",
":",
"# 1 parametre : une liste ou un tuple de coordonnees",
"if",
"len",
"(",
"args",
")",
"==",
"1",
":",
"if",
"isinstance",
"(",
"args",
"[",
"0",
"]",
",",
"list",
")",
"or",
"isinstance",
"(",
"args",
"[",
"... | [
272,
0
] | [
303,
13
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.