stac-utils__stac-fastapi-729

cd /stac-fastapi && python -c "
from stac_fastapi.api.models import create_get_request_model
from stac_fastapi.extensions.core import FieldsExtension
from stac_fastapi.types.search import BaseSearchGetRequest
import json

# Let's see what create_request_model does
from stac_fastapi.api.models import create_request_model

model = create_request_model(
    'SearchGetRequest',
    base_model=BaseSearchGetRequest,
    extensions=[FieldsExtension()],
    request_type='GET',
)

print('Model type:', type(model))
print('Model MRO:', [c.__name__ for c in model.__mro__])

# Try creating an instance
try:
    m = model(datetime='yo', collections='test1,test2')
    print('Created instance - datetime:', m.datetime, 'collections:', m.collections)
except Exception as e:
    print('Error:', type(e).__name__, e)
"

cd /stac-fastapi && python -c "
from stac_fastapi.api.models import create_request_model
from stac_fastapi.extensions.core import FieldsExtension
from stac_fastapi.types.search import BaseSearchGetRequest

model = create_request_model(
    'SearchGetRequest',
    base_model=BaseSearchGetRequest,
    extensions=[FieldsExtension()],
    request_type='GET',
)

print('Model type:', type(model))
print('Model MRO:', [c.__name__ for c in model.__mro__])
print('Has __post_init__:', hasattr(model, '__post_init__'))
if hasattr(model, '__post_init__'):
    import inspect
    print('__post_init__ source:', inspect.getsource(model.__post_init__))
"

cd /stac-fastapi && python -c "
from stac_fastapi.api.models import create_request_model
from stac_fastapi.extensions.core import FieldsExtension
from stac_fastapi.types.search import BaseSearchGetRequest

model = create_request_model(
    'SearchGetRequest',
    base_model=BaseSearchGetRequest,
    extensions=[FieldsExtension()],
    request_type='GET',
)

# Check if __post_init__ is called automatically
m = model(datetime='yo', collections='test1,test2')
print('datetime:', m.datetime)
print('collections:', m.collections)
"

cd /stac-fastapi && python -c "
from dataclasses import make_dataclass, dataclass
from stac_fastapi.types.search import BaseSearchGetRequest
import inspect

# Create a model with BaseSearchGetRequest having __post_init__
Model = make_dataclass('TestModel', [], bases=(BaseSearchGetRequest,))

# Check which __post_init__ is called
import dataclasses
# Let's manually call __post_init__ and see what happens
m = Model(collections='test1,test2', datetime='2020-01-01T00:00:00Z')
print('collections:', m.collections)
print('datetime:', m.datetime)
"

cd /stac-fastapi && python -c "
from dataclasses import make_dataclass, dataclass
from stac_fastapi.types.search import BaseSearchGetRequest

# Create model with BaseSearchGetRequest
Model = make_dataclass('TestModel', [], bases=(BaseSearchGetRequest,))

# Lets manually check if __post_init__ from base is called
# by adding our own __post_init__
@dataclass
class DebugModel:
    def __post_init__(self):
        print('DebugModel.__post_init__ called')
        super().__post_init__() if hasattr(super(), '__post_init__') else None

# Actually let's just trace what happens
m = Model(datetime='2020-01-01T00:00:00Z', collections='test1,test2')
print('Success - datetime converted:', m.datetime)
"

cd /stac-fastapi && python -c "
from stac_fastapi.api.models import create_request_model
from stac_fastapi.extensions.core import FieldsExtension
from stac_fastapi.types.search import BaseSearchGetRequest

model = create_request_model(
    'SearchGetRequest',
    base_model=BaseSearchGetRequest,
    extensions=[FieldsExtension()],
    request_type='GET',
)

print('MRO:', [c.__name__ for c in model.__mro__])
print()
# Check each class for __post_init__
for cls in model.__mro__:
    if '__post_init__' in cls.__dict__:
        print(f'{cls.__name__} has __post_init__: {cls.__dict__[\"__post_init__\"]}')
"

cd /stac-fastapi && python -c "
# Let's test if we can manually call __post_init__ from all bases
from dataclasses import make_dataclass
from stac_fastapi.types.search import BaseSearchGetRequest

# Create a model
Model = make_dataclass('TestModel', [], bases=(BaseSearchGetRequest,))

