schemathesis 3.18.5__py3-none-any.whl → 3.19.1__py3-none-any.whl

schemathesis/specs/openapi/expressions/context.py

@@ -1,12 +1,12 @@
-import attr
+from dataclasses import dataclass
 
 from ....models import Case
 from ....utils import GenericResponse
 
 
-@attr.s(slots=True)  # pragma: no mutate
+@dataclass
 class ExpressionContext:
     """Context in what an expression are evaluated."""
 
-    response: GenericResponse = attr.ib()  # pragma: no mutate
-    case: Case = attr.ib()  # pragma: no mutate
+    response: GenericResponse
+    case: Case

schemathesis/specs/openapi/expressions/lexer.py

@@ -1,26 +1,25 @@
 """Lexical analysis of runtime expressions."""
+from dataclasses import dataclass
 from enum import Enum, unique
 from typing import Callable, Generator
 
-import attr
 
-
-@unique  # pragma: no mutate
+@unique
 class TokenType(Enum):
-    VARIABLE = 1  # pragma: no mutate
-    STRING = 2  # pragma: no mutate
-    POINTER = 3  # pragma: no mutate
-    DOT = 4  # pragma: no mutate
-    LBRACKET = 5  # pragma: no mutate
-    RBRACKET = 6  # pragma: no mutate
+    VARIABLE = 1
+    STRING = 2
+    POINTER = 3
+    DOT = 4
+    LBRACKET = 5
+    RBRACKET = 6
 
 
-@attr.s(slots=True)  # pragma: no mutate
+@dataclass
 class Token:
     """Lexical token that may occur in a runtime expression."""
 
-    value: str = attr.ib()  # pragma: no mutate
-    type_: TokenType = attr.ib()  # pragma: no mutate
+    value: str
+    type_: TokenType
 
     # Helpers for cleaner instantiation
 

schemathesis/specs/openapi/expressions/nodes.py

@@ -1,8 +1,8 @@
 """Expression nodes description and evaluation logic."""
+from dataclasses import dataclass
 from enum import Enum, unique
 from typing import Any, Dict, Optional, Union
 
-import attr
 from requests.structures import CaseInsensitiveDict
 
 from ....utils import WSGIResponse
@@ -10,7 +10,7 @@ from .. import references
 from .context import ExpressionContext
 
 
-@attr.s(slots=True)  # pragma: no mutate
+@dataclass
 class Node:
     """Generic expression node."""
 
@@ -27,11 +27,11 @@ class NodeType(Enum):
     RESPONSE = "$response"
 
 
-@attr.s(slots=True)  # pragma: no mutate
+@dataclass
 class String(Node):
     """A simple string that is not evaluated somehow specifically."""
 
