Upgrade python version and python doctest for a CI

Author: lighting9999

.github/workflows/python.yml

@@ -16,7 +16,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: ['3.10', '3.11', '3.12']
+        python-version: ['3.11', '3.12','3.13','3.14']
     steps:
       - name: Checkout repository
         uses: actions/checkout@v4
@@ -29,7 +29,7 @@ jobs:
       - name: Install all dependencies and tools
         run: |
           python -m pip install --upgrade pip
-          pip install ruff bandit mypy pytest codespell requests-mock colorama
+          pip install ruff bandit mypy pytest codespell requests-mock colorama pytest-xdist
 
       - name: Run Codespell check
         run: codespell --skip "*.json,*.txt,*.pdf,*.md" || true
@@ -38,7 +38,7 @@ jobs:
         run: bandit -r . --skip B101,B105 -ll || true
 
       - name: Run Pytest tests
-        run: pytest --tb=short || true
+        run: pytest --doctest-modules -tb=short -n auto || true
 
       - name: Run Ruff checks with ignored rules
         run: ruff check . --ignore B904,B905,EM101,EXE001,G004,ISC001,PLC0415,PLC1901,PLW060,PLW1641,PLW2901,PT011,PT018,PT028,S101,S311,SIM905,SLF001,F405

aaa.txt

@@ -0,0 +1,15 @@
+num = float(input("Enter a number: "))
+if num > 0:
+    print("Positive number")
+elif num == 0:
+    print("Zero")
+else:
+    print("Negative number")
+    num = float(input("Enter a number: "))
+if num >= 0:
+    if num == 0:
+        print("Zero")
+    else:
+        print("Positive number")
+else:
+    print("Negative number")

check if a number positive , negative or zero

@@ -1,80 +1,208 @@
-from random import *
-from turtle import *
+#!/usr/bin/env python3
+"""
+Memory Game – a tile‑matching game using the Turtle graphics library.
+
+The board consists of 64 tiles (8x8 grid), each hiding one of 32 possible
+icons (numbers 0–31). The player clicks on tiles to reveal them. When two
+consecutive revealed tiles show the same icon, they remain visible; otherwise
+they are hidden again. The game continues until all pairs are found.
+
+Dependencies:
+    - Python standard library: random, turtle
+    - freegames (optional) – provides a car image; if not available, remove
+      the car-related lines and the game will work without it.
+
+Author: Adapted from a freegames example.
+Date: 2026-07-12
+"""
+
+import random
+import turtle
 
 from freegames import path
 
+# ----------------------------------------------------------------------------
+# Game constants and global state
+# ----------------------------------------------------------------------------
+
+# Load the car image (used as a decorative stamp on the board)
 car = path("car.gif")
+
+# Create a list of 64 tile values: each number from 0 to 31 appears exactly twice
 tiles = list(range(32)) * 2
+
+# State dictionary: 'mark' stores the index of the currently selected tile
+# (the first tile clicked in a pair attempt). None means no tile is selected.
 state = {"mark": None}
+
+# Boolean list indicating whether each tile is hidden (True = hidden, False = shown)
 hide = [True] * 64
 
 
-def square(x, y):
-    "Draw white square with black outline at (x, y)."
-    up()
-    goto(x, y)
-    down()
-    color("black", "white")
-    begin_fill()
-    for count in range(4):
-        forward(50)
-        left(90)
-    end_fill()
+# ----------------------------------------------------------------------------
+# Drawing utilities
+# ----------------------------------------------------------------------------
+
+
+def square(x: float, y: float) -> None:
+    """
+    Draw a 50x50 white square with a black outline at the given coordinates.
+
+    The turtle starts at the bottom‑left corner of the square and draws it
+    counter‑clockwise using the standard forward/left movements.
+
+    Args:
+        x: X‑coordinate of the bottom‑left corner.
+        y: Y‑coordinate of the bottom‑left corner.
+    """
+    turtle.up()
+    turtle.goto(x, y)
+    turtle.down()
+    turtle.color("black", "white")
+    turtle.begin_fill()
+    for _ in range(4):
+        turtle.forward(50)
+        turtle.left(90)
+    turtle.end_fill()
+
+
+# ----------------------------------------------------------------------------
+# Coordinate and index conversion
+# ----------------------------------------------------------------------------
+
 
