fibonacci-tdd-kataa 0.1.0__tar.gz

fibonacci_tdd_kataa-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,28 @@
+
+name: Publish package
+
+on:
+  release:
+    types: [published]
+
+permissions:
+  id-token: write
+
+jobs:
+  test:
+    uses: ./.github/workflows/tests.yml
+
+  build-and-publish:
+    needs: test
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+
+      - name: Build package
+        run: uv build
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

fibonacci_tdd_kataa-0.1.0/.github/workflows/tests.yml

@@ -0,0 +1,33 @@
+
+name: Tests
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+  workflow_call:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.12"]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install dependencies
+        run: uv sync --all-groups
+
+      - name: Lint
+        run: uv run ruff check .
+
+      - name: Run tests
+        run: uv run pytest --cov=src --cov-report=term-missing

fibonacci_tdd_kataa-0.1.0/.gitignore

@@ -0,0 +1,5 @@
+.venv/
+__pycache__/
+*.pyc
+.pytest_cache/
+__marimo__/

fibonacci_tdd_kataa-0.1.0/.python-version

@@ -0,0 +1 @@
+3.12

fibonacci_tdd_kataa-0.1.0/PKG-INFO

@@ -0,0 +1,6 @@
+Metadata-Version: 2.5
+Name: fibonacci-tdd-kataa
+Version: 0.1.0
+Summary: A TDD kata: Fibonacci, from notebook exploration to a tested, published package
+Author-email: malak khalil <malak.khalil@lau.edu>
+Requires-Python: >=3.12

fibonacci_tdd_kataa-0.1.0/notebooks/notebook.py

