fibonacci-kata 0.1.0__tar.gz

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

@@ -0,0 +1,27 @@
+name: Publish package
+
+on:
+  release:
+    types: [published]
+
+permissions:
+  id-token: write   # required for PyPI Trusted Publishing
+
+jobs:
+  test:
+    uses: ./.github/workflows/tests.yml   # re-run the full test workflow
+
+  build-and-publish:
+    needs: test                            # only runs if tests succeeded
+    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_kata-0.1.0/.github/workflows/tests.yml

@@ -0,0 +1,31 @@
+name: Tests
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+  workflow_call:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.11", "3.12", "3.13"]
+    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_kata-0.1.0/.gitignore

@@ -0,0 +1,10 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv

fibonacci_kata-0.1.0/.python-version

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

fibonacci_kata-0.1.0/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.5
+Name: fibonacci-kata
+Version: 0.1.0
+Summary: A TDD kata: Fibonacci, from notebook exploration to a tested, published package
+Author-email: Rina Ralijaona <rinaralijaona4@gmail.com>
+License: MIT
+Requires-Python: >=3.11

fibonacci_kata-0.1.0/__marimo__/session/notebook.py.json

@@ -0,0 +1,15 @@
+{
+  "version": "1",
+  "metadata": {
+    "marimo_version": "0.24.2",
+    "script_metadata_hash": null
+  },
+  "cells": [
+    {
+      "id": "Hbol",
+      "code_hash": null,
+      "outputs": [],
+      "console": []
+    }
+  ]
+}

fibonacci_kata-0.1.0/notebooks/tdd_fibonacci_marimo_en.py

@@ -0,0 +1,127 @@
+import marimo
+
+__generated_with = "0.24.2"
+app = marimo.App(width="medium")
+
+
+@app.cell
+def _():
+    import marimo as mo
+
+    return (mo,)
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(r"""
+    # Fibonacci Kata
+    """)
+    #return
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(r"""
+    This notebook implements the Fibonacci sequence using TDD.
+
+    The Fibonacci sequence is defined by:
+
+    - F(0) = 0
+    - F(1) = 1
+    - F(n) = F(n-1) + F(n-2)
+    """)
+    #return
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(r"""
+    ### Fibonacci function implementation
+    """)
+    #return
+
+
+@app.function
+def fibonacci(n: int) -> int:
+    """
+        Returns the n-th Fibonacci number 
+        Contract:
+        - if n = 0: 0
+        - if n = 1: 1
+        - otherwise: fibonacci(n-1) + fibonacci(n-2)
+
+    """
+    prev = 0
+    cur = 1
+    
+    for k in range(n):
+        cur, prev = cur + prev, cur
+
+
+    return prev
+
+
+app._unparsable_cell(
+    r"""
+    ### Fibonacci optimization
+
+    The algorthme can be improved to O(log n) by using fast doubling. 
+    - F(2k) = F(k) * (2*F(k+1) - F(k))
+    - F(2k + 1) = F(k)² + F(k+1)²
+    """,
+    name="_"
+)
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(r"""
+    ### Unit tests
+    """)
+    #return
+
+
+@app.cell
+def _():
+    assert fibonacci(0) == 0
+    assert fibonacci(1) == 1
+    assert fibonacci(2) == 1
+    assert fibonacci(5) == 5
+    assert fibonacci(10) == 55
+    #return
+
+
+@app.cell
+def _():
+    fibonacci(10**2)
+    #return
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(r"""
+    ### Interactive marimo widget
+    """)
+    #return
+
+
+@app.cell
+def _(mo):
+    n_input = mo.ui.number(start=1, stop=1000, step=1, value=5, label="n")
+    
+    return n_input
+
+
+@app.cell
+def _(mo, n_input):
+    try:
+        result = fibonacci(n_input.value)
+        output = mo.md(f"`fibonacci({n_input.value})` → **{result}**")
+    except ValueError as e:
+        output = mo.md(f"⚠️ Error: {e}")
+    
+    return output
+
+
+if __name__ == "__main__":
+    app.run()

fibonacci_kata-0.1.0/pyproject.toml

@@ -0,0 +1,27 @@
+[project]
+name = "fibonacci-kata"
+version = "0.1.0"
+description = "A TDD kata: Fibonacci, from notebook exploration to a tested, published package"
+readme = "README.md"
+requires-python = ">=3.11"
+license = { text = "MIT" }
+authors = [{ name = "Rina Ralijaona", email = "rinaralijaona4@gmail.com" }]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/fibonacci_kata"]
+
+[dependency-groups]
+dev = [
+    "pytest>=8.0",
+    "pytest-cov>=5.0",
+    "ruff>=0.6",
+    "marimo>=0.10",
+]
+
+[tool.pytest.ini_options]
+pythonpath = ["src"]
+testpaths = ["tests"]

fibonacci_kata-0.1.0/src/fibonacci_kata/core.py

@@ -0,0 +1,20 @@
+def fibonacci(n: int) -> int:
+    """
+        Returns the n-th Fibonacci number 
+        Contract:
+        - if n = 0: 0
+        - if n = 1: 1
+        - otherwise: fibonacci(n-1) + fibonacci(n-2)
+
+    """
+
+    if not isinstance(n, int) or n < 0:
+        raise ValueError("fibonacci expects a positive integer")
+    
+    prev = 0
+    cur = 1
+    
+    for k in range(n):
+        cur, prev = cur + prev, cur
+
+    return prev

fibonacci_kata-0.1.0/src/fibonacci_kata/init.py

@@ -0,0 +1,5 @@
+"""Fibonacci kata package — see core.py for the implementation."""
+
+all = ["fibonacci"]
+version = "0.1.0"
+

fibonacci_kata-0.1.0/src/fibonacci_tdd_kata/__init__.py

@@ -0,0 +1,2 @@
+def main() -> None:
+    print("Hello from fibonacci-tdd-kata!")

fibonacci_kata-0.1.0/tests/test_core.py

@@ -0,0 +1,19 @@
+import pytest
+
+from fibonacci_kata.core import fibonacci
+
+
+@pytest.mark.parametrize(
+    ("n", "expected"),
+    [
+        (0, 0),
+        (1, 1),
+        (2, 1),
+        (3, 2),
+        (10, 55),
+        (20, 6765)
+    ],
+)
+
+def test_cases(n, expected):
+    assert fibonacci(n) == expected