+def index(x: float, y: float) -> int:
+    """
+    Convert screen coordinates to a tile index (0‑63).
 
-def index(x, y):
-    "Convert (x, y) coordinates to tiles index."
+    The board is arranged in an 8x8 grid, with each cell being 50x50 pixels.
+    The origin (0,0) is at the centre of the screen; the board occupies the
+    region from (-200, -200) to (200, 200). This function maps a click
+    position to the corresponding tile index, row‑major order.
+
+    Args:
+        x: X‑coordinate of the click (in turtle screen units).
+        y: Y‑coordinate of the click.
+
+    Returns:
+        int: Tile index (0 to 63).
+    """
     return int((x + 200) // 50 + ((y + 200) // 50) * 8)
 
 
-def xy(count):
-    "Convert tiles count to (x, y) coordinates."
+def xy(count: int) -> tuple[float, float]:
+    """
+    Convert a tile index to screen coordinates of its bottom‑left corner.
+
+    This is the inverse of `index()`. The calculation uses integer division
+    and modulo to determine the row and column.
+
+    Args:
+        count: Tile index (0‑63).
+
+    Returns:
+        tuple[float, float]: (x, y) coordinates of the tile's bottom‑left corner.
+    """
     return (count % 8) * 50 - 200, (count // 8) * 50 - 200
 
 
-def tap(x, y):
-    "Update mark and hidden tiles based on tap."
+# ----------------------------------------------------------------------------
+# Game logic
+# ----------------------------------------------------------------------------
+
+
+def tap(x: float, y: float) -> None:
+    """
+    Handle a mouse click event on the canvas.
+
+    This is the core game logic. It performs the following steps:
+        1. Determine which tile was clicked.
+        2. If no tile is currently marked (state["mark"] is None),
+           mark this tile as the first of a pair.
+        3. If a tile is already marked and it is not the same tile,
+           compare the values of the marked tile and the newly clicked tile:
+             - If they match (same number), reveal both tiles permanently.
+             - If they do not match, unmark the tile (keep it hidden).
+        4. If the same tile is clicked twice, it simply remains marked.
+
+    Args:
+        x: X‑coordinate of the click.
+        y: Y‑coordinate of the click.
+    """
     spot = index(x, y)
     mark = state["mark"]
 
+    # If no mark, or we clicked the same tile again, or the values differ:
+    # just set the mark to the new spot (or keep it if it's the same).
+    # Note: if the two values are different, we don't hide anything – the
+    # tile will be drawn hidden again in the next draw() cycle because
+    # hide[spot] remains True.
     if mark is None or mark == spot or tiles[mark] != tiles[spot]:
         state["mark"] = spot
     else:
+        # Values match: reveal both tiles permanently.
         hide[spot] = False
         hide[mark] = False
+        # Clear the mark so the next click starts a new pair.
         state["mark"] = None
 
 
-def draw():
-    "Draw image and tiles."
-    clear()
-    goto(0, 0)
-    shape(car)
-    stamp()
-
+def draw() -> None:
+    """
+    Redraw the entire board and schedule the next animation frame.
+
+    This function is called repeatedly via turtle.ontimer() to update the
+    display. It:
+        - Clears the canvas.
+        - Draws the decorative car image at the centre.
+        - Draws a white square for every hidden tile.
+        - If a tile is marked and currently hidden, it writes the tile's
+          value (number) on top of that square.
+        - Finally, triggers a redraw after 100 milliseconds.
+
+    The use of turtle.tracer(False) and manual turtle.update() ensures
+    smooth animation without flickering.
+    """
+    turtle.clear()
+    turtle.goto(0, 0)
+    turtle.shape(car)
+    turtle.stamp()  # Place the car image permanently on the canvas
+
+    # Draw all tiles that are still hidden.
     for count in range(64):
         if hide[count]:
             x, y = xy(count)
             square(x, y)
 
+    # If a tile is marked and hidden, display its value.
     mark = state["mark"]
-
     if mark is not None and hide[mark]:
         x, y = xy(mark)
-        up()
-        goto(x + 2, y)
-        color("black")
-        write(tiles[mark], font=("Arial", 30, "normal"))
+        turtle.up()
+        turtle.goto(x + 2, y)  # Shift slightly for better centering
+        turtle.color("black")
+        turtle.write(tiles[mark], font=("Arial", 30, "normal"))
+
+    turtle.update()  # Refresh the screen with all drawn elements
+    turtle.ontimer(draw, 100)  # Schedule next redraw (10 fps)
 
-    update()
-    ontimer(draw, 100)
 
+# ----------------------------------------------------------------------------
+# Main setup and execution
+# ----------------------------------------------------------------------------
 
-shuffle(tiles)
-setup(420, 420, 370, 0)
-addshape(car)
-hideturtle()
-tracer(False)
-onscreenclick(tap)
+# Shuffle the tile values to randomise the board layout.
+random.shuffle(tiles)
+
+# Configure the turtle window.
+turtle.setup(420, 420, 370, 0)  # Window size, start x, start y
+turtle.addshape(car)  # Register the car image as a shape
+turtle.hideturtle()  # Hide the turtle cursor (we only need drawings)
+turtle.tracer(False)  # Disable automatic updates for performance
+turtle.onscreenclick(tap)  # Bind mouse clicks to the tap() function
+
+# Start the game loop.
 draw()
-done()
+
+# Keep the window open (this is the main event loop).
+turtle.done()