python-proxy-headers 0.1.0__tar.gz

python_proxy_headers-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 ProxyMesh
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

python_proxy_headers-0.1.0/PKG-INFO

@@ -0,0 +1,151 @@
+Metadata-Version: 2.2
+Name: python-proxy-headers
+Version: 0.1.0
+Summary: Handle custom proxy headers for http requests in various python libraries
+Author-email: ProxyMesh <support@proxymesh.com>
+Project-URL: Homepage, https://github.com/proxymesh/python-proxy-headers
+Project-URL: Changelog, https://github.com/proxymesh/python-proxy-headers/commits/main/
+Project-URL: Issues, https://github.com/proxymesh/python-proxy-headers/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# Python Proxy Headers
+
+The `python-proxy-headers` package provides support for handling custom proxy headers when making HTTPS requests in various python modules.
+
+We currently provide extensions to the following packages:
+
+* [urllib3](https://urllib3.readthedocs.io/en/stable/)
+* [requests](https://docs.python-requests.org/en/latest/index.html)
+* [aiohttp](https://docs.aiohttp.org/en/stable/index.html)
+* [httpx](https://www.python-httpx.org/)
+
+None of these modules provide good support for parsing custom response headers from proxy servers. And some of them make it hard to send custom headers to proxy servers. So we at [ProxyMesh](https://proxymesh.com) made these extension modules to support our customers that use Python and want to use custom headers to control our proxy behavior. But these modules can work for handling custom headers with any proxy.
+
+*If you are looking for [Scrapy](https://scrapy.org/) support, please see our [scrapy-proxy-headers](https://github.com/proxymesh/scrapy-proxy-headers) project.*
+
+## Installation
+
+Examples for how to use these extension modules are described below. You must first do the following:
+
+1. `pip install python-proxy-headers`
+2. Install the appropriate package based on the python module you want to use.
+
+This package does not have any dependencies because we don't know which module you want to use.
+
+You can also find more example code in our [proxy-examples for python](https://github.com/proxymesh/proxy-examples/tree/main/python).
+
+## urllib3
+
+If you just want to send custom proxy headers, but don't need to receive proxy response headers, then you can [urllib3.ProxyManager](https://urllib3.readthedocs.io/en/stable/reference/urllib3.poolmanager.html#urllib3.ProxyManager), like so:
+
+``` python
+import urllib3
+proxy = urllib3.ProxyManager('http://PROXYHOST:PORT', proxy_headers={'X-ProxyMesh-Country': 'US'})
+r = proxy.request('GET', 'https://api.ipify.org?format=json')
+```
+
+Note that when using this method, if you keep reusing the same `ProxyManager` instance, you may be re-using the proxy connection, which may have different behavior than if you create a new proxy connection for each request. For example, with ProxyMesh you may keep getting the same IP address if you reuse the proxy connection.
+
+To get proxy response headers, use our extension module like this:
+
+``` python
+from python_proxy_headers import urllib3_proxy_manager
+proxy = urllib3_proxy_manager.ProxyHeaderManager('http://PROXYHOST:PORT')
+r = proxy.request('GET', 'https://api.ipify.org?format=json')
+r.headers['X-ProxyMesh-IP']
+```
+
+You can also pass `proxy_headers` into our `ProxyHeaderManager` as well. For example, you can pass back the same `X-ProxyMesh-IP` header to ensure you get the same IP address on subsequent requests.
+
+## requests
+
+The requests adapter builds on our `urllib3_proxy_manager` module to make it easy to pass in proxy headers and receive proxy response headers.
+
+``` python
+from python_proxy_headers import requests_adapter
+r = requests_adapter.get('https://api.ipify.org?format=json', proxies={'http': 'http://PROXYHOST:PORT', 'https': 'http://PROXYHOST:PORT'}, proxy_headers={'X-ProxyMesh-Country': 'US'})
+r.headers['X-ProxyMesh-IP']
+```
+
+The `requests_adapter` module supports all the standard requests methods: `get`, `post`, `put`, `delete`, etc.
+
+## aiohttp
+
+While it's not documented, aiohttp does support passing in custom proxy headers by default.
+
+``` python
+import aiohttp
+async with aiohttp.ClientSession() as session:
+	async with session.get('https://api.ipify.org?format=json', proxy="http://PROXYHOST:PORT", proxy_headers={'X-ProxyMesh-Country': 'US'}) as r:
+		await r.text()
+```
+
+However, if you want to get proxy response, you should use our extension module:
+
+``` python
+from python_proxy_headers import aiohttp_proxy
+async with aiohttp_proxy.ProxyClientSession() as session:
+	async with session.get('https://api.ipify.org?format=json', proxy="http://PROXYHOST:PORT", proxy_headers={'X-ProxyMesh-Country': 'US'}) as r:
+		await r.text()
+
+r.headers['X-ProxyMesh-IP']
+```
+
+## httpx
+
+httpx also supports proxy headers by default, though it's not documented:
+
+``` python
+import httpx
+proxy = httpx.Proxy('http://PROXYHOST:PORT', headers={'X-ProxyMesh-Country': 'US'})
+transport = HTTPProxyTransport(proxy=proxy)
+with httpx.Client(mounts={'http://': transort, 'https://': transport}) as client:
+	r = client.get('https://api.ipify.org?format=json')
+```
+
+But to get the response headers, you need to use our extension module:
+
+``` python
+import httpx
+from python_proxy_headers.httpx_proxy import HTTPProxyTransport
+proxy = httpx.Proxy('http://PROXYHOST:PORT', headers={'X-ProxyMesh-Country': 'US'})
+transport = HTTPProxyTransport(proxy=proxy)
+with httpx.Client(mounts={'http://': transort, 'https://': transport}) as client:
+	r = client.get('https://api.ipify.org?format=json')
+
+r.headers['X-ProxyMesh-IP']
+```
+
+This module also provide helper methods similar to requests:
+
+``` python
+import httpx
+from python_proxy_headers import httpx_proxy
+proxy = httpx.Proxy('http://PROXYHOST:PORT', headers={'X-ProxyMesh-Country': 'US'})
+r = httpx_proxy.get('https://api.ipify.org?format=json', proxy=proxy)
+r.headers['X-ProxyMesh-IP']
+```
+
+And finally, httpx supports async requests, so we provide an async extension too:
+
+``` python
+import httpx
+from python_proxy_headers.httpx_proxy import AsyncHTTPProxyTransport
+proxy = httpx.Proxy('http://PROXYHOST:PORT', headers={'X-ProxyMesh-Country': 'US'})
+transport = AsyncHTTPProxyTransport(proxy=proxy)
+async with httpx.AsyncClient(mounts={'http://': transport, 'https://': transport}) as client:
+	r = await client.get('https://api.ipify.org?format=json')
+
+r.headers['X-ProxyMesh-IP']
+```
+
+Our httpx helper module internally provides extension classes for [httpcore](https://www.encode.io/httpcore/), for handling proxy headers over tunnel connections.
+You can use those classes if you're building on top of httpcore.

python_proxy_headers-0.1.0/README.md

@@ -0,0 +1,133 @@
+# Python Proxy Headers
+
+The `python-proxy-headers` package provides support for handling custom proxy headers when making HTTPS requests in various python modules.
+
+We currently provide extensions to the following packages:
+
+* [urllib3](https://urllib3.readthedocs.io/en/stable/)
+* [requests](https://docs.python-requests.org/en/latest/index.html)
+* [aiohttp](https://docs.aiohttp.org/en/stable/index.html)
+* [httpx](https://www.python-httpx.org/)
+
+None of these modules provide good support for parsing custom response headers from proxy servers. And some of them make it hard to send custom headers to proxy servers. So we at [ProxyMesh](https://proxymesh.com) made these extension modules to support our customers that use Python and want to use custom headers to control our proxy behavior. But these modules can work for handling custom headers with any proxy.
+
+*If you are looking for [Scrapy](https://scrapy.org/) support, please see our [scrapy-proxy-headers](https://github.com/proxymesh/scrapy-proxy-headers) project.*
+
+## Installation
+
+Examples for how to use these extension modules are described below. You must first do the following:
+
+1. `pip install python-proxy-headers`
+2. Install the appropriate package based on the python module you want to use.
+
+This package does not have any dependencies because we don't know which module you want to use.
+
+You can also find more example code in our [proxy-examples for python](https://github.com/proxymesh/proxy-examples/tree/main/python).
+
+## urllib3
+
+If you just want to send custom proxy headers, but don't need to receive proxy response headers, then you can [urllib3.ProxyManager](https://urllib3.readthedocs.io/en/stable/reference/urllib3.poolmanager.html#urllib3.ProxyManager), like so:
+
+``` python
+import urllib3
+proxy = urllib3.ProxyManager('http://PROXYHOST:PORT', proxy_headers={'X-ProxyMesh-Country': 'US'})
+r = proxy.request('GET', 'https://api.ipify.org?format=json')
+```
+
+Note that when using this method, if you keep reusing the same `ProxyManager` instance, you may be re-using the proxy connection, which may have different behavior than if you create a new proxy connection for each request. For example, with ProxyMesh you may keep getting the same IP address if you reuse the proxy connection.
+
+To get proxy response headers, use our extension module like this:
+
+``` python
+from python_proxy_headers import urllib3_proxy_manager
+proxy = urllib3_proxy_manager.ProxyHeaderManager('http://PROXYHOST:PORT')
+r = proxy.request('GET', 'https://api.ipify.org?format=json')
+r.headers['X-ProxyMesh-IP']
+```
+
+You can also pass `proxy_headers` into our `ProxyHeaderManager` as well. For example, you can pass back the same `X-ProxyMesh-IP` header to ensure you get the same IP address on subsequent requests.
+
+## requests
+
+The requests adapter builds on our `urllib3_proxy_manager` module to make it easy to pass in proxy headers and receive proxy response headers.
+
+``` python
+from python_proxy_headers import requests_adapter
+r = requests_adapter.get('https://api.ipify.org?format=json', proxies={'http': 'http://PROXYHOST:PORT', 'https': 'http://PROXYHOST:PORT'}, proxy_headers={'X-ProxyMesh-Country': 'US'})
+r.headers['X-ProxyMesh-IP']
+```
+
+The `requests_adapter` module supports all the standard requests methods: `get`, `post`, `put`, `delete`, etc.
+
+## aiohttp
+
+While it's not documented, aiohttp does support passing in custom proxy headers by default.
+
+``` python
+import aiohttp
+async with aiohttp.ClientSession() as session:
+	async with session.get('https://api.ipify.org?format=json', proxy="http://PROXYHOST:PORT", proxy_headers={'X-ProxyMesh-Country': 'US'}) as r:
+		await r.text()
+```
+
+However, if you want to get proxy response, you should use our extension module:
+
+``` python
+from python_proxy_headers import aiohttp_proxy
+async with aiohttp_proxy.ProxyClientSession() as session:
+	async with session.get('https://api.ipify.org?format=json', proxy="http://PROXYHOST:PORT", proxy_headers={'X-ProxyMesh-Country': 'US'}) as r:
+		await r.text()
+
+r.headers['X-ProxyMesh-IP']
+```
+
+## httpx
+
+httpx also supports proxy headers by default, though it's not documented:
+
+``` python
+import httpx
+proxy = httpx.Proxy('http://PROXYHOST:PORT', headers={'X-ProxyMesh-Country': 'US'})
+transport = HTTPProxyTransport(proxy=proxy)
+with httpx.Client(mounts={'http://': transort, 'https://': transport}) as client:
+	r = client.get('https://api.ipify.org?format=json')
+```
+
+But to get the response headers, you need to use our extension module:
+
+``` python
+import httpx
+from python_proxy_headers.httpx_proxy import HTTPProxyTransport
+proxy = httpx.Proxy('http://PROXYHOST:PORT', headers={'X-ProxyMesh-Country': 'US'})
+transport = HTTPProxyTransport(proxy=proxy)
+with httpx.Client(mounts={'http://': transort, 'https://': transport}) as client:
+	r = client.get('https://api.ipify.org?format=json')
+
+r.headers['X-ProxyMesh-IP']
+```
+
+This module also provide helper methods similar to requests:
+
+``` python
+import httpx
+from python_proxy_headers import httpx_proxy
+proxy = httpx.Proxy('http://PROXYHOST:PORT', headers={'X-ProxyMesh-Country': 'US'})
+r = httpx_proxy.get('https://api.ipify.org?format=json', proxy=proxy)
+r.headers['X-ProxyMesh-IP']
+```
+
+And finally, httpx supports async requests, so we provide an async extension too:
+
+``` python
+import httpx
+from python_proxy_headers.httpx_proxy import AsyncHTTPProxyTransport
+proxy = httpx.Proxy('http://PROXYHOST:PORT', headers={'X-ProxyMesh-Country': 'US'})
+transport = AsyncHTTPProxyTransport(proxy=proxy)
+async with httpx.AsyncClient(mounts={'http://': transport, 'https://': transport}) as client:
+	r = await client.get('https://api.ipify.org?format=json')
+
+r.headers['X-ProxyMesh-IP']
+```
+
+Our httpx helper module internally provides extension classes for [httpcore](https://www.encode.io/httpcore/), for handling proxy headers over tunnel connections.
+You can use those classes if you're building on top of httpcore.

python_proxy_headers-0.1.0/pyproject.toml

@@ -0,0 +1,26 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "python-proxy-headers"
+version = "0.1.0"
+authors = [
+  { name="ProxyMesh", email="support@proxymesh.com" },
+]
+description = "Handle custom proxy headers for http requests in various python libraries"
+readme = "README.md"
+requires-python = ">=3.8"
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Operating System :: OS Independent",
+	"License :: OSI Approved :: BSD License",
+	"Intended Audience :: Developers",
+	"Topic :: Internet :: WWW/HTTP",
+  "Topic :: Software Development :: Libraries :: Python Modules",
+]
+
+[project.urls]
+Homepage = "https://github.com/proxymesh/python-proxy-headers"
+Changelog = "https://github.com/proxymesh/python-proxy-headers/commits/main/"
+Issues = "https://github.com/proxymesh/python-proxy-headers/issues"

python_proxy_headers-0.1.0/python_proxy_headers/aiohttp_proxy.py

@@ -0,0 +1,159 @@
+from http import HTTPStatus
+from aiohttp.client_reqrep import ClientRequest, ClientResponse
+from aiohttp.connector import TCPConnector, Connection
+from aiohttp.client_exceptions import ClientHttpProxyError, ClientProxyConnectionError
+from aiohttp.client import ClientSession
+from aiohttp.helpers import reify
+from aiohttp import hdrs
+from multidict import CIMultiDict, CIMultiDictProxy
+
+class ProxyTCPConnector(TCPConnector):
+	async def _create_proxy_connection(self, req: ClientRequest, traces, timeout):
+		self._fail_on_no_start_tls(req)
+		runtime_has_start_tls = self._loop_supports_start_tls()
+
+		headers = {}
+		if req.proxy_headers is not None:
+			headers = req.proxy_headers  # type: ignore[assignment]
+		headers[hdrs.HOST] = req.headers[hdrs.HOST]
+
+		url = req.proxy
+		assert url is not None
+		proxy_req = ClientRequest(
+			hdrs.METH_GET,
+			url,
+			headers=headers,
+			auth=req.proxy_auth,
+			loop=self._loop,
+			ssl=req.ssl,
+		)
+
+		# create connection to proxy server
+		transport, proto = await self._create_direct_connection(
+			proxy_req, [], timeout, client_error=ClientProxyConnectionError
+		)
+
+		auth = proxy_req.headers.pop(hdrs.AUTHORIZATION, None)
+		if auth is not None:
+			if not req.is_ssl():
+				req.headers[hdrs.PROXY_AUTHORIZATION] = auth
+			else:
+				proxy_req.headers[hdrs.PROXY_AUTHORIZATION] = auth
+
+		if req.is_ssl():
+			if runtime_has_start_tls:
+				self._warn_about_tls_in_tls(transport, req)
+
+			# For HTTPS requests over HTTP proxy
+			# we must notify proxy to tunnel connection
+			# so we send CONNECT command:
+			#   CONNECT www.python.org:443 HTTP/1.1
+			#   Host: www.python.org
+			#
+			# next we must do TLS handshake and so on
+			# to do this we must wrap raw socket into secure one
+			# asyncio handles this perfectly
+			proxy_req.method = hdrs.METH_CONNECT
+			proxy_req.url = req.url
+			key = req.connection_key._replace(
+				proxy=None, proxy_auth=None, proxy_headers_hash=None
+			)
+			conn = Connection(self, key, proto, self._loop)
+			proxy_resp = await proxy_req.send(conn)
+			try:
+				protocol = conn._protocol
+				assert protocol is not None
+
+				# read_until_eof=True will ensure the connection isn't closed
+				# once the response is received and processed allowing
+				# START_TLS to work on the connection below.
+				protocol.set_response_params(
+					read_until_eof=runtime_has_start_tls,
+					timeout_ceil_threshold=self._timeout_ceil_threshold,
+				)
+				resp = await proxy_resp.start(conn)
+			except BaseException:
+				proxy_resp.close()
+				conn.close()
+				raise
+			else:
+				conn._protocol = None
+				try:
+					if resp.status != 200:
+						message = resp.reason
+						if message is None:
+							message = HTTPStatus(resp.status).phrase
+						raise ClientHttpProxyError(
+							proxy_resp.request_info,
+							resp.history,
+							status=resp.status,
+							message=message,
+							headers=resp.headers,
+						)
+					if not runtime_has_start_tls:
+						rawsock = transport.get_extra_info("socket", default=None)
+						if rawsock is None:
+							raise RuntimeError(
+								"Transport does not expose socket instance"
+							)
+						# Duplicate the socket, so now we can close proxy transport
+						rawsock = rawsock.dup()
+				except BaseException:
+					# It shouldn't be closed in `finally` because it's fed to
+					# `loop.start_tls()` and the docs say not to touch it after
+					# passing there.
+					transport.close()
+					raise
+				finally:
+					if not runtime_has_start_tls:
+						transport.close()
+
+				# TODO: try adding resp.headers to the proto returned as 2nd tuple element below
+				if not runtime_has_start_tls:
+					# HTTP proxy with support for upgrade to HTTPS
+					sslcontext = self._get_ssl_context(req)
+					transport, proto = await self._wrap_existing_connection(
+						self._factory,
+						timeout=timeout,
+						ssl=sslcontext,
+						sock=rawsock,
+						server_hostname=req.host,
+						req=req,
+					)
+
+				transport, proto = await self._start_tls_connection(
+					# Access the old transport for the last time before it's
+					# closed and forgotten forever:
+					transport,
+					req=req,
+					timeout=timeout,
+				)
+			finally:
+				proxy_resp.close()
+
+			proto._proxy_headers = resp.headers
+		return transport, proto
+
+
+class ProxyClientRequest(ClientRequest):
+	async def send(self, conn):
+		resp = await super().send(conn)
+		if hasattr(conn.protocol, '_proxy_headers'):
+			resp._proxy_headers = conn.protocol._proxy_headers
+		return resp
+
+class ProxyClientResponse(ClientResponse):
+	@reify
+	def headers(self):
+		proxy_headers = getattr(self, '_proxy_headers', None)
+
+		if proxy_headers:
+			headers = CIMultiDict(self._headers)
+			headers.extend(proxy_headers)
+			return CIMultiDictProxy(headers)
+		else:
+			return self._headers
+
+class ProxyClientSession(ClientSession):
+	def __init__(self, *args, **kwargs):
+		super().__init__(connector=ProxyTCPConnector(), response_class=ProxyClientResponse,request_class=ProxyClientRequest, *args, **kwargs)

python_proxy_headers-0.1.0/python_proxy_headers/httpx_proxy.py

@@ -0,0 +1,376 @@
+from contextlib import contextmanager
+from httpcore._sync.http_proxy import HTTPProxy, TunnelHTTPConnection, merge_headers, logger
+from httpcore._sync.http11 import HTTP11Connection
+from httpcore._async.http_proxy import AsyncHTTPProxy, AsyncTunnelHTTPConnection
+from httpcore._async.http11 import AsyncHTTP11Connection
+from httpcore._models import URL, Request
+from httpcore._exceptions import ProxyError
+from httpcore._ssl import default_ssl_context
+from httpcore._trace import Trace
+from httpx import AsyncHTTPTransport, HTTPTransport, Client
+from httpx._config import DEFAULT_LIMITS, DEFAULT_TIMEOUT_CONFIG, Proxy, create_ssl_context
+
+class ProxyTunnelHTTPConnection(TunnelHTTPConnection):
+	# Unfortunately the only way to get connect_response.headers into the Response
+	# is to override this whole method
+	def handle_request(self, request):
+		timeouts = request.extensions.get("timeout", {})
+		timeout = timeouts.get("connect", None)
+
+		with self._connect_lock:
+			if not self._connected:
+				target = b"%b:%d" % (self._remote_origin.host, self._remote_origin.port)
+
+				connect_url = URL(
+					scheme=self._proxy_origin.scheme,
+					host=self._proxy_origin.host,
+					port=self._proxy_origin.port,
+					target=target,
+				)
+				connect_headers = merge_headers(
+					[(b"Host", target), (b"Accept", b"*/*")], self._proxy_headers
+				)
+				connect_request = Request(
+					method=b"CONNECT",
+					url=connect_url,
+					headers=connect_headers,
+					extensions=request.extensions,
+				)
+				connect_response = self._connection.handle_request(
+					connect_request
+				)
+
+				if connect_response.status < 200 or connect_response.status > 299:
+					reason_bytes = connect_response.extensions.get("reason_phrase", b"")
+					reason_str = reason_bytes.decode("ascii", errors="ignore")
+					msg = "%d %s" % (connect_response.status, reason_str)
+					self._connection.close()
+					raise ProxyError(msg)
+
+				stream = connect_response.extensions["network_stream"]
+
+				# Upgrade the stream to SSL
+				ssl_context = (
+					default_ssl_context()
+					if self._ssl_context is None
+					else self._ssl_context
+				)
+				alpn_protocols = ["http/1.1", "h2"] if self._http2 else ["http/1.1"]
+				ssl_context.set_alpn_protocols(alpn_protocols)
+
+				kwargs = {
+					"ssl_context": ssl_context,
+					"server_hostname": self._remote_origin.host.decode("ascii"),
+					"timeout": timeout,
+				}
+				with Trace("start_tls", logger, request, kwargs) as trace:
+					stream = stream.start_tls(**kwargs)
+					trace.return_value = stream
+
+				# Determine if we should be using HTTP/1.1 or HTTP/2
+				ssl_object = stream.get_extra_info("ssl_object")
+				http2_negotiated = (
+					ssl_object is not None
+					and ssl_object.selected_alpn_protocol() == "h2"
+				)
+
+				# Create the HTTP/1.1 or HTTP/2 connection
+				if http2_negotiated or (self._http2 and not self._http1):
+					from httpcore._sync.http2 import HTTP2Connection
+
+					self._connection = HTTP2Connection(
+						origin=self._remote_origin,
+						stream=stream,
+						keepalive_expiry=self._keepalive_expiry,
+					)
+				else:
+					self._connection = HTTP11Connection(
+						origin=self._remote_origin,
+						stream=stream,
+						keepalive_expiry=self._keepalive_expiry,
+					)
+
+				self._connected = True
+		# this is the only modification
+		response = self._connection.handle_request(request)
+		response.headers = merge_headers(response.headers, connect_response.headers)
+		return response
+
+class AsyncProxyTunnelHTTPConnection(AsyncTunnelHTTPConnection):
+	async def handle_async_request(self, request):
+		timeouts = request.extensions.get("timeout", {})
+		timeout = timeouts.get("connect", None)
+
+		async with self._connect_lock:
+			if not self._connected:
+				target = b"%b:%d" % (self._remote_origin.host, self._remote_origin.port)
+
+				connect_url = URL(
+					scheme=self._proxy_origin.scheme,
+					host=self._proxy_origin.host,
+					port=self._proxy_origin.port,
+					target=target,
+				)
+				connect_headers = merge_headers(
+					[(b"Host", target), (b"Accept", b"*/*")], self._proxy_headers
+				)
+				connect_request = Request(
+					method=b"CONNECT",
+					url=connect_url,
+					headers=connect_headers,
+					extensions=request.extensions,
+				)
+				connect_response = await self._connection.handle_async_request(
+					connect_request
+				)
+
+				if connect_response.status < 200 or connect_response.status > 299:
+					reason_bytes = connect_response.extensions.get("reason_phrase", b"")
+					reason_str = reason_bytes.decode("ascii", errors="ignore")
+					msg = "%d %s" % (connect_response.status, reason_str)
+					await self._connection.aclose()
+					raise ProxyError(msg)
+
+				stream = connect_response.extensions["network_stream"]
+
+				# Upgrade the stream to SSL
+				ssl_context = (
+					default_ssl_context()
+					if self._ssl_context is None
+					else self._ssl_context
+				)
+				alpn_protocols = ["http/1.1", "h2"] if self._http2 else ["http/1.1"]
+				ssl_context.set_alpn_protocols(alpn_protocols)
+
+				kwargs = {
+					"ssl_context": ssl_context,
+					"server_hostname": self._remote_origin.host.decode("ascii"),
+					"timeout": timeout,
+				}
+				async with Trace("start_tls", logger, request, kwargs) as trace:
+					stream = await stream.start_tls(**kwargs)
+					trace.return_value = stream
+
+				# Determine if we should be using HTTP/1.1 or HTTP/2
+				ssl_object = stream.get_extra_info("ssl_object")
+				http2_negotiated = (
+					ssl_object is not None
+					and ssl_object.selected_alpn_protocol() == "h2"
+				)
+
+				# Create the HTTP/1.1 or HTTP/2 connection
+				if http2_negotiated or (self._http2 and not self._http1):
+					from httpcore._async.http2 import AsyncHTTP2Connection
+
+					self._connection = AsyncHTTP2Connection(
+						origin=self._remote_origin,
+						stream=stream,
+						keepalive_expiry=self._keepalive_expiry,
+					)
+				else:
+					self._connection = AsyncHTTP11Connection(
+						origin=self._remote_origin,
+						stream=stream,
+						keepalive_expiry=self._keepalive_expiry,
+					)
+
+				self._connected = True
+		# this is the only modification
+		response = await self._connection.handle_async_request(request)
+		response.headers = merge_headers(response.headers, connect_response.headers)
+		return response
+
+class HTTPProxyHeaders(HTTPProxy):
+	def create_connection(self, origin):
+		if origin.scheme == b"http":
+			return super().create_connection(origin)
+		return ProxyTunnelHTTPConnection(
+			proxy_origin=self._proxy_url.origin,
+			proxy_headers=self._proxy_headers,
+			remote_origin=origin,
+			ssl_context=self._ssl_context,
+			proxy_ssl_context=self._proxy_ssl_context,
+			keepalive_expiry=self._keepalive_expiry,
+			http1=self._http1,
+			http2=self._http2,
+			network_backend=self._network_backend,
+		)
+
+class AsyncHTTPProxyHeaders(AsyncHTTPProxy):
+	def create_connection(self, origin):
+		if origin.scheme == b"http":
+			return super().create_connection(origin)
+		return AsyncProxyTunnelHTTPConnection(
+			proxy_origin=self._proxy_url.origin,
+			proxy_headers=self._proxy_headers,
+			remote_origin=origin,
+			ssl_context=self._ssl_context,
+			proxy_ssl_context=self._proxy_ssl_context,
+			keepalive_expiry=self._keepalive_expiry,
+			http1=self._http1,
+			http2=self._http2,
+			network_backend=self._network_backend,
+		)
+
+# class ProxyConnectionPool(ConnectionPool):
+# 	def create_connection(self, origin):
+# 		if self._proxy is not None:
+# 			if self._proxy.url.scheme in (b"socks5", b"socks5h"):
+# 				return super().create_connection(origin)
+# 			elif origin.scheme == b"http":
+# 				return super().create_connection(origin)
+			
+# 			return ProxyTunnelHTTPConnection(
+# 				proxy_origin=self._proxy.url.origin,
+# 				proxy_headers=self._proxy.headers,
+# 				proxy_ssl_context=self._proxy.ssl_context,
+# 				remote_origin=origin,
+# 				ssl_context=self._ssl_context,
+# 				keepalive_expiry=self._keepalive_expiry,
+# 				http1=self._http1,
+# 				http2=self._http2,
+# 				network_backend=self._network_backend,
+# 			)
+
+# 		return super().create_connection(origin)
+
+class HTTPProxyTransport(HTTPTransport):
+	def __init__(
+		self,
+		verify = True,
+		cert = None,
+		trust_env: bool = True,
+		http1: bool = True,
+		http2: bool = False,
+		limits = DEFAULT_LIMITS,
+		proxy = None,
+		uds: str | None = None,
+		local_address: str | None = None,
+		retries: int = 0,
+		socket_options = None,
+	) -> None:
+		proxy = Proxy(url=proxy) if isinstance(proxy, (str, URL)) else proxy
+		ssl_context = create_ssl_context(verify=verify, cert=cert, trust_env=trust_env)
+
+		if proxy and proxy.url.scheme in ("http", "https"):
+			self._pool = HTTPProxyHeaders(
+				proxy_url=URL(
+					scheme=proxy.url.raw_scheme,
+					host=proxy.url.raw_host,
+					port=proxy.url.port,
+					target=proxy.url.raw_path,
+				),
+				proxy_auth=proxy.raw_auth,
+				proxy_headers=proxy.headers.raw,
+				ssl_context=ssl_context,
+				proxy_ssl_context=proxy.ssl_context,
+				max_connections=limits.max_connections,
+				max_keepalive_connections=limits.max_keepalive_connections,
+				keepalive_expiry=limits.keepalive_expiry,
+				http1=http1,
+				http2=http2,
+				socket_options=socket_options,
+			)
+		else:
+			super().__init__(verify, cert, trust_env, http1, http2, limits, proxy, uds, local_address, retries, socket_options)
+
+class AsyncHTTPProxyTransport(AsyncHTTPTransport):
+	def __init__(
+		self,
+		verify = True,
+		cert = None,
+		trust_env: bool = True,
+		http1: bool = True,
+		http2: bool = False,
+		limits = DEFAULT_LIMITS,
+		proxy = None,
+		uds: str | None = None,
+		local_address: str | None = None,
+		retries: int = 0,
+		socket_options = None,
+	) -> None:
+		proxy = Proxy(url=proxy) if isinstance(proxy, (str, URL)) else proxy
+		ssl_context = create_ssl_context(verify=verify, cert=cert, trust_env=trust_env)
+
+		if proxy and proxy.url.scheme in ("http", "https"):
+			self._pool = AsyncHTTPProxyHeaders(
+				proxy_url=URL(
+					scheme=proxy.url.raw_scheme,
+					host=proxy.url.raw_host,
+					port=proxy.url.port,
+					target=proxy.url.raw_path,
+				),
+				proxy_auth=proxy.raw_auth,
+				proxy_headers=proxy.headers.raw,
+				proxy_ssl_context=proxy.ssl_context,
+				ssl_context=ssl_context,
+				max_connections=limits.max_connections,
+				max_keepalive_connections=limits.max_keepalive_connections,
+				keepalive_expiry=limits.keepalive_expiry,
+				http1=http1,
+				http2=http2,
+				socket_options=socket_options,
+			)
+		else:
+			super().__init__(verify, cert, trust_env, http1, http2, limits, proxy, uds, local_address, retries, socket_options)
+
+def request(method: str,
+			url: URL | str,
+			*,
+			cookies = None,
+			proxy = None,
+			timeout = DEFAULT_TIMEOUT_CONFIG,
+			verify = True,
+			trust_env: bool = True,
+			**kwargs):
+	transport = HTTPProxyTransport(proxy=proxy)
+	with Client(
+		cookies=cookies,
+		verify=verify,
+		timeout=timeout,
+		trust_env=trust_env,
+		mounts={'http://': transport, 'https://': transport}
+	) as client:
+		return client.request(method=method, url=url, **kwargs)
+
+def get(*args, **kwargs):
+	return request('GET', *args, **kwargs)
+
+def options(*args, **kwargs):
+	return request('OPTIONS', *args, **kwargs)
+
+def head(*args, **kwargs):
+	return request('HEAD', *args, **kwargs)
+
+def post(*args, **kwargs):
+	return request('POST', *args, **kwargs)
+
+def put(*args, **kwargs):
+	return request('PUT', *args, **kwargs)
+
+def patch(*args, **kwargs):
+	return request('PATCH', *args, **kwargs)
+
+def delete(*args, **kwargs):
+	return request('DELETE', *args, **kwargs)
+
+@contextmanager
+def stream(method: str,
+		   url: URL | str,
+		   *,
+		   cookies = None,
+		   proxy = None,
+		   timeout = DEFAULT_TIMEOUT_CONFIG,
+		   verify = True,
+		   trust_env: bool = True,
+		   **kwargs):
+	transport = HTTPProxyTransport(proxy=proxy)
+	with Client(
+		cookies=cookies,
+		verify=verify,
+		timeout=timeout,
+		trust_env=trust_env,
+		mounts={'http://': transport, 'https://': transport}
+	) as client:
+		with client.stream(method=method, url=url, **kwargs) as response:
+			yield response

python_proxy_headers-0.1.0/python_proxy_headers/requests_adapter.py

@@ -0,0 +1,73 @@
+from requests.adapters import HTTPAdapter
+from requests.sessions import Session
+from .urllib3_proxy_manager import proxy_from_url
+
+class HTTPProxyHeaderAdapter(HTTPAdapter):
+	def __init__(self, proxy_headers=None):
+		super().__init__()
+		self._proxy_headers = proxy_headers or {}
+	
+	def proxy_manager_for(self, proxy, **proxy_kwargs):
+		"""Return urllib3 ProxyManager for the given proxy.
+
+		This method should not be called from user code, and is only
+		exposed for use when subclassing the
+		:class:`HTTPAdapter <requests.adapters.HTTPAdapter>`.
+
+		:param proxy: The proxy to return a urllib3 ProxyManager for.
+		:param proxy_kwargs: Extra keyword arguments used to configure the Proxy Manager.
+		:returns: ProxyManager
+		:rtype: urllib3.ProxyManager
+		"""
+		if proxy in self.proxy_manager:
+			manager = self.proxy_manager[proxy]
+		elif proxy.lower().startswith("socks"):
+			return super().proxy_manager_for(proxy, **proxy_kwargs)
+		else:
+			# HTTPAdapter.proxy_headers only gets Proxy-Authorization
+			_proxy_headers = self.proxy_headers(proxy)
+			if self._proxy_headers:
+				_proxy_headers.update(self._proxy_headers)
+			
+			manager = self.proxy_manager[proxy] = proxy_from_url(
+				proxy,
+				proxy_headers=_proxy_headers,
+				num_pools=self._pool_connections,
+				maxsize=self._pool_maxsize,
+				block=self._pool_block,
+				**proxy_kwargs,
+			)
+
+		return manager
+
+class ProxySession(Session):
+	def __init__(self, proxy_headers=None):
+		super().__init__()
+		self.mount('https://', HTTPProxyHeaderAdapter(proxy_headers=proxy_headers))
+		self.mount('http://', HTTPProxyHeaderAdapter(proxy_headers=proxy_headers))
+
+def request(method, url, proxy_headers=None, **kwargs):
+	with ProxySession(proxy_headers) as session:
+		return session.request(method=method, url=url, **kwargs)
+
+def get(*args, **kwargs):
+	return request('get', *args, **kwargs)
+
+def options(*args, **kwargs):
+	return request('options', *args, **kwargs)
+
+def head(*args, **kwargs):
+	kwargs.setdefault("allow_redirects", False)
+	return request('head', *args, **kwargs)
+
+def post(*args, **kwargs):
+	return request('post', *args, **kwargs)
+
+def put(*args, **kwargs):
+	return request('put', *args, **kwargs)
+
+def patch(*args, **kwargs):
+	return request('patch', *args, **kwargs)
+
+def delete(*args, **kwargs):
+	return request('delete', *args, **kwargs)

python_proxy_headers-0.1.0/python_proxy_headers/urllib3_proxy_manager.py

@@ -0,0 +1,135 @@
+import http, sys
+from http.client import _read_headers
+from urllib3.connection import HTTPSConnection
+from urllib3.connectionpool import HTTPConnectionPool, HTTPSConnectionPool
+from urllib3.poolmanager import ProxyManager
+
+if sys.version_info < (3, 12, 0):
+	#####################################
+	### copied from python3.12 source ###
+	#####################################
+	import email.parser
+	import email.message
+
+	class HTTPMessage(email.message.Message):
+		# XXX The only usage of this method is in
+		# http.server.CGIHTTPRequestHandler.  Maybe move the code there so
+		# that it doesn't need to be part of the public API.  The API has
+		# never been defined so this could cause backwards compatibility
+		# issues.
+
+		def getallmatchingheaders(self, name):
+			"""Find all header lines matching a given header name.
+
+			Look through the list of headers and find all lines matching a given
+			header name (and their continuation lines).  A list of the lines is
+			returned, without interpretation.  If the header does not occur, an
+			empty list is returned.  If the header occurs multiple times, all
+			occurrences are returned.  Case is not important in the header name.
+
+			"""
+			name = name.lower() + ':'
+			n = len(name)
+			lst = []
+			hit = 0
+			for line in self.keys():
+				if line[:n].lower() == name:
+					hit = 1
+				elif not line[:1].isspace():
+					hit = 0
+				if hit:
+					lst.append(line)
+			return lst
+
+	def _parse_header_lines(header_lines, _class=HTTPMessage):
+		"""
+		Parses only RFC2822 headers from header lines.
+
+		email Parser wants to see strings rather than bytes.
+		But a TextIOWrapper around self.rfile would buffer too many bytes
+		from the stream, bytes which we later need to read as bytes.
+		So we read the correct bytes here, as bytes, for email Parser
+		to parse.
+
+		"""
+		hstring = b''.join(header_lines).decode('iso-8859-1')
+		return email.parser.Parser(_class=_class).parsestr(hstring)
+else:
+	from http.client import _parse_header_lines
+
+class HTTPSProxyConnection(HTTPSConnection):
+	if sys.version_info < (3, 12, 0):
+		#####################################
+		### copied from python3.12 source ###
+		#####################################
+
+		def _wrap_ipv6(self, ip):
+			if b':' in ip and ip[0] != b'['[0]:
+				return b"[" + ip + b"]"
+			return ip
+		
+		def _tunnel(self):
+			connect = b"CONNECT %s:%d %s\r\n" % (
+				self._wrap_ipv6(self._tunnel_host.encode("idna")),
+				self._tunnel_port,
+				self._http_vsn_str.encode("ascii"))
+			headers = [connect]
+			for header, value in self._tunnel_headers.items():
+				headers.append(f"{header}: {value}\r\n".encode("latin-1"))
+			headers.append(b"\r\n")
+			# Making a single send() call instead of one per line encourages
+			# the host OS to use a more optimal packet size instead of
+			# potentially emitting a series of small packets.
+			self.send(b"".join(headers))
+			del headers
+
+			response = self.response_class(self.sock, method=self._method)
+			try:
+				(version, code, message) = response._read_status()
+
+				self._raw_proxy_headers = _read_headers(response.fp)
+
+				if self.debuglevel > 0:
+					for header in self._raw_proxy_headers:
+						print('header:', header.decode())
+
+				if code != http.HTTPStatus.OK:
+					self.close()
+					raise OSError(f"Tunnel connection failed: {code} {message.strip()}")
+
+			finally:
+				response.close()
+
+		def get_proxy_response_headers(self):
+			"""
+			Returns a dictionary with the headers of the response
+			received from the proxy server to the CONNECT request
+			sent to set the tunnel.
+
+			If the CONNECT request was not sent, the method returns None.
+			"""
+			return (
+				_parse_header_lines(self._raw_proxy_headers)
+				if self._raw_proxy_headers is not None
+				else None
+			)
+
+class HTTPSProxyConnectionPool(HTTPSConnectionPool):
+	ConnectionCls = HTTPSProxyConnection
+
+	def _prepare_proxy(self, conn):
+		super()._prepare_proxy(conn)
+		self._proxy_response_headers = conn.get_proxy_response_headers()
+	
+	def urlopen(self, *args, **kwargs):
+		response = super().urlopen(*args, **kwargs)
+		response.headers.update(self._proxy_response_headers)
+		return response
+
+class ProxyHeaderManager(ProxyManager):
+	def __init__(self, *args, **kwargs):
+		super().__init__(*args, **kwargs)
+		self.pool_classes_by_scheme = {"http": HTTPConnectionPool, "https": HTTPSProxyConnectionPool}
+
+def proxy_from_url(url, **kwargs):
+    return ProxyHeaderManager(proxy_url=url, **kwargs)

python_proxy_headers-0.1.0/python_proxy_headers.egg-info/PKG-INFO

@@ -0,0 +1,151 @@
+Metadata-Version: 2.2
+Name: python-proxy-headers
+Version: 0.1.0
+Summary: Handle custom proxy headers for http requests in various python libraries
+Author-email: ProxyMesh <support@proxymesh.com>
+Project-URL: Homepage, https://github.com/proxymesh/python-proxy-headers
+Project-URL: Changelog, https://github.com/proxymesh/python-proxy-headers/commits/main/
+Project-URL: Issues, https://github.com/proxymesh/python-proxy-headers/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# Python Proxy Headers
+
+The `python-proxy-headers` package provides support for handling custom proxy headers when making HTTPS requests in various python modules.
+
+We currently provide extensions to the following packages:
+
+* [urllib3](https://urllib3.readthedocs.io/en/stable/)
+* [requests](https://docs.python-requests.org/en/latest/index.html)
+* [aiohttp](https://docs.aiohttp.org/en/stable/index.html)
+* [httpx](https://www.python-httpx.org/)
+
+None of these modules provide good support for parsing custom response headers from proxy servers. And some of them make it hard to send custom headers to proxy servers. So we at [ProxyMesh](https://proxymesh.com) made these extension modules to support our customers that use Python and want to use custom headers to control our proxy behavior. But these modules can work for handling custom headers with any proxy.
+
+*If you are looking for [Scrapy](https://scrapy.org/) support, please see our [scrapy-proxy-headers](https://github.com/proxymesh/scrapy-proxy-headers) project.*
+
+## Installation
+
+Examples for how to use these extension modules are described below. You must first do the following:
+
+1. `pip install python-proxy-headers`
+2. Install the appropriate package based on the python module you want to use.
+
+This package does not have any dependencies because we don't know which module you want to use.
+
+You can also find more example code in our [proxy-examples for python](https://github.com/proxymesh/proxy-examples/tree/main/python).
+
+## urllib3
+
+If you just want to send custom proxy headers, but don't need to receive proxy response headers, then you can [urllib3.ProxyManager](https://urllib3.readthedocs.io/en/stable/reference/urllib3.poolmanager.html#urllib3.ProxyManager), like so:
+
+``` python
+import urllib3
+proxy = urllib3.ProxyManager('http://PROXYHOST:PORT', proxy_headers={'X-ProxyMesh-Country': 'US'})
+r = proxy.request('GET', 'https://api.ipify.org?format=json')
+```
+
+Note that when using this method, if you keep reusing the same `ProxyManager` instance, you may be re-using the proxy connection, which may have different behavior than if you create a new proxy connection for each request. For example, with ProxyMesh you may keep getting the same IP address if you reuse the proxy connection.
+
+To get proxy response headers, use our extension module like this:
+
+``` python
+from python_proxy_headers import urllib3_proxy_manager
+proxy = urllib3_proxy_manager.ProxyHeaderManager('http://PROXYHOST:PORT')
+r = proxy.request('GET', 'https://api.ipify.org?format=json')
+r.headers['X-ProxyMesh-IP']
+```
+
+You can also pass `proxy_headers` into our `ProxyHeaderManager` as well. For example, you can pass back the same `X-ProxyMesh-IP` header to ensure you get the same IP address on subsequent requests.
+
+## requests
+
+The requests adapter builds on our `urllib3_proxy_manager` module to make it easy to pass in proxy headers and receive proxy response headers.
+
+``` python
+from python_proxy_headers import requests_adapter
+r = requests_adapter.get('https://api.ipify.org?format=json', proxies={'http': 'http://PROXYHOST:PORT', 'https': 'http://PROXYHOST:PORT'}, proxy_headers={'X-ProxyMesh-Country': 'US'})
+r.headers['X-ProxyMesh-IP']
+```
+
+The `requests_adapter` module supports all the standard requests methods: `get`, `post`, `put`, `delete`, etc.
+
+## aiohttp
+
+While it's not documented, aiohttp does support passing in custom proxy headers by default.
+
+``` python
+import aiohttp
+async with aiohttp.ClientSession() as session:
+	async with session.get('https://api.ipify.org?format=json', proxy="http://PROXYHOST:PORT", proxy_headers={'X-ProxyMesh-Country': 'US'}) as r:
+		await r.text()
+```
+
+However, if you want to get proxy response, you should use our extension module:
+
+``` python
+from python_proxy_headers import aiohttp_proxy
+async with aiohttp_proxy.ProxyClientSession() as session:
+	async with session.get('https://api.ipify.org?format=json', proxy="http://PROXYHOST:PORT", proxy_headers={'X-ProxyMesh-Country': 'US'}) as r:
+		await r.text()
+
+r.headers['X-ProxyMesh-IP']
+```
+
+## httpx
+
+httpx also supports proxy headers by default, though it's not documented:
+
+``` python
+import httpx
+proxy = httpx.Proxy('http://PROXYHOST:PORT', headers={'X-ProxyMesh-Country': 'US'})
+transport = HTTPProxyTransport(proxy=proxy)
+with httpx.Client(mounts={'http://': transort, 'https://': transport}) as client:
+	r = client.get('https://api.ipify.org?format=json')
+```
+
+But to get the response headers, you need to use our extension module:
+
+``` python
+import httpx
+from python_proxy_headers.httpx_proxy import HTTPProxyTransport
+proxy = httpx.Proxy('http://PROXYHOST:PORT', headers={'X-ProxyMesh-Country': 'US'})
+transport = HTTPProxyTransport(proxy=proxy)
+with httpx.Client(mounts={'http://': transort, 'https://': transport}) as client:
+	r = client.get('https://api.ipify.org?format=json')
+
+r.headers['X-ProxyMesh-IP']
+```
+
+This module also provide helper methods similar to requests:
+
+``` python
+import httpx
+from python_proxy_headers import httpx_proxy
+proxy = httpx.Proxy('http://PROXYHOST:PORT', headers={'X-ProxyMesh-Country': 'US'})
+r = httpx_proxy.get('https://api.ipify.org?format=json', proxy=proxy)
+r.headers['X-ProxyMesh-IP']
+```
+
+And finally, httpx supports async requests, so we provide an async extension too:
+
+``` python
+import httpx
+from python_proxy_headers.httpx_proxy import AsyncHTTPProxyTransport
+proxy = httpx.Proxy('http://PROXYHOST:PORT', headers={'X-ProxyMesh-Country': 'US'})
+transport = AsyncHTTPProxyTransport(proxy=proxy)
+async with httpx.AsyncClient(mounts={'http://': transport, 'https://': transport}) as client:
+	r = await client.get('https://api.ipify.org?format=json')
+
+r.headers['X-ProxyMesh-IP']
+```
+
+Our httpx helper module internally provides extension classes for [httpcore](https://www.encode.io/httpcore/), for handling proxy headers over tunnel connections.
+You can use those classes if you're building on top of httpcore.

python_proxy_headers-0.1.0/python_proxy_headers.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+pyproject.toml
+python_proxy_headers/__init__.py
+python_proxy_headers/aiohttp_proxy.py
+python_proxy_headers/httpx_proxy.py
+python_proxy_headers/requests_adapter.py
+python_proxy_headers/urllib3_proxy_manager.py
+python_proxy_headers.egg-info/PKG-INFO
+python_proxy_headers.egg-info/SOURCES.txt
+python_proxy_headers.egg-info/dependency_links.txt
+python_proxy_headers.egg-info/top_level.txt

python_proxy_headers-0.1.0/python_proxy_headers.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

python_proxy_headers-0.1.0/python_proxy_headers.egg-info/top_level.txt

@@ -0,0 +1 @@
+python_proxy_headers

python_proxy_headers-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+