diff --git a/.gitignore b/.gitignore
index 2f6f1d2..9409915 100644
--- a/.gitignore
+++ b/.gitignore
@@ -5,3 +5,6 @@ dist/
 
 *.egg-info/
 __pycache__/
+
+.tox/
+.idea/
\ No newline at end of file
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
new file mode 100644
index 0000000..6352b24
--- /dev/null
+++ b/CONTRIBUTING.md
@@ -0,0 +1,50 @@
+## Contributing to Sigmoid_Check
+
+Welcome to the **Sigmoid_Check** repository! This guide outlines the process of contributing to our Python library, which automates homework verification. Please read and follow the steps carefully to ensure smooth collaboration.
+
+### 1. Access Permission
+This repository is private, and only those with the necessary permissions can access it. If you have access, you can create branches and make contributions.
+
+### 2. Working on a Ticket
+
+#### Step 1: Create a Branch
+1. Navigate to the **GitHub Projects** section where tickets are listed.
+2. Select the ticket you will be working on.
+3. Use the **Create Branch** button available within the ticket to automatically generate a branch with the correct name.
+4. Checkout the newly created branch locally using the following command:
+   ```bash
+   git checkout <branch_name>
+   ```
+
+#### Step 2: Implement Changes
+1. Make your changes locally on the checked-out branch.
+2. Ensure your code follows PEP 8 standards and is properly tested.
+
+### 3. Create a Pull Request (PR)
+1. Once your changes are implemented and tested, push your branch to the repository:
+   ```bash
+   git push origin <branch_name>
+   ```
+2. Navigate to GitHub and create a **Pull Request** (PR) from your branch.
+3. Assign **Eduard Balamatiuc** (`eduard-balamatiuc`) as the reviewer.
+4. If needed, add any additional reviewers requested by the team.
+
+### 4. Review and Update
+1. After submitting the PR, wait for the code review.
+2. Implement any feedback or changes requested by the reviewers.
+3. Once all changes are approved, the PR will be ready to merge.
+
+### 5. Merging the PR
+1. Once approved, merge the PR into the main branch.
+2. After merging, deployment to PyPi will need to be handled manually until we automate the process.
+
+### 6. PyPi Deployment
+1. Contact **Eduard Balamatiuc** (`eduard-balamatiuc`) to handle version updates and PyPi deployment.
+2. Ensure the version number is correctly updated to reflect the latest changes.
+
+### 7. Updating the Documentation
+If the deployment process is automated in the future, this documentation will be updated to reflect the changes. Please check back for any updates.
+
+---
+
+Thank you for contributing to **Sigmoid_Check**! We appreciate your effort in improving the project.
\ No newline at end of file
diff --git a/setup.cfg b/setup.cfg
index 224a779..0f94f37 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -1,2 +1,2 @@
 [metadata]
-description-file = README.md
\ No newline at end of file
+description_file = README.md
\ No newline at end of file
diff --git a/setup.py b/setup.py
index 3eb7006..aa0e0bb 100644
--- a/setup.py
+++ b/setup.py
@@ -26,4 +26,4 @@
         "Programming Language :: Python :: 3.10",
         "Operating System :: OS Independent"
     ],
-)
\ No newline at end of file
+)
diff --git a/sigmoid_check/__init__.py b/sigmoid_check/__init__.py
index f4ccb34..2d5201b 100644
--- a/sigmoid_check/__init__.py
+++ b/sigmoid_check/__init__.py
@@ -1 +1 @@
-from . import python_odyssey
\ No newline at end of file
+from . import python_odyssey
diff --git a/sigmoid_check/python_odyssey/__init__.py b/sigmoid_check/python_odyssey/__init__.py
index 40d60e6..f6702a6 100644
--- a/sigmoid_check/python_odyssey/__init__.py
+++ b/sigmoid_check/python_odyssey/__init__.py
@@ -3,4 +3,4 @@
 from .lesson_13.lesson import Lesson13
 from .lesson_14.lesson import Lesson14
 from .lesson_15.lesson import Lesson15
-from .lesson_16.lesson import Lesson16
\ No newline at end of file
+from .lesson_16.lesson import Lesson16
diff --git a/sigmoid_check/python_odyssey/lesson_10/__init__.py b/sigmoid_check/python_odyssey/lesson_10/__init__.py
index 69dcb45..4bdb67a 100644
--- a/sigmoid_check/python_odyssey/lesson_10/__init__.py
+++ b/sigmoid_check/python_odyssey/lesson_10/__init__.py
@@ -1 +1 @@
-from .lesson import Lesson10
\ No newline at end of file
+from .lesson import Lesson10
diff --git a/sigmoid_check/python_odyssey/lesson_10/lesson.py b/sigmoid_check/python_odyssey/lesson_10/lesson.py
index f029c88..1731dc9 100644
--- a/sigmoid_check/python_odyssey/lesson_10/lesson.py
+++ b/sigmoid_check/python_odyssey/lesson_10/lesson.py
@@ -1,8 +1,9 @@
 class Lesson10:
     "Test class for cheking the implementation of the tasks in lesson 10"
+
     def __init__(self):
         self.status_tasks = {f"task_{i}": False for i in range(1, 25)}
-    
+
     def check_task_1(self, func):
         """Task: Creați o funcție cu numele "task_1" care va returna o listă cu numerele de la 1 la 10
         Utilizați list comprehension."""
@@ -17,7 +18,7 @@ def check_task_1(self, func):
                 return "Exercise 1: Incorrect. Please try again."
         except Exception as e:
             return f"Exercise 1: Error - {e}"
-        
+
     def check_task_2(self, func):
         """Task: Creați o funcție cu numele "task_2" care va returna o listă cu pătratele numerelor de la 1 la 10.
         Utilizați list comprehension în proces"""
@@ -49,10 +50,10 @@ def check_task_3(self, func):
         except Exception as e:
             return f"Exercise 3: Error - {e}"
 
-
     def check_task_4(self, func):
-        """Task: Creați o funcție cu numele "task_4" care primind ca argument o matrice de liste precum [[1, 2], [3, 4], [5, 6]]
-        va returna o listă aplatizată sau altfel spus o listă cu elementele fiecărei liste , adică [1, 2, 3, 4, 5, 6]
+        """Task: Creați o funcție cu numele "task_4" care primind ca argument o matrice de liste precum [[1, 2], [3, 4],
+        [5, 6]] va returna o listă aplatizată sau altfel spus o listă cu elementele fiecărei liste
+        adică [1, 2, 3, 4, 5, 6]
         """
         matrix = [[1, 2], [3, 4], [5, 6]]
         expected_output = [num for row in matrix for num in row]
@@ -66,14 +67,16 @@ def check_task_4(self, func):
                 return "Exercise 1: Incorrect. Please try again."
         except Exception as e:
             return f"Exercise 4: Error - {e}"
-        
+
     def check_task_5(self, func):
-        """Task: Creați o funcție cu numele "task_5" care utilizând list comprehension va returna o listă care conține string-ul "par" sau "impar" pentru fiecare număr de la 1 până la 10.
+        """Task: Creați o funcție cu numele "task_5" care utilizând list comprehension va returna o listă care conține
+        string-ul "par" sau "impar" pentru fiecare număr de la 1 până la 10.
         Funcția va primi ca argument un număr n care va reprezenta numărul până la care se va face maparea.
-        Exemplu: Pentru n=10 rezultatul returnat va fi ["impar", "par", "impar", "par", "impar", "par", "impar", "par", "impar", "par"]
+        Exemplu: Pentru n=10 rezultatul returnat va fi
+        ["impar", "par", "impar", "par", "impar", "par", "impar", "par", "impar", "par"]
         """
         n = 10
-        expected_output = ["par" if i % 2 == 0 else "impar" for i in range(1, n+1)]
+        expected_output = ["par" if i % 2 == 0 else "impar" for i in range(1, n + 1)]
         try:
             student_output = func(n)
             if student_output == expected_output:
@@ -84,14 +87,15 @@ def check_task_5(self, func):
                 return "Exercise 1: Incorrect. Please try again."
         except Exception as e:
             return f"Exercise 5: Error - {e}"
-        
+
     def check_task_6(self, func):
-        """Task: Creați o funcție cu numele "task_6" care utilizând list comprehension va returna un dicționar care mappează fiecare număr de la 1 la 5 la cubul său.
+        """Task: Creați o funcție cu numele "task_6" care utilizând list comprehension va returna un dicționar care
+        mappează fiecare număr de la 1 la 5 la cubul său.
         Funcția va primi ca argument un număr n care va reprezenta numărul până la care se va face maparea.
         Exemplu: Pentru n=5 rezultatul returnat va fi {1: 1, 2: 8, 3: 27, 4: 64, 5: 125}
         """
         n = 5
-        expected_output = {i: i**3 for i in range(1, n+1)}
+        expected_output = {i: i**3 for i in range(1, n + 1)}
         try:
             student_output = func(n)
             if student_output == expected_output:
@@ -102,14 +106,15 @@ def check_task_6(self, func):
                 return "Exercise 1: Incorrect. Please try again."
         except Exception as e:
             return f"Exercise 6: Error - {e}"
-        
+
     def check_task_7(self, func):
-        """Task: Creați o funcție cu numele "task_7" care utilizând list comprehension va returna un set cu multiplii de 3 de la 1 la n, unde n este un argument al funcției.
+        """Task: Creați o funcție cu numele "task_7" care utilizând list comprehension va returna un set cu multiplii de
+        3 de la 1 la n, unde n este un argument al funcției.
         Funcția va primi ca argument un număr n care va reprezenta numărul până la care se va face maparea.
-        Exemplu: Pentru n=50 rezultatul returnat va fi {3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39, 42, 45, 48}       
+        Exemplu: Pentru n=50 rezultatul returnat va fi {3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39, 42, 45, 48}
         """
         n = 50
-        expected_output = {i for i in range(1, n+1) if i % 3 == 0}
+        expected_output = {i for i in range(1, n + 1) if i % 3 == 0}
         try:
             student_output = func(n)
             if student_output == expected_output:
@@ -122,7 +127,8 @@ def check_task_7(self, func):
             return f"Exercise 7: Error - {e}"
 
     def check_task_8(self, func):
-        """Task: Creați o funcție cu numele "task_8" care are ca argument o listă de numere și va returna media aritmetică a numerelor din listă.
+        """Task: Creați o funcție cu numele "task_8" care are ca argument o listă de numere și va returna media
+        aritmetică a numerelor din listă.
         Exemplu: Pentru lista [1, 2, 3, 4, 5] rezultatul va fi 3.0
         """
         numbers = [1, 2, 3, 4, 5]
@@ -137,9 +143,10 @@ def check_task_8(self, func):
                 return "Exercise 1: Incorrect. Please try again."
         except Exception as e:
             return f"Exercise 8: Error - {e}"
-        
+
     def check_task_9(self, func):
-        """Task: Creați o funcție cu numele "task_9" care are ca argument un număr și va returna `True` dacă numărul este par, altfel `False`.
+        """Task: Creați o funcție cu numele "task_9" care are ca argument un număr și va returna `True` dacă numărul
+        este par, altfel `False`.
         Exemplu: Pentru numărul 4 rezultatul va fi `True`, iar pentru numărul 5 rezultatul va fi `False`.
         """
         number_1 = 4
@@ -157,11 +164,13 @@ def check_task_9(self, func):
                 return "Exercise 1: Incorrect. Please try again."
         except Exception as e:
             return f"Exercise 9: Error - {e}"
-        
+
     def check_task_10(self, func):
-        """Task: Creați o funcție cu numele "task_10" care are ca argument numele și vârsta unei persoane ca argumente poziționale și orașul ca un argument opțional,
+        """Task: Creați o funcție cu numele "task_10" care are ca argument numele și vârsta unei persoane ca argumente
+        poziționale și orașul ca un argument opțional,
         apoi returnează o descriere a persoanei în forma "Nume: *nume*, Varsta: *varsta*, Oras: *oras*".
-        Exemplu: Pentru numele "Ana", vârsta 32 și orașul "București" rezultatul va fi "Nume: Ana, Varsta: 32, Oras: București"
+        Exemplu: Pentru numele "Ana", vârsta 32 și orașul "București" rezultatul va fi "Nume: Ana, Varsta: 32,
+        Oras: București"
         """
         name = "Ana"
         age = 32
@@ -177,9 +186,10 @@ def check_task_10(self, func):
                 return "Exercise 1: Incorrect. Please try again."
         except Exception as e:
             return f"Exercise 10: Error - {e}"
-        
+
     def check_task_11(self, func):
-        """Task: Creați o funcție cu numele "task_11" care acceptă o listă variabilă de numere și returnează valoarea maximă.
+        """Task: Creați o funcție cu numele "task_11" care acceptă o listă variabilă de numere și returnează valoarea
+        maximă.
         Exemplu: Pentru lista [10, 20, 30, 40, 50] rezultatul va fi 50
         """
         numbers = [10, 20, 30, 40, 50]
@@ -194,7 +204,7 @@ def check_task_11(self, func):
                 return "Exercise 1: Incorrect. Please try again."
         except Exception as e:
             return f"Exercise 11: Error - {e}"
-        
+
     def check_task_12(self, func):
         """Task: Creați o funcție cu numele "task_12" care acceptă un număr și returnează factorialul său.
         Exemplu: Pentru numărul 5 rezultatul va fi 120
@@ -211,7 +221,7 @@ def check_task_12(self, func):
                 return "Exercise 1: Incorrect. Please try again."
         except Exception as e:
             return f"Exercise 12: Error - {e}"
-        
+
     def check_task_13(self, func):
         """Task: Creați o funcție cu numele "task_13" care acceptă două numere și returnează suma și produsul lor.
         Exemplu: Pentru numerele 3 și 4 rezultatul va fi (7, 12)
@@ -229,9 +239,11 @@ def check_task_13(self, func):
                 return "Exercise 1: Incorrect. Please try again."
         except Exception as e:
             return f"Exercise 13: Error - {e}"
-        
+
     def check_task_14(self, func):
-        """Task: Creați o funcție cu numele "task_14" care acceptă un număr ce reprezintă vârsta unei persoane și returnează textul "minor" dacă vârsta este sub 18 ani, "adult" dacă vârsta este între 18 și 65 ani și "senior" dacă vârsta este peste 65 de ani.
+        """Task: Creați o funcție cu numele "task_14" care acceptă un număr ce reprezintă vârsta unei persoane și
+        returnează textul "minor" dacă vârsta este sub 18 ani, "adult" dacă vârsta este între 18 și 65 ani și "senior"
+        dacă vârsta este peste 65 de ani.
         Exemplu: Pentru vârsta 32 rezultatul va fi "adult"
         """
         age_1 = 65
@@ -244,7 +256,11 @@ def check_task_14(self, func):
             student_output_1 = func(age_1)
             student_output_2 = func(age_2)
             student_output_3 = func(age_3)
-            if student_output_1 == expected_output_1 and student_output_2 == expected_output_2 and student_output_3 == expected_output_3:
+            if (
+                student_output_1 == expected_output_1
+                and student_output_2 == expected_output_2
+                and student_output_3 == expected_output_3
+            ):
                 self.status_tasks["task_14"] = True
                 return "Exercise 1: Correct! Well done."
             else:
@@ -252,9 +268,10 @@ def check_task_14(self, func):
                 return "Exercise 1: Incorrect. Please try again."
         except Exception as e:
             return f"Exercise 14: Error - {e}"
-        
+
     def check_task_15(self, func):
-        """Task: Creați o funcție cu numele "task_15" care acceptă un string și returnează `True` dacă string-ul este un palindrom, altfel `False`.
+        """Task: Creați o funcție cu numele "task_15" care acceptă un string și returnează `True` dacă string-ul este
+        un palindrom, altfel `False`.
         Exemplu: Pentru string-ul "ana" rezultatul va fi `True`, iar pentru string-ul "test" rezultatul va fi `False`.
         """
         string_1 = "ana"
