schemathesis 3.15.4__py3-none-any.whl → 4.4.2__py3-none-any.whl

schemathesis/core/rate_limit.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+from contextlib import nullcontext
+from typing import TYPE_CHECKING, ContextManager
+from urllib.parse import urlparse
+
+from schemathesis.core.errors import InvalidRateLimit
+
+if TYPE_CHECKING:
+    from pyrate_limiter import Duration, Limiter
+
+
+def ratelimit(rate_limiter: Limiter | None, base_url: str | None) -> ContextManager:
+    """Limit the rate of sending generated requests."""
+    label = urlparse(base_url).netloc
+    if rate_limiter is not None:
+        rate_limiter.try_acquire(label)
+    return nullcontext()
+
+
+def parse_units(rate: str) -> tuple[int, int]:
+    from pyrate_limiter import Duration
+
+    try:
+        limit, interval_text = rate.split("/")
+        interval = {
+            "s": Duration.SECOND,
+            "m": Duration.MINUTE,
+            "h": Duration.HOUR,
+            "d": Duration.DAY,
+        }.get(interval_text)
+        if interval is None:
+            raise InvalidRateLimit(rate)
+        return int(limit), interval
+    except ValueError as exc:
+        raise InvalidRateLimit(rate) from exc
+
+
+def _get_max_delay(value: int, unit: Duration) -> int:
+    from pyrate_limiter import Duration
+
+    if unit == Duration.SECOND:
+        multiplier = 1
+    elif unit == Duration.MINUTE:
+        multiplier = 60
+    elif unit == Duration.HOUR:
+        multiplier = 60 * 60
+    else:
+        multiplier = 60 * 60 * 24
+    # Delay is in milliseconds + `pyrate_limiter` adds 50ms on top.
+    # Hence adding 100 covers this
+    return value * multiplier * 1000 + 100
+
+
+def build_limiter(rate: str) -> Limiter:
+    from pyrate_limiter import Limiter, Rate
+
+    limit, interval = parse_units(rate)
+    rate = Rate(limit, interval)
+    return Limiter(rate, max_delay=_get_max_delay(limit, interval))

schemathesis/core/registries.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from typing import Callable, Generic, Sequence, TypeVar, Union
+
+T = TypeVar("T", bound=Union[Callable, type])
+
+
+class Registry(Generic[T]):
+    """Container for Schemathesis extensions."""
+
+    __slots__ = ("_items",)
+
+    def __init__(self) -> None:
+        self._items: dict[str, T] = {}
+
+    def register(self, item: T) -> T:
+        self._items[item.__name__] = item
+        return item
+
+    def unregister(self, name: str) -> None:
+        del self._items[name]
+
+    def get_all_names(self) -> list[str]:
+        return list(self._items)
+
+    def get_all(self) -> list[T]:
+        return list(self._items.values())
+
+    def get_one(self, name: str) -> T:
+        return self._items[name]
+
+    def get_by_names(self, names: Sequence[str]) -> list[T]:
+        """Get items by their names."""
+        return [self._items[name] for name in names]

schemathesis/core/result.py

@@ -0,0 +1,27 @@
+from typing import Generic, TypeVar, Union
+
+T = TypeVar("T")
+E = TypeVar("E", bound=Exception)
+
+
+class Ok(Generic[T]):
+    __slots__ = ("_value",)
+
+    def __init__(self, value: T):
+        self._value = value
+
+    def ok(self) -> T:
+        return self._value
+
+
+class Err(Generic[E]):
+    __slots__ = ("_error",)
+
+    def __init__(self, error: E):
+        self._error = error
+
+    def err(self) -> E:
+        return self._error
+
+
+Result = Union[Ok[T], Err[E]]

schemathesis/core/schema_analysis.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from typing import Protocol
+
+from schemathesis.config import SchemathesisWarning
+
+
+class SchemaWarning(Protocol):
+    """Shared interface for static schema analysis warnings."""
+
+    operation_label: str
+
+    @property
+    def kind(self) -> SchemathesisWarning: ...
+
+    @property
+    def message(self) -> str: ...

schemathesis/core/shell.py

