merged upstream main and resolved conflicts

Author: paltannistha

.github/data/contributors-log.json

@@ -19,10 +19,12 @@
   },
   "TIC_TAC_TOE": {
     "contributor-name": [
-      "06RAVI06"
+      "06RAVI06",
+      "Tithi234"
     ],
     "pull-request-number": [
-      "7"
+      "7",
+      "77"
     ],
     "demo-path": "TIC_TAC_TOE"
   },
@@ -150,10 +152,12 @@
   },
   "Pomodoro-Timer": {
     "contributor-name": [
-      "adedayoprcs"
+      "adedayoprcs",
+      "Tithi234"
     ],
     "pull-request-number": [
-      "21"
+      "21",
+      "73"
     ],
     "demo-path": "Pomodoro-Timer"
   },
@@ -285,10 +289,12 @@
   },
   "Auto-Clicker": {
     "contributor-name": [
-      "BasselDar"
+      "BasselDar",
+      "Tithi234"
     ],
     "pull-request-number": [
-      "54"
+      "54",
+      "70"
     ],
     "demo-path": "Auto-Clicker"
   },
@@ -309,5 +315,23 @@
       "62"
     ],
     "demo-path": "Motion-Detection"
+  },
+  "Bowling-Action-Tracking": {
+    "contributor-name": [
+      "musharrafhamraz"
+    ],
+    "pull-request-number": [
+      "67"
+    ],
+    "demo-path": "https://github.com/Grow-with-Open-Source/Python-Projects/tree/main/Bowling-Action-Tracking"
+  },
+  "Encryption_Project": {
+    "contributor-name": [
+      "moonabys"
+    ],
+    "pull-request-number": [
+      "75"
+    ],
+    "demo-path": "Encryption_Project"
   }
 }

Auto-Clicker/auto_clicker.py

@@ -2,33 +2,48 @@
 import keyboard
 import time
 
-clicking = False
 
+def run_auto_clicker(delay: float = 0.01) -> None:
+    """
+    Runs an auto clicker that can be controlled with keyboard hotkeys.
 
-def start_clicking():
-    global clicking
-    clicking = True
-    print("Auto clicker started")
+    Controls:
+    - Press 'S' to start clicking
+    - Press 'E' to stop clicking
+    - Press 'Q' to quit
+    """
+    clicking = False
 
+    def start_clicking():
+        nonlocal clicking
+        clicking = True
+        print("✅ Auto clicker started")
 
-def stop_clicking():
-    global clicking
-    clicking = False
-    print("Auto clicker stopped")
+    def stop_clicking():
+        nonlocal clicking
+        clicking = False
+        print("⏹ Auto clicker stopped")
+
+    keyboard.add_hotkey("s", start_clicking)
+    keyboard.add_hotkey("e", stop_clicking)
+
+    print("Press 'S' to start clicking")
+    print("Press 'E' to stop clicking")
+    print("Press 'Q' to quit")
 
+    try:
+        while True:
+            if clicking:
+                pyautogui.click()
+                time.sleep(delay)
 
-keyboard.add_hotkey("s", start_clicking)
-keyboard.add_hotkey("e", stop_clicking)
+            if keyboard.is_pressed("q"):
+                print("👋 Exiting program")
+                break
 
-print("Press 'S' to start clicking")
-print("Press 'E' to stop clicking")
-print("Press 'Q' to quit")
+    except KeyboardInterrupt:
+        print("\nProgram interrupted by user.")
 
-while True:
-    if clicking:
-        pyautogui.click()
-        time.sleep(0.001)
 
-    if keyboard.is_pressed("q"):
-        print("Exiting program")
-        break
+if __name__ == "__main__":
+    run_auto_clicker()

Bowling-Action-Tracking/main.py

