1
def request(
2
    method: str,
3
    url: URL | str,
4
    *,
5
    params: QueryParamTypes | None = None,
6
    content: RequestContent | None = None,
7
    data: RequestData | None = None,
8
    files: RequestFiles | None = None,
9
    json: typing.Any | None = None,
10
    headers: HeaderTypes | None = None,
11
    cookies: CookieTypes | None = None,
12
    auth: AuthTypes | None = None,
13
    proxy: ProxyTypes | None = None,
14
    timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG,
15
    follow_redirects: bool = False,
16
    verify: ssl.SSLContext | str | bool = True,
17
    trust_env: bool = True,
18
) -> Response:
19
    """
20
    Sends an HTTP request.
21

22
    **Parameters:**
23

24
    * **method** - HTTP method for the new `Request` object: `GET`, `OPTIONS`,
25
    `HEAD`, `POST`, `PUT`, `PATCH`, or `DELETE`.
26
    * **url** - URL for the new `Request` object.
27
    * **params** - *(optional)* Query parameters to include in the URL, as a
28
    string, dictionary, or sequence of two-tuples.
29
    * **content** - *(optional)* Binary content to include in the body of the
30
    request, as bytes or a byte iterator.
31
    * **data** - *(optional)* Form data to include in the body of the request,
32
    as a dictionary.
33
    * **files** - *(optional)* A dictionary of upload files to include in the
34
    body of the request.
35
    * **json** - *(optional)* A JSON serializable object to include in the body
36
    of the request.
37
    * **headers** - *(optional)* Dictionary of HTTP headers to include in the
38
    request.
39
    * **cookies** - *(optional)* Dictionary of Cookie items to include in the
40
    request.
41
    * **auth** - *(optional)* An authentication class to use when sending the
42
    request.
43
    * **proxy** - *(optional)* A proxy URL where all the traffic should be routed.
44
    * **timeout** - *(optional)* The timeout configuration to use when sending
45
    the request.
46
    * **follow_redirects** - *(optional)* Enables or disables HTTP redirects.
47
    * **verify** - *(optional)* Either `True` to use an SSL context with the
48
    default CA bundle, `False` to disable verification, or an instance of
49
    `ssl.SSLContext` to use a custom context.
50
    * **trust_env** - *(optional)* Enables or disables usage of environment
51
    variables for configuration.
52

53
    **Returns:** `Response`
54

55
    Usage:
56

57
    ```
58
    >>> import httpx
59
    >>> response = httpx.request('GET', 'https://httpbin.org/get')
60
    >>> response
61
    <Response [200 OK]>
62
    ```
63
    """
64
    with Client(
65
        cookies=cookies,
66
        proxy=proxy,
67
        verify=verify,
68
        timeout=timeout,
69
        trust_env=trust_env,
70
    ) as client:
71
        return client.request(
72
            method=method,
73
            url=url,
74
            content=content,
75
            data=data,
76
            files=files,
77
            json=json,
78
            params=params,
79
            headers=headers,
80
            auth=auth,
81
            follow_redirects=follow_redirects,
82
        )

1
def request(
2
    self,
3
    method: str,
4
    url: URL | str,
5
    *,
6
    content: RequestContent | None = None,
7
    data: RequestData | None = None,
8
    files: RequestFiles | None = None,
9
    json: typing.Any | None = None,
10
    params: QueryParamTypes | None = None,
11
    headers: HeaderTypes | None = None,
12
    cookies: CookieTypes | None = None,
13
    auth: AuthTypes | UseClientDefault | None = USE_CLIENT_DEFAULT,
14
    follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
15
    timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
16
    extensions: RequestExtensions | None = None,
17
) -> Response:
18
    """
19
    Build and send a request.
20

21
    Equivalent to:
22

23
    ```python
24
    request = client.build_request(...)
25
    response = client.send(request, ...)
26
    ```
27

28
    See `Client.build_request()`, `Client.send()` and
29
    [Merging of configuration][0] for how the various parameters
30
    are merged with client-level configuration.
31

32
    [0]: /advanced/clients/#merging-of-configuration
33
    """
34
    if cookies is not None:
35
        message = (
36
            "Setting per-request cookies=<...> is being deprecated, because "
37
            "the expected behaviour on cookie persistence is ambiguous. Set "
38
            "cookies directly on the client instance instead."
39
        )
