fastapi_14372

{"status": "ok", "stdout": "fastapi/param_functions.py:2221:def Depends(  # noqa: N802\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "fastapi/param_functions.py:2301:def Security(  # noqa: N802\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "        le=le,\n        min_length=min_length,\n        max_length=max_length,\n        pattern=pattern,\n        regex=regex,\n        discriminator=discriminator,\n        strict=strict,\n        multiple_of=multiple_of,\n        allow_inf_nan=allow_inf_nan,\n        max_digits=max_digits,\n        decimal_places=decimal_places,\n        example=example,\n        examples=examples,\n        openapi_examples=openapi_examples,\n        deprecated=deprecated,\n        include_in_schema=include_in_schema,\n        json_schema_extra=json_schema_extra,\n        **extra,\n    )\n\n\ndef Depends(  # noqa: N802\n    dependency: Annotated[\n        Optional[Callable[..., Any]],\n        Doc(\n            \"\"\"\n            A \"dependable\" callable (like a function).\n\n            Don't call it directly, FastAPI will call it for you, just pass the object\n            directly.\n            \"\"\"\n        ),\n    ] = None,\n    *,\n    use_cache: Annotated[\n        bool,\n        Doc(\n            \"\"\"\n            By default, after a dependency is called the first time in a request, if\n            the dependency is declared again for the rest of the request (for example\n            if the dependency is needed by several dependencies), the value will be\n            re-used for the rest of the request.\n\n            Set `use_cache` to `False` to disable this behavior and ensure the\n            dependency is called again (if declared more than once) in the same request.\n            \"\"\"\n        ),\n    ] = True,\n    scope: Annotated[\n        Union[Literal[\"function\", \"request\"], None],\n        Doc(\n            \"\"\"\n            Mainly for dependencies with `yield`, define when the dependency function\n            should start (the code before `yield`) and when it should end (the code\n            after `yield`).\n\n            * `\"function\"`: start the dependency before the *path operation function*\n                that h

{"status": "ok", "stdout": "fastapi/params.py:766:class Depends:\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "fastapi/dependencies/models.py:19:class SecurityRequirement:\nfastapi/security/oauth2.py:614:class SecurityScopes:\nfastapi/security/base.py:4:class SecurityBase:\nfastapi/params.py:773:class Security(Depends):\nfastapi/openapi/models.py:337:class SecuritySchemeType(Enum):\nfastapi/openapi/models.py:344:class SecurityBase(BaseModelWithConfig):\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "            json_schema_extra=json_schema_extra,\n            **extra,\n        )\n\n\n@dataclass\nclass Depends:\n    dependency: Optional[Callable[..., Any]] = None\n    use_cache: bool = True\n    scope: Union[Literal[\"function\", \"request\"], None] = None\n\n\n@dataclass\nclass Security(Depends):\n    scopes: Optional[Sequence[str]] = None\n", "stderr": "", "exit_code": 0}

{"status": "error", "error_type": "CommandError", "error_message": "  File \"<string>\", line 1\n    from dataclasses import dataclass; from typing import Optional, Callable, Any, Union, Literal; import collections; @dataclass\\nclass Depends:\\n    dependency: Optional[Callable[..., Any]] = None\\n    use_cache: bool = True\\n    scope: Union[Literal['function', 'request'], None] = None\\n\\n@dataclass\\nclass Security(Depends):\\n    scopes: Optional[collections.abc.Sequence[str]] = None\\n\\nd1 = Depends(dependency=lambda: 1)\\nd2 = Depends(dependency=lambda: 1)\\nprint(f'Depends hashable: {hash(d1) == hash(d2) if hash(d1) else \"No\"}')\\nprint(f'Depends in set: {len({d1, d1}) == 1}')\\n\n                                                                                                                       ^\nSyntaxError: invalid syntax\n", "details": {"stdout": "", "stderr": "  File \"<string>\", line 1\n    from dataclasses import dataclass; from typing import Optional, Callable, Any, Union, Literal; import collections; @dataclass\\nclass Depends:\\n    dependency: Optional[Callable[..., Any]] = None\\n    use_cache: bool = True\\n    scope: Union[Literal['function', 'request'], None] = None\\n\\n@dataclass\\nclass Security(Depends):\\n    scopes: Optional[collections.abc.Sequence[str]] = None\\n\\nd1 = Depends(dependency=lambda: 1)\\nd2 = Depends(dependency=lambda: 1)\\nprint(f'Depends hashable: {hash(d1) == hash(d2) if hash(d1) else \"No\"}')\\nprint(f'Depends in set: {len({d1, d1}) == 1}')\\n\n                                                                                                                       ^\nSyntaxError: invalid syntax\n", "exit_code": 1}}

{"status": "ok", "stdout": "Not hashable: unhashable type: 'Depends'\n", "stderr": "", "exit_code": 0}

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

{"status": "ok", "stdout": "d1 == d2: False\nhash(d1) == hash(d2): False\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "d1 == d2: True\nhash(d1) == hash(d2): True\n", "stderr": "", "exit_code": 0}

{"status": "ok", "filepath": "fastapi/params.py", "occurrences": 1, "strategy": "exact", "diff": "--- a/fastapi/params.py\n+++ b/fastapi/params.py\n@@ -762,13 +762,13 @@\n         )\n \n \n-@dataclass\n+@dataclass(frozen=True)\n class Depends:\n     dependency: Optional[Callable[..., Any]] = None\n     use_cache: bool = True\n     scope: Union[Literal[\"function\", \"request\"], None] = None\n \n \n-@dataclass\n+@dataclass(frozen=True)\n class Security(Depends):\n     scopes: Optional[Sequence[str]] = None\n", "is_truncated": false}

{"status": "error", "error_type": "CommandError", "error_message": "  File \"<string>\", line 1\n    from fastapi.params import Depends, Security; def d(): pass; d1 = Depends(dependency=d); d2 = Depends(dependency=d); print(f'Depends hashable: {hash(d1) == hash(d2)}'); s1 = Security(dependency=d, scopes=['a']); s2 = Security(dependency=d, scopes=['a']); print(f'Security hashable: {hash(s1) == hash(s2)}')\n                                                  ^^^\nSyntaxError: invalid syntax\n", "details": {"stdout": "", "stderr": "  File \"<string>\", line 1\n    from fastapi.params import Depends, Security; def d(): pass; d1 = Depends(dependency=d); d2 = Depends(dependency=d); print(f'Depends hashable: {hash(d1) == hash(d2)}'); s1 = Security(dependency=d, scopes=['a']); s2 = Security(dependency=d, scopes=['a']); print(f'Security hashable: {hash(s1) == hash(s2)}')\n                                                  ^^^\nSyntaxError: invalid syntax\n", "exit_code": 1}}

{"status": "ok", "stdout": "Depends hashable: True\nSecurity created\nSecurity not hashable: unhashable type: 'list'\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "Security hashable with tuple\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "Security not hashable: unhashable type: 'list'\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "2301:def Security(  # noqa: N802\n2376:        current_user: Annotated[User, Security(get_current_active_user, scopes=[\"items\"])]\n2381:    return params.Security(dependency=dependency, scopes=scopes, use_cache=use_cache)\n", "stderr": "", "exit_code": 0}

{"status": "ok", "stdout": "\ndef Security(  # noqa: N802\n    dependency: Annotated[\n        Optional[Callable[..., Any]],\n        Doc(\n            \"\"\"\n            A \"dependable\" callable (like a function).\n\n            Don't call it directly, FastAPI will call it for you, just pass the object\n            directly.\n            \"\"\"\n        ),\n    ] = None,\n    *,\n    scopes: Annotated[\n        Optional[Sequence[str]],\n        Doc(\n            \"\"\"\n            OAuth2 scopes required for the *path operation* that uses this Security\n            dependency.\n\n            The term \"scope\" comes from the OAuth2 specification, it seems to be\n            intentionally vague and interpretable. It normally refers to permissions,\n            in cases to roles.\n\n            These scopes are integrated with OpenAPI (and the API docs at `/docs`).\n            So they are visible in the OpenAPI specification.\n            )\n            \"\"\"\n        ),\n    ] = None,\n    use_cache: Annotated[\n        bool,\n        Doc(\n            \"\"\"\n            By default, after a dependency is called the first time in a request, if\n            the dependency is declared again for the rest of the request (for example\n            if the dependency is needed by several dependencies), the value will be\n            re-used for the rest of the request.\n\n            Set `use_cache` to `False` to disable this behavior and ensure the\n            dependency is called again (if declared more than once) in the same request.\n            \"\"\"\n        ),\n    ] = True,\n) -> Any:\n    \"\"\"\n    Declare a FastAPI Security dependency.\n\n    The only difference with a regular dependency is that it can declare OAuth2\n    scopes that will be integrated with OpenAPI and the automatic UI docs (by default\n    at `/docs`).\n\n    It takes a single \"dependable\" callable (like a function).\n\n    Don't call it directly, FastAPI will call it for you.\n\n    Re

{"status": "ok", "stdout": "Not hashable: unhashable type: 'list'\nSecurityFixed hashable\n", "stderr": "", "exit_code": 0}

{"status": "ok", "filepath": "fastapi/params.py", "occurrences": 1, "strategy": "exact", "diff": "--- a/fastapi/params.py\n+++ b/fastapi/params.py\n@@ -772,3 +772,7 @@\n @dataclass(frozen=True)\n class Security(Depends):\n     scopes: Optional[Sequence[str]] = None\n+\n+    def __post_init__(self):\n+        if self.scopes is not None:\n+            object.__setattr__(self, \"scopes\", tuple(self.scopes))\n", "is_truncated": false}

{"status": "ok", "stdout": "Depends hashable: True\nSecurity hashable: True\n", "stderr": "", "exit_code": 0}

{"status": "ok", "patch_size": 653, "files_changed": 1}