pythonlings 0.3.0__py3-none-any.whl

pythonlings/core/manifest.py

@@ -0,0 +1,110 @@
+# pythonlings/core/manifest.py
+from __future__ import annotations
+
+try:
+    import tomllib
+except ModuleNotFoundError:  # Python < 3.11
+    import tomli as tomllib
+from dataclasses import dataclass
+from pathlib import Path
+
+from pythonlings.core.exercise import Exercise
+
+
+class ManifestError(ValueError):
+    """info.toml is missing, malformed, or fails validation."""
+
+
+@dataclass(frozen=True)
+class Manifest:
+    exercises: list[Exercise]
+    welcome_message: str
+    final_message: str
+
+    def by_name(self, name: str) -> Exercise:
+        for ex in self.exercises:
+            if ex.name == name:
+                return ex
+        raise KeyError(name)
+
+    def index_of(self, name: str) -> int:
+        for i, ex in enumerate(self.exercises):
+            if ex.name == name:
+                return i
+        raise KeyError(name)
+
+    def topics(self) -> list[str]:
+        """Topic names in first-appearance order."""
+        ordered: list[str] = []
+        for ex in self.exercises:
+            if ex.topic not in ordered:
+                ordered.append(ex.topic)
+        return ordered
+
+    def exercises_in(self, topic: str) -> list[Exercise]:
+        """Exercises belonging to one topic, in curriculum order."""
+        return [ex for ex in self.exercises if ex.topic == topic]
+
+
+def load(root: Path) -> Manifest:
+    info_path = root / "info.toml"
+    if not info_path.exists():
+        raise ManifestError(
+            f"no pythonlings workspace here ({info_path} not found). "
+            "Run 'pythonlings init' to create one."
+        )
+
+    with info_path.open("rb") as f:
+        data = tomllib.load(f)
+
+    if data.get("format_version") != 1:
+        raise ManifestError(
+            f"info.toml format_version must be 1, got {data.get('format_version')!r}"
+        )
+
+    raw_exercises = data.get("exercises", [])
+    if not raw_exercises:
+        raise ManifestError("info.toml must define a non-empty [[exercises]] array")
+
+    seen: set[str] = set()
+    exercises: list[Exercise] = []
+    for entry in raw_exercises:
+        name = entry["name"]
+        if name in seen:
+            raise ManifestError(f"duplicate exercise name: {name!r}")
+        seen.add(name)
+
+        rel_path = Path(entry["path"])
+        if not rel_path.parts or rel_path.parts[0] != "exercises":
+            raise ManifestError(
+                f"exercise path must be under exercises/: {rel_path}"
+            )
+        abs_path = root / rel_path
+        if not abs_path.exists():
+            raise ManifestError(f"exercise path does not exist: {rel_path}")
+
+        # Derive the check path: exercises/<...> mirrors to checks/<...>.
+        check_rel = Path("checks", *rel_path.parts[1:])
+        check_abs = root / check_rel
+        if not check_abs.exists():
+            raise ManifestError(f"no check file for {name!r}: {check_rel}")
+
+        exercises.append(
+            Exercise(
+                name=name,
+                path=abs_path,
+                check_path=check_abs,
+                topic=rel_path.parent.name,
+                hint=entry.get("hint", ""),
+                docs=entry.get("docs", ""),
+                root=root,
+                rel_path=rel_path,
+                check_rel_path=check_rel,
+            )
+        )
+
+    return Manifest(
+        exercises=exercises,
+        welcome_message=data.get("welcome_message", "Welcome to pythonlings!"),
+        final_message=data.get("final_message", "All exercises complete."),
+    )

pythonlings/core/reset.py

