from typing import Any, Dict

# imports
import pytest  # used for our unit tests
from guardrails.classes.schema.model_schema import ModelSchema


class DummyBase:
    """A dummy base class to simulate the parent to_dict behavior."""
    def __init__(self, data):
        self._data = data

    def to_dict(self):
        # Simulate pydantic's behavior: returns all keys, including those with None
        return dict(self._data)
from guardrails.classes.schema.model_schema import ModelSchema

# ------------------- UNIT TESTS -------------------

# 1. BASIC TEST CASES
















#------------------------------------------------
from typing import Any, Dict

# imports
import pytest
from guardrails.classes.schema.model_schema import ModelSchema


# function to test
# Simulate the parent class and the ModelSchema class as described.
class IModelSchema:
    def __init__(self, **kwargs):
        # Store all fields as attributes
        for k, v in kwargs.items():
            setattr(self, k, v)
        self._fields = kwargs.keys()
    def to_dict(self) -> Dict[str, Any]:
        # Return all fields as a dict, including those with value None
        return {k: getattr(self, k, None) for k in self._fields}
from guardrails.classes.schema.model_schema import ModelSchema

# unit tests

# 1. Basic Test Cases

def test_to_dict_basic_all_fields_present():
    # Test with all fields having non-None values
    ms = ModelSchema(a=1, b="hello", c=True)
    codeflash_output = ms.to_dict(); result = codeflash_output # 11.6μs -> 10.8μs (7.53% faster)

def test_to_dict_some_fields_none():
    # Test with some fields set to None
    ms = ModelSchema(a=1, b=None, c="test")
    codeflash_output = ms.to_dict(); result = codeflash_output # 10.3μs -> 9.62μs (6.84% faster)

def test_to_dict_all_fields_none():
    # Test with all fields set to None
    ms = ModelSchema(a=None, b=None)
    codeflash_output = ms.to_dict(); result = codeflash_output # 10.3μs -> 9.62μs (6.67% faster)

def test_to_dict_empty_schema():
    # Test with no fields at all
    ms = ModelSchema()
    codeflash_output = ms.to_dict(); result = codeflash_output # 10.2μs -> 9.84μs (3.68% faster)

def test_to_dict_mixed_types():
    # Test with various types including int, str, bool, float, list, dict
    ms = ModelSchema(a=0, b="", c=False, d=3.14, e=[1,2], f={'x': 10})
    expected = {'a': 0, 'b': "", 'c': False, 'd': 3.14, 'e': [1,2], 'f': {'x': 10}}
    codeflash_output = ms.to_dict(); result = codeflash_output # 10.3μs -> 9.85μs (4.82% faster)

# 2. Edge Test Cases

def test_to_dict_field_with_empty_string_and_zero():
    # Empty string and zero are not None, so they should be included
    ms = ModelSchema(a="", b=0, c=None)
    codeflash_output = ms.to_dict(); result = codeflash_output # 9.98μs -> 9.71μs (2.76% faster)

def test_to_dict_field_with_false_and_empty_list():
    # False and empty list are not None, so they should be included
    ms = ModelSchema(a=False, b=[], c=None)
    codeflash_output = ms.to_dict(); result = codeflash_output # 10.2μs -> 9.51μs (7.55% faster)

def test_to_dict_field_with_empty_dict():
    # Empty dict is not None, so it should be included
    ms = ModelSchema(a={}, b=None)
    codeflash_output = ms.to_dict(); result = codeflash_output # 10.4μs -> 9.69μs (7.83% faster)

def test_to_dict_nested_none_values():
    # Nested dicts/lists containing None should not be filtered at inner levels
    ms = ModelSchema(a={'x': None, 'y': 2}, b=[None, 1, 2])
    codeflash_output = ms.to_dict(); result = codeflash_output # 10.4μs -> 9.62μs (7.70% faster)

def test_to_dict_fields_with_special_types():
    # Test with special types like objects, functions, etc.
    class Dummy: pass
    def foo(): return 42
    ms = ModelSchema(a=Dummy, b=foo, c=None)
    codeflash_output = ms.to_dict(); result = codeflash_output # 10.4μs -> 9.70μs (6.74% faster)

def test_to_dict_field_names_with_none_value():
    # Field name is 'None' (as a string), value is not None
    ms = ModelSchema(**{'None': 123, 'b': None})
    codeflash_output = ms.to_dict(); result = codeflash_output # 10.4μs -> 9.75μs (6.65% faster)

# 3. Large Scale Test Cases

def test_to_dict_many_fields_all_non_none():
    # Test with 1000 fields, all non-None
    data = {f'field_{i}': i for i in range(1000)}
    ms = ModelSchema(**data)
    codeflash_output = ms.to_dict(); result = codeflash_output # 10.6μs -> 9.70μs (9.20% faster)

def test_to_dict_many_fields_some_none():
    # Test with 1000 fields, every 10th is None
    data = {f'field_{i}': (None if i % 10 == 0 else i) for i in range(1000)}
    ms = ModelSchema(**data)
    expected = {k: v for k, v in data.items() if v is not None}
    codeflash_output = ms.to_dict(); result = codeflash_output # 10.2μs -> 9.74μs (4.27% faster)

def test_to_dict_large_nested_structures():
    # Test with large nested structures (dicts/lists containing None)
    nested_dict = {f'k{i}': (None if i % 2 == 0 else i) for i in range(100)}
    nested_list = [None if i % 2 == 0 else i for i in range(100)]
    ms = ModelSchema(a=nested_dict, b=nested_list, c=None)
    # Only top-level 'c' should be omitted
    codeflash_output = ms.to_dict(); result = codeflash_output # 10.3μs -> 9.74μs (5.94% faster)

def test_to_dict_performance_on_large_input():
    # This test checks that the function completes in reasonable time for large input
    import time
    data = {f'field_{i}': (i if i % 3 else None) for i in range(1000)}
    ms = ModelSchema(**data)
    start = time.time()
    codeflash_output = ms.to_dict(); result = codeflash_output # 10.5μs -> 9.83μs (6.81% faster)
    duration = time.time() - start
    # Also check correctness
    expected = {k: v for k, v in data.items() if v is not None}
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.