-    value: str = attr.ib()  # pragma: no mutate
+    value: str
 
     def evaluate(self, context: ExpressionContext) -> str:
         """String tokens are passed as they are.
@@ -43,7 +43,7 @@ class String(Node):
         return self.value
 
 
-@attr.s(slots=True)  # pragma: no mutate
+@dataclass
 class URL(Node):
     """A node for `$url` expression."""
 
@@ -51,7 +51,7 @@ class URL(Node):
         return context.case.get_full_url()
 
 
-@attr.s(slots=True)  # pragma: no mutate
+@dataclass
 class Method(Node):
     """A node for `$method` expression."""
 
@@ -59,7 +59,7 @@ class Method(Node):
         return context.case.operation.method.upper()
 
 
-@attr.s(slots=True)  # pragma: no mutate
+@dataclass
 class StatusCode(Node):
     """A node for `$statusCode` expression."""
 
@@ -67,12 +67,12 @@ class StatusCode(Node):
         return str(context.response.status_code)
 
 
-@attr.s(slots=True)  # pragma: no mutate
+@dataclass
 class NonBodyRequest(Node):
     """A node for `$request` expressions where location is not `body`."""
 
-    location: str = attr.ib()  # pragma: no mutate
-    parameter: str = attr.ib()  # pragma: no mutate
+    location: str
+    parameter: str
 
     def evaluate(self, context: ExpressionContext) -> str:
         container: Union[Dict, CaseInsensitiveDict] = {
@@ -85,11 +85,11 @@ class NonBodyRequest(Node):
         return container[self.parameter]
 
 
-@attr.s(slots=True)  # pragma: no mutate
+@dataclass
 class BodyRequest(Node):
     """A node for `$request` expressions where location is `body`."""
 
-    pointer: Optional[str] = attr.ib(default=None)  # pragma: no mutate
+    pointer: Optional[str] = None
 
     def evaluate(self, context: ExpressionContext) -> Any:
         document = context.case.body
@@ -98,21 +98,21 @@ class BodyRequest(Node):
         return references.resolve_pointer(document, self.pointer[1:])
 
 
-@attr.s(slots=True)  # pragma: no mutate
+@dataclass
 class HeaderResponse(Node):
     """A node for `$response.header` expressions."""
 
-    parameter: str = attr.ib()  # pragma: no mutate
+    parameter: str
 
     def evaluate(self, context: ExpressionContext) -> str:
         return context.response.headers[self.parameter]
 
 
-@attr.s(slots=True)  # pragma: no mutate
+@dataclass
 class BodyResponse(Node):
     """A node for `$response.body` expressions."""
 
-    pointer: Optional[str] = attr.ib(default=None)  # pragma: no mutate
+    pointer: Optional[str] = None
 
     def evaluate(self, context: ExpressionContext) -> Any:
         if isinstance(context.response, WSGIResponse):

schemathesis/specs/openapi/expressions/parser.py

@@ -5,7 +5,7 @@ from . import lexer, nodes
 from .errors import RuntimeExpressionError, UnknownToken
 
 
-@lru_cache()  # pragma: no mutate
+@lru_cache()
 def parse(expr: str) -> List[nodes.Node]:
     """Parse lexical tokens into concrete expression nodes."""
     return list(_parse(expr))

schemathesis/specs/openapi/links.py

@@ -2,11 +2,10 @@
 
 Based on https://swagger.io/docs/specification/links/
 """
+from dataclasses import dataclass, field
 from difflib import get_close_matches
 from typing import Any, Dict, Generator, List, NoReturn, Optional, Sequence, Tuple, Union
 
-import attr
-
 from ...models import APIOperation, Case
 from ...parameters import ParameterSet
 from ...stateful import Direction, ParsedData, StatefulTest
@@ -17,15 +16,14 @@ from .constants import LOCATION_TO_CONTAINER
 from .parameters import OpenAPI20Body, OpenAPI30Body, OpenAPIParameter
 
 
-@attr.s(slots=True, repr=False)  # pragma: no mutate
+@dataclass(repr=False)
 class Link(StatefulTest):
-    operation: APIOperation = attr.ib()  # pragma: no mutate
-    parameters: Dict[str, Any] = attr.ib()  # pragma: no mutate
-    request_body: Any = attr.ib(default=NOT_SET)  # pragma: no mutate
+    operation: APIOperation
+    parameters: Dict[str, Any]
+    request_body: Any = NOT_SET
 