# Now let's manually call __post_init__ from the base
m = Model(datetime='2020-01-01T00:00:00Z', collections='test1,test2')
print('Before manual call - datetime:', m.datetime)

# Manually call BaseSearchGetRequest.__post_init__
BaseSearchGetRequest.__post_init__(m)
print('After manual call - datetime:', m.datetime)
"

cd /stac-fastapi && python -c "
from dataclasses import make_dataclass, dataclass, fields, Field
from stac_fastapi.types.search import BaseSearchGetRequest
from stac_fastapi.extensions.core import FieldsExtension
import inspect

# Simulate what create_request_model does
base_model = BaseSearchGetRequest
extensions = [FieldsExtension()]

# Get extension models
extension_models = []
for extension in extensions:
    if extension_model := extension.get_request_model('GET'):
        extension_models.append(extension_model)

models = extension_models + [base_model]
print('Models:', [m.__name__ for m in models])

# Check if all are APIRequest subclasses
from stac_fastapi.types.extension import ApiExtension
print('All APIRequest subclasses:', all(issubclass(m, ApiExtension) for m in models))

# Create dataclass
Model = make_dataclass('SearchGetRequest', [], bases=tuple(models))
print('Model created:', Model)

# Get all __post_init__ methods from MRO
post_init_methods = []
for cls in Model.__mro__:
    if '__post_init__' in cls.__dict__ and cls.__dict__['__post_init__'] is not object.__dict__['__post_init__']:
        post_init_methods.append(cls.__dict__['__post_init__'])

print('__post_init__ methods to call:', [m.__name__ for m in post_init_methods])

# Create a new __post_init__ that calls all base __post_init__
def make_post_init(mro_classes):
    def __post_init__(self):
        for cls in mro_classes:
            if '__post_init__' in cls.__dict__:
                cls.__post_init__(self)
    return __post_init__

Model.__post_init__ = make_post_init(Model.__mro__)

# Now test
m = Model(datetime='2020-01-01T00:00:00Z', collections='test1,test2')
print('After creation - datetime:', m.datetime)
print('After creation - collections:', m.collections)
"

cd /stac-fastapi && python -c "
from dataclasses import make_dataclass, dataclass
from stac_fastapi.types.search import BaseSearchGetRequest
from stac_fastapi.extensions.core import FieldsExtension

# Simulate what create_request_model does
base_model = BaseSearchGetRequest
extensions = [FieldsExtension()]

# Get extension models - let's just use the base for now
models = [base_model]

# Create dataclass
Model = make_dataclass('SearchGetRequest', [], bases=tuple(models))
print('Model created:', Model)

# Get all __post_init__ methods from MRO
post_init_methods = []
for cls in Model.__mro__:
    if '__post_init__' in cls.__dict__:
        post_init_methods.append(cls)

print('Classes with __post_init__ in MRO:', [c.__name__ for c in post_init_methods])

# Create a new __post_init__ that calls all base __post_init__
def make_post_init(mro):
    def __post_init__(self):
        for cls in mro:
            if '__post_init__' in cls.__dict__:
                # Get the original __post_init__ from that class
                original = cls.__dict__['__post_init__']
                original(self)
    return __post_init__

Model.__post_init__ = make_post_init(Model.__mro__)

# Now test
m = Model(datetime='2020-01-01T00:00:00Z', collections='test1,test2')
print('After creation - datetime:', m.datetime)
print('After creation - collections:', m.collections)
"

cd /stac-fastapi && python -c "
from dataclasses import make_dataclass, dataclass, fields
import inspect

# Simple test
class Base:
    def __post_init__(self):
        print('Base.__post_init__ called')

class Derived(Base):
    def __post_init__(self):
        print('Derived.__post_init__ called')
        super().__post_init__()

@dataclass
class DCBase:
    x: int = 0
    def __post_init__(self):
        print('DCBase.__post_init__ called')
        super().__post_init__()

@dataclass
class DCDerived(DCBase):
    y: int = 0
    def __post_init__(self):
        print('DCDerived.__post_init__ called')
        super().__post_init__

d = DCDerived(x=1, y=2)
print('Done')
"

cd /stac-fastapi && python -c "
from dataclasses import make_dataclass, dataclass
from stac_fastapi.types.search import BaseSearchGetRequest