@@ -0,0 +1,157 @@
+import marimo
+
+__generated_with = "0.24.2"
+app = marimo.App(width="medium")
+
+
+@app.cell
+def _():
+    import marimo as mo
+    import pytest
+
+    return (mo,)
+
+
+@app.cell
+def _(mo):
+    mo.md("""
+    # Fibonacci TDD Kata
+
+    ## Objective
+
+    This notebook demonstrates the Test-Driven Development workflow by implementing
+    the Fibonacci sequence step by step.
+
+    ## Fibonacci sequence
+
+    The sequence is defined as:
+
+    - F(0) = 0
+    - F(1) = 1
+    - F(n) = F(n - 1) + F(n - 2) for n >= 2
+
+    ## TDD workflow
+
+    The implementation follows the Red → Green → Refactor cycle:
+
+    1. Write tests that initially fail.
+    2. Implement the function until all tests pass.
+    3. Refactor the code while keeping the test suite green.
+
+    ## Interactive demo
+
+    Use the widget below to select a value of `n` and display the corresponding
+    Fibonacci number.
+    """)
+    return
+
+
+@app.function
+def fibonacci(n):
+    def fib_pair(k):
+        if k == 0:
+            return 0, 1
+
+        a, b = fib_pair(k // 2)
+
+        c = a * (2 * b - a)
+        d = a * a + b * b
+
+        if k % 2 == 0:
+            return c, d
+        return d, c + d
+
+    return fib_pair(n)[0]
+
+
+@app.cell
+def _():
+    def test_fibonacci_zero():
+        assert fibonacci(0) == 0
+
+    def test_fibonacci_one():
+        assert fibonacci(1) == 1
+
+    def test_fibonacci_two():
+        assert fibonacci(2) == 1
+
+    def test_fibonacci_three():
+        assert fibonacci(3) == 2
+
+    def test_fibonacci_four():
+        assert fibonacci(4) == 3
+
+    def test_fibonacci_five():
+        assert fibonacci(5) == 5
+
+    return
+
+
+@app.cell
+def _(mo):
+    n_input = mo.ui.number(
+        start=0,
+        stop=30,
+        step=1,
+        value=10,
+        label="n"
+    )
+
+    n_input
+    return (n_input,)
+
+
+@app.cell
+def _(mo, n_input):
+    mo.md(
+        f"**F({n_input.value}) = {fibonacci(n_input.value)}**"
+    )
+    return
+
+
+@app.cell
+def _(mo):
+    mo.md("""
+    ## Large-value tests
+
+    These tests serve two purposes:
+
+    1. **Correctness after optimization**
+       We verify that the function still returns known Fibonacci values for larger inputs.
+
+    2. **Performance motivation**
+       We use a much larger input to reveal the limitations of the naive recursive implementation
+       before refactoring it for better performance.
+    """)
+    return
+
+
+@app.function
+def test_fibonacci_large_values():
+    assert fibonacci(10) == 55
+    assert fibonacci(20) == 6765
+    assert fibonacci(30) == 832040
+
+
+@app.function
+def test_fibonacci_large_recurrence():
+    n = 1000
+    assert fibonacci(n) == fibonacci(n - 1) + fibonacci(n - 2)
+
+
+@app.function
+# Large-scale performance and correctness test:
+# Verifies that the optimized implementation can handle n = 10^7.
+# Two consecutive Fibonacci numbers are always coprime.
+def test_fibonacci_very_large():
+    import math
+
+    n = 10**7
+    fn = fibonacci(n)
+    fn_next = fibonacci(n + 1)
+
+    assert math.gcd(fn, fn_next) == 1
+
+
+if __name__ == "__main__":
+    app.run()

fibonacci_tdd_kataa-0.1.0/pyproject.toml

@@ -0,0 +1,33 @@
+
+[project]
+name = "fibonacci-tdd-kataa"
+version = "0.1.0"
+description = "A TDD kata: Fibonacci, from notebook exploration to a tested, published package"
+readme = "README.md"
+requires-python = ">=3.12"
+authors = [
+    { name = "malak khalil", email = "malak.khalil@lau.edu" }
+]
+dependencies = []
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/fibonacci_tdd_kata"]
+
+[dependency-groups]
+dev = [
+    "pytest>=9.1.1",
+    "pytest-cov>=5.0",
+    "ruff>=0.16.8",
+    "marimo>=0.24.2",
+]
+
+[tool.pytest.ini_options]
+pythonpath = ["src"]
+testpaths = ["tests"]
+
+[tool.ruff.lint.per-file-ignores]
+"notebooks/*.py" = ["B018", "PLR1711", "F401"]

fibonacci_tdd_kataa-0.1.0/src/fibonacci_tdd_kata/__init__.py

@@ -0,0 +1,7 @@
+
+"""Fibonacci TDD kata package — see core.py for the implementation."""
+
+from fibonacci_tdd_kata.core import fibonacci
+
+__all__ = ["fibonacci"]
+__version__ = "0.1.0"

fibonacci_tdd_kataa-0.1.0/src/fibonacci_tdd_kata/core.py

@@ -0,0 +1,22 @@
+
+"""Core Fibonacci implementation."""
+
+
+def fibonacci(n: int) -> int:
+    """Return F(n) using the fast-doubling algorithm."""
+    if not isinstance(n, int) or n < 0:
+        raise ValueError("n must be a non-negative integer")
+
+    def fib_pair(k: int) -> tuple[int, int]:
+        if k == 0:
+            return 0, 1
+
+        a, b = fib_pair(k // 2)
+        c = a * (2 * b - a)
+        d = a * a + b * b
+
+        if k % 2 == 0:
+            return c, d
+        return d, c + d
+
+    return fib_pair(n)[0]

fibonacci_tdd_kataa-0.1.0/tests/test_core.py

@@ -0,0 +1,62 @@
+
+"""Tests for the Fibonacci implementation."""
+
+import math
+
+import pytest
+
+from fibonacci_tdd_kata.core import fibonacci
+
+
+def test_fibonacci_zero():
+    assert fibonacci(0) == 0
+
+
+def test_fibonacci_one():
+    assert fibonacci(1) == 1
+
+
+def test_fibonacci_two():
+    assert fibonacci(2) == 1
+
+
+def test_fibonacci_three():
+    assert fibonacci(3) == 2
+
+
+def test_fibonacci_four():
+    assert fibonacci(4) == 3
+
+
+def test_fibonacci_five():
+    assert fibonacci(5) == 5
+
+
+@pytest.mark.parametrize(
+    ("n", "expected"),
+    [
+        (10, 55),
+        (20, 6765),
+        (30, 832040),
+    ],
+)
+def test_fibonacci_large_values(n, expected):
+    assert fibonacci(n) == expected
+
+
+def test_fibonacci_large_recurrence():
+    n = 1000
+    assert fibonacci(n) == fibonacci(n - 1) + fibonacci(n - 2)
+
+
+def test_fibonacci_very_large():
+    n = 10**7
+    fn = fibonacci(n)
+    fn_next = fibonacci(n + 1)
+
+    assert math.gcd(fn, fn_next) == 1
+
+
+def test_fibonacci_negative_input():
+    with pytest.raises(ValueError):
+        fibonacci(-1)