@@ -0,0 +1,43 @@
+# pythonlings/core/reset.py
+
+from __future__ import annotations
+
+import shutil
+from pathlib import Path
+
+from pythonlings.core.exercise import Exercise
+
+
+class ResetError(RuntimeError):
+    """Reset failed (typically: no snapshot exists)."""
+
+
+def _snapshot_path(root: Path, exercise: Exercise) -> Path:
+    # Key on Exercise.name (unique per the manifest validator) so two
+    # exercises in different topics with the same filename don't collide.
+    return root / ".pythonlings" / "originals" / f"{exercise.name}.py"
+
+
+def _original_path(root: Path, exercise: Exercise) -> Path:
+    if exercise.rel_path is None:
+        return _snapshot_path(root, exercise)
+    return root / ".pythonlings" / "originals" / exercise.rel_path.relative_to("exercises")
+
+
+def snapshot(root: Path, exercise: Exercise) -> None:
+    """Copy the pristine source into .pythonlings/originals/ if not already snapshotted."""
+    snap = _original_path(root, exercise)
+    if snap.exists():
+        return
+    snap.parent.mkdir(parents=True, exist_ok=True)
+    shutil.copy2(exercise.path, snap)
+
+
+def restore(root: Path, exercise: Exercise) -> None:
+    """Overwrite the exercise file with its pristine original."""
+    snap = _original_path(root, exercise)
+    if not snap.exists():
+        raise ResetError(
+            f"no snapshot for {exercise.name!r}. Run 'pythonlings update' first."
+        )
+    shutil.copy2(snap, exercise.path)

pythonlings/core/runner.py

@@ -0,0 +1,114 @@
+# pythonlings/core/runner.py
+
+from __future__ import annotations
+
+import os
+import subprocess
+import sys
+import tempfile
+import time
+
+from pythonlings.core.exercise import Exercise
+from pythonlings.core.exercise import RunResult
+
+DEFAULT_TIMEOUT_S = 5.0
+
+
+def run(exercise: Exercise, timeout_s: float = DEFAULT_TIMEOUT_S) -> RunResult:
+    """Run an exercise concatenated with its check file, in a subprocess.
+
+    Never raises.
+    """
+    start = time.monotonic()
+    exercise_path = exercise.path.resolve()
+    check_path = exercise.check_path.resolve()
+    env = {
+        **os.environ,
+        "PYTHONDONTWRITEBYTECODE": "1",
+        "PYTHONIOENCODING": "utf-8",
+    }
+    exercise_src = exercise_path.read_text(encoding="utf-8")
+    runner_src = (
+        "import sys\n"
+        "from pathlib import Path\n"
+        f"exercise_path = Path({str(exercise_path)!r})\n"
+        f"check_path = Path({str(check_path)!r})\n"
+        "sys.path.insert(0, str(Path.cwd()))\n"
+        "namespace = {\n"
+        "    '__name__': '__main__',\n"
+        "    '__file__': str(exercise_path),\n"
+        "    '__package__': None,\n"
+        "}\n"
+        "exercise_src = exercise_path.read_text(encoding='utf-8')\n"
+        "check_src = check_path.read_text(encoding='utf-8')\n"
+        "exec(compile(exercise_src, str(exercise_path), 'exec'), namespace)\n"
+        "namespace['__file__'] = str(check_path)\n"
+        "exec(compile(check_src, str(check_path), 'exec'), namespace)\n"
+    )
+    tmp = tempfile.NamedTemporaryFile(
+        mode="w", suffix=".py", delete=False, encoding="utf-8"
+    )
+    try:
+        tmp.write(runner_src)
+        tmp.close()
+        try:
+            cwd = (exercise.root or exercise_path.parent).resolve()
+            proc = subprocess.run(
+                [sys.executable, tmp.name],
+                capture_output=True,
+                text=True,
+                encoding="utf-8",
+                errors="replace",
+                timeout=timeout_s,
+                env=env,
+                cwd=cwd,
+            )
+            duration = time.monotonic() - start
+            exit_code = proc.returncode
+            stdout = proc.stdout
+            stderr = proc.stderr
+            timed_out = False
+        except subprocess.TimeoutExpired as e:
+            duration = time.monotonic() - start
+            exit_code = -1
+            stdout = (
+                e.stdout.decode("utf-8", errors="replace")
+                if isinstance(e.stdout, bytes)
+                else (e.stdout or "")
+            )
+            stderr = (
+                e.stderr.decode("utf-8", errors="replace")
+                if isinstance(e.stderr, bytes)
+                else (e.stderr or "")
+            )
+            timed_out = True
+        except Exception as e:  # noqa: BLE001 — run() must never raise
+            duration = time.monotonic() - start
+            exit_code = -1
+            stdout = ""
+            stderr = f"pythonlings: failed to run exercise: {e}"
+            timed_out = False
+    finally:
+        os.unlink(tmp.name)
+
+    pending = Exercise.DONE_MARKER in exercise_src
+    passed = exit_code == 0 and not timed_out and not pending
+
+    return RunResult(
+        passed=passed,
+        exit_code=exit_code,
+        stdout=stdout,
+        stderr=stderr,
+        duration_s=duration,
+        timed_out=timed_out,
+    )
+
+
+def run_verify(
+    exercise: Exercise, timeout_s: float = DEFAULT_TIMEOUT_S
+) -> RunResult:
+    """Run an exercise but treat the marker as a no-op (CI / curriculum-author mode)."""
+    result = run(exercise, timeout_s=timeout_s)
+    # `verify` cares only about exit code; recompute passed without the marker check.
+    result.passed = result.exit_code == 0 and not result.timed_out
+    return result

