tp.4

tp.4/etudiants/apl1test.py

+import thonnycontrib
+from thonnycontrib.backend.evaluator import Evaluator
+import thonnycontrib.backend.l1test_backend
+from thonny.plugins.cpython_backend.cp_back import MainCPythonBackend
+import thonnycontrib.backend.doctest_parser 
+from thonnycontrib.backend.doctest_parser import ExampleWithExpected, ExampleWithoutExpected
+import thonnycontrib.backend.ast_parser
+from thonnycontrib.backend.ast_parser import L1DocTest
+import thonnycontrib.backend.verdicts
+from thonnycontrib.backend.verdicts.ExceptionVerdict import ExceptionVerdict 
+
+import inspect
+import tempfile
+import os
+import sys
+        
+class MockBackend(MainCPythonBackend):
+    """
+    Fake backend.
+    """
+    def __init__(self):
+        ...
+
+    def send_message(self, msg) -> None:
+        ...
+
+# register backend
+thonnycontrib.backend.l1test_backend.BACKEND = MockBackend()
+
+def l1test_to_org(filename: str, source: str=""):
+    """
+    Return an org abstract of the tests presents in `filename` file.
+    """
+    abstract = {'total': 0,
+                'success': 0,
+                'failures': 0,
+                'errors': 0,
+                'empty': 0}
+
+    if source == "":
+        with open(filename, 'rt') as fin:
+            source = fin.read()
+    evaluator = Evaluator(filename=filename,
+                          source=source)
+    tests = evaluator.evaluate()
+    n = len(tests)
+    abstract['total'] = n
+    res = ""
+    for test in tests:
+        examples = test.get_examples()
+        res_examples = ""
+        nb_test, nb_test_ok = 0, 0
+        empty = True
+        for example in examples:
+            verdict = test.get_verdict_from_example(example)
+            if isinstance(example, ExampleWithExpected):
+                nb_test += 1
+                if verdict.isSuccess():
+                    nb_test_ok += 1
+                    abstract['success'] += 1
+                else:
+                    abstract['failures'] += 1
+                empty = False
+            if isinstance(verdict, ExceptionVerdict):
+                abstract['errors'] += 1
+                empty = False
+            res_examples += f"** {verdict}\n\n"
+            if not verdict.isSuccess():
+                res_examples += f"   {verdict.get_details()}\n\n"
+        if not empty: 
+            res += f"* {test.get_name()} ~ {nb_test_ok}/{nb_test} réussis\n\n"
+        else:
+            abstract['empty'] += 1
+            res += f"* {test.get_name()}\n\n Aucun test trouvé !\n\n"
+        res += res_examples
+    res = f"Tests exécutés : {abstract['total']}\nSuccès: {abstract['success']}, \
+Echecs: {abstract['failures']}, Erreurs: {abstract['errors']}, \
+Vide: {abstract['empty']}\n\n" + res
+    return res
+
+
+def testmod(modulename: str):
+    """
+    mimic the doctest.testmod function
+    for `modulename` module
+    """
+    print(l1test_to_org(modulename))
+
+

tp.4/etudiants/date.py