@@ -0,0 +1,103 @@
+import cv2
+import mediapipe as mp
+import numpy as np
+from collections import deque
+
+# Initialize MediaPipe Pose
+mp_pose = mp.solutions.pose
+pose = mp_pose.Pose()
+mp_drawing = mp.solutions.drawing_utils
+
+# Initialize video capture
+cap = cv2.VideoCapture('bowling.mp4')
+
+# Store wrist trajectory and arcs
+wrist_trajectory = deque(maxlen=100)  # Main wrist trajectory
+wrist_positions = deque(maxlen=20)  # For arcs
+elbow_positions = deque(maxlen=20)
+shoulder_positions = deque(maxlen=20)
+
+# Function to convert normalized coordinates to pixel coordinates
+def to_pixel_coords(landmark, frame):
+    return int(landmark.x * frame.shape[1]), int(landmark.y * frame.shape[0])
+
+# Function to draw a gradient arc between two points
+def draw_gradient_arc(frame, p1, p2, thickness, start_color, end_color):
+    num_segments = 50
+    x_diff = (p2[0] - p1[0]) / num_segments
+    y_diff = (p2[1] - p1[1]) / num_segments
+
+    for i in range(num_segments):
+        # Compute start and end points of each segment
+        start_point = (int(p1[0] + i * x_diff), int(p1[1] + i * y_diff))
+        end_point = (int(p1[0] + (i + 1) * x_diff), int(p1[1] + (i + 1) * y_diff))
+        
+        # Interpolate color between start and end
+        alpha = i / num_segments
+        color = (
+            int(start_color[0] * (1 - alpha) + end_color[0] * alpha),
+            int(start_color[1] * (1 - alpha) + end_color[1] * alpha),
+            int(start_color[2] * (1 - alpha) + end_color[2] * alpha),
+        )
+        cv2.line(frame, start_point, end_point, color, thickness)
+
+while cap.isOpened():
+    ret, frame = cap.read()
+    if not ret:
+        break
+    frame = cv2.resize(frame, (1000, 600))
+    # Convert the frame to RGB
+    rgb_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+    results = pose.process(rgb_frame)
+
+    if results.pose_landmarks:
+        landmarks = results.pose_landmarks.landmark
+
+        # Extract right-hand keypoints
+        right_shoulder = landmarks[mp_pose.PoseLandmark.RIGHT_SHOULDER]
+        right_elbow = landmarks[mp_pose.PoseLandmark.RIGHT_ELBOW]
+        right_wrist = landmarks[mp_pose.PoseLandmark.RIGHT_WRIST]
+
+        # Convert normalized coordinates to pixel coordinates
+        shoulder_coords = to_pixel_coords(right_shoulder, frame)
+        elbow_coords = to_pixel_coords(right_elbow, frame)
+        wrist_coords = to_pixel_coords(right_wrist, frame)
+
+        # Add wrist coordinates to the deque for trajectory
+        wrist_trajectory.append(wrist_coords)
+
+        # Add coordinates for arcs
+        shoulder_positions.append(shoulder_coords)
+        elbow_positions.append(elbow_coords)
+        wrist_positions.append(wrist_coords)
+
+        # Draw the wrist trajectory (main line)
+        for i in range(1, len(wrist_trajectory)):
+            cv2.line(frame, wrist_trajectory[i - 1], wrist_trajectory[i], (0, 255, 255), 3)
+
+        # Draw dynamic arcs for the last few positions
+        for i in range(1, len(shoulder_positions)):
+            # Fade effect using index
+            thickness = max(2, 10 - (len(shoulder_positions) - i))
+            
+            # Gradient arc for shoulder-to-elbow
+            draw_gradient_arc(frame, shoulder_positions[i - 1], elbow_positions[i - 1], thickness, (0, 255, 0), (255, 0, 0))
+            # Gradient arc for elbow-to-wrist
+            draw_gradient_arc(frame, elbow_positions[i - 1], wrist_positions[i - 1], thickness, (255, 0, 0), (0, 0, 255))
+
+        # Draw keypoints
+        cv2.circle(frame, shoulder_coords, 10, (0, 255, 0), -1)  # Shoulder
+        cv2.circle(frame, elbow_coords, 10, (255, 0, 0), -1)     # Elbow
+        cv2.circle(frame, wrist_coords, 10, (0, 0, 255), -1)     # Wrist
+
+    # Display the frame
+    cv2.imshow('Dynamic Bowling Trajectory', frame)
+
+    if cv2.waitKey(10) & 0xFF == ord('q'):
+        break
+
+cap.release()
+cv2.destroyAllWindows()
+
+
+

Encryption_Project/README.md

@@ -0,0 +1,9 @@
+# Encryption Project
+
+For now this project can only encrypt messages using the following methods:
+
+* SHA-256
+* AES-128
+* Base64
+
+*If you want to understand how this works, this project comments all around it to make sure you understand what's happening*

Encryption_Project/encryption/aes.py