# make_dataclass test
Model = make_dataclass('TestModel', [], bases=(BaseSearchGetRequest,))

# Check if __post_init__ is inherited
print('__post_init__ in Model.__dict__:', '__post_init__' in Model.__dict__)
print('__post_init__ in BaseSearchGetRequest.__dict__:', '__post_init__' in BaseSearchGetRequest.__dict__)

# Try calling on instance
m = Model(datetime='2020-01-01T00:00:00Z', collections='test1,test2')
print('datetime:', m.datetime)
print('collections:', m.collections)
"

cd /stac-fastapi && python -c "
import dataclasses
import inspect
print(inspect.getsource(dataclasses.make_dataclass))
"

cd /stac-fastapi && python -c "
import dataclasses
import inspect
print(inspect.getsource(dataclasses.dataclass))
" 2>&1 | head -100

cd /stac-fastapi && python -c "
import dataclasses
import inspect
# Get _process_class source
print(inspect.getsource(dataclasses._process_class))
"

cd /stac-fastapi && python -c "
import dataclasses
import inspect
# Find _set_new_attribute and _init_fn
print('=== _set_new_attribute ===')
print(inspect.getsource(dataclasses._set_new_attribute))
print('=== _init_fn ===')
print(inspect.getsource(dataclasses._init_fn))
"

cd /stac-fastapi && python -c "
from dataclasses import make_dataclass
from stac_fastapi.types.search import BaseSearchGetRequest
from stac_fastapi.extensions.core import FieldsExtension

# With just base model
model1 = make_dataclass('Test1', [], bases=(BaseSearchGetRequest,))
print('Just base model:')
print('  has_post_init:', hasattr(model1, '_POST_INIT_NAME') if hasattr(model1, '_POST_INIT_NAME') else 'checking...')
print('  __post_init__ in __dict__:', '__post_init__' in model1.__dict__)
print('  hasattr __post_init__:', hasattr(model1, '__post_init__'))

# With extensions
model2 = make_dataclass('Test2', [], bases=(FieldsExtension(), BaseSearchGetRequest))
print('With extensions:')
print('  has_post_init:', hasattr(model2, '_POST_INIT_NAME') if hasattr(model2, '_POST_INIT_NAME') else 'checking...')
print('  __post_init__ in __dict__:', '__post_init__' in model2.__dict__)
print('  hasattr __post_init__:', hasattr(model2, '__post_init__'))
"

cd /stac-fastapi && python -c "
from stac_fastapi.extensions.core import FieldsExtension
from stac_fastapi.types.search import BaseSearchGetRequest

print('FieldsExtension metaclass:', type(FieldsExtension))
print('BaseSearchGetRequest metaclass:', type(BaseSearchGetRequest))
print('FieldsExtension().__class__:', FieldsExtension().__class__)
print('BaseSearchGetRequest().__class__:', BaseSearchGetRequest().__class__)
"

cd /stac-fastapi && python -c "
from dataclasses import make_dataclass
from stac_fastapi.types.search import BaseSearchGetRequest
from stac_fastapi.extensions.core import FieldsExtension

# With just base model
model1 = make_dataclass('Test1', [], bases=(BaseSearchGetRequest,))
print('Just base model:')
print('  __post_init__ in __dict__:', '__post_init__' in model1.__dict__)
print('  hasattr __post_init__:', hasattr(model1, '__post_init__'))

# Try creating instance
try:
    m1 = model1(datetime='2020-01-01T00:00:00Z', collections='test1,test2')
    print('  datetime:', m1.datetime)
    print('  collections:', m1.collections)
except Exception as e:
    print('  Error:', e)

# With extensions - need to handle metaclass
try:
    model2 = make_dataclass('Test2', [], bases=(FieldsExtension, BaseSearchGetRequest))
    print('\\nWith extensions:')
    print('  __post_init__ in __dict__:', '__post_init__' in model2.__dict__)
    print('  hasattr __post_init__:', hasattr(model2, '__post_init__'))
    
    # Try creating instance
    m2 = model2(datetime='2020-01-01T00:00:00Z', collections='test1,test2')
    print('  datetime:', m2.datetime)
    print('  collections:', m2.collections)
except Exception as e:
    print('  Error:', type(e).__name__, e)
"

