⚡️ Speed up method GenerateSchema._union_is_subclass_schema by 7%

[codeflash-ai]

📄 7% (0.07x) speedup for GenerateSchema._union_is_subclass_schema in pydantic/_internal/_generate_schema.py

⏱️ Runtime : 39.8 microseconds → 37.4 microseconds (best of 565 runs)

📝 Explanation and details

To optimize the given Python program, we can consider improving both the structure and efficiency of the code for faster execution. Here's a revised version of your Python program that incorporates some performance improvements.

1. Inlining and minimizing temporary variables: Avoid unnecessary variables where possible to reduce memory overhead.
2. Early returns: Helps in reducing the complexity and improves readability.
3. Functional decomposition: Breaking down complex functions into simpler, smaller functions can help the compiler optimize the execution.

Key Changes.

1. Method Splitting: Introduced the _finalize_schema method to handle final schema modifications for better readability and to limit the responsibility scope of generate_schema.
2. Early Returns: Optimize the flow by returning immediately when the result is clear.
3. Documented the main functionalities for quicker understanding.
4. Efficient conditional checks: Combined some conditionals to reduce complexity.

By following these practices, the revised version of the program should have reduced memory overhead and improved performance.

✅ Correctness verification report:

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

🌀 Generated Regression Tests Details

import typing
from typing import Any, Dict, List, Set, Tuple, Type, Union, overload

# imports
import pytest  # used for our unit tests
from pydantic._internal._config import ConfigWrapper, ConfigWrapperStack
from pydantic._internal._generate_schema import GenerateSchema
from pydantic_core import CoreSchema, core_schema
from typing_extensions import Literal

# unit tests

# Mock dependencies
class MockConfigWrapper:
    json_encoders = {}

class MockCoreSchema:
    pass

class MockGenerateSchema(GenerateSchema):
    def _get_args_resolving_forward_refs(self, obj: Any, required: Literal[True]) -> tuple[Any, ...]:
        if obj == Union[int, str]:
            return (int, str)
        elif obj == Union[Union[int, str], float]:
            return (Union[int, str], float)
        elif obj == Union['A', 'B']:
            return ('A', 'B')
        elif obj == Union[List[int], Dict[str, float]]:
            return (List[int], Dict[str, float])
        elif obj == Union[None, int]:
            return (None, int)
        elif obj == Union[int, 'invalid_type']:
            return (int, 'invalid_type')
        elif obj == Union[int, str, float, bool, None, complex, bytes, bytearray, memoryview, list, tuple, set, frozenset, dict, range]:
            return (int, str, float, bool, None, complex, bytes, bytearray, memoryview, list, tuple, set, frozenset, dict, range)
        return ()

    def generate_schema(self, obj: Any, from_dunder_get_core_schema: bool = True) -> core_schema.CoreSchema:
        return MockCoreSchema()

# Test cases
@pytest.fixture
def schema_generator():
    return MockGenerateSchema(MockConfigWrapper(), None)

def test_single_type_in_union(schema_generator):
    codeflash_output = schema_generator._union_is_subclass_schema(Union[int])

def test_multiple_types_in_union(schema_generator):
    codeflash_output = schema_generator._union_is_subclass_schema(Union[int, str])

def test_nested_unions(schema_generator):
    codeflash_output = schema_generator._union_is_subclass_schema(Union[Union[int, str], float])

def test_forward_references(schema_generator):
    codeflash_output = schema_generator._union_is_subclass_schema(Union['A', 'B'])

def test_complex_types(schema_generator):
    codeflash_output = schema_generator._union_is_subclass_schema(Union[List[int], Dict[str, float]])

def test_union_with_none_type(schema_generator):
    codeflash_output = schema_generator._union_is_subclass_schema(Union[None, int])

def test_large_number_of_types_in_union(schema_generator):
    codeflash_output = schema_generator._union_is_subclass_schema(Union[int, str, float, bool, None, complex, bytes, bytearray, memoryview, list, tuple, set, frozenset, dict, range])

📢 Feedback on this optimization?