-    @request_body.validator
-    def is_defined(self, attribute: attr.Attribute, value: Any) -> None:
-        if value is not NOT_SET and not self.operation.body:
+    def __post_init__(self) -> None:
+        if self.request_body is not NOT_SET and not self.operation.body:
             # Link defines `requestBody` for a parameter that does not accept one
             raise ValueError(
                 f"Request body is not defined in API operation {self.operation.method.upper()} {self.operation.path}"
@@ -159,21 +157,21 @@ def get_links(response: GenericResponse, operation: APIOperation, field: str) ->
     return [Link.from_definition(name, definition, operation) for name, definition in links.items()]
 
 
-@attr.s(slots=True, repr=False)  # pragma: no mutate
+@dataclass(repr=False)
 class OpenAPILink(Direction):
     """Alternative approach to link processing.
 
     NOTE. This class will replace `Link` in the future.
     """
 
-    name: str = attr.ib()  # pragma: no mutate
-    status_code: str = attr.ib()  # pragma: no mutate
-    definition: Dict[str, Any] = attr.ib()  # pragma: no mutate
-    operation: APIOperation = attr.ib()  # pragma: no mutate
-    parameters: List[Tuple[Optional[str], str, str]] = attr.ib(init=False)  # pragma: no mutate
-    body: Union[Dict[str, Any], NotSet] = attr.ib(init=False)  # pragma: no mutate
+    name: str
+    status_code: str
+    definition: Dict[str, Any]
+    operation: APIOperation
+    parameters: List[Tuple[Optional[str], str, str]] = field(init=False)
+    body: Union[Dict[str, Any], NotSet] = field(init=False)
 
-    def __attrs_post_init__(self) -> None:
+    def __post_init__(self) -> None:
         self.parameters = [
             normalize_parameter(parameter, expression)
             for parameter, expression in self.definition.get("parameters", {}).items()

schemathesis/specs/openapi/loaders.py

@@ -9,6 +9,7 @@ import jsonschema
 import requests
 import yaml
 from jsonschema import ValidationError
+from pyrate_limiter import Limiter
 from starlette.applications import Starlette
 from starlette_testclient import TestClient as ASGIClient
 from werkzeug.test import Client
@@ -18,6 +19,7 @@ from ...constants import DEFAULT_DATA_GENERATION_METHODS, WAIT_FOR_SCHEMA_INTERV
 from ...exceptions import HTTPError, SchemaLoadingError
 from ...hooks import HookContext, dispatch
 from ...lazy import LazySchema
+from ...throttling import build_limiter
 from ...types import DataGenerationMethodInput, Filter, NotSet, PathLike
 from ...utils import (
     NOT_SET,
@@ -61,6 +63,7 @@ def from_path(
     force_schema_version: Optional[str] = None,
     data_generation_methods: DataGenerationMethodInput = DEFAULT_DATA_GENERATION_METHODS,
     code_sample_style: str = CodeSampleStyle.default().name,
+    rate_limit: Optional[str] = None,
     encoding: str = "utf8",
 ) -> BaseOpenAPISchema:
     """Load Open API schema via a file from an OS path.
@@ -83,6 +86,7 @@ def from_path(
             data_generation_methods=data_generation_methods,
             code_sample_style=code_sample_style,
             location=pathlib.Path(path).absolute().as_uri(),
+            rate_limit=rate_limit,
             __expects_json=_is_json_path(path),
         )
 
@@ -103,6 +107,7 @@ def from_uri(
     data_generation_methods: DataGenerationMethodInput = DEFAULT_DATA_GENERATION_METHODS,
     code_sample_style: str = CodeSampleStyle.default().name,
     wait_for_schema: Optional[float] = None,
+    rate_limit: Optional[str] = None,
     **kwargs: Any,
 ) -> BaseOpenAPISchema:
     """Load Open API schema from the network.
@@ -110,8 +115,10 @@ def from_uri(
     :param str uri: Schema URL.
     """
     setup_headers(kwargs)
-    if not base_url and port:
-        base_url = str(URL(uri).with_port(port))
+    if port:
+        uri = str(URL(uri).with_port(port))
+        if not base_url:
+            base_url = uri
 
     if wait_for_schema is not None:
 
@@ -144,6 +151,7 @@ def from_uri(
             data_generation_methods=data_generation_methods,
             code_sample_style=code_sample_style,
             location=uri,
+            rate_limit=rate_limit,
             __expects_json=_is_json_response(response),
         )
     except SchemaLoadingError as exc:
@@ -181,6 +189,7 @@ def from_file(
     data_generation_methods: DataGenerationMethodInput = DEFAULT_DATA_GENERATION_METHODS,
     code_sample_style: str = CodeSampleStyle.default().name,
     location: Optional[str] = None,
+    rate_limit: Optional[str] = None,
     __expects_json: bool = False,
     **kwargs: Any,  # needed in the runner to have compatible API across all loaders
 ) -> BaseOpenAPISchema:
@@ -216,6 +225,7 @@ def from_file(
         data_generation_methods=data_generation_methods,
         code_sample_style=code_sample_style,
         location=location,
+        rate_limit=rate_limit,
     )
 
 
@@ -234,6 +244,7 @@ def from_dict(
     data_generation_methods: DataGenerationMethodInput = DEFAULT_DATA_GENERATION_METHODS,
     code_sample_style: str = CodeSampleStyle.default().name,
     location: Optional[str] = None,
+    rate_limit: Optional[str] = None,
 ) -> BaseOpenAPISchema:
     """Load Open API schema from a Python dictionary.
 
@@ -242,6 +253,9 @@ def from_dict(
     _code_sample_style = CodeSampleStyle.from_str(code_sample_style)
     hook_context = HookContext()
     dispatch("before_load_schema", hook_context, raw_schema)
+    rate_limiter: Optional[Limiter] = None
+    if rate_limit is not None:
+        rate_limiter = build_limiter(rate_limit)
 
     def init_openapi_2() -> SwaggerV20:
         _maybe_validate_schema(raw_schema, definitions.SWAGGER_20_VALIDATOR, validate_schema)
@@ -258,6 +272,7 @@ def from_dict(
             data_generation_methods=prepare_data_generation_methods(data_generation_methods),
             code_sample_style=_code_sample_style,
             location=location,
+            rate_limiter=rate_limiter,
         )
         dispatch("after_load_schema", hook_context, instance)
         return instance
@@ -277,6 +292,7 @@ def from_dict(
             data_generation_methods=prepare_data_generation_methods(data_generation_methods),
             code_sample_style=_code_sample_style,
             location=location,
+            rate_limiter=rate_limiter,
         )
         dispatch("after_load_schema", hook_context, instance)
         return instance
@@ -344,6 +360,7 @@ def from_pytest_fixture(
     validate_schema: bool = False,
     data_generation_methods: Union[DataGenerationMethodInput, NotSet] = NOT_SET,
     code_sample_style: str = CodeSampleStyle.default().name,
+    rate_limit: Optional[str] = None,
 ) -> LazySchema:
     """Load schema from a ``pytest`` fixture.
 
@@ -361,6 +378,9 @@ def from_pytest_fixture(
         _data_generation_methods = prepare_data_generation_methods(data_generation_methods)
     else:
         _data_generation_methods = data_generation_methods
+    rate_limiter: Optional[Limiter] = None
+    if rate_limit is not None:
+        rate_limiter = build_limiter(rate_limit)
     return LazySchema(
         fixture_name,
         app=app,
@@ -373,6 +393,7 @@ def from_pytest_fixture(
         validate_schema=validate_schema,
         data_generation_methods=_data_generation_methods,
         code_sample_style=_code_sample_style,
+        rate_limiter=rate_limiter,
     )
 
 
@@ -390,6 +411,7 @@ def from_wsgi(
     force_schema_version: Optional[str] = None,
     data_generation_methods: DataGenerationMethodInput = DEFAULT_DATA_GENERATION_METHODS,
     code_sample_style: str = CodeSampleStyle.default().name,
+    rate_limit: Optional[str] = None,
     **kwargs: Any,
 ) -> BaseOpenAPISchema:
     """Load Open API schema from a WSGI app.
@@ -416,6 +438,7 @@ def from_wsgi(
         data_generation_methods=data_generation_methods,
         code_sample_style=code_sample_style,
         location=schema_path,
+        rate_limit=rate_limit,
         __expects_json=_is_json_response(response),
     )
 
@@ -442,6 +465,7 @@ def from_aiohttp(
     force_schema_version: Optional[str] = None,
     data_generation_methods: DataGenerationMethodInput = DEFAULT_DATA_GENERATION_METHODS,
     code_sample_style: str = CodeSampleStyle.default().name,
+    rate_limit: Optional[str] = None,
     **kwargs: Any,
 ) -> BaseOpenAPISchema:
     """Load Open API schema from an AioHTTP app.
@@ -466,6 +490,7 @@ def from_aiohttp(
         force_schema_version=force_schema_version,
         data_generation_methods=data_generation_methods,
         code_sample_style=code_sample_style,
+        rate_limit=rate_limit,
         **kwargs,
     )
 
@@ -484,6 +509,7 @@ def from_asgi(
     force_schema_version: Optional[str] = None,
     data_generation_methods: DataGenerationMethodInput = DEFAULT_DATA_GENERATION_METHODS,
     code_sample_style: str = CodeSampleStyle.default().name,
+    rate_limit: Optional[str] = None,
     **kwargs: Any,
 ) -> BaseOpenAPISchema:
     """Load Open API schema from an ASGI app.
@@ -510,5 +536,6 @@ def from_asgi(
         data_generation_methods=data_generation_methods,
         code_sample_style=code_sample_style,
         location=schema_path,
+        rate_limit=rate_limit,
         __expects_json=_is_json_response(response),
     )

schemathesis/specs/openapi/negative/__init__.py

@@ -1,8 +1,8 @@
+from dataclasses import dataclass
 from functools import lru_cache
 from typing import Any, Dict, Optional, Tuple
 from urllib.parse import urlencode
 
-import attr
 import jsonschema
 from hypothesis import strategies as st
 from hypothesis_jsonschema import from_schema
@@ -12,16 +12,16 @@ from .mutations import MutationContext
 from .types import Draw, Schema
 
 
-@attr.s(slots=True, hash=False)
+@dataclass
 class CacheKey:
     """A cache key for API Operation / location.
 
     Carries the schema around but don't use it for hashing to simplify LRU cache usage.
     """
 
-    operation_name: str = attr.ib()
-    location: str = attr.ib()
-    schema: Schema = attr.ib()
+    operation_name: str
+    location: str
+    schema: Schema
 
     def __hash__(self) -> int:
         return hash((self.operation_name, self.location))

schemathesis/specs/openapi/negative/mutations.py

@@ -1,9 +1,9 @@
 """Schema mutations."""
 import enum
+from dataclasses import dataclass
 from functools import wraps
 from typing import Any, Callable, List, Optional, Sequence, Set, Tuple, TypeVar
 
-import attr
 from hypothesis import reject
 from hypothesis import strategies as st
 from hypothesis.strategies._internal.featureflags import FeatureStrategy
@@ -58,17 +58,17 @@ TYPE_SPECIFIC_KEYS = {
 }
 
 
-@attr.s(slots=True)
+@dataclass
 class MutationContext:
     """Meta information about the current mutation state."""
 
     # The original schema
-    keywords: Schema = attr.ib()  # only keywords
-    non_keywords: Schema = attr.ib()  # everything else
+    keywords: Schema  # only keywords
+    non_keywords: Schema  # everything else
     # Schema location within API operation (header, query, etc)
-    location: str = attr.ib()
+    location: str
     # Payload media type, if available
-    media_type: Optional[str] = attr.ib()
+    media_type: Optional[str]
 
     @property
     def is_header_location(self) -> bool:

schemathesis/specs/openapi/parameters.py

@@ -1,15 +1,14 @@
 import json
+from dataclasses import dataclass
 from typing import Any, ClassVar, Dict, Iterable, List, Optional, Tuple
 
-import attr
-
 from ...exceptions import InvalidSchema
 from ...models import APIOperation
 from ...parameters import Parameter
 from .converter import to_json_schema_recursive
 
 
-@attr.s(eq=False)
+@dataclass(eq=False)
 class OpenAPIParameter(Parameter):
     """A single Open API operation parameter."""
 
@@ -122,7 +121,7 @@ class OpenAPIParameter(Parameter):
         return json.dumps(self.as_json_schema(operation), sort_keys=True)
 
 
-@attr.s(eq=False)
+@dataclass(eq=False)
 class OpenAPI20Parameter(OpenAPIParameter):
     """Open API 2.0 parameter.
 
@@ -167,7 +166,7 @@ class OpenAPI20Parameter(OpenAPIParameter):
         return None
 
 
-@attr.s(eq=False)
+@dataclass(eq=False)
 class OpenAPI30Parameter(OpenAPIParameter):
     """Open API 3.0 parameter.
 
@@ -217,9 +216,9 @@ class OpenAPI30Parameter(OpenAPIParameter):
         return super().from_open_api_to_json_schema(operation, open_api_schema)
 
 
-@attr.s(eq=False)
+@dataclass(eq=False)
 class OpenAPIBody(OpenAPIParameter):
-    media_type: str = attr.ib()
+    media_type: str
 
     @property
     def location(self) -> str:
@@ -231,7 +230,7 @@ class OpenAPIBody(OpenAPIParameter):
         return "body"
 
 
-@attr.s(slots=True, eq=False)
+@dataclass(eq=False)
 class OpenAPI20Body(OpenAPIBody, OpenAPI20Parameter):
     """Open API 2.0 body variant."""
 
@@ -280,7 +279,7 @@ class OpenAPI20Body(OpenAPIBody, OpenAPI20Parameter):
 FORM_MEDIA_TYPES = ("multipart/form-data", "application/x-www-form-urlencoded")
 
 
-@attr.s(slots=True, eq=False)
+@dataclass(eq=False)
 class OpenAPI30Body(OpenAPIBody, OpenAPI30Parameter):
     """Open API 3.0 body variant.
 
@@ -290,8 +289,8 @@ class OpenAPI30Body(OpenAPIBody, OpenAPI30Parameter):
 
     # The `required` keyword is located above the schema for concrete media-type;
     # Therefore, it is passed here explicitly
-    required: bool = attr.ib(default=False)
-    description: Optional[str] = attr.ib(default=None)
+    required: bool = False
+    description: Optional[str] = None
 
     def as_json_schema(self, operation: APIOperation) -> Dict[str, Any]:
         """Convert body definition to JSON Schema."""
@@ -315,11 +314,11 @@ class OpenAPI30Body(OpenAPIBody, OpenAPI30Parameter):
         return self.required
 
 
-@attr.s(slots=True, eq=False)
+@dataclass(eq=False)
 class OpenAPI20CompositeBody(OpenAPIBody, OpenAPI20Parameter):
     """A special container to abstract over multiple `formData` parameters."""
 
-    definition: List[OpenAPI20Parameter] = attr.ib()
+    definition: List[OpenAPI20Parameter]
 
     @classmethod
     def from_parameters(cls, *parameters: Dict[str, Any], media_type: str) -> "OpenAPI20CompositeBody":

schemathesis/specs/openapi/references.py

@@ -52,11 +52,11 @@ class InliningResolver(jsonschema.RefResolver):
         )
         super().__init__(*args, **kwargs)
 
-    @overload  # pragma: no mutate
+    @overload
     def resolve_all(self, item: Dict[str, Any], recursion_level: int = 0) -> Dict[str, Any]:
         pass
 
-    @overload  # pragma: no mutate
+    @overload
     def resolve_all(self, item: List, recursion_level: int = 0) -> List:
         pass
 

schemathesis/specs/openapi/schemas.py

@@ -2,6 +2,7 @@ import itertools
 import json
 from collections import defaultdict
 from contextlib import ExitStack, contextmanager
+from dataclasses import dataclass, field
 from difflib import get_close_matches
 from hashlib import sha1
 from json import JSONDecodeError
@@ -23,7 +24,6 @@ from typing import (
 )
 from urllib.parse import urlsplit
 
-import attr
 import jsonschema
 import requests
 from hypothesis.strategies import SearchStrategy
@@ -82,24 +82,20 @@ SCHEMA_ERROR_MESSAGE = "Schema parsing failed. Please check your schema."
 SCHEMA_PARSING_ERRORS = (KeyError, AttributeError, jsonschema.exceptions.RefResolutionError)
 
 
-@attr.s(eq=False, repr=False)
+@dataclass(eq=False, repr=False)
 class BaseOpenAPISchema(BaseSchema):
-    nullable_name: str
-    links_field: str
-    header_required_field: str
-    security: BaseSecurityProcessor
-    component_locations: ClassVar[Tuple[Tuple[str, ...], ...]] = ()
-    _operations_by_id: Dict[str, APIOperation]
-    _inline_reference_cache: Dict[str, Any]
+    nullable_name: ClassVar[str] = ""
+    links_field: ClassVar[str] = ""
+    header_required_field: ClassVar[str] = ""
+    security: ClassVar[BaseSecurityProcessor] = None  # type: ignore
+    _operations_by_id: Dict[str, APIOperation] = field(init=False)
+    _inline_reference_cache: Dict[str, Any] = field(default_factory=dict)
     # Inline references cache can be populated from multiple threads, therefore we need some synchronisation to avoid
     # excessive resolving
-    _inline_reference_cache_lock: RLock
-
-    def __attrs_post_init__(self) -> None:
-        self._inline_reference_cache = {}
-        self._inline_reference_cache_lock = RLock()
+    _inline_reference_cache_lock: RLock = field(default_factory=RLock)
+    component_locations: ClassVar[Tuple[Tuple[str, ...], ...]] = ()
 
-    @property  # pragma: no mutate
+    @property
     def spec_version(self) -> str:
         raise NotImplementedError