⚡️ Speed up method StrawchemyRepository._get_field_hooks by 82% in PR #120 (renovate/lock-file-maintenance)

[codeflash-ai]

⚡️ This pull request contains optimizations for PR #120

If you approve this dependent PR, these changes will be merged into the original PR branch renovate/lock-file-maintenance.

This PR will be automatically closed if the original PR is merged.

---

📄 82% (0.82x) speedup for StrawchemyRepository._get_field_hooks in src/strawchemy/strawberry/repository/_base.py

⏱️ Runtime : 332 microseconds → 182 microseconds (best of 217 runs)

📝 Explanation and details

The optimization eliminates the repeated import overhead by caching the imported class as a class attribute after first use. In the original code, every call to _get_field_hooks performed a fresh import of StrawchemyField from strawchemy.strawberry._field, which accounted for 55% of the function's execution time according to the profiler.

Key changes:

• Import caching: Uses a try/except pattern to check for cls._StrawchemyField attribute first, only importing on the initial call when AttributeError is raised
• Class-level storage: Stores the imported StrawchemyField class on the repository class itself for reuse across all instances and calls

Why this is faster:
Python's import system involves module lookup, attribute resolution, and potential disk I/O on first import. Even for already-loaded modules, the from X import Y statement still requires namespace resolution. By caching the class reference, subsequent calls skip this entirely and just perform a simple attribute access.

Performance impact:
The line profiler shows the import went from 656,967ns (55% of runtime) to just 1,443ns on first call, with subsequent calls avoiding the import completely. This results in an 82% speedup overall. The test results show consistent 100-190% improvements across all test cases, indicating the optimization benefits any workload that calls this method multiple times.

Workload compatibility:
Since this appears to be a field processing utility in a GraphQL repository, it's likely called frequently during query resolution. The caching pattern is thread-safe for the common case (reading an already-set attribute) and maintains identical behavior including the lazy import pattern required by the # noqa: PLC0415 comment.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	🔘 None Found
🌀 Generated Regression Tests	✅ 1034 Passed
⏪ Replay Tests	🔘 None Found
🔎 Concolic Coverage Tests	🔘 None Found
📊 Tests Coverage	100.0%

🌀 Generated Regression Tests and Runtime

import sys
import types

# imports
from src.strawchemy.strawberry.repository._base import StrawchemyRepository

# --- Minimal stubs for dependencies ---


# Simulate QueryHook (could be any callable or object)
class QueryHook:
    def __init__(self, name):
        self.name = name

    def __repr__(self):
        return f"QueryHook({self.name!r})"

    def __eq__(self, other):
        return isinstance(other, QueryHook) and self.name == other.name


# Simulate StrawberryField base class
class StrawberryField:
    pass


# Simulate StrawchemyField subclass with query_hook attribute
class StrawchemyField(StrawberryField):
    def __init__(self, query_hook=None):
        self.query_hook = query_hook


strawchemy_strawberry_field_mod = types.ModuleType("strawchemy.strawberry._field")
strawchemy_strawberry_field_mod.StrawchemyField = StrawchemyField
sys.modules["strawchemy.strawberry._field"] = strawchemy_strawberry_field_mod

# --- Unit Tests ---

# 1. Basic Test Cases


def test_none_for_plain_strawberryfield():
    # Should return None for a plain StrawberryField (not a StrawchemyField)
    field = StrawberryField()
    codeflash_output = StrawchemyRepository._get_field_hooks(field)
    result = codeflash_output  # 1.55μs -> 651ns (139% faster)


def test_none_for_strawchemyfield_with_no_hook():
    # Should return None if StrawchemyField has no query_hook attribute set
    field = StrawchemyField()
    codeflash_output = StrawchemyRepository._get_field_hooks(field)
    result = codeflash_output  # 1.13μs -> 450ns (152% faster)


def test_single_queryhook_object():
    # Should return the QueryHook if StrawchemyField has a single QueryHook
    hook = QueryHook("hook1")
    field = StrawchemyField(query_hook=hook)
    codeflash_output = StrawchemyRepository._get_field_hooks(field)
    result = codeflash_output  # 1.07μs -> 441ns (143% faster)


