python-socks 2.1.1__py3-none-any.whl → 2.3.0__py3-none-any.whl

python_socks/async_/asyncio/v2/_proxy.py

@@ -1,5 +1,6 @@
 import asyncio
 import ssl
+import warnings
 
 import async_timeout
 
@@ -21,8 +22,15 @@ class AsyncioProxy:
         proxy_host: str,
         proxy_port: int,
         proxy_ssl: ssl.SSLContext = None,
+        forward: 'AsyncioProxy' = None,
         loop: asyncio.AbstractEventLoop = None,
     ):
+        if loop is not None:  # pragma: no cover
+            warnings.warn(
+                'The loop argument is deprecated and scheduled for removal in the future.',
+                DeprecationWarning,
+                stacklevel=2,
+            )
 
         if loop is None:
             loop = asyncio.get_event_loop()
@@ -32,13 +40,8 @@ class AsyncioProxy:
         self._proxy_host = proxy_host
         self._proxy_port = proxy_port
         self._proxy_ssl = proxy_ssl
+        self._forward = forward
 
-        self._dest_host = None
-        self._dest_port = None
-        self._dest_ssl = None
-        self._timeout = None
-
-        self._stream = None
         self._resolver = Resolver(loop=loop)
 
     async def connect(
@@ -47,83 +50,77 @@ class AsyncioProxy:
         dest_port: int,
         dest_ssl: ssl.SSLContext = None,
         timeout: float = None,
-        _stream: AsyncioSocketStream = None,
     ) -> AsyncioSocketStream:
-
         if timeout is None:
             timeout = DEFAULT_TIMEOUT
 
-        self._dest_host = dest_host
-        self._dest_port = dest_port
-        self._dest_ssl = dest_ssl
-        self._timeout = timeout
-
         try:
-            return await self._connect(_stream)
+            async with async_timeout.timeout(timeout):
+                return await self._connect(
+                    dest_host=dest_host,
+                    dest_port=dest_port,
+                    dest_ssl=dest_ssl,
+                )
         except asyncio.TimeoutError as e:
