python-socks 2.8.2__py3-none-any.whl → 3.0.0__py3-none-any.whl

python_socks-3.0.0.dist-info/METADATA

@@ -0,0 +1,346 @@
+Metadata-Version: 2.4
+Name: python-socks
+Version: 3.0.0
+Summary: Proxy (SOCKS4, SOCKS5, HTTP CONNECT) client for Python
+Author-email: Roman Snegirev <snegiryev@gmail.com>
+License-Expression: Apache-2.0
+Project-URL: homepage, https://github.com/romis2012/python-socks
+Project-URL: repository, https://github.com/romis2012/python-socks
+Keywords: socks,socks5,socks4,http,proxy,asyncio,trio,anyio
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Intended Audience :: Developers
+Classifier: Framework :: AsyncIO
+Classifier: Framework :: Trio
+Requires-Python: >=3.9.0
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Provides-Extra: asyncio
+Requires-Dist: async-timeout>=5.0.1; python_version < "3.11" and extra == "asyncio"
+Provides-Extra: trio
+Requires-Dist: trio>=0.30.0; extra == "trio"
+Provides-Extra: anyio
+Requires-Dist: anyio<5.0.0,>=4.12.1; extra == "anyio"
+Dynamic: license-file
+
+## python-socks
+
+[![CI](https://github.com/romis2012/python-socks/actions/workflows/ci.yml/badge.svg)](https://github.com/romis2012/python-socks/actions/workflows/ci.yml)
+[![Coverage Status](https://codecov.io/gh/romis2012/python-socks/branch/master/graph/badge.svg)](https://codecov.io/gh/romis2012/python-socks)
+[![PyPI version](https://badge.fury.io/py/python-socks.svg)](https://pypi.python.org/pypi/python-socks)
+[![versions](https://img.shields.io/pypi/pyversions/python-socks.svg)](https://github.com/romis2012/python-socks)
+<!--
+[![Downloads](https://pepy.tech/badge/python-socks/month)](https://pepy.tech/project/python-socks)
+-->
+
+The `python-socks` package provides a core proxy client functionality for Python.
+Supports `SOCKS4(a)`, `SOCKS5(h)`, `HTTP CONNECT` proxy and provides sync and async (asyncio, trio, anyio) APIs.
+You probably don't need to use `python-socks` directly. 
+It is used internally by 
+[aiohttp-socks](https://github.com/romis2012/aiohttp-socks) and [httpx-socks](https://github.com/romis2012/httpx-socks) packages.  
+
+## Requirements
+- Python >= 3.9
+- async-timeout >= 5.0 (optional)
+- trio >= 0.30 (optional)
+- anyio >= 4.12 (optional)
+
+## Installation
+
+only sync proxy support:
+```
+pip install python-socks
+```
+
+to include optional asyncio support:
+```
+pip install python-socks[asyncio]
+```
+
+to include optional trio support:
+```
+pip install python-socks[trio]
+```
+
+to include optional anyio support:
+```
+pip install python-socks[anyio]
+```
+
+## Simple usage
+We are making secure HTTP GET request via SOCKS5 proxy
+ 
+#### Sync
+```python
+import ssl
+from python_socks.sync import Proxy
+
+
+def fetch():
+    proxy = Proxy.from_url("socks5://user:password@127.0.0.1:1080")
+
+    # `connect` returns standard Python socket in blocking mode
+    sock = proxy.connect(
+        dest_host="check-host.net",
+        dest_port=443,
+    )
+
+    sock = ssl.create_default_context().wrap_socket(
+        sock=sock,
+        server_hostname="check-host.net",
+    )
+
+    # fmt: off
+    request = (
+        b"GET /ip HTTP/1.1\r\n"
+        b"Host: check-host.net\r\n"
+        b"Connection: close\r\n\r\n"
+    )
+    # fmt: on
+
+    sock.sendall(request)
+    response = sock.recv(4096)
+    print(response)
+
+
+fetch()
+```
+
+#### Async (asyncio)
+```python
+import asyncio
+import ssl
+from python_socks.async_.asyncio import Proxy
+
+
+async def fetch():
+    proxy = Proxy.from_url("socks5://user:password@127.0.0.1:1080")
+
+    # `connect` returns standard Python socket in non-blocking mode
+    # so we can pass it to asyncio.open_connection(...)
+    sock = await proxy.connect(
+        dest_host="check-host.net",
+        dest_port=443,
+    )
+
+    reader, writer = await asyncio.open_connection(
+        sock=sock,
+        ssl=ssl.create_default_context(),
+        server_hostname="check-host.net",
+    )
+
+    # fmt: off
+    request = (
+        b"GET /ip HTTP/1.1\r\n"
+        b"Host: check-host.net\r\n"
+        b"Connection: close\r\n\r\n"
+    )
+    # fmt: on
+
+    writer.write(request)
+    response = await reader.read(-1)
+    print(response)
+
+    writer.close()
+    await writer.wait_closed()
+
+
+asyncio.run(fetch())
+```
+
+#### Async (trio)
+```python
+import ssl
+import trio
+from python_socks.async_.trio import Proxy
+
+
+async def fetch():
+    proxy = Proxy.from_url("socks5://user:password@127.0.0.1:1080")
+
+    # `connect` returns trio.socket.SocketType
+    # so we can pass it to trio.SocketStream
+    sock = await proxy.connect(
+        dest_host="check-host.net",
+        dest_port=443,
+    )
+    stream = trio.SocketStream(sock)
+    stream = trio.SSLStream(
+        stream,
+        ssl_context=ssl.create_default_context(),
+        server_hostname="check-host.net",
+    )
+    await stream.do_handshake()
+
+    # fmt: off
+    request = (
+        b"GET /ip HTTP/1.1\r\n"
+        b"Host: check-host.net\r\n"
+        b"Connection: close\r\n\r\n"
+    )
+    # fmt: on
+
+    await stream.send_all(request)
+    response = await stream.receive_some(4096)
+    print(response)
+
+    await stream.aclose()
+
+
+trio.run(fetch)
+```
+
+#### Async (anyio)
+```python
+import ssl
+import anyio
+from anyio.streams.tls import TLSStream
+from python_socks.async_.anyio import Proxy
+
+
+async def fetch():
+    proxy = Proxy.from_url("socks5://user:password@127.0.0.1:1080")
+
+    # `connect` returns anyio.abc.SocketStream
+    # we can use it directly
+    stream = await proxy.connect(
+        dest_host="check-host.net",
+        dest_port=443,
+    )
+    stream = await TLSStream.wrap(
+        stream,
+        ssl_context=ssl.create_default_context(),
+        hostname="check-host.net",
+    )
+
+    # fmt: off
+    request = (
+        b"GET /ip HTTP/1.1\r\n"
+        b"Host: check-host.net\r\n"
+        b"Connection: close\r\n\r\n"
+    )
+    # fmt: on
+
+    await stream.send(request)
+    response = await stream.receive(4096)
+    print(response)
+
+    await stream.aclose()
+
+
+anyio.run(fetch)
+```
+
+## More complex example
+
+#### A urllib3 PoolManager that routes connections via the proxy
+
+```python
+from urllib3 import PoolManager, HTTPConnectionPool, HTTPSConnectionPool
+from urllib3.connection import HTTPConnection, HTTPSConnection
+from python_socks.sync import Proxy
+
+
+class ProxyHTTPConnection(HTTPConnection):
+    def __init__(self, *args, **kwargs):
+        socks_options = kwargs.pop("_socks_options")
+        self._proxy_url = socks_options["proxy_url"]
+        super().__init__(*args, **kwargs)
+
+    def _new_conn(self):
+        proxy = Proxy.from_url(self._proxy_url)
+        return proxy.connect(
+            dest_host=self.host,
+            dest_port=self.port,
+            timeout=self.timeout,
+        )
+
+
+class ProxyHTTPSConnection(ProxyHTTPConnection, HTTPSConnection):
+    pass
+
+
+class ProxyHTTPConnectionPool(HTTPConnectionPool):
+    ConnectionCls = ProxyHTTPConnection
+
+
+class ProxyHTTPSConnectionPool(HTTPSConnectionPool):
+    ConnectionCls = ProxyHTTPSConnection
+
+
+class ProxyPoolManager(PoolManager):
+    def __init__(
+        self,
+        proxy_url,
+        timeout=5,
+        num_pools=10,
+        headers=None,
+        **connection_pool_kw,
+    ):
+
+        connection_pool_kw["_socks_options"] = {"proxy_url": proxy_url}
+        connection_pool_kw["timeout"] = timeout
+
+        super().__init__(num_pools, headers, **connection_pool_kw)
+
+        self.pool_classes_by_scheme = {
+            "http": ProxyHTTPConnectionPool,
+            "https": ProxyHTTPSConnectionPool,
+        }
+
+
+### and how to use it
+manager = ProxyPoolManager("socks5://user:password@127.0.0.1:1080")
+response = manager.request("GET", "https://check-host.net/ip")
+print(response.data)
+```
+
+## Proxy Chaining (sync example — same for asyncio, trio, anyio)
+
+```python
+import ssl
+from python_socks.sync import Proxy
+
+
+def fetch():
+    proxy1 = Proxy.from_url("socks5://user:password@127.0.0.1:1080")
+    proxy2 = Proxy.from_url("socks4://127.0.0.1:1081", forward=proxy1)
+    proxy3 = Proxy.from_url("http://user:password@127.0.0.1:1082", forward=proxy2)
+
+    sock = proxy3.connect(
+        dest_host="check-host.net",
+        dest_port=443,
+    )
+
+    sock = ssl.create_default_context().wrap_socket(
+        sock=sock,
+        server_hostname="check-host.net",
+    )
+
+    # fmt: off
+    request = (
+        b"GET /ip HTTP/1.1\r\n"
+        b"Host: check-host.net\r\n"
+        b"Connection: close\r\n\r\n"
+    )
+    # fmt: on
+
+    sock.sendall(request)
+    response = sock.recv(4096)
+    print(response)
+
+
+fetch()
+```

python_socks-3.0.0.dist-info/RECORD

@@ -0,0 +1,65 @@
+python_socks/__init__.py,sha256=6IejmLHZJBuYvt6V5fFRmsDdE9BI4SHJYw4vQwBS4nU,365
+python_socks/_abc.py,sha256=hWx0g_a1Df5puIzVIn3Dd9_SHF4ADzax4WQZeo-Y8bY,1207
+python_socks/_errors.py,sha256=gfolrrm3V08_v5HTLz0IyLlq14lkyXbOGa_X-ppSFzQ,511
+python_socks/_helpers.py,sha256=NweYNhD0-RimP0TPzfqofp3EFl23WWr6pMP_4g-Tskc,2743
+python_socks/_types.py,sha256=G4Pktu-z8eJmdmlt6t8gnMT5-kuZQkY7Vmy1Nx0rdIw,157
+python_socks/_version.py,sha256=IDLGnOO0HqgubX0FroxCqZQ1glwT5MN-OdAtMXKqdgA,49
+python_socks/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+python_socks/_connectors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+python_socks/_connectors/abc.py,sha256=FaLueczebKhIH0CvOfw232hE_SlKc8BY2hWfCXNpxmI,435
+python_socks/_connectors/factory_async.py,sha256=ni429tDujO-xjv7Q7mvJ4yqwT2hrk9sqU4_2CZe30cg,1069
+python_socks/_connectors/factory_sync.py,sha256=t3C2pV4NISkSOezzIysunyp9Xz2wKyLfTSPK6eP2QoQ,1056
+python_socks/_connectors/http_async.py,sha256=AjlS_PgKxU1M1EVlYDRFIl_fM8HG3fSlng3ueqZSqQY,956
+python_socks/_connectors/http_sync.py,sha256=W1FrclTg-4shC2KkDaBQ616BTpjrFFEz01cIyYrBHUQ,931
+python_socks/_connectors/socks4_async.py,sha256=OS-dDXQNtSrz5YjZqn-VXQ4PEqOJwVdVP6JfZ5HQyR0,1202
+python_socks/_connectors/socks4_sync.py,sha256=lnQ2EueNvPlSJg8WHV1ZlLlsffMsZPFEt-eTa5KD6NY,1171
+python_socks/_connectors/socks5_async.py,sha256=NWjUYubjCuT9Kxz02LLQbhgotzUug_J-GKxIaxGgmbs,3091
+python_socks/_connectors/socks5_sync.py,sha256=_Au7HLSC3UPVORyC4ziFOXisxetTItIqqH7iEjhSR7g,2907
+python_socks/_protocols/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+python_socks/_protocols/errors.py,sha256=rtQo2fM92Oc41ELMBPvyY2zHZomGAxXWRL0_3rzm9FM,269
+python_socks/_protocols/http.py,sha256=aq1THZoNi6cqAfvcGRx5guNbWqYgsM0X88b9olerkAA,4987
+python_socks/_protocols/socks4.py,sha256=F2sEgWYe19asMH4AtD4htlEnRlQBN641HQqoFKivVpw,3071
+python_socks/_protocols/socks5.py,sha256=grVRKgRVm6xMBgX9MwUVXTJ515-tLOYGXYyfnH7AIXA,10147
+python_socks/async_/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+python_socks/async_/anyio/__init__.py,sha256=4M0l4I7yH3TNjeBjHqQfZWEZD7uCFf-wQzWkUREm5Hc,62
+python_socks/async_/anyio/_connect.py,sha256=z2Uq2909RmTH9oABoYoIBXjdgbfEAX2wFxSWdDNcDzc,305
+python_socks/async_/anyio/_proxy.py,sha256=HdMguf864waZMoLIpFMTuifegsBUSscgV2mCaC-xrF8,3741
+python_socks/async_/anyio/_resolver.py,sha256=VotJDC-fs_EWNLzm_x0gys-kUvlkxeV1x1JYezpPuhE,711
+python_socks/async_/anyio/_stream.py,sha256=xCMMjst07gsDbVM9cW_kzCB3ULApozfNOW3k2xs1XwY,1301
+python_socks/async_/anyio/v2/__init__.py,sha256=4M0l4I7yH3TNjeBjHqQfZWEZD7uCFf-wQzWkUREm5Hc,62
+python_socks/async_/anyio/v2/_connect.py,sha256=9XAnQX8WXpsfEYJDJwpudD0kLwIl4apnusV9jbhRASI,352
+python_socks/async_/anyio/v2/_proxy.py,sha256=1JRDH2R1fxE7VnonIWrSFpXvV3hP4AxsrCO9plcKW_4,4237
+python_socks/async_/anyio/v2/_stream.py,sha256=lj4SvetB5stU0KE6uG1fuW5sGrW_GZ1XpPX_GojrwKk,1704
+python_socks/async_/asyncio/__init__.py,sha256=vryJNtCqDYriwWhmlB279WN7XI1dbELUAOrsMXWN2Ww,64
+python_socks/async_/asyncio/_connect.py,sha256=_lmJj_1Bs_mASeCv5j9bI_o_wgu8YMI8zeUStfzd6_g,1240
+python_socks/async_/asyncio/_proxy.py,sha256=t0OKUBa9MQ3xTarNRIvuYSb83K2V9k95C0UupExqa0k,4120
+python_socks/async_/asyncio/_resolver.py,sha256=9kHNrBk8Cf_gULxCix_yB7G5wjueLUQ_FPzq25DjsD4,871
+python_socks/async_/asyncio/_stream.py,sha256=p2XMTbrnXwz23jGd4NPYIcpgx1nZnNjn7aw7w0R-Dcg,1067
+python_socks/async_/asyncio/v2/__init__.py,sha256=vryJNtCqDYriwWhmlB279WN7XI1dbELUAOrsMXWN2Ww,64
+python_socks/async_/asyncio/v2/_connect.py,sha256=W5ZaQF-jY1yxD_WjiuFUot0gADeY-QiCFFaXm5Nfj5I,625
+python_socks/async_/asyncio/v2/_proxy.py,sha256=iqngXtYYD79yHAnMHIc5UxsTlzRQZiY8pL2seBnxYI4,4935
+python_socks/async_/asyncio/v2/_stream.py,sha256=t4C5eUajR-Bfb5jSJ2o3t3v4LVJ_M3lCWF47suHERwk,2798
+python_socks/async_/trio/__init__.py,sha256=-SQ1iuGgZ3A9YUaVKF8Q12lCj_e-5Kytd9P3zJwaoy0,61
+python_socks/async_/trio/_connect.py,sha256=Zvdun2nXdMmbXACEQsKnmRcUmB8fCLuiJD21gXnfv8c,910
+python_socks/async_/trio/_proxy.py,sha256=LhacHbqElxSZK9nWmyTAbbBc5cAqZ8MrlylkD52-3Po,3793
+python_socks/async_/trio/_resolver.py,sha256=cAFm7fEwg9lG5QaeXBFhrLJKju-nqTE9gs_VislMzRg,755
+python_socks/async_/trio/_stream.py,sha256=dDmBoqJxmF1DIZFRzoy86wu90vezT88M5TqxD_q2yzE,1138
+python_socks/async_/trio/v2/__init__.py,sha256=-SQ1iuGgZ3A9YUaVKF8Q12lCj_e-5Kytd9P3zJwaoy0,61
+python_socks/async_/trio/v2/_connect.py,sha256=1AIy6xjv64BDyZzCrfE-1Ad-GT5_zoMH7hbkrPfOcOg,365
+python_socks/async_/trio/v2/_proxy.py,sha256=igiZ25e_zo7UZ6TCNdCUxoMW9PPyy7bnfNNqW1bSQnI,4315
+python_socks/async_/trio/v2/_stream.py,sha256=LNuEv4cntWpBN0zLUyvdQ74Skhvk2FdaOILaIkic9Tk,1620
+python_socks/sync/__init__.py,sha256=O9lYydn6a2z0QSz8hoZjxL6OqQQ873i8Zy1ye67iR8k,61
+python_socks/sync/_connect.py,sha256=SSkmuekFEGK7GMm4ffUo--29SuOkfLgeFvyt0KCphjM,339
+python_socks/sync/_proxy.py,sha256=uqIIDbgmnk3v0NcqC966_ljU5qHI_Uem0VMB98DxuAk,3317
+python_socks/sync/_resolver.py,sha256=IUpXerBFIhOciM_CJ_I29IKMGI49yEUJKD02SOb_BHE,750
+python_socks/sync/_stream.py,sha256=wuonNLZwtKtuvOMhgAoEsONNK0_tH0MYben_J1sjLBk,922
+python_socks/sync/v2/__init__.py,sha256=O9lYydn6a2z0QSz8hoZjxL6OqQQ873i8Zy1ye67iR8k,61
+python_socks/sync/v2/_connect.py,sha256=TQGD3j8qwHjJqqzLRubmwmIMhkoWRfQd4351ipTY4mU,416
+python_socks/sync/v2/_proxy.py,sha256=sD2vVKvXEfSw5IzzDcwp45DElkKB33lsT6ZCKXcoxPk,3815
+python_socks/sync/v2/_ssl_transport.py,sha256=z3fB52pH7tqOADyICuoJF1YYKTs1ogkeR3K-J8v6P0w,6123
+python_socks/sync/v2/_stream.py,sha256=23srzyxyP7o7KtEdNQllZIvPIxBZ8oC_rV0bkd4jui8,1744
+python_socks-3.0.0.dist-info/licenses/LICENSE.txt,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
+python_socks-3.0.0.dist-info/METADATA,sha256=vmOXG6pVTxNJzJeDUVPlvOMS0tj2PqN2B0_Oenym9Lo,8923
+python_socks-3.0.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+python_socks-3.0.0.dist-info/top_level.txt,sha256=7qyDAVwjTZ0sIYG1iatFbE-SLpWhONjaoMQ0Ib2DX0Q,13
+python_socks-3.0.0.dist-info/RECORD,,

{python_socks-2.8.2.dist-info → python_socks-3.0.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (82.0.1)
+Generator: setuptools (84.0.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

python_socks/async_/_proxy_chain.py

@@ -1,34 +0,0 @@
-from typing import Iterable
-import warnings
-
-
-class ProxyChain:
-    def __init__(self, proxies: Iterable):
-        warnings.warn(
-            'This implementation of ProxyChain is deprecated and will be removed in the future',
-            DeprecationWarning,
-            stacklevel=2,
-        )
-        self._proxies = proxies
-
-    async def connect(self, dest_host, dest_port, timeout=None):
-        curr_socket = None
-        proxies = list(self._proxies)
-
-        length = len(proxies) - 1
-        for i in range(length):
-            curr_socket = await proxies[i].connect(
-                dest_host=proxies[i + 1].proxy_host,
-                dest_port=proxies[i + 1].proxy_port,
-                timeout=timeout,
-                _socket=curr_socket,
-            )
-
-        curr_socket = await proxies[length].connect(
-            dest_host=dest_host,
-            dest_port=dest_port,
-            timeout=timeout,
-            _socket=curr_socket,
-        )
-
-        return curr_socket

python_socks/async_/anyio/_chain.py

@@ -1,42 +0,0 @@
-from typing import Iterable
-import warnings
-from ._proxy import AnyioProxy
-
-
-class ProxyChain:
-    def __init__(self, proxies: Iterable[AnyioProxy]):
-        warnings.warn(
-            'This implementation of ProxyChain is deprecated and will be removed in the future',
-            DeprecationWarning,
-            stacklevel=2,
-        )
-        self._proxies = proxies
-
-    async def connect(
-        self,
-        dest_host,
-        dest_port,
-        dest_ssl=None,
-        timeout=None,
-    ):
-        _stream = None
-        proxies = list(self._proxies)
-
-        length = len(proxies) - 1
-        for i in range(length):
-            _stream = await proxies[i].connect(
-                dest_host=proxies[i + 1].proxy_host,
-                dest_port=proxies[i + 1].proxy_port,
-                timeout=timeout,
-                _stream=_stream,
-            )
-
-        _stream = await proxies[length].connect(
-            dest_host=dest_host,
-            dest_port=dest_port,
-            dest_ssl=dest_ssl,
-            timeout=timeout,
-            _stream=_stream,
-        )
-
-        return _stream

python_socks/async_/anyio/v2/_chain.py

@@ -1,32 +0,0 @@
-from typing import Sequence
-import warnings
-from ._proxy import AnyioProxy
-
-
-class ProxyChain:
-    def __init__(self, proxies: Sequence[AnyioProxy]):
-        warnings.warn(
-            'This implementation of ProxyChain is deprecated and will be removed in the future',
-            DeprecationWarning,
-            stacklevel=2,
-        )
-        self._proxies = proxies
-
-    async def connect(
-        self,
-        dest_host,
-        dest_port,
-        dest_ssl=None,
-        timeout=None,
-    ):
-        forward = None
-        for proxy in self._proxies:
-            proxy._forward = forward
-            forward = proxy
-
-        return await forward.connect(
-            dest_host=dest_host,
-            dest_port=dest_port,
-            dest_ssl=dest_ssl,
-            timeout=timeout,
-        )

python_socks/async_/asyncio/v2/_chain.py

@@ -1,32 +0,0 @@
-from typing import Sequence
-import warnings
-from ._proxy import AsyncioProxy
-
-
-class ProxyChain:
-    def __init__(self, proxies: Sequence[AsyncioProxy]):
-        warnings.warn(
-            'This implementation of ProxyChain is deprecated and will be removed in the future',
-            DeprecationWarning,
-            stacklevel=2,
-        )
-        self._proxies = proxies
-
-    async def connect(
-        self,
-        dest_host: str,
-        dest_port: int,
-        dest_ssl=None,
-        timeout=None,
-    ):
-        forward = None
-        for proxy in self._proxies:
-            proxy._forward = forward
-            forward = proxy
-
-        return await forward.connect(
-            dest_host=dest_host,
-            dest_port=dest_port,
-            dest_ssl=dest_ssl,
-            timeout=timeout,
-        )

python_socks/async_/curio/__init__.py

@@ -1,4 +0,0 @@
-from ._proxy import CurioProxy as Proxy
-
-
-__all__ = ('Proxy',)

python_socks/async_/curio/_connect.py

@@ -1,17 +0,0 @@
-from typing import Optional, Tuple
-
-import curio
-import curio.io
-import curio.socket
-
-
-async def connect_tcp(
-    host: str,
-    port: int,
-    local_addr: Optional[Tuple[str, int]] = None,
-) -> curio.io.Socket:
-    return await curio.open_connection(
-        host=host,
-        port=port,
-        source_addr=local_addr,
-    )