def test_sequence_of_queryhooks():
    # Should return the list of QueryHooks if StrawchemyField has a sequence of QueryHooks
    hooks = [QueryHook("hookA"), QueryHook("hookB")]
    field = StrawchemyField(query_hook=hooks)
    codeflash_output = StrawchemyRepository._get_field_hooks(field)
    result = codeflash_output  # 1.07μs -> 411ns (161% faster)


def test_tuple_of_queryhooks():
    # Should return the tuple of QueryHooks if StrawchemyField has a tuple of QueryHooks
    hooks = (QueryHook("hookX"), QueryHook("hookY"))
    field = StrawchemyField(query_hook=hooks)
    codeflash_output = StrawchemyRepository._get_field_hooks(field)
    result = codeflash_output  # 1.05μs -> 361ns (191% faster)


def test_queryhook_is_none_explicitly():
    # Should return None if query_hook is explicitly set to None
    field = StrawchemyField(query_hook=None)
    codeflash_output = StrawchemyRepository._get_field_hooks(field)
    result = codeflash_output  # 1.05μs -> 401ns (162% faster)


# 2. Edge Test Cases


def test_queryhook_is_empty_list():
    # Should return empty list if query_hook is set to empty list
    field = StrawchemyField(query_hook=[])
    codeflash_output = StrawchemyRepository._get_field_hooks(field)
    result = codeflash_output  # 1.06μs -> 401ns (165% faster)


def test_queryhook_is_empty_tuple():
    # Should return empty tuple if query_hook is set to empty tuple
    field = StrawchemyField(query_hook=())
    codeflash_output = StrawchemyRepository._get_field_hooks(field)
    result = codeflash_output  # 1.01μs -> 430ns (135% faster)


def test_queryhook_is_unexpected_type():
    # Should return the value as-is even if it's not a QueryHook or Sequence thereof (since function doesn't type-check)
    field = StrawchemyField(query_hook=123)
    codeflash_output = StrawchemyRepository._get_field_hooks(field)
    result = codeflash_output  # 1.02μs -> 371ns (175% faster)


def test_queryhook_is_string():
    # Should return the string as-is if that's what is stored
    field = StrawchemyField(query_hook="not a hook")
    codeflash_output = StrawchemyRepository._get_field_hooks(field)
    result = codeflash_output  # 1.05μs -> 381ns (176% faster)


def test_non_strawchemyfield_with_query_hook_attr():
    # Even if a plain StrawberryField has a query_hook attribute, should return None (type check is on class)
    field = StrawberryField()
    field.query_hook = QueryHook("should not see this")
    codeflash_output = StrawchemyRepository._get_field_hooks(field)
    result = codeflash_output  # 1.32μs -> 631ns (110% faster)


def test_strawchemyfield_with_falsey_query_hook():
    # Should return the falsey value (0, '', False) if that's what is set
    for falsey in [0, "", False]:
        field = StrawchemyField(query_hook=falsey)
        codeflash_output = StrawchemyRepository._get_field_hooks(field)
        result = codeflash_output  # 1.87μs -> 802ns (134% faster)


# 3. Large Scale Test Cases


def test_large_list_of_queryhooks():
    # Should return a large list of QueryHooks correctly
    hooks = [QueryHook(f"hook{i}") for i in range(500)]
    field = StrawchemyField(query_hook=hooks)
    codeflash_output = StrawchemyRepository._get_field_hooks(field)
    result = codeflash_output  # 1.01μs -> 371ns (173% faster)


def test_large_tuple_of_queryhooks():
    # Should return a large tuple of QueryHooks correctly
    hooks = tuple(QueryHook(f"hook{i}") for i in range(999))
    field = StrawchemyField(query_hook=hooks)
    codeflash_output = StrawchemyRepository._get_field_hooks(field)
    result = codeflash_output  # 1.00μs -> 410ns (144% faster)


def test_large_string_queryhook():
    # Should return the large string as-is
    large_string = "X" * 1000
    field = StrawchemyField(query_hook=large_string)
    codeflash_output = StrawchemyRepository._get_field_hooks(field)
    result = codeflash_output  # 1.03μs -> 401ns (157% faster)


def test_large_nested_sequence_queryhook():
    # Should return the nested structure as-is (no flattening or validation)
    nested = [[QueryHook(f"hook{i}") for i in range(10)] for _ in range(50)]
    field = StrawchemyField(query_hook=nested)
    codeflash_output = StrawchemyRepository._get_field_hooks(field)
    result = codeflash_output  # 1.05μs -> 411ns (156% faster)


