Metadata-Version: 2.1
Name: httpcore
Version: 0.10.1
Summary: A minimal low-level HTTP client.
Home-page: https://github.com/encode/httpcore
Author: Tom Christie
Author-email: tom@tomchristie.com
License: BSD
Project-URL: Documentation, https://www.encode.io/httpcore
Project-URL: Source, https://github.com/encode/httpcore
Description: # HTTP Core
        
        [![Test Suite](https://github.com/encode/httpcore/workflows/Test%20Suite/badge.svg)](https://github.com/encode/httpcore/actions)
        [![Package version](https://badge.fury.io/py/httpcore.svg)](https://pypi.org/project/httpcore/)
        
        > *Do one thing, and do it well.*
        
        The HTTP Core package provides a minimal low-level HTTP client, which does
        one thing only. Sending HTTP requests.
        
        It does not provide any high level model abstractions over the API,
        does not handle redirects, multipart uploads, building authentication headers,
        transparent HTTP caching, URL parsing, session cookie handling,
        content or charset decoding, handling JSON, environment based configuration
        defaults, or any of that Jazz.
        
        Some things HTTP Core does do:
        
        * Sending HTTP requests.
        * Provides both sync and async interfaces.
        * Supports HTTP/1.1 and HTTP/2.
        * Async backend support for `asyncio` and `trio`.
        * Automatic connection pooling.
        * HTTP(S) proxy support.
        
        ## Installation
        
        For HTTP/1.1 only support, install with...
        
        ```shell
        $ pip install httpcore
        ```
        
        For HTTP/1.1 and HTTP/2 support, install with...
        
        ```shell
        $ pip install httpcore[http2]
        ```
        
        ## Quickstart
        
        Here's an example of making an HTTP GET request using `httpcore`...
        
        ```python
        async with httpcore.AsyncConnectionPool() as http:
            http_version, status_code, reason_phrase, headers, stream = await http.request(
                method=b'GET',
                url=(b'https', b'example.org', 443, b'/'),
                headers=[(b'host', b'example.org'), (b'user-agent', 'httpcore')]
            )
        
            try:
                body = b''.join([chunk async for chunk in stream])
            finally:
                await stream.aclose()
        
            print(status_code, body)
        ```
        
        ## Motivation
        
        You probably don't want to be using HTTP Core directly. It might make sense if
        you're writing something like a proxy service in Python, and you just want
        something at the lowest possible level, but more typically you'll want to use
        a higher level client library, such as `httpx`.
        
        The motivation for `httpcore` is:
        
        * To provide a reusable low-level client library, that other packages can then build on top of.
        * To provide a *really clear interface split* between the networking code and client logic,
          so that each is easier to understand and reason about in isolation.
        
        
        # Changelog
        
        All notable changes to this project will be documented in this file.
        
        The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
        
        ## 0.10.1 (August 7th, 2020)
        
        - Include `max_keepalive_connections` on `AsyncHTTPProxy`/`SyncHTTPProxy` classes.
        
        ## 0.10.0 (August 7th, 2020)
        
        The most notable change in the 0.10.0 release is that HTTP/2 support is now fully optional.
        
        Use either `pip install httpcore` for HTTP/1.1 support only, or `pip install httpcore[http2]` for HTTP/1.1 and HTTP/2 support.
        
        ### Added
        
        - HTTP/2 support becomes optional. (Pull #121, #130)
        - Add `local_address=...` support. (Pull #100, #134)
        - Add `PlainByteStream`, `IteratorByteStream`, `AsyncIteratorByteStream`. The `AsyncByteSteam` and `SyncByteStream` classes are now pure interface classes. (#133)
        - Add `LocalProtocolError`, `RemoteProtocolError` exceptions. (Pull #129)
        - Add `UnsupportedProtocol` exception. (Pull #128)
        - Add `.get_connection_info()` method. (Pull #102, #137)
        - Add better TRACE logs. (Pull #101)
        
        ### Changed
        
        - `max_keepalive` is deprecated in favour of `max_keepalive_connections`. (Pull #140)
        
        ### Fixed
        
        - Improve handling of server disconnects. (Pull #112)
        
        ## 0.9.1 (May 27th, 2020)
        
        ### Fixed
        
        - Proper host resolution for sync case, including IPv6 support. (Pull #97)
        - Close outstanding connections when connection pool is closed. (Pull #98)
        
        ## 0.9.0 (May 21th, 2020)
        
        ### Changed
        
        - URL port becomes an `Optional[int]` instead of `int`. (Pull #92)
        
        ### Fixed
        
        - Honor HTTP/2 max concurrent streams settings. (Pull #89, #90)
        - Remove incorrect debug log. (Pull #83)
        
        ## 0.8.4 (May 11th, 2020)
        
        ### Added
        
        - Logging via HTTPCORE_LOG_LEVEL and HTTPX_LOG_LEVEL environment variables
        and TRACE level logging. (Pull #79)
        
        ### Fixed
        
        - Reuse of connections on HTTP/2 in close concurrency situations. (Pull #81)
        
        ## 0.8.3 (May 6rd, 2020)
        
        ### Fixed
        
        - Include `Host` and `Accept` headers on proxy "CONNECT" requests.
        - De-duplicate any headers also contained in proxy_headers.
        - HTTP/2 flag not being passed down to proxy connections.
        
        ## 0.8.2 (May 3rd, 2020)
        
        ### Fixed
        
        - Fix connections using proxy forwarding requests not being added to the
        connection pool properly. (Pull #70)
        
        ## 0.8.1 (April 30th, 2020)
        
        ### Changed
        
        - Allow inherintance of both `httpcore.AsyncByteStream`, `httpcore.SyncByteStream` without type conflicts.
        
        ## 0.8.0 (April 30th, 2020)
        
        ### Fixed
        
        - Fixed tunnel proxy support.
        
        ### Added
        
        - New `TimeoutException` base class.
        
        ## 0.7.0 (March 5th, 2020)
        
        - First integration with HTTPX.
        
Platform: UNKNOWN
Classifier: Development Status :: 3 - Alpha
Classifier: Environment :: Web Environment
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: BSD License
Classifier: Operating System :: OS Independent
Classifier: Topic :: Internet :: WWW/HTTP
Classifier: Framework :: AsyncIO
Classifier: Framework :: Trio
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.6
Classifier: Programming Language :: Python :: 3.7
Classifier: Programming Language :: Python :: 3.8
Classifier: Programming Language :: Python :: 3 :: Only
Requires-Python: >=3.6
Description-Content-Type: text/markdown
Provides-Extra: http2