-            raise ProxyTimeoutError('Proxy connection timed out: {}'.format(self._timeout)) from e
-
-    async def _connect(self, _stream: AsyncioSocketStream) -> AsyncioSocketStream:
-        async with async_timeout.timeout(self._timeout):
-            try:
-                if _stream is None:
-                    reader, writer = await connect_tcp(
-                        host=self._proxy_host,
-                        port=self._proxy_port,
-                    )
-                    self._stream = AsyncioSocketStream(
-                        loop=self._loop,
-                        reader=reader,
-                        writer=writer,
-                    )
-                else:
-                    self._stream = _stream
-
-                if self._proxy_ssl is not None:  # pragma: no cover
-                    self._stream = await self._stream.start_tls(
-                        hostname=self._proxy_host,
-                        ssl_context=self._proxy_ssl,
-                    )
-            except OSError as e:
-                await self._close()
-                msg = 'Could not connect to proxy {}:{} [{}]'.format(
-                    self._proxy_host,
-                    self._proxy_port,
-                    e.strerror,
+            raise ProxyTimeoutError('Proxy connection timed out: {}'.format(timeout)) from e
+
+    async def _connect(
+        self,
+        dest_host: str,
+        dest_port: int,
+        dest_ssl: ssl.SSLContext = None,
+    ) -> AsyncioSocketStream:
+        try:
+            if self._forward is None:
+                stream = await connect_tcp(
+                    host=self._proxy_host,
+                    port=self._proxy_port,
+                    loop=self._loop,
                 )
-                raise ProxyConnectionError(e.errno, msg) from e
-            except (asyncio.CancelledError, Exception):
-                await self._close()
-                raise
-
-            try:
-                await self._negotiate()
-
-                if self._dest_ssl is not None:
-                    self._stream = await self._stream.start_tls(
-                        hostname=self._dest_host,
-                        ssl_context=self._dest_ssl,
-                    )
-            except (asyncio.CancelledError, Exception):
-                await self._close()
-                raise
-
-            return self._stream
-
-    async def _negotiate(self):
-        raise NotImplementedError()
+            else:
+                stream = await self._forward.connect(
+                    dest_host=self._proxy_host,
+                    dest_port=self._proxy_port,
+                )
+        except OSError as e:
+            raise ProxyConnectionError(
+                e.errno,
+                f"Couldn't connect to proxy {self._proxy_host}:{self._proxy_port} [{e.strerror}]",
+            ) from e
+        except (asyncio.CancelledError, Exception):
+            raise
 
-    async def _close(self):
-        if self._stream is not None:
-            await self._stream.close()
+        try:
+            if self._proxy_ssl is not None:  # pragma: no cover
+                stream = await stream.start_tls(
+                    hostname=self._proxy_host,
+                    ssl_context=self._proxy_ssl,
+                )
 
-    @property
-    def proxy_host(self):
-        return self._proxy_host
+            await self._negotiate(
+                stream=stream,
+                dest_host=dest_host,
+                dest_port=dest_port,
+            )
 
-    @property
-    def proxy_port(self):
-        return self._proxy_port
+            if dest_ssl is not None:
+                stream = await stream.start_tls(
+                    hostname=dest_host,
+                    ssl_context=dest_ssl,
+                )
+        except (asyncio.CancelledError, Exception):
+            await stream.close()
+            raise
+
+        return stream
+
+    async def _negotiate(
+        self,
+        stream: AsyncioSocketStream,
+        dest_host: str,
+        dest_port: int,
+    ):
+        raise NotImplementedError()
 
 
 class Socks5Proxy(AsyncioProxy):
@@ -135,24 +132,31 @@ class Socks5Proxy(AsyncioProxy):
         password=None,
         rdns=None,
         proxy_ssl=None,
+        forward: 'AsyncioProxy' = None,
         loop: asyncio.AbstractEventLoop = None,
     ):
         super().__init__(
             proxy_host=proxy_host,
             proxy_port=proxy_port,
             proxy_ssl=proxy_ssl,
+            forward=forward,
             loop=loop,
         )
         self._username = username
         self._password = password
         self._rdns = rdns
 
-    async def _negotiate(self):
+    async def _negotiate(
+        self,
+        stream: AsyncioSocketStream,
+        dest_host: str,
+        dest_port: int,
+    ):
         proto = Socks5Proto(
-            stream=self._stream,
+            stream=stream,
             resolver=self._resolver,
-            dest_host=self._dest_host,
-            dest_port=self._dest_port,
+            dest_host=dest_host,
+            dest_port=dest_port,
             username=self._username,
             password=self._password,
             rdns=self._rdns,
@@ -168,23 +172,30 @@ class Socks4Proxy(AsyncioProxy):
         user_id=None,
         rdns=None,
         proxy_ssl=None,
+        forward: 'AsyncioProxy' = None,
         loop: asyncio.AbstractEventLoop = None,
     ):
         super().__init__(
             proxy_host=proxy_host,
             proxy_port=proxy_port,
             proxy_ssl=proxy_ssl,
+            forward=forward,
             loop=loop,
         )
         self._user_id = user_id
         self._rdns = rdns
 
-    async def _negotiate(self):
+    async def _negotiate(
+        self,
+        stream: AsyncioSocketStream,
+        dest_host: str,
+        dest_port: int,
+    ):
         proto = Socks4Proto(
-            stream=self._stream,
+            stream=stream,
             resolver=self._resolver,
-            dest_host=self._dest_host,
-            dest_port=self._dest_port,
+            dest_host=dest_host,
+            dest_port=dest_port,
             user_id=self._user_id,
             rdns=self._rdns,
         )
@@ -199,22 +210,29 @@ class HttpProxy(AsyncioProxy):
         username=None,
         password=None,
         proxy_ssl=None,