# 4. Mutant-killer: Type check is on class, not attribute presence


def test_type_check_is_on_class_not_attribute():
    # Even if a StrawberryField has a query_hook attribute, only StrawchemyField triggers return
    field = StrawberryField()
    field.query_hook = QueryHook("should not be returned")
    codeflash_output = StrawchemyRepository._get_field_hooks(field)
    result = codeflash_output  # 1.26μs -> 621ns (103% faster)


# 5. Mutant-killer: Should not import StrawchemyField globally


def test_import_of_strawchemyfield_is_local():
    # The import should be inside the function (simulate by deleting from sys.modules)
    # Remove from sys.modules and call function to ensure it does not fail unless called
    sys.modules.pop("strawchemy.strawberry._field")
    # Re-insert for the function to work
    sys.modules["strawchemy.strawberry._field"] = strawchemy_strawberry_field_mod
    field = StrawchemyField(query_hook=QueryHook("test"))
    codeflash_output = StrawchemyRepository._get_field_hooks(field)
    result = codeflash_output  # 982ns -> 400ns (146% faster)


# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

# imports
from src.strawchemy.strawberry.repository._base import StrawchemyRepository


# Simulate the relevant classes and types for testing
class QueryHook:
    def __init__(self, name):
        self.name = name

    def __eq__(self, other):
        return isinstance(other, QueryHook) and self.name == other.name

    def __repr__(self):
        return f"QueryHook({self.name!r})"


class StrawberryField:
    """Base StrawberryField, does not have query_hook attribute."""

    def __init__(self, name):
        self.name = name


# Simulate StrawchemyField as a subclass of StrawberryField, with query_hook attribute
class StrawchemyField(StrawberryField):
    def __init__(self, name, query_hook=None):
        super().__init__(name)
        self.query_hook = query_hook


# --------------------------
# Unit tests for _get_field_hooks
# --------------------------

# 1. Basic Test Cases


def test_basic_none_for_non_strawchemyfield():
    """Should return None for plain StrawberryField (not StrawchemyField)."""
    field = StrawberryField(name="plain_field")
    codeflash_output = StrawchemyRepository._get_field_hooks(field)
    result = codeflash_output  # 1.10μs -> 481ns (129% faster)


def test_basic_single_hook():
    """Should return the single QueryHook for StrawchemyField."""
    hook = QueryHook("basic_hook")
    field = StrawchemyField(name="hook_field", query_hook=hook)
    codeflash_output = StrawchemyRepository._get_field_hooks(field)
    result = codeflash_output  # 1.32μs -> 591ns (124% faster)


def test_basic_sequence_of_hooks():
    """Should return a sequence of QueryHooks for StrawchemyField."""
    hooks = [QueryHook("hook1"), QueryHook("hook2")]
    field = StrawchemyField(name="multi_hook_field", query_hook=hooks)
    codeflash_output = StrawchemyRepository._get_field_hooks(field)
    result = codeflash_output  # 1.01μs -> 431ns (135% faster)


def test_basic_empty_sequence():
    """Should return an empty sequence if query_hook is an empty list."""
    hooks = []
    field = StrawchemyField(name="empty_hook_field", query_hook=hooks)
    codeflash_output = StrawchemyRepository._get_field_hooks(field)
    result = codeflash_output  # 1.05μs -> 430ns (145% faster)


def test_basic_none_query_hook():
    """Should return None if StrawchemyField has query_hook=None."""
    field = StrawchemyField(name="none_hook_field", query_hook=None)
    codeflash_output = StrawchemyRepository._get_field_hooks(field)
    result = codeflash_output  # 1.06μs -> 441ns (141% faster)


# 2. Edge Test Cases


def test_edge_query_hook_is_tuple():
    """Should return tuple if query_hook is a tuple of hooks."""
    hooks = (QueryHook("tuple1"), QueryHook("tuple2"))
    field = StrawchemyField(name="tuple_hook_field", query_hook=hooks)
    codeflash_output = StrawchemyRepository._get_field_hooks(field)
    result = codeflash_output  # 1.05μs -> 411ns (156% faster)


def test_edge_query_hook_is_str():
    """Should allow any type as query_hook, even a string."""
    field = StrawchemyField(name="str_hook_field", query_hook="not_a_hook")
    codeflash_output = StrawchemyRepository._get_field_hooks(field)
    result = codeflash_output  # 1.32μs -> 581ns (128% faster)


