Add CodSpeed performance benchmarks (#98)

Co-authored-by: codspeed-hq[bot] <117304815+codspeed-hq[bot]@users.noreply.github.com>
Co-authored-by: Tiago Silva <tiago.arasilva@gmail.com>

Author: codspeed-hq[bot]

.github/workflows/codspeed.yml

@@ -0,0 +1,36 @@
+---
+name: CodSpeed Benchmarks
+
+on:
+  push:
+    branches:
+      - "main"
+  pull_request:
+    branches:
+      - "main"
+  workflow_dispatch:
+
+permissions:
+  contents: read
+  id-token: write
+
+jobs:
+  benchmarks:
+    name: Run benchmarks
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: "actions/checkout@v4"
+      - uses: "actions/setup-python@v5"
+        with:
+          python-version: "3.13"
+      - name: Install dependencies
+        run: |
+          pip install hatch
+          pip install -e .
+          pip install pytest-codspeed pytest-asyncio
+      - name: Run the benchmarks
+        uses: CodSpeedHQ/action@v4
+        with:
+          mode: simulation
+          run: pytest benchmarks/ --codspeed

README.md

@@ -20,6 +20,10 @@
 <a href="https://pypi.org/project/mongoz" target="_blank">
     <img src="https://img.shields.io/pypi/pyversions/mongoz.svg?color=%2334D058" alt="Supported Python versions">
 </a>
+
+<a href="https://codspeed.io/dymmond/mongoz?utm_source=badge" target="_blank">
+    <img src="https://img.shields.io/endpoint?url=https://codspeed.io/badge/dymmond/mongoz" alt="CodSpeed">
+</a>
 </p>
 
 ---

benchmarks/__init__.py

@@ -0,0 +1,24 @@
+import asyncio
+import os
+import typing
+
+import pytest
+
+from mongoz.core.connection.registry import Registry
+
+database_uri = os.environ.get(
+    "DATABASE_URI", "mongodb://root:mongoadmin@localhost:27017"
+)
+client = Registry(database_uri, event_loop=asyncio.get_running_loop)
+
+
+@pytest.fixture(scope="module")
+def anyio_backend():
+    return ("asyncio", {"debug": False})
+
+
+@pytest.fixture(scope="session")
+def event_loop() -> typing.Generator[asyncio.AbstractEventLoop, None, None]:
+    loop = asyncio.get_event_loop_policy().new_event_loop()
+    yield loop
+    loop.close()

benchmarks/conftest.py

@@ -0,0 +1,124 @@
+"""Benchmarks for Document model instantiation and serialization."""
+
+from __future__ import annotations
+
+from datetime import datetime
+from typing import List, Optional
+
+import pytest
+
+import mongoz
+from benchmarks.conftest import client
+
+
+class Movie(mongoz.Document):
+    name: str = mongoz.String()
+    year: int = mongoz.Integer()
+    tags: Optional[List[str]] = mongoz.Array(str, null=True)
+
+    class Meta:
+        registry = client
+        database = "bench_db"
+
+
+class Course(mongoz.EmbeddedDocument):
+    code: str = mongoz.String()
+    name: str = mongoz.String()
+    start_date: datetime = mongoz.DateTime()
+    end_date: datetime = mongoz.DateTime()
+
+
+class Student(mongoz.Document):
+    name: str = mongoz.String()
+    roll_no: int = mongoz.Integer()
+    courses: List[Course] = mongoz.Array(Course, default=[])
+
+    class Meta:
+        registry = client
+        database = "bench_db"
+
+
+@pytest.mark.benchmark
+def test_bench_embedded_document_instantiation():
+    """Benchmark creating EmbeddedDocument instances."""
+    for _ in range(100):
+        Course(
+            code="CS101",
+            name="Computer Science",
+            start_date="2024-01-15",
+            end_date="2024-06-15",
+        )
+
+
+@pytest.mark.benchmark
+def test_bench_embedded_document_model_dump():
+    """Benchmark serializing EmbeddedDocument to dict."""
+    course = Course(
+        code="CS101",
+        name="Computer Science",
+        start_date="2024-01-15",
+        end_date="2024-06-15",
+    )
+    for _ in range(100):
+        course.model_dump()
+
+
+@pytest.mark.benchmark
+def test_bench_embedded_document_model_dump_json():
+    """Benchmark serializing EmbeddedDocument to JSON."""
+    course = Course(
+        code="CS101",
+        name="Computer Science",
+        start_date="2024-01-15",
+        end_date="2024-06-15",
+    )
+    for _ in range(100):
+        course.model_dump_json()
+
+
+@pytest.mark.benchmark
+def test_bench_embedded_document_with_nested():
+    """Benchmark creating a Student with nested Course documents."""
+    courses = [
+        Course(
+            code=f"CS{i}",
+            name=f"Course {i}",
+            start_date="2024-01-15",
+            end_date="2024-06-15",
+        )
+        for i in range(5)
+    ]
+    for _ in range(50):
+        Student(name="Test Student", roll_no=2024, courses=courses)
+
+
+@pytest.mark.benchmark
+def test_bench_document_model_dump_with_nested():
+    """Benchmark serializing a Student with nested Course documents."""
+    courses = [
+        Course(
+            code=f"CS{i}",
+            name=f"Course {i}",
+            start_date="2024-01-15",
+            end_date="2024-06-15",
+        )
+        for i in range(5)
+    ]
+    student = Student(name="Test Student", roll_no=2024, courses=courses)
+    for _ in range(50):
+        student.model_dump()
+
+
+@pytest.mark.benchmark
+def test_bench_movie_model_instantiation():
+    """Benchmark creating Movie document instances."""
+    for _ in range(100):
+        Movie(name="Benchmark Movie", year=2024, tags=["action", "sci-fi"])
+
+
+@pytest.mark.benchmark
+def test_bench_movie_model_dump():
+    """Benchmark serializing a Movie document."""
+    movie = Movie(name="Benchmark Movie", year=2024, tags=["action", "sci-fi"])
+    for _ in range(100):
+        movie.model_dump()

benchmarks/test_bench_documents.py

@@ -0,0 +1,119 @@
+"""Benchmarks for Expression compilation and Q operator construction."""
+
+from __future__ import annotations
+
+import pytest
+
+from mongoz.core.db.querysets.expressions import Expression, SortExpression
+from mongoz.core.db.querysets.operators import Q
+from mongoz.utils.enums import ExpressionOperator
+
+
+@pytest.mark.benchmark
+def test_bench_expression_compile_eq():
+    """Benchmark compiling a simple equality expression."""
+    expr = Expression(key="name", operator=ExpressionOperator.EQUAL, value="test")
+    for _ in range(100):
+        expr.compile()
+
+
+@pytest.mark.benchmark
+def test_bench_expression_compile_regex():
+    """Benchmark compiling a regex expression."""
+    expr = Expression(
+        key="name", operator=ExpressionOperator.PATTERN, value="test.*pattern"
+    )
+    for _ in range(100):
+        expr.compile()
+
+
+@pytest.mark.benchmark
+def test_bench_expression_compile_startswith():
+    """Benchmark compiling a startswith expression."""
+    expr = Expression(
+        key="name", operator=ExpressionOperator.STARTSWITH, value="prefix"
+    )
+    for _ in range(100):
+        expr.compile()
+
+
+@pytest.mark.benchmark
+def test_bench_expression_compile_many():
+    """Benchmark compiling multiple expressions at once."""
+    expressions = [
+        Expression(key="name", operator=ExpressionOperator.EQUAL, value="test"),
+        Expression(key="age", operator=ExpressionOperator.GREATER_THAN, value=18),
+        Expression(key="year", operator=ExpressionOperator.LESS_THAN, value=2024),
+        Expression(
+            key="email", operator=ExpressionOperator.PATTERN, value=".*@example.com"
+        ),
+        Expression(
+            key="status", operator=ExpressionOperator.IN, value=["active", "pending"]
+        ),
+    ]
+    for _ in range(100):
+        Expression.compile_many(expressions)
+
+
+@pytest.mark.benchmark
+def test_bench_expression_unpack():
+    """Benchmark unpacking a dictionary into expressions."""
+    d = {
+        "name": "test",
+        "year": {"$gt": 1990, "$lt": 2024},
+        "status": "active",
+    }
+    for _ in range(100):
+        Expression.unpack(d)
+
+
+@pytest.mark.benchmark
+def test_bench_q_operator_construction():
+    """Benchmark constructing Q operator expressions."""
+    for _ in range(100):
+        Q.eq("name", "test")
+        Q.neq("status", "inactive")
+        Q.gt("age", 18)
+        Q.lt("year", 2024)
+        Q.gte("score", 80)
+        Q.lte("price", 100.0)
+
+
+@pytest.mark.benchmark
+def test_bench_q_in_operator():
+    """Benchmark constructing Q in/not_in expressions."""
+    values = ["active", "pending", "approved", "rejected"]
+    for _ in range(100):
+        Q.in_("status", values)
+        Q.not_in("status", values)
+
+
+@pytest.mark.benchmark
+def test_bench_q_logical_operators():
+    """Benchmark constructing logical Q operators (and, or, nor)."""
+    expr1 = Q.eq("name", "test")
+    expr2 = Q.gt("age", 18)
+    expr3 = Q.lt("year", 2024)
+    for _ in range(100):
+        Q.and_(expr1, expr2, expr3)
+        Q.or_(expr1, expr2, expr3)
+
+
+@pytest.mark.benchmark
+def test_bench_q_ordering():
+    """Benchmark constructing ordering expressions."""
+    for _ in range(100):
+        Q.asc("name")
+        Q.desc("created_at")
+        Q.asc("year")
+        Q.desc("score")
+
+
+@pytest.mark.benchmark
+def test_bench_sort_expression_compile():
+    """Benchmark compiling sort expressions."""
+    from mongoz.core.db.datastructures import Order
+
+    sort_expr = SortExpression(key="name", direction=Order.ASCENDING)
+    for _ in range(100):
+        sort_expr.compile()

benchmarks/test_bench_expressions.py

@@ -123,6 +123,7 @@ dependencies = [
     "mypy==1.16.1",
     "pytest>=7.2.2,<9.0.0",
     "pytest-asyncio>=0.21.1,<1.0.0",
+    "pytest-codspeed>=4.3.0",
     "pytest-cov>=4.0.0,<5.0.0",
     "requests>=2.28.2",
     "ruff>=0.0.256,<1.0.0",
@@ -183,6 +184,9 @@ ignore_errors = true
 addopts = ["--strict-config", "--strict-markers"]
 xfail_strict = true
 junit_family = "xunit2"
+markers = [
+    "benchmark: mark a test as a CodSpeed benchmark",
+]
 
 [tool.hatch.build.targets.sdist]
 include = ["/mongoz"]