pythonlings/core/solutions.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from dataclasses import replace
+from pathlib import Path
+
+from pythonlings.core.exercise import Exercise
+
+
+class SolutionError(RuntimeError):
+    """Solution lookup failed."""
+
+
+def solution_exercise(root: Path, exercise: Exercise) -> Exercise:
+    path = root / "solutions" / f"{exercise.name}.py"
+    if not path.exists():
+        raise SolutionError(f"no solution for {exercise.name!r}")
+    return replace(exercise, path=path, rel_path=Path("solutions") / path.name)

pythonlings/core/state.py

@@ -0,0 +1,86 @@
+# pythonlings/core/state.py
+
+from __future__ import annotations
+
+import json
+import sys
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from pythonlings.core.exercise import Exercise
+
+FORMAT_VERSION = 2
+
+
+@dataclass
+class State:
+    completed: set[str] = field(default_factory=set)
+    seen_intro: bool = False
+    last_topic: str | None = None
+    last_exercise: str | None = None
+
+    def mark_done(self, name: str) -> None:
+        self.completed.add(name)
+
+    def record_resume(self, topic: str, exercise: str | None) -> None:
+        self.seen_intro = True
+        self.last_topic = topic
+        self.last_exercise = exercise
+
+    def clear_resume(self) -> None:
+        self.last_topic = None
+        self.last_exercise = None
+
+
+def _state_path(root: Path) -> Path:
+    return root / ".pythonlings" / "state.json"
+
+
+def load(root: Path) -> State:
+    path = _state_path(root)
+    if not path.exists():
+        return State()
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+        if data.get("format_version") != FORMAT_VERSION:
+            raise ValueError(
+                f"unsupported state format_version: {data.get('format_version')}"
+            )
+        return State(
+            completed=set(data.get("completed", [])),
+            seen_intro=bool(data.get("seen_intro", False)),
+            last_topic=data.get("last_topic"),
+            last_exercise=data.get("last_exercise"),
+        )
+    except (json.JSONDecodeError, ValueError, KeyError) as e:
+        backup = path.with_suffix(".json.bak")
+        path.rename(backup)
+        print(
+            f"pythonlings: state file unreadable ({e}); backed up to {backup} "
+            f"and starting fresh",
+            file=sys.stderr,
+        )
+        return State()
+
+
+def save(root: Path, state: State) -> None:
+    path = _state_path(root)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    payload = {
+        "format_version": FORMAT_VERSION,
+        "completed": sorted(state.completed),
+        "seen_intro": state.seen_intro,
+        "last_topic": state.last_topic,
+        "last_exercise": state.last_exercise,
+    }
+    tmp = path.with_suffix(".json.tmp")
+    tmp.write_text(json.dumps(payload, indent=2), encoding="utf-8")
+    tmp.replace(path)
+
+
+def next_pending(exercises: list[Exercise], completed: set[str]) -> str | None:
+    """First exercise name in `exercises` not in `completed`, or None."""
+    for ex in exercises:
+        if ex.name not in completed:
+            return ex.name
+    return None

pythonlings/curriculum/checks/async/async1.py

@@ -0,0 +1,4 @@
+import asyncio
+
+assert asyncio.run(greet()) == "hello async"
+print("async1 ok")

pythonlings/curriculum/checks/async/async10.py

@@ -0,0 +1,4 @@
+import asyncio
+
+assert asyncio.run(fetch_all(["ada", "lin", "guido"])) == "ADA,LIN,GUIDO"
+print("async10 ok")

pythonlings/curriculum/checks/async/async2.py

@@ -0,0 +1,4 @@
+import asyncio
+
+assert asyncio.run(main()) == "ready"
+print("async2 ok")

pythonlings/curriculum/checks/async/async3.py

@@ -0,0 +1,4 @@
+import asyncio
+
+assert asyncio.run(wake_up()) == "awake"
+print("async3 ok")