cd /stac-fastapi && python -c "
from stac_fastapi.api.models import create_get_request_model
from stac_fastapi.extensions.core import FieldsExtension

# Test with extensions
model = create_get_request_model(extensions=[FieldsExtension()])
print('Model type:', type(model))
print('Model MRO:', [c.__name__ for c in model.__mro__])

# Try creating instance with valid datetime
try:
    m = model(datetime='2020-01-01T00:00:00Z', collections='test1,test2')
    print('Valid datetime - datetime:', m.datetime)
except Exception as e:
    print('Valid datetime Error:', type(e).__name__, e)

# Try creating instance with invalid datetime
try:
    m = model(datetime='yo', collections='test1,test2')
    print('Invalid datetime - datetime:', m.datetime, '(should have raised error!)')
except Exception as e:
    print('Invalid datetime - Error:', type(e).__name__, e)
"

cd /stac-fastapi && python -c "
from stac_fastapi.api.models import create_request_model
from stac_fastapi.extensions.core import FieldsExtension
from stac_fastapi.types.search import BaseSearchGetRequest

model = create_request_model(
    'SearchGetRequest',
    base_model=BaseSearchGetRequest,
    extensions=[FieldsExtension()],
    request_type='GET',
)

print('Model type:', type(model))
print('Model MRO:', [c.__name__ for c in model.__mro__])
print()
print('Classes with __post_init__ in MRO:')
for cls in model.__mro__:
    if '__post_init__' in cls.__dict__:
        print(f'  {cls.__name__}: {cls.__dict__[\"__post_init__\"]}')

# Try creating instance
m = model(datetime='2020-01-01T00:00:00Z', collections='test1,test2')
print('\\ndatetime:', m.datetime)
print('collections:', m.collections)
"

cd /stac-fastapi && head -60 stac_fastapi/api/stac_fastapi/api/models.py

cd /stac-fastapi && sed -n '28,50p' stac_fastapi/api/stac_fastapi/api/models.py

cat /stac-fastapi/stac_fastapi/api/stac_fastapi/api/models.py

ls -la /stac-fastapi/stac_fastapi/api/stac_fastapi/api/models.py

/opt/receipts-45b347ae0b974b75be77d2ed8200518d/bin/busybox sh -c 'mkdir -p /stac-fastapi/stac_fastapi/api/stac_fastapi/api && cp /opt/receipts-45b347ae0b974b75be77d2ed8200518d/incoming/3e349222771fc9aa6e3219bef39667aaa6390810740f0dd88ca6f690bfc06fee /stac-fastapi/stac_fastapi/api/stac_fastapi/api/models.py'

cd /stac-fastapi && python -c "
from stac_fastapi.api.models import create_get_request_model
from stac_fastapi.extensions.core import FieldsExtension

# Test with extensions
model = create_get_request_model(extensions=[FieldsExtension()])
print('Test 1: With extensions, valid datetime')
try:
    m = model(datetime='2020-01-01T00:00:00Z', collections='test1,test2')
    print('  SUCCESS - datetime:', m.datetime, 'collections:', m.collections)
except Exception as e:
    print('  FAILED -', type(e).__name__, e)

print('Test 2: With extensions, invalid datetime')
try:
    m = model(datetime='yo', collections='test1,test2')
    print('  FAILED - should have raised error, datetime:', m.datetime)
except Exception as e:
    print('  SUCCESS - raised', type(e).__name__, e)

# Test without extensions
model2 = create_get_request_model(extensions=[])
print('Test 3: Without extensions, valid datetime')
try:
    m = model2(datetime='2020-01-01T00:00:00Z', collections='test1,test2')
    print('  SUCCESS - datetime:', m.datetime, 'collections:', m.collections)
except Exception as e:
    print('  FAILED -', type(e).__name__, e)

print('Test 4: Without extensions, invalid datetime')
try:
    m = model2(datetime='yo', collections='test1,test2')
    print('  FAILED - should have raised error, datetime:', m.datetime)
except Exception as e:
    print('  SUCCESS - raised', type(e).__name__, e)
"

cd /stac-fastapi && python -c "
from dataclasses import make_dataclass
from stac_fastapi.types.search import BaseSearchGetRequest

# Just base model - works
Model = make_dataclass('Test1', [], bases=(BaseSearchGetRequest,))
m = Model(datetime='2020-01-01T00:00:00Z', collections='test1,test2')
print('Just base - datetime:', m.datetime, 'collections:', m.collections)
"