+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+
+"""
+:mod:`date` module :  a  module for date
+
+:author: `FIL - Faculté des Sciences et Technologies - 
+          Univ. Lille <http://portail.fil.univ-lille1.fr>`_
+
+:date: 2024, january. Last revision: 2024, january
+
+Date are objects
+
+"""
+
+NOM_MOIS = ['janvier', 'février', 'mars', 'avril', 'mai', 'juin', 'juillet',
+            'août', 'septembre', 'octobre', 'novembre', 'décembre']
+DUREE_MOIS = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
+
+
+def est_bissextile(annee: int) -> bool:
+    """
+    Renvoie True si et seulement si annee est bissextile.
+
+    précondition: annee >= 1582.
+
+    $$$ est_bissextile(2024)
+    True
+    $$$ est_bissextile(2000)
+    True
+    $$$ est_bissextile(2100)
+    False
+    """
+    return annee % 4 == 0 and (annee % 100 != 0 or annee % 400 == 0)
+
+
+def nombre_de_jour_dans_mois(mois: int, annee: int) -> int:
+    """
+    Renvoie le nombre de jour dans le mois `mois` de l'année `année`.
+
+    précondition : 0 <= mois < 12 et annee >= 1582.
+    """
+    duree_mois = DUREE_MOIS[mois - 1]
+    if est_bissextile(annee) and mois == 2:
+        return duree_mois + 1
+    return duree_mois
+
+
+def nom_mois(mois) -> str:
+    """Renvoie le nom du mois en français."""
+    return NOM_MOIS[mois - 1]
+
+
+class Date:
+    """
+    une classe permettant de représenter des dates
+    """
+    
+    def __init__(self, jour: int, mois: int, annee: int):
+        """
+        initialise une nouvelle date
+
+        précondition : jour/mois/annee est une date valide
+
+        exemples :
+
+        $$$ adate = Date(4, 6, 2024)
+        $$$ type(adate) == Date
+        True
+        """
+        self.jour = jour
+        self.mois = mois
+        self.annee = annee
+
+    
+    def __str__(self) -> str:
+        """
+        Renvoie une châine représentant la date.
+
+        $$$ adate = Date(23, 1, 2024)
+        $$$ str(adate)
+        '23 janvier 2024'
+        """
+        return f"{self.jour} {nom_mois(self.mois)} {self.annee}"
+
+    def __eq__(self, other: 'Date') -> bool:
+        """
+        Renvoie True si, et seulement si, deux dates sont égales.
+
+        exemples :
+
+        $$$ adate1 = Date(23, 1, 2024)
+        $$$ adate2 = Date(23, 1, 2024)
+        $$$ id(adate1) == id(adate2)
+        False
+        $$$ adate1 == adate2
+        True
+        """
+        return self.jour == other.jour and \
+            self.mois == other.mois and \
+            self.annee == other.annee
+    
+    def __lt__(self, other: 'Date') -> bool:
+        """
+        Renvoie True si, et seulement si, la date représentée par
+        self est avant celle représentée par other.
+
+        exemples :
+
+        $$$ adate1 = Date(23, 1, 2024)
+        $$$ adate2 = Date(25, 1, 2024)
+        $$$ adate1 < adate2
+        True
+        $$$ adate2 < adate1
+        False
+        $$$ adate1 < Date(23, 1, 2024)
+        False
+        """
+        if self.annee == other.annee:
+            if self.mois == other.mois:
+                res = self.jour < other.jour                    
+            else:
+                res = self.mois < other.mois    
+        else:
+            res = self.annee < other.annee
+        return res
+
+    def __le__(self, other: 'Date') -> bool:
+        """
+        Renvoie True si, et seulement si, la date représentée par
+        self est avant ou egale à celle représentée par other.
+
+        exemples :
+
+        $$$ adate1 = Date(23, 1, 2024)
+        $$$ adate2 = Date(25, 1, 2024)
+        $$$ adate1 <= adate2
+        True
+        $$$ adate2 <= adate1
+        False
+        $$$ adate1 <= Date(23, 1, 2024)
+        True
+        """
+        return self < other or self == other
+
+    def tomorrow(self) -> 'Date':
+        """
+        renvoie la date du lendemain.
+
+        $$$ Date(31, 12, 2023).tomorrow() == Date(1, 1, 2024)
+        True
+        $$$ Date(31, 1, 2024).tomorrow() == Date(1, 2, 2024)
+        True
+        $$$ Date(24, 1, 2024).tomorrow() == Date(25, 1, 2024)
+        True
+        """
+        annee = self.annee
+        mois = self.mois
+        jour = self.jour
+
+        if jour == nombre_de_jour_dans_mois(mois, annee):
+            jour = 1
+            if mois == 12:
+                annee = annee + 1
+                mois = 1
+            else:
+                mois = mois + 1
+        else:
+            jour = jour + 1
+        return Date(jour, mois, annee)
+
+    def __add__(self, njour: int) -> 'Date':
+        """
+        ajoute un nombre de jour à une date.
+
+        $$$ Date(31, 1, 24) + 7
+        Date(7, 2, 24)
+        """
+        res = self
+        for _ in range(njour):
+            res = res.tomorrow()
+        return res
+
+    def __sub__(self, other: 'Date') -> int:
+        """
+        Renvoie le nombre de jour entre deux dates.
+
+        $$$ Date(7, 2, 24) - Date(31, 1, 24)
+        7
+        """
+        if self <= other:
+            start, ending = self, other
+        else:
+            start, ending = other, self
+        res = 0
+        while start != ending:
+            start = start.tomorrow()
+            res = res + 1
+        return res
+
+
+if (__name__ == '__main__'):
+    import apl1test
+    apl1test.testmod('date.py')