@@ -0,0 +1,22 @@
+# Let's start with AES
+# AES is a type of encryption used mainly for things that require certain level of safety and later will be used
+# There is a specific thing you shouldn't encrypt with AES that's Passkeys
+# For passkeys you will use a method showed later that are the Hash Methods
+
+# In this example we using pycryptodome
+
+from Crypto.Cipher import AES
+
+def encrypt_aes(message: str, key: str):
+    encrypt_cipher = AES.new(key, AES.MODE_EAX) # This is the "configuration" for the encryption
+
+    nonce = encrypt_cipher.nonce # Nonce aka Number Once is basically what makes the key random
+
+    encrypted_message = encrypt_cipher.encrypt_and_digest(message) # Here we are truly encrypting the message
+
+    return encrypted_message, nonce
+
+def decrypt_aes(message: bytes, key: bytes, nonce: bytes):
+    decrypt_cipher = AES.new(key, AES.MODE_EAX, nonce=nonce) # Here we are Saying what's the key, type of encryption and nonce
+    decrypted_message = decrypt_cipher.decrypt(message)
+    return decrypted_message

Encryption_Project/encryption/base64.py

@@ -0,0 +1,16 @@
+# Let's start
+# Base64 is NOT a safe way to encrypt important things, it's used to encrypt binary data to text and doesn't have a key such as AES
+# If you pretend encrypting something that you need to know later you should use AES
+# Else you just want to encrypt something and doesn't care about the privacy Base64 might be a good choice
+
+# In this example we are using a pre-installed module from Python called "base64"
+
+import base64
+
+def encrypt_base64(message: str):
+    encrypt_message = base64.b64encode(message.encode()).decode()
+    return encrypt_message
+
+def decrypt_base64(message: str):
+    decrypt_message = base64.b64decode(message).decode('utf-8')
+    return decrypt_message

Encryption_Project/encryption/sha.py

@@ -0,0 +1,10 @@
+# Let's start with Hashes! (more specifically SHA256)
+# Hashes are a way to encrypt thing in a irreversible way
+# This means if you encrypt something using Hash Methods there is no way to know the content
+
+# In this example we using pre-installed module called "hashlib"
+
+import hashlib
+
+def encryption_sha(message: str):
+    return hashlib.sha256().digest() # This makes the encryption in SHA-256. This is the usually how your passkeys are encrypted

Encryption_Project/main.py

@@ -0,0 +1,73 @@
+from encryption import sha, aes, base64
+import os
+
+def main(): 
+    while True:
+        print("""Welcome to Encryption Project\n
+              1 - SHA256\n
+              2 - AES\n
+              3 - Base64\n
+              4 - Quit\n
+              More soon!\n""")
+
+        encrypt_choice = int(input())
+
+        match encrypt_choice:
+            case 1:
+                message_to_encrypt = input("What's the message you want to encrypt?: ")
+
+                encrypted_message = sha.encryption_sha(message_to_encrypt)
+
+                print(f"The encrypted message is: {encrypted_message}")
+
+            case 2:
+                aes_choice = int(input("1 - Encrypt\n2 - Decrypt\n"))   
+
+                if aes_choice == 1:
+                    message_to_encrypt = input("What's the message you want to encrypt? ").encode('utf-8')
+                    key = os.urandom(16) # if you are confused, this just guarantee the key will have 16 bytes
+
+                    encrypted_message, nonce = aes.encrypt_aes(message_to_encrypt, key)
+
+                    print(f"Encrypted message: {encrypted_message}\nnonce: {nonce}\nkey: {key}\n *Save those!*")
+                elif aes_choice == 2:
+                    message_to_decrypt = eval(input("What's the message to decrypt? "))
+                    key = eval(input("What's the key? "))
+                    nonce = eval(input("What's the nonce? "))
+
+                    decrypted_message = aes.decrypt_aes(message_to_decrypt, key, nonce)
+
+                    print(f"Message: {decrypted_message}")
+                
+                else:
+                    print("Option does not exist")
+            
+            case 3:
+                base_choice = int(input("1 - Encrypt\n2 - Decrypt\n"))  
+
+                if base_choice == 1:
+                    message_to_encrypt = input("What's the message you want to encrypt? ")
+
+                    encrypted_message = base64.encrypt_base64(message_to_encrypt)
+
+                    print(f"Message: {encrypted_message}")
+
+                elif base_choice == 2:
+                    message_to_decrypt = input("What's the message to decrypt? ")
+
+                    decrypted_message = base64.decrypt_base64(message_to_decrypt)
+
+                    print(f"Message: {decrypted_message}")
+                
+                else:
+                    print("Option does not exist")
+            
+            case 4:
+                print("Bye!")
+                break
+        
+            case _:
+                print("This option is not available")
+
+if __name__ == "__main__":
+    main()

Encryption_Project/requirements.txt

@@ -0,0 +1 @@
+pycryptodome