pythonlings/curriculum/checks/async/async4.py

@@ -0,0 +1,4 @@
+import asyncio
+
+assert asyncio.run(collect()) == ["a", "b"]
+print("async4 ok")

pythonlings/curriculum/checks/async/async5.py

@@ -0,0 +1,4 @@
+import asyncio
+
+assert asyncio.run(run_task()) == 42
+print("async5 ok")

pythonlings/curriculum/checks/async/async6.py

@@ -0,0 +1,4 @@
+import asyncio
+
+assert asyncio.run(collect_numbers()) == [1, 2, 3]
+print("async6 ok")

pythonlings/curriculum/checks/async/async7.py

@@ -0,0 +1,4 @@
+import asyncio
+
+assert asyncio.run(with_timeout()) == "done"
+print("async7 ok")

pythonlings/curriculum/checks/async/async8.py

@@ -0,0 +1,2 @@
+assert result == 42
+print("async8 ok")

pythonlings/curriculum/checks/async/async9.py

@@ -0,0 +1,4 @@
+import asyncio
+
+assert asyncio.run(double_all([1, 2, 3])) == [2, 4, 6]
+print("async9 ok")

pythonlings/curriculum/checks/classes/classes1.py

@@ -0,0 +1,3 @@
+assert isinstance(my_cat, Cat), "my_cat should be an instance of Cat"
+assert type(my_cat) is Cat
+print("classes1 ✓")

pythonlings/curriculum/checks/classes/classes10.py

@@ -0,0 +1,5 @@
+assert Circle.pi == 3.14159, "pi should be a class attribute on Circle"
+assert abs(c1.area() - 3.14159) < 1e-6, f"area of circle r=1 should be ~3.14159, got {c1.area()}"
+assert abs(c2.area() - 3.14159 * 25) < 1e-4
+assert c1.pi is c2.pi, "pi should be the same class-level object for all instances"
+print("classes10 ✓")

pythonlings/curriculum/checks/classes/classes11.py

@@ -0,0 +1,5 @@
+assert isinstance(t, Temperature), "from_string should return a Temperature instance"
+assert t.degrees == 36.6, f"expected 36.6, got {t.degrees}"
+assert boiling.degrees == 100.0
+assert isinstance(Temperature.from_string("0C"), Temperature)
+print("classes11 ✓")

pythonlings/curriculum/checks/classes/classes12.py

@@ -0,0 +1,16 @@
+assert account.owner == "Alice", f"owner should be 'Alice', got {account.owner!r}"
+assert account.balance == 120, f"balance should be 120 after deposit 50 and withdraw 30, got {account.balance}"
+assert str(account) == "BankAccount(Alice, balance=120)", f"got {str(account)!r}"
+
+fresh = BankAccount("Bob", 50)
+fresh.deposit(25)
+assert fresh.balance == 75
+
+import sys
+try:
+    fresh.withdraw(1000)
+    assert False, "should have raised ValueError"
+except ValueError as e:
+    assert "insufficient" in str(e).lower(), f"ValueError message should mention 'insufficient', got {e!r}"
+
+print("classes12 ✓")

pythonlings/curriculum/checks/classes/classes2.py

@@ -0,0 +1,3 @@
+assert rex.name == "Rex", "the dog's name attribute should be 'Rex'"
+assert Dog("Fido").name == "Fido"
+print("classes2 ✓")

pythonlings/curriculum/checks/classes/classes3.py

@@ -0,0 +1,4 @@
+assert p.x == 3, "p.x should be 3"
+assert p.y == 7, "p.y should be 7"
+assert Point(0, 0).y == 0
+print("classes3 ✓")

pythonlings/curriculum/checks/classes/classes4.py

@@ -0,0 +1,4 @@
+assert rect.area() == 20, f"area of 4x5 should be 20, got {rect.area()}"
+assert Rectangle(3, 3).area() == 9
+assert Rectangle(1, 7).area() == 7
+print("classes4 ✓")

pythonlings/curriculum/checks/classes/classes5.py

@@ -0,0 +1,5 @@
+assert c.count == 3, f"count should be 3 after three increments, got {c.count}"
+d = Counter()
+d.increment()
+assert d.count == 1
+print("classes5 ✓")

pythonlings/curriculum/checks/classes/classes6.py

