python-socks 2.1.1__tar.gz → 2.3.0__tar.gz

{python-socks-2.1.1/python_socks.egg-info → python-socks-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-socks
-Version: 2.1.1
+Version: 2.3.0
 Summary: Core proxy (SOCKS4, SOCKS5, HTTP tunneling) functionality for Python
 Home-page: https://github.com/romis2012/python-socks
 Author: Roman Snegirev

{python-socks-2.1.1 → python-socks-2.3.0}/python_socks/_version.py

@@ -1,2 +1,2 @@
 __title__ = 'python-socks'
-__version__ = '2.1.1'
+__version__ = '2.3.0'

python-socks-2.3.0/python_socks/async_/anyio/v2/_chain.py

@@ -0,0 +1,26 @@
+from typing import Sequence
+from ._proxy import AnyioProxy
+
+
+class ProxyChain:
+    def __init__(self, proxies: Sequence[AnyioProxy]):
+        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-2.3.0/python_socks/async_/anyio/v2/_connect.py

@@ -0,0 +1,16 @@
+import anyio
+import anyio.abc
+from ._stream import AnyioSocketStream
+
+
+async def connect_tcp(
+    host: str,
+    port: int,
+    local_host: str = None,
+) -> AnyioSocketStream:
+    s = await anyio.connect_tcp(
+        remote_host=host,
+        remote_port=port,
+        local_host=local_host,
+    )
+    return AnyioSocketStream(s)

python-socks-2.3.0/python_socks/async_/anyio/v2/_factory.py

@@ -0,0 +1,11 @@
+from ...._proxy_factory import ProxyFactory
+from ...._types import ProxyType
+from ._proxy import Socks5Proxy, Socks4Proxy, HttpProxy, AnyioProxy
+
+
+class Proxy(ProxyFactory[AnyioProxy]):
+    types = {
+        ProxyType.SOCKS4: Socks4Proxy,
+        ProxyType.SOCKS5: Socks5Proxy,
+        ProxyType.HTTP: HttpProxy,
+    }

python-socks-2.3.0/python_socks/async_/anyio/v2/_proxy.py

@@ -0,0 +1,215 @@
+import ssl
+
+import anyio
+
+from ._connect import connect_tcp
+from ._stream import AnyioSocketStream
+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
+
+DEFAULT_TIMEOUT = 60
+
+
+class AnyioProxy:
+    def __init__(
+        self,
+        proxy_host: str,
+        proxy_port: int,
+        proxy_ssl: ssl.SSLContext = None,
+        forward: 'AnyioProxy' = None,
+    ):
+        self._proxy_host = proxy_host
+        self._proxy_port = proxy_port
+        self._proxy_ssl = proxy_ssl
+        self._forward = forward
+
+        self._resolver = Resolver()
+
+    async def connect(
+        self,
+        dest_host: str,
+        dest_port: int,
+        dest_ssl: ssl.SSLContext = None,
+        timeout: float = None,
+    ) -> AnyioSocketStream:
+        if timeout is None:
+            timeout = DEFAULT_TIMEOUT
+
+        try:
+            with anyio.fail_after(timeout):
+                return await self._connect(
+                    dest_host=dest_host,
+                    dest_port=dest_port,
+                    dest_ssl=dest_ssl,
+                )
+        except TimeoutError 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,
+    ) -> AnyioSocketStream:
+        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:
+            raise ProxyConnectionError(
+                e.errno,
+                f"Couldn't connect to proxy {self._proxy_host}:{self._proxy_port} [{e.strerror}]",
+            ) from e
+
+        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,
+            )
+
+            if dest_ssl is not None:
+                stream = await stream.start_tls(
+                    hostname=dest_host,
+                    ssl_context=dest_ssl,
+                )
+        except BaseException:
+            with anyio.CancelScope(shield=True):
+                await stream.close()
+            raise
+
+        return stream
+
+    async def _negotiate(
+        self,
+        stream: AnyioSocketStream,
+        dest_host: str,
+        dest_port: int,
+    ):
+        raise NotImplementedError()
+
+
+class Socks5Proxy(AnyioProxy):
+    def __init__(
+        self,
+        proxy_host,
+        proxy_port,
+        username=None,
+        password=None,
+        rdns=None,
+        proxy_ssl=None,
+        forward: 'AnyioProxy' = 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,
+        stream: AnyioSocketStream,
+        dest_host: str,
+        dest_port: int,
+    ):
+        proto = Socks5Proto(
+            stream=stream,
+            resolver=self._resolver,
+            dest_host=dest_host,
+            dest_port=dest_port,
+            username=self._username,
+            password=self._password,
+            rdns=self._rdns,
+        )
+        await proto.negotiate()
+
+
+class Socks4Proxy(AnyioProxy):
+    def __init__(
+        self,
+        proxy_host,
+        proxy_port,
+        user_id=None,
+        rdns=None,
+        proxy_ssl=None,
+        forward: 'AnyioProxy' = 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,
+        stream: AnyioSocketStream,
+        dest_host: str,
+        dest_port: int,
+    ):
+        proto = Socks4Proto(
+            stream=stream,
+            resolver=self._resolver,
+            dest_host=dest_host,
+            dest_port=dest_port,
+            user_id=self._user_id,
+            rdns=self._rdns,
+        )
+        await proto.negotiate()
+
+
+class HttpProxy(AnyioProxy):
+    def __init__(
+        self,
+        proxy_host,
+        proxy_port,
+        username=None,
+        password=None,
+        proxy_ssl=None,
+        forward: 'AnyioProxy' = 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,
+        stream: AnyioSocketStream,
+        dest_host: str,
+        dest_port: int,
+    ):
+        proto = HttpProto(
+            stream=stream,
+            dest_host=dest_host,
+            dest_port=dest_port,
+            username=self._username,
+            password=self._password,
+        )
+        await proto.negotiate()

