Feature/essaie game

Game_shooter/Essaie.py

@@ -0,0 +1,43 @@
+import pygame
+from pygame.locals import *
+
+
+class App:
+    def __init__(self):
+        self._running = True
+        self._display_surf = None
+        self.size = self.weight, self.height = 1280, 800
+
+    def on_init(self):
+        pygame.init()
+        self._display_surf = pygame.display.set_mode(self.size, pygame.HWSURFACE | pygame.DOUBLEBUF)
+        self._running = True
+
+    def on_event(self, event):
+        if event.type == pygame.QUIT:
+            self._running = False
+
+    def on_loop(self):
+        pass
+
+    def on_render(self):
+        pass
+
+    def on_cleanup(self):
+        pygame.quit()
+
+    def on_execute(self):
+        if self.on_init() == False:
+            self._running = False
+
+        while (self._running):
+            for event in pygame.event.get():
+                self.on_event(event)
+            self.on_loop()
+            self.on_render()
+        self.on_cleanup()
+
+
+if __name__ == "__main__":
+    theApp = App()
+    theApp.on_execute()

Game_shooter/ball_move.py

@@ -0,0 +1,25 @@
+import sys, pygame
+pygame.init()
+
+size = width, height = 400, 440
+speed = [1, 1]
+black = 0, 0, 0
+
+screen = pygame.display.set_mode(size)
+
+ball = pygame.image.load("intro_ball.gif")
+ballrect = ball.get_rect()
+
+while True:
+    for event in pygame.event.get():
+        if event.type == pygame.QUIT: sys.exit()
+
+    ballrect = ballrect.move(speed)
+    if ballrect.left < 0 or ballrect.right > width:
+        speed[0] = -speed[0]
+    if ballrect.top < 0 or ballrect.bottom > height:
+        speed[1] = -speed[1]
+
+    screen.fill(black)
+    screen.blit(ball, ballrect)
+    pygame.display.flip()

ICT-319/src/MathRequest.py

@@ -1,5 +1,3 @@
-from ICT_319.src.MathLib import MathLib
-
 class MathRequest:
 
     def __init__ (self, ope1, oper, ope2,):

ICT-319/test/test_sample.py

@@ -1,72 +1,26 @@
 import unittest
-from src.Math_Lib import MathLib
-from src.Math_Request import MathRequest
 
+from src.MathRequest import MathRequest
 
-class TestMathLib(unittest.TestCase):
+class TestMathRequest(unittest.TestCase):
 
     def setUp(self):
-        mathLib = MathLib()
+        self.ope1 = 3
+        self.operator = '+'
+        self.ope2 = 5
+        self.mathRequest = MathRequest(self.ope1, self.operator, self.ope2)
 
-    def test_execute_add_get_result(self):
-        #given
-        mathrequest = MathRequest(3, '+', 4)
+    def test_get_ope1(self):
+        self.assertEqual(self.ope1, self.mathRequest.get_ope1())
 
-        #when
-        MathLib.calculate(mathrequest)
+    def test_get_oper(self):
+        self.assertEqual( self.operator, self.mathRequest.get_operator())
 
-        #then
-        self.assertEqual(mathrequest.get_res(), 7)
+    def test_get_ope2(self):
+        self.assertEqual(self.ope2, self.mathRequest.get_ope2())
 
-    def test_execute_sub_get_result(self):
-        # given
-        mathrequest = MathRequest(3, '-', 4)
-
-        # when
-        MathLib.calculate(mathrequest)
-
-        # then
-        self.assertEqual(mathrequest.get_res(), -1)
-
-    def test_execute_mul_get_result(self):
-        # given
-        mathrequest = MathRequest(3, '*', 4)
-
-        # when
-        MathLib.calculate(mathrequest)
-
-        # then
-        self.assertEqual(mathrequest.get_res(), 12)
-
-    def test_execute_div_get_result(self):
-        # given
-        mathrequest = MathRequest(3, '/', 4)
-
-        # when
-        MathLib.calculate(mathrequest)
-
-        # then
-        self.assertEqual(mathrequest.get_res(), 0.75)
-
-    def test_execute_pow_get_result(self):
-        # given
-        mathrequest = MathRequest(3, '^', 81)
-
-        # when
-        MathLib.calculate(mathrequest)
-
-        # then
-        self.assertEqual(mathrequest.get_res(), )
-
-    def test_execute_root_get_result(self):
-        # given
-        mathrequest = MathRequest(3, '**', 4)
-
-        # when
-        MathLib.calculate(mathrequest)
-
-        # then
-        self.assertEqual(mathrequest.get_res(), 1.32)
+    def test_to_string(self):
+        self.assertEqual("3 + 5 = None", self.mathRequest.to_string())
 
 if __name__ == '__main__':
     unittest.main()

