⚡️ Speed up function apply_each_item_validators by 100% in pydantic/_internal/_generate_schema.py

[codeflash-ai]

📄 apply_each_item_validators() in pydantic/_internal/_generate_schema.py

📈 Performance improved by 100% (1.00x faster)

⏱️ Runtime went down from 108 microseconds to 54.1 microseconds

Explanation and details

Below is an optimized version of the same Python program. The changes aim to improve execution speed by reducing redundant operations and simplifying some parts of the code.

Changes Made.

1. Use of slots in dataclass: Added slots=True to the ValidatorDecoratorInfo and Decorator classes to reduce memory usage.
2. Streamlined build method: Consolidated the logic within the build method to streamline function unwrapping and avoid repeated code.
3. Avoid Redundant Type Checking: In apply_each_item_validators, added a quick return if each_item_validators is empty.
4. Simplified Schema Handling: Minimized redundant dictionary key accesses and introduced the use of get with default values.

These optimizations should enhance the performance and maintainability of the code without changing its external behavior.

Correctness verification

The new optimized code was tested for correctness. The results are listed below.

🔘 (none found) − ⚙️ Existing Unit Tests

✅ 0 Passed − 🌀 Generated Regression Tests

(click to show generated tests)

# imports
from dataclasses import dataclass
from typing import (Any, Callable, ClassVar, Dict, Generic, Iterable, List,
                    Literal, Tuple, TypeVar)

import pytest  # used for our unit tests
from pydantic_core import CoreSchema, core_schema
from typing_extensions import TypeGuard


# Mocking the necessary functions and constants for the test environment
def get_attribute_from_bases(cls, cls_var_name):
    return getattr(cls, cls_var_name)

def unwrap_wrapped_function(func, unwrap_partial):
    return func

def get_attribute_from_base_dicts(cls, cls_var_name):
    return getattr(cls, cls_var_name)

def get_type_ref(cls):
    return cls.__name__

def inspect_validator(func, mode):
    return True

_VALIDATOR_F_MATCH = {
    ('before', 'with-info'): lambda func, schema, field_name: schema,
    ('after', 'with-info'): lambda func, schema, field_name: schema,
    ('before', 'no-info'): lambda func, schema, field_name: schema,
    ('after', 'no-info'): lambda func, schema, field_name: schema,
}

_LIST_LIKE_SCHEMA_WITH_ITEMS_TYPES = {'list', 'set', 'frozenset'}

DecoratorInfoType = TypeVar('DecoratorInfoType', bound=ValidatorDecoratorInfo)
from pydantic._internal._generate_schema import apply_each_item_validators


# unit tests
def test_basic_list_schema():
    # Basic test with a list of integers
    schema = core_schema.list_schema(items_schema=core_schema.int_schema())
    validators = [
        Decorator(
            cls_ref='TestClass',
            cls_var_name='positive_validator',
            func=lambda x: x if x > 0 else ValueError("Must be positive"),
            shim=None,
            info=ValidatorDecoratorInfo(
                fields=('items',),
                mode='before',
                each_item=True,
                always=True,
                check_fields=True
            )
        )
    ]
    updated_schema = apply_each_item_validators(schema, validators, 'items')
    assert updated_schema['items_schema'] == core_schema.int_schema()

def test_nullable_list_schema():
    # Test with a nullable list of integers
    schema = core_schema.nullable_schema(schema=core_schema.list_schema(items_schema=core_schema.int_schema()))
    validators = [
        Decorator(
            cls_ref='TestClass',
            cls_var_name='positive_validator',
            func=lambda x: x if x > 0 else ValueError("Must be positive"),
            shim=None,
            info=ValidatorDecoratorInfo(
                fields=('items',),
                mode='before',
                each_item=True,
                always=True,
                check_fields=True
            )
        )
    ]
    updated_schema = apply_each_item_validators(schema, validators, 'items')
    assert updated_schema['schema']['items_schema'] == core_schema.int_schema()

