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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
nextIte | (matrix, fourmis) | return matrix | Calcule la matrice suivante d'apres les règles du jeu
Args:
matrix (array): la représentation du board, array en 2 dimensions
fourmis (Fourmis): la fourmis (contenant sa position et sa direction)
| Calcule la matrice suivante d'apres les règles du jeu | def nextIte(matrix, fourmis):
"""Calcule la matrice suivante d'apres les règles du jeu
Args:
matrix (array): la représentation du board, array en 2 dimensions
fourmis (Fourmis): la fourmis (contenant sa position et sa direction)
"""
# case noire : tourne à gauche
# case blanche : to... | [
"def",
"nextIte",
"(",
"matrix",
",",
"fourmis",
")",
":",
"# case noire : tourne à gauche",
"# case blanche : tourne à droite",
"# la case précédente change de couleur",
"originalPosition",
"=",
"fourmis",
".",
"position",
"couleur",
"=",
"couleurCell",
"(",
"matrix",
",",... | [
110,
0
] | [
136,
17
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
sphere_reflet.rayon_reflechi | (self, rayon, p) | return r | retourne le rayon r�fl�chi au point p de la surface,
si aucune, retourne None | retourne le rayon r�fl�chi au point p de la surface,
si aucune, retourne None | def rayon_reflechi (self, rayon, p) :
"""retourne le rayon r�fl�chi au point p de la surface,
si aucune, retourne None"""
if p == rayon.origine : return None
n = self.normale (p, rayon)
n = n.renorme ()
y = n.scalaire (rayon.direction)
d = rayon.direction - n * y ... | [
"def",
"rayon_reflechi",
"(",
"self",
",",
"rayon",
",",
"p",
")",
":",
"if",
"p",
"==",
"rayon",
".",
"origine",
":",
"return",
"None",
"n",
"=",
"self",
".",
"normale",
"(",
"p",
",",
"rayon",
")",
"n",
"=",
"n",
".",
"renorme",
"(",
")",
"y"... | [
71,
4
] | [
80,
16
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
check_same_value_or_nan | (l) | Vérifie si 2 fois la même valeur
ou valeur et np.nan dans liste à deux éléments | Vérifie si 2 fois la même valeur
ou valeur et np.nan dans liste à deux éléments | def check_same_value_or_nan(l):
"""Vérifie si 2 fois la même valeur
ou valeur et np.nan dans liste à deux éléments"""
if type(l[0]) == float:
l = [x for x in l if not np.isnan(x)]
try:
assert len(set(l)) in [0, 1]
return True
except:
# print(len(set(l)))
re... | [
"def",
"check_same_value_or_nan",
"(",
"l",
")",
":",
"if",
"type",
"(",
"l",
"[",
"0",
"]",
")",
"==",
"float",
":",
"l",
"=",
"[",
"x",
"for",
"x",
"in",
"l",
"if",
"not",
"np",
".",
"isnan",
"(",
"x",
")",
"]",
"try",
":",
"assert",
"len",... | [
8,
0
] | [
18,
20
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
Vecteur.sinus | (self, v, norm) | return sc.scalaire(norm) / float(n) | retourne le sinus de entre le vecteur self et le vecteur r,
norm est un vecteur normal et de norme 1 permettant d'orienter
le plan dans lequel se trouve les deux vecteurs dont il faut mesurer le sinus | retourne le sinus de entre le vecteur self et le vecteur r,
norm est un vecteur normal et de norme 1 permettant d'orienter
le plan dans lequel se trouve les deux vecteurs dont il faut mesurer le sinus | def sinus(self, v, norm):
"""retourne le sinus de entre le vecteur self et le vecteur r,
norm est un vecteur normal et de norme 1 permettant d'orienter
le plan dans lequel se trouve les deux vecteurs dont il faut mesurer le sinus"""
sc = self.vectoriel(v)
n1 = self.norme()
... | [
"def",
"sinus",
"(",
"self",
",",
"v",
",",
"norm",
")",
":",
"sc",
"=",
"self",
".",
"vectoriel",
"(",
"v",
")",
"n1",
"=",
"self",
".",
"norme",
"(",
")",
"n2",
"=",
"v",
".",
"norme",
"(",
")",
"n",
"=",
"n1",
"*",
"n2",
"if",
"n",
"==... | [
107,
4
] | [
117,
43
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
ListenShortcut.key_pressed | (self) | Quand la touche est appuyé, calcul l'interval
entre les deux temps d'appuie. Si il est inférieur
au seuil définit, créé l'alerte. | Quand la touche est appuyé, calcul l'interval
entre les deux temps d'appuie. Si il est inférieur
au seuil définit, créé l'alerte. | def key_pressed(self) :
""" Quand la touche est appuyé, calcul l'interval
entre les deux temps d'appuie. Si il est inférieur
au seuil définit, créé l'alerte."""
actual_hour = int(time())
last_pressed_hour = int(self.read_time())
if actual_hour-last_pressed_hour <= self.in... | [
"def",
"key_pressed",
"(",
"self",
")",
":",
"actual_hour",
"=",
"int",
"(",
"time",
"(",
")",
")",
"last_pressed_hour",
"=",
"int",
"(",
"self",
".",
"read_time",
"(",
")",
")",
"if",
"actual_hour",
"-",
"last_pressed_hour",
"<=",
"self",
".",
"interval... | [
37,
4
] | [
45,
36
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
Accreditation.exp_date | (self) | return self.renewal_date + datetime.timedelta(days=365) | Returne la date d'expiration de l'accred | Returne la date d'expiration de l'accred | def exp_date(self):
"""Returne la date d'expiration de l'accred"""
return self.renewal_date + datetime.timedelta(days=365) | [
"def",
"exp_date",
"(",
"self",
")",
":",
"return",
"self",
".",
"renewal_date",
"+",
"datetime",
".",
"timedelta",
"(",
"days",
"=",
"365",
")"
] | [
407,
4
] | [
409,
63
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
send_sync_report_mail | (*args, **kwargs) | Envoyer un e-mail contenant les dernières Tasks exécutées ;
par exemple suite un une synchronisation des ressources exécutée
avec le script `sync_resources`.
| Envoyer un e-mail contenant les dernières Tasks exécutées ;
par exemple suite un une synchronisation des ressources exécutée
avec le script `sync_resources`.
| def send_sync_report_mail(*args, **kwargs):
"""Envoyer un e-mail contenant les dernières Tasks exécutées ;
par exemple suite un une synchronisation des ressources exécutée
avec le script `sync_resources`.
"""
tasks_tracking = TaskTracking.objects.filter(
task='celeriac.tasks.save_resource',... | [
"def",
"send_sync_report_mail",
"(",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"tasks_tracking",
"=",
"TaskTracking",
".",
"objects",
".",
"filter",
"(",
"task",
"=",
"'celeriac.tasks.save_resource'",
",",
"start__gte",
"=",
"timezone",
".",
"datetime",
... | [
259,
0
] | [
323,
50
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
resultatStatsGeneralAvant | () | Controleur de la route '/resultatStatsGeneralAvant' | Controleur de la route '/resultatStatsGeneralAvant' | def resultatStatsGeneralAvant():
"Controleur de la route '/resultatStatsGeneralAvant' "
def requeteNombreCandidatureParEtab(conn, cur):
requete = """
SELECT nom, COUNT(*) AS nb
FROM superieur JOIN candidature USING(idSuperieur)
GROUP BY idSuperieur
... | [
"def",
"resultatStatsGeneralAvant",
"(",
")",
":",
"def",
"requeteNombreCandidatureParEtab",
"(",
"conn",
",",
"cur",
")",
":",
"requete",
"=",
"\"\"\"\r\n SELECT nom, COUNT(*) AS nb\r\n FROM superieur JOIN candidature USING(idSuperieur)\r\n ... | [
191,
0
] | [
269,
79
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
is_cout_calcul._write_resultats | (self) | Ecrit les résultats des calculs dans la page récapitulative | Ecrit les résultats des calculs dans la page récapitulative | def _write_resultats(self):
"Ecrit les résultats des calculs dans la page récapitulative"
for obj in self:
for row in obj.cout_actualise_ids:
product=row.product_id
couts=self._productid2cout(product.id)
for cout in couts:
v... | [
"def",
"_write_resultats",
"(",
"self",
")",
":",
"for",
"obj",
"in",
"self",
":",
"for",
"row",
"in",
"obj",
".",
"cout_actualise_ids",
":",
"product",
"=",
"row",
".",
"product_id",
"couts",
"=",
"self",
".",
"_productid2cout",
"(",
"product",
".",
"id... | [
581,
4
] | [
594,
35
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
get_points_2D | (outputs, threshold=0.2) | return xys | Pour 1 personnage capté:
[Pose(keypoints={
<KeypointType.NOSE: 0>: Keypoint(point=Point(x=717.3, y=340.8), score=0.98),
<KeypointType.LEFT_EYE: 1>: Keypoint(point=Point(x=716.2, y=312.5), score=0.6),
<KeypointType.RIGHT_EYE: 2>: Keypoint(point=Point(x=699.6, y=312.8), score=0.98),
<KeypointType.LEF... | Pour 1 personnage capté:
[Pose(keypoints={
<KeypointType.NOSE: 0>: Keypoint(point=Point(x=717.3, y=340.8), score=0.98),
<KeypointType.LEFT_EYE: 1>: Keypoint(point=Point(x=716.2, y=312.5), score=0.6),
<KeypointType.RIGHT_EYE: 2>: Keypoint(point=Point(x=699.6, y=312.8), score=0.98),
<KeypointType.LEF... | def get_points_2D(outputs, threshold=0.2):
"""Pour 1 personnage capté:
[Pose(keypoints={
<KeypointType.NOSE: 0>: Keypoint(point=Point(x=717.3, y=340.8), score=0.98),
<KeypointType.LEFT_EYE: 1>: Keypoint(point=Point(x=716.2, y=312.5), score=0.6),
<KeypointType.RIGHT_EYE: 2>: Keypoint(point=Point(x=6... | [
"def",
"get_points_2D",
"(",
"outputs",
",",
"threshold",
"=",
"0.2",
")",
":",
"pose",
"=",
"outputs",
"[",
"0",
"]",
"xys",
"=",
"{",
"}",
"for",
"label",
",",
"keypoint",
"in",
"pose",
".",
"keypoints",
".",
"items",
"(",
")",
":",
"if",
"keypoi... | [
231,
0
] | [
248,
14
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
ManagerClient.output_processing | (self, message) | Construit le message qui sera envoyé au serveur selon son type :
- i_am_in_alert : envoie une alerte, le raccourcis clavier a été pressé.
- alert_is_readed : l'utilisateur à lu un message d'alerte en cours.
- alert_is_en_error : l'utilisateur a envoyé une alerte par erreur. | Construit le message qui sera envoyé au serveur selon son type :
- i_am_in_alert : envoie une alerte, le raccourcis clavier a été pressé.
- alert_is_readed : l'utilisateur à lu un message d'alerte en cours.
- alert_is_en_error : l'utilisateur a envoyé une alerte par erreur. | def output_processing(self, message) :
""" Construit le message qui sera envoyé au serveur selon son type :
- i_am_in_alert : envoie une alerte, le raccourcis clavier a été pressé.
- alert_is_readed : l'utilisateur à lu un message d'alerte en cours.
- alert_is_en_error : l'utilisateur a ... | [
"def",
"output_processing",
"(",
"self",
",",
"message",
")",
":",
"if",
"message",
"==",
"\"i_am_in_alert\"",
":",
"self",
".",
"new_message_for_server_list",
".",
"append",
"(",
"{",
"'type'",
":",
"\"alert\"",
",",
"'sender'",
":",
"self",
".",
"userid",
... | [
92,
4
] | [
114,
43
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
add | (x, y) | return x + y | addition de deux nombres | addition de deux nombres | def add(x, y):
"""addition de deux nombres"""
return x + y | [
"def",
"add",
"(",
"x",
",",
"y",
")",
":",
"return",
"x",
"+",
"y"
] | [
1,
0
] | [
3,
16
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
nb_descendants | (noeud) | return 1 + nb_descendants(noeud.gauche) + nb_descendants(noeud.droite) | Renvoie le nombre de descendants à partir du noeud. | Renvoie le nombre de descendants à partir du noeud. | def nb_descendants(noeud):
"""Renvoie le nombre de descendants à partir du noeud."""
if noeud == None:
return 0
return 1 + nb_descendants(noeud.gauche) + nb_descendants(noeud.droite) | [
"def",
"nb_descendants",
"(",
"noeud",
")",
":",
"if",
"noeud",
"==",
"None",
":",
"return",
"0",
"return",
"1",
"+",
"nb_descendants",
"(",
"noeud",
".",
"gauche",
")",
"+",
"nb_descendants",
"(",
"noeud",
".",
"droite",
")"
] | [
103,
0
] | [
108,
74
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
norvegian_to_english | (norvegien_text) | return english_text | traduit norvegien en anglais | traduit norvegien en anglais | def norvegian_to_english(norvegien_text):
""" traduit norvegien en anglais"""
if norvegien_text is None:
english_text = None
else:
l_t = get_language_translator(apikey, version, url)
translation = l_t.translate(
text=norvegien_text,
model_id='nb-en').get_resul... | [
"def",
"norvegian_to_english",
"(",
"norvegien_text",
")",
":",
"if",
"norvegien_text",
"is",
"None",
":",
"english_text",
"=",
"None",
"else",
":",
"l_t",
"=",
"get_language_translator",
"(",
"apikey",
",",
"version",
",",
"url",
")",
"translation",
"=",
"l_t... | [
46,
0
] | [
56,
23
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
set.contains | (self, elem) | return elem in self.size | Savoir si un élément est présent dans l'ensemble | Savoir si un élément est présent dans l'ensemble | def contains(self, elem):
"""Savoir si un élément est présent dans l'ensemble"""
return elem in self.size | [
"def",
"contains",
"(",
"self",
",",
"elem",
")",
":",
"return",
"elem",
"in",
"self",
".",
"size"
] | [
24,
4
] | [
26,
32
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
InterfaceJeu.initChoix | (self) | Initialisation du canvas de choix des pièces | Initialisation du canvas de choix des pièces | def initChoix(self):
"""Initialisation du canvas de choix des pièces"""
# Création d'une liste de 3 pièces à jouer uniques et aléatoires
plc = []
cpt = 0
while cpt < 3:
if cpt == 0 :
# Ajoute une première pièce
self.listePieces.append(self.board.getRandomPiece())
cpt =1
else :
# Ajout... | [
"def",
"initChoix",
"(",
"self",
")",
":",
"# Création d'une liste de 3 pièces à jouer uniques et aléatoires",
"plc",
"=",
"[",
"]",
"cpt",
"=",
"0",
"while",
"cpt",
"<",
"3",
":",
"if",
"cpt",
"==",
"0",
":",
"# Ajoute une première pièce",
"self",
".",
"listePi... | [
310,
1
] | [
377,
41
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
modifierCandidature | () | return redirect(url_for('candidature')) | Controleur de la route '/modifierCandidature' | Controleur de la route '/modifierCandidature' | def modifierCandidature():
"Controleur de la route '/modifierCandidature' "
def requeteListeCandidatureApresSuppression(conn, cur, result, idEleve):
"""Supprime les candidatures abandonnées
et retourne la liste des identifiants des établissements demandés par l'élève
"""
... | [
"def",
"modifierCandidature",
"(",
")",
":",
"def",
"requeteListeCandidatureApresSuppression",
"(",
"conn",
",",
"cur",
",",
"result",
",",
"idEleve",
")",
":",
"\"\"\"Supprime les candidatures abandonnées\r\n et retourne la liste des identifiants des établissements demandés... | [
254,
0
] | [
302,
43
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
ListeAccords.frequenceAvecTemperament | (self,pitch1) | return (pitch1.frequency) | Fonction qui prend en entree un pitch pour renvoyer une frequence, en tenant compte du temperament | Fonction qui prend en entree un pitch pour renvoyer une frequence, en tenant compte du temperament | def frequenceAvecTemperament(self,pitch1):
"""Fonction qui prend en entree un pitch pour renvoyer une frequence, en tenant compte du temperament"""
pitchRef = pitch.Pitch(self.noteDeReferencePourLeTunning)
pitch1.microtone = self.temperament[(pitch1.pitchClass - pitchRef.pitchClass)%12] - 100*((pitc... | [
"def",
"frequenceAvecTemperament",
"(",
"self",
",",
"pitch1",
")",
":",
"pitchRef",
"=",
"pitch",
".",
"Pitch",
"(",
"self",
".",
"noteDeReferencePourLeTunning",
")",
"pitch1",
".",
"microtone",
"=",
"self",
".",
"temperament",
"[",
"(",
"pitch1",
".",
"pit... | [
80,
2
] | [
87,
31
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
Crud.get_form_elements | (self) | return self.application["tables"][self.ctx["table_id"]]["forms"][self.ctx["form_id"]]["elements"] | Obtenir la liste des champs du formulaire courant | Obtenir la liste des champs du formulaire courant | def get_form_elements(self):
""" Obtenir la liste des champs du formulaire courant """
return self.application["tables"][self.ctx["table_id"]]["forms"][self.ctx["form_id"]]["elements"] | [
"def",
"get_form_elements",
"(",
"self",
")",
":",
"return",
"self",
".",
"application",
"[",
"\"tables\"",
"]",
"[",
"self",
".",
"ctx",
"[",
"\"table_id\"",
"]",
"]",
"[",
"\"forms\"",
"]",
"[",
"self",
".",
"ctx",
"[",
"\"form_id\"",
"]",
"]",
"[",
... | [
514,
4
] | [
516,
105
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
Rectangle.__init__ | (self, a, b, c, d, couleur) | initialisation, si d == None, d est calculé comme étant
le symétrique de b par rapport au milieu du segment [ac] | initialisation, si d == None, d est calculé comme étant
le symétrique de b par rapport au milieu du segment [ac] | def __init__(self, a, b, c, d, couleur):
"""initialisation, si d == None, d est calculé comme étant
le symétrique de b par rapport au milieu du segment [ac]"""
Facette.__init__(self, a, b, c, couleur)
if d is not None:
self.d = d
else:
i = (a + c) / 2
... | [
"def",
"__init__",
"(",
"self",
",",
"a",
",",
"b",
",",
"c",
",",
"d",
",",
"couleur",
")",
":",
"Facette",
".",
"__init__",
"(",
"self",
",",
"a",
",",
"b",
",",
"c",
",",
"couleur",
")",
"if",
"d",
"is",
"not",
"None",
":",
"self",
".",
... | [
75,
4
] | [
83,
36
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
SphereReflet.rayon_reflechi | (self, rayon, p) | return r | retourne le rayon réfléchi au point p de la surface,
si aucune, retourne None | retourne le rayon réfléchi au point p de la surface,
si aucune, retourne None | def rayon_reflechi(self, rayon, p):
"""retourne le rayon réfléchi au point p de la surface,
si aucune, retourne None"""
if p == rayon.origine:
return None
n = self.normale(p, rayon)
n = n.renorme()
y = n.scalaire(rayon.direction)
d = rayon.direction - ... | [
"def",
"rayon_reflechi",
"(",
"self",
",",
"rayon",
",",
"p",
")",
":",
"if",
"p",
"==",
"rayon",
".",
"origine",
":",
"return",
"None",
"n",
"=",
"self",
".",
"normale",
"(",
"p",
",",
"rayon",
")",
"n",
"=",
"n",
".",
"renorme",
"(",
")",
"y"... | [
70,
4
] | [
80,
16
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
Scene.intersection | (self, rayon) | return so, sp | calcule le point d'intersection entre un rayon et le plus proche des objets,
retourne l'objet et le point d'intersection | calcule le point d'intersection entre un rayon et le plus proche des objets,
retourne l'objet et le point d'intersection | def intersection(self, rayon):
"""calcule le point d'intersection entre un rayon et le plus proche des objets,
retourne l'objet et le point d'intersection"""
if not hasattr(self, "objets"):
return None, None
p = rayon.origine
sp, so = None, None
for o in self.... | [
"def",
"intersection",
"(",
"self",
",",
"rayon",
")",
":",
"if",
"not",
"hasattr",
"(",
"self",
",",
"\"objets\"",
")",
":",
"return",
"None",
",",
"None",
"p",
"=",
"rayon",
".",
"origine",
"sp",
",",
"so",
"=",
"None",
",",
"None",
"for",
"o",
... | [
48,
4
] | [
72,
21
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
Calculatrice.btnOperationPressed | (self, operation) | Fonction activée quand l'utilisateur appuie sur une touche d'opération (+, -, /, *) | Fonction activée quand l'utilisateur appuie sur une touche d'opération (+, -, /, *) | def btnOperationPressed(self, operation):
"""Fonction activée quand l'utilisateur appuie sur une touche d'opération (+, -, /, *)"""
resultat = self.le_resultat.text()
self.le_resultat.setText(resultat + " " + operation + " ") | [
"def",
"btnOperationPressed",
"(",
"self",
",",
"operation",
")",
":",
"resultat",
"=",
"self",
".",
"le_resultat",
".",
"text",
"(",
")",
"self",
".",
"le_resultat",
".",
"setText",
"(",
"resultat",
"+",
"\" \"",
"+",
"operation",
"+",
"\" \"",
")"
] | [
66,
1
] | [
69,
60
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
decompose | (n) | return facteurs | décomposition d'un nombre en facteurs premiers | décomposition d'un nombre en facteurs premiers | def decompose(n):
""" décomposition d'un nombre en facteurs premiers """
facteurs = {}
i = 2
while i * i <= n:
while n % i == 0:
n = n // i
facteurs[i] = facteurs.get(i, 0) + 1
if i >= 3:
i += 2
else:
i += 1
if n > 1:
fa... | [
"def",
"decompose",
"(",
"n",
")",
":",
"facteurs",
"=",
"{",
"}",
"i",
"=",
"2",
"while",
"i",
"*",
"i",
"<=",
"n",
":",
"while",
"n",
"%",
"i",
"==",
"0",
":",
"n",
"=",
"n",
"//",
"i",
"facteurs",
"[",
"i",
"]",
"=",
"facteurs",
".",
"... | [
10,
0
] | [
24,
19
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
LigneGradient.next_chemin | (self, ext, ij) | Retourne le couple suivant d'extrémités possibles,
None, dans le cas contraire. | Retourne le couple suivant d'extrémités possibles,
None, dans le cas contraire. | def next_chemin(self, ext, ij):
"""Retourne le couple suivant d'extrémités possibles,
None, dans le cas contraire."""
if ij[1] < len(ext) - 1:
return (ij[0], ij[1] + 1)
elif ij[0] < len(ext) - 2:
return (ij[0] + 1, ij[0] + 2)
else:
return None | [
"def",
"next_chemin",
"(",
"self",
",",
"ext",
",",
"ij",
")",
":",
"if",
"ij",
"[",
"1",
"]",
"<",
"len",
"(",
"ext",
")",
"-",
"1",
":",
"return",
"(",
"ij",
"[",
"0",
"]",
",",
"ij",
"[",
"1",
"]",
"+",
"1",
")",
"elif",
"ij",
"[",
"... | [
109,
4
] | [
117,
23
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
DatasetList.get | (self, request) | return JsonResponse(
[serialize(dataset) for dataset in datasets], safe=False) | Voir les jeux de données. | Voir les jeux de données. | def get(self, request):
"""Voir les jeux de données."""
datasets = handler_get_request(request)
return JsonResponse(
[serialize(dataset) for dataset in datasets], safe=False) | [
"def",
"get",
"(",
"self",
",",
"request",
")",
":",
"datasets",
"=",
"handler_get_request",
"(",
"request",
")",
"return",
"JsonResponse",
"(",
"[",
"serialize",
"(",
"dataset",
")",
"for",
"dataset",
"in",
"datasets",
"]",
",",
"safe",
"=",
"False",
")... | [
346,
4
] | [
351,
69
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
attendre_clic | (screen,x,y) | dessine un rectangle rouge sur l'�cran et
attend la pression d'un clic de souris | dessine un rectangle rouge sur l'�cran et
attend la pression d'un clic de souris | def attendre_clic (screen,x,y):
"""dessine un rectangle rouge sur l'�cran et
attend la pression d'un clic de souris"""
color = 255,0,0
pygame.draw.line (screen, color, (10,10), (x-10,10), 2)
pygame.draw.line (screen, color, (x-10,10), (x-10,y-10), 2)
pygame.draw.line (screen, color, (x-10,y-1... | [
"def",
"attendre_clic",
"(",
"screen",
",",
"x",
",",
"y",
")",
":",
"color",
"=",
"255",
",",
"0",
",",
"0",
"pygame",
".",
"draw",
".",
"line",
"(",
"screen",
",",
"color",
",",
"(",
"10",
",",
"10",
")",
",",
"(",
"x",
"-",
"10",
",",
"1... | [
215,
0
] | [
229,
21
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
point | (px, py) | return id | affichage d'un point de coordonnees (px, py) dans la couleur courante
retour de l'identificateur unique de l'objet cree
| affichage d'un point de coordonnees (px, py) dans la couleur courante
retour de l'identificateur unique de l'objet cree
| def point(px, py):
"""affichage d'un point de coordonnees (px, py) dans la couleur courante
retour de l'identificateur unique de l'objet cree
"""
if px < 0 or px > __la or py < 0 or py > __ha:
__erreur("[point] coordonnees hors fenetre")
# changement de repere
py = __ha - py
id = __c... | [
"def",
"point",
"(",
"px",
",",
"py",
")",
":",
"if",
"px",
"<",
"0",
"or",
"px",
">",
"__la",
"or",
"py",
"<",
"0",
"or",
"py",
">",
"__ha",
":",
"__erreur",
"(",
"\"[point] coordonnees hors fenetre\"",
")",
"# changement de repere",
"py",
"=",
"__ha"... | [
190,
0
] | [
200,
13
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
InterfaceJeu.reset | (self) | Replace tout le jeu à son état initial et relance une partie | Replace tout le jeu à son état initial et relance une partie | def reset(self):
"""Replace tout le jeu à son état initial et relance une partie"""
# Reset des variables
self.piece_choisie = None
self.listePieces = []
self.cpt_tour = 1
# Reset des canvas
self.canvas.delete("all")
self.tabpieces0.delete("all")
self.tabpieces1.delete("all")
self.tabpieces2.dele... | [
"def",
"reset",
"(",
"self",
")",
":",
"# Reset des variables",
"self",
".",
"piece_choisie",
"=",
"None",
"self",
".",
"listePieces",
"=",
"[",
"]",
"self",
".",
"cpt_tour",
"=",
"1",
"# Reset des canvas",
"self",
".",
"canvas",
".",
"delete",
"(",
"\"all... | [
478,
1
] | [
500,
18
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
ModelTests.test_recipe_str | (self) | test la represetnation en chaine de caractere de l'objet recette | test la represetnation en chaine de caractere de l'objet recette | def test_recipe_str(self):
"""test la represetnation en chaine de caractere de l'objet recette"""
recipe = models.Recipe.objects.create(
user=sample_user(),
title='nockedli',
time_minutes=5,
price=5.00)
self.assertEqual(str(recipe), recipe.title) | [
"def",
"test_recipe_str",
"(",
"self",
")",
":",
"recipe",
"=",
"models",
".",
"Recipe",
".",
"objects",
".",
"create",
"(",
"user",
"=",
"sample_user",
"(",
")",
",",
"title",
"=",
"'nockedli'",
",",
"time_minutes",
"=",
"5",
",",
"price",
"=",
"5.00"... | [
61,
4
] | [
69,
51
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
Storage.get_nodes | (self) | return result | Récupère la liste des noeuds | Récupère la liste des noeuds | def get_nodes(self):
"""Récupère la liste des noeuds"""
cursor = self.connection.cursor()
cursor.execute("SELECT * FROM nodes")
result = cursor.fetchall()
return result | [
"def",
"get_nodes",
"(",
"self",
")",
":",
"cursor",
"=",
"self",
".",
"connection",
".",
"cursor",
"(",
")",
"cursor",
".",
"execute",
"(",
"\"SELECT * FROM nodes\"",
")",
"result",
"=",
"cursor",
".",
"fetchall",
"(",
")",
"return",
"result"
] | [
33,
4
] | [
38,
21
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
res_partner.num_closing_days | (self, partner) | return jours_fermes | Retourner les jours de fermetures du partner
| Retourner les jours de fermetures du partner
| def num_closing_days(self, partner):
""" Retourner les jours de fermetures du partner
"""
jours_fermes = []
if partner.close_monday:
jours_fermes.append(1)
if partner.close_tuesday:
jours_fermes.append(2)
if partner.close_wednesday:
... | [
"def",
"num_closing_days",
"(",
"self",
",",
"partner",
")",
":",
"jours_fermes",
"=",
"[",
"]",
"if",
"partner",
".",
"close_monday",
":",
"jours_fermes",
".",
"append",
"(",
"1",
")",
"if",
"partner",
".",
"close_tuesday",
":",
"jours_fermes",
".",
"appe... | [
286,
4
] | [
304,
27
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
Admin.main_bug | (self, ctx: MyContext) | Gère la liste des bugs | Gère la liste des bugs | async def main_bug(self, ctx: MyContext):
"""Gère la liste des bugs"""
pass | [
"async",
"def",
"main_bug",
"(",
"self",
",",
"ctx",
":",
"MyContext",
")",
":",
"pass"
] | [
850,
4
] | [
852,
12
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
Utilities.allowed_card_styles | (self, user: discord.User) | return sorted(liste2)+sorted(liste) | Retourne la liste des styles autorisées pour la carte d'xp de cet utilisateur | Retourne la liste des styles autorisées pour la carte d'xp de cet utilisateur | async def allowed_card_styles(self, user: discord.User):
"""Retourne la liste des styles autorisées pour la carte d'xp de cet utilisateur"""
liste = ['blue', 'dark', 'green', 'grey', 'orange',
'purple', 'red', 'turquoise', 'yellow']
if not self.bot.database_online:
r... | [
"async",
"def",
"allowed_card_styles",
"(",
"self",
",",
"user",
":",
"discord",
".",
"User",
")",
":",
"liste",
"=",
"[",
"'blue'",
",",
"'dark'",
",",
"'green'",
",",
"'grey'",
",",
"'orange'",
",",
"'purple'",
",",
"'red'",
",",
"'turquoise'",
",",
... | [
312,
4
] | [
349,
43
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
spearman | (n, X, Y) | return r | calcul du coefficient de Spearman pour des échantillons avec des valeurs uniques | calcul du coefficient de Spearman pour des échantillons avec des valeurs uniques | def spearman(n, X, Y):
""" calcul du coefficient de Spearman pour des échantillons avec des valeurs uniques """
def rank(X):
r = [0] * len(X)
xs = sorted((x, i) for i, x in enumerate(X))
for j, xi in enumerate(xs):
r[xi[1]] = j + 1
return r
# somme de la différe... | [
"def",
"spearman",
"(",
"n",
",",
"X",
",",
"Y",
")",
":",
"def",
"rank",
"(",
"X",
")",
":",
"r",
"=",
"[",
"0",
"]",
"*",
"len",
"(",
"X",
")",
"xs",
"=",
"sorted",
"(",
"(",
"x",
",",
"i",
")",
"for",
"i",
",",
"x",
"in",
"enumerate"... | [
7,
0
] | [
21,
12
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
account_invoice.envoi_par_mail | (self) | Envoi du mail directement sans passer par le wizard | Envoi du mail directement sans passer par le wizard | def envoi_par_mail(self):
"""Envoi du mail directement sans passer par le wizard"""
cr , uid, context = self.env.args
if not self.pool['res.users'].has_group(cr, uid, 'is_plastigray.is_comptable_group'):
raise Warning(u"Accès non autorisé !")
ids=[]
for obj in self:
... | [
"def",
"envoi_par_mail",
"(",
"self",
")",
":",
"cr",
",",
"uid",
",",
"context",
"=",
"self",
".",
"env",
".",
"args",
"if",
"not",
"self",
".",
"pool",
"[",
"'res.users'",
"]",
".",
"has_group",
"(",
"cr",
",",
"uid",
",",
"'is_plastigray.is_comptabl... | [
256,
4
] | [
321,
58
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
Font.addtext | (self, text, txtname=None, color=(255, 0, 0)) | fabrique une image(surface) associée à text prete à coller | fabrique une image(surface) associée à text prete à coller | def addtext(self, text, txtname=None, color=(255, 0, 0)):
'''fabrique une image(surface) associée à text prete à coller'''
if txtname == None:
self.textdic[text] = self.font.render(text, True, color)
else:
self.textdic[txtname] = self.font.render(text, True, color) | [
"def",
"addtext",
"(",
"self",
",",
"text",
",",
"txtname",
"=",
"None",
",",
"color",
"=",
"(",
"255",
",",
"0",
",",
"0",
")",
")",
":",
"if",
"txtname",
"==",
"None",
":",
"self",
".",
"textdic",
"[",
"text",
"]",
"=",
"self",
".",
"font",
... | [
11,
4
] | [
16,
71
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
Xp.calc_level | (self, xp: int, system: int) | Calcule le niveau correspondant à un nombre d'xp | Calcule le niveau correspondant à un nombre d'xp | async def calc_level(self, xp: int, system: int):
"""Calcule le niveau correspondant à un nombre d'xp"""
if system != 1:
if xp == 0:
return [0,ceil((1*125/7)**(20/13)),0]
lvl = ceil(0.056*xp**0.65)
next_step = xp
while ceil(0.056*next_step*... | [
"async",
"def",
"calc_level",
"(",
"self",
",",
"xp",
":",
"int",
",",
"system",
":",
"int",
")",
":",
"if",
"system",
"!=",
"1",
":",
"if",
"xp",
"==",
"0",
":",
"return",
"[",
"0",
",",
"ceil",
"(",
"(",
"1",
"*",
"125",
"/",
"7",
")",
"*... | [
269,
4
] | [
294,
58
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
Crud.compute_formulas | (self, elements, virtual_only=False) | Calcul des formules des éléments | Calcul des formules des éléments | def compute_formulas(self, elements, virtual_only=False):
""" Calcul des formules des éléments """
for element in elements:
crudel = elements[element].get("crudel")
if crudel.with_formulas() :
if virtual_only :
if crudel.is_virtual :
... | [
"def",
"compute_formulas",
"(",
"self",
",",
"elements",
",",
"virtual_only",
"=",
"False",
")",
":",
"for",
"element",
"in",
"elements",
":",
"crudel",
"=",
"elements",
"[",
"element",
"]",
".",
"get",
"(",
"\"crudel\"",
")",
"if",
"crudel",
".",
"with_... | [
724,
4
] | [
735,
50
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
coups_legaux | (grille) | return coups | Renvoie la liste des colonnes dans lesquelles il est possible de
jouer un jeton
| Renvoie la liste des colonnes dans lesquelles il est possible de
jouer un jeton | def coups_legaux(grille):
"""Renvoie la liste des colonnes dans lesquelles il est possible de
jouer un jeton
"""
coups = []
for i in range(0, 6):
if grille[i][0] == 0:
coups += [str(i + 1)]
return coups | [
"def",
"coups_legaux",
"(",
"grille",
")",
":",
"coups",
"=",
"[",
"]",
"for",
"i",
"in",
"range",
"(",
"0",
",",
"6",
")",
":",
"if",
"grille",
"[",
"i",
"]",
"[",
"0",
"]",
"==",
"0",
":",
"coups",
"+=",
"[",
"str",
"(",
"i",
"+",
"1",
... | [
36,
0
] | [
46,
16
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
D_aux | (xj,xjj) | return (pow(polynome_B(xj,xjj),3) - polynome_B(xj,xjj))/6 | Intermédiaire de calcul du polynôme D | Intermédiaire de calcul du polynôme D | def D_aux(xj,xjj):
""" Intermédiaire de calcul du polynôme D """
return (pow(polynome_B(xj,xjj),3) - polynome_B(xj,xjj))/6 | [
"def",
"D_aux",
"(",
"xj",
",",
"xjj",
")",
":",
"return",
"(",
"pow",
"(",
"polynome_B",
"(",
"xj",
",",
"xjj",
")",
",",
"3",
")",
"-",
"polynome_B",
"(",
"xj",
",",
"xjj",
")",
")",
"/",
"6"
] | [
75,
0
] | [
77,
59
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
Facette.couleur_point | (self, p) | return self.couleur | retourne la couleur au point de coordonnée p | retourne la couleur au point de coordonnée p | def couleur_point(self, p):
"""retourne la couleur au point de coordonnée p"""
return self.couleur | [
"def",
"couleur_point",
"(",
"self",
",",
"p",
")",
":",
"return",
"self",
".",
"couleur"
] | [
59,
4
] | [
61,
27
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
nCk_mod | (n, r, m) | return x % m | calcule C(n, r) % m avec m square-free | calcule C(n, r) % m avec m square-free | def nCk_mod(n, r, m):
""" calcule C(n, r) % m avec m square-free """
if m < 2:
return 0
p = decompose(m)
assert set(p.values()) == set({1})
p = list(p.keys())
x = 0
for pi in p:
ai = lucas(n, r, pi)
_, _, v = egcd(pi, m // pi)
x += ai * v * (m // pi)
... | [
"def",
"nCk_mod",
"(",
"n",
",",
"r",
",",
"m",
")",
":",
"if",
"m",
"<",
"2",
":",
"return",
"0",
"p",
"=",
"decompose",
"(",
"m",
")",
"assert",
"set",
"(",
"p",
".",
"values",
"(",
")",
")",
"==",
"set",
"(",
"{",
"1",
"}",
")",
"p",
... | [
79,
0
] | [
96,
16
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
credit | () | attributions : option "Credits" 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_credit()'
du fichier 'fonctions.py' en lui passant en argument la largeur et hauteur de la fenêtre | attributions : option "Credits" 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_credit()'
du fichier 'fonctions.py' en lui passant en argument la largeur et hauteur de la fenêtre | def credit():
"""attributions : option "Credits" 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_credit()'
du fichier 'fonctions.py' en lui passant en argument la largeur et hauteur de la fenêtre"""
masterx=... | [
"def",
"credit",
"(",
")",
":",
"masterx",
"=",
"master",
".",
"winfo_width",
"(",
")",
"mastery",
"=",
"master",
".",
"winfo_height",
"(",
")",
"f_credit",
"(",
"masterx",
",",
"mastery",
")"
] | [
73,
0
] | [
79,
29
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
asklocation | (message, location="") | Affiche une fenêtre simple qui demande la
localisation du bureaux et retourne sa valeur | Affiche une fenêtre simple qui demande la
localisation du bureaux et retourne sa valeur | def asklocation(message, location="") :
""" Affiche une fenêtre simple qui demande la
localisation du bureaux et retourne sa valeur"""
from time import sleep
window = Tk()
window.title("Kemenn - Demande de localisation")
window.resizable(False, False)
#Affichage de texte explicatif
Label... | [
"def",
"asklocation",
"(",
"message",
",",
"location",
"=",
"\"\"",
")",
":",
"from",
"time",
"import",
"sleep",
"window",
"=",
"Tk",
"(",
")",
"window",
".",
"title",
"(",
"\"Kemenn - Demande de localisation\"",
")",
"window",
".",
"resizable",
"(",
"False"... | [
110,
0
] | [
141,
18
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
Joueur.actualiser | (self) | Actualise les stats du personnage | Actualise les stats du personnage | def actualiser(self):
"""Actualise les stats du personnage"""
self.enlever_vie()
self.actualiser_frame() # Actualiser les frames
self.actualiser_sprite() # Actualiser le sprite
self.attaquer()
self.actualiser_son()
# Je calcule la position de rendu du sprite a... | [
"def",
"actualiser",
"(",
"self",
")",
":",
"self",
".",
"enlever_vie",
"(",
")",
"self",
".",
"actualiser_frame",
"(",
")",
"# Actualiser les frames",
"self",
".",
"actualiser_sprite",
"(",
")",
"# Actualiser le sprite",
"self",
".",
"attaquer",
"(",
")",
"se... | [
190,
4
] | [
203,
54
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
symbolic_Rz_matrix | (symbolic_theta) | return sympy.Matrix([
[sympy.cos(symbolic_theta), -sympy.sin(symbolic_theta), 0],
[sympy.sin(symbolic_theta), sympy.cos(symbolic_theta), 0],
[0, 0, 1]
]) | Matrice symbolique de rotation autour de l'axe Z | Matrice symbolique de rotation autour de l'axe Z | def symbolic_Rz_matrix(symbolic_theta):
"""Matrice symbolique de rotation autour de l'axe Z"""
return sympy.Matrix([
[sympy.cos(symbolic_theta), -sympy.sin(symbolic_theta), 0],
[sympy.sin(symbolic_theta), sympy.cos(symbolic_theta), 0],
[0, 0, 1]
]) | [
"def",
"symbolic_Rz_matrix",
"(",
"symbolic_theta",
")",
":",
"return",
"sympy",
".",
"Matrix",
"(",
"[",
"[",
"sympy",
".",
"cos",
"(",
"symbolic_theta",
")",
",",
"-",
"sympy",
".",
"sin",
"(",
"symbolic_theta",
")",
",",
"0",
"]",
",",
"[",
"sympy",... | [
28,
0
] | [
34,
6
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
node_name_to_id | (storage, name) | return node | Récupèrer un noeud en ayant son nom | Récupèrer un noeud en ayant son nom | def node_name_to_id(storage, name):
"""Récupèrer un noeud en ayant son nom"""
node = storage.get_node_by_name(name)
return node | [
"def",
"node_name_to_id",
"(",
"storage",
",",
"name",
")",
":",
"node",
"=",
"storage",
".",
"get_node_by_name",
"(",
"name",
")",
"return",
"node"
] | [
18,
0
] | [
21,
15
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
ScenePhong.couleur_fond | (self) | return self.fond * self.ka | retourne la couleur du fond | retourne la couleur du fond | def couleur_fond(self):
"""retourne la couleur du fond"""
return self.fond * self.ka | [
"def",
"couleur_fond",
"(",
"self",
")",
":",
"return",
"self",
".",
"fond",
"*",
"self",
".",
"ka"
] | [
36,
4
] | [
38,
34
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
gagnant_diagonale | (lig, col, grille) | return | Renvoie True si le coup joué (lig,col) forme une diagonale de 4 jetons
False sinon
| Renvoie True si le coup joué (lig,col) forme une diagonale de 4 jetons
False sinon
| def gagnant_diagonale(lig, col, grille):
"""Renvoie True si le coup joué (lig,col) forme une diagonale de 4 jetons
False sinon
"""
return | [
"def",
"gagnant_diagonale",
"(",
"lig",
",",
"col",
",",
"grille",
")",
":",
"return"
] | [
74,
0
] | [
78,
10
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
log_gaspillage | (X_pred) | Affiche les métriques relatives au gaspillage out of sample | Affiche les métriques relatives au gaspillage out of sample | def log_gaspillage(X_pred):
"""Affiche les métriques relatives au gaspillage out of sample"""
print("gaspillage réel", X_pred.gaspillage.mean())
print("gaspillage avec nos prédictions - upper", X_pred.gaspi_pred_upper.mean())
print(
len(X_pred[X_pred.gaspillage < 0]),
"reel : jours ave... | [
"def",
"log_gaspillage",
"(",
"X_pred",
")",
":",
"print",
"(",
"\"gaspillage réel\",",
" ",
"_pred.",
"g",
"aspillage.",
"m",
"ean(",
")",
")",
"",
"print",
"(",
"\"gaspillage avec nos prédictions - upper\",",
" ",
"_pred.",
"g",
"aspi_pred_upper.",
"m",
"ean(",
... | [
131,
0
] | [
152,
17
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
isInContinent | (country_name: str, continent: str) | return int(concode == continent) | Permet de vérifier si le pays est dans un continent
Paramètres
----------
country_name : str
Le nom du pays
continent : str
Le code du continent (alpha2)
Retours
-------
is_in_continent : int
entier binaire positif si le pays est dans le continent
Exemples
... | Permet de vérifier si le pays est dans un continent | def isInContinent(country_name: str, continent: str):
"""Permet de vérifier si le pays est dans un continent
Paramètres
----------
country_name : str
Le nom du pays
continent : str
Le code du continent (alpha2)
Retours
-------
is_in_continent : int
entier binair... | [
"def",
"isInContinent",
"(",
"country_name",
":",
"str",
",",
"continent",
":",
"str",
")",
":",
"try",
":",
"# code a deux lettres du pays",
"calpha2",
"=",
"country_name_to_country_alpha2",
"(",
"country_name",
".",
"strip",
"(",
")",
")",
"except",
"KeyError",
... | [
25,
0
] | [
54,
36
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
set.add | (self, elem) | return 0 | Ajouter un élément à l'ensemble | Ajouter un élément à l'ensemble | def add(self, elem):
"""Ajouter un élément à l'ensemble"""
if elem != None:
#L'utilisateur a bien fourni un élément à ajouter
if not (elem in self.list):
#L'élément n'est pas déjà présent dans l'ensemble
self.list.append(elem)
... | [
"def",
"add",
"(",
"self",
",",
"elem",
")",
":",
"if",
"elem",
"!=",
"None",
":",
"#L'utilisateur a bien fourni un élément à ajouter",
"if",
"not",
"(",
"elem",
"in",
"self",
".",
"list",
")",
":",
"#L'élément n'est pas déjà présent dans l'ensemble",
"self",
".",... | [
10,
4
] | [
22,
16
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
Point.__sub__ | (self, p) | return Point(self.x - p.x, self.y - p.y) | soustraction de deux de vecteurs | soustraction de deux de vecteurs | def __sub__(self, p):
"""soustraction de deux de vecteurs"""
return Point(self.x - p.x, self.y - p.y) | [
"def",
"__sub__",
"(",
"self",
",",
"p",
")",
":",
"return",
"Point",
"(",
"self",
".",
"x",
"-",
"p",
".",
"x",
",",
"self",
".",
"y",
"-",
"p",
".",
"y",
")"
] | [
88,
4
] | [
90,
48
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
serialise_noeud | (noeud) | return resultat | Sérialise récursivement l'arbre à partir du noeud.
A chaque niveau, on créé un bloc de texte rectangulaire.
On fusionne chaque bloc récursivement.
| Sérialise récursivement l'arbre à partir du noeud.
A chaque niveau, on créé un bloc de texte rectangulaire.
On fusionne chaque bloc récursivement.
| def serialise_noeud(noeud):
"""Sérialise récursivement l'arbre à partir du noeud.
A chaque niveau, on créé un bloc de texte rectangulaire.
On fusionne chaque bloc récursivement.
"""
# Fin de la récursivité
if noeud == None:
return ""
# Créé une chaîne de caractères pour chaque ... | [
"def",
"serialise_noeud",
"(",
"noeud",
")",
":",
"# Fin de la récursivité",
"if",
"noeud",
"==",
"None",
":",
"return",
"\"\"",
"# Créé une chaîne de caractères pour chaque bloc",
"bloc_gauche",
"=",
"serialise_noeud",
"(",
"noeud",
".",
"gauche",
")",
"bloc_droite",
... | [
143,
0
] | [
177,
19
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
Crud.get_table_prop | (self, prop, default="") | return self.application["tables"][self.ctx["table_id"]].get(prop, default) | Obtenir la valeur d'une propriété de la table courante | Obtenir la valeur d'une propriété de la table courante | def get_table_prop(self, prop, default=""):
""" Obtenir la valeur d'une propriété de la table courante """
return self.application["tables"][self.ctx["table_id"]].get(prop, default) | [
"def",
"get_table_prop",
"(",
"self",
",",
"prop",
",",
"default",
"=",
"\"\"",
")",
":",
"return",
"self",
".",
"application",
"[",
"\"tables\"",
"]",
"[",
"self",
".",
"ctx",
"[",
"\"table_id\"",
"]",
"]",
".",
"get",
"(",
"prop",
",",
"default",
"... | [
472,
4
] | [
474,
82
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
ListeAccords.spectre | (self,f0) | return S | Cette methode va etre appelee dans la classe Accord, mais elle est definie ici car le seul attribut d'objet
qui en est parametre est l'instrument | Cette methode va etre appelee dans la classe Accord, mais elle est definie ici car le seul attribut d'objet
qui en est parametre est l'instrument | def spectre(self,f0):
'''Cette methode va etre appelee dans la classe Accord, mais elle est definie ici car le seul attribut d'objet
qui en est parametre est l'instrument'''
n = np.arange(0,16,0.001)
S = np.zeros(np.shape(n))
if not parametres.shepard:
for i in ran... | [
"def",
"spectre",
"(",
"self",
",",
"f0",
")",
":",
"n",
"=",
"np",
".",
"arange",
"(",
"0",
",",
"16",
",",
"0.001",
")",
"S",
"=",
"np",
".",
"zeros",
"(",
"np",
".",
"shape",
"(",
"n",
")",
")",
"if",
"not",
"parametres",
".",
"shepard",
... | [
68,
4
] | [
95,
16
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
main | () | Fonction lancée à la première frame dans blender en temps que module. | Fonction lancée à la première frame dans blender en temps que module. | def main():
'''Fonction lancée à la première frame dans blender en temps que module.'''
once.main() | [
"def",
"main",
"(",
")",
":",
"once",
".",
"main",
"(",
")"
] | [
4,
0
] | [
7,
15
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
Crud.get_application_tables | (self) | return self.application["tables"] | Obtenir la liste des tables de l'application courante | Obtenir la liste des tables de l'application courante | def get_application_tables(self):
""" Obtenir la liste des tables de l'application courante """
return self.application["tables"] | [
"def",
"get_application_tables",
"(",
"self",
")",
":",
"return",
"self",
".",
"application",
"[",
"\"tables\"",
"]"
] | [
449,
4
] | [
451,
41
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
sync_remote_catalogs | (*args, **kwargs) | Synchroniser les catalogues distants. | Synchroniser les catalogues distants. | def sync_remote_catalogs(*args, **kwargs):
"""Synchroniser les catalogues distants."""
for RemoteCatalog in RemoteCatalogs:
for remote in RemoteCatalog.objects.filter(**kwargs):
logger.info("Start synchronize remote instance %s %d (%s)" % (
remote.__class__.__qualname__, rem... | [
"def",
"sync_remote_catalogs",
"(",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"for",
"RemoteCatalog",
"in",
"RemoteCatalogs",
":",
"for",
"remote",
"in",
"RemoteCatalog",
".",
"objects",
".",
"filter",
"(",
"*",
"*",
"kwargs",
")",
":",
"logger",
"... | [
146,
0
] | [
156,
35
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
PublicIngredientsApiTest.test_login_required | (self) | il faut se loguer pour acceder | il faut se loguer pour acceder | def test_login_required(self):
""" il faut se loguer pour acceder"""
res = self.client.get(INGREDIENTS_URL)
self.assertEqual(res.status_code, status.HTTP_401_UNAUTHORIZED) | [
"def",
"test_login_required",
"(",
"self",
")",
":",
"res",
"=",
"self",
".",
"client",
".",
"get",
"(",
"INGREDIENTS_URL",
")",
"self",
".",
"assertEqual",
"(",
"res",
".",
"status_code",
",",
"status",
".",
"HTTP_401_UNAUTHORIZED",
")"
] | [
19,
4
] | [
22,
71
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
creer_arbre_binaire_avec_liste | (liste) | return arbre | Convertie une liste en arbre binaire. | Convertie une liste en arbre binaire. | def creer_arbre_binaire_avec_liste(liste):
"""Convertie une liste en arbre binaire."""
arbre = ArbreBinaire()
for element in liste:
insere_noeud_dans_arbre_binaire(arbre, element)
return arbre | [
"def",
"creer_arbre_binaire_avec_liste",
"(",
"liste",
")",
":",
"arbre",
"=",
"ArbreBinaire",
"(",
")",
"for",
"element",
"in",
"liste",
":",
"insere_noeud_dans_arbre_binaire",
"(",
"arbre",
",",
"element",
")",
"return",
"arbre"
] | [
49,
0
] | [
55,
16
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
Crud.get_application_prop | (self, prop, default="") | return self.application.get(prop, default) | Obtenir la valeur d'une propriété de l'application courante | Obtenir la valeur d'une propriété de l'application courante | def get_application_prop(self, prop, default=""):
""" Obtenir la valeur d'une propriété de l'application courante """
return self.application.get(prop, default) | [
"def",
"get_application_prop",
"(",
"self",
",",
"prop",
",",
"default",
"=",
"\"\"",
")",
":",
"return",
"self",
".",
"application",
".",
"get",
"(",
"prop",
",",
"default",
")"
] | [
446,
4
] | [
448,
50
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
load_all_sfx | (directory, accept=('.wav','.mpe','.ogg','.mdi')) | return effects | Renvoie un dico associant les noms des sons a leur objet sound pygame depuis un dossier | Renvoie un dico associant les noms des sons a leur objet sound pygame depuis un dossier | def load_all_sfx(directory, accept=('.wav','.mpe','.ogg','.mdi')):
"""Renvoie un dico associant les noms des sons a leur objet sound pygame depuis un dossier"""
effects = {}
for fx in os.listdir(directory):
name, ext = os.path.splitext(fx)
if ext.lower() in accept:
effects[... | [
"def",
"load_all_sfx",
"(",
"directory",
",",
"accept",
"=",
"(",
"'.wav'",
",",
"'.mpe'",
",",
"'.ogg'",
",",
"'.mdi'",
")",
")",
":",
"effects",
"=",
"{",
"}",
"for",
"fx",
"in",
"os",
".",
"listdir",
"(",
"directory",
")",
":",
"name",
",",
"ext... | [
137,
0
] | [
144,
18
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
LinkCsteF.__init__ | (self, m1, m2, F=[0,0]) | Lien avec force constante | Lien avec force constante | def __init__(self, m1, m2, F=[0,0]):
'''Lien avec force constante'''
self.linktype = 10
self.force1 = pygame.math.Vector2(F)
self.force2 = -self.force1
super().__init__(m1, m2)
self.rigid = False | [
"def",
"__init__",
"(",
"self",
",",
"m1",
",",
"m2",
",",
"F",
"=",
"[",
"0",
",",
"0",
"]",
")",
":",
"self",
".",
"linktype",
"=",
"10",
"self",
".",
"force1",
"=",
"pygame",
".",
"math",
".",
"Vector2",
"(",
"F",
")",
"self",
".",
"force2... | [
120,
4
] | [
126,
26
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
Events.add_task | (self, action:str, duration:int, userID: int, guildID:int=None, channelID:int=None, message:str=None, data:dict=None) | return True | Ajoute une tâche à la liste | Ajoute une tâche à la liste | async def add_task(self, action:str, duration:int, userID: int, guildID:int=None, channelID:int=None, message:str=None, data:dict=None):
"""Ajoute une tâche à la liste"""
tasks = await self.get_events_from_db(all=True)
for t in tasks:
if (t['user']==userID and t['guild']==guildID and... | [
"async",
"def",
"add_task",
"(",
"self",
",",
"action",
":",
"str",
",",
"duration",
":",
"int",
",",
"userID",
":",
"int",
",",
"guildID",
":",
"int",
"=",
"None",
",",
"channelID",
":",
"int",
"=",
"None",
",",
"message",
":",
"str",
"=",
"None",... | [
447,
4
] | [
460,
19
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
Screen.set_world_size | (self, world) | Ajuste les dimensions en pixels du monde par rapport aux dimensions de la fenêtre | Ajuste les dimensions en pixels du monde par rapport aux dimensions de la fenêtre | def set_world_size(self, world):
''' Ajuste les dimensions en pixels du monde par rapport aux dimensions de la fenêtre'''
if world.sizex >= world.sizey*4/3: # bon rectangle
self.pxpm = self.width/world.sizex # Afficher sur toute la largeur
yshift = int((self.height-world.si... | [
"def",
"set_world_size",
"(",
"self",
",",
"world",
")",
":",
"if",
"world",
".",
"sizex",
">=",
"world",
".",
"sizey",
"*",
"4",
"/",
"3",
":",
"# bon rectangle\r",
"self",
".",
"pxpm",
"=",
"self",
".",
"width",
"/",
"world",
".",
"sizex",
"# Affic... | [
62,
4
] | [
79,
42
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
apply_objet_position_orientation | (objet_point_1, objet_point_2, objet) | Valable pour un objet seulement.
objet_point_1, objet_point_2 sont 2 objets Blender:
ils définissent un vecteur.
L'objet objet est orienté suivant ce vecteur,
si objet_point_2 n'est pas None
et positionné en objet_point_1.
| Valable pour un objet seulement.
objet_point_1, objet_point_2 sont 2 objets Blender:
ils définissent un vecteur.
L'objet objet est orienté suivant ce vecteur,
si objet_point_2 n'est pas None
et positionné en objet_point_1.
| def apply_objet_position_orientation(objet_point_1, objet_point_2, objet):
"""Valable pour un objet seulement.
objet_point_1, objet_point_2 sont 2 objets Blender:
ils définissent un vecteur.
L'objet objet est orienté suivant ce vecteur,
si objet_point_2 n'est pas None
et positionné en ob... | [
"def",
"apply_objet_position_orientation",
"(",
"objet_point_1",
",",
"objet_point_2",
",",
"objet",
")",
":",
"if",
"objet_point_2",
":",
"try",
":",
"a",
"=",
"objet_point_1",
".",
"worldPosition",
"b",
"=",
"objet_point_2",
".",
"worldPosition",
"direction",
"=... | [
11,
0
] | [
42,
53
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
gagnant_antidiagonale | (lig, col, grille) | return | Renvoie True si le coup joué (lig,col) forme une antidiagonale de 4 jetons
False sinon
| Renvoie True si le coup joué (lig,col) forme une antidiagonale de 4 jetons
False sinon
| def gagnant_antidiagonale(lig, col, grille):
"""Renvoie True si le coup joué (lig,col) forme une antidiagonale de 4 jetons
False sinon
"""
return | [
"def",
"gagnant_antidiagonale",
"(",
"lig",
",",
"col",
",",
"grille",
")",
":",
"return"
] | [
80,
0
] | [
84,
10
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
OscAug.play | (self) | return self | Play pour objet qui necessite des changements d'amplitudes rapides | Play pour objet qui necessite des changements d'amplitudes rapides | def play(self):
"Play pour objet qui necessite des changements d'amplitudes rapides"
self.fade.play()
return self | [
"def",
"play",
"(",
"self",
")",
":",
"self",
".",
"fade",
".",
"play",
"(",
")",
"return",
"self"
] | [
58,
4
] | [
61,
19
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
parcours_zigzag | (n) | return [(x if y % 2 == 0 else 9 - x, y) for y in range(0, n) for x in range(0, n)] | Retourne la liste des indices (ligne,
colonne) des cases correspondant a un parcours sinusoidal d'un
tableau de taille n x n.
Ex: pour T = [ [1,2,3],
[4,5,6],
[7,8,9] ]
le parcours correspond aux cases 1,2,3,6,5,4,7,8,9 et la
fonction retournera la liste d'indi... | Retourne la liste des indices (ligne,
colonne) des cases correspondant a un parcours sinusoidal d'un
tableau de taille n x n. | def parcours_zigzag(n):
"""Retourne la liste des indices (ligne,
colonne) des cases correspondant a un parcours sinusoidal d'un
tableau de taille n x n.
Ex: pour T = [ [1,2,3],
[4,5,6],
[7,8,9] ]
le parcours correspond aux cases 1,2,3,6,5,4,7,8,9 et la
fonc... | [
"def",
"parcours_zigzag",
"(",
"n",
")",
":",
"return",
"[",
"(",
"x",
"if",
"y",
"%",
"2",
"==",
"0",
"else",
"9",
"-",
"x",
",",
"y",
")",
"for",
"y",
"in",
"range",
"(",
"0",
",",
"n",
")",
"for",
"x",
"in",
"range",
"(",
"0",
",",
"n"... | [
96,
0
] | [
109,
86
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
functions_list_down | (f, step, hmax) | return y | Fonction qui calcule la liste des fonctions f(x,lambda) pour lambda entre 0 et 1 (partie inférieure de l'aile) | Fonction qui calcule la liste des fonctions f(x,lambda) pour lambda entre 0 et 1 (partie inférieure de l'aile) | def functions_list_down(f, step, hmax):
""" Fonction qui calcule la liste des fonctions f(x,lambda) pour lambda entre 0 et 1 (partie inférieure de l'aile)"""
y = []
for lambd in np.arange (0, 1 + step, step):
y.append (curve_function_down(f, lambd, hmax))
return y | [
"def",
"functions_list_down",
"(",
"f",
",",
"step",
",",
"hmax",
")",
":",
"y",
"=",
"[",
"]",
"for",
"lambd",
"in",
"np",
".",
"arange",
"(",
"0",
",",
"1",
"+",
"step",
",",
"step",
")",
":",
"y",
".",
"append",
"(",
"curve_function_down",
"("... | [
75,
0
] | [
80,
10
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
modifierReponses | () | Controleur de la route '/modifierReponses' | Controleur de la route '/modifierReponses' | def modifierReponses():
"Controleur de la route '/modifierReponses' "
def requeteAbandonCandidature(conn, cur, result, idSuperieur, idEleve):
requete = """
UPDATE candidature SET statut='abandonne'
WHERE idSuperieur = ? AND idEleve = ?;
... | [
"def",
"modifierReponses",
"(",
")",
":",
"def",
"requeteAbandonCandidature",
"(",
"conn",
",",
"cur",
",",
"result",
",",
"idSuperieur",
",",
"idEleve",
")",
":",
"requete",
"=",
"\"\"\"\r\n UPDATE candidature SET statut='abandonne' \r\n ... | [
338,
0
] | [
397,
44
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
Entite.bouger_hitbox | (self, coord) | Gere le mouvement de la hitbox
| Gere le mouvement de la hitbox
| def bouger_hitbox(self, coord):
""" Gere le mouvement de la hitbox
"""
self.hitbox.rect = self.sprite.get_rect(center=(self.position[0] + coord[0] + self.taille[0]/2,
self.position[1] + coord[1] + self.taille[1]/2))
self.hitbox.mask... | [
"def",
"bouger_hitbox",
"(",
"self",
",",
"coord",
")",
":",
"self",
".",
"hitbox",
".",
"rect",
"=",
"self",
".",
"sprite",
".",
"get_rect",
"(",
"center",
"=",
"(",
"self",
".",
"position",
"[",
"0",
"]",
"+",
"coord",
"[",
"0",
"]",
"+",
"self... | [
63,
4
] | [
69,
31
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
SphereReflet.__init__ | (self, centre, rayon, couleur, reflet) | initialisation, reflet est un coefficient de réflexion | initialisation, reflet est un coefficient de réflexion | def __init__(self, centre, rayon, couleur, reflet):
"""initialisation, reflet est un coefficient de réflexion"""
Sphere.__init__(self, centre, rayon, couleur)
self.reflet = reflet | [
"def",
"__init__",
"(",
"self",
",",
"centre",
",",
"rayon",
",",
"couleur",
",",
"reflet",
")",
":",
"Sphere",
".",
"__init__",
"(",
"self",
",",
"centre",
",",
"rayon",
",",
"couleur",
")",
"self",
".",
"reflet",
"=",
"reflet"
] | [
58,
4
] | [
61,
28
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
Accord.ListeHauteursAvecMultiplicite | (self) | Fonction qui donne la liste des pitches, comptes autant de fois qu'ils sont repetes a differentes voix | Fonction qui donne la liste des pitches, comptes autant de fois qu'ils sont repetes a differentes voix | def ListeHauteursAvecMultiplicite(self):
""" Fonction qui donne la liste des pitches, comptes autant de fois qu'ils sont repetes a differentes voix"""
#self.listeHauteursAvecMultiplicite = list
for elt in self.verticality.startTimespans:
if elt.element.isChord:
for pitch in e... | [
"def",
"ListeHauteursAvecMultiplicite",
"(",
"self",
")",
":",
"#self.listeHauteursAvecMultiplicite = list",
"for",
"elt",
"in",
"self",
".",
"verticality",
".",
"startTimespans",
":",
"if",
"elt",
".",
"element",
".",
"isChord",
":",
"for",
"pitch",
"in",
"elt",
... | [
310,
2
] | [
330,
75
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
parcours_antidiagonal | (n) | return [] | Retourne la liste des indices (colonne,ligne) (!!attention ici
ligne et colonne sont inversées!!) des cases correspondant à un
parcours de tableau de taille n x n en anti-diagonale.
Ex: pour T = [ [1,2,3],
[4,5,6],
[7,8,9] ]
le parcours correspond aux cases 9,6,8,... | Retourne la liste des indices (colonne,ligne) (!!attention ici
ligne et colonne sont inversées!!) des cases correspondant à un
parcours de tableau de taille n x n en anti-diagonale. | def parcours_antidiagonal(n):
"""Retourne la liste des indices (colonne,ligne) (!!attention ici
ligne et colonne sont inversées!!) des cases correspondant à un
parcours de tableau de taille n x n en anti-diagonale.
Ex: pour T = [ [1,2,3],
[4,5,6],
[7,8,9] ]
le... | [
"def",
"parcours_antidiagonal",
"(",
"n",
")",
":",
"return",
"[",
"]"
] | [
51,
0
] | [
63,
13
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
Facette.intersection_plan | (self, r) | return p | retourne le point d'intersection entre le plan et le rayon r | retourne le point d'intersection entre le plan et le rayon r | def intersection_plan(self, r):
"""retourne le point d'intersection entre le plan et le rayon r"""
if r.direction.scalaire(self.vnorm) == 0:
return None
oa = self.a - r.origine
lv = self.vnorm.scalaire(oa) / self.vnorm.scalaire(r.direction)
p = r.origine + r.direction... | [
"def",
"intersection_plan",
"(",
"self",
",",
"r",
")",
":",
"if",
"r",
".",
"direction",
".",
"scalaire",
"(",
"self",
".",
"vnorm",
")",
"==",
"0",
":",
"return",
"None",
"oa",
"=",
"self",
".",
"a",
"-",
"r",
".",
"origine",
"lv",
"=",
"self",... | [
21,
4
] | [
28,
16
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
Board.isBoardFull | (self) | return True | Renvoie True si toute le plateau de jeu est occupé (fin de partie) | Renvoie True si toute le plateau de jeu est occupé (fin de partie) | def isBoardFull(self):
"""Renvoie True si toute le plateau de jeu est occupé (fin de partie)"""
for y in range(len(self.matrix)):
for x in range(len(self.matrix[y])):
if self.isFree(x, y):
# Si on trouve une case libre alors on renvoit True
return False
return True | [
"def",
"isBoardFull",
"(",
"self",
")",
":",
"for",
"y",
"in",
"range",
"(",
"len",
"(",
"self",
".",
"matrix",
")",
")",
":",
"for",
"x",
"in",
"range",
"(",
"len",
"(",
"self",
".",
"matrix",
"[",
"y",
"]",
")",
")",
":",
"if",
"self",
".",... | [
55,
1
] | [
62,
13
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
InformationPoint.__str__ | (self) | return s | permet d'afficher cette classe | permet d'afficher cette classe | def __str__(self):
"""permet d'afficher cette classe"""
s = "aligne " + str(self.aligne)
s += " pix " + str(self.pos)
s += " gnor " + str(self.norme)
return s | [
"def",
"__str__",
"(",
"self",
")",
":",
"s",
"=",
"\"aligne \"",
"+",
"str",
"(",
"self",
".",
"aligne",
")",
"s",
"+=",
"\" pix \"",
"+",
"str",
"(",
"self",
".",
"pos",
")",
"s",
"+=",
"\" gnor \"",
"+",
"str",
"(",
"self",
".",
"norme",
")"... | [
48,
4
] | [
53,
16
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
Map.afficher_premier_plan | (self) | Affiche la 4 eme couche de la map
Quatrième couche (3) = Premier plan devant le personnage
| Affiche la 4 eme couche de la map
Quatrième couche (3) = Premier plan devant le personnage
| def afficher_premier_plan(self):
""" Affiche la 4 eme couche de la map
Quatrième couche (3) = Premier plan devant le personnage
"""
cp.ecran.blit(self.premier_plan, (self.x_camera,
self.y_camera)) | [
"def",
"afficher_premier_plan",
"(",
"self",
")",
":",
"cp",
".",
"ecran",
".",
"blit",
"(",
"self",
".",
"premier_plan",
",",
"(",
"self",
".",
"x_camera",
",",
"self",
".",
"y_camera",
")",
")"
] | [
72,
4
] | [
77,
57
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
Admin.main_botserv | (self, ctx: MyContext) | Quelques commandes liées au serveur officiel | Quelques commandes liées au serveur officiel | async def main_botserv(self, ctx: MyContext):
"""Quelques commandes liées au serveur officiel"""
if ctx.invoked_subcommand is None or ctx.invoked_subcommand==self.main_botserv:
text = "Liste des commandes disponibles :"
for cmd in ctx.command.commands:
text+="\n- ... | [
"async",
"def",
"main_botserv",
"(",
"self",
",",
"ctx",
":",
"MyContext",
")",
":",
"if",
"ctx",
".",
"invoked_subcommand",
"is",
"None",
"or",
"ctx",
".",
"invoked_subcommand",
"==",
"self",
".",
"main_botserv",
":",
"text",
"=",
"\"Liste des commandes dispo... | [
631,
4
] | [
637,
32
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
SegmentBord.__init__ | (self, dim, dangle=math.pi / 24.0) | initialise les dimensions et
fait sorte que la classe contienne le premier segment | initialise les dimensions et
fait sorte que la classe contienne le premier segment | def __init__(self, dim, dangle=math.pi / 24.0):
"""initialise les dimensions et
fait sorte que la classe contienne le premier segment"""
SegmentBord_Commun.__init__(self, dim)
self.premier()
self.dangle = dangle | [
"def",
"__init__",
"(",
"self",
",",
"dim",
",",
"dangle",
"=",
"math",
".",
"pi",
"/",
"24.0",
")",
":",
"SegmentBord_Commun",
".",
"__init__",
"(",
"self",
",",
"dim",
")",
"self",
".",
"premier",
"(",
")",
"self",
".",
"dangle",
"=",
"dangle"
] | [
38,
4
] | [
43,
28
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
visible_or_not | () | Visibilité soit du personnage, soit la matérialisation des os | Visibilité soit du personnage, soit la matérialisation des os | def visible_or_not():
"""Visibilité soit du personnage, soit la matérialisation des os"""
if gl.body_visible:
gl.person.visible = 0
for name, obj in gl.all_obj.items():
if "Text" in name:
obj.visible = 1
for num in JOINTS:
gl.all_obj[num].visible ... | [
"def",
"visible_or_not",
"(",
")",
":",
"if",
"gl",
".",
"body_visible",
":",
"gl",
".",
"person",
".",
"visible",
"=",
"0",
"for",
"name",
",",
"obj",
"in",
"gl",
".",
"all_obj",
".",
"items",
"(",
")",
":",
"if",
"\"Text\"",
"in",
"name",
":",
... | [
125,
0
] | [
148,
27
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
strategie.closeAll | (self, BidAsk, temps, backtest) | Ferme tout les ordres
| Ferme tout les ordres
| def closeAll(self, BidAsk, temps, backtest):
""" Ferme tout les ordres
"""
if backtest:
dico = Var.fakeDeal
else:
dico = Var.dealDone
toute = []
for x in range(0, len(dico["entry"])):
toute.append(x)
if backtest:
Re... | [
"def",
"closeAll",
"(",
"self",
",",
"BidAsk",
",",
"temps",
",",
"backtest",
")",
":",
"if",
"backtest",
":",
"dico",
"=",
"Var",
".",
"fakeDeal",
"else",
":",
"dico",
"=",
"Var",
".",
"dealDone",
"toute",
"=",
"[",
"]",
"for",
"x",
"in",
"range",... | [
306,
4
] | [
320,
70
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
rectangle | (px1, py1, px2, py2, pep=1) | return id | affichage d'un rectangle dans la couleur courante
defini par le sommet inf. gauche (px1, py1)
et le sommet sup. droit (px2, py2) et d'epaisseur pep
retour de l'identificateur unique de l'objet cree
| affichage d'un rectangle dans la couleur courante
defini par le sommet inf. gauche (px1, py1)
et le sommet sup. droit (px2, py2) et d'epaisseur pep
retour de l'identificateur unique de l'objet cree
| def rectangle(px1, py1, px2, py2, pep=1):
"""affichage d'un rectangle dans la couleur courante
defini par le sommet inf. gauche (px1, py1)
et le sommet sup. droit (px2, py2) et d'epaisseur pep
retour de l'identificateur unique de l'objet cree
"""
# changement de repere
py1, py2 = __ha - py1,... | [
"def",
"rectangle",
"(",
"px1",
",",
"py1",
",",
"px2",
",",
"py2",
",",
"pep",
"=",
"1",
")",
":",
"# changement de repere",
"py1",
",",
"py2",
"=",
"__ha",
"-",
"py1",
",",
"__ha",
"-",
"py2",
"id",
"=",
"__canv",
".",
"create_rectangle",
"(",
"p... | [
218,
0
] | [
227,
13
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
minutes_left | (arrival_time) | return int(timedelta.total_seconds(arrival_time - datetime.now()) // 60) | Calcule des minutes restantes entre arrival_time et maintenant. | Calcule des minutes restantes entre arrival_time et maintenant. | def minutes_left(arrival_time):
"""Calcule des minutes restantes entre arrival_time et maintenant."""
return int(timedelta.total_seconds(arrival_time - datetime.now()) // 60) | [
"def",
"minutes_left",
"(",
"arrival_time",
")",
":",
"return",
"int",
"(",
"timedelta",
".",
"total_seconds",
"(",
"arrival_time",
"-",
"datetime",
".",
"now",
"(",
")",
")",
"//",
"60",
")"
] | [
15,
0
] | [
17,
76
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
polynome_D | (xj, xjj) | return (D_aux(xj,xjj) * pow((xjj - xj), 2)) | Polynome D associé au couple de point xj xj+1 (=xjj) | Polynome D associé au couple de point xj xj+1 (=xjj) | def polynome_D(xj, xjj):
""" Polynome D associé au couple de point xj xj+1 (=xjj) """
return (D_aux(xj,xjj) * pow((xjj - xj), 2)) | [
"def",
"polynome_D",
"(",
"xj",
",",
"xjj",
")",
":",
"return",
"(",
"D_aux",
"(",
"xj",
",",
"xjj",
")",
"*",
"pow",
"(",
"(",
"xjj",
"-",
"xj",
")",
",",
"2",
")",
")"
] | [
79,
0
] | [
81,
45
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
genere_tableau_aleatoire | (distance_moyenne, taille) | return [int(ra.gauss(0,distance_moyenne)) for i in range(0,taille)] | cette fonction prend deux paramètres et génere un tableau de nombres
entiers ayant une distance moyenne entre ses éléments de "distance_moyenne"
et une taille de "taille". | cette fonction prend deux paramètres et génere un tableau de nombres
entiers ayant une distance moyenne entre ses éléments de "distance_moyenne"
et une taille de "taille". | def genere_tableau_aleatoire(distance_moyenne, taille):
""" cette fonction prend deux paramètres et génere un tableau de nombres
entiers ayant une distance moyenne entre ses éléments de "distance_moyenne"
et une taille de "taille". """
return [int(ra.gauss(0,distance_moyenne)) for i in range(0,taille)] | [
"def",
"genere_tableau_aleatoire",
"(",
"distance_moyenne",
",",
"taille",
")",
":",
"return",
"[",
"int",
"(",
"ra",
".",
"gauss",
"(",
"0",
",",
"distance_moyenne",
")",
")",
"for",
"i",
"in",
"range",
"(",
"0",
",",
"taille",
")",
"]"
] | [
33,
0
] | [
37,
71
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
Couleur.__add__ | (self, p) | return Couleur(self.x + p.x, self.y + p.y, self.z + p.z) | addition de deux couleurs | addition de deux couleurs | def __add__(self, p):
"""addition de deux couleurs"""
return Couleur(self.x + p.x, self.y + p.y, self.z + p.z) | [
"def",
"__add__",
"(",
"self",
",",
"p",
")",
":",
"return",
"Couleur",
"(",
"self",
".",
"x",
"+",
"p",
".",
"x",
",",
"self",
".",
"y",
"+",
"p",
".",
"y",
",",
"self",
".",
"z",
"+",
"p",
".",
"z",
")"
] | [
174,
4
] | [
176,
64
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
gagner | (lig, col, grille) | return | Renvoie True si le coup joué est un coup gagnant
False sinon
| Renvoie True si le coup joué est un coup gagnant
False sinon
| def gagner(lig, col, grille):
"""Renvoie True si le coup joué est un coup gagnant
False sinon
"""
return | [
"def",
"gagner",
"(",
"lig",
",",
"col",
",",
"grille",
")",
":",
"return"
] | [
86,
0
] | [
90,
10
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
Admin.bug_fix | (self, ctx: MyContext, ID:int, fixed:bool=True) | Marque un bug comme étant fixé | Marque un bug comme étant fixé | async def bug_fix(self, ctx: MyContext, ID:int, fixed:bool=True):
"""Marque un bug comme étant fixé"""
try:
chan = ctx.bot.get_channel(548138866591137802) if self.bot.beta else ctx.bot.get_channel(488769283673948175)
if chan is None:
return await ctx.send("Salon i... | [
"async",
"def",
"bug_fix",
"(",
"self",
",",
"ctx",
":",
"MyContext",
",",
"ID",
":",
"int",
",",
"fixed",
":",
"bool",
"=",
"True",
")",
":",
"try",
":",
"chan",
"=",
"ctx",
".",
"bot",
".",
"get_channel",
"(",
"548138866591137802",
")",
"if",
"se... | [
870,
4
] | [
892,
68
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
Vecteur.norme2 | (self) | return self.x * self.x + self.y * self.y + self.z * self.z | retourne la norme du vecteur au carré | retourne la norme du vecteur au carré | def norme2(self):
"""retourne la norme du vecteur au carré"""
return self.x * self.x + self.y * self.y + self.z * self.z | [
"def",
"norme2",
"(",
"self",
")",
":",
"return",
"self",
".",
"x",
"*",
"self",
".",
"x",
"+",
"self",
".",
"y",
"*",
"self",
".",
"y",
"+",
"self",
".",
"z",
"*",
"self",
".",
"z"
] | [
69,
4
] | [
71,
66
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
World.update_rigids | (self) | calcule puis mets à jours les forces des liens rigides | calcule puis mets à jours les forces des liens rigides | def update_rigids(self):
'''calcule puis mets à jours les forces des liens rigides'''
forces = self.calc_rigids()
i = 0
for link in self.link:
if link.rigid:
m1 = link.mass1
m2 = link.mass2
i1 = self.mass.index(m1)
... | [
"def",
"update_rigids",
"(",
"self",
")",
":",
"forces",
"=",
"self",
".",
"calc_rigids",
"(",
")",
"i",
"=",
"0",
"for",
"link",
"in",
"self",
".",
"link",
":",
"if",
"link",
".",
"rigid",
":",
"m1",
"=",
"link",
".",
"mass1",
"m2",
"=",
"link",... | [
257,
4
] | [
274,
22
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
OrganisationList.post | (self, request) | return response | Créer une nouvelle organisation. | Créer une nouvelle organisation. | def post(self, request):
"""Créer une nouvelle organisation."""
request.POST._mutable = True
if not request.user.profile.is_admin:
raise Http404()
try:
organisation = handle_pust_request(request)
except Http404:
raise Http404()
except G... | [
"def",
"post",
"(",
"self",
",",
"request",
")",
":",
"request",
".",
"POST",
".",
"_mutable",
"=",
"True",
"if",
"not",
"request",
".",
"user",
".",
"profile",
".",
"is_admin",
":",
"raise",
"Http404",
"(",
")",
"try",
":",
"organisation",
"=",
"han... | [
185,
4
] | [
198,
23
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
Admin.membercounter | (self, ctx: MyContext) | Recharge tout ces salons qui contiennent le nombre de membres, pour tout les serveurs | Recharge tout ces salons qui contiennent le nombre de membres, pour tout les serveurs | async def membercounter(self, ctx: MyContext):
"""Recharge tout ces salons qui contiennent le nombre de membres, pour tout les serveurs"""
if self.bot.database_online:
i = 0
for x in self.bot.guilds:
if await self.bot.get_cog("Servers").update_memberChannel(x):
... | [
"async",
"def",
"membercounter",
"(",
"self",
",",
"ctx",
":",
"MyContext",
")",
":",
"if",
"self",
".",
"bot",
".",
"database_online",
":",
"i",
"=",
"0",
"for",
"x",
"in",
"self",
".",
"bot",
".",
"guilds",
":",
"if",
"await",
"self",
".",
"bot",... | [
349,
4
] | [
358,
91
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
compress | (img, k) | return img | Compression d'une image 'img' au rang k.
| Compression d'une image 'img' au rang k.
| def compress(img, k):
""" Compression d'une image 'img' au rang k.
"""
img = np.array(img)
R = img[:, :, 0]
G = img[:, :, 1]
B = img[:, :, 2]
img[:, :, 0] = compress_matrix(R, k).clip(0, 1)
img[:, :, 1] = compress_matrix(G, k).clip(0, 1)
img[:, :, 2] = compress_matrix(B, k).clip(0, 1)
return img | [
"def",
"compress",
"(",
"img",
",",
"k",
")",
":",
"img",
"=",
"np",
".",
"array",
"(",
"img",
")",
"R",
"=",
"img",
"[",
":",
",",
":",
",",
"0",
"]",
"G",
"=",
"img",
"[",
":",
",",
":",
",",
"1",
"]",
"B",
"=",
"img",
"[",
":",
","... | [
28,
0
] | [
38,
11
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
is_cout_calcul._maj_couts | (self,nb_threads=0) | Mise à jour des couts en threads | Mise à jour des couts en threads | def _maj_couts(self,nb_threads=0):
"""Mise à jour des couts en threads"""
for obj in self:
#** Répartition des lignes dans le nombre de threads indiqué *******
t=0
res={}
#TODO : Nouvelle environnement pour avoir un cr contenant les dernières modification... | [
"def",
"_maj_couts",
"(",
"self",
",",
"nb_threads",
"=",
"0",
")",
":",
"for",
"obj",
"in",
"self",
":",
"#** Répartition des lignes dans le nombre de threads indiqué *******",
"t",
"=",
"0",
"res",
"=",
"{",
"}",
"#TODO : Nouvelle environnement pour avoir un cr conte... | [
335,
4
] | [
380,
30
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null | |
load_all_fonts | (directory, accept=('.ttf')) | return load_all_music(directory, accept) | Meme que musique mais pour fonts | Meme que musique mais pour fonts | def load_all_fonts(directory, accept=('.ttf')):
"""Meme que musique mais pour fonts"""
return load_all_music(directory, accept) | [
"def",
"load_all_fonts",
"(",
"directory",
",",
"accept",
"=",
"(",
"'.ttf'",
")",
")",
":",
"return",
"load_all_music",
"(",
"directory",
",",
"accept",
")"
] | [
133,
0
] | [
135,
44
] | null | python | fr | ['fr', 'fr', 'fr'] | True | true | null |
is_cout_calcul._get_couts_ids | (self,couts) | return ids | Retourne la liste des id des couts à partir des couts | Retourne la liste des id des couts à partir des couts | def _get_couts_ids(self,couts):
"""Retourne la liste des id des couts à partir des couts"""
ids=[]
for cout in couts:
ids.append(str(cout.id))
return ids | [
"def",
"_get_couts_ids",
"(",
"self",
",",
"couts",
")",
":",
"ids",
"=",
"[",
"]",
"for",
"cout",
"in",
"couts",
":",
"ids",
".",
"append",
"(",
"str",
"(",
"cout",
".",
"id",
")",
")",
"return",
"ids"
] | [
572,
4
] | [
577,
18
] | 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.