fastapi_14482

{"status": "ok", "stdout": "./tests/test_inherited_custom_class.py:45:        model_config = {\"arbitrary_types_allowed\": True}\n./tests/test_inherited_custom_class.py:89:            arbitrary_types_allowed = True\n./tests/test_jsonable_encoder.py:248:            model_config = {\"arbitrary_types_allowed\": True}\n./tests/test_jsonable_encoder.py:252:                arbitrary_types_allowed = True\n./tests/test_jsonable_encoder.py:264:            model_config = {\"arbitrary_types_allowed\": True}\n./tests/test_jsonable_encoder.py:268:                arbitrary_types_allowed = True\n./tests/test_jsonable_encoder.py:279:            model_config = {\"arbitrary_types_allowed\": True}\n./tests/test_jsonable_encoder.py:283:                arbitrary_types_allowed = True\n./tests/test_compat.py:87:        model_config = ConfigDict(arbitrary_types_allowed=True)\n./tests/test_compat.py:92:            arbitrary_types_allowed=True,\n", "stderr": "", "exit_code": 0}

{"status": "error", "error_type": "CommandError", "error_message": "", "details": {"stdout": "", "stderr": "", "exit_code": 1}}

{"status": "error", "error_type": "CommandError", "error_message": "", "details": {"stdout": "", "stderr": "", "exit_code": 1}}