40
        warnings.warn(message, DeprecationWarning, stacklevel=2)
41

42
    request = self.build_request(
43
        method=method,
44
        url=url,
45
        content=content,
46
        data=data,
47
        files=files,
48
        json=json,
49
        params=params,
50
        headers=headers,
51
        cookies=cookies,
52
        timeout=timeout,
53
        extensions=extensions,
54
    )
55
    return self.send(request, auth=auth, follow_redirects=follow_redirects)

1
def build_request(
2
    self,
3
    method: str,
4
    url: URL | str,
5
    *,
6
    content: RequestContent | None = None,
7
    data: RequestData | None = None,
8
    files: RequestFiles | None = None,
9
    json: typing.Any | None = None,
10
    params: QueryParamTypes | None = None,
11
    headers: HeaderTypes | None = None,
12
    cookies: CookieTypes | None = None,
13
    timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
14
    extensions: RequestExtensions | None = None,
15
) -> Request:
16
    """
17
    Build and return a request instance.
18

19
    * The `params`, `headers` and `cookies` arguments
20
    are merged with any values set on the client.
21
    * The `url` argument is merged with any `base_url` set on the client.
22

23
    See also: [Request instances][0]
24

25
    [0]: /advanced/clients/#request-instances
26
    """
27
    url = self._merge_url(url)
28
    headers = self._merge_headers(headers)
29
    cookies = self._merge_cookies(cookies)
30
    params = self._merge_queryparams(params)
31
    extensions = {} if extensions is None else extensions
32
    if "timeout" not in extensions:
33
        timeout = (
34
            self.timeout
35
            if isinstance(timeout, UseClientDefault)
36
            else Timeout(timeout)
37
        )
38
        extensions = dict(**extensions, timeout=timeout.as_dict())
39
    return Request(
40
        method,
41
        url,
42
        content=content,
43
        data=data,
44
        files=files,
45
        json=json,
46
        params=params,
47
        headers=headers,
48
        cookies=cookies,
49
        extensions=extensions,
50
    )

1
class Request:
2
    def __init__(
3
        self,
4
        method: str,
5
        url: URL | str,
6
        *,
7
        params: QueryParamTypes | None = None,
8
        headers: HeaderTypes | None = None,
9
        cookies: CookieTypes | None = None,
10
        content: RequestContent | None = None,
11
        data: RequestData | None = None,
12
        files: RequestFiles | None = None,
13
        json: typing.Any | None = None,
14
        stream: SyncByteStream | AsyncByteStream | None = None,
15
        extensions: RequestExtensions | None = None,
16
    ) -> None:
17
        self.method = method.upper()
18
        self.url = URL(url) if params is None else URL(url, params=params)
19
        self.headers = Headers(headers)
20
        self.extensions = {} if extensions is None else dict(extensions)
21

22
        if cookies:
23
            Cookies(cookies).set_cookie_header(self)
24

25
        if stream is None:
26
            content_type: str | None = self.headers.get("content-type")
27
            headers, stream = encode_request(
28
                content=content,
29
                data=data,
30
                files=files,
31
                json=json,
32
                boundary=get_multipart_boundary_from_content_type(
33
                    content_type=content_type.encode(self.headers.encoding)
34
                    if content_type
35
                    else None
36
                ),
37
            )
38
            self._prepare(headers)
39
            self.stream = stream
40
            # Load the request body, except for streaming content.
41
            if isinstance(stream, ByteStream):
42
                self.read()
43
        else:
44
            # There's an important distinction between `Request(content=...)`,
45
            # and `Request(stream=...)`.
46
            #
47
            # Using `content=...` implies automatically populated `Host` and content
48
            # headers, of either `Content-Length: ...` or `Transfer-Encoding: chunked`.
49
            #
50
            # Using `stream=...` will not automatically include *any*
51
            # auto-populated headers.
52
            #
53
            # As an end-user you don't really need `stream=...`. It's only
54
            # useful when:
55
            #
56
            # * Preserving the request stream when copying requests, eg for redirects.
57
            # * Creating request instances on the *server-side* of the transport API.
58
            self.stream = stream

1
  action = request.files.get("action")
2
  act = json.loads(action.stream.read().decode())
3
  if act["type"] == "echo":
4
     return content, 200
5
  elif act["type"] == "debug":
6
     return content.format(app), 200
7
  else:
8
     return 'unkown action', 400