Dnd 2026

.gitignore

@@ -1,4 +1,3 @@
-
 *.class
 Level1-Module3/_01_gui_app_bindings/_c_PigLatinTranslator/__pycache__/PigLatinConverter.cpython-38.pyc
 *.xml
@@ -11,8 +10,6 @@ Level1-Module3/_01_gui_app_bindings/_c_PigLatinTranslator/__pycache__/PigLatinCo
 .idea
 .idea/workspace.xml
 
-
-
 # Byte-compiled / optimized / DLL files
 __pycache__/
 *.py[cod]
@@ -56,4 +53,4 @@ coverage.xml
 saved/
 
 .jtl/*completion*
-.vscode
+.vscode

.lib/auto_turtle.py

@@ -0,0 +1,147 @@
+#!/usr/bin/env python
+"""
+auto_turtle.py
+
+This script automatically sets up the ipyturtle3 environment
+for use in a Jupyter Notebook.
+
+When used with %run, it will:
+1. Import all necessary modules (turtle, Canvas, TurtleScreen, Turtle, display).
+2. Create and display a default Canvas named 'myCanvas'.
+3. Define a custom Turtle class that remaps the coordinate system so that
+   the student's (0, 0) is at (start_x, start_y) on the canvas.
+4. Display the Canvas in the notebook.
+5. Wait a moment to ensure the canvas is rendered.
+6. Create a TurtleScreen for the canvas named 'myTS'.
+"""
+
+import time # Might not be necessary, but used for sleep
+
+# --- Configuration ---
+canvas_width = 750         # Width of the turtle canvas
+canvas_height = 250        # Height of the turtle canvas
+start_x = -300             # Starting X position of the canvas
+start_y = -50              # Starting Y position of the canvas
+time_sleep = 0.1           # Time to wait for canvas rendering
+# ---------------------
+
+try:
+    # 1. Import the main library and necessary classes
+    import ipyturtle3 as turtle
+    import sys, types
+    from ipyturtle3 import Canvas, TurtleScreen, Turtle
+    from IPython.display import display
+
+    turtle = types.ModuleType("turtle") # Make a fake 'turtle' module
+    # 2. Define a NEW Turtle class that overrides the original for custom behavior
+    class turtle(Turtle):
+        """
+        Custom Turtle class that remaps the coordinate system.
+        The student's (0, 0) is now our (START_X, START_Y).
+
+        This class overrides all position-related methods to 
+        translate between the student's "relative" coordinates
+        and the canvas's "absolute" coordinates.
+        """
+        def __init__(self, screen=None, *args, **kwargs):
+            """
+            Initializes the turtle and moves it instantly
+            to the new (0, 0) origin point.
+            """
+            # Store the new origin offset
+            self._origin_x = start_x
+            self._origin_y = start_y
+
+            # Call the original __init__ to create the turtle
+            super().__init__(screen, *args, **kwargs)
+
+            # --- Set the default starting position (instantly) ---
+            original_speed = self.speed()    # Save original speed
+            self.speed(0)                    # Set to instant
+            self.penup()
+            super().goto(self._origin_x, self._origin_y) # Move to *absolute* start
+            self.pendown()
+            self.speed(original_speed)       # Restore original speed
+
+        # --- Private Helper Methods ---
+
+        def _to_absolute(self, x, y):
+            """Converts student's relative (x, y) to absolute canvas coordinates."""
+            return (x + self._origin_x, y + self._origin_y)
+
+        def _to_relative(self, x, y):
+            """Converts absolute canvas (x, y) to student's relative coordinates."""
+            return (x - self._origin_x, y - self._origin_y)
+
+        # --- Overridden Position & Movement Methods ---
+
+        def goto(self, x, y):
+            """Moves the turtle to a (student) coordinate."""
+            abs_x, abs_y = self._to_absolute(x, y)
+            super().goto(abs_x, abs_y)
+
+        def setposition(self, x, y=None):
+            """Alias for goto."""
+            # This handles the case where setposition is called with one arg (a tuple)
+            # or two args (x, y). Standard turtle behavior.
+            if y is None:
+                try:
+                    x, y = x
+                except TypeError:
+                    # Handle error or just pass to goto to raise it
+                    pass
+            self.goto(x, y)
+
+        def setx(self, x):
+            """Sets the turtle's (student) x coordinate."""
+            abs_x = x + self._origin_x
+            super().setx(abs_x)
+
+        def sety(self, y):
+            """Sets the turtle's (student) y coordinate."""
+            abs_y = y + self._origin_y
+            super().sety(abs_y)
+
+        def position(self):
+            """Returns the turtle's (student) position."""
+            abs_x, abs_y = super().position()
+            return self._to_relative(abs_x, abs_y)
+
+        def pos(self):
+            """Alias for position."""
+            return self.position()
+
+        def xcor(self):
+            """Returns the turtle's (student) x coordinate."""
+            abs_x = super().xcor()
+            return abs_x - self._origin_x
+
+        def ycor(self):
+            """Returns the turtle's (student) y coordinate."""
+            abs_y = super().ycor()
+            return abs_y - self._origin_y
+
+        turtle.Turtle = Turtle          # This puts the class in the fame module
+        sys.modules["turtle"] = turtle  # This allows "import turtle" to work. 
+
+    # 3. Create a Canvas for the turtle to draw on
+    myCanvas = Canvas(width=canvas_width, height=canvas_height)
+
+    # 4. Display the Canvas in the Jupyter notebook
+    display(myCanvas)
+
+    # 5. Wait a moment to ensure the canvas is fully rendered
+    time.sleep(time_sleep)
+
+    # 6. Create a TurtleScreen
+    myTS = TurtleScreen(myCanvas)
+    myTS.clear()  # Clear the screen to start fresh
+
+# Handle import errors gracefully
+except ImportError:
+    print("❌ Error: 'ipyturtle3' or 'IPython' not found.")
+    print("Please make sure you are in a Jupyter environment and have")
+    print("ipyturtle3 installed (e.g., `pip install ipyturtle3`).")
+# Handle any other exceptions
+except Exception as e:
+    print(f"An error occurred during auto_turtle setup: {e}")

.lib/auto_turtle_concise.py

@@ -0,0 +1,29 @@
+#!/usr/bin/env python
+"""
+auto_turtle_concise.py
+Inherits setup from auto_turtle.py and initializes 'tina'.
+
+This just inherits the setup from auto_turtle.py but creates 'tina' the turtle for you.
+It's a more concise way to get started with Tina the Turtle without having to write the setup code again.
+My intent was to use this for the later examples in this course since they already will know how to use Tina at that point.
+"""
+
+try:
+    # Attempting to open and execute auto_turtle.py to inherit its setup
+    # Use utf-8 to prevent a UnicodeDecodeError on some systems
+    with open(".lib/auto_turtle.py", encoding="utf-8") as f:
+        exec(f.read())
+
+    # Setup Tina (using the variables inherited from auto_turtle.py)
+    # These will only run if the 'exec' above was successful
+    tina = turtle(myTS)          # type: ignore[name-defined]
+    tina.shape('turtle')
+    tina.speed(5)
+
+except FileNotFoundError:
+    print("Error: Could not find and inherit from '.lib/auto_turtle.py'.")
+    print("Please ensure auto_turtle.py exists in the .lib directory.")
+
+except Exception as e:
+    # Any other exceptions that may occur
+    print(f"Error: {e}")

.vscode/settings.json

@@ -4,17 +4,17 @@
         "**/.svn": true,
         "**/.hg": true,
         "**/Thumbs.db": true,