cd /stac-fastapi && python -c "
from stac_fastapi.api.models import create_request_model
from stac_fastapi.extensions.core import FieldsExtension
from stac_fastapi.types.search import BaseSearchGetRequest

# Without extensions - should work
model = create_request_model(
    'SearchGetRequest',
    base_model=BaseSearchGetRequest,
    extensions=[],
    request_type='GET',
)

print('Without extensions:')
print('  MRO:', [c.__name__ for c in model.__mro__])
print('  __post_init__ in __dict__:', '__post_init__' in model.__dict__)

m = model(datetime='2020-01-01T00:00:00Z', collections='test1,test2')
print('  datetime:', m.datetime)
print('  collections:', m.collections)
"

cd /stac-fastapi && python -c "
# Let's understand the flow better
from dataclasses import make_dataclass, _POST_INIT_NAME
from stac_fastapi.types.search import BaseSearchGetRequest

# Just base model
Model = make_dataclass('Test1', [], bases=(BaseSearchGetRequest,))

# Check if __post_init__ is in __dict__
print('__post_init__ in __dict__:', '__post_init__' in Model.__dict__)
print('_POST_INIT_NAME:', _POST_INIT_NAME)
print('hasattr __post_init__:', hasattr(Model, '_POST_INIT_NAME'))

# Check the __init__ source
import inspect
try:
    print('__init__ source:')
    print(inspect.getsource(Model.__init__)[:500])
except:
    print('Cannot get __init__ source')
"

cd /stac-fastapi && python -c "
from stac_fastapi.api.models import create_request_model
from stac_fastapi.extensions.core import FieldsExtension
from stac_fastapi.types.search import BaseSearchGetRequest

# Without extensions - check what happens
model = create_request_model(
    'SearchGetRequest',
    base_model=BaseSearchGetRequest,
    extensions=[],
    request_type='GET',
)

print('MRO:', [c.__name__ for c in model.__mro__])
print('__post_init__ in __dict__:', '__post_init__' in model.__dict__)
print('Model.__dict__.keys():', list(model.__dict__.keys())[:20])

# Check if we can access the original __post_init
for cls in model.__mro__:
    if '__post_init__' in cls.__dict__:
        print(f'{cls.__name__} has __post_init__ in __dict__')
"

cd /stac-fastapi && python -c "
from dataclasses import make_dataclass
from stac_fastapi.types.search import BaseSearchGetRequest

# Just base model - works
Model = make_dataclass('Test1', [], bases=(BaseSearchGetRequest,))
m = Model(datetime='2020-01-01T00:00:00Z', collections='test1,test2')
print('Just base - datetime:', m.datetime, 'collections:', m.collections)

# Now with two bases
from stac_fastapi.extensions.core import FieldsExtension

# This might fail due to metaclass conflict, let's try
try:
    Model2 = make_dataclass('Test2', [], bases=(FieldsExtension, BaseSearchGetRequest))
    m2 = Model2(datetime='2020-01-01T00:00:00Z', collections='test1,test2')
    print('With extensions - datetime:', m2.datetime, 'collections:', m2.collections)
except Exception as e:
    print('Error with extensions:', type(e).__name__, e)
"

cd /stac-fastapi && python -c "
from stac_fastapi.api.models import create_request_model
from stac_fastapi.extensions.core import FieldsExtension
from stac_fastapi.types.search import BaseSearchGetRequest

# With extensions through create_request_model
model = create_request_model(
    'SearchGetRequest',
    base_model=BaseSearchGetRequest,
    extensions=[FieldsExtension()],
    request_type='GET',
)

print('MRO:', [c.__name__ for c in model.__mro__])
print('__post_init__ in __dict__:', '__post_init__' in model.__dict__)

# Check each class's __post_init__
for cls in model.__mro__:
    if '__post_init__' in cls.__dict__:
        print(f'{cls.__name__}\'s __post_init__: {cls.__dict__[\"__post_init__\"]}')

# Try creating instance
try:
    m = model(datetime='2020-01-01T00:00:00Z', collections='test1,test2')
    print('datetime:', m.datetime)
except Exception as e:
    print('Error:', type(e).__name__, e)
"