+        forward: 'AsyncioProxy' = None,
         loop: asyncio.AbstractEventLoop = None,
     ):
         super().__init__(
             proxy_host=proxy_host,
             proxy_port=proxy_port,
             proxy_ssl=proxy_ssl,
+            forward=forward,
             loop=loop,
         )
         self._username = username
         self._password = password
 
-    async def _negotiate(self):
+    async def _negotiate(
+        self,
+        stream: AsyncioSocketStream,
+        dest_host: str,
+        dest_port: int,
+    ):
         proto = HttpProto(
-            stream=self._stream,  # noqa
-            dest_host=self._dest_host,
-            dest_port=self._dest_port,
+            stream=stream,
+            dest_host=dest_host,
+            dest_port=dest_port,
             username=self._username,
             password=self._password,
         )

python_socks/async_/asyncio/v2/_stream.py

@@ -17,7 +17,7 @@ async def backport_start_tls(
     ssl_handshake_timeout=None,
 ):  # pragma: no cover
     """
-    Python 3.6 asyncio doesn't have a start_tls() method on the loop
+    Python 3.6 asyncio doesn't have a start_tls() method on the loop,
     so we use this function in place of the loop's start_tls() method.
     Adapted from this comment:
     https://github.com/urllib3/urllib3/issues/1323#issuecomment-362494839

python_socks/async_/trio/v2/_chain.py

@@ -1,31 +1,26 @@
-from typing import Iterable
+from typing import Sequence
 from ._proxy import TrioProxy
 
 
 class ProxyChain:
-    def __init__(self, proxies: Iterable[TrioProxy]):
+    def __init__(self, proxies: Sequence[TrioProxy]):
         self._proxies = proxies
 
-    async def connect(self, dest_host, dest_port,
-                      dest_ssl=None, timeout=None,):
-        _stream = None
-        proxies = list(self._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
 
-        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(
+        return await forward.connect(
             dest_host=dest_host,
             dest_port=dest_port,
             dest_ssl=dest_ssl,
             timeout=timeout,
-            _stream=_stream
         )
-
-        return _stream

python_socks/async_/trio/v2/_connect.py

@@ -1,15 +1,17 @@
 from typing import Optional, Tuple
 
 import trio
+from ._stream import TrioSocketStream
 
 
 async def connect_tcp(
     host: str,
     port: int,
     local_addr: Optional[Tuple[str, int]] = None,
-) -> trio.SocketStream:
-    return await trio.open_tcp_stream(
+) -> TrioSocketStream:
+    trio_stream = await trio.open_tcp_stream(
         host=host,
         port=port,
         local_address=local_addr,
     )
+    return TrioSocketStream(trio_stream)

python_socks/async_/trio/v2/_proxy.py

@@ -2,35 +2,30 @@ import ssl
 
 import trio
 
+from ._connect import connect_tcp
+from ._stream import TrioSocketStream
+from .._resolver import Resolver
 from ...._errors import ProxyConnectionError, ProxyTimeoutError
 from ...._proto.http_async import HttpProto
 from ...._proto.socks4_async import Socks4Proto
 from ...._proto.socks5_async import Socks5Proto
-from .._resolver import Resolver
-from ._stream import TrioSocketStream
-from ._connect import connect_tcp
-from .... import _abc as abc
 
 DEFAULT_TIMEOUT = 60
 
 
-class TrioProxy(abc.AsyncProxy):
+class TrioProxy:
     def __init__(
         self,
         proxy_host: str,
         proxy_port: int,
         proxy_ssl: ssl.SSLContext = None,
+        forward: 'TrioProxy' = None,
     ):
         self._proxy_host = proxy_host
         self._proxy_port = proxy_port
         self._proxy_ssl = proxy_ssl
+        self._forward = forward
 
-        self._dest_host = None
-        self._dest_port = None
-        self._dest_ssl = None
-        self._timeout = None
-
-        self._stream = None
         self._resolver = Resolver()
 
     async def connect(
@@ -39,74 +34,75 @@ class TrioProxy(abc.AsyncProxy):
         dest_port: int,
         dest_ssl: ssl.SSLContext = None,
         timeout: float = None,
-        _stream: TrioSocketStream = None,
     ) -> TrioSocketStream:
-
         if timeout is None:
             timeout = DEFAULT_TIMEOUT
 
-        self._dest_host = dest_host
-        self._dest_port = dest_port
-        self._dest_ssl = dest_ssl
-        self._timeout = timeout
-
         try:
-            with trio.fail_after(self._timeout):
-                if _stream is None:
-                    self._stream = TrioSocketStream(
-                        await connect_tcp(
-                            host=self._proxy_host,
-                            port=self._proxy_port,
-                        )
-                    )
-                else:
-                    self._stream = _stream
-
-                if self._proxy_ssl is not None:
-                    self._stream = await self._stream.start_tls(
-                        hostname=self._proxy_host,
-                        ssl_context=self._proxy_ssl,
-                    )
-
-                await self._negotiate()
-
-                if self._dest_ssl is not None:
-                    self._stream = await self._stream.start_tls(
-                        hostname=self._dest_host,
-                        ssl_context=self._dest_ssl,
-                    )
-
-                return self._stream
+            with trio.fail_after(timeout):
+                return await self._connect(
+                    dest_host=dest_host,
+                    dest_port=dest_port,
+                    dest_ssl=dest_ssl,
+                )
+        except trio.TooSlowError as e:
+            raise ProxyTimeoutError('Proxy connection timed out: {}'.format(timeout)) from e
 
+    async def _connect(
+        self,
+        dest_host: str,
+        dest_port: int,
+        dest_ssl: ssl.SSLContext = None,
+    ) -> TrioSocketStream:
+        try:
+            if self._forward is None:
+                stream = await connect_tcp(
+                    host=self._proxy_host,
+                    port=self._proxy_port,
+                )
+            else:
+                stream = await self._forward.connect(
+                    dest_host=self._proxy_host,
+                    dest_port=self._proxy_port,
+                )
         except OSError as e:
-            await self._close()
-            msg = 'Could not connect to proxy {}:{} [{}]'.format(
-                self._proxy_host,
-                self._proxy_port,
-                e.strerror,
-            )
-            raise ProxyConnectionError(e.errno, msg) from e
-        except trio.TooSlowError as e:
-            await self._close()
-            raise ProxyTimeoutError('Proxy connection timed out: {}'.format(self._timeout)) from e
-        except Exception:
-            await self._close()
-            raise
+            raise ProxyConnectionError(
+                e.errno,
+                f"Couldn't connect to proxy {self._proxy_host}:{self._proxy_port} [{e.strerror}]",
+            ) from e
 
-    async def _negotiate(self):
-        raise NotImplementedError
+        try:
+            if self._proxy_ssl is not None:
+                stream = await stream.start_tls(
+                    hostname=self._proxy_host,
+                    ssl_context=self._proxy_ssl,
+                )
+
+            await self._negotiate(
+                stream=stream,
+                dest_host=dest_host,
+                dest_port=dest_port,
+            )
 
-    async def _close(self):
-        if self._stream is not None:
-            await self._stream.close()
+            if dest_ssl is not None:
+                stream = await stream.start_tls(
+                    hostname=dest_host,
+                    ssl_context=dest_ssl,
+                )
+        except BaseException:  # trio.Cancelled...
+            with trio.CancelScope(shield=True):
+                await stream.close()
+            raise
 
-    @property
-    def proxy_host(self):
-        return self._proxy_host
+        return stream
 
-    @property
-    def proxy_port(self):
-        return self._proxy_port
+    async def _negotiate(
+        self,
+        stream: TrioSocketStream,
+        dest_host: str,
+        dest_port: int,
+    ):
+        raise NotImplementedError
 
 
 class Socks5Proxy(TrioProxy):
@@ -118,22 +114,29 @@ class Socks5Proxy(TrioProxy):
         password=None,
         rdns=None,
         proxy_ssl=None,
+        forward: 'TrioProxy' = None,
     ):
         super().__init__(
             proxy_host=proxy_host,
             proxy_port=proxy_port,
             proxy_ssl=proxy_ssl,
+            forward=forward,
         )
         self._username = username
         self._password = password
         self._rdns = rdns
 
-    async def _negotiate(self):
+    async def _negotiate(
+        self,
+        stream: TrioSocketStream,
+        dest_host: str,
+        dest_port: int,
+    ):
         proto = Socks5Proto(
-            stream=self._stream,
+            stream=stream,
             resolver=self._resolver,
-            dest_host=self._dest_host,
-            dest_port=self._dest_port,
+            dest_host=dest_host,
+            dest_port=dest_port,
             username=self._username,
             password=self._password,
             rdns=self._rdns,
@@ -149,21 +152,28 @@ class Socks4Proxy(TrioProxy):
         user_id=None,
         rdns=None,
         proxy_ssl=None,
+        forward: 'TrioProxy' = None,
     ):
         super().__init__(
             proxy_host=proxy_host,
             proxy_port=proxy_port,
             proxy_ssl=proxy_ssl,
+            forward=forward,
         )
         self._user_id = user_id
         self._rdns = rdns
 
-    async def _negotiate(self):
+    async def _negotiate(
+        self,
+        stream: TrioSocketStream,
+        dest_host: str,
+        dest_port: int,
+    ):
         proto = Socks4Proto(
-            stream=self._stream,
+            stream=stream,
             resolver=self._resolver,
-            dest_host=self._dest_host,
-            dest_port=self._dest_port,
+            dest_host=dest_host,
+            dest_port=dest_port,
             user_id=self._user_id,
             rdns=self._rdns,
         )
@@ -178,20 +188,27 @@ class HttpProxy(TrioProxy):
         username=None,
         password=None,
         proxy_ssl=None,
+        forward: 'TrioProxy' = None,
     ):
         super().__init__(
             proxy_host=proxy_host,
             proxy_port=proxy_port,
             proxy_ssl=proxy_ssl,
+            forward=forward,
         )
         self._username = username
         self._password = password
 
-    async def _negotiate(self):
+    async def _negotiate(
+        self,
+        stream: TrioSocketStream,
+        dest_host: str,
+        dest_port: int,
+    ):
         proto = HttpProto(
-            stream=self._stream,
-            dest_host=self._dest_host,
-            dest_port=self._dest_port,
+            stream=stream,
+            dest_host=dest_host,
+            dest_port=dest_port,
             username=self._username,
             password=self._password,
         )

python_socks/sync/v2/_chain.py

@@ -13,24 +13,14 @@ class ProxyChain:
         dest_ssl=None,
         timeout=None,
     ):
-        stream = None
-        proxies = list(self._proxies)
+        forward = None
+        for proxy in self._proxies:
+            proxy._forward = forward
+            forward = proxy
 
-        length = len(proxies) - 1
-        for i in range(length):
-            stream = proxies[i].connect(
-                dest_host=proxies[i + 1].proxy_host,
-                dest_port=proxies[i + 1].proxy_port,
-                timeout=timeout,
-                _stream=stream,
-            )
-
-        stream = proxies[length].connect(
+        return forward.connect(
             dest_host=dest_host,
             dest_port=dest_port,
             dest_ssl=dest_ssl,
             timeout=timeout,
-            _stream=stream,
         )
-
-        return stream

python_socks/sync/v2/_connect.py

@@ -0,0 +1,19 @@
+import socket
+from typing import Optional, Tuple
+from ._stream import SyncSocketStream
+
+
+def connect_tcp(
+    host: str,
+    port: int,
+    timeout: float = None,
+    local_addr: Optional[Tuple[str, int]] = None,
+) -> SyncSocketStream:
+    address = (host, port)
+    sock = socket.create_connection(
+        address,
+        timeout,
+        source_address=local_addr,
+    )
+
+    return SyncSocketStream(sock)