{"status": "ok", "stdout": "./tests/test_inherited_custom_class.py:45:        model_config = {\"arbitrary_types_allowed\": True}\n./tests/test_inherited_custom_class.py:89:            arbitrary_types_allowed = True\n./tests/test_jsonable_encoder.py:248:            model_config = {\"arbitrary_types_allowed\": True}\n./tests/test_jsonable_encoder.py:252:                arbitrary_types_allowed = True\n./tests/test_jsonable_encoder.py:264:            model_config = {\"arbitrary_types_allowed\": True}\n./tests/test_jsonable_encoder.py:268:                arbitrary_types_allowed = True\n./tests/test_jsonable_encoder.py:279:            model_config = {\"arbitrary_types_allowed\": True}\n./tests/test_jsonable_encoder.py:283:                arbitrary_types_allowed = True\n./tests/test_compat.py:87:        model_config = ConfigDict(arbitrary_types_allowed=True)\n./tests/test_compat.py:92:            arbitrary_types_allowed=True,\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "fastapi/exception_handlers.py:1:from fastapi.encoders import jsonable_encoder\nfastapi/exception_handlers.py:25:        content={\"detail\": jsonable_encoder(exc.errors())},\nfastapi/exception_handlers.py:33:        code=WS_1008_POLICY_VIOLATION, reason=jsonable_encoder(exc.errors())\nfastapi/encoders.py:114:def jsonable_encoder(\nfastapi/encoders.py:247:        return jsonable_encoder(\nfastapi/encoders.py:258:        return jsonable_encoder(\nfastapi/encoders.py:294:                encoded_key = jsonable_encoder(\nfastapi/encoders.py:302:                encoded_value = jsonable_encoder(\nfastapi/encoders.py:316:                jsonable_encoder(\nfastapi/encoders.py:346:    return jsonable_encoder(\nfastapi/openapi/docs.py:5:from fastapi.encoders import jsonable_encoder\nfastapi/openapi/docs.py:137:        html += f\"{json.dumps(key)}: {json.dumps(jsonable_encoder(value))},\\n\"\nfastapi/openapi/docs.py:151:        ui.initOAuth({json.dumps(jsonable_encoder(init_oauth))})\nfastapi/openapi/utils.py:23:from fastapi.encoders import jsonable_encoder\nfastapi/openapi/utils.py:85:        security_definition = jsonable_encoder(\nfastapi/openapi/utils.py:168:                parameter[\"examples\"] = jsonable_encoder(openapi_examples)\nfastapi/openapi/utils.py:170:                parameter[\"example\"] = jsonable_encoder(example)\nfastapi/openapi/utils.py:203:        request_media_content[\"examples\"] = jsonable_encoder(\nfastapi/openapi/utils.py:207:        request_media_content[\"example\"] = jsonable_encoder(field_info.example)\nfastapi/openapi/utils.py:567:    return jsonable_encoder(OpenAPI(**output), by_alias=True, exclude_none=True)  # type: ignore\nfastapi/routing.py:47:from fastapi.encoders import jsonable_encoder\nfastapi/routing.py:295:        return jsonable_encoder(\nfastapi/routing.py:305:        return jsonable_encoder(response_content)\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "def jsonable_encoder(\n    obj: Annotated[\n        Any,\n        Doc(\n            \"\"\"\n            The input object to convert to JSON.\n            \"\"\"\n        ),\n    ],\n    include: Annotated[\n        Optional[IncEx],\n        Doc(\n            \"\"\"\n            Pydantic's `include` parameter, passed to Pydantic models to set the\n            fields to include.\n            \"\"\"\n        ),\n    ] = None,\n    exclude: Annotated[\n        Optional[IncEx],\n        Doc(\n            \"\"\"\n            Pydantic's `exclude` parameter, passed to Pydantic models to set the\n            fields to exclude.\n            \"\"\"\n        ),\n    ] = None,\n    by_alias: Annotated[\n        bool,\n        Doc(\n            \"\"\"\n            Pydantic's `by_alias` parameter, passed to Pydantic models to define if\n            the output should use the alias names (when provided) or the Python\n            attribute names. In an API, if you set an alias, it's probably because you\n            want to use it in the result, so you probably want to leave this set to\n            `True`.\n            \"\"\"\n        ),\n    ] = True,\n    exclude_unset: Annotated[\n        bool,\n        Doc(\n            \"\"\"\n            Pydantic's `exclude_unset` parameter, passed to Pydantic models to define\n            if it should exclude from the output the fields that were not explicitly\n            set (and that only had their default values).\n            \"\"\"\n        ),\n    ] = False,\n    exclude_defaults: Annotated[\n        bool,\n        Doc(\n            \"\"\"\n            Pydantic's `exclude_defaults` parameter, passed to Pydantic models to define\n            if it should exclude from the output the fields that had the same default\n            value, even when they were explicitly set.\n            \"\"\"\n        ),\n    ] = False,\n    exclude_none: Annotated[\n        bool,\n        Doc(\n            \"\"\"\n            P

{"status": "ok", "stdout": "            by_alias=by_alias,\n            exclude_unset=exclude_unset,\n            exclude_none=exclude_none,\n            exclude_defaults=exclude_defaults,\n        )\n        if \"__root__\" in obj_dict:\n            obj_dict = obj_dict[\"__root__\"]\n        return jsonable_encoder(\n            obj_dict,\n            exclude_none=exclude_none,\n            exclude_defaults=exclude_defaults,\n            # TODO: remove when deprecating Pydantic v1\n            custom_encoder=encoders,\n            sqlalchemy_safe=sqlalchemy_safe,\n        )\n    if dataclasses.is_dataclass(obj):\n        assert not isinstance(obj, type)\n        obj_dict = dataclasses.asdict(obj)\n        return jsonable_encoder(\n            obj_dict,\n            include=include,\n            exclude=exclude,\n            by_alias=by_alias,\n            exclude_unset=exclude_unset,\n            exclude_defaults=exclude_defaults,\n            exclude_none=exclude_none,\n            custom_encoder=custom_encoder,\n            sqlalchemy_safe=sqlalchemy_safe,\n        )\n    if isinstance(obj, Enum):\n        return obj.value\n    if isinstance(obj, PurePath):\n        return str(obj)\n    if isinstance(obj, (str, int, float, type(None))):\n        return obj\n    if _is_undefined(obj):\n        return None\n    if isinstance(obj, dict):\n        encoded_dict = {}\n        allowed_keys = set(obj.keys())\n        if include is not None:\n            allowed_keys &= set(include)\n        if exclude is not None:\n            allowed_keys -= set(exclude)\n        for key, value in obj.items():\n            if (\n                (\n                    not sqlalchemy_safe\n                    or (not isinstance(key, str))\n                    or (not key.startswith(\"_sa\"))\n                )\n                and (value is not None or not exclude_none)\n                and key in allowed_keys\n            ):\n                encoded_key = jsonable_encoder(\n             

{"status": "ok", "stdout": "import uuid\n\nimport pytest\nfrom fastapi import FastAPI\nfrom fastapi.testclient import TestClient\nfrom pydantic import BaseModel\n\nfrom .utils import needs_pydanticv1, needs_pydanticv2\n\n\nclass MyUuid:\n    def __init__(self, uuid_string: str):\n        self.uuid = uuid_string\n\n    def __str__(self):\n        return self.uuid\n\n    @property  # type: ignore\n    def __class__(self):\n        return uuid.UUID\n\n    @property\n    def __dict__(self):\n        \"\"\"Spoof a missing __dict__ by raising TypeError, this is how\n        asyncpg.pgroto.pgproto.UUID behaves\"\"\"\n        raise TypeError(\"vars() argument must have __dict__ attribute\")\n\n\n@needs_pydanticv2\ndef test_pydanticv2():\n    from pydantic import field_serializer\n\n    app = FastAPI()\n\n    @app.get(\"/fast_uuid\")\n    def return_fast_uuid():\n        asyncpg_uuid = MyUuid(\"a10ff360-3b1e-4984-a26f-d3ab460bdb51\")\n        assert isinstance(asyncpg_uuid, uuid.UUID)\n        assert type(asyncpg_uuid) is not uuid.UUID\n        with pytest.raises(TypeError):\n            vars(asyncpg_uuid)\n        return {\"fast_uuid\": asyncpg_uuid}\n\n    class SomeCustomClass(BaseModel):\n        model_config = {\"arbitrary_types_allowed\": True}\n\n        a_uuid: MyUuid\n\n        @field_serializer(\"a_uuid\")\n        def serialize_a_uuid(self, v):\n            return str(v)\n\n    @app.get(\"/get_custom_class\")\n    def return_some_user():\n        # Test that the fix also works for custom pydantic classes\n        return SomeCustomClass(a_uuid=MyUuid(\"b8799909-f914-42de-91bc-95c819218d01\"))\n\n    client = TestClient(app)\n\n    with client:\n        response_simple = client.get(\"/fast_uuid\")\n        response_pydantic = client.get(\"/get_custom_class\")\n\n    assert response_simple.json() == {\n        \"fast_uuid\": \"a10ff360-3b1e-4984-a26f-d3ab460bdb51\"\n    }\n\n    assert response_pydantic.json() == {\n        \"a_uuid\": \"b8799909-f914-42de-91bc-95c81

{"status": "ok", "stdout": "from collections import deque\nfrom dataclasses import dataclass\nfrom datetime import datetime, timezone\nfrom decimal import Decimal\nfrom enum import Enum\nfrom math import isinf, isnan\nfrom pathlib import PurePath, PurePosixPath, PureWindowsPath\nfrom typing import Optional\n\nimport pytest\nfrom fastapi._compat import PYDANTIC_V2, Undefined\nfrom fastapi.encoders import jsonable_encoder\nfrom pydantic import BaseModel, Field, ValidationError\n\nfrom .utils import needs_pydanticv1, needs_pydanticv2\n\n\nclass Person:\n    def __init__(self, name: str):\n        self.name = name\n\n\nclass Pet:\n    def __init__(self, owner: Person, name: str):\n        self.owner = owner\n        self.name = name\n\n\n@dataclass\nclass Item:\n    name: str\n    count: int\n\n\nclass DictablePerson(Person):\n    def __iter__(self):\n        return ((k, v) for k, v in self.__dict__.items())\n\n\nclass DictablePet(Pet):\n    def __iter__(self):\n        return ((k, v) for k, v in self.__dict__.items())\n\n\nclass Unserializable:\n    def __iter__(self):\n        raise NotImplementedError()\n\n    @property\n    def __dict__(self):\n        raise NotImplementedError()\n\n\nclass RoleEnum(Enum):\n    admin = \"admin\"\n    normal = \"normal\"\n\n\nclass ModelWithConfig(BaseModel):\n    role: Optional[RoleEnum] = None\n\n    if PYDANTIC_V2:\n        model_config = {\"use_enum_values\": True}\n    else:\n\n        class Config:\n            use_enum_values = True\n\n\nclass ModelWithAlias(BaseModel):\n    foo: str = Field(alias=\"Foo\")\n\n\nclass ModelWithDefault(BaseModel):\n    foo: str = ...  # type: ignore\n    bar: str = \"bar\"\n    bla: str = \"bla\"\n\n\ndef test_encode_dict():\n    pet = {\"name\": \"Firulais\", \"owner\": {\"name\": \"Foo\"}}\n    assert jsonable_encoder(pet) == {\"name\": \"Firulais\", \"owner\": {\"name\": \"Foo\"}}\n    assert jsonable_encoder(pet, include={\"name\"}) == {\"name\": \"Firulais\"}\n    assert jsonable_encoder(pe

{"status": "ok", "stdout": "            model_config = {\"arbitrary_types_allowed\": True}\n        else:\n\n            class Config:\n                arbitrary_types_allowed = True\n\n    test_path = PurePath(\"/foo\", \"bar\")\n    obj = ModelWithPath(path=test_path)\n    assert jsonable_encoder(obj) == {\"path\": str(test_path)}\n\n\ndef test_encode_model_with_pure_posix_path():\n    class ModelWithPath(BaseModel):\n        path: PurePosixPath\n\n        if PYDANTIC_V2:\n            model_config = {\"arbitrary_types_allowed\": True}\n        else:\n\n            class Config:\n                arbitrary_types_allowed = True\n\n    obj = ModelWithPath(path=PurePosixPath(\"/foo\", \"bar\"))\n    assert jsonable_encoder(obj) == {\"path\": \"/foo/bar\"}\n\n\ndef test_encode_model_with_pure_windows_path():\n    class ModelWithPath(BaseModel):\n        path: PureWindowsPath\n\n        if PYDANTIC_V2:\n            model_config = {\"arbitrary_types_allowed\": True}\n        else:\n\n            class Config:\n                arbitrary_types_allowed = True\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "                    sqlalchemy_safe=sqlalchemy_safe,\n                )\n                encoded_value = jsonable_encoder(\n                    value,\n                    by_alias=by_alias,\n                    exclude_unset=exclude_unset,\n                    exclude_none=exclude_none,\n                    custom_encoder=custom_encoder,\n                    sqlalchemy_safe=sqlalchemy_safe,\n                )\n                encoded_dict[encoded_key] = encoded_value\n        return encoded_dict\n    if isinstance(obj, (list, set, frozenset, GeneratorType, tuple, deque)):\n        encoded_list = []\n        for item in obj:\n            encoded_list.append(\n                jsonable_encoder(\n                    item,\n                    include=include,\n                    exclude=exclude,\n                    by_alias=by_alias,\n                    exclude_unset=exclude_unset,\n                    exclude_defaults=exclude_defaults,\n                    exclude_none=exclude_none,\n                    custom_encoder=custom_encoder,\n                    sqlalchemy_safe=sqlalchemy_safe,\n                )\n            )\n        return encoded_list\n\n    if type(obj) in ENCODERS_BY_TYPE:\n        return ENCODERS_BY_TYPE[type(obj)](obj)\n    for encoder, classes_tuple in encoders_by_class_tuples.items():\n        if isinstance(obj, classes_tuple):\n            return encoder(obj)\n\n    try:\n        data = dict(obj)\n    except Exception as e:\n        errors: List[Exception] = []\n        errors.append(e)\n        try:\n            data = vars(obj)\n        except Exception as e:\n            errors.append(e)\n            raise ValueError(errors) from e\n    return jsonable_encoder(\n        data,\n        include=include,\n        exclude=exclude,\n        by_alias=by_alias,\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "        errors.append(e)\n        try:\n            data = vars(obj)\n        except Exception as e:\n            errors.append(e)\n            raise ValueError(errors) from e\n    return jsonable_encoder(\n        data,\n        include=include,\n        exclude=exclude,\n        by_alias=by_alias,\n        exclude_unset=exclude_unset,\n        exclude_defaults=exclude_defaults,\n        exclude_none=exclude_none,\n        custom_encoder=custom_encoder,\n        sqlalchemy_safe=sqlalchemy_safe,\n    )\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "============================= test session starts ==============================\nplatform darwin -- Python 3.13.15, pytest-9.1.1, pluggy-1.6.0\ncodspeed: 5.0.3 (disabled, mode: walltime, callgraph: not supported, timer_resolution: 41.7ns)\nrootdir: /private/workspace\nconfigfile: pytest.ini (WARNING: ignoring pytest config in pyproject.toml!)\nplugins: cov-7.1.0, xdist-3.8.0, timeout-2.4.0, codspeed-5.0.3, sugar-1.1.1, anyio-4.15.1, inline-snapshot-0.35.4\ncollected 2 items\n\ntests/test_inherited_custom_class.py .s                                  [100%]\n\n=============================== warnings summary ===============================\n../../../../../../../Users/jp/repos/kaggle-gemini-coding-agent-post-training/.envs/overlays/starlette-0.50.0-py3-none-any/starlette/testclient.py:45\n  /Users/jp/repos/kaggle-gemini-coding-agent-post-training/.envs/overlays/starlette-0.50.0-py3-none-any/starlette/testclient.py:45: DeprecationWarning: The anyio.abc.BlockingPortal alias is deprecated, use anyio.from_thread.BlockingPortal instead.\n    _PortalFactoryType = Callable[[], AbstractContextManager[anyio.abc.BlockingPortal]]\n\n-- Docs: https://docs.pytest.org/en/stable/how-to/capture-warnings.html\n=================== 1 passed, 1 skipped, 1 warning in 0.36s ====================\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "============================= test session starts ==============================\nplatform darwin -- Python 3.13.15, pytest-9.1.1, pluggy-1.6.0\ncodspeed: 5.0.3 (disabled, mode: walltime, callgraph: not supported, timer_resolution: 41.7ns)\nrootdir: /private/workspace\nconfigfile: pytest.ini (WARNING: ignoring pytest config in pyproject.toml!)\nplugins: cov-7.1.0, xdist-3.8.0, timeout-2.4.0, codspeed-5.0.3, sugar-1.1.1, anyio-4.15.1, inline-snapshot-0.35.4\ncollected 23 items\n\ntests/test_jsonable_encoder.py ......s....s....s......                   [100%]\n\n======================== 20 passed, 3 skipped in 0.32s =========================\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "Error: Unable to serialize unknown type: <class '__main__.MyCustomType'>\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "Error model_dump: Unable to serialize unknown type: <class '__main__.MyCustomType'>\nError jsonable_encoder: Unable to serialize unknown type: <class '__main__.MyCustomType'>\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "Error jsonable_encoder: Unable to serialize unknown type: <class '__main__.MyCustomType'>\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "Error: Unable to serialize unknown type: <class '__main__.MyCustomType'>\n", "stderr": "", "exit_code": 0}

{"status": "error", "error_type": "CommandError", "error_message": "", "details": {"stdout": "", "stderr": "", "exit_code": 1}}

{"status": "error", "error_type": "CommandError", "error_message": "", "details": {"stdout": "", "stderr": "", "exit_code": 1}}

{"status": "ok", "stdout": "", "stderr": "Traceback (most recent call last):\n  File \"<stdin>\", line 16, in <module>\n  File \"/private/workspace/fastapi/encoders.py\", line 235, in jsonable_encoder\n    obj_dict = _model_dump(\n        obj,\n    ...<6 lines>...\n        exclude_defaults=exclude_defaults,\n    )\n  File \"/private/workspace/fastapi/_compat/main.py\", line 95, in _model_dump\n    return v2._model_dump(model, mode=mode, **kwargs)\n           ~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n  File \"/private/workspace/fastapi/_compat/v2.py\", line 167, in _model_dump\n    return model.model_dump(mode=mode, **kwargs)\n           ~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^\n  File \"/Users/jp/repos/kaggle-gemini-coding-agent-post-training/.envs/fastapi/lib/python3.13/site-packages/pydantic/main.py\", line 475, in model_dump\n    return self.__pydantic_serializer__.to_python(\n           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^\n        self,\n        ^^^^^\n    ...<13 lines>...\n        polymorphic_serialization=polymorphic_serialization,\n        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n    )\n    ^\npydantic_core._pydantic_core.PydanticSerializationError: Unable to serialize unknown type: <class '__main__.MyCustomType'>\n", "exit_code": 0}

{"status": "ok", "stdout": "        else:\n            for encoder_type, encoder_instance in custom_encoder.items():\n                if isinstance(obj, encoder_type):\n                    return encoder_instance(obj)\n    if include is not None and not isinstance(include, (set, dict)):\n        include = set(include)\n    if exclude is not None and not isinstance(exclude, (set, dict)):\n        exclude = set(exclude)\n    if isinstance(obj, (BaseModel, may_v1.BaseModel)):\n        # TODO: remove when deprecating Pydantic v1\n        encoders: Dict[Any, Any] = {}\n        if isinstance(obj, may_v1.BaseModel):\n            encoders = getattr(obj.__config__, \"json_encoders\", {})  # type: ignore[attr-defined]\n            if custom_encoder:\n                encoders = {**encoders, **custom_encoder}\n        obj_dict = _model_dump(\n            obj,\n            mode=\"json\",\n            include=include,\n            exclude=exclude,\n            by_alias=by_alias,\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "model_dump(mode='python'): {'custom': <__main__.MyCustomType object at 0x10553dfd0>}\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "import re\nimport warnings\nfrom copy import copy, deepcopy\nfrom dataclasses import dataclass\nfrom enum import Enum\nfrom typing import (\n    Any,\n    Dict,\n    List,\n    Sequence,\n    Set,\n    Tuple,\n    Type,\n    Union,\n    cast,\n)\n\nfrom fastapi._compat import may_v1, shared\nfrom fastapi.openapi.constants import REF_TEMPLATE\nfrom fastapi.types import IncEx, ModelNameMap, UnionType\nfrom pydantic import BaseModel, TypeAdapter, create_model\nfrom pydantic import PydanticSchemaGenerationError as PydanticSchemaGenerationError\nfrom pydantic import PydanticUndefinedAnnotation as PydanticUndefinedAnnotation\nfrom pydantic import ValidationError as ValidationError\nfrom pydantic._internal._schema_generation_shared import (  # type: ignore[attr-defined]\n    GetJsonSchemaHandler as GetJsonSchemaHandler,\n)\nfrom pydantic._internal._typing_extra import eval_type_lenient\nfrom pydantic._internal._utils import lenient_issubclass as lenient_issubclass\nfrom pydantic.fields import FieldInfo as FieldInfo\nfrom pydantic.json_schema import GenerateJsonSchema as GenerateJsonSchema\nfrom pydantic.json_schema import JsonSchemaValue as JsonSchemaValue\nfrom pydantic_core import CoreSchema as CoreSchema\nfrom pydantic_core import PydanticUndefined, PydanticUndefinedType\nfrom pydantic_core import Url as Url\nfrom typing_extensions import Annotated, Literal, get_args, get_origin\n\ntry:\n    from pydantic_core.core_schema import (\n        with_info_plain_validator_function as with_info_plain_validator_function,\n    )\nexcept ImportError:  # pragma: no cover\n    from pydantic_core.core_schema import (\n        general_plain_validator_function as with_info_plain_validator_function,  # noqa: F401\n    )\n\nRequiredParam = PydanticUndefined\nUndefined = PydanticUndefined\nUndefinedType = PydanticUndefinedType\nevaluate_forwardref = eval_type_lenient\nValidator = Any\n\n\nclass BaseConfig:\n    pass\n\n\nclass ErrorWrapper(Exception):\n    pass

{"status": "ok", "stdout": "        # ModelField to its JSON Schema.\n        return id(self)\n\n\ndef get_annotation_from_field_info(\n    annotation: Any, field_info: FieldInfo, field_name: str\n) -> Any:\n    return annotation\n\n\ndef _model_rebuild(model: Type[BaseModel]) -> None:\n    model.model_rebuild()\n\n\ndef _model_dump(\n    model: BaseModel, mode: Literal[\"json\", \"python\"] = \"json\", **kwargs: Any\n) -> Any:\n    return model.model_dump(mode=mode, **kwargs)\n\n\ndef _get_model_config(model: BaseModel) -> Any:\n    return model.model_config\n\n\ndef _has_computed_fields(field: ModelField) -> bool:\n    computed_fields = field._type_adapter.core_schema.get(\"schema\", {}).get(\n        \"computed_fields\", []\n    )\n    return len(computed_fields) > 0\n\n\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "model_dump(mode='python'): {'custom': <__main__.MyCustomType object at 0x102255fd0>}\njsonable_encoder(model.model_dump(mode='python')): {'custom': {'value': 'hello'}}\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "dumped: {'custom': <__main__.MyCustomType object at 0x101de1fd0>, 'dt': datetime.datetime(2023, 1, 1, 0, 0)}\nencoded: {'custom': {'value': 'hello'}, 'dt': '2023-01-01T00:00:00'}\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "mode='json': {'dt': '2023-01-01T00:00:00'}\nmode='python' then jsonable_encoder: {'dt': '2023-01-01T00:00:00'}\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "mode='json': {'foo': 'bar'}\nmode='python' then jsonable_encoder: {'foo': 'bar'}\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "mode='json' exclude_none: {'foo': 'bar'}\nmode='python' then jsonable_encoder exclude_none: {'foo': 'bar'}\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "mode='json' exclude_none: {'foo': 'bar'}\nmode='python' then jsonable_encoder exclude_none: {'foo': 'bar'}\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "mode='json' exclude_defaults: {}\nmode='python' then jsonable_encoder exclude_defaults: {'foo': 'bar'}\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "mode='json' exclude_defaults: {}\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "        encoders: Dict[Any, Any] = {}\n        if isinstance(obj, may_v1.BaseModel):\n            encoders = getattr(obj.__config__, \"json_encoders\", {})  # type: ignore[attr-defined]\n            if custom_encoder:\n                encoders = {**encoders, **custom_encoder}\n        obj_dict = _model_dump(\n            obj,\n            mode=\"json\",\n            include=include,\n            exclude=exclude,\n            by_alias=by_alias,\n            exclude_unset=exclude_unset,\n            exclude_none=exclude_none,\n            exclude_defaults=exclude_defaults,\n        )\n        if \"__root__\" in obj_dict:\n            obj_dict = obj_dict[\"__root__\"]\n        return jsonable_encoder(\n            obj_dict,\n            exclude_none=exclude_none,\n            exclude_defaults=exclude_defaults,\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "dumped: {}\nencoded: {}\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "dumped: {'foo': 'bar'}\nencoded: {'foo': 'bar'}\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "dumped: {}\nencoded: {}\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "dumped: {'foo': 'bar'}\nencoded: {'foo': 'bar'}\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "dumped: {}\nencoded: {}\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "dumped: {'foo': 'bar'}\nencoded: {'foo': 'bar'}\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "dumped: {}\nencoded: {}\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "dumped: {'foo': 'bar'}\nencoded: {'foo': 'bar'}\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "dumped: {}\nencoded: {}\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "dumped: {'foo': 'bar'}\nencoded: {'foo': 'bar'}\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "dumped: {}\nencoded: {}\n", "stderr": "", "exit_code": 0}