python-socks-2.3.0/python_socks/async_/anyio/v2/_stream.py

@@ -0,0 +1,59 @@
+import ssl
+from typing import Union
+
+import anyio
+import anyio.abc
+from anyio.streams.tls import TLSStream
+
+from ...._errors import ProxyError
+from .... import _abc as abc
+
+DEFAULT_RECEIVE_SIZE = 65536
+
+AnyioStreamType = Union[anyio.abc.SocketStream, TLSStream]
+
+
+class AnyioSocketStream(abc.AsyncSocketStream):
+    _stream: AnyioStreamType
+
+    def __init__(self, stream: AnyioStreamType) -> None:
+        self._stream = stream
+
+    async def write_all(self, data: bytes):
+        await self._stream.send(item=data)
+
+    async def read(self, max_bytes: int = DEFAULT_RECEIVE_SIZE):
+        try:
+            return await self._stream.receive(max_bytes=max_bytes)
+        except anyio.EndOfStream:  # pragma: no cover
+            return b""
+
+    async def read_exact(self, n: int):
+        data = bytearray()
+        while len(data) < n:
+            packet = await self.read(n - len(data))
+            if not packet:  # pragma: no cover
+                raise ProxyError('Connection closed unexpectedly')
+            data += packet
+        return data
+
+    async def start_tls(
+        self,
+        hostname: str,
+        ssl_context: ssl.SSLContext,
+    ) -> 'AnyioSocketStream':
+        ssl_stream = await TLSStream.wrap(
+            self._stream,
+            ssl_context=ssl_context,
+            hostname=hostname,
+            standard_compatible=False,
+            server_side=False,
+        )
+        return AnyioSocketStream(ssl_stream)
+
+    async def close(self):
+        await self._stream.aclose()
+
+    @property
+    def anyio_stream(self) -> AnyioStreamType:  # pragma: no cover
+        return self._stream

python-socks-2.3.0/python_socks/async_/asyncio/v2/_chain.py

@@ -0,0 +1,26 @@
+from typing import Sequence
+from ._proxy import AsyncioProxy
+
+
+class ProxyChain:
+    def __init__(self, proxies: Sequence[AsyncioProxy]):
+        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-2.1.1 → python-socks-2.3.0}/python_socks/async_/asyncio/v2/_connect.py

@@ -1,16 +1,17 @@
 import asyncio
 from typing import Optional, Tuple
+from ._stream import AsyncioSocketStream
 
 
 async def connect_tcp(
     host: str,
     port: int,
+    loop: asyncio.AbstractEventLoop,
     local_addr: Optional[Tuple[str, int]] = None,
-) -> Tuple[asyncio.StreamReader, asyncio.StreamWriter]:
-
+) -> AsyncioSocketStream:
     kwargs = {}
     if local_addr is not None:
-        kwargs['local_addr'] = local_addr   # pragma: no cover
+        kwargs['local_addr'] = local_addr  # pragma: no cover
 
     reader, writer = await asyncio.open_connection(
         host=host,
@@ -18,4 +19,8 @@ async def connect_tcp(
         **kwargs,
     )
 
-    return reader, writer
+    return AsyncioSocketStream(
+        loop=loop,
+        reader=reader,
+        writer=writer,
+    )

{python-socks-2.1.1 → python-socks-2.3.0}/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-2.1.1 → python-socks-2.3.0}/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