@@ -0,0 +1,4 @@
+assert slow.brand == "Tesla"
+assert slow.speed == 0, f"default speed should be 0, got {slow.speed}"
+assert fast.speed == 200
+print("classes6 ✓")

pythonlings/curriculum/checks/classes/classes7.py

@@ -0,0 +1,3 @@
+assert g.greet() == "Hello, Alice!", f"got {g.greet()!r}"
+assert Greeter("Bob").greet() == "Hello, Bob!"
+print("classes7 ✓")

pythonlings/curriculum/checks/classes/classes8.py

@@ -0,0 +1,3 @@
+assert str(book) == "Book: 1984 by Orwell", f"got {str(book)!r}"
+assert str(Book("Dune", "Herbert")) == "Book: Dune by Herbert"
+print("classes8 ✓")

pythonlings/curriculum/checks/classes/classes9.py

@@ -0,0 +1,4 @@
+assert repr(c) == "Color(r=255, g=128, b=0)", f"got {repr(c)!r}"
+assert str(c) == "rgb(255, 128, 0)"
+assert repr(Color(0, 0, 0)) == "Color(r=0, g=0, b=0)"
+print("classes9 ✓")

pythonlings/curriculum/checks/collections/collections1.py

@@ -0,0 +1,4 @@
+assert counts["apple"] == 3, "apple appears 3 times"
+assert counts["banana"] == 2, "banana appears 2 times"
+assert counts["cherry"] == 1, "cherry appears 1 time"
+print("collections1 ✓")

pythonlings/curriculum/checks/collections/collections10.py

@@ -0,0 +1,15 @@
+assert grouped["api"] == [120, 95, 110, 85, 100], "api response times"
+assert grouped["web"] == [45, 60, 55, 50], "web response times"
+assert grouped["db"] == [300, 280, 310], "db response times"
+
+assert hit_counts["api"] == 5, "api was hit 5 times"
+assert hit_counts["web"] == 4, "web was hit 4 times"
+assert hit_counts["db"] == 3, "db was hit 3 times"
+
+assert top_category == "api", "api has the most requests"
+
+assert abs(avg_times["api"] - 102.0) < 1e-9, "api avg is 510/5 = 102.0"
+assert abs(avg_times["web"] - 52.5) < 1e-9, "web avg is 210/4 = 52.5"
+assert abs(avg_times["db"] - 296.666_666_7) < 1e-4, "db avg is 890/3"
+
+print("collections10 ✓")

pythonlings/curriculum/checks/collections/collections2.py

@@ -0,0 +1,4 @@
+assert len(top2) == 2, "top2 must have exactly 2 entries"
+assert top2[0] == ("Alice", 4), "Alice leads with 4 votes"
+assert top2[1] == ("Bob", 3), "Bob is second with 3 votes"
+print("collections2 ✓")

pythonlings/curriculum/checks/collections/collections3.py

@@ -0,0 +1,5 @@
+assert char_counts["m"] == 1, "m appears once"
+assert char_counts["i"] == 4, "i appears 4 times"
+assert char_counts["s"] == 4, "s appears 4 times"
+assert char_counts["p"] == 2, "p appears 2 times"
+print("collections3 ✓")

pythonlings/curriculum/checks/collections/collections4.py

@@ -0,0 +1,4 @@
+assert by_grade["A"] == ["Alice", "Carol", "Frank"], "A students"
+assert by_grade["B"] == ["Bob", "Eve"], "B students"
+assert by_grade["C"] == ["Dave"], "C students"
+print("collections4 ✓")

pythonlings/curriculum/checks/collections/collections5.py

@@ -0,0 +1,5 @@
+assert p.x == 3, "p.x should be 3"
+assert p.y == 4, "p.y should be 4"
+assert p == (3, 4), "Point is still a tuple"
+assert Point.__name__ == "Point", "type name should be Point"
+print("collections5 ✓")

pythonlings/curriculum/checks/collections/collections6.py

@@ -0,0 +1,6 @@
+assert card.rank == "K", "card rank should be K"
+assert card.suit == "spades", "card suit should be spades"
+assert upgraded.rank == "A", "upgraded rank should be A"
+assert upgraded.suit == "spades", "suit is preserved after _replace"
+assert card.suit == upgraded.suit, "_replace does not mutate the original"
+print("collections6 ✓")

pythonlings/curriculum/checks/collections/collections7.py

