ddd_domain_modeling - first week

.github/workflows/pylint.yml

@@ -14,4 +14,17 @@ jobs:
         with:
           python-version: "3.11"
       - name: flake8 Lint
-        uses: py-actions/flake8@v2
+        uses: py-actions/flake8@v2
+  mypy:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Setup Python
+        uses: actions/setup-python@v4
+        with:
+          python-version: "3.11"
+      - name: Checkout
+        uses: actions/checkout@v3
+      - name: Install mypy
+        run: pip install mypy
+      - name: Run mypy
+        run: python -m mypy

pyproject.toml

@@ -28,6 +28,14 @@ mysqlclient = "2.2.0"
 [tool.poetry.group.jupyter.dependencies]
 matplotlib = "^3.9.2"
 
+
+[tool.poetry.group.dev.dependencies]
+mypy = "^1.11.2"
+
 [build-system]
 requires = ["poetry-core"]
 build-backend = "poetry.core.masonry.api"
+
+[tool.mypy]
+files = ['src', 'tests']
+ignore_missing_imports = true

src/algos/array/trapping_rain_water.py

@@ -2,34 +2,34 @@ def trap_rain_water(heights: list[int]) -> int:
     ans = 0
 
     for i in range(1, len(heights)-1):
-        maxL, maxR = 0, 0
+        max_l, max_r = 0, 0
 
         for left in range(i, -1, -1):
-            maxL = max(maxL, heights[left])
+            max_l = max(max_l, heights[left])
 
         for right in range(i, len(heights)):
-            maxR = max(maxR, heights[right])
+            max_r = max(max_r, heights[right])
 
-        ans += min(maxL, maxR) - heights[i]
+        ans += min(max_l, max_r) - heights[i]
 
     return ans
 
 
 def trap_rain_water_dp(heights: list[int]) -> int:
     ans = 0
-    leftMax = [0 for _ in range(len(heights))]
-    rightMax = [0 for _ in range(len(heights))]
+    left_max = [0 for _ in range(len(heights))]
+    right_max = [0 for _ in range(len(heights))]
 
-    leftMax[0] = heights[0]
-    rightMax[-1] = heights[-1]
+    left_max[0] = heights[0]
+    right_max[-1] = heights[-1]
 
     for i in range(1, len(heights)):
-        leftMax[i] = max(heights[i], leftMax[i - 1])
+        left_max[i] = max(heights[i], left_max[i - 1])
 
     for i in range(len(heights) - 2, 0, -1):
-        rightMax[i] = max(heights[i], rightMax[i+1])
+        right_max[i] = max(heights[i], right_max[i+1])
 
     for i in range(1, len(heights) - 1):
-        ans += min(leftMax[i], rightMax[i]) - heights[i]
+        ans += min(left_max[i], right_max[i]) - heights[i]
 
     return ans

src/algos/array/two_pointers/squares_of_sorted_array.py

@@ -34,7 +34,7 @@ def return_squares(l1: list[int]) -> list[int]:
             ans[i] = negative_num ** 2
             left -= 1
         else:
-            if positive_num == 0 or (abs(positive_num) < abs(negative_num)):
+            if positive_num == 0 or int((abs(positive_num) < abs(negative_num))):
                 ans[i] = positive_num ** 2
                 right += 1
             else:

src/algos/general/create_substeps.py

@@ -1,3 +1,6 @@
+"""_summary_"""
+
+
 def create_substeps(nums: list):
     index = 1
     sub_steps = []

src/algos/general/decode.py

@@ -1,6 +1,9 @@
+"""_summary_"""
+
+
 def decode(message_file: str):
     try:
-        with open(message_file, 'r') as file:
+        with open(message_file, 'r', encoding='utf-8') as file:
             text_lines = file.read().splitlines()
     except FileNotFoundError:
         print(f"file doesn't exist: {message_file}")

src/algos/general/is_prime.py

@@ -1,7 +1,17 @@
+"""_summary_
+"""
 from math import sqrt
 
 
 def is_prime(num: int) -> bool:
+    """_summary_
+
+    Args:
+        num (int): _description_
+
+    Returns:
+        bool: _description_
+    """
     if num > 1:
         for i in range(2, int(sqrt(num)) + 1):
             if num % i == 0:

src/algos/trees/dfs/__init__.py

@@ -1,2 +1,2 @@
 from .reversal import reverse_tree, invert_tree
-from .tree_depth import max_depth, min_depth
+from .tree_depth import max_depth

src/algos/trees/dfs/sum.py

@@ -24,6 +24,6 @@ def helper(root: Optional[TreeNode], cur_bits: list[int], ans: list[int]):
             rest = sum([2 ** (len(cur_bits) - i - 1) for i, bit in enumerate(cur_bits[:-1]) if bit == 1])
             ans.append(rest + first_bit)
 
-    ans = []
+    ans: list[int] = []
     helper(root, [], ans)
     return sum(ans)

src/algos/trees/dfs/tree_depth.py

@@ -9,7 +9,3 @@ def max_depth(root: Optional[TreeNode]) -> int:
     left_max = max_depth(root.left)
     right_max = max_depth(root.right)
     return max(left_max, right_max) + 1
-
-
-def min_depth(root: Optional[TreeNode]) -> int:
-    ...

src/algos/trees/traversal/iterative_traversal.py

@@ -6,7 +6,7 @@ def iterative_inorder_traversal(root: Optional[TreeNode], ans: list[int]):
     cur = root
     stack = []
 
-    while len(stack) or cur:
+    while len(stack) > 0 or cur:
         while cur:
             stack.append(cur)
             cur = cur.left

src/algos/trees/traversal/recursive_traversal.py

@@ -7,8 +7,8 @@ def recursive_preorder_traversal(root: Optional[TreeNode], nums: list[int]):
         return
 
     nums.append(root.val)
-    recursive_preorder_traversal(root.left)
-    recursive_preorder_traversal(root.right)
+    recursive_preorder_traversal(root.left, nums)
+    recursive_preorder_traversal(root.right, nums)
 
 
 def recursive_inorder_traversal(root: Optional[TreeNode], nums: list[int]):

src/data_structures/graphs/disjoint_set.py

@@ -7,12 +7,12 @@ def __find(self, x):
         return self._root[x]
 
     def union(self, x: int, y: int):
-        rootX = self.__find(x)
-        rootY = self.__find(y)
+        root_x = self.__find(x)
+        root_y = self.__find(y)
 
         for i in range(self.size):
-            if self._root[i] == rootY:
-                self._root[i] = rootX
+            if self._root[i] == root_y:
+                self._root[i] = root_x
 
     def connected(self, x: int, y: int) -> bool:
         return self.__find(x) == self.__find(y)
@@ -33,11 +33,11 @@ def __find(self, x):
         return x
 
     def union(self, x: int, y: int):
-        rootX = self.__find(x)
-        rootY = self.__find(y)
+        root_x = self.__find(x)
+        root_y = self.__find(y)
 
-        if rootX != rootY:
-            self._root[rootY] = rootX
+        if root_x != root_y:
+            self._root[root_y] = root_x
 
     def connected(self, x: int, y: int) -> bool:
         return self.__find(x) == self.__find(y)

src/data_structures/linked_list.py

@@ -1,8 +1,8 @@
 class LinkedList:
 
-    def __init__(self, val: int, next=None):
+    def __init__(self, val: int, next_list=None):
         self._val = val
-        self.next = next
+        self.next = next_list
 
     @property
     def val(self):

src/domain_driven_design/cosmic_python/README.md

@@ -0,0 +1 @@
+https://www.cosmicpython.com/book/chapter_01_domain_model.html