@@ -0,0 +1,203 @@
+"""Shell detection and escaping for generating reproducible curl commands."""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from enum import Enum
+
+
+class ShellType(str, Enum):
+    """Supported shell types."""
+
+    BASH = "bash"
+    ZSH = "zsh"
+    FISH = "fish"
+    UNKNOWN = "unknown"
+
+    @property
+    def supports_ansi_c_quoting(self) -> bool:
+        r"""Whether shell supports $'...\xHH' syntax."""
+        return self in (ShellType.BASH, ShellType.ZSH)
+
+    @property
+    def supports_hex_in_quotes(self) -> bool:
+        r"""Whether shell interprets \xHH in single quotes."""
+        return self == ShellType.FISH
+
+
+@dataclass(frozen=True)
+class EscapeResult:
+    """Result of escaping a value for shell."""
+
+    escaped_value: str
+    """The escaped string ready for shell."""
+
+    needs_warning: bool
+    """Whether a warning should be shown to the user."""
+
+    original_bytes: bytes | None
+    """Original bytes if warning is needed, for detailed display."""
+
+    shell_used: ShellType
+    """Which shell type the escaping is for."""
+
+    __slots__ = ("escaped_value", "needs_warning", "original_bytes", "shell_used")
+
+
+_DETECTED_SHELL: ShellType | None = None
+
+
+def detect_shell() -> ShellType:
+    """Detect the current shell type from $SHELL environment variable."""
+    global _DETECTED_SHELL
+
+    if _DETECTED_SHELL is not None:
+        return _DETECTED_SHELL
+
+    # Check $SHELL environment variable
+    shell_path = os.environ.get("SHELL", "")
+    if shell_path:
+        shell_name = os.path.basename(shell_path).lower()
+        detected = _parse_shell_name(shell_name)
+        _DETECTED_SHELL = detected
+        return detected
+
+    _DETECTED_SHELL = ShellType.UNKNOWN
+    return ShellType.UNKNOWN
+
+
+def _parse_shell_name(name: str) -> ShellType:
+    """Parse shell name string to ShellType."""
+    name_lower = name.lower()
+
+    # Check exact matches first
+    for shell_type in (ShellType.BASH, ShellType.ZSH, ShellType.FISH):
+        if shell_type.value == name_lower:
+            return shell_type
+
+    # Check substring matches
+    for shell_type in (ShellType.BASH, ShellType.ZSH, ShellType.FISH):
+        if shell_type.value in name_lower:
+            return shell_type
+
+    return ShellType.UNKNOWN
+
+
+def has_non_printable(value: str | bytes) -> bool:
+    """Check if value contains ASCII control characters."""
+    if isinstance(value, bytes):
+        try:
+            value = value.decode("utf-8")
+        except UnicodeDecodeError:
+            # Binary data that can't be decoded - treat as non-printable
+            return True
+
+    # Check for ASCII control characters: 0-31 and 127 (DEL)
+    return any(ord(c) < 32 or ord(c) == 127 for c in value)
+
+
+def escape_for_shell(value: str, shell: ShellType | None = None) -> EscapeResult:
+    """Escape value for shell use in curl commands."""
+    if shell is None:
+        shell = detect_shell()
+
+    # Fast path: no non-printable characters
+    if not has_non_printable(value):
+        return EscapeResult(
+            escaped_value=value,
+            needs_warning=False,
+            original_bytes=None,
+            shell_used=shell,
+        )
+
+    original_bytes = value.encode("utf-8")
+
+    # Bash/Zsh: Use ANSI-C quoting $'...\xHH'
+    if shell.supports_ansi_c_quoting:
+        escaped = _escape_with_ansi_c(value)
+        return EscapeResult(
+            escaped_value=f"$'{escaped}'",
+            needs_warning=False,
+            original_bytes=None,
+            shell_used=shell,
+        )
+
+    # Fish: Use \xHH in single quotes
+    if shell.supports_hex_in_quotes:
+        escaped = _escape_with_hex(value)
+        return EscapeResult(
+            escaped_value=f"'{escaped}'",
+            needs_warning=False,
+            original_bytes=None,
+            shell_used=shell,
+        )
+
+    # Unknown shell: Show bash-style with warning
+    escaped = _escape_with_ansi_c(value)
+    return EscapeResult(
+        escaped_value=f"$'{escaped}'",
+        needs_warning=True,
+        original_bytes=original_bytes,
+        shell_used=ShellType.BASH,
+    )
+
+
+def _escape_with_ansi_c(value: str) -> str:
+    """Escape string for ANSI-C quoting ($'...') used in bash/zsh."""
+    result = []
+    for char in value:
+        code = ord(char)
+
+        # Readable escapes for common control characters
+        if char == "\t":
+            result.append("\\t")
+        elif char == "\n":
+            result.append("\\n")
+        elif char == "\r":
+            result.append("\\r")
+        elif code < 32:
+            # Other control characters as hex
+            result.append(f"\\x{code:02x}")
+        elif code == 127:
+            # DEL character
+            result.append("\\x7f")
+        elif char in ("'", "\\", "$", "`"):
+            # Shell special characters that need escaping in $'...'
+            result.append(f"\\{char}")
+        else:
+            result.append(char)
+
+    return "".join(result)
+
+
+def _escape_with_hex(value: str) -> str:
+    r"""Escape string with \xHH notation for fish shell.
+
+    Fish interprets \x escapes directly in single quotes.
+    We still need to escape single quotes and backslashes.
+    """
+    result = []
+    for char in value:
+        code = ord(char)
+
+        # Readable escapes for common control characters
+        if char == "\t":
+            result.append("\\t")
+        elif char == "\n":
+            result.append("\\n")
+        elif char == "\r":
+            result.append("\\r")
+        elif code < 32 or code == 127:
+            # Control characters as hex
+            result.append(f"\\x{code:02x}")
+        elif char == "'":
+            # Escape single quote for fish
+            result.append("\\'")
+        elif char == "\\":
+            # Escape backslash
+            result.append("\\\\")
+        else:
+            result.append(char)
+
+    return "".join(result)