@@ -0,0 +1,4 @@
+assert right_val == 2, "pop() removes from the right — should be 2"
+assert left_val == 0, "popleft() removes from the left — should be 0"
+assert list(d) == [1], "one element remains in the deque"
+print("collections7 ✓")

pythonlings/curriculum/checks/collections/collections8.py

@@ -0,0 +1,5 @@
+assert first == "doc1", "first out should be doc1"
+assert second == "doc2", "second out should be doc2"
+assert third == "doc3", "third out should be doc3"
+assert len(queue) == 0, "queue should be empty after draining"
+print("collections8 ✓")

pythonlings/curriculum/checks/collections/collections9.py

@@ -0,0 +1,9 @@
+assert combined["apple"] == 7, "5 + 2 = 7 apples"
+assert combined["banana"] == 7, "3 + 4 = 7 bananas"
+assert combined["cherry"] == 2, "2 + 0 = 2 cherries"
+assert combined["date"] == 1, "0 + 1 = 1 date"
+assert remainder["apple"] == 3, "7 - 4 = 3 apples remain"
+assert remainder["banana"] == 2, "7 - 5 = 2 bananas remain"
+assert remainder["cherry"] == 1, "2 - 1 = 1 cherry remains"
+assert "date" not in remainder or remainder["date"] == 1, "date was not sold"
+print("collections9 ✓")

pythonlings/curriculum/checks/comprehensions/comprehensions1.py

@@ -0,0 +1,3 @@
+assert isinstance(numbers, list), "numbers should be a list"
+assert numbers == [0, 1, 2, 3, 4], f"expected [0, 1, 2, 3, 4], got {numbers!r}"
+print("comprehensions1 ✓")

pythonlings/curriculum/checks/comprehensions/comprehensions10.py

@@ -0,0 +1,5 @@
+assert isinstance(word_index, dict), "word_index should be a dict"
+assert word_index == {"apple": 0, "banana": 1, "cherry": 2, "date": 3}, (
+    f"unexpected word_index: {word_index!r}"
+)
+print("comprehensions10 ✓")

pythonlings/curriculum/checks/comprehensions/comprehensions2.py

@@ -0,0 +1,3 @@
+assert isinstance(evens, list), "evens should be a list"
+assert evens == [2, 4, 6, 8], f"expected [2, 4, 6, 8], got {evens!r}"
+print("comprehensions2 ✓")

pythonlings/curriculum/checks/comprehensions/comprehensions3.py

@@ -0,0 +1,3 @@
+assert isinstance(doubled, list), "doubled should be a list"
+assert doubled == [2, 4, 6, 8, 10], f"expected [2, 4, 6, 8, 10], got {doubled!r}"
+print("comprehensions3 ✓")

pythonlings/curriculum/checks/comprehensions/comprehensions4.py

@@ -0,0 +1,6 @@
+assert isinstance(pairs, list), "pairs should be a list"
+assert pairs == [
+    (0, 0), (0, 1), (0, 2),
+    (1, 0), (1, 1), (1, 2),
+], f"unexpected pairs: {pairs!r}"
+print("comprehensions4 ✓")

pythonlings/curriculum/checks/comprehensions/comprehensions5.py

@@ -0,0 +1,3 @@
+assert isinstance(squared, dict), "squared should be a dict"
+assert squared == {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}, f"unexpected squared: {squared!r}"
+print("comprehensions5 ✓")

pythonlings/curriculum/checks/comprehensions/comprehensions6.py

@@ -0,0 +1,3 @@
+assert isinstance(unique_lengths, set), "unique_lengths should be a set"
+assert unique_lengths == {3, 5, 8}, f"expected {{3, 5, 8}}, got {unique_lengths!r}"
+print("comprehensions6 ✓")

pythonlings/curriculum/checks/comprehensions/comprehensions7.py

@@ -0,0 +1,4 @@
+assert isinstance(vowels, list), "vowels should be a list"
+expected = [c for c in "list comprehensions are quite powerful" if c in "aeiou"]
+assert vowels == expected, f"expected {expected!r}, got {vowels!r}"
+print("comprehensions7 ✓")

pythonlings/curriculum/checks/comprehensions/comprehensions8.py

@@ -0,0 +1,5 @@
+assert isinstance(labels, list), "labels should be a list"
+assert labels == ["odd", "even", "odd", "even", "odd", "even"], (
+    f"expected ['odd', 'even', 'odd', 'even', 'odd', 'even'], got {labels!r}"
+)
+print("comprehensions8 ✓")