def test_edge_field_is_not_a_field():
    """Should return None for objects not inheriting StrawberryField."""

    class NotAField:
        pass

    codeflash_output = StrawchemyRepository._get_field_hooks(NotAField())
    result = codeflash_output  # 1.42μs -> 681ns (109% faster)


def test_edge_field_is_subclass_of_strawberryfield_but_not_strawchemyfield():
    """Should return None for subclasses of StrawberryField that are not StrawchemyField."""

    class CustomField(StrawberryField):
        pass

    field = CustomField(name="custom_field")
    codeflash_output = StrawchemyRepository._get_field_hooks(field)
    result = codeflash_output  # 1.49μs -> 741ns (101% faster)


def test_edge_field_is_strawchemyfield_with_query_hook_falsey():
    """Should return the falsey value if query_hook is set to False."""
    field = StrawchemyField(name="falsey_hook_field", query_hook=False)
    codeflash_output = StrawchemyRepository._get_field_hooks(field)
    result = codeflash_output  # 1.17μs -> 501ns (134% faster)


def test_edge_field_is_strawchemyfield_with_query_hook_zero():
    """Should return 0 if query_hook is set to 0."""
    field = StrawchemyField(name="zero_hook_field", query_hook=0)
    codeflash_output = StrawchemyRepository._get_field_hooks(field)
    result = codeflash_output  # 1.18μs -> 461ns (156% faster)


# 3. Large Scale Test Cases


def test_large_scale_many_hooks_in_list():
    """Should handle a large list of QueryHooks."""
    hooks = [QueryHook(f"hook_{i}") for i in range(1000)]
    field = StrawchemyField(name="large_hook_field", query_hook=hooks)
    codeflash_output = StrawchemyRepository._get_field_hooks(field)
    result = codeflash_output  # 1.13μs -> 441ns (157% faster)


def test_large_scale_many_hooks_in_tuple():
    """Should handle a large tuple of QueryHooks."""
    hooks = tuple(QueryHook(f"hook_{i}") for i in range(500))
    field = StrawchemyField(name="large_tuple_hook_field", query_hook=hooks)
    codeflash_output = StrawchemyRepository._get_field_hooks(field)
    result = codeflash_output  # 1.09μs -> 461ns (137% faster)


def test_large_scale_field_is_strawberryfield_among_many():
    """Should return None for StrawberryField among many StrawchemyFields."""
    fields = [StrawchemyField(name=f"field_{i}", query_hook=QueryHook(f"hook_{i}")) for i in range(999)]
    fields.append(StrawberryField(name="plain_field"))
    # Only the last field is plain StrawberryField
    codeflash_output = StrawchemyRepository._get_field_hooks(fields[-1])
    result = codeflash_output  # 1.31μs -> 601ns (118% faster)


def test_large_scale_all_fields_none_query_hook():
    """Should return None for StrawchemyFields with query_hook=None in bulk."""
    fields = [StrawchemyField(name=f"field_{i}", query_hook=None) for i in range(1000)]
    for field in fields:
        codeflash_output = StrawchemyRepository._get_field_hooks(field)
        result = codeflash_output  # 294μs -> 166μs (76.9% faster)


# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

To edit these changes git checkout codeflash/optimize-pr120-2025-12-12T20.30.38 and push.

[coderabbitai]

Important

Review skipped

Bot user detected.

To trigger a single review, invoke the @coderabbitai review command.

You can disable this status message by setting the reviews.review_status to false in the CodeRabbit configuration file.

Note

.coderabbit.yaml has unrecognized properties

CodeRabbit is using all valid settings from your configuration. Unrecognized properties (listed below) have been ignored and may indicate typos or deprecated fields that can be removed.

⚠️ Parsing warnings (1)

Validation error: Unrecognized key(s) in object: 'tools'

⚙️ Configuration instructions

• Please see the configuration documentation for more information.
• You can also validate your configuration using the online YAML validator.
• If your editor has YAML language server enabled, you can add the path at the top of this file to enable auto-completion and validation: # yaml-language-server: $schema=https://coderabbit.ai/integrations/schema.v2.json

---

_{Comment @coderabbitai help to get the list of available commands and usage tips.}

[codeflash-ai]

This PR has been automatically closed because the original PR #120 by renovate[bot] was closed.