schemathesis/core/transforms.py

@@ -0,0 +1,144 @@
+from __future__ import annotations
+
+from typing import Any, Callable, Dict, Iterator, List, Mapping, TypeVar, Union, overload
+
+T = TypeVar("T")
+
+
+@overload
+def deepclone(value: dict) -> dict: ...  # pragma: no cover
+
+
+@overload
+def deepclone(value: list) -> list: ...  # pragma: no cover
+
+
+@overload
+def deepclone(value: T) -> T: ...  # pragma: no cover
+
+
+def deepclone(value: Any) -> Any:
+    """A specialized version of `deepcopy` that copies only `dict` and `list` and does unrolling.
+
+    It is on average 3x faster than `deepcopy` and given the amount of calls, it is an important optimization.
+    """
+    if isinstance(value, dict):
+        return {
+            k1: (
+                {
+                    k2: (
+                        {k3: deepclone(v3) for k3, v3 in v2.items()}
+                        if isinstance(v2, dict)
+                        else [deepclone(v3) for v3 in v2]
+                        if isinstance(v2, list)
+                        else v2
+                    )
+                    for k2, v2 in v1.items()
+                }
+                if isinstance(v1, dict)
+                else [deepclone(v2) for v2 in v1]
+                if isinstance(v1, list)
+                else v1
+            )
+            for k1, v1 in value.items()
+        }
+    if isinstance(value, list):
+        return [
+            {k2: deepclone(v2) for k2, v2 in v1.items()}
+            if isinstance(v1, dict)
+            else [deepclone(v2) for v2 in v1]
+            if isinstance(v1, list)
+            else v1
+            for v1 in value
+        ]
+    return value
+
+
+def diff(left: Mapping[str, Any], right: Mapping[str, Any]) -> dict[str, Any]:
+    """Calculate the difference between two dictionaries."""
+    diff = {}
+    for key, value in right.items():
+        if key not in left or left[key] != value:
+            diff[key] = value
+    return diff
+
+
+def merge_at(data: dict[str, Any], data_key: str, new: dict[str, Any]) -> None:
+    original = data[data_key] or {}
+    for key, value in new.items():
+        original[key] = value
+    data[data_key] = original
+
+
+JsonValue = Union[Dict[str, Any], List, str, float, int]
+
+
+@overload
+def transform(schema: dict[str, Any], callback: Callable, *args: Any, **kwargs: Any) -> dict[str, Any]: ...
+
+
+@overload
+def transform(schema: list, callback: Callable, *args: Any, **kwargs: Any) -> list: ...
+
+
+@overload
+def transform(schema: str, callback: Callable, *args: Any, **kwargs: Any) -> str: ...
+
+
+@overload
+def transform(schema: float, callback: Callable, *args: Any, **kwargs: Any) -> float: ...
+
+
+def transform(schema: JsonValue, callback: Callable[..., dict[str, Any]], *args: Any, **kwargs: Any) -> JsonValue:
+    """Apply callback recursively to the given schema."""
+    if isinstance(schema, dict):
+        schema = callback(schema, *args, **kwargs)
+        for key, sub_item in schema.items():
+            schema[key] = transform(sub_item, callback, *args, **kwargs)
+    elif isinstance(schema, list):
+        schema = [transform(sub_item, callback, *args, **kwargs) for sub_item in schema]
+    return schema
+
+
+class Unresolvable: ...
+
+
+UNRESOLVABLE = Unresolvable()
+
+
+def encode_pointer(pointer: str) -> str:
+    return pointer.replace("~", "~0").replace("/", "~1")
+
+
+def decode_pointer(value: str) -> str:
+    return value.replace("~1", "/").replace("~0", "~")
+
+
+def iter_decoded_pointer_segments(pointer: str) -> Iterator[str]:
+    return map(decode_pointer, pointer.split("/")[1:])
+
+
+def resolve_pointer(document: Any, pointer: str) -> dict | list | str | int | float | None | Unresolvable:
+    """Implementation is adapted from Rust's `serde-json` crate.
+
+    Ref: https://github.com/serde-rs/json/blob/master/src/value/mod.rs#L751
+    """
+    if not pointer:
+        return document
+    if not pointer.startswith("/"):
+        return UNRESOLVABLE
+
+    target = document
+    for token in iter_decoded_pointer_segments(pointer):
+        if isinstance(target, dict):
+            target = target.get(token, UNRESOLVABLE)
+            if target is UNRESOLVABLE:
+                return UNRESOLVABLE
+        elif isinstance(target, list):
+            try:
+                target = target[int(token)]
+            except (IndexError, ValueError):
+                return UNRESOLVABLE
+        else:
+            return UNRESOLVABLE
+    return target