ICT-431/API_key.py

@@ -0,0 +1,14 @@
+import requests
+
+url = "http://10.229.33.64/rest/V1/integration/admin/token"
+data = {
+    "username": "API",
+    "password": "227227Ak!"
+}
+response = requests.post(url, json=data)
+
+if response.status_code == 200:
+    print("Jeton :", response.text)
+else:
+    print("Erreur :", response.status_code, response.text)
+

ICT114/ICT_114_Json/villes.json

@@ -0,0 +1,23 @@
+{
+  "villes" : [
+    {
+      "nom" : "",
+      "population": "",
+      "superficie": "",
+      "altitude": ""
+      },
+    {
+      "nom" : "",
+      "population": "",
+      "superficie": "",
+      "altitude": ""
+    },
+    {
+      "nom" : "",
+      "population": "",
+      "superficie": "",
+      "altitude": ""
+    }
+  ]
+}
+

ICT114/ICT_114_PYTHON/Hashage_package/HashLib.py

@@ -0,0 +1,71 @@
+import random
+
+from ICT114.ICT_114_PYTHON.Hashage_package.HashRequest import HashRequest
+
+class CardHash:
+    # constante définissant la langueur du numéro de carte attendu
+    card_number = None
+    card_length = 15
+
+    def __init__(self):
+        pass
+    @classmethod
+    def validate_card_number(cls, card_number):
+        """
+        vérifie si le numéro de carte est valide avec l'algorithme de Luhn.'
+        """
+        return len(cls.card_number) == cls.card_length and \
+        card_number.isdigit()
+    @classmethod
+    def calculate_luhn_last_digit(cls, card_number):
+        """
+        Calcule le dernier chiffre d'un numéro de carte
+        de crédit pour rendre valide avec l'algorithme de Luhn.
+        """
+        """
+        Étape 1 : Vérification de l'entrée
+        """
+        if not cls.validate_card_number(card_number):
+            return "Erreur: Entrez exactement 15 chiffres."
+        """
+        Étape 2 : Convertir la chaîne de caractères en une liste de chiffres
+        """
+        digits = [int(d) for d in cls.card_number]  # Chaque caractère devient un chiffre entier
+        """
+        Étape 3 : Appliquer l'algorithme de Luhn sur les 15 chiffres
+        """
+        checksum = cls.calculate_luhn_checksum(digits)
+        """
+        Étape 4 : Calculer le dernier chiffre (chiffre de contrôle)
+        """
+        # 1. Vérifie si le nombre est divisible par 10,2. Dit combien il manque pour faire 10 (donne le nombre manquant)3: vérifie que le nombre est compris entre 1-9.
+        last_digit = (10 - (checksum % 10)) % 10
+        return HashRequest.get_last_digit(last_digit, 2)
+
+    @staticmethod
+    def calculate_luhn_checksum(digits):
+        """
+        Applique l'algorithme de Luhn pour calculer le checksum.
+        """
+        checksum = 0    # Initialisation de la somme de contrôle
+        for i, digit in enumerate(reversed(digits)):  # On parcourt les chiffres de droite à gauche
+            if i % 2 == 0:  # Les positions paires (en partant de la droite)
+                digit *= 2  # Doubler le chiffre
+                if digit > 9:  # Si le double est supérieur à 9
+                    digit -= 9  # soustraire 9
+            checksum += digit # Ajouter le chiffre transformé ou brut à la somme de contrôle
+        return checksum
+
+class CardSelector:
+    card_length = CardHash.card_length
+
+    def __init__(self):
+        pass
+
+    @staticmethod
+    def generate_random_card_number(length=card_length):
+        """
+        Génère les 14 premiers chiffres d'un numéro de carte aléatoire.
+        """
+        return ''.join(str(random.randint(0, 9)) for _
+        in range(length))