tp.4/etudiants/etudiant.py

+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+
+"""
+:author: FIL - FST - Univ. Lille.fr <http://portail.fil.univ-lille.fr>_
+:date: janvier 2019
+:last revised: 
+:Fournit :
+"""
+from date import Date
+
+
+class Etudiant:
+    """
+    une classe représentant des étudiants.
+
+    $$$ etu = Etudiant(314159, 'Oléon', 'Tim', Date(7,11,2004), 'MI', '15')
+    $$$ str(etu)
+    'Tim Oléon'
+    $$$ repr(etu)
+    '314159 : Tim OLÉON'
+    $$$ etu.prenom
+    'Tim'
+    $$$ etu.nip
+    314159
+    $$$ etu.nom
+    'Oléon'
+    $$$ etu.formation
+    'MI'
+    $$$ etu.groupe
+    '15'
+    $$$ etu2 = Etudiant(314159, 'Oléon', 'Tim', Date(7,11,2004), 'MI', '15')
+    $$$ etu == etu2
+    True
+    $$$ etu3 = Etudiant(141442, 'Oléon', 'Tim', Date(7,11,2004), 'MI', '15')
+    $$$ etu == etu3
+    False
+    $$$ etu4 = Etudiant(141442, 'Calbuth', 'Raymond', Date(2,1,2005), 'MI', '11')
+    $$$ etu < etu4
+    True
+    $$$ isinstance(etu.naissance, Date)
+    True
+    """
+    def __init__(self, nip: int, nom: str, prenom: str,
+                 naissance: Date, formation: str, groupe: str):
+        """
+        initialise un nouvel étudiant à partir de son nip, son nom, son
+        prénom, sa formation et son groupe.
+
+        précondition : le nip, le nom et le prénom ne peuvent être nuls ou vides.
+        """
+        ...
+
+    def __eq__(self, other) -> bool:
+        """
+        Renvoie True ssi other est un étudiant ayant :
+        - même nip,
+        - même nom et
+        - même prénom que `self`,
+        et False sinon.
+        """
+        ...
+
+    def __lt__(self, other) -> bool:
+        """
+        Renvoie True si self est né avant other
+        """
+        ...
+
+    def __str__(self) -> str:
+        """
+        Renvoie une représentation textuelle de self.
+        """
+        ...
+
+    def __repr__(self) -> str:
+        """
+        Renvoie une représentation textuelle interne de self pour le shell.
+        """
+        ...
+
+if (__name__ == "__main__"):
+    import apl1test
+    apl1test.testmod('etudiant.py')

tp.4/etudiants/gestion_promo_etudiants.py

+#Angy Wallot
+#gestion_promo_etudiants
+#07/02/24
+
+def pour_tous(seq_bool: bool) -> bool:
+    """
+    Renvoie True ssi `seq_bool` ne contient pas False
+
+    Exemples:
+
+    $$$ pour_tous([])
+    True
+    $$$ pour_tous((True, True, True))
+    True
+    $$$ pour_tous((True, False, True))
+    False
+    """
+    for el in seq_bool:
+        if el == False:
+            return el
+    return True
+
+def il_existe(seq_bool: bool) -> bool:
+    """
+
+    Renvoie True si seq_bool contient au moins une valeur True, False sinon
+
+    Exemples:
+
+    $$$ il_existe([])
+    False
+    $$$ il_existe((False, True, False))
+    True
+    $$$ il_existe((False, False))
+    False
+    """
+    for el in seq_bool:
+        if el == True:
+            return el
+    return False