fasthttpc 0.6.0__py3-none-any.whl

fasthttpc/__init__.py

@@ -0,0 +1,102 @@
+"""
+fasthttpc — Pure-Python HTTP istemcisi
+
+TLS 1.3 fingerprinting, Chrome/Firefox/Safari impersonation,
+async destek, akıllı connection pool ve plugin sistemi içerir.
+
+Hızlı başlangıç::
+
+    from fasthttpc import Session, Timeout
+
+    with Session(impersonate="chrome_131") as s:
+        r = s.get("https://httpbin.org/get")
+        print(r.status_code, r.elapsed)
+
+Async::
+
+    from fasthttpc import AsyncSession
+
+    async with AsyncSession() as s:
+        r = await s.get("https://httpbin.org/get")
+"""
+
+# `cryptography` alt modülleri import edilmeden ÖNCE ayarlanmalı. Bazı
+# ortamlarda (özellikle Pydroid3/Android'deki OpenSSL 3.0) legacy provider
+# yüklenemez ve import ölümcül bir RuntimeError ile patlar. fasthttpc yalnızca
+# modern algoritmalar kullanır (AES-GCM, ChaCha20-Poly1305, x25519, ECDSA,
+# RSA-PSS, Ed25519) — hiçbiri legacy provider'a ihtiyaç duymaz, dolayısıyla
+# onu devre dışı bırakmak güvenli ve gereklidir.
+import os as _os
+_os.environ.setdefault("CRYPTOGRAPHY_OPENSSL_NO_LEGACY", "1")
+
+from .session       import Session
+from .async_session import AsyncSession
+from .config        import Timeout, Limits
+from .retry         import Retry
+from .transport.mock import MockTransport, BaseTransport
+from .multipart     import encode_multipart
+from .models.response import Response, HTTPStatusError
+from .models.request  import Request
+from .models.headers  import Headers
+from .models.urls     import URL
+from .cache         import ResponseCache
+from .cookies       import CookieJar, Cookie
+from ._log          import enable_debug_logging
+from .protocol.dns_over_https import DoHResolver
+from .fingerprint   import (
+    get_profile,
+    available_profiles,
+    ja3_from_client_hello,
+    ja3_for_profile,
+)
+from .metrics       import RequestMetrics
+from .tls_tools     import (
+    TLSFragmenter,
+    TLSDowngradeDetector,
+    ClientHelloEntropyScorer,
+)
+from .async_session import ProxyRotator
+from .plugins import Plugin, RetryPlugin, LoggingPlugin, RateLimitPlugin
+from .auth import Auth, BasicAuth, BearerAuth, DigestAuth
+from ._api import USE_CLIENT_DEFAULT
+
+__version__ = "0.6.0"
+__author__  = "Buğra"
+__all__ = [
+    "Session",
+    "AsyncSession",
+    "Timeout",
+    "Limits",
+    "Retry",
+    "MockTransport",
+    "BaseTransport",
+    "encode_multipart",
+    "Response",
+    "HTTPStatusError",
+    "Request",
+    "Headers",
+    "URL",
+    "ResponseCache",
+    "CookieJar",
+    "Cookie",
+    "DoHResolver",
+    "enable_debug_logging",
+    "get_profile",
+    "available_profiles",
+    "ja3_from_client_hello",
+    "ja3_for_profile",
+    "RequestMetrics",
+    "TLSFragmenter",
+    "TLSDowngradeDetector",
+    "ClientHelloEntropyScorer",
+    "Plugin",
+    "RetryPlugin",
+    "LoggingPlugin",
+    "RateLimitPlugin",
+    "ProxyRotator",
+    "Auth",
+    "BasicAuth",
+    "BearerAuth",
+    "DigestAuth",
+    "USE_CLIENT_DEFAULT",
+]

fasthttpc/_api.py

