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": "ok", "stdout": "", "stderr": "", "exit_code": 0}

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

{"status": "ok", "stdout": ".\n./pytest.ini\n./LICENSE\n./requirements.txt\n./CITATION.cff\n./pyproject.toml\n./tests\n./tests/test_datastructures.py\n./tests/test_filter_pydantic_sub_model\n./tests/test_starlette_exception.py\n./tests/test_multi_body_errors.py\n./tests/test_security_http_digest_description.py\n./tests/test_computed_fields.py\n./tests/test_security_oauth2.py\n./tests/test_openapi_schema_type.py\n./tests/test_param_in_path_and_dependency.py\n./tests/test_pydantic_v1_v2_01.py\n./tests/test_security_http_basic_optional.py\n./tests/test_depends_hashable.py\n./tests/test_response_model_invalid.py\n./tests/test_dependency_yield_scope.py\n./tests/test_multi_query_errors.py\n./tests/test_additional_responses_bad.py\n./tests/test_dependency_security_overrides.py\n./tests/test_pydantic_v1_v2_list.py\n./tests/test_response_change_status_code.py\n./tests/test_compat_params_v1.py\n./tests/test_include_route.py\n./tests/test_forms_from_non_typing_sequences.py\n./tests/test_union_forms.py\n./tests/test_security_scopes_dont_propagate.py\n./tests/test_schema_extra_examples.py\n./tests/test_default_response_class_router.py\n./tests/test_invalid_sequence_param.py\n./tests/forward_reference_type.py\n./tests/test_custom_swagger_ui_redirect.py\n./tests/test_response_model_sub_types.py\n./tests/test_params_repr.py\n./tests/test_schema_ref_pydantic_v2.py\n./tests/test_modules_same_name_body\n./tests/test_security_openid_connect_description.py\n./tests/test_inherited_custom_class.py\n./tests/test_union_inherited_body.py\n./tests/test_response_model_as_return_annotation.py\n./tests/test_invalid_path_param.py\n./tests/test_schema_compat_pydantic_v2.py\n./tests/test_param_include_in_schema.py\n./tests/test_dependency_paramless.py\n./tests/test_custom_middleware_exception.py\n./tests/test_get_request_body.py\n./tests/test_dependency_wrapped.py\n./tests/test_dependency_yield_except_httpexception.py\n./tests/test_datetime_custom_encoder.py\n./tests/test_router_prefix_with_templat

{"status": "ok", "stdout": "./fastapi\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "", "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": "__init__.py\n__main__.py\n_compat\napplications.py\nbackground.py\ncli.py\nconcurrency.py\ndatastructures.py\ndependencies\nencoders.py\nexception_handlers.py\nexceptions.py\nlogger.py\nmiddleware\nopenapi\nparam_functions.py\nparams.py\npy.typed\nrequests.py\nresponses.py\nrouting.py\nsecurity\nstaticfiles.py\ntemp_pydantic_v1_params.py\ntemplating.py\ntestclient.py\ntypes.py\nutils.py\nwebsockets.py\n\nfastapi/_compat:\n__init__.py\nmain.py\nmay_v1.py\nmodel_field.py\nshared.py\nv1.py\nv2.py\n\nfastapi/dependencies:\n__init__.py\nmodels.py\nutils.py\n\nfastapi/middleware:\n__init__.py\nasyncexitstack.py\ncors.py\ngzip.py\nhttpsredirect.py\ntrustedhost.py\nwsgi.py\n\nfastapi/openapi:\n__init__.py\nconstants.py\ndocs.py\nmodels.py\nutils.py\n\nfastapi/security:\n__init__.py\napi_key.py\nbase.py\nhttp.py\noauth2.py\nopen_id_connect_url.py\nutils.py\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": "============================= 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": "248:            model_config = {\"arbitrary_types_allowed\": True}\n249-        else:\n250-\n251-            class Config:\n252:                arbitrary_types_allowed = True\n253-\n254-    test_path = PurePath(\"/foo\", \"bar\")\n255-    obj = ModelWithPath(path=test_path)\n256-    assert jsonable_encoder(obj) == {\"path\": str(test_path)}\n257-\n--\n264:            model_config = {\"arbitrary_types_allowed\": True}\n265-        else:\n266-\n267-            class Config:\n268:                arbitrary_types_allowed = True\n269-\n270-    obj = ModelWithPath(path=PurePosixPath(\"/foo\", \"bar\"))\n271-    assert jsonable_encoder(obj) == {\"path\": \"/foo/bar\"}\n272-\n273-\n--\n279:            model_config = {\"arbitrary_types_allowed\": True}\n280-        else:\n281-\n282-            class Config:\n283:                arbitrary_types_allowed = True\n284-\n285-    obj = ModelWithPath(path=PureWindowsPath(\"/foo\", \"bar\"))\n286-    assert jsonable_encoder(obj) == {\"path\": \"\\\\foo\\\\bar\"}\n287-\n288-\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "    assert encoded_instance == custom_enum_encoder(instance)\n\n\ndef test_encode_model_with_pure_path():\n    class ModelWithPath(BaseModel):\n        path: PurePath\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    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\n    obj = ModelWithPath(path=PureWindowsPath(\"/foo\", \"bar\"))\n    assert jsonable_encoder(obj) == {\"path\": \"\\\\foo\\\\bar\"}\n\n\n@needs_pydanticv1\ndef test_encode_root():\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.30s =========================\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "Model: custom=MyCustomType(hello)\nError encoding model: Unable to serialize unknown type: <class '__main__.MyCustomType'>\nError encoding list model: Unable to serialize unknown type: <class '__main__.MyCustomType'>\n", "stderr": "", "exit_code": 0}

{"status": "error", "error_type": "CommandError", "error_message": "  File \"<string>\", line 1\n    from pydantic import BaseModel, ConfigDict; class MyCustomType: pass; class MyModel(BaseModel): model_config = ConfigDict(arbitrary_types_allowed=True); custom: MyCustomType; m = MyModel(custom=MyCustomType()); print(m.model_dump())\n                                                ^^^^^\nSyntaxError: invalid syntax\n", "details": {"stdout": "", "stderr": "  File \"<string>\", line 1\n    from pydantic import BaseModel, ConfigDict; class MyCustomType: pass; class MyModel(BaseModel): model_config = ConfigDict(arbitrary_types_allowed=True); custom: MyCustomType; m = MyModel(custom=MyCustomType()); print(m.model_dump())\n                                                ^^^^^\nSyntaxError: invalid syntax\n", "exit_code": 1}}

{"status": "error", "error_type": "CommandError", "error_message": "Traceback (most recent call last):\n  File \"<stdin>\", line 12, in <module>\n  File \"/Users/jp/repos/kaggle-gemini-coding-agent-post-training/.envs/fastapi/lib/python3.13/site-packages/pydantic/main.py\", line 542, in model_dump_json\n    return self.__pydantic_serializer__.to_json(\n           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^\n        self,\n        ^^^^^\n    ...<14 lines>...\n        polymorphic_serialization=polymorphic_serialization,\n        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n    ).decode()\n    ^\npydantic_core._pydantic_core.PydanticSerializationError: Unable to serialize unknown type: <class '__main__.MyCustomType'>\n", "details": {"stdout": "model_dump(): {'custom': MyCustomType}\n", "stderr": "Traceback (most recent call last):\n  File \"<stdin>\", line 12, in <module>\n  File \"/Users/jp/repos/kaggle-gemini-coding-agent-post-training/.envs/fastapi/lib/python3.13/site-packages/pydantic/main.py\", line 542, in model_dump_json\n    return self.__pydantic_serializer__.to_json(\n           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^\n        self,\n        ^^^^^\n    ...<14 lines>...\n        polymorphic_serialization=polymorphic_serialization,\n        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n    ).decode()\n    ^\npydantic_core._pydantic_core.PydanticSerializationError: Unable to serialize unknown type: <class '__main__.MyCustomType'>\n", "exit_code": 1}}

{"status": "ok", "stdout": "model_dump(): {'custom': MyCustomType}\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "model_dump(): {'custom': MyCustomType}\njsonable_encoder error: Unable to serialize unknown type: <class '__main__.MyCustomType'>\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "            \"\"\"\n        ),\n    ] = False,\n    exclude_none: Annotated[\n        bool,\n        Doc(\n            \"\"\"\n            Pydantic's `exclude_none` parameter, passed to Pydantic models to define\n            if it should exclude from the output any fields that have a `None` value.\n            \"\"\"\n        ),\n    ] = False,\n    custom_encoder: Annotated[\n        Optional[Dict[Any, Callable[[Any], Any]]],\n        Doc(\n            \"\"\"\n            Pydantic's `custom_encoder` parameter, passed to Pydantic models to define\n            a custom encoder.\n            \"\"\"\n        ),\n    ] = None,\n    sqlalchemy_safe: Annotated[\n        bool,\n        Doc(\n            \"\"\"\n            Exclude from the output any fields that start with the name `_sa`.\n\n            This is mainly a hack for compatibility with SQLAlchemy objects, they\n            store internal SQLAlchemy-specific state in attributes named with `_sa`,\n            and those objects can't (and shouldn't be) serialized to JSON.\n            \"\"\"\n        ),\n    ] = True,\n) -> Any:\n    \"\"\"\n    Convert any object to something that can be encoded in JSON.\n\n    This is used internally by FastAPI to make sure anything you return can be\n    encoded as JSON before it is sent to the client.\n\n    You can also use it yourself, for example to convert objects before saving them\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "        ),\n    ] = False,\n    custom_encoder: Annotated[\n        Optional[Dict[Any, Callable[[Any], Any]]],\n        Doc(\n            \"\"\"\n            Pydantic's `custom_encoder` parameter, passed to Pydantic models to define\n            a custom encoder.\n            \"\"\"\n        ),\n    ] = None,\n    sqlalchemy_safe: Annotated[\n        bool,\n        Doc(\n            \"\"\"\n            Exclude from the output any fields that start with the name `_sa`.\n\n            This is mainly a hack for compatibility with SQLAlchemy objects, they\n            store internal SQLAlchemy-specific state in attributes named with `_sa`,\n            and those objects can't (and shouldn't be) serialized to JSON.\n            \"\"\"\n        ),\n    ] = True,\n) -> Any:\n    \"\"\"\n    Convert any object to something that can be encoded in JSON.\n\n    This is used internally by FastAPI to make sure anything you return can be\n    encoded as JSON before it is sent to the client.\n\n    You can also use it yourself, for example to convert objects before saving them\n    in a database that supports only JSON.\n\n    Read more about it in the\n    [FastAPI docs for JSON Compatible Encoder](https://fastapi.tiangolo.com/tutorial/encoder/).\n    \"\"\"\n    custom_encoder = custom_encoder or {}\n    if custom_encoder:\n        if type(obj) in custom_encoder:\n            return custom_encoder[type(obj)](obj)\n        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    

{"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": "            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", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "model_dump(): {'custom': MyCustomType}\njsonable_encoder error: Unable to serialize unknown type: <class '__main__.MyCustomType'>\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "29:from ._compat import Url, _is_undefined, _model_dump\n235:        obj_dict = _model_dump(\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "import dataclasses\nimport datetime\nfrom collections import defaultdict, deque\nfrom decimal import Decimal\nfrom enum import Enum\nfrom ipaddress import (\n    IPv4Address,\n    IPv4Interface,\n    IPv4Network,\n    IPv6Address,\n    IPv6Interface,\n    IPv6Network,\n)\nfrom pathlib import Path, PurePath\nfrom re import Pattern\nfrom types import GeneratorType\nfrom typing import Any, Callable, Dict, List, Optional, Tuple, Type, Union\nfrom uuid import UUID\n\nfrom annotated_doc import Doc\nfrom fastapi._compat import may_v1\nfrom fastapi.types import IncEx\nfrom pydantic import BaseModel\nfrom pydantic.color import Color\nfrom pydantic.networks import AnyUrl, NameEmail\nfrom pydantic.types import SecretBytes, SecretStr\nfrom typing_extensions import Annotated\n\nfrom ._compat import Url, _is_undefined, _model_dump\n\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "from .main import BaseConfig as BaseConfig\nfrom .main import PydanticSchemaGenerationError as PydanticSchemaGenerationError\nfrom .main import RequiredParam as RequiredParam\nfrom .main import Undefined as Undefined\nfrom .main import UndefinedType as UndefinedType\nfrom .main import Url as Url\nfrom .main import Validator as Validator\nfrom .main import _get_model_config as _get_model_config\nfrom .main import _is_error_wrapper as _is_error_wrapper\nfrom .main import _is_model_class as _is_model_class\nfrom .main import _is_model_field as _is_model_field\nfrom .main import _is_undefined as _is_undefined\nfrom .main import _model_dump as _model_dump\nfrom .main import _model_rebuild as _model_rebuild\nfrom .main import copy_field_info as copy_field_info\nfrom .main import create_body_model as create_body_model\nfrom .main import evaluate_forwardref as evaluate_forwardref\nfrom .main import get_annotation_from_field_info as get_annotation_from_field_info\nfrom .main import get_cached_model_fields as get_cached_model_fields\nfrom .main import get_compat_model_name_map as get_compat_model_name_map\nfrom .main import get_definitions as get_definitions\nfrom .main import get_missing_field_error as get_missing_field_error\nfrom .main import get_schema_from_model_field as get_schema_from_model_field\nfrom .main import is_bytes_field as is_bytes_field\nfrom .main import is_bytes_sequence_field as is_bytes_sequence_field\nfrom .main import is_scalar_field as is_scalar_field\nfrom .main import is_scalar_sequence_field as is_scalar_sequence_field\nfrom .main import is_sequence_field as is_sequence_field\nfrom .main import serialize_sequence_value as serialize_sequence_value\nfrom .main import (\n    with_info_plain_validator_function as with_info_plain_validator_function,\n)\nfrom .may_v1 import CoreSchema as CoreSchema\nfrom .may_v1 import GetJsonSchemaHandler as GetJsonSchemaHandler\nfrom .may_v1 import JsonSchemaValue as JsonSchemaValue\nfrom .m

{"status": "ok", "stdout": "85:def _model_dump(\n86-    model: BaseModel, mode: Literal[\"json\", \"python\"] = \"json\", **kwargs: Any\n87-) -> Any:\n88-    if isinstance(model, may_v1.BaseModel):\n89-        from fastapi._compat import v1\n90-\n91:        return v1._model_dump(model, mode=mode, **kwargs)\n92-    elif PYDANTIC_V2:\n93-        from . import v2\n94-\n95:        return v2._model_dump(model, mode=mode, **kwargs)\n96-\n97-\n98-def _is_error_wrapper(exc: Exception) -> bool:\n99-    if isinstance(exc, may_v1.ErrorWrapper):\n100-        return True\n101-    elif PYDANTIC_V2:\n102-        from . import v2\n103-\n104-        return isinstance(exc, v2.ErrorWrapper)\n105-    return False\n106-\n107-\n108-def copy_field_info(*, field_info: FieldInfo, annotation: Any) -> FieldInfo:\n109-    if isinstance(field_info, may_v1.FieldInfo):\n110-        from fastapi._compat import v1\n111-\n112-        return v1.copy_field_info(field_info=field_info, annotation=annotation)\n113-    else:\n114-        assert PYDANTIC_V2\n115-        from . import v2\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "164:def _model_dump(\n165-    model: BaseModel, mode: Literal[\"json\", \"python\"] = \"json\", **kwargs: Any\n166-) -> Any:\n167-    return model.model_dump(mode=mode, **kwargs)\n168-\n169-\n170-def _get_model_config(model: BaseModel) -> Any:\n171-    return model.model_config\n172-\n173-\n174-def _has_computed_fields(field: ModelField) -> bool:\n175-    computed_fields = field._type_adapter.core_schema.get(\"schema\", {}).get(\n176-        \"computed_fields\", []\n177-    )\n178-    return len(computed_fields) > 0\n179-\n180-\n181-def get_schema_from_model_field(\n182-    *,\n183-    field: ModelField,\n184-    model_name_map: ModelNameMap,\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "model_dump(mode='python'): {'custom': MyCustomType}\njsonable_encoder error: Unable to serialize unknown type: <class '__main__.MyCustomType'>\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "model_dump(mode='python'): {'custom': MyCustomType}\njsonable_encoder(m.model_dump(mode='python')): {'custom': {}}\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "model_dump(mode='python'): {'custom': MyCustomType(hello)}\njsonable_encoder(m.model_dump(mode='python')): {'custom': {'value': 'hello'}}\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "model_dump(mode='python'): {'custom': MyCustomType}\nmodel_dump(mode='json') error: Unable to serialize unknown type: <class '__main__.MyCustomType'>\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "jsonable_encoder(MyCustomType()): {}\n", "stderr": "", "exit_code": 0}

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

{"status": "ok", "stdout": "jsonable_encoder(m) with mode='python': {'custom': {'value': 'hello'}}\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "jsonable_encoder(m): {'custom': {'value': 'hello'}}\njsonable_encoder(lm): {'items': [{'value': 'a'}, {'value': 'b'}]}\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", "stderr": "", "exit_code": 0}

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

{"status": "ok", "stdout": "Model: custom=MyCustomType(hello)\nEncoded: {'custom': {'value': 'hello'}}\nEncoded list: {'items': [{'value': 'hello'}, {'value': 'world'}]}\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.39s ====================\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.30s =========================\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "diff --git a/fastapi/encoders.py b/fastapi/encoders.py\nindex 79395108..ec754986 100644\n--- a/fastapi/encoders.py\n+++ b/fastapi/encoders.py\n@@ -234,7 +234,7 @@ def jsonable_encoder(\n                 encoders = {**encoders, **custom_encoder}\n         obj_dict = _model_dump(\n             obj,\n-            mode=\"json\",\n+            mode=\"python\",\n             include=include,\n             exclude=exclude,\n             by_alias=by_alias,\n", "stderr": "", "exit_code": 0}