cd /stac-fastapi && python -c "
from stac_fastapi.types.search import BaseSearchGetRequest
from stac_fastapi.extensions.core import FieldsExtension

# Create instances and call __post_init__ explicitly
br = BaseSearchGetRequest(collections='test1,test2', datetime='2020-01-01T00:00:00Z')
print('BaseSearchGetRequest:')
print('  collections:', br.collections)
print('  datetime:', br.datetime)

# Now let's see what happens with FieldsExtension
fe = FieldsExtension()
# Get the request model from extension
req_model = fe.get_request_model('GET')
print('Extension request model:', req_model)

# Create an instance with FieldsExtension
# This is getting complex. Let me just trace through the issue.
"

cd /stac-fastapi && python -c "
from dataclasses import make_dataclass, dataclass, _POST_INIT_NAME
from stac_fastapi.types.search import BaseSearchGetRequest

# Create a class without __post_init__ first
# Then add our own

# Step 1: Create the class with make_dataclass but without __post_init__
# Actually, make_dataclass always adds __post_init__ if any base has it

# Let me try a different approach - create the class manually
import types

# Get the bases
base_model = BaseSearchGetRequest

# Create a namespace
namespace = {}
exec_body_callback = lambda ns: ns.update(namespace)

# Create the class
cls = types.new_class('TestModel', (base_model,), {}, exec_body_callback)

# Remove __post_init__ if it exists
if hasattr(cls, '_POST_INIT_NAME'):
    delattr(cls, _POST_INIT_NAME)

print('After removal, has __post_init__:', hasattr(cls, _POST_INIT_NAME))

# Now apply dataclass decorator
Model = dataclass(cls)

# Now add our own __post_init__
def our_post_init(self):
    print('Our __post_init__ called')
    # Call base __post_init__
    for base in Model.__mro__:
        if '__post_init__' in base.__dict__ and base.__dict__['__post_init__'] is not object.__dict__['__post_init__']:
            base.__post_init__(self)

Model.__post_init__ = our_post_init

# Test
m = Model(datetime='2020-01-01T00:00:00Z', collections='test1,test2')
print('datetime:', m.datetime)
print('collections:', m.collections)
"

cd /stac-fastapi && python -c "
from dataclasses import make_dataclass, dataclass
from stac_fastapi.types.search import BaseSearchGetRequest
import types

# Create the class
cls = types.new_class('TestModel', (BaseSearchGetRequest,), {}, lambda ns: ns.update({}))

# Check what's in __dict__
print('__dict__ keys with post_init:', [k for k in cls.__dict__.keys() if 'post_init' in k.lower()])

# Try to delete
if '_POST_INIT_NAME' in cls.__dict__:
    del cls.__dict__['_POST_INIT_NAME']

print('After deletion, has __post_init__:', hasattr(cls, '_POST_INIT_NAME'))
"

cd /stac-fastapi && python -c "
from dataclasses import make_dataclass, dataclass
from stac_fastapi.types.search import BaseSearchGetRequest
import types

# Create the class
cls = types.new_class('TestModel', (BaseSearchGetRequest,), {}, lambda ns: ns.update({}))

# Remove __post_init__ if present
if '_POST_INIT_NAME' in cls.__dict__:
    del cls.__dict__['_POST_INIT_NAME']

print('After removal, has __post_init__:', hasattr(cls, '_POST_INIT_NAME'))

# Now apply dataclass decorator
Model = dataclass(cls)

# Now add our own __post_init__
def our_post_init(self):
    print('Our __post_init__ called')
    # Call base __post_init__ from all bases that have it
    for base in Model.__mro__:
        if '__post_init__' in base.__dict__:
            print(f'  Calling {base.__name__}\'s __post_init__')
            base.__post_init__(self)

Model.__post_init__ = our_post_init

# Test
m = Model(datetime='2020-01-01T00:00:00Z', collections='test1,test2')
print('datetime:', m.datetime)
print('collections:', m.collections)
"

cd /stac-fastapi && python -c "
from dataclasses import make_dataclass, dataclass
from stac_fastapi.types.search import BaseSearchGetRequest
import types

# Create the class
cls = types.new_class('TestModel', (BaseSearchGetRequest,), {}, lambda ns: ns.update({}))

# Remove __post_init__ if present
if '_POST_INIT_NAME' in cls.__dict__:
    del cls.__dict__['_POST_INIT_NAME']