@@ -272,9 +289,10 @@ def check_task_15(self, func):
                 return "Exercise 1: Incorrect. Please try again."
         except Exception as e:
             return f"Exercise 15: Error - {e}"
-        
+
     def check_task_16(self, func):
-        """Task: Creați o funcție cu numele "task_16" care acceptă un string și returnează același string cu literele inversate.
+        """Task: Creați o funcție cu numele "task_16" care acceptă un string și returnează același string
+        cu literele inversate.
         Exemplu: Pentru string-ul "test" rezultatul va fi "tset"
         """
         string = "test"
@@ -289,9 +307,10 @@ def check_task_16(self, func):
                 return "Exercise 1: Incorrect. Please try again."
         except Exception as e:
             return f"Exercise 16: Error - {e}"
-        
+
     def check_task_17(self, func):
-        """Task: Creați o funcție cu numele "task_17" care acceptă un string și returnează numărul de cuvinte din string.
+        """Task: Creați o funcție cu numele "task_17" care acceptă un string și returnează numărul
+        de cuvinte din string.
         Exemplu: Pentru string-ul "Hello, World!" rezultatul va fi 2
         """
         string = "Hello, World!"
@@ -306,9 +325,10 @@ def check_task_17(self, func):
                 return "Exercise 1: Incorrect. Please try again."
         except Exception as e:
             return f"Exercise 17: Error - {e}"
-        
+
     def check_task_18(self, func):
-        """Task: Creați o funcție cu numele "task_18" care acceptă un număr ce reprezintă temperatura în grade Celsius și returnează temperatura în grade Fahrenheit.
+        """Task: Creați o funcție cu numele "task_18" care acceptă un număr ce reprezintă temperatura în grade Celsius
+        și returnează temperatura în grade Fahrenheit.
         Exemplu: Pentru temperatura 0 rezultatul va fi 32.0
         """
         celsius = 0
@@ -323,9 +343,10 @@ def check_task_18(self, func):
                 return "Exercise 1: Incorrect. Please try again."
         except Exception as e:
             return f"Exercise 18: Error - {e}"
-        
+
     def check_task_19(self, func):
-        """Task: Creați o funcție cu numele "task_19" care acceptă un număr și returnează `True` dacă numărul este prim, altfel `False`.
+        """Task: Creați o funcție cu numele "task_19" care acceptă un număr și returnează `True` dacă numărul este prim,
+         altfel `False`.
         Exemplu: Pentru numărul 7 rezultatul va fi `True`, iar pentru numărul 10 rezultatul va fi `False`.
         """
         number_1 = 7
@@ -343,9 +364,10 @@ def check_task_19(self, func):
                 return "Exercise 1: Incorrect. Please try again."
         except Exception as e:
             return f"Exercise 19: Error - {e}"
-        
+
     def check_task_20(self, func):
-        """Task: Creați o funcție cu numele "task_20" care acceptă un număr și returnează `True` dacă numărul este un număr perfect, altfel `False`.
+        """Task: Creați o funcție cu numele "task_20" care acceptă un număr și returnează `True` dacă numărul este un
+        număr perfect, altfel `False`.
         Un număr perfect este un număr întreg pozitiv care este egal cu suma divizorilor săi, excluzând numărul însuși.
         Exemplu: Pentru numărul 28 rezultatul va fi `True`, iar pentru numărul 10 rezultatul va fi `False`.
         """
@@ -364,9 +386,10 @@ def check_task_20(self, func):
                 return "Exercise 1: Incorrect. Please try again."
         except Exception as e:
             return f"Exercise 20: Error - {e}"
-        
+
     def check_task_21(self, func):
-        """Task: Creați o funcție cu numele "task_21" care acceptă un număr și returnează `True` dacă numărul este un număr Armstrong, altfel `False`.
+        """Task: Creați o funcție cu numele "task_21" care acceptă un număr și returnează `True` dacă numărul este un
+        număr Armstrong, altfel `False`.
         Un număr Armstrong este un număr care este egal cu suma puterilor sale de cifre.
         Exemplu: Pentru numărul 153 rezultatul va fi `True`, iar pentru numărul 10 rezultatul va fi `False`.
         """
@@ -385,9 +408,10 @@ def check_task_21(self, func):
                 return "Exercise 1: Incorrect. Please try again."
         except Exception as e:
             return f"Exercise 21: Error - {e}"
-        
+
     def check_task_22(self, func):
-        """Task: Creați o funcție cu numele "task_22" care acceptă un număr și returnează `True` dacă numărul este un număr Harshad, altfel `False`.
+        """Task: Creați o funcție cu numele "task_22" care acceptă un număr și returnează `True` dacă numărul este un
+        număr Harshad, altfel `False`.
         Un număr Harshad este un număr care este divizibil cu suma cifrelor sale.
         Exemplu: Pentru numărul 18 rezultatul va fi `True`, iar pentru numărul 14 rezultatul va fi `False`.
         """
@@ -406,9 +430,10 @@ def check_task_22(self, func):
                 return "Exercise 1: Incorrect. Please try again."
         except Exception as e:
             return f"Exercise 22: Error - {e}"
-        
+
     def check_task_23(self, func):
-        """Task: Creați o funcție cu numele "task_23" care primește ca argument un număr și returneaeză o listă cu primele n numere ale seriei Fibonacci.
+        """Task: Creați o funcție cu numele "task_23" care primește ca argument un număr și returneaeză o listă cu
+        primele n numere ale seriei Fibonacci.
         Exemplu: Pentru numărul 5 rezultatul va fi [0, 1, 1, 2, 3]
         """
         number = 5
@@ -423,9 +448,10 @@ def check_task_23(self, func):
                 return "Exercise 1: Incorrect. Please try again."
         except Exception as e:
             return f"Exercise 23: Error - {e}"
-        
+
     def check_task_24(self, func):
-        """Task: Creați o funcție cu numele "task_24" care primește ca argument un număr și returnează o listă cu divizorii numărului respectiv.
+        """Task: Creați o funcție cu numele "task_24" care primește ca argument un număr și returnează o listă cu
+        divizorii numărului respectiv.
         Exemplu: Pentru numărul 10 rezultatul va fi [1, 2, 5, 10]
         """
         number = 10
@@ -441,8 +467,7 @@ def check_task_24(self, func):
         except Exception as e:
             return f"Exercise 24: Error - {e}"
 
-
     def get_completion_percentage(self):
         """Return the completion percentage of the tasks"""
         completed = sum([1 for task in self.status_tasks if self.status_tasks[task]])
-        return f"Your completion percentage is {completed * 100 / len(self.status_tasks)}%"
\ No newline at end of file
+        return f"Your completion percentage is {completed * 100 / len(self.status_tasks)}%"
diff --git a/sigmoid_check/python_odyssey/lesson_11/__init__.py b/sigmoid_check/python_odyssey/lesson_11/__init__.py
index f9b1795..b51ed25 100644
--- a/sigmoid_check/python_odyssey/lesson_11/__init__.py
+++ b/sigmoid_check/python_odyssey/lesson_11/__init__.py
@@ -1 +1 @@
-from .lesson import Lesson11
\ No newline at end of file
+from .lesson import Lesson11
diff --git a/sigmoid_check/python_odyssey/lesson_11/lesson.py b/sigmoid_check/python_odyssey/lesson_11/lesson.py
index 5204307..e5bc6fd 100644
--- a/sigmoid_check/python_odyssey/lesson_11/lesson.py
+++ b/sigmoid_check/python_odyssey/lesson_11/lesson.py
@@ -1,7 +1,9 @@
 class Task1:
-    """Task: Creați o funcție cu numele `task_1` care poate primi un număr variabil de argumente și returnează suma acestora.
+    """Task: Creați o funcție cu numele `task_1` care poate primi un număr variabil de argumente și returnează
+    suma acestora.
     Exemplu: task_1(1, 2, 3) ➞ 6
     """
+
     def __init__(self, func):
         self.func = func
 
@@ -19,15 +21,17 @@ def check_task(self):
 
 
 class Task2:
-    """Task: Creați o funcție cu numele `task_2` care primește un număr variabil de argumente și returnează o listă cu argumentele care sunt numere întregi.
+    """Task: Creați o funcție cu numele `task_2` care primește un număr variabil de argumente și returnează o listă
+    cu argumentele care sunt numere întregi.
     Exemplu: task_2(1, 2, 'a', 'b') ➞ [1, 2]
     """
+
     def __init__(self, func):
         self.func = func
 
     def check_task(self):
         try:
-            assert self.func(1, 2, 'a', 'b') == [1, 2]
+            assert self.func(1, 2, "a", "b") == [1, 2]
             assert self.func(1, 2, 3, 4, 5) == [1, 2, 3, 4, 5]
             assert self.func(1, 2, 3, 4, 5, 6, 7, 8, 9, 10) == [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
             assert self.func("a", "b", "c", "d", "e") == []
@@ -41,9 +45,11 @@ def check_task(self):
 
 
 class Task3:
-    """Task: Creați o funcție cu numele `task_3` care poate primi un număr variabil de argumente și va returna produsul acesora.
+    """Task: Creați o funcție cu numele `task_3` care poate primi un număr variabil de argumente și va returna
+    produsul acesora.
     Exemplu: task_3(1, 4, 5) ➞ 20
     """
+
     def __init__(self, func):
         self.func = func
 
@@ -62,47 +68,55 @@ def check_task(self):
 
 
 class Task4:
-    """Task: Creați o funcție cu numele `task_4` care primește un număr arbitrar de perechi cheie-valoare și returnează un string care conține toate cheile și valorile concatenate separate de un spațiu.
+    """Task: Creați o funcție cu numele `task_4` care primește un număr arbitrar de perechi cheie-valoare și returnează
+    un string care conține toate cheile și valorile concatenate separate de un spațiu.
     Exemplu: task_4(a=1, b=2, c=3) ➞ 'a 1 b 2 c 3'
     """
+
     def __init__(self, func):
         self.func = func
 
     def check_task(self):
         try:
-            assert self.func(a=1, b=2, c=3) == 'a 1 b 2 c 3'
-            assert self.func(a=1) == 'a 1'
-            assert self.func(a=1, b=2, c=3, d=4, e=5) == 'a 1 b 2 c 3 d 4 e 5'
-            assert self.func(ciao=1, bella=2, come=3, stai=4) == 'ciao 1 bella 2 come 3 stai 4'
-            assert self.func(a=1, b=2, c=3, d=4, e=5, f=6, g=7, h=8, i=9, j=10) == 'a 1 b 2 c 3 d 4 e 5 f 6 g 7 h 8 i 9 j 10'
-            assert self.func(a_2=1, b_2=2, c_2=3, d_2=4, e_2=5) == 'a_2 1 b_2 2 c_2 3 d_2 4 e_2 5'
+            assert self.func(a=1, b=2, c=3) == "a 1 b 2 c 3"
+            assert self.func(a=1) == "a 1"
+            assert self.func(a=1, b=2, c=3, d=4, e=5) == "a 1 b 2 c 3 d 4 e 5"
+            assert self.func(ciao=1, bella=2, come=3, stai=4) == "ciao 1 bella 2 come 3 stai 4"
+            assert (
+                self.func(a=1, b=2, c=3, d=4, e=5, f=6, g=7, h=8, i=9, j=10)
+                == "a 1 b 2 c 3 d 4 e 5 f 6 g 7 h 8 i 9 j 10"
+            )
+            assert self.func(a_2=1, b_2=2, c_2=3, d_2=4, e_2=5) == "a_2 1 b_2 2 c_2 3 d_2 4 e_2 5"
             return True
         except:
             return False
 
 
 class Task5:
-    """Task: Creați o funcție cu numele `task_5` care primește un număr variabil de argumente și returnează două liste separate.
-    Prima listă conține toate argumentele de tip întreg sortate în ordine crescătoare, iar a doua listă conține denumirea tuturor argumentelor keyword care sunt de tip string sortate în ordine alfabetică.
+    """Task: Creați o funcție cu numele `task_5` care primește un număr variabil de argumente și returnează
+    două liste separate.
+    Prima listă conține toate argumentele de tip întreg sortate în ordine crescătoare, iar a doua listă conține
+    denumirea tuturor argumentelor keyword care sunt de tip string sortate în ordine alfabetică.
     Exemplu: task_6(3, 1, 2, a=10, b=20) ➞ [1, 2, 3], []
     Exemplu: task_6(3, 1, 2, a=10, b=20, c='a') ➞ [1, 2, 3], ['c']
     Exemplu: task_6(3, 1, 2, a=10, b=20, c='a', d='b') ➞ [1, 2, 3], ['c', 'd']
     """
+
     def __init__(self, func):
         self.func = func
 
     def check_task(self):
         try:
             assert self.func(3, 1, 2, a=10, b=20) == ([1, 2, 3], [])
-            assert self.func(3, 1, 2, a=10, b=20, c='a') == ([1, 2, 3], ['c'])
-            assert self.func(3, 1, 2, a=10, b=20, c='a', d='b') == ([1, 2, 3], ['c', 'd'])
-            assert self.func(3, 1, 2, a=10, b=20, c='a', d='b', e=30) == ([1, 2, 3], ['c', 'd'])
-            assert self.func(3, 1, 2, a=10, b=20, c='a', d='b', e=30, f='c') == ([1, 2, 3], ['c', 'd', 'f'])
-            assert self.func(3, 1, 2, a=10, b=20, c='a', d='b', e=30, f='c', g='d') == ([1, 2, 3], ['c', 'd', 'f', 'g'])
-            assert self.func(a=10, b=20, c='a', d='b', e=30, f='c', g='d') == ([], ['c', 'd', 'f', 'g'])
-            assert self.func(a=10, b=20, c='a', d='b', e=30) == ([], ['c', 'd'])
-            assert self.func(a=10, b=20, c='a', d='b') == ([], ['c', 'd'])
-            assert self.func(a=10, b=20, c='a') == ([], ['c'])
+            assert self.func(3, 1, 2, a=10, b=20, c="a") == ([1, 2, 3], ["c"])
+            assert self.func(3, 1, 2, a=10, b=20, c="a", d="b") == ([1, 2, 3], ["c", "d"])
+            assert self.func(3, 1, 2, a=10, b=20, c="a", d="b", e=30) == ([1, 2, 3], ["c", "d"])
+            assert self.func(3, 1, 2, a=10, b=20, c="a", d="b", e=30, f="c") == ([1, 2, 3], ["c", "d", "f"])
+            assert self.func(3, 1, 2, a=10, b=20, c="a", d="b", e=30, f="c", g="d") == ([1, 2, 3], ["c", "d", "f", "g"])
+            assert self.func(a=10, b=20, c="a", d="b", e=30, f="c", g="d") == ([], ["c", "d", "f", "g"])
+            assert self.func(a=10, b=20, c="a", d="b", e=30) == ([], ["c", "d"])
+            assert self.func(a=10, b=20, c="a", d="b") == ([], ["c", "d"])
+            assert self.func(a=10, b=20, c="a") == ([], ["c"])
             assert self.func(a=10, b=20) == ([], [])
             assert self.func(a=10) == ([], [])
             assert self.func() == ([], [])
@@ -112,75 +126,115 @@ def check_task(self):
 
 
 class Task6:
-    """Task: Creați o funcție cu numele `task_6` care primește un număr variabil de argumente și returnează un dicționar care conține toate argumentele keyword ca key și valoarea acestora ca value.
+    """Task: Creați o funcție cu numele `task_6` care primește un număr variabil de argumente și returnează
+    un dicționar care conține toate argumentele keyword ca key și valoarea acestora ca value.
     Exemplu: task_6(a=1, b=2, c=3) ➞ {'a': 1, 'b': 2, 'c': 3}
     """
+
     def __init__(self, func):
         self.func = func
 
     def check_task(self):
         try:
-            assert self.func(a=1, b=2, c=3) == {'a': 1, 'b': 2, 'c': 3}
-            assert self.func(a=1) == {'a': 1}
-            assert self.func(a=1, b=2, c=3, d=4, e=5) == {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
-            assert self.func(ciao=1, bella=2, come=3, stai=4) == {'ciao': 1, 'bella': 2, 'come': 3, 'stai': 4}
-            assert self.func(a=1, b=2, c=3, d=4, e=5, f=6, g=7, h=8, i=9, j=10) == {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6, 'g': 7, 'h': 8, 'i': 9, 'j': 10}
-            assert self.func(a_2=1, b_2=2, c_2=3, d_2=4, e_2=5) == {'a_2': 1, 'b_2': 2, 'c_2': 3, 'd_2': 4, 'e_2': 5}
+            assert self.func(a=1, b=2, c=3) == {"a": 1, "b": 2, "c": 3}
+            assert self.func(a=1) == {"a": 1}
+            assert self.func(a=1, b=2, c=3, d=4, e=5) == {"a": 1, "b": 2, "c": 3, "d": 4, "e": 5}
+            assert self.func(ciao=1, bella=2, come=3, stai=4) == {"ciao": 1, "bella": 2, "come": 3, "stai": 4}
+            assert self.func(a=1, b=2, c=3, d=4, e=5, f=6, g=7, h=8, i=9, j=10) == {
+                "a": 1,
+                "b": 2,
+                "c": 3,
+                "d": 4,
+                "e": 5,
+                "f": 6,
+                "g": 7,
+                "h": 8,
+                "i": 9,
+                "j": 10,
+            }
+            assert self.func(a_2=1, b_2=2, c_2=3, d_2=4, e_2=5) == {"a_2": 1, "b_2": 2, "c_2": 3, "d_2": 4, "e_2": 5}
             return True
         except:
             return False
 
 
 class Task7:
-    """Task: Creați o funcție cu numele `task_7` care poate primi un număr nedeterminat de argumente atât string-uri cât și numere și va returna un dicționar cu două chei: `str` și `int`.
-    Cheia `str` va avea o listă cu toate string-urile primite ca argumente, iar cheia `int` va avea o listă cu toate numerele primite ca argumente.
+    """Task: Creați o funcție cu numele `task_7` care poate primi un număr nedeterminat de argumente atât string-uri
+    cât și numere și va returna un dicționar cu două chei: `str` și `int`.
+    Cheia `str` va avea o listă cu toate string-urile primite ca argumente, iar cheia `int` va avea o listă cu toate
+    numerele primite ca argumente.
     Exemplu: task_7(1, 'a', 2, 'b') ➞ {'str': ['a', 'b'], 'int': [1, 2]}
     """
+
     def __init__(self, func):
         self.func = func
 
     def check_task(self):
         try:
-            assert self.func(1, 'a', 2, 'b') == {'str': ['a', 'b'], 'int': [1, 2]}
-            assert self.func(1, 'a', 2, 'b', 3, 'c') == {'str': ['a', 'b', 'c'], 'int': [1, 2, 3]}
-            assert self.func(1, 'a', 2, 'b', 3, 'c', 4, 'd') == {'str': ['a', 'b', 'c', 'd'], 'int': [1, 2, 3, 4]}
-            assert self.func(1, 'a', 2, 'b', 3, 'c', 4, 'd', 5, 'e') == {'str': ['a', 'b', 'c', 'd', 'e'], 'int': [1, 2, 3, 4, 5]}
-            assert self.func() == {'str': [], 'int': []}
-            assert self.func(1, 2, 3, 4, 5) == {'str': [], 'int': [1, 2, 3, 4, 5]}
-            assert self.func('a', 'b', 'c', 'd', 'e') == {'str': ['a', 'b', 'c', 'd', 'e'], 'int': []}
+            assert self.func(1, "a", 2, "b") == {"str": ["a", "b"], "int": [1, 2]}
+            assert self.func(1, "a", 2, "b", 3, "c") == {"str": ["a", "b", "c"], "int": [1, 2, 3]}
+            assert self.func(1, "a", 2, "b", 3, "c", 4, "d") == {"str": ["a", "b", "c", "d"], "int": [1, 2, 3, 4]}
+            assert self.func(1, "a", 2, "b", 3, "c", 4, "d", 5, "e") == {
+                "str": ["a", "b", "c", "d", "e"],
+                "int": [1, 2, 3, 4, 5],
+            }
+            assert self.func() == {"str": [], "int": []}
+            assert self.func(1, 2, 3, 4, 5) == {"str": [], "int": [1, 2, 3, 4, 5]}
+            assert self.func("a", "b", "c", "d", "e") == {"str": ["a", "b", "c", "d", "e"], "int": []}
             return True
         except:
             return False
 
 
 class Task8:
-    """Task: Creați o funcție cu numele `task_8` care primește un număr variabil de argumente și returnează un dicționar cu două chei: `palindrom` și `non_palindrom`.
-    Cheia `palindrom` va avea o listă cu toate argumentele care sunt palindroame, iar cheia `non_palindrom` va avea o listă cu toate argumentele care nu sunt palindroame.
-    Exemplu: task_8('madam', 'hello', 'level', 'world') ➞ {'palindrom': ['madam', 'level'], 'non_palindrom': ['hello', 'world']}
+    """Task: Creați o funcție cu numele `task_8` care primește un număr variabil de argumente și returnează un dicționar
+    cu două chei: `palindrom` și `non_palindrom`.
+    Cheia `palindrom` va avea o listă cu toate argumentele care sunt palindroame, iar cheia `non_palindrom` va avea
+    o listă cu toate argumentele care nu sunt palindroame.
+    Exemplu: task_8('madam', 'hello', 'level', 'world') ➞ {'palindrom': ['madam', 'level'],
+    'non_palindrom': ['hello', 'world']}
     """
+
     def __init__(self, func):
         self.func = func
 
     def check_task(self):
         try:
-            assert self.func('madam', 'hello', 'level', 'world') == {'palindrom': ['madam', 'level'], 'non_palindrom': ['hello', 'world']}
-            assert self.func('madam', 'hello', 'level', 'world', 'civic') == {'palindrom': ['madam', 'level', 'civic'], 'non_palindrom': ['hello', 'world']}
-            assert self.func('madam', 'hello', 'level', 'world', 'civic', 'radar') == {'palindrom': ['madam', 'level', 'civic', 'radar'], 'non_palindrom': ['hello', 'world']}
-            assert self.func("cai", "ciao", "bella", "come", "stai") == {'palindrom': [], 'non_palindrom': ['cai', 'ciao', 'bella', 'come', 'stai']}
-            assert self.func("cai", "ciao", "bella", "come", "stai", "radar") == {'palindrom': ['radar'], 'non_palindrom': ['cai', 'ciao', 'bella', 'come', 'stai']}
-            assert self.func("", "") == {'palindrom': ["", ""], 'non_palindrom': []}
-            assert self.func("a", "b") == {'palindrom': ['a', 'b'], 'non_palindrom': []}
-            assert self.func() == {'palindrom': [], 'non_palindrom': []}
+            assert self.func("madam", "hello", "level", "world") == {
+                "palindrom": ["madam", "level"],
+                "non_palindrom": ["hello", "world"],
+            }
+            assert self.func("madam", "hello", "level", "world", "civic") == {
+                "palindrom": ["madam", "level", "civic"],
+                "non_palindrom": ["hello", "world"],
+            }
+            assert self.func("madam", "hello", "level", "world", "civic", "radar") == {
+                "palindrom": ["madam", "level", "civic", "radar"],
+                "non_palindrom": ["hello", "world"],
+            }
+            assert self.func("cai", "ciao", "bella", "come", "stai") == {
+                "palindrom": [],
+                "non_palindrom": ["cai", "ciao", "bella", "come", "stai"],
+            }
+            assert self.func("cai", "ciao", "bella", "come", "stai", "radar") == {
+                "palindrom": ["radar"],
+                "non_palindrom": ["cai", "ciao", "bella", "come", "stai"],
+            }
+            assert self.func("", "") == {"palindrom": ["", ""], "non_palindrom": []}
+            assert self.func("a", "b") == {"palindrom": ["a", "b"], "non_palindrom": []}
+            assert self.func() == {"palindrom": [], "non_palindrom": []}
             return True
         except:
             return False
 
 
 class Task9:
-    """Task: Creați o funcție cu numele `task_9` care primește un număr variabil de argumente de tip integer și un argument `number` de tip integer.
+    """Task: Creați o funcție cu numele `task_9` care primește un număr variabil de argumente de tip integer și
+    un argument `number` de tip integer.
     Funcția va returna toate argumentele care sunt multipli ai lui `number`.
     Exemplu: task_9(1, 2, 3, 4, 5, number=2) ➞ [2, 4]
     """
+
     def __init__(self, func):
         self.func = func
 
@@ -199,10 +253,12 @@ def check_task(self):
 
 
 class Task10:
-    """Task: Creați o funcție cu numele `task_10` care primește un număr variabil de argumente de tip integer și un argument `number` de tip integer.
+    """Task: Creați o funcție cu numele `task_10` care primește un număr variabil de argumente de tip integer și
+    un argument `number` de tip integer.
     Funcția va returna toate argumentele care sunt divizibile cu `number`.
     Exemplu: task_10(1, 2, 3, 4, 5, number=2) ➞ [2, 4]
     """
+
     def __init__(self, func):
         self.func = func
 
@@ -221,25 +277,27 @@ def check_task(self):
 
 
 class Task11:
-    """Task: Creați o funcție cu numele `task_11` care primește un număr variabil de argumente de tip integer care reprezintă șirul Fibonacci.
+    """Task: Creați o funcție cu numele `task_11` care primește un număr variabil de argumente de tip integer
+    care reprezintă șirul Fibonacci.
     Funcția va returna valoarea True dacă șirul Fibonacci este corect și False în caz contrar.
     Exemplu: task_11(1, 1, 2, 3, 5, 8) ➞ True
     Exemplu: task_11(1, 1, 2, 3, 5, 9) ➞ False
     """
+
     def __init__(self, func):
         self.func = func
 
     def check_task(self):
         try:
-            assert self.func(1, 1, 2, 3, 5, 8) == True
-            assert self.func(1, 1, 2, 3, 5, 9) == False
-            assert self.func(1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144) == True
-            assert self.func(1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 145) == False
-            assert self.func(1, 2, 34 , 55, 89, 144) == False
-            assert self.func(1, 1) == True
-            assert self.func(1, 1, 3) == False
-            assert self.func(0) == False
-            assert self.func() == False
+            assert self.func(1, 1, 2, 3, 5, 8) is True
+            assert self.func(1, 1, 2, 3, 5, 9) is False
+            assert self.func(1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144) is True
+            assert self.func(1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 145) is False
+            assert self.func(1, 2, 34, 55, 89, 144) is False
+            assert self.func(1, 1) is True
+            assert self.func(1, 1, 3) is False
+            assert self.func(0) is False
+            assert self.func() is False
             return True
         except:
             return False
@@ -251,65 +309,75 @@ class Task12:
     Exemplu: task_12(2, 3, 5, 7) ➞ True
     Exemplu: task_12(1, 2, 3, 4) ➞ False
     """
+
     def __init__(self, func):
         self.func = func
 
     def check_task(self):
         try:
-            assert self.func(2, 3, 5, 7) == True
-            assert self.func(1, 2, 3, 4) == False
-            assert self.func(1, 2, 3, 4, 5, 6, 7, 8, 9, 10) == False
-            assert self.func(2, 3, 5, 7, 11, 13, 17, 19, 23, 29) == True
-            assert self.func(1, 4, 6, 8, 9, 10, 12, 14, 15, 16) == False
-            assert self.func(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11) == False
-            assert self.func(2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31) == True
-            assert self.func(1, 4, 6, 8, 9, 10, 12, 14, 15, 16, 18) == False
-            assert self.func(0) == False
-            assert self.func() == True
-            assert self.func(2) == True
+            assert self.func(2, 3, 5, 7) is True
+            assert self.func(1, 2, 3, 4) is False
+            assert self.func(1, 2, 3, 4, 5, 6, 7, 8, 9, 10) is False
+            assert self.func(2, 3, 5, 7, 11, 13, 17, 19, 23, 29) is True
+            assert self.func(1, 4, 6, 8, 9, 10, 12, 14, 15, 16) is False
+            assert self.func(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11) is False
+            assert self.func(2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31) is True
+            assert self.func(1, 4, 6, 8, 9, 10, 12, 14, 15, 16, 18) is False
+            assert self.func(0) is False
+            assert self.func() is True
+            assert self.func(2) is True
             return True
         except:
             return False
 
 
 class Task13:
-    """Task: Creați o funcție cu numele `task_13` care primește obligatoriu un argument de tip string și un număr variabil de argumente de tip string.
+    """Task: Creați o funcție cu numele `task_13` care primește obligatoriu un argument de tip string și
+    un număr variabil de argumente de tip string.
     Funcția va returna True dacă toate argumentele sunt anagrame și False în caz contrar.
     Exemplu: task_13('listen', 'silent') ➞ True
     Exemplu: task_13('hello', 'world') ➞ False
     """
+
     def __init__(self, func):
         self.func = func
 
     def check_task(self):
         try:
-            assert self.func('listen', 'silent') == True
-            assert self.func('hello', 'world') == False
-            assert self.func('listen', 'silent', 'hello', 'world') == False
-            assert self.func('listen', 'silent', 'enlist', 'silent') == True
-            assert self.func('listen', 'silent', 'enlist', 'silent', 'listen', 'silent') == True
-            assert self.func('listen', 'silent', 'enlist', 'silent', 'listen', 'silent', 'listen', 'silent') == True
-            assert self.func("") == True
-            assert self.func('listen') == True
-            assert self.func("listen", "silent", "listen", "silent", "listen", "silent", "listen", "silent", "listen", "silent") == True
+            assert self.func("listen", "silent") is True
+            assert self.func("hello", "world") is False
+            assert self.func("listen", "silent", "hello", "world") is False
+            assert self.func("listen", "silent", "enlist", "silent") is True
+            assert self.func("listen", "silent", "enlist", "silent", "listen", "silent") is True
+            assert self.func("listen", "silent", "enlist", "silent", "listen", "silent", "listen", "silent") is True
+            assert self.func("") is True
+            assert self.func("listen") is True
+            assert (
+                self.func(
+                    "listen", "silent", "listen", "silent", "listen", "silent", "listen", "silent", "listen", "silent"
+                )
+                is True
+            )
             return True
         except:
             return False
 
 
 class Task14:
-    """Task: Creați o funcție cu numele `task_14` care primește un argument `sub_string` de tip string și un număr variabil de argumente de tip string.
+    """Task: Creați o funcție cu numele `task_14` care primește un argument `sub_string` de tip string și
+    un număr variabil de argumente de tip string.
     Funcția va returna o listă cu toate argumentele care conțin `sub_string`.
     Exemplu: task_14('home', 'same', 'meme', sub_string="me") ➞ ['home', 'meme', 'same']
     """
+
     def __init__(self, func):
         self.func = func
 
     def check_task(self):
         try:
-            assert self.func('home', 'same', 'meme', sub_string="me") == ['home', 'same', 'meme']
-            assert self.func('home', 'same', 'meme', sub_string="ho") == ['home']
-            assert self.func('home', 'same', 'meme', sub_string="sa") == ['same']
+            assert self.func("home", "same", "meme", sub_string="me") == ["home", "same", "meme"]
+            assert self.func("home", "same", "meme", sub_string="ho") == ["home"]
+            assert self.func("home", "same", "meme", sub_string="sa") == ["same"]
             assert self.func(sub_string="sa") == []
             assert self.func("123", "456", "789", sub_string="1") == ["123"]
             assert self.func("123", "456", "789", sub_string="") == ["123", "456", "789"]
@@ -319,30 +387,50 @@ def check_task(self):
 
 
 class Task15:
-    """Task: Creați o funcție cu numele `task_15` care primește un argument `sub_string` de tip string și un număr variabil de argumente de tip string.
+    """Task: Creați o funcție cu numele `task_15` care primește un argument `sub_string` de tip string și un
+    număr variabil de argumente de tip string.
     Funcția va returna un dicționar cu două chei: `contains` și `not_contains`.
-    Cheia `contains` va avea o listă cu toate argumentele care conțin `sub_string`, iar cheia `not_contains` va avea o listă cu toate argumentele care nu conțin `sub_string`.
-    Exemplu: task_15('home', 'same', 'meme', sub_string = 'me') ➞ {'contains': ['home', 'same', 'meme'], 'not_contains': []}
+    Cheia `contains` va avea o listă cu toate argumentele care conțin `sub_string`, iar cheia `not_contains` va avea
+    o listă cu toate argumentele care nu conțin `sub_string`.
+    Exemplu: task_15('home', 'same', 'meme', sub_string = 'me') ➞
+    {'contains': ['home', 'same', 'meme'], 'not_contains': []}
     """
+
     def __init__(self, func):
         self.func = func
 
     def check_task(self):
         try:
-            assert self.func('home', 'same', 'meme', sub_string='me') == {'contains': ['home', 'same', 'meme'], 'not_contains': []}
-            assert self.func('home', 'same', 'meme', sub_string='ho') == {'contains': ['home'], 'not_contains': ['same', 'meme']}
-            assert self.func('home', 'same', 'meme', sub_string='sa') == {'contains': ['same'], 'not_contains': ['home', 'meme']}
-            assert self.func(sub_string='sa') == {'contains': [], 'not_contains': []}
-            assert self.func('123', '456', '789', sub_string='1') == {'contains': ['123'], 'not_contains': ['456', '789']}
-            assert self.func('123', '456', '789', sub_string='') == {'contains': ['123', '456', '789'], 'not_contains': []}
-            assert self.func(sub_string="") == {'contains': [], 'not_contains': []}
+            assert self.func("home", "same", "meme", sub_string="me") == {
+                "contains": ["home", "same", "meme"],
+                "not_contains": [],
+            }
+            assert self.func("home", "same", "meme", sub_string="ho") == {
+                "contains": ["home"],
+                "not_contains": ["same", "meme"],
+            }
+            assert self.func("home", "same", "meme", sub_string="sa") == {
+                "contains": ["same"],
+                "not_contains": ["home", "meme"],
+            }
+            assert self.func(sub_string="sa") == {"contains": [], "not_contains": []}
+            assert self.func("123", "456", "789", sub_string="1") == {
+                "contains": ["123"],
+                "not_contains": ["456", "789"],
+            }
+            assert self.func("123", "456", "789", sub_string="") == {
+                "contains": ["123", "456", "789"],
+                "not_contains": [],
+            }
+            assert self.func(sub_string="") == {"contains": [], "not_contains": []}
             return True
         except:
             return False
 
 
 class Task16:
-    """Task: Creați o funcție cu numele `task_16` care va primi un număr variabil de argumente de tip integer și un argument `ooperation` de tip string.
+    """Task: Creați o funcție cu numele `task_16` care va primi un număr variabil de argumente de tip integer
+    și un argument `ooperation` de tip string.
     Funcția va returna rezultatul operației specificate de argumentul `operation` aplicată tuturor argumentelor.
     Operațiile posibile sunt: `add`, `sub`, `mul`, `div`.
     Exemplu: task_16(2, 3, 4, 5, operation='add') ➞ 14
@@ -350,31 +438,34 @@ class Task16:
     Exemplu: task_16(2, 3, 4, 5, operation='mul') ➞ 120
     Exemplu: task_16(2, 3, 4, 5, operation='div') ➞ 0.008333333333333333
     """
+
     def __init__(self, func):
         self.func = func
 
     def check_task(self):
         try:
-            assert self.func(2, 3, 4, 5, operation='add') == 14
-            assert self.func(2, 3, 4, 5, operation='sub') == -10
-            assert self.func(2, 3, 4, 5, operation='mul') == 120
-            assert self.func(2, 3, 4, 5, operation='div') == 2/3/4/5
-            assert self.func(-1, operation='add') == -1
-            assert self.func(-1, operation='sub') == -1
-            assert self.func(-1, operation='mul') == -1
-            assert self.func(-1, operation='div') == -1
-            assert self.func(0, operation='add') == 0
-            assert self.func(0, operation='sub') == 0
-            assert self.func(0, operation='mul') == 0
-            assert self.func(0, operation='div') == 0
+            assert self.func(2, 3, 4, 5, operation="add") == 14
+            assert self.func(2, 3, 4, 5, operation="sub") == -10
+            assert self.func(2, 3, 4, 5, operation="mul") == 120
+            assert self.func(2, 3, 4, 5, operation="div") == 2 / 3 / 4 / 5
+            assert self.func(-1, operation="add") == -1
+            assert self.func(-1, operation="sub") == -1
+            assert self.func(-1, operation="mul") == -1
+            assert self.func(-1, operation="div") == -1
+            assert self.func(0, operation="add") == 0
+            assert self.func(0, operation="sub") == 0
+            assert self.func(0, operation="mul") == 0
+            assert self.func(0, operation="div") == 0
             return True
         except:
             return False
 
 
 class Task17:
-    """Task: Creați o funcție cu numele `task_17` care primește un argument `number` după putea primi diferite argumente keyword precum `add`, `sub`, `mul`, `div` care vor fi liste cu numere.
-    Funcția va returna rezultatul operației specificate de argumentul `operation` aplicată tuturor argumentelor. Mai multe operații pot fi aplicate. Ordinea operațiilor va fi în ordinea în care sunt specificate.
+    """Task: Creați o funcție cu numele `task_17` care primește un argument `number` după putea primi diferite argumente
+    keyword precum `add`, `sub`, `mul`, `div` care vor fi liste cu numere.
+    Funcția va returna rezultatul operației specificate de argumentul `operation` aplicată tuturor argumentelor.
+    Mai multe operații pot fi aplicate. Ordinea operațiilor va fi în ordinea în care sunt specificate.
     Operațiile posibile sunt: `add`, `sub`, `mul`, `div`.
     Exemplu: task_17(2, add=[3, 4, 5]) ➞ 14
     Exemplu: task_17(2, sub=[3, 4, 5]) ➞ -10
@@ -382,6 +473,7 @@ class Task17:
     Exemplu: task_17(2, div=[3, 4, 5]) ➞ 0.008333333333333333
     Exemplu: task_17(2, add=[3, 4, 5], sub=[1, 2]) ➞ 11
     """
+
     def __init__(self, func):
         self.func = func
 
@@ -390,45 +482,68 @@ def check_task(self):
             assert self.func(2, add=[3, 4, 5]) == 14
             assert self.func(2, sub=[3, 4, 5]) == -10
             assert self.func(2, mul=[3, 4, 5]) == 120
-            assert self.func(2, div=[3, 4, 5]) == 2/3/4/5
+            assert self.func(2, div=[3, 4, 5]) == 2 / 3 / 4 / 5
             assert self.func(2, add=[3, 4, 5], sub=[1, 2]) == 11
-            assert self.func(2, add=[3, 4, 5], sub=[1, 2], mul=[2, 3]) == ((2+3+4+5-1-2)*2*3)
-            assert self.func(2, add=[3, 4, 5], sub=[1, 2], mul=[2, 3], div=[1, 2]) == ((((2+3+4+5)-1-2)*2*3)/1)/2
-            assert self.func(2, sub=[3, 4, 5], mul=[2, 3], div=[1, 2]) == ((2-3-4-5)*2*3)/1/2
-            assert self.func(2, add=[3, 4, 5], mul=[2, 3], div=[1, 2]) == ((2+3+4+5)*2*3)/1/2
-            assert self.func(2, add=[3, 4, 5], sub=[1, 2], div=[1, 2]) == ((((2+3)+4)+5-1-2)/1)/2
-            assert self.func(2, add=[3, 4, 5], sub=[1, 2], mul=[2, 3], div=[1, 2]) == ((((((2+3)+4)+5)-1-2)*2*3)/1)/2
-            assert self.func(2, div=[3, 4, 5], sub=[1, 2], mul=[2, 3], add=[1, 2]) == ((((((2/3)/4)/5-1-2)*2)*3)+1)+2
+            assert self.func(2, add=[3, 4, 5], sub=[1, 2], mul=[2, 3]) == ((2 + 3 + 4 + 5 - 1 - 2) * 2 * 3)
+            assert (
+                self.func(2, add=[3, 4, 5], sub=[1, 2], mul=[2, 3], div=[1, 2])
+                == ((((2 + 3 + 4 + 5) - 1 - 2) * 2 * 3) / 1) / 2
+            )
+            assert self.func(2, sub=[3, 4, 5], mul=[2, 3], div=[1, 2]) == ((2 - 3 - 4 - 5) * 2 * 3) / 1 / 2
+            assert self.func(2, add=[3, 4, 5], mul=[2, 3], div=[1, 2]) == ((2 + 3 + 4 + 5) * 2 * 3) / 1 / 2
+            assert self.func(2, add=[3, 4, 5], sub=[1, 2], div=[1, 2]) == ((((2 + 3) + 4) + 5 - 1 - 2) / 1) / 2
+            assert (
+                self.func(2, add=[3, 4, 5], sub=[1, 2], mul=[2, 3], div=[1, 2])
+                == ((((((2 + 3) + 4) + 5) - 1 - 2) * 2 * 3) / 1) / 2
+            )
+            assert (
+                self.func(2, div=[3, 4, 5], sub=[1, 2], mul=[2, 3], add=[1, 2])
+                == ((((((2 / 3) / 4) / 5 - 1 - 2) * 2) * 3) + 1) + 2
+            )
             return True
         except:
             return False
 
 
 class Task18:
-    """Task: Creați o funcție cu numele `task_18` care primește un număr variabil de argumente de tip string și va returna un dicționar în care cheile vor fi caracterele întâlnite în argumentele primite, iar valorile vor fi numărul de apariții ale caracterelor.
+    """Task: Creați o funcție cu numele `task_18` care primește un număr variabil de argumente de tip string și
+    va returna un dicționar în care cheile vor fi caracterele întâlnite în argumentele primite,
+    iar valorile vor fi numărul de apariții ale caracterelor.
     Exemplu: task_18('hello', 'world') ➞ {'h': 1, 'e': 1, 'l': 3, 'o': 2, 'w': 1, 'r': 1, 'd': 1}
     """
+
     def __init__(self, func):
         self.func = func
 
     def check_task(self):
         try:
-            assert self.func('hello', 'world') == {'h': 1, 'e': 1, 'l': 3, 'o': 2, 'w': 1, 'r': 1, 'd': 1}
-            assert self.func('hello') == {'h': 1, 'e': 1, 'l': 2, 'o': 1}
-            assert self.func('world') == {'w': 1, 'o': 1, 'r': 1, 'l': 1, 'd': 1}
-            assert self.func('hello', 'world', 'hello') == {'h': 2, 'e': 2, 'l': 5, 'o': 3, 'w': 1, 'r': 1, 'd': 1}
-            assert self.func('hello', 'world', 'hello', 'world') == {'h': 2, 'e': 2, 'l': 6, 'o': 4, 'w': 2, 'r': 2, 'd': 2}
+            assert self.func("hello", "world") == {"h": 1, "e": 1, "l": 3, "o": 2, "w": 1, "r": 1, "d": 1}
+            assert self.func("hello") == {"h": 1, "e": 1, "l": 2, "o": 1}
+            assert self.func("world") == {"w": 1, "o": 1, "r": 1, "l": 1, "d": 1}
+            assert self.func("hello", "world", "hello") == {"h": 2, "e": 2, "l": 5, "o": 3, "w": 1, "r": 1, "d": 1}
+            assert self.func("hello", "world", "hello", "world") == {
+                "h": 2,
+                "e": 2,
+                "l": 6,
+                "o": 4,
+                "w": 2,
+                "r": 2,
+                "d": 2,
+            }
             assert self.func() == {}
-            assert self.func("aaaaaaaaa") == {'a': 9}
+            assert self.func("aaaaaaaaa") == {"a": 9}
             return True
         except:
             return False
 
 
 class Task19:
-    """Task: Creați o funcție cu numele `task_19` care primește un număr variabil de argumente de tip integer și va returna un dicționar în care cheile vor fi numerele prime întâlnite în argumentele primite, iar valorile vor fi numărul de apariții ale numerelor prime.
+    """Task: Creați o funcție cu numele `task_19` care primește un număr variabil de argumente de tip integer
+    și va returna un dicționar în care cheile vor fi numerele prime întâlnite în argumentele primite,
+    iar valorile vor fi numărul de apariții ale numerelor prime.
     Exemplu: task_19(1, 2, 3, 4, 5, 6, 7, 8, 9) ➞ {2: 1, 3: 1, 5: 1, 7: 1}
     """
+
     def __init__(self, func):
         self.func = func
 
@@ -445,19 +560,22 @@ def check_task(self):
 
 
 class Task20:
-    """Task: Creați o funcție cu numele `task_20` care primește un număr variabil de argumente de tip string și va returna un dicționar în care cheile vor fi lungimile cuvintelor întâlnite în argumentele primite, iar valorile vor fi numărul de apariții ale lungimilor cuvintelor.
+    """Task: Creați o funcție cu numele `task_20` care primește un număr variabil de argumente de tip string
+    și va returna un dicționar în care cheile vor fi lungimile cuvintelor întâlnite în argumentele primite,
+    iar valorile vor fi numărul de apariții ale lungimilor cuvintelor.
     Exemplu: task_20('hello', 'world') ➞ {5: 2}
     Exemplu: task_20('hello', 'world', 'python') ➞ {5: 2, 6: 1}
     """
+
     def __init__(self, func):
         self.func = func
 
     def check_task(self):
         try:
-            assert self.func('hello', 'world') == {5: 2}
-            assert self.func('hello', 'world', 'python') == {5: 2, 6: 1}
-            assert self.func('hello', 'world', 'python', 'java') == {5: 2, 6: 1, 4: 1}
-            assert self.func('hello', 'world', 'python', 'java', 'ruby') == {5: 2, 6: 1, 4: 2}
+            assert self.func("hello", "world") == {5: 2}
+            assert self.func("hello", "world", "python") == {5: 2, 6: 1}
+            assert self.func("hello", "world", "python", "java") == {5: 2, 6: 1, 4: 1}
+            assert self.func("hello", "world", "python", "java", "ruby") == {5: 2, 6: 1, 4: 2}
             assert self.func() == {}
             assert self.func("aaaaaaaaa") == {9: 1}
             return True
@@ -467,6 +585,7 @@ def check_task(self):
 
 class Lesson11:
     """Test class for checking the implementation of tasks in lesson 11 of the Python Odyssey Bootcamp."""
+
     def __init__(self):
         self.status_tasks = {f"task_{i}": False for i in range(1, 21)}
 
@@ -484,4 +603,4 @@ def check_task(self, task_number, func):
     def get_completion_percentage(self):
         """Return the completion percentage of the tasks"""
         completed = sum([1 for task in self.status_tasks if self.status_tasks[task]])
-        return f"Your completion percentage is {completed * 100 / len(self.status_tasks)}%"
\ No newline at end of file
+        return f"Your completion percentage is {completed * 100 / len(self.status_tasks)}%"
diff --git a/sigmoid_check/python_odyssey/lesson_13/__init__.py b/sigmoid_check/python_odyssey/lesson_13/__init__.py
index c58b943..4cd9750 100644
--- a/sigmoid_check/python_odyssey/lesson_13/__init__.py
+++ b/sigmoid_check/python_odyssey/lesson_13/__init__.py
@@ -1 +1 @@
-from .lesson import Lesson13
\ No newline at end of file
+from .lesson import Lesson13
diff --git a/sigmoid_check/python_odyssey/lesson_13/lesson.py b/sigmoid_check/python_odyssey/lesson_13/lesson.py
index f03534a..195dad8 100644
--- a/sigmoid_check/python_odyssey/lesson_13/lesson.py
+++ b/sigmoid_check/python_odyssey/lesson_13/lesson.py
@@ -1,6 +1,8 @@
 class Task1:
-    """1. Avem nevoie să creezi o clasă `Produs`, aceasta trebuie să accepte 3 parametri: numele, pretul, anul_producerii
-    Cu ajutorul acestei clase trebuie să fiu capabil să creeze câte obiecte doresc cu orice configurație a numelui, prețului și anul_producerii
+    """1. Avem nevoie să creezi o clasă `Produs`,
+    aceasta trebuie să accepte 3 parametri: numele, pretul, anul_producerii
+    Cu ajutorul acestei clase trebuie să fiu capabil să creeze câte obiecte doresc cu orice configurație a numelui,
+    prețului și anul_producerii
 
     Exemplu utilizare:
     telefon = Produs("Iphone", 15000, 2020) # Voi putea crea un obiect utilizând anumiți parametri de intrare
@@ -8,141 +10,179 @@ class Task1:
     print(telefon.pretul)                   # Voi putea accesa pretul obiectului creat
     print(telefon.anul_producerii)          # Voi putea accesa anul producerii obiectului creat
     """
+
     def __init__(self, class_to_test) -> None:
         self.class_to_test = class_to_test
 
     def check_task(self):
         try:
-            phone_test_1 = self.class_to_test('Samsung', 500, 300)
-            assert phone_test_1.numele == 'Samsung', 'Asigură-te că ai creat atributul numele'
-            assert phone_test_1.pretul == 500, 'Asigură-te că ai creat atributul pretul'
-            assert phone_test_1.anul_producerii == 300, 'Asigură-te că ai creat atributul anul_producerii'
+            phone_test_1 = self.class_to_test("Samsung", 500, 300)
+            assert phone_test_1.numele == "Samsung", "Asigură-te că ai creat atributul numele"
+            assert phone_test_1.pretul == 500, "Asigură-te că ai creat atributul pretul"
+            assert phone_test_1.anul_producerii == 300, "Asigură-te că ai creat atributul anul_producerii"
             return True
         except:
             return False
-        
+
+
 class Task2:
-    """2.1Prima clasă se numește `Telefon` aceasta va moșteni clasa `Produs` și va avea doi parametri în plus numit `baterie_mAh` și `memorie_GB`
+    """2.1Prima clasă se numește `Telefon` aceasta va moșteni clasa `Produs`
+    și va avea doi parametri în plus numit `baterie_mAh` și `memorie_GB`
 
-    De asemenea aceasta va avea o metodă numită `upgrade_memory` care va primi un parametru `new_memory` și va actualiza valoarea memoriei telefonului.
-    Totodată aceasta va avea o metodă numită `upgrade_battery` care va primi un parametru `new_battery` și va actualiza valoarea bateriei telefonului.
+    De asemenea aceasta va avea o metodă numită `upgrade_memory` care va primi un parametru `new_memory`
+    și va actualiza valoarea memoriei telefonului.
+    Totodată aceasta va avea o metodă numită `upgrade_battery` care va primi un parametru `new_battery`
+    și va actualiza valoarea bateriei telefonului.
     """
+
     def __init__(self, child, parent) -> None:
         self.class_to_test = child
         self.parent_class = parent
 
     def check_task(self):
         try:
-            phone_test_1 = self.class_to_test('Samsung', 500, 300, 4000, 128)
-            assert phone_test_1.baterie_mAh == 4000, 'Asigură-te că ai creat atributul baterie_mAh'
-            assert phone_test_1.memorie_GB == 128, 'Asigură-te că ai creat atributul memorie_GB'
-            assert issubclass(self.class_to_test, self.parent_class), 'Clasa nu mosteneste clasa parinte'
+            phone_test_1 = self.class_to_test("Samsung", 500, 300, 4000, 128)
+            assert phone_test_1.baterie_mAh == 4000, "Asigură-te că ai creat atributul baterie_mAh"
+            assert phone_test_1.memorie_GB == 128, "Asigură-te că ai creat atributul memorie_GB"
+            assert issubclass(self.class_to_test, self.parent_class), "Clasa nu mosteneste clasa parinte"
             phone_test_1.upgrade_memory(256)
-            assert phone_test_1.memorie_GB == 256, 'Metoda upgrade_memory nu functioneaza'
+            assert phone_test_1.memorie_GB == 256, "Metoda upgrade_memory nu functioneaza"
             phone_test_1.upgrade_battery(5000)
-            assert phone_test_1.baterie_mAh == 5000, 'Metoda upgrade_battery nu functioneaza'
+            assert phone_test_1.baterie_mAh == 5000, "Metoda upgrade_battery nu functioneaza"
             return True
         except:
             return False
-        
+
+
 class Task3:
-    """2.2 A doua clasă se numește `Laptop` aceasta va moșteni clasa `Produs` și va avea doi parametri în plus numit `sistem_de_operare` și `procesor`
+    """2.2 A doua clasă se numește `Laptop` aceasta va moșteni clasa `Produs` și va avea doi parametri în plus
+    numit `sistem_de_operare` și `procesor`
 
-    De asemenea aceasta va avea o metodă numită `upgrade_processor` care va primi un parametru `new_processor` și va actualiza valoarea procesorului laptopului.
-    Totodată aceasta va avea o metodă numită `upgrade_os` care va primi un parametru `new_os` și va actualiza valoarea sistemului de operare al laptopului.
+    De asemenea aceasta va avea o metodă numită `upgrade_processor` care va primi un parametru `new_processor`
+    și va actualiza valoarea procesorului laptopului.
+    Totodată aceasta va avea o metodă numită `upgrade_os` care va primi un parametru `new_os`
+    și va actualiza valoarea sistemului de operare al laptopului.
     """
+
     def __init__(self, child, parent) -> None:
         self.class_to_test = child
         self.parent_class = parent
 
     def check_task(self):
         try:
-            laptop_test_1 = self.class_to_test('Samsung', 500, 300, 'Windows', 'Intel i5')
-            assert laptop_test_1.sistem_de_operare == 'Windows', 'Asigură-te că ai creat atributul sistem_de_operare'
-            assert laptop_test_1.procesor == 'Intel i5', 'Asigură-te că ai creat atributul procesor'
-            assert issubclass(self.class_to_test, self.parent_class), 'Clasa nu mosteneste clasa parinte'
-            laptop_test_1.upgrade_processor('Intel i7')
-            assert laptop_test_1.procesor == 'Intel i7', 'Metoda upgrade_processor nu functioneaza'
-            laptop_test_1.upgrade_os('Windows 11')
-            assert laptop_test_1.sistem_de_operare == 'Windows 11', 'Metoda upgrade_os nu functioneaza'
+            laptop_test_1 = self.class_to_test("Samsung", 500, 300, "Windows", "Intel i5")
+            assert laptop_test_1.sistem_de_operare == "Windows", "Asigură-te că ai creat atributul sistem_de_operare"
+            assert laptop_test_1.procesor == "Intel i5", "Asigură-te că ai creat atributul procesor"
+            assert issubclass(self.class_to_test, self.parent_class), "Clasa nu mosteneste clasa parinte"
+            laptop_test_1.upgrade_processor("Intel i7")
+            assert laptop_test_1.procesor == "Intel i7", "Metoda upgrade_processor nu functioneaza"
+            laptop_test_1.upgrade_os("Windows 11")
+            assert laptop_test_1.sistem_de_operare == "Windows 11", "Metoda upgrade_os nu functioneaza"
             return True
         except:
             return False
-        
+
+
 class Task4:
-    """2.3 A treia clasă se numește `trotineta` aceasta va moșteni clasa `Produs` și va avea doi parametri în plus numit `viteza_maxima` și `autonomie_km`
+    """2.3 A treia clasă se numește `trotineta` aceasta va moșteni clasa `Produs`
+    și va avea doi parametri în plus numit `viteza_maxima` și `autonomie_km`
 
-    De asemenea aceasta va avea o metodă numită `upgrade_speed` care va primi un parametru `new_speed` și va actualiza valoarea vitezei maxime a trotinetei.
-    Totodată aceasta va avea o metodă numită `upgrade_autonomy` care va primi un parametru `new_autonomy` și va actualiza valoarea autonomiei trotinetei.
+    De asemenea aceasta va avea o metodă numită `upgrade_speed` care va primi un parametru `new_speed`
+    și va actualiza valoarea vitezei maxime a trotinetei.
+    Totodată aceasta va avea o metodă numită `upgrade_autonomy` care va primi un parametru `new_autonomy`
+    și va actualiza valoarea autonomiei trotinetei.
     """
+
     def __init__(self, child, parent) -> None:
         self.class_to_test = child
         self.parent_class = parent
 
     def check_task(self):
         try:
-            trotineta_test_1 = self.class_to_test('Samsung', 500, 300, 25, 30)
-            assert trotineta_test_1.viteza_maxima == 25, 'Asigură-te că ai creat atributul viteza_maxima'
-            assert trotineta_test_1.autonomie_km == 30, 'Asigură-te că ai creat atributul autonomie_km'
-            assert issubclass(self.class_to_test, self.parent_class), 'Clasa nu mosteneste clasa parinte'
+            trotineta_test_1 = self.class_to_test("Samsung", 500, 300, 25, 30)
+            assert trotineta_test_1.viteza_maxima == 25, "Asigură-te că ai creat atributul viteza_maxima"
+            assert trotineta_test_1.autonomie_km == 30, "Asigură-te că ai creat atributul autonomie_km"
+            assert issubclass(self.class_to_test, self.parent_class), "Clasa nu mosteneste clasa parinte"
             trotineta_test_1.upgrade_speed(30)
-            assert trotineta_test_1.viteza_maxima == 30, 'Metoda upgrade_speed nu functioneaza'
+            assert trotineta_test_1.viteza_maxima == 30, "Metoda upgrade_speed nu functioneaza"
             trotineta_test_1.upgrade_autonomy(40)
-            assert trotineta_test_1.autonomie_km == 40, 'Metoda upgrade_autonomy nu functioneaza'
+            assert trotineta_test_1.autonomie_km == 40, "Metoda upgrade_autonomy nu functioneaza"
             return True
         except:
             return False
-        
+
+
 class Task5:
-    """Avem nevoie de o clasă nouă care să se numească `AppleProduct` care va moșteni clasa `Produs` și va avea un parametru în plus numit `culoare` și `produs_conectat` 
-    parametrul `produs_conectat` va avea valoarea "nimic" la crearea unui produs astfel încât nu va fi necesar de menționat la crearea unui obiect nou
-    De asemenea va avea o metodă numită `combine_products` care va primi un parametru `product` ce va reprezenta un alt obiect de tip `AppleProduct` care va fi salvat în parametrul `produs_conectat`
-    Există o singură condiție, produsul conectat trebuie să fie de tip `AppleProduct` iar culoarea acestuia trebuie să fie aceeași cu a produsului curent.
+    """Avem nevoie de o clasă nouă care să se numească `AppleProduct` care va moșteni clasa `Produs`
+    și va avea un parametru în plus numit `culoare` și `produs_conectat`
+    parametrul `produs_conectat` va avea valoarea "nimic" la crearea unui produs astfel încât nu va fi necesar
+    de menționat la crearea unui obiect nou
+    De asemenea va avea o metodă numită `combine_products` care va primi un parametru `product`
+    ce va reprezenta un alt obiect de tip `AppleProduct` care va fi salvat în parametrul `produs_conectat`
+    Există o singură condiție, produsul conectat trebuie să fie de tip `AppleProduct` iar culoarea acestuia trebuie
+    să fie aceeași cu a produsului curent.
 
     Exemplu utilizare:
     iphone = AppleProduct("Iphone", 15000, 2020, "negru")
     airpods = AppleProduct("Airpods", 1000, 2021, "alb")
-    iphone.combine_products(airpods) # În acest caz se va returna textul "Produsul nu poate fi conectat deoarece culorile nu coincid"
+    iphone.combine_products(airpods) # În acest caz se va returna textul
+    "Produsul nu poate fi conectat deoarece culorile nu coincid"
 
     iphone = AppleProduct("Iphone", 15000, 2020, "negru")
     airpods = AppleProduct("Airpods", 1000, 2021, "negru")
-    iphone.combine_products(airpods) # În acest caz se va returna textul "Produsul a fost conectat cu succes" și dacă se va printa iphone.produs_conectat se va returna obiectul airpods
+    iphone.combine_products(airpods) # În acest caz se va returna textul
+    "Produsul a fost conectat cu succes" și dacă se va printa iphone.produs_conectat se va returna obiectul airpods
     print(iphone.produs_conectat.numele) # Va returna numele produsului conectat
     print(iphone.produs_conectat.pretul) # Va returna prețul produsului conectat
     """
+
     def __init__(self, child, parent) -> None:
         self.class_to_test = child
         self.parent_class = parent
-    
+
     def check_task(self):
         try:
             iphone = self.class_to_test("Iphone", 15000, 2020, "negru")
             airpods = self.class_to_test("Airpods", 1000, 2021, "alb")
-            assert iphone.produs_conectat == 'nimic', 'Asigură-te că ai creat atributul produs_conectat cu valoarea default "nimic"'
-            assert iphone.culoare == 'negru', 'Asigură-te că ai creat atributul culoare'
-            assert issubclass(self.class_to_test, self.parent_class), 'Clasa nu mosteneste clasa parinte'
-            assert iphone.combine_products(airpods) == 'Produsul nu poate fi conectat deoarece culorile nu coincid', 'Metoda combine_products nu functioneaza'
+            assert (
+                iphone.produs_conectat == "nimic"
+            ), 'Asigură-te că ai creat atributul produs_conectat cu valoarea default "nimic"'
+            assert iphone.culoare == "negru", "Asigură-te că ai creat atributul culoare"
+            assert issubclass(self.class_to_test, self.parent_class), "Clasa nu mosteneste clasa parinte"
+            assert (
+                iphone.combine_products(airpods) == "Produsul nu poate fi conectat deoarece culorile nu coincid"
+            ), "Metoda combine_products nu functioneaza"
             airpods = self.class_to_test("Airpods", 1000, 2021, "negru")
-            assert iphone.combine_products(airpods) == 'Produsul a fost conectat cu succes', 'Metoda combine_products nu functioneaza'
-            assert iphone.produs_conectat == airpods, 'Metoda combine_products nu functioneaza'
+            assert (
+                iphone.combine_products(airpods) == "Produsul a fost conectat cu succes"
+            ), "Metoda combine_products nu functioneaza"
+            assert iphone.produs_conectat == airpods, "Metoda combine_products nu functioneaza"
             iphone2 = self.class_to_test("Iphone", 15000, 2020, "negru", airpods)