@@ -0,0 +1,272 @@
+"""Session / AsyncSession'ın ortak, G/Ç'siz yardımcıları (requests/httpx uyumu).
+
+params birleştirme, istek düzeyi çerez/zaman aşımı, gövde kodlama, URL'deki
+``user:pass@`` ayrıştırma ve hook sözlüklerinin normalleştirilmesi burada
+durur; senkron ve asenkron oturum aynı kodu kullanır (davranış farkı olmaz).
+"""
+from __future__ import annotations
+
+import contextvars
+from http.cookies import SimpleCookie
+from typing import Any, Callable, Optional
+from urllib.parse import unquote, urlencode, urlsplit
+
+from .config import Timeout
+from .multipart import encode_multipart
+
+
+class _UseClientDefault:
+    """``auth=`` / ``timeout=`` için "oturum varsayılanını kullan" işareti (httpx ile aynı ad)."""
+
+    def __repr__(self) -> str:
+        return "USE_CLIENT_DEFAULT"
+
+
+USE_CLIENT_DEFAULT: Any = _UseClientDefault()
+
+
+# --- params -----------------------------------------------------------------
+
+def _encode_params(params) -> str:
+    if params is None:
+        return ""
+    if isinstance(params, bytes):
+        return params.decode("latin-1")
+    if isinstance(params, str):
+        return params
+    items = params.items() if hasattr(params, "items") else params
+    flat = []
+    for k, v in items:
+        if v is None:
+            continue                      # requests gibi: None → parametre yok
+        if isinstance(v, (list, tuple)):
+            flat.extend((k, x) for x in v if x is not None)
+        else:
+            flat.append((k, v))
+    return urlencode([(k, _scalar(v)) for k, v in flat])
+
+
+def _scalar(v):
+    if isinstance(v, bool):
+        return "true" if v else "false"   # httpx ile aynı
+    return v
+
+
+def merge_params(session_params, request_params) -> str:
+    """Oturum ve istek parametrelerini tek query string'e çevirir.
+
+    İkisi de sözlükse istek aynı anahtarı ezer (``None`` anahtarı kaldırır);
+    aksi hâlde sıralı birleştirilir.
+    """
+    if session_params is None:
+        return _encode_params(request_params)
+    if request_params is None:
+        return _encode_params(session_params)
+    if isinstance(session_params, dict) and isinstance(request_params, dict):
+        merged = {k: v for k, v in session_params.items()}
+        merged.update(request_params)
+        return _encode_params(merged)
+    return "&".join(p for p in (_encode_params(session_params),
+                                _encode_params(request_params)) if p)
+
+
+def apply_params(url: str, session_params, request_params) -> str:
+    """``params`` sorgusunu URL'in mevcut sorgusuna EKLER (requests gibi)."""
+    extra = merge_params(session_params, request_params)
+    if not extra:
+        return url
+    frag = ""
+    if "#" in url:
+        url, _, frag = url.partition("#")
+        frag = "#" + frag
+    sep = "&" if "?" in url else "?"
+    if url.endswith(("?", "&")):
+        sep = ""
+    return f"{url}{sep}{extra}{frag}"
+
+
+# --- URL'deki kimlik ----------------------------------------------------------
+
+def split_userinfo(url) -> "tuple[str, Optional[tuple[str, str]]]":
+    """``https://u:p@host/x`` -> (``https://host/x``, ``("u", "p")``)."""
+    username = getattr(url, "username", None)
+    if username is not None and not isinstance(url, str):      # URL nesnesi
+        creds = (username, getattr(url, "password", "") or "")
+        return str(url), (creds if any(creds) else None)
+    url = str(url)
+    netloc = urlsplit(url).netloc
+    if "@" not in netloc:
+        return url, None
+    userinfo, _, hostport = netloc.rpartition("@")
+    user, _, pw = userinfo.partition(":")
+    clean = url.replace(netloc, hostport, 1)
+    creds = (unquote(user), unquote(pw))
+    return clean, (creds if any(creds) else None)
+
+
+# --- gövde ----------------------------------------------------------------------
+
+def _has(headers: dict, name: str) -> bool:
+    return any(k.lower() == name for k in headers)
+
+
+def encode_body(data, json, files, headers: dict) -> bytes:
+    """``data/json/files`` -> bayt gövde; gerekirse Content-Type ``headers``'a eklenir."""
+    import json as jsonlib
+    if files is not None:
+        body, ct = encode_multipart(fields=data if isinstance(data, dict) else None,
+                                    files=files)
+        if not _has(headers, "content-type"):
+            headers["Content-Type"] = ct
+        return body
+    if json is not None:
+        if not _has(headers, "content-type"):
+            headers["Content-Type"] = "application/json"
+        return jsonlib.dumps(json).encode("utf-8")
+    if isinstance(data, (dict, list, tuple)):
+        if not _has(headers, "content-type"):
+            headers["Content-Type"] = "application/x-www-form-urlencoded"
+        return urlencode(data, doseq=True).encode("ascii")
+    if isinstance(data, str):
+        return data.encode("utf-8")
+    if isinstance(data, (bytes, bytearray)):
+        return bytes(data)
+    return b""
+
+
+# --- çerezler -------------------------------------------------------------------
+
+def merge_cookie_header(jar_header: str, extra) -> str:
+    """Çerez kavanozundan gelen ``Cookie`` değerine istek çerezlerini ekler (istek kazanır)."""
+    if not extra:
+        return jar_header
+    pairs: dict = {}
+    for part in (jar_header or "").split(";"):
+        k, sep, v = part.strip().partition("=")
+        if sep:
+            pairs[k] = v
+    items = extra.items() if hasattr(extra, "items") else extra
+    for k, v in items:
+        pairs[str(k)] = str(v)
+    return "; ".join(f"{k}={v}" for k, v in pairs.items())
+
+
+def parse_cookie_arg(cookies) -> "dict[str, str]":
+    """``cookies=`` (dict / (k, v) listesi / ``Cookie:`` metni) -> dict."""
+    if not cookies:
+        return {}
+    if isinstance(cookies, str):
+        sc = SimpleCookie()
+        sc.load(cookies)
+        return {k: m.value for k, m in sc.items()}
+    if hasattr(cookies, "as_dict"):
+        return dict(cookies.as_dict())
+    return {str(k): str(v) for k, v in (cookies.items() if hasattr(cookies, "items") else cookies)}
+
+
+# --- zaman aşımı -------------------------------------------------------------------
+
+def resolve_timeout(value, session_timeout: Timeout) -> Optional[Timeout]:
+    """İstek düzeyi ``timeout=`` -> Timeout; varsayılansa ``None`` (oturumunki geçerli).
+
+    float/int -> hepsi; ``(connect, read)`` ikilisi (requests); ``Timeout``;
+    ``None`` -> sınırsız (``Timeout(None)``).
+    """
+    if value is USE_CLIENT_DEFAULT:
+        return None
+    if isinstance(value, bool):
+        raise TypeError("timeout bool olamaz; saniye, (connect, read) ikilisi veya Timeout verin.")
+    if isinstance(value, Timeout):
+        return value
+    if value is None:
+        return Timeout(None)
+    if isinstance(value, (int, float)):
+        return Timeout(float(value))
+    if isinstance(value, (tuple, list)) and len(value) == 2:
+        c, r = value
+        return Timeout(session_timeout, connect=c, read=r)
+    raise TypeError(f"Geçersiz timeout değeri: {value!r}")
+
+
+_TIMEOUT_OVERRIDE: "contextvars.ContextVar[Optional[tuple]]" = contextvars.ContextVar(
+    "fasthttpc_timeout_override", default=None)
+
+
+def set_timeout_override(owner, timeout: Optional[Timeout]):
+    """İstek boyunca (iş parçacığı/görev başına) geçerli zaman aşımını ayarlar."""
+    return _TIMEOUT_OVERRIDE.set(None if timeout is None else (owner, timeout))
+
+
+def reset_timeout_override(token) -> None:
+    _TIMEOUT_OVERRIDE.reset(token)
+
+
+def effective_timeout(owner, default: Timeout) -> Timeout:
+    cur = _TIMEOUT_OVERRIDE.get()
+    return cur[1] if cur is not None and cur[0] is owner else default
+
+
+# --- hook'lar -------------------------------------------------------------------
+
+_RESPONSE_ONLY = ("response",)
+_EVENT_KEYS = ("request", "response")
+
+
+def _as_list(v) -> list:
+    if v is None:
+        return []
+    if callable(v):
+        return [v]
+    return list(v)
+
+
+def normalize_hooks(hooks, allowed=_RESPONSE_ONLY, label="hooks") -> "dict[str, list]":
+    """``{"response": fn | [fn, ...]}`` -> ``{"response": [fn, ...]}`` (anahtarlar doğrulanır)."""
+    out = {k: [] for k in allowed}
+    for k, v in (hooks or {}).items():
+        if k not in allowed:
+            raise ValueError(f"{label}: bilinmeyen olay {k!r}; geçerli: {', '.join(allowed)}")
+        out[k] = _as_list(v)
+    return out
+
+
+def normalize_event_hooks(hooks) -> "dict[str, list]":
+    return normalize_hooks(hooks, _EVENT_KEYS, "event_hooks")
+
+
+def hook_list(mapping, key: str) -> list:
+    """Canlı (mutable) hook sözlüğünden ``key`` listesini okur (callable / liste kabul)."""
+    return _as_list((mapping or {}).get(key))
+
+
+def hook_kwargs(session, timeout) -> dict:
+    """requests hook'larına geçirilen ``**kwargs`` (``timeout``, ``verify`` ...)."""
+    return {"timeout": timeout, "verify": getattr(session, "verify", True),
+            "proxies": None, "stream": False, "cert": None}
+
+
+REDIRECT_STATUSES = (301, 302, 303, 307, 308)
+
+
+def next_request(resp, method, current_url, headers, body):
+    """``allow_redirects=False`` iken ``r.next``: izlenecek yönlendirme isteği (ya da None)."""
+    from .models.request import Request
+    from .models.urls import URL
+    from .session import _resolve_location
+    if resp.status_code not in REDIRECT_STATUSES:
+        return None
+    location = resp.headers.get("location", "")
+    if not location:
+        return None
+    target = _resolve_location(URL(str(current_url)), location)
+    hdrs = {k: v for k, v in dict(headers or {}).items() if v is not None}
+    if URL(target).origin != URL(str(current_url)).origin:
+        hdrs = {k: v for k, v in hdrs.items()
+                if k.lower() not in ("authorization", "cookie", "proxy-authorization")}
+    if resp.status_code in (301, 302, 303):
+        method, body = "GET", b""
+        hdrs = {k: v for k, v in hdrs.items() if k.lower() not in ("content-type", "content-length")}
+    return Request(method, target, headers=hdrs, data=body or None)
+
+
+Hook = Callable[..., Any]