# Now apply dataclass decorator
Model = dataclass(cls)

# Now add our own __post_init__
def our_post_init(self):
    print('Our __post_init__ called')
    # Call base __post_init__ from all bases EXCEPT the current class
    for base in Model.__mro__:
        if base is Model:  # Skip the current class
            continue
        if '__post_init__' in base.__dict__:
            print(f'  Calling {base.__name__}\'s __post_init__')
            base.__post_init__(self)

Model.__post_init__ = our_post_init

# Test
m = Model(datetime='2020-01-01T00:00:00Z', collections='test1,test2')
print('datetime:', m.datetime)
print('collections:', m.collections)
"

cd /stac-fastapi && python -c "
from dataclasses import make_dataclass, dataclass
from stac_fastapi.types.search import BaseSearchGetRequest
from stac_fastapi.extensions.core import FieldsExtension
import types

# Create the class with multiple bases
cls = types.new_class('TestModel', (FieldsExtension, BaseSearchGetRequest), {}, lambda ns: ns.update({}))

# Remove __post_init__ if present
if '_POST_INIT_NAME' in cls.__dict__:
    del cls.__dict__['_POST_INIT_NAME']

print('Classes in MRO with __post_init__:')
for c in cls.__mro__:
    if '__post_init__' in c.__dict__:
        print(f'  {c.__name__}')

# Now apply dataclass decorator
Model = dataclass(cls)

# Now add our own __post_init__
def our_post_init(self):
    print('Our __post_init__ called')
    # Call base __post_init__ from all bases EXCEPT the current class
    for base in Model.__mro__:
        if base is Model:  # Skip the current class
            continue
        if '__post_init__' in base.__dict__:
            print(f'  Calling {base.__name__}\'s __post_init__')
            base.__post_init__(self)

Model.__post_init__ = our_post_init

# Test
m = Model(datetime='2020-01-01T00:00:00Z', collections='test1,test2')
print('datetime:', m.datetime)
print('collections:', m.collections)
"

cd /stac-fastapi && python -c "
from stac_fastapi.extensions.core import FieldsExtension

fe = FieldsExtension()
req_model = fe.get_request_model('GET')
print('Request model:', req_model)
print('MRO:', [c.__name__ for c in req_model.__mro__])
print()
for cls in req_model.__mro__:
    if '__post_init__' in cls.__dict__:
        print(f'{cls.__name__} has __post_init__ in __dict__')
        import inspect
        print(f'  Source: {inspect.getsource(cls.__post_init__)[:200]}')
"

cd /stac-fastapi && python -c "
from stac_fastapi.api.models import create_request_model
from stac_fastapi.extensions.core import FieldsExtension
from stac_fastapi.types.search import BaseSearchGetRequest

# Recreate the model but with our fix approach
# First, let's see what create_request_model does internally

base_model = BaseSearchGetRequest
extensions = [FieldsExtension()]

# Get extension models
extension_models = []
for extension in extensions:
    if extension_model := extension.get_request_model('GET'):
        extension_models.append(extension_model)

models = extension_models + [base_model]
print('Models:', [m.__name__ for m in models])

# Now create the model manually using our approach
import types
from dataclasses import dataclass

# Create namespace
namespace = {}

# Create class using types.new_class
model_cls = types.new_class('SearchGetRequest', tuple(models), {}, lambda ns: ns.update(namespace))

# Remove __post_init__ if present
if '_POST_INIT_NAME' in model_cls.__dict__:
    del model_cls.__dict__['_POST_INIT_NAME']

print('After removal, has __post_init__:', hasattr(model_cls, '_POST_INIT_NAME'))

# Apply dataclass
Model = dataclass(model_cls)

# Add our __post_init__
def our_post_init(self):
    print('Our __post_init__ called')
    # Call base __post_init__ from all bases EXCEPT the current class
    for base in Model.__mro__:
        if base is Model:  # Skip the current class
            continue
        if '__post_init__' in base.__dict__:
            print(f'  Calling {base.__name__}\'s __post_init__')
            base.__post_init__(self)

Model.__post_init__ = our_post_init

# Test
m = Model(datetime='2020-01-01T00:00:00Z', collections='test1,test2')
print('datetime:', m.datetime)
print('collections:', m.collections)
"