-            assert iphone2.produs_conectat == airpods, 'Metoda combine_products nu functioneaza, parametrul produs_conectat nu este setat corect'
+            assert iphone2.produs_conectat == airpods, (
+                "Metoda combine_products nu functioneaza, parametrul " "produs_conectat nu este setat corect"
+            )
             return True
         except:
             return False
-        
+
+
 class Task6:
     """
-    Avem nevoie de o clasă nouă care să se numească `GoogleProduct` care va moșteni clasa `AppleProduct` posibilitățile la ambele sunt aceleași, dar va fi nevoie de o singură schimbare.
-    Produsul conectat trebuie să fie de tip `GoogleProduct` iar culoarea acestuia poate să fie diferită de a produsului curent.
-    Asta ar însemna că singurul element care va necesita modificări este metoda `combine_products` care va trebui să accepte orice tip de obiect de tip `GoogleProduct`
+    Avem nevoie de o clasă nouă care să se numească `GoogleProduct` care va moșteni clasa
+    `AppleProduct` posibilitățile la ambele sunt aceleași, dar va fi nevoie de o singură schimbare.
+    Produsul conectat trebuie să fie de tip `GoogleProduct`
+    iar culoarea acestuia poate să fie diferită de a produsului curent.
+    Asta ar însemna că singurul element care va necesita modificări este metoda `combine_products` care va trebui
+    să accepte orice tip de obiect de tip `GoogleProduct`
 
     Exemplu utilizare:
     pixel = GoogleProduct("Pixel", 10000, 2020, "negru")
     home = GoogleProduct("Home", 500, 2021, "alb")
-    pixel.combine_products(home) # În acest caz se va returna textul "Produsul a fost conectat cu succes" și dacă se va printa pixel.produs_conectat se va returna obiectul home
+    pixel.combine_products(home) # În acest caz se va returna textul "Produsul a fost conectat cu succes"
+    și dacă se va printa pixel.produs_conectat se va returna obiectul home
     print(pixel.produs_conectat.numele) # Va returna numele produsului conectat
     """
+
     def __init__(self, child, parent) -> None:
         self.class_to_test = child
         self.parent_class = parent
@@ -151,28 +191,39 @@ def check_task(self):
         try:
             pixel = self.class_to_test("Pixel", 10000, 2020, "negru")
             home = self.class_to_test("Home", 500, 2021, "alb")
-            assert pixel.produs_conectat == 'nimic', 'Asigură-te că ai creat atributul produs_conectat cu valoarea default "nimic"'
-            assert pixel.culoare == 'negru', 'Asigură-te că ai creat atributul culoare'
-            assert issubclass(self.class_to_test, self.parent_class), 'Clasa nu mosteneste clasa parinte'
-            assert pixel.combine_products(home) == 'Produsul a fost conectat cu succes', 'Metoda combine_products nu functioneaza'
-            assert pixel.produs_conectat == home, 'Metoda combine_products nu functioneaza'
+            assert (
+                pixel.produs_conectat == "nimic"
+            ), 'Asigură-te că ai creat atributul produs_conectat cu valoarea default "nimic"'
+            assert pixel.culoare == "negru", "Asigură-te că ai creat atributul culoare"
+            assert issubclass(self.class_to_test, self.parent_class), "Clasa nu mosteneste clasa parinte"
+            assert (
+                pixel.combine_products(home) == "Produsul a fost conectat cu succes"
+            ), "Metoda combine_products nu functioneaza"
+            assert pixel.produs_conectat == home, "Metoda combine_products nu functioneaza"
             pixel2 = self.class_to_test("Pixel", 10000, 2020, "negru", home)
-            assert pixel2.produs_conectat == home, 'Metoda combine_products nu functioneaza, parametrul produs_conectat nu este setat corect'
+            assert pixel2.produs_conectat == home, (
+                "Metoda combine_products nu functioneaza, " "parametrul produs_conectat nu este setat corect"
+            )
             return True
         except:
             return False
-        
+
+
 class Task7:
-    """Avem nevoie de o clasă nouă pentru aceasta, ea se va numi `Magazin` și va conține doar 2 metode, `vinde_produs` și `returneaza_produs`
+    """Avem nevoie de o clasă nouă pentru aceasta, ea se va numi `Magazin` și va conține doar 2 metode, `vinde_produs`
+    și `returneaza_produs`
 
-    Metoda `vinde_produs` va primi un parametru `produs` care va reprezenta un obiect de tip `Produs` și va returna textul "Produsul *numele produsului* a fost vândut cu succes"
-    Metoda `returneaza_produs` va primi un parametru `produs` care va reprezenta un obiect de tip `Produs` și va returna textul "Produsul *numele produsului* a fost returnat cu succes"
+    Metoda `vinde_produs` va primi un parametru `produs` care va reprezenta un obiect de tip `Produs`
+    și va returna textul "Produsul *numele produsului* a fost vândut cu succes"
+    Metoda `returneaza_produs` va primi un parametru `produs` care va reprezenta un obiect de tip `Produs`
+    și va returna textul "Produsul *numele produsului* a fost returnat cu succes"
 
     Exemplu utilizare:
     iphone = AppleProduct("Iphone", 15000, 2020, "negru")
     print(magazin.vinde_produs(iphone)) # Va returna textul "Produsul Iphone a fost vândut cu succes"
     print(magazin.returneaza_produs(iphone)) # Va returna textul "Produsul Iphone a fost returnat cu succes
     """
+
     def __init__(self, class_to_test, product_class) -> None:
         self.class_to_test = class_to_test
         self.product_class = product_class
@@ -181,14 +232,20 @@ def check_task(self):
         try:
             magazin = self.class_to_test()
             iphone = self.product_class("Ciao", 15000, 2020)
-            assert magazin.vinde_produs(iphone) == 'Produsul Ciao a fost vândut cu succes', 'Metoda vinde_produs nu functioneaza'
-            assert magazin.returneaza_produs(iphone) == 'Produsul Ciao a fost returnat cu succes', 'Metoda returneaza_produs nu functioneaza'
+            assert (
+                magazin.vinde_produs(iphone) == "Produsul Ciao a fost vândut cu succes"
+            ), "Metoda vinde_produs nu functioneaza"
+            assert (
+                magazin.returneaza_produs(iphone) == "Produsul Ciao a fost returnat cu succes"
+            ), "Metoda returneaza_produs nu functioneaza"
             return True
         except:
             return False
 
+
 class Lesson13:
     """Test class for checking the implementation of tasks in lesson 13 of the Python Odyssey Bootcamp."""
+
     def __init__(self):
         self.status_tasks = {f"task_{i}": False for i in range(1, 8)}
 
@@ -202,8 +259,8 @@ def check_task(self, task_number, *args):
             return f"Task {task_number}: Incorrect! Please try again."
         except:
             return f"Task {task_number}: Error!"
-        
+
     def get_completion_percentage(self):
         """Return the completion percentage of the tasks"""
         completed = sum([1 for task in self.status_tasks if self.status_tasks[task]])
-        return f"Your completion percentage is {completed * 100 / len(self.status_tasks)}%"
\ No newline at end of file
+        return f"Your completion percentage is {completed * 100 / len(self.status_tasks)}%"
diff --git a/sigmoid_check/python_odyssey/lesson_14/__init__.py b/sigmoid_check/python_odyssey/lesson_14/__init__.py
index 2c16849..f0ce76c 100644
--- a/sigmoid_check/python_odyssey/lesson_14/__init__.py
+++ b/sigmoid_check/python_odyssey/lesson_14/__init__.py
@@ -1 +1 @@
-from .lesson import Lesson14
\ No newline at end of file
+from .lesson import Lesson14
diff --git a/sigmoid_check/python_odyssey/lesson_14/lesson.py b/sigmoid_check/python_odyssey/lesson_14/lesson.py
index 84c1a60..631a5a8 100644
--- a/sigmoid_check/python_odyssey/lesson_14/lesson.py
+++ b/sigmoid_check/python_odyssey/lesson_14/lesson.py
@@ -1,16 +1,26 @@
 class Task1:
-    """1. Creează o clasă `Utilizator` care să conțină un atribut public `nume` și un atribut protejat `_nivel_acces` cu valoarea implicită "Default".
-        Clasa `Utilizator` trebuie să conțină metoda `afiseaza_nivel_acces` care să returneze string-ul "*nume-utilizator* are nivelul de acces *nivel-acces*.".
-        De asemenea, clasa `Utilizator` trebuie să conțină metoda `utilizeaza_sistem` care să returneze string-ul "*nume-utilizator* poate utiliza funcții de bază ale sistemului.".
+    """1. Creează o clasă `Utilizator` care să conțină un atribut public `nume` și un atribut protejat `_nivel_acces`
+    cu valoarea implicită "Default".
+        Clasa `Utilizator` trebuie să conțină metoda `afiseaza_nivel_acces` care să returneze string-ul
+        "*nume-utilizator* are nivelul de acces *nivel-acces*.".
+        De asemenea, clasa `Utilizator` trebuie să conțină metoda `utilizeaza_sistem` care să returneze string-ul
+        "*nume-utilizator* poate utiliza funcții de bază ale sistemului.".
 
-    2. Creează o clasă `UtilizatorManager` care să moștenească clasa `Utilizator` și să aibă atributul protejat `_nivel_acces` cu valoarea "Manager".
-        Clasa `UtilizatorManager` trebuie să conțină metoda `modifica_setari` care să returneze string-ul "*nume-utilizator* poate modifica setările sistemului.".
-        De asemenea, clasa `UtilizatorManager` trebuie să conțină metoda `citeste_date_utilizator` care să returneze string-ul "*nume-utilizator* poate citi datele utilizatorilor.".
+    2. Creează o clasă `UtilizatorManager` care să moștenească clasa `Utilizator`
+    și să aibă atributul protejat `_nivel_acces` cu valoarea "Manager".
+        Clasa `UtilizatorManager` trebuie să conțină metoda `modifica_setari` care să returneze string-ul
+        "*nume-utilizator* poate modifica setările sistemului.".
+        De asemenea, clasa `UtilizatorManager` trebuie să conțină metoda `citeste_date_utilizator`
+        care să returneze string-ul "*nume-utilizator* poate citi datele utilizatorilor.".
 
-    3. Creează o clasă `UtilizatorAdmin` care să moștenească clasa `Utilizator` și să aibă atributul protejat `_nivel_acces` cu valoarea "Admin".
-        Clasa `UtilizatorAdmin` trebuie să conțină metoda `modifica_setari` care să returneze string-ul "*nume-utilizator* poate modifica setările sistemului.".
-        De asemenea, clasa `UtilizatorAdmin` trebuie să conțină metoda `modifica_date_utilizator` care să returneze string-ul "*nume-utilizator* poate modifica datele utilizatorilor.".
+    3. Creează o clasă `UtilizatorAdmin` care să moștenească clasa `Utilizator`
+    și să aibă atributul protejat `_nivel_acces` cu valoarea "Admin".
+        Clasa `UtilizatorAdmin` trebuie să conțină metoda `modifica_setari` care să returneze string-ul
+        "*nume-utilizator* poate modifica setările sistemului.".
+        De asemenea, clasa `UtilizatorAdmin` trebuie să conțină metoda `modifica_date_utilizator` care să returneze
+        string-ul "*nume-utilizator* poate modifica datele utilizatorilor.".
     """
+
     def __init__(self, class_user, class_user_manager, class_user_admin):
         self.class_user = class_user
         self.class_user_manager = class_user_manager
@@ -37,18 +47,29 @@ def check_task(self):
 
 
 class Task2:
-    """1. Pentru această sarcină vom crea o copie a clasei `Utilizator` de mai sus, deoarece vom avea nevoie de aceeași structură pentru a adăuga utilizatorii în sistem.
-    Creează o clasă `user` care să conțină un atribut privat `_nume` și un atribut protejat `__nivel_acces` cu valoarea implicită "Default".
-    Acum avem nevoie de un getter și un setter pentru atributul `_nume` și `__nivel_acces` pentru a putea modifica aceste valori în afara clasei.
-
-    2. Creează o clasă `Sistem` care va conține un atribut privat `__utilizatori` inițializat cu un dicționar gol în care cheile vor fi id-ul și valorile utilizatorii.
-        Clasa `Sistem` trebuie să conțină metoda `adauga_utilizator` care va primi un obiect de tip `Utilizator` și va adăuga utilizatorul la dicționar împreună cu un nou id.
-        De asemenea, clasa `Sistem` trebuie să conțină metoda `afiseaza_utilizatori` care va returna o listă cu numele utilizatorilor existenți.
-        Clasa `Sistem` trebuie să conțină metoda `verifica_nivel_acces` care va primi numele unui utilizator și va returna nivelul de acces al utilizatorului respectiv.
-        Clasa `Sistem` trebuie să conțină și metoda `modifica_name_user` care va primi id-ul utilizatorului și noul nume al utilizatorului și va modifica numele utilizatorului respectiv.
-        Clasa `Sistem` trebuie să conțină și metoda `sterge_utilizator` care va primi id-ul utilizatorului și va șterge utilizatorul respectiv.
-        Clasa `Sistem` trebuie să conțină și metoda `modifica_nivel_acces` care va primi id-ul utilizatorului și noul nivel de acces al utilizatorului și va modifica nivelul de acces al utilizatorului respectiv.
+    """1. Pentru această sarcină vom crea o copie a clasei `Utilizator` de mai sus, deoarece vom avea nevoie de aceeași
+    structură pentru a adăuga utilizatorii în sistem.
+    Creează o clasă `user` care să conțină un atribut privat `_nume` și un atribut protejat
+    `__nivel_acces` cu valoarea implicită "Default".
+    Acum avem nevoie de un getter și un setter pentru atributul `_nume` și `__nivel_acces` pentru a putea modifica
+    aceste valori în afara clasei.
+
+    2. Creează o clasă `Sistem` care va conține un atribut privat `__utilizatori` inițializat cu un dicționar gol
+    în care cheile vor fi id-ul și valorile utilizatorii.
+        Clasa `Sistem` trebuie să conțină metoda `adauga_utilizator` care va primi un obiect de tip `Utilizator`
+        și va adăuga utilizatorul la dicționar împreună cu un nou id.
+        De asemenea, clasa `Sistem` trebuie să conțină metoda `afiseaza_utilizatori` care va returna
+        o listă cu numele utilizatorilor existenți.
+        Clasa `Sistem` trebuie să conțină metoda `verifica_nivel_acces` care va primi numele unui utilizator
+        și va returna nivelul de acces al utilizatorului respectiv.
+        Clasa `Sistem` trebuie să conțină și metoda `modifica_name_user` care va primi id-ul utilizatorului
+        și noul nume al utilizatorului și va modifica numele utilizatorului respectiv.
+        Clasa `Sistem` trebuie să conțină și metoda `sterge_utilizator` care va primi id-ul utilizatorului
+        și va șterge utilizatorul respectiv.
+        Clasa `Sistem` trebuie să conțină și metoda `modifica_nivel_acces` care va primi id-ul utilizatorului
+        și noul nivel de acces al utilizatorului și va modifica nivelul de acces al utilizatorului respectiv.
     """
+
     def __init__(self, class_user, class_sistem):
         self.class_user = class_user
         self.class_sistem = class_sistem
@@ -72,14 +93,21 @@ def check_task(self):
 
 
 class Task3:
-    """1. Creează o clasă `TechSolutionsApp` care va conține o valoare a clasei `versiune_applicatie` cu valoarea implicită "1.0".
-        Această clasă va avea nevoie de 3 metode, fiecare dintre acestea va fi utilizată pentru a simula interacțiunea cu sistemul nostru.
-        De asemenea clasa va primi ca argument la inițializare o valoare ce va reprezenta versiunea aplicatiei care va fi stocată în atributul `self.versiune_aplicatie`.
+    """1. Creează o clasă `TechSolutionsApp` care va conține o valoare a clasei `versiune_applicatie`
+    cu valoarea implicită "1.0".
+        Această clasă va avea nevoie de 3 metode, fiecare dintre acestea va fi utilizată pentru a simula interacțiunea
+        cu sistemul nostru.
+        De asemenea clasa va primi ca argument la inițializare o valoare ce va reprezenta versiunea aplicatiei
+        care va fi stocată în atributul `self.versiune_aplicatie`.
 
-        Metoda `market_view` va fi o metodă statică care nu va avea acces la self sau cls și va returna string-ul "Vizualizare piață".
-        Metoda `delogat_view` va fi o metodă de clasă care va avea acces la cls și va returna string-ul "Versiunea aplicației este *versiune-aplicatie*" utilizând atributul clasei.
-        Metoda `account_view` va fi o metodă de instanță care va avea acces la self și va returna string-ul "Vizualizare aplicație user *versiune-aplicatie*" utilizând atributul instanței.
+        Metoda `market_view` va fi o metodă statică care nu va avea acces la self sau cls
+        și va returna string-ul "Vizualizare piață".
+        Metoda `delogat_view` va fi o metodă de clasă care va avea acces la cls și va returna string-ul
+        "Versiunea aplicației este *versiune-aplicatie*" utilizând atributul clasei.
+        Metoda `account_view` va fi o metodă de instanță care va avea acces la self și va returna string-ul
+        "Vizualizare aplicație user *versiune-aplicatie*" utilizând atributul instanței.
     """