ICT114/ICT_114_PYTHON/Hashage_package/HashRequest.py

@@ -0,0 +1,21 @@
+class HashRequest:
+    def __init__(self, user_input, choice=None):
+        self.user_input = user_input
+        self.choice = choice
+        self.card_number = user_input
+        self.last_digit = None
+
+    def get_user_input(self):
+        return self.user_input
+
+    def get_choice(self):
+        return self.choice
+
+    def get_card_number(self):
+        return self.card_number
+
+    def get_last_digit(self,digit_count):
+        if not self.card_number or len(self.card_number) < digit_count:
+            raise ValueError(f"Invalid card number must be at least 1{digit_count} digits long")
+        self.last_digit = self.card_number[-digit_count:]
+        return self.last_digit

ICT114/ICT_114_PYTHON/Hashage_package/Hashage.py

@@ -0,0 +1,67 @@
+from random import choice
+
+from ICT114.ICT_114_PYTHON.Hashage_package.HashRequest import HashRequest
+from ICT114.ICT_114_PYTHON.Hashage_package.HashLib import CardHash, CardSelector
+
+choice_manually = 'manuel'
+choice_auto = 'auto'
+
+def get_and_validate_user_choice():
+    """
+    Demande et valide le choix de l'utilisateur
+    """
+    while True:
+        user_input = input(
+            "Voulez-vous entrer vos 14 chiffres ou générer un numéro aléatoire ? "
+            f"(entrez '{choice_manually}' ou '{choice_auto}') : "
+        ).strip().lower()
+        if user_input in [choice_manually, choice_auto]:
+            return user_input
+        else:
+            print("Choix invalide. Veuillez réessayer.")
+
+def display_result(user_input ,result):
+
+    if isinstance(result, tuple):
+        complete_card = f"{user_input}{result[0]}{result[1]}"
+        print(f"Les deux derniers chiffres pour rendre le numéro valide sont : {result[0]}{result[1]}")
+        print(f"Numéro complet : {complete_card}")
+    else:
+        print(result)
+
+def get_card_number_input(user_choice):
+
+    if user_choice == 'manuel':
+        user_input = input("Entrez les 14 premiers chiffres de"
+        "votre numéro de carte de crédit : ")
+        return user_input
+    elif user_choice == 'auto':
+        user_input = CardSelector.generate_random_card_number()
+        print(f"Numéro aléatoire généré : {user_input}")
+        return user_input
+
+    else:
+        print("Choix invalide. Veuillez réessayer.")
+        return None
+
+def run_program():
+    """
+    Programme de génération au Luhn
+    """
+    print("Bienvenue dans le générateur de numéros conformes à Luhn !")
+
+    user_choice = get_and_validate_user_choice()
+
+
+    user_input = get_card_number_input(user_choice)
+
+    hash_request = HashRequest(
+        user_input=user_input,
+        choice=user_choice)
+
+    result = hash_request.get_last_digit(2)
+
+    display_result(user_input, result)
+
+if __name__ == "__main__":
+    run_program()

ICT114/ICT_114_PYTHON/Hashage_test/hashage_test.py

@@ -0,0 +1,20 @@
+import unittest
+
+from ICT114.ICT_114_PYTHON.Hashage_package.HashRequest import HashRequest
+
+class MyTestCase(unittest.TestCase):
+
+    def setUp(self):
+        self.user_input = "auto"
+        self.choice = "auto"
+        self.HashRequest = HashRequest(self.user_input)
+
+    def test_get_user_input(self):
+        self.assertEqual(self.user_input, self.HashRequest.get_user_input())
+
+    def test_get_choice(self):
+        self.assertEqual(self.choice, self.HashRequest.get_choice())# add assertion here
+
+
+if __name__ == '__main__':
+    unittest.main()