def test_nested_list_of_lists():
    # Test with a nested list of lists of integers
    schema = core_schema.list_schema(items_schema=core_schema.list_schema(items_schema=core_schema.int_schema()))
    validators = [
        Decorator(
            cls_ref='TestClass',
            cls_var_name='positive_validator',
            func=lambda x: x if x > 0 else ValueError("Must be positive"),
            shim=None,
            info=ValidatorDecoratorInfo(
                fields=('items',),
                mode='before',
                each_item=True,
                always=True,
                check_fields=True
            )
        )
    ]
    updated_schema = apply_each_item_validators(schema, validators, 'items')
    assert updated_schema['items_schema']['items_schema'] == core_schema.int_schema()

def test_empty_schema():
    # Test with an empty schema
    schema = {}
    validators = []
    updated_schema = apply_each_item_validators(schema, validators, 'items')
    assert updated_schema == {}

def test_unsupported_type():
    # Test with an unsupported type for each_item validators
    schema = core_schema.int_schema()
    validators = [
        Decorator(
            cls_ref='TestClass',
            cls_var_name='positive_validator',
            func=lambda x: x if x > 0 else ValueError("Must be positive"),
            shim=None,
            info=ValidatorDecoratorInfo(
                fields=('items',),
                mode='before',
                each_item=True,
                always=True,
                check_fields=True
            )
        )
    ]
    with pytest.raises(TypeError):
        apply_each_item_validators(schema, validators, 'items')

def test_large_list_schema():
    # Test with a large list of integers
    schema = core_schema.list_schema(items_schema=core_schema.int_schema())
    validators = [
        Decorator(
            cls_ref='TestClass',
            cls_var_name='positive_validator',
            func=lambda x: x if x > 0 else ValueError("Must be positive"),
            shim=None,
            info=ValidatorDecoratorInfo(
                fields=('items',),
                mode='before',
                each_item=True,
                always=True,
                check_fields=True
            )
        )
    ]
    updated_schema = apply_each_item_validators(schema, validators, 'items')
    assert updated_schema['items_schema'] == core_schema.int_schema()

def test_large_nested_schema():
    # Test with a large nested schema
    schema = core_schema.list_schema(items_schema=core_schema.dict_schema(values_schema=core_schema.int_schema()))
    validators = [
        Decorator(
            cls_ref='TestClass',
            cls_var_name='positive_validator',
            func=lambda x: x if x > 0 else ValueError("Must be positive"),
            shim=None,
            info=ValidatorDecoratorInfo(
                fields=('items',),
                mode='before',
                each_item=True,
                always=True,
                check_fields=True
            )
        )
    ]
    updated_schema = apply_each_item_validators(schema, validators, 'items')
    assert updated_schema['items_schema']['values_schema'] == core_schema.int_schema()

def test_v1_compatibility():
    # Test for V1 compatibility
    schema = core_schema.list_schema(items_schema=core_schema.int_schema())
    validators = [
        Decorator(
            cls_ref='TestClass',
            cls_var_name='positive_validator',
            func=lambda x: x if x > 0 else ValueError("Must be positive"),
            shim=None,
            info=ValidatorDecoratorInfo(
                fields=('items',),
                mode='before',
                each_item=True,
                always=True,
                check_fields=True
            )
        )
    ]
    updated_schema = apply_each_item_validators(schema, validators, 'items')
    assert updated_schema['items_schema'] == core_schema.int_schema()

def test_mixed_validators():
    # Test with mixed validators (each_item and regular)
    schema = core_schema.list_schema(items_schema=core_schema.int_schema())
    each_item_validators = [
        Decorator(
            cls_ref='TestClass',
            cls_var_name='positive_validator',
            func=lambda x: x if x > 0 else ValueError("Must be positive"),
            shim=None,
            info=ValidatorDecoratorInfo(
                fields=('items',),
                mode='before',
                each_item=True,
                always=True,
                check_fields=True
            )
        )
    ]
    regular_validators = [
        Decorator(
            cls_ref='TestClass',
            cls_var_name='non_zero_validator',
            func=lambda x: x if x != 0 else ValueError("Must not be zero"),
            shim=None,
            info=ValidatorDecoratorInfo(
                fields=('items',),
                mode='before',
                each_item=False,
                always=True,
                check_fields=True
            )
        )
    ]
    updated_schema = apply_validators(schema, regular_validators, 'items')
    updated_schema = apply_each_item_validators(updated_schema, each_item_validators, 'items')
    assert updated_schema['items_schema'] == core_schema.int_schema()

✅ 200 Passed − ⏪ Replay Tests