fromtypingimportAny,Dict# importsimportpytest# used for our unit testsfromguardrails.classes.schema.model_schemaimportModelSchemaclassDummyBase:"""A dummy base class to simulate the parent to_dict behavior."""def__init__(self,data):self._data=datadefto_dict(self):# Simulate pydantic's behavior: returns all keys, including those with Nonereturndict(self._data)fromguardrails.classes.schema.model_schemaimportModelSchema# ------------------- UNIT TESTS -------------------# 1. BASIC TEST CASES#------------------------------------------------fromtypingimportAny,Dict# importsimportpytestfromguardrails.classes.schema.model_schemaimportModelSchema# function to test# Simulate the parent class and the ModelSchema class as described.classIModelSchema:def__init__(self,**kwargs):# Store all fields as attributesfork,vinkwargs.items():setattr(self,k,v)self._fields=kwargs.keys()defto_dict(self)->Dict[str,Any]:# Return all fields as a dict, including those with value Nonereturn {k:getattr(self,k,None)forkinself._fields}fromguardrails.classes.schema.model_schemaimportModelSchema# unit tests# 1. Basic Test Casesdeftest_to_dict_basic_all_fields_present():# Test with all fields having non-None valuesms=ModelSchema(a=1,b="hello",c=True)codeflash_output=ms.to_dict();result=codeflash_output# 11.6μs -> 10.8μs (7.53% faster)deftest_to_dict_some_fields_none():# Test with some fields set to Nonems=ModelSchema(a=1,b=None,c="test")codeflash_output=ms.to_dict();result=codeflash_output# 10.3μs -> 9.62μs (6.84% faster)deftest_to_dict_all_fields_none():# Test with all fields set to Nonems=ModelSchema(a=None,b=None)codeflash_output=ms.to_dict();result=codeflash_output# 10.3μs -> 9.62μs (6.67% faster)deftest_to_dict_empty_schema():# Test with no fields at allms=ModelSchema()codeflash_output=ms.to_dict();result=codeflash_output# 10.2μs -> 9.84μs (3.68% faster)deftest_to_dict_mixed_types():# Test with various types including int, str, bool, float, list, dictms=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 Casesdeftest_to_dict_field_with_empty_string_and_zero():# Empty string and zero are not None, so they should be includedms=ModelSchema(a="",b=0,c=None)codeflash_output=ms.to_dict();result=codeflash_output# 9.98μs -> 9.71μs (2.76% faster)deftest_to_dict_field_with_false_and_empty_list():# False and empty list are not None, so they should be includedms=ModelSchema(a=False,b=[],c=None)codeflash_output=ms.to_dict();result=codeflash_output# 10.2μs -> 9.51μs (7.55% faster)deftest_to_dict_field_with_empty_dict():# Empty dict is not None, so it should be includedms=ModelSchema(a={},b=None)codeflash_output=ms.to_dict();result=codeflash_output# 10.4μs -> 9.69μs (7.83% faster)deftest_to_dict_nested_none_values():# Nested dicts/lists containing None should not be filtered at inner levelsms=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)deftest_to_dict_fields_with_special_types():# Test with special types like objects, functions, etc.classDummy:passdeffoo():return42ms=ModelSchema(a=Dummy,b=foo,c=None)codeflash_output=ms.to_dict();result=codeflash_output# 10.4μs -> 9.70μs (6.74% faster)deftest_to_dict_field_names_with_none_value():# Field name is 'None' (as a string), value is not Nonems=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 Casesdeftest_to_dict_many_fields_all_non_none():# Test with 1000 fields, all non-Nonedata= {f'field_{i}':iforiinrange(1000)}ms=ModelSchema(**data)codeflash_output=ms.to_dict();result=codeflash_output# 10.6μs -> 9.70μs (9.20% faster)deftest_to_dict_many_fields_some_none():# Test with 1000 fields, every 10th is Nonedata= {f'field_{i}': (Noneifi%10==0elsei)foriinrange(1000)}ms=ModelSchema(**data)expected= {k:vfork,vindata.items()ifvisnotNone}codeflash_output=ms.to_dict();result=codeflash_output# 10.2μs -> 9.74μs (4.27% faster)deftest_to_dict_large_nested_structures():# Test with large nested structures (dicts/lists containing None)nested_dict= {f'k{i}': (Noneifi%2==0elsei)foriinrange(100)}nested_list= [Noneifi%2==0elseiforiinrange(100)]ms=ModelSchema(a=nested_dict,b=nested_list,c=None)# Only top-level 'c' should be omittedcodeflash_output=ms.to_dict();result=codeflash_output# 10.3μs -> 9.74μs (5.94% faster)deftest_to_dict_performance_on_large_input():# This test checks that the function completes in reasonable time for large inputimporttimedata= {f'field_{i}': (iifi%3elseNone)foriinrange(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 correctnessexpected= {k:vfork,vindata.items()ifvisnotNone}# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.