-        "**/*.crswap": true,
         "**/__pycache__": true,
-        "**/.cache": true,
         "**/.coverage": true,
         "**/.coverage.*": true,
         "**/.hypothesis": true,
         "**/.mypy_cache": true,
         "**/.nox": true,
         "**/.pytest_cache": true,
         "**/.ruff_cache": true,
-        "**/.tox": true
+        "**/.tox": true,
+        "**/*.crswap": true,
+        "**/.cache": true
     }
 
 }

.vscode/tasks.json

@@ -1,4 +1,4 @@
-{
+league{
 	"version": "2.0.0",
 	"tasks": []
 }

CLAUDE.md

@@ -0,0 +1,99 @@
+# Curriculum Review Guide
+
+This repository is the League's Python Apprentice curriculum, aligned with the Python Institute's [PCEP](https://pythoninstitute.org/pcep) (entry-level) exam. Students are typically middle school and early high school age. Lessons live in `lessons/` as Jupyter notebooks organized into numbered category directories.
+
+When asked to review a lesson or set of lessons, use the criteria below.
+
+## Voice
+
+Aim for a fun adult tone — a good teacher who respects the reader, not a kids-TV host or a cheerleader. Silly topic choices (badgers, mushrooms, snakes) are fine; breathless enthusiasm is not.
+
+**Do:**
+- Write like you'd explain something to a smart 12-year-old.
+- Use "you" — the student is the reader.
+- Allow at most one exclamation point per lesson, and only when the emphasis is genuinely earned.
+
+**Don't:**
+- Use "super", "awesome", "amazing", "fantastic", "incredible" as intensifiers.
+- Write "We're so excited", "Don't worry!", "Let's go!", "You've got this!", "Ready to have some fun?".
+- Use ALL-CAPS warnings or stacked exclamation points.
+- Use emojis as substitutes for words (e.g. "turn left 🡐", "move forward ⬆️"). Decorative emojis in small doses are fine.
+- Adopt kid-speak or corporate-training-speak.
+
+**Example:**
+- Okay: *"The turtle draws a line behind it as it moves."*
+- Not okay: *"The turtle draws a SUPER cool line as it zooms around! 🚀"*
+
+## Content flow
+
+Within each lesson and across lessons in a category, check:
+
+- **Logical progression** — each step follows from the last.
+- **No prerequisites from later lessons** — every concept used in code or exercises has been introduced already, or is flagged with a brief "we'll cover this later".
+- **No abrupt jumps** — difficulty increases smoothly.
+- **Callbacks where warranted** — reference earlier lessons when it reinforces the current one, but don't force it.
+- **Consistent terminology** — once we call it a "function", don't switch to "method" or "routine" without reason. Flag terminology drift across lessons.
+- **No holes** — if a lesson uses a skill the student hasn't seen, that's a hole worth flagging.
+
+**Motivation vs. mechanics:** Kids often do fine being handed a mechanic and getting the reason after they've tried it, as long as the mechanic itself is sensible. Don't flag missing motivation unless the lesson genuinely doesn't make sense without it.
+
+**One concept per lesson:** The general preference is focused lessons, but existing structure takes priority. Note serious violations in the review, but **do not rewrite lessons to split concepts without explicit approval**.
+
+## Technical quality
+
+- Code examples must run as written.
+- Examples should be realistic — not `foo()` / `bar()` placeholders — but not so elaborate they distract from the concept being taught.
+- Follow PEP 8: 4-space indents, `snake_case` for variables and functions, `PascalCase` for classes, blank lines between top-level definitions, no trailing whitespace, line lengths ~79–100 chars, imports at the top.
+- Accurate technical claims. Simplifications are fine ("a variable is a box for data"); outright-wrong statements are not.
+- When we teach a topic, teach it thoroughly: a worked example, an exercise, and at least one edge case or common mistake called out.
+
+### Exercise stubs are intentional
+
+Many lessons have exercise code where key lines or whole function bodies are missing, commented out, or replaced with `...` / `# Your code here`. The student is supposed to type those in. Do **not** flag these as bugs, syntax errors, or missing implementations. Common shapes:
+
+- `def foo():` with just a `# Your code here` comment as the body
+- A bare `x = ` with no value (student will fill in the expression)
+- `... # Your code here` placeholders in the middle of otherwise-complete code
+- `.py` files that contain only a docstring — the rest is for the student
+
+Only flag these if something adjacent is actually wrong (e.g. the surrounding hint text is misleading, or the stub references a concept the student hasn't learned).
+
+## Scope
+
+Curriculum targets PCEP. Intentionally **out of scope**:
+
+- List / dict / set comprehensions
+- Generators and `yield`
+- Decorators
+- Context managers beyond `with open(...)`
+- Metaclasses, descriptors, `__slots__`
+- `async` / `await`
+- Type hints beyond incidental use
+
+Do not suggest adding these. Teach what we teach thoroughly rather than expanding the surface area.
+
+## Review workflow
+
+When asked to review one or more lessons:
+
+1. Read the lesson(s) in full, plus enough surrounding lessons in the same category (and the lesson immediately before and after) to judge flow and prerequisites.
+2. Produce a markdown review with one `## <relative file path>` heading per file, and findings as bulleted items underneath.
+3. The user will delete findings they don't want applied and hand the edited review back.
+4. Apply the remaining findings.
+
+### Finding format
+
+Each bullet must be **standalone and deletable** — removing it shouldn't break any other finding. Include: category tag, location, the problem, and a concrete suggestion.
+
+Group findings under each file heading in this order: **Voice**, **Flow**, **Technical**, **Scope**. Order within a category follows the location in the file.
+
+```
+## lessons/10_Turtles/10_Welcome/10_Welcome.ipynb
+
+- **Voice** (cell 0, opening line): "Hello future coders, programmers, and engineers!" — drop the greeting, open with "Welcome to your first Python lesson."
+- **Voice** (cell 0, intro paragraph): "We're super excited to help you..." — rewrite as "This course will help you take your first steps into programming."
+- **Flow** (cell 2, exercise): exercise uses `random.randint()` but `random` hasn't been introduced — either introduce it earlier or swap the exercise for one using only what's been taught.
+- **Technical** (cell 4, code block): mixes `Turtle()` and `turtle.Turtle()` — standardize on one convention and use it throughout the lesson.
+```
+
+Keep findings specific enough that applying one doesn't require re-reading the whole lesson. If a single change touches multiple places in a lesson (e.g. "rename `x` to `count` everywhere"), that's one finding — say so in the bullet.