+
     def __init__(self, class_app):
         self.class_app = class_app
 
@@ -93,8 +121,10 @@ def check_task(self):
         except AssertionError:
             return False
 
+
 class Lesson14:
     """Test class for checking the implementation of tasks in lesson 13 of the Python Odyssey Bootcamp."""
+
     def __init__(self):
         self.status_tasks = {f"task_{i}": False for i in range(1, 4)}
 
@@ -107,7 +137,7 @@ def check_task(self, task_number, *args):
             if self.status_tasks[f"task_{task_number}"]:
                 return f"Task {task_number}: Correct! Well done."
             return f"Task {task_number}: Incorrect! Please try again."
-        except Exception as e:
+        except:
             return f"Task {task_number}: Error!"
 
     def get_completion_percentage(self):
diff --git a/sigmoid_check/python_odyssey/lesson_15/__init__.py b/sigmoid_check/python_odyssey/lesson_15/__init__.py
index 70b87e4..cd45e25 100644
--- a/sigmoid_check/python_odyssey/lesson_15/__init__.py
+++ b/sigmoid_check/python_odyssey/lesson_15/__init__.py
@@ -1 +1 @@
-from .lesson import Lesson15
\ No newline at end of file
+from .lesson import Lesson15
diff --git a/sigmoid_check/python_odyssey/lesson_15/lesson.py b/sigmoid_check/python_odyssey/lesson_15/lesson.py
index b01c4b3..c0972d7 100644
--- a/sigmoid_check/python_odyssey/lesson_15/lesson.py
+++ b/sigmoid_check/python_odyssey/lesson_15/lesson.py
@@ -1,6 +1,8 @@
 class Task1:
-    """Primul pas în crearea algoritmului este implementarea unor containere de date care va permite stocarea și manipularea datelor într-un mod mai simplu
-    și eficient. Trebuie să creezi o clasă nouă `DataContainer`. Pentru a manipula datele vom folosi metodele speciale ale clasei.
+    """Primul pas în crearea algoritmului este implementarea unor containere de date care va permite stocarea
+    și manipularea datelor într-un mod mai simplu
+    și eficient. Trebuie să creezi o clasă nouă `DataContainer`.
+    Pentru a manipula datele vom folosi metodele speciale ale clasei.
 
     Clasa va primi ca parametru o listă de numere integer.
     - __init__ initializează clasa cu lista de numere.
@@ -10,6 +12,7 @@ class Task1:
     - __setitem__ va permite modificarea elementelor din listă folosind indexul (e.g., container[0] = 5).
     - __add__ va permite combinarea a două instanțe de `DataContainer` într-o singură instanță.
     """
+
     def __init__(self, class_data_container):
         self.class_data_container = class_data_container
 
@@ -28,12 +31,15 @@ def check_task(self):
         except:
             return False
 
+
 class Task2:
-    """Acum avem nevoie de o modalitate de a calcula suma și produsul containerului de date. Pentru aceasta creează două clase noi care vor moșteni clasa `DataContainer`.
+    """Acum avem nevoie de o modalitate de a calcula suma și produsul containerului de date. Pentru aceasta creează
+    două clase noi care vor moșteni clasa `DataContainer`.
     - `SumaContainer` va calcula suma elementelor din listă.
     - `ProdusContainer` va calcula produsul elementelor din listă.
     Ambele clase vor avea metoda `calculate` care va returna suma sau produsul elementelor.
     """
+
     def __init__(self, class_suma_container, class_produs_container, class_data_container):
         self.class_suma_container = class_suma_container
         self.class_produs_container = class_produs_container
@@ -49,6 +55,7 @@ def check_task(self):
         except:
             return False
 
+
 class Task3:
     """Pentru ca instrumentul pe care îl folosim să fie complet vom mai avea nevoie de careva adiții.
     Creează o clasă `DataAnalysis` care va primi ca input o listă de obiecte de tipul `DataContainer`.
@@ -56,6 +63,7 @@ class Task3:
     - `add_container` va permite adăugarea unui nou container în listă.
     - `__call__` va returna o listă cu valorile maxime ale fiecărui container.
     """
+
     def __init__(self, class_data_analysis, class_data_container):
         self.class_data_analysis = class_data_analysis
         self.class_data_container = class_data_container
@@ -72,6 +80,7 @@ def check_task(self):
         except:
             return False
 
+
 class Task4:
     """Pe lângă elementul de analiză a datelor, Microsoft a mai cerut și un element de statistică.
     Creează o clasă `DataStatistics` care va primi ca input o listă de obiecte de tipul `DataContainer`.
@@ -82,6 +91,7 @@ class Task4:
     - `min` va returna valoarea minimă din toate containerele.
     - `sum` va returna suma elementelor din toate containerele.
     """
+
     def __init__(self, class_data_statistics, class_data_container):
         self.class_data_statistics = class_data_statistics
         self.class_data_container = class_data_container
@@ -99,6 +109,7 @@ def check_task(self):
         except:
             return False
 
+
 class Task5:
     """Creează o clasă `DataFilter` care va primi ca input o listă de obiecte de tipul `DataContainer`.
     - __init__ va inițializa clasa cu lista de obiecte.
@@ -106,8 +117,10 @@ class Task5:
     - `filter_zeros` va returna o listă cu toate elementele care sunt diferite de 0.
     - `filter_negatives` va returna o listă cu toate elementele care sunt mai mari sau egale cu 0.
     - `filter_positives` va returna o listă cu toate elementele care sunt mai mici sau egale cu 0.
-    - `filter_under_mean` va returna o listă cu toate elementele care sunt mai mari decât media aritmetică a tuturor elementelor calculate cu metoda `mean` din clasa `DataStatistics`.
+    - `filter_under_mean` va returna o listă cu toate elementele care sunt mai mari decât media aritmetică
+    a tuturor elementelor calculate cu metoda `mean` din clasa `DataStatistics`.
     """
+
     def __init__(self, class_data_filter, class_data_statistics, class_data_container):
         self.class_data_filter = class_data_filter
         self.class_data_statistics = class_data_statistics
@@ -118,7 +131,6 @@ def check_task(self):
             container1 = self.class_data_container([1, 2, 3, 0, -1, -2])
             container2 = self.class_data_container([4, 5, 6, 0, -3, -4])
             filter = self.class_data_filter([container1, container2])
-            stats = self.class_data_statistics([container1, container2])
             assert sorted(filter.filter_zeros()) == sorted([1, 2, 3, -1, -2, 4, 5, 6, -3, -4])
             assert sorted(filter.filter_negatives()) == sorted([-1, -2, -3, -4])
             assert sorted(filter.filter_positives()) == sorted([1, 2, 3, 0, 4, 5, 6, 0])
@@ -127,8 +139,10 @@ def check_task(self):
         except:
             return False
 
+
 class Lesson15:
     """Test class for checking the implementation of tasks in lesson 15 of the Python Odyssey Bootcamp."""
+
     def __init__(self):
         self.status_tasks = {f"task_{i}": False for i in range(1, 6)}
 
@@ -141,13 +155,14 @@ def check_task(self, task_number, *args):
             if self.status_tasks[f"task_{task_number}"]:
                 return f"Task {task_number}: Correct! Well done."
             return f"Task {task_number}: Incorrect! Please try again."
-        except Exception as e:
+        except:
             return f"Task {task_number}: Error!"
 
     def get_completion_percentage(self):
         completed = sum([1 for task in self.status_tasks if self.status_tasks[task]])
         return f"Your completion percentage is {completed * 100 / len(self.status_tasks)}%"
 
+
 class DataContainer:
     def __init__(self, data):
         """
@@ -186,4 +201,4 @@ def __add__(self, other):
         if isinstance(other, DataContainer):
             combined_data = self.data + other.data
             return DataContainer(combined_data)
-        raise TypeError("Can only add another DataContainer instance.")
\ No newline at end of file
+        raise TypeError("Can only add another DataContainer instance.")
diff --git a/sigmoid_check/python_odyssey/lesson_16/__init__.py b/sigmoid_check/python_odyssey/lesson_16/__init__.py
index 0f7ac11..abcbf12 100644
--- a/sigmoid_check/python_odyssey/lesson_16/__init__.py
+++ b/sigmoid_check/python_odyssey/lesson_16/__init__.py
@@ -1 +1 @@
-from .lesson import Lesson16
\ No newline at end of file
+from .lesson import Lesson16
diff --git a/sigmoid_check/python_odyssey/lesson_16/lesson.py b/sigmoid_check/python_odyssey/lesson_16/lesson.py
index 8c2538a..7748f6b 100644
--- a/sigmoid_check/python_odyssey/lesson_16/lesson.py
+++ b/sigmoid_check/python_odyssey/lesson_16/lesson.py
@@ -1,9 +1,10 @@
-import time
 import itertools
+import time
 
 
 class Task1:
     """Creează o funcție lambda numită `task1` care adaugă 10 la un număr dat."""
+
     def __init__(self, func):
         self.func = func
 
@@ -14,21 +15,25 @@ def check_task(self):
         except:
             return False
 
+
 class Task2:
     """Creează o funcție lambda numită `task2` care verifică dacă un număr este par."""
+
     def __init__(self, func):
         self.func = func
 
     def check_task(self):
         try:
-            assert self.func(4) == True
-            assert self.func(5) == False
+            assert self.func(4) is True
+            assert self.func(5) is False
             return True
         except:
             return False
 
+
 class Task3:
     """Creează o funcție lambda numită `task3` care înmulțește două numere."""
+
     def __init__(self, func):
         self.func = func
 
@@ -40,8 +45,10 @@ def check_task(self):
         except:
             return False
 
+
 class Task4:
     """Crează o funcție lambda numită `task4` care returnează lungimea unui șir de caractere."""
+
     def __init__(self, func):
         self.func = func
 
@@ -53,8 +60,10 @@ def check_task(self):
         except:
             return False
 
+
 class Task5:
     """Creează o funcție lambda numită `task5` care convertește un șir de caractere în majuscule."""
+
     def __init__(self, func):
         self.func = func
 
@@ -66,8 +75,10 @@ def check_task(self):
         except:
             return False
 
+
 class Task6:
     """Creează o funcție lambda numită `task6` care găsește maximul dintre trei numere."""
+
     def __init__(self, func):
         self.func = func
 
@@ -79,8 +90,10 @@ def check_task(self):
         except:
             return False
 
+
 class Task7:
     """Creează o funcție lambda numită `task7` care concatenează două șiruri de caractere cu un spațiu între ele."""
+
     def __init__(self, func):
         self.func = func
 
@@ -92,8 +105,10 @@ def check_task(self):
         except:
             return False
 
+
 class Task8:
     """Creează o funcție lambda numită `task8` care filtrează numerele impare dintr-o listă și le returnează."""
+
     def __init__(self, func):
         self.func = func
 
@@ -105,8 +120,11 @@ def check_task(self):
         except:
             return False
 
+
 class Task9:
-    """Creează o funcție lambda numită `task9` care calculează factorialul unui număr folosind funcția reduce din functools (google it!)."""
+    """Creează o funcție lambda numită `task9` care calculează factorialul unui număr folosind funcția reduce
+    din functools (google it!)."""
+
     def __init__(self, func):
         self.func = func
 
@@ -118,8 +136,10 @@ def check_task(self):
         except:
             return False
 
+
 class Task10:
     """Creează o funcție lambda numită `task10` care sortează o listă de tuple după a doua valoare din fiecare tuple."""
+
     def __init__(self, func):
         self.func = func
 
@@ -131,8 +151,10 @@ def check_task(self):
         except:
             return False
 
+
 class Task11:
     """Creează o funcție lambda numită `task11` care returnează rădăcina pătrată a unui număr."""
+
     def __init__(self, func):
         self.func = func
 
@@ -144,21 +166,25 @@ def check_task(self):
         except:
             return False
 
+
 class Task12:
     """Creează o funcție lambda numită `task12` care verifică dacă un șir de caractere este palindrom."""
+
     def __init__(self, func):
         self.func = func
 
     def check_task(self):
         try:
-            assert self.func("madam") == True
-            assert self.func("hello") == False
+            assert self.func("madam") is True
+            assert self.func("hello") is False
             return True
         except:
             return False
 
+
 class Task13:
     """Creează o funcție lambda numită `task13` care numără numărul de vocale dintr-un șir de caractere."""
+
     def __init__(self, func):
         self.func = func
 
@@ -170,8 +196,10 @@ def check_task(self):
         except:
             return False
 
+
 class Task14:
     """Creează o funcție lambda numită `task14` care returnează inversul unui șir de caractere."""
+
     def __init__(self, func):
         self.func = func
 
@@ -183,8 +211,11 @@ def check_task(self):
         except:
             return False
 
+
 class Task15:
-    """Creează o funcție lambda numită `task15` care filtrează toate șirurile de caractere mai lungi de 5 caractere dintr-o listă."""
+    """Creează o funcție lambda numită `task15` care filtrează toate șirurile
+    de caractere mai lungi de 5 caractere dintr-o listă."""
+
     def __init__(self, func):
         self.func = func
 
@@ -196,8 +227,10 @@ def check_task(self):
         except:
             return False
 
+
 class Task16:
     """Creează o funcție lambda numită `task16` care sortează o listă de dicționare după o cheie specificată."""
+
     def __init__(self, func):
         self.func = func
 
@@ -210,8 +243,10 @@ def check_task(self):
         except:
             return False
 
+
 class Task17:
     """Creează o funcție lambda numită `task17` care găsește cel mai mare divizor comun al două numere."""
+
     def __init__(self, func):
         self.func = func
 
@@ -223,8 +258,10 @@ def check_task(self):
         except:
             return False
 
+
 class Task18:
     """Creează o funcție lambda numită `task18` care calculează suma pătratelor numerelor pare dintr-o listă."""
+
     def __init__(self, func):
         self.func = func
 
@@ -236,21 +273,25 @@ def check_task(self):
         except:
             return False
 
+
 class Task19:
     """Creează o funcție lambda numită `task19` care verifică dacă un an dat este bisect."""
+
     def __init__(self, func):
         self.func = func
 
     def check_task(self):
         try:
-            assert self.func(2020) == True
-            assert self.func(2019) == False
+            assert self.func(2020) is True
+            assert self.func(2019) is False
             return True
         except:
             return False
 
+
 class Task20:
     """Creează o funcție lambda numită `task20` care găsește cel mai lung cuvânt dintr-o listă de cuvinte."""
+
     def __init__(self, func):
         self.func = func
 
@@ -262,10 +303,13 @@ def check_task(self):
         except:
             return False
 
+
 # Generators
 
+
 class Task21:
     """Creează un generator numit `task21` care generează numere de la 1 la 10."""
+
     def __init__(self, func):
         self.func = func
 
@@ -277,21 +321,25 @@ def check_task(self):
         except:
             return False
 
+
 class Task22:
     """Creează un generator numit `task22` care generează pătratele numerelor de la 1 la 10."""
+
     def __init__(self, func):
         self.func = func
 
     def check_task(self):
         try:
             gen = self.func()
-            assert list(gen) == [i ** 2 for i in range(1, 11)]
+            assert list(gen) == [i**2 for i in range(1, 11)]
             return True
         except:
             return False
 
+
 class Task23:
     """Creează un generator numit `task23` care generează caracterele unui string primit ca input unul câte unul."""
+
     def __init__(self, func):
         self.func = func
 
@@ -303,8 +351,10 @@ def check_task(self):
         except:
             return False
 
+
 class Task24:
     """Creează un generator numit `task24` care generează numere pare până la un limită dată ca input."""
+
     def __init__(self, func):
         self.func = func
 
@@ -316,8 +366,10 @@ def check_task(self):
         except:
             return False
 
+
 class Task25:
     """Creează un generator numit `task25` care primește ca input un număr n și generează primele n numere Fibonacci."""
+
     def __init__(self, func):
         self.func = func
 
@@ -329,8 +381,10 @@ def check_task(self):
         except:
             return False
 
+
 class Task26:
     """Creează un generator numit `task26` care generează numere prime până la o limită dată ca input."""
+
     def __init__(self, func):
         self.func = func
 
@@ -342,8 +396,11 @@ def check_task(self):
         except:
             return False
 
+
 class Task27:
-    """Creează un generator numit `task27` care generează numere într-un interval specificat start, și end cu un pas dat."""
+    """Creează un generator numit `task27` care generează numere într-un interval specificat start,
+    și end cu un pas dat."""
+
     def __init__(self, func):
         self.func = func
 
@@ -355,12 +412,14 @@ def check_task(self):
         except:
             return False
 
+
 class Task28:
     """Creează un generator numit `task28` care generează toate subșirurile unui șir oferit sub formă de string.
     Exemplu:
     pentru input-ul "ciao"
     output-ul va fi: "c", "ci", "cia", "ciao", "i", "ia", "iao", "a", "ao", "o"
     """
+
     def __init__(self, func):
         self.func = func
 
@@ -372,8 +431,10 @@ def check_task(self):
         except:
             return False
 
+
 class Task29:
     """Creează un generator numit `task29` care generează factorialul numerelor de la 1 la n primind n ca input."""
+
     def __init__(self, func):
         self.func = func
 
@@ -385,8 +446,11 @@ def check_task(self):
         except:
             return False
 
+
 class Task30:
-    """Creează un generator numit `task30` care generează cifrele unui număr în ordine inversă primind numărul ca input."""
+    """Creează un generator numit `task30`
+    care generează cifrele unui număr în ordine inversă primind numărul ca input."""
+
     def __init__(self, func):
         self.func = func
 
@@ -398,30 +462,31 @@ def check_task(self):
         except:
             return False
 
+
 class Task31:
     """Creează un generator numit `task31` care generează toate combinațiile posibile ale elementelor dintr-o listă.
     Exemplu:
     pentru input-ul [1, 2, 3, 4]
-    output-ul va fi: (1,), (2,), (3,), (4,), (1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (3, 4), (1, 2, 3), (1, 2, 4), (1, 3, 4), (2, 3, 4), (1, 2, 3, 4)
+    output-ul va fi: (1,), (2,), (3,), (4,), (1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (3, 4), (1, 2, 3), (1, 2, 4),
+    (1, 3, 4), (2, 3, 4), (1, 2, 3, 4)
     """
+
     def __init__(self, func):
         self.func = func
 
     def check_task(self):
         try:
             gen = self.func([1, 2, 3])
-            expected_combinations = [
-                (1,), (2,), (3,),
-                (1, 2), (1, 3), (2, 3),
-                (1, 2, 3)
-            ]
+            expected_combinations = [(1,), (2,), (3,), (1, 2), (1, 3), (2, 3), (1, 2, 3)]
             assert list(gen) == expected_combinations
             return True
         except:
             return False
 
+
 class Task32:
     """Creează un generator numit `task32` care generează suma curentă a unei liste de numere primite ca input."""
+
     def __init__(self, func):
         self.func = func
 
@@ -433,12 +498,16 @@ def check_task(self):
         except:
             return False
 
+
 class Task33:
-    """Creează un generator numit `task33` care generează primele n termeni ai unei secvențe aritmetice primind a, d și n ca input unde a este primul termen, d este diferența sau pasul de creștere și n este numărul de termeni.
+    """Creează un generator numit `task33` care generează primele n termeni ai unei secvențe aritmetice
+    primind a, d și n ca input unde a este primul termen,
+    d este diferența sau pasul de creștere și n este numărul de termeni.
     Exemplu:
     pentru input-ul a=1, d=2, n=5
     output-ul va fi: 1, 3, 5, 7, 9
     """
+
     def __init__(self, func):
         self.func = func
 
@@ -450,8 +519,10 @@ def check_task(self):
         except:
             return False
 
+
 class Task34:
     """Creează un generator numit `task34` care generează puterile lui 2 până la o limită dată ca input (inclusiv)."""
+
     def __init__(self, func):
         self.func = func
 
@@ -463,12 +534,15 @@ def check_task(self):
         except:
             return False
 
+
 class Task35:
-    """Creează un generator numit `task35` care generează numere într-o secvență geometrică infinită primind a și r ca input unde a este primul termen și r este rația.
+    """Creează un generator numit `task35` care generează numere într-o
+    secvență geometrică infinită primind a și r ca input unde a este primul termen și r este rația.
     Exemplu:
     pentru input-ul a=2, r=3
     output-ul va fi: 2, 6, 18, 54, 162, ...
     """
+
     def __init__(self, func):
         self.func = func
 
@@ -481,12 +555,14 @@ def check_task(self):
         except:
             return False
 
+
 class Task36:
     """Creează un generator numit `task36` care generează permutările unei liste primite ca input.
     Exemplu:
     pentru input-ul [1, 2, 3]
     output-ul va fi: (1, 2, 3), (1, 3, 2), (2, 1, 3), (2, 3, 1), (3, 1, 2), (3, 2, 1)
     """
+
     def __init__(self, func):
         self.func = func
 
@@ -498,8 +574,10 @@ def check_task(self):
         except:
             return False
 
+
 class Task37:
     """Creează un generator numit `task37` care generează toți factorii primi ai unui număr dat ca input."""
+
     def __init__(self, func):
         self.func = func
 
@@ -511,8 +589,11 @@ def check_task(self):
         except:
             return False
 
+
 class Task38:
-    """Creează un generator numit `task38` care generează reprezentarea binară a numerelor de la 1 la n primind n ca input."""
+    """Creează un generator numit `task38` care generează reprezentarea binară
+    a numerelor de la 1 la n primind n ca input."""
+
     def __init__(self, func):
         self.func = func
 
@@ -524,12 +605,14 @@ def check_task(self):
         except:
             return False
 
+
 class Task39:
     """Creează un generator numit `task39` care generează toate anagramele unui șir dat ca input.
     Exemplu:
     pentru input-ul "abc"
     output-ul va fi: "abc", "acb", "bac", "bca", "cab", "cba"
     """
+
     def __init__(self, func):
         self.func = func
 
@@ -541,14 +624,17 @@ def check_task(self):
         except:
             return False
 
+
 class Task40:
-    """Creează un generator numit `task40` care generează termenii unei serii matematice simple. 
+    """Creează un generator numit `task40` care generează termenii unei serii matematice simple.
     De exemplu, acest generator va produce termenii unei serii în care fiecare termen este dat de formula:
 
     termen = (-1)^n / n!
 
-    Aici, n este indexul termenului (începând de la 0), iar n! (n factorial) este produsul tuturor numerelor întregi pozitive până la n.
+    Aici, n este indexul termenului (începând de la 0), iar n! (n factorial) este produsul tuturor numerelor întregi
+    pozitive până la n.
     """
+
     def __init__(self, func):
         self.func = func
 
@@ -561,51 +647,67 @@ def check_task(self):
             return True
         except:
             return False
+
+
 # Decorators
 
+
 class Task41:
-    """Creează un decorator numit `task41` care afișează timpul de execuție al unei funcții în formatul "Execution time: x seconds"."""
+    """Creează un decorator numit `task41` care afișează timpul de execuție al unei funcții în formatul
+    "Execution time: x seconds"."""
+
     def __init__(self, func):
         self.func = func
 
     def check_task(self):
         try:
+
             @self.func
             def dummy_function():
                 time.sleep(1)
                 return "Done"
+
             result = dummy_function()
             assert result == "Done"
             return True
         except:
             return False
 
+
 class Task42:
     """Creează un decorator numit `task42` care afișează mesaje "Before" și "After" în jurul apelului unei funcții."""
+
     def __init__(self, func):
         self.func = func
 
     def check_task(self):
         try:
+
             @self.func
             def dummy_function():
                 return "Done"
+
             result = dummy_function()
             assert result == "Done"
             return True
         except:
             return False
 
+
 class Task43:
-    """Creează un decorator numit `task43` care memorează rezultatele unei funcții într-un dicționar `cache` pentru a le returna direct dacă aceleași argumente sunt folosite din nou."""
+    """Creează un decorator numit `task43` care memorează rezultatele unei funcții
+    într-un dicționar `cache` pentru a le returna direct dacă aceleași argumente sunt folosite din nou."""
+
     def __init__(self, func):
         self.func = func
 
     def check_task(self):
         try:
+
             @self.func
             def dummy_function(x):
                 return x + 10
+
             result1 = dummy_function(5)
             result2 = dummy_function(5)
             assert result1 == 15
@@ -614,16 +716,21 @@ def dummy_function(x):
         except:
             return False
 
+
 class Task44:
-    """Creează un decorator numit `task44` care numără de câte ori o funcție este apelată. La fiecare apel, afișează numărul de apeluri în formatul "Count: x"."""
+    """Creează un decorator numit `task44` care numără de câte ori o funcție este apelată.
+    La fiecare apel, afișează numărul de apeluri în formatul "Count: x"."""
+
     def __init__(self, func):
         self.func = func
 
     def check_task(self):
         try:
+
             @self.func
             def dummy_function():
                 return "Done"
+
             result1 = dummy_function()
             result2 = dummy_function()
             assert result1 == "Done"
@@ -632,82 +739,106 @@ def dummy_function():
         except:
             return False
 
+
 class Task45:
     """Creează un decorator numit `task45` care convertește rezultatul unei funcții în majuscule."""
+
     def __init__(self, func):
         self.func = func
 
     def check_task(self):
         try:
+
             @self.func
             def dummy_function():
                 return "done"
+
             result = dummy_function()
             assert result == "DONE"
             return True
         except:
             return False
 
+
 class Task46:
-    """Creează un decorator numit `task46` care reîncearcă o funcție dacă aceasta aruncă o excepție. Dacă funcția aruncă o excepție, decoratorul va încerca să o apeleze din nou de 3 ori."""
+    """Creează un decorator numit `task46` care reîncearcă o funcție dacă aceasta aruncă o excepție.
+    Dacă funcția aruncă o excepție, decoratorul va încerca să o apeleze din nou de 3 ori."""
+
     def __init__(self, func):
         self.func = func
 
     def check_task(self):
         try:
+
             @self.func
             def dummy_function():
                 raise ValueError("Test")
+
             dummy_function()
             return False
         except ValueError:
             return True
 
+
 class Task47:
-    """Creează un decorator numit `task47` care adaugă o valoare specificată la valoarea returnată de o funcție primind valoarea ca input."""
+    """Creează un decorator numit `task47` care adaugă o valoare specificată la valoarea returnată
+    de o funcție primind valoarea ca input."""
+
     def __init__(self, func):
         self.func = func
 
     def check_task(self):
         try:
+
             @self.func(5)
             def dummy_function(x):
                 return x
+
             result = dummy_function(10)
             assert result == 15
             return True
         except:
             return False
 
+
 class Task48:
-    """Creează un decorator numit `task48` care validează tipurile argumentelor primite de o funcție și aruncă o excepție `TypeError` dacă tipurile nu sunt cele așteptate."""
+    """Creează un decorator numit `task48` care validează tipurile argumentelor primite de o funcție
+    și aruncă o excepție `TypeError` dacă tipurile nu sunt cele așteptate."""
+
     def __init__(self, func):
         self.func = func
 
     def check_task(self):
         try:
+
             @self.func([int, int])
             def dummy_function(x, y):
                 return x + y
+
             result = dummy_function(5, 10)
             assert result == 15
             return True
         except:
             return False
 
+
 class Task49:
-    """Creează un decorator numit `task49` care asigură că o funcție este apelată doar de utilizatori cu un anumit rol. Utilizând decoratorul, vei specifica rolul necesar pentru a apela funcția.
+    """Creează un decorator numit `task49` care asigură că o funcție este apelată doar de utilizatori cu un anumit rol.
+    Utilizând decoratorul, vei specifica rolul necesar pentru a apela funcția.
 
     Aceasta va arunca o excepție `PermissionError` dacă utilizatorul nu are rolul specificat.
     """
+
     def __init__(self, func):
         self.func = func
 
     def check_task(self):
         try:
+
             @self.func("admin")
-            def dummy_function():
+            def dummy_function(user):
                 return "Done"
+
             dummy_function("user")
             return False
         except PermissionError:
@@ -717,6 +848,7 @@ def dummy_function():
 
 class Lesson16:
     """Test class for checking the implementation of tasks in lesson 16 of the Python Odyssey Bootcamp."""
+
     def __init__(self):
         self.status_tasks = {f"task_{i}": False for i in range(1, 50)}
 
diff --git a/tox.ini b/tox.ini
new file mode 100644
index 0000000..ff0bb81
--- /dev/null
+++ b/tox.ini
@@ -0,0 +1,29 @@
+[tox]
+envlist = py{310,312}
+
+[testenv]
+parallel_show_output = True
+usedevelop = True
+passenv = *
+deps =
+    setuptools>=73.0.1
+    flake8
+    pylint
+    black
+    isort
+    pydocstyle
+    -e .
+commands =
+    python setup.py check -m -s
+    pylint -E ./sigmoid_check
+    flake8 --ignore=E203,W503,E722 .
+    black --line-length=120 --exclude="E203, W503, venv" --check --diff ./sigmoid_check/
+    isort --line-length=120 --check --profile black --diff ./sigmoid_check/
+    pydocstyle --convention=google --add-ignore="D100, D104, D205, D101, D415" --match=".*.py" ./sigmoid_check/
+
+[flake8]
+max-line-length = 120
+exclude = .tox,*.egg,build,data,venv
+select = E,W,F
+per-file-ignores =
+    */__init__.py:F401