python-socks 2.5.3__py3-none-any.whl → 2.6.1__py3-none-any.whl

python_socks/async_/asyncio/_proxy.py

@@ -1,11 +1,8 @@
 import asyncio
 import socket
 import sys
-
-if sys.version_info >= (3, 11):
-    import asyncio as async_timeout
-else:
-    import async_timeout
+from typing import Any, Optional
+import warnings
 
 from ..._types import ProxyType
 from ..._helpers import parse_proxy_url
@@ -17,21 +14,25 @@ from ..._protocols.errors import ReplyError
 from ..._connectors.factory_async import create_connector
 
 from ._connect import connect_tcp
-from ... import _abc as abc
+
+if sys.version_info >= (3, 11):
+    import asyncio as async_timeout  # pylint:disable=reimported
+else:
+    import async_timeout
 
 DEFAULT_TIMEOUT = 60
 
 
-class AsyncioProxy(abc.AsyncProxy):
+class AsyncioProxy:
     def __init__(
         self,
         proxy_type: ProxyType,
         host: str,
         port: int,
-        username: str = None,
-        password: str = None,
-        rdns: bool = None,
-        loop: asyncio.AbstractEventLoop = None,
+        username: Optional[str] = None,
+        password: Optional[str] = None,
+        rdns: Optional[bool] = None,
+        loop: Optional[asyncio.AbstractEventLoop] = None,
     ):
         if loop is None:
             loop = asyncio.get_event_loop()
@@ -51,29 +52,46 @@ class AsyncioProxy(abc.AsyncProxy):
         self,
         dest_host: str,
         dest_port: int,
-        timeout: float = None,
-        _socket=None,
+        timeout: Optional[float] = None,
+        **kwargs: Any,
     ) -> socket.socket:
         if timeout is None:
             timeout = DEFAULT_TIMEOUT
 
+        _socket = kwargs.get('_socket')
+        if _socket is not None:
+            warnings.warn(
+                "The '_socket' argument is deprecated and will be removed in the future",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+
+        local_addr = kwargs.get('local_addr')
         try:
             async with async_timeout.timeout(timeout):
                 return await self._connect(
                     dest_host=dest_host,
                     dest_port=dest_port,
                     _socket=_socket,
+                    local_addr=local_addr,
                 )
         except asyncio.TimeoutError as e:
             raise ProxyTimeoutError(f'Proxy connection timed out: {timeout}') from e
 
-    async def _connect(self, dest_host, dest_port, _socket=None) -> socket.socket:
+    async def _connect(
+        self,
+        dest_host,
+        dest_port,
+        _socket=None,
+        local_addr=None,
+    ) -> socket.socket:
         if _socket is None:
             try:
                 _socket = await connect_tcp(
                     host=self._proxy_host,
                     port=self._proxy_port,
                     loop=self._loop,
+                    local_addr=local_addr,
                 )
             except OSError as e:
                 msg = 'Could not connect to proxy {}:{} [{}]'.format(
@@ -100,36 +118,13 @@ class AsyncioProxy(abc.AsyncProxy):
             )
 
             return _socket
-        except asyncio.CancelledError:  # pragma: no cover
-            # https://bugs.python.org/issue30064
-            # https://bugs.python.org/issue34795
-            if self._can_be_closed_safely():
-                await stream.close()
-            raise
         except ReplyError as e:
             await stream.close()
             raise ProxyError(e, error_code=e.error_code)
-        except Exception:  # pragma: no cover
+        except (asyncio.CancelledError, Exception):  # pragma: no cover
             await stream.close()
             raise
 
-    def _can_be_closed_safely(self):  # pragma: no cover
-        def is_proactor_event_loop():
-            try:
-                from asyncio import ProactorEventLoop  # noqa
-            except ImportError:
-                return False
-            return isinstance(self._loop, ProactorEventLoop)
-
-        def is_uvloop_event_loop():
-            try:
-                from uvloop import Loop  # noqa
-            except ImportError:
-                return False
-            return isinstance(self._loop, Loop)
-
-        return sys.version_info[:2] >= (3, 8) or is_proactor_event_loop() or is_uvloop_event_loop()
-
     @property
     def proxy_host(self):
         return self._proxy_host
@@ -139,10 +134,10 @@ class AsyncioProxy(abc.AsyncProxy):
         return self._proxy_port
 
     @classmethod
-    def create(cls, *args, **kwargs):
+    def create(cls, *args, **kwargs):  # for backward compatibility
         return cls(*args, **kwargs)
 
     @classmethod
-    def from_url(cls, url: str, **kwargs):
+    def from_url(cls, url: str, **kwargs) -> 'AsyncioProxy':
         url_args = parse_proxy_url(url)
         return cls(*url_args, **kwargs)

python_socks/async_/asyncio/v2/_chain.py

@@ -1,9 +1,15 @@
 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(

python_socks/async_/asyncio/v2/_connect.py

@@ -16,7 +16,7 @@ async def connect_tcp(
     reader, writer = await asyncio.open_connection(
         host=host,
         port=port,
-        **kwargs,
+        **kwargs,  # type: ignore
     )
 
     return AsyncioSocketStream(

python_socks/async_/asyncio/v2/_proxy.py

@@ -1,14 +1,10 @@
 import asyncio
 import ssl
+from typing import Any, Optional, Tuple
 import warnings
 import sys
 
 
-if sys.version_info >= (3, 11):
-    import asyncio as async_timeout
-else:
-    import async_timeout
-
 from ...._types import ProxyType
 from ...._helpers import parse_proxy_url
 from ...._errors import ProxyConnectionError, ProxyTimeoutError, ProxyError
@@ -20,6 +16,12 @@ from .._resolver import Resolver
 from ._stream import AsyncioSocketStream
 from ._connect import connect_tcp
 
+if sys.version_info >= (3, 11):
+    import asyncio as async_timeout  # pylint:disable=reimported
+else:
+    import async_timeout
+
+
 DEFAULT_TIMEOUT = 60
 
 
@@ -29,12 +31,12 @@ class AsyncioProxy:
         proxy_type: ProxyType,
         host: str,
         port: int,
-        username: str = None,
-        password: str = None,
-        rdns: bool = None,
-        proxy_ssl: ssl.SSLContext = None,
-        forward: 'AsyncioProxy' = None,
-        loop: asyncio.AbstractEventLoop = None,
+        username: Optional[str] = None,
+        password: Optional[str] = None,
+        rdns: Optional[bool] = None,
+        proxy_ssl: Optional[ssl.SSLContext] = None,
+        forward: Optional['AsyncioProxy'] = None,
+        loop: Optional[asyncio.AbstractEventLoop] = None,
     ):
         if loop is not None:  # pragma: no cover
             warnings.warn(
@@ -64,18 +66,21 @@ class AsyncioProxy:
         self,
         dest_host: str,
         dest_port: int,
-        dest_ssl: ssl.SSLContext = None,
-        timeout: float = None,
+        dest_ssl: Optional[ssl.SSLContext] = None,
+        timeout: Optional[float] = None,
+        **kwargs: Any,
     ) -> AsyncioSocketStream:
         if timeout is None:
             timeout = DEFAULT_TIMEOUT
 
+        local_addr = kwargs.get('local_addr')
         try:
             async with async_timeout.timeout(timeout):
                 return await self._connect(
                     dest_host=dest_host,
                     dest_port=dest_port,
                     dest_ssl=dest_ssl,
+                    local_addr=local_addr,
                 )
         except asyncio.TimeoutError as e:
             raise ProxyTimeoutError('Proxy connection timed out: {}'.format(timeout)) from e
@@ -84,7 +89,8 @@ class AsyncioProxy:
         self,
         dest_host: str,
         dest_port: int,
-        dest_ssl: ssl.SSLContext = None,
+        dest_ssl: Optional[ssl.SSLContext] = None,
+        local_addr: Optional[Tuple[str, int]] = None,
     ) -> AsyncioSocketStream:
         if self._forward is None:
             try:
@@ -92,6 +98,7 @@ class AsyncioProxy:
                     host=self._proxy_host,
                     port=self._proxy_port,
                     loop=self._loop,
+                    local_addr=local_addr,
                 )
             except OSError as e:
                 raise ProxyConnectionError(
@@ -141,10 +148,10 @@ class AsyncioProxy:
         return stream
 
     @classmethod
-    def create(cls, *args, **kwargs):
+    def create(cls, *args, **kwargs):  # for backward compatibility
         return cls(*args, **kwargs)
 
     @classmethod
-    def from_url(cls, url: str, **kwargs):
+    def from_url(cls, url: str, **kwargs) -> 'AsyncioProxy':
         url_args = parse_proxy_url(url)
         return cls(*url_args, **kwargs)

python_socks/async_/asyncio/v2/_stream.py

@@ -6,48 +6,10 @@ from .... import _abc as abc
 DEFAULT_RECEIVE_SIZE = 65536
 
 
-# noinspection PyUnusedLocal
-async def backport_start_tls(
-    transport,
-    protocol,
-    ssl_context,
-    *,
-    server_side=False,
-    server_hostname=None,
-    ssl_handshake_timeout=None,
-):  # pragma: no cover
-    """
-    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
-    """
-    import asyncio.sslproto
-
-    loop = asyncio.get_event_loop()
-    waiter = loop.create_future()
-    ssl_protocol = asyncio.sslproto.SSLProtocol(
-        loop,
-        protocol,
-        ssl_context,
-        waiter,
-        server_side=False,
-        server_hostname=server_hostname,
-        call_connection_made=False,
-    )
-
-    transport.set_protocol(ssl_protocol)
-    loop.call_soon(ssl_protocol.connection_made, transport)
-    loop.call_soon(transport.resume_reading)  # type: ignore
-
-    await waiter
-    return ssl_protocol._app_transport  # noqa
-
-
 class AsyncioSocketStream(abc.AsyncSocketStream):
-    _loop: asyncio.AbstractEventLoop = None
-    _reader: asyncio.StreamReader = None
-    _writer: asyncio.StreamWriter = None
+    _loop: asyncio.AbstractEventLoop
+    _reader: asyncio.StreamReader
+    _writer: asyncio.StreamWriter
 
     def __init__(
         self,
@@ -86,9 +48,7 @@ class AsyncioSocketStream(abc.AsyncSocketStream):
         reader = asyncio.StreamReader()
         protocol = asyncio.StreamReaderProtocol(reader)
 
-        loop_start_tls = getattr(self._loop, 'start_tls', backport_start_tls)
-
-        transport = await loop_start_tls(
+        transport: asyncio.Transport = await self._loop.start_tls(
             self._writer.transport,  # type: ignore
             protocol,
             ssl_context,
@@ -115,7 +75,7 @@ class AsyncioSocketStream(abc.AsyncSocketStream):
         # When we return a new SocketStream with new StreamReader/StreamWriter instances
         # we need to keep references to the old StreamReader/StreamWriter so that they
         # are not garbage collected and closed while we're still using them.
-        stream._inner = self  # type: ignore
+        stream._inner = self  # type: ignore # pylint:disable=W0212,W0201
         return stream
 
     async def close(self):

python_socks/async_/curio/_proxy.py

@@ -1,3 +1,5 @@
+from typing import Any, Optional
+import warnings
 import curio
 import curio.io
 
@@ -12,20 +14,19 @@ from ._connect import connect_tcp
 from ..._protocols.errors import ReplyError
 from ..._connectors.factory_async import create_connector
 
-from ... import _abc as abc
 
 DEFAULT_TIMEOUT = 60
 
 
-class CurioProxy(abc.AsyncProxy):
+class CurioProxy:
     def __init__(
         self,
         proxy_type: ProxyType,
         host: str,
         port: int,
-        username: str = None,
-        password: str = None,
-        rdns: bool = None,
+        username: Optional[str] = None,
+        password: Optional[str] = None,
+        rdns: Optional[bool] = None,
     ):
         self._proxy_type = proxy_type
         self._proxy_host = host
@@ -40,12 +41,21 @@ class CurioProxy(abc.AsyncProxy):
         self,
         dest_host: str,
         dest_port: int,
-        timeout: float = None,
-        _socket=None,
+        timeout: Optional[float] = None,
+        **kwargs: Any,
     ) -> curio.io.Socket:
         if timeout is None:
             timeout = DEFAULT_TIMEOUT
 
+        _socket = kwargs.get('_socket')
+        if _socket is not None:
+            warnings.warn(
+                "The '_socket' argument is deprecated and will be removed in the future",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+
+        local_addr = kwargs.get('local_addr')
         try:
             return await curio.timeout_after(
                 timeout,
@@ -53,6 +63,7 @@ class CurioProxy(abc.AsyncProxy):
                 dest_host,
                 dest_port,
                 _socket,
+                local_addr,
             )
         except curio.TaskTimeout as e:
             raise ProxyTimeoutError(f'Proxy connection timed out: {timeout}') from e
@@ -62,12 +73,14 @@ class CurioProxy(abc.AsyncProxy):
         dest_host: str,
         dest_port: int,
         _socket=None,
+        local_addr=None,
     ):
         if _socket is None:
             try:
                 _socket = await connect_tcp(
                     host=self._proxy_host,
                     port=self._proxy_port,
+                    local_addr=local_addr,
                 )
             except OSError as e:
                 msg = 'Could not connect to proxy {}:{} [{}]'.format(
@@ -110,10 +123,10 @@ class CurioProxy(abc.AsyncProxy):
         return self._proxy_port
 
     @classmethod
-    def create(cls, *args, **kwargs):
+    def create(cls, *args, **kwargs):  # for backward compatibility
         return cls(*args, **kwargs)
 
     @classmethod
-    def from_url(cls, url: str, **kwargs):
+    def from_url(cls, url: str, **kwargs) -> 'CurioProxy':
         url_args = parse_proxy_url(url)
         return cls(*url_args, **kwargs)

python_socks/async_/trio/_proxy.py

@@ -1,3 +1,5 @@
+from typing import Any, Optional
+import warnings
 import trio
 
 from ..._types import ProxyType
@@ -11,20 +13,19 @@ from ._connect import connect_tcp
 from ..._protocols.errors import ReplyError
 from ..._connectors.factory_async import create_connector
 
-from ... import _abc as abc
 
 DEFAULT_TIMEOUT = 60
 
 
-class TrioProxy(abc.AsyncProxy):
+class TrioProxy:
     def __init__(
         self,
         proxy_type: ProxyType,
         host: str,
         port: int,
-        username: str = None,
-        password: str = None,
-        rdns: bool = None,
+        username: Optional[str] = None,
+        password: Optional[str] = None,
+        rdns: Optional[bool] = None,
     ):
         self._proxy_type = proxy_type
         self._proxy_host = host
@@ -39,18 +40,28 @@ class TrioProxy(abc.AsyncProxy):
         self,
         dest_host: str,
         dest_port: int,
-        timeout: float = None,
-        _socket=None,
+        timeout: Optional[float] = None,
+        **kwargs: Any,
     ) -> trio.socket.SocketType:
         if timeout is None:
             timeout = DEFAULT_TIMEOUT
 
+        _socket = kwargs.get('_socket')
+        if _socket is not None:
+            warnings.warn(
+                "The '_socket' argument is deprecated and will be removed in the future",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+
+        local_addr = kwargs.get('local_addr')
         try:
             with trio.fail_after(timeout):
                 return await self._connect(
                     dest_host=dest_host,
                     dest_port=dest_port,
                     _socket=_socket,
+                    local_addr=local_addr,
                 )
         except trio.TooSlowError as e:
             raise ProxyTimeoutError('Proxy connection timed out: {}'.format(timeout)) from e
@@ -60,12 +71,14 @@ class TrioProxy(abc.AsyncProxy):
         dest_host: str,
         dest_port: int,
         _socket=None,
+        local_addr=None,
     ) -> trio.socket.SocketType:
         if _socket is None:
             try:
                 _socket = await connect_tcp(
                     host=self._proxy_host,
                     port=self._proxy_port,
+                    local_addr=local_addr,
                 )
             except OSError as e:
                 msg = 'Could not connect to proxy {}:{} [{}]'.format(
@@ -109,10 +122,10 @@ class TrioProxy(abc.AsyncProxy):
         return self._proxy_port
 
     @classmethod
-    def create(cls, *args, **kwargs):
+    def create(cls, *args, **kwargs):  # for backward compatibility
         return cls(*args, **kwargs)
 
     @classmethod
-    def from_url(cls, url: str, **kwargs):
+    def from_url(cls, url: str, **kwargs) -> 'TrioProxy':
         url_args = parse_proxy_url(url)
         return cls(*url_args, **kwargs)

python_socks/async_/trio/v2/_chain.py

@@ -1,9 +1,15 @@
 from typing import Sequence
+import warnings
 from ._proxy import TrioProxy
 
 
 class ProxyChain:
     def __init__(self, proxies: Sequence[TrioProxy]):
+        warnings.warn(
+            'This implementation of ProxyChain is deprecated and will be removed in the future',
+            DeprecationWarning,
+            stacklevel=2,
+        )
         self._proxies = proxies
 
     async def connect(

python_socks/async_/trio/v2/_connect.py

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

python_socks/async_/trio/v2/_proxy.py

@@ -1,4 +1,5 @@
 import ssl
+from typing import Any, Optional
 
 import trio
 
@@ -22,11 +23,11 @@ class TrioProxy:
         proxy_type: ProxyType,
         host: str,
         port: int,
-        username: str = None,
-        password: str = None,
-        rdns: bool = None,
-        proxy_ssl: ssl.SSLContext = None,
-        forward: 'TrioProxy' = None,
+        username: Optional[str] = None,
+        password: Optional[str] = None,
+        rdns: Optional[bool] = None,
+        proxy_ssl: Optional[ssl.SSLContext] = None,
+        forward: Optional['TrioProxy'] = None,
     ):
         self._proxy_type = proxy_type
         self._proxy_host = host
@@ -44,18 +45,21 @@ class TrioProxy:
         self,
         dest_host: str,
         dest_port: int,
-        dest_ssl: ssl.SSLContext = None,
-        timeout: float = None,
+        dest_ssl: Optional[ssl.SSLContext] = None,
+        timeout: Optional[float] = None,
+        **kwargs: Any,
     ) -> TrioSocketStream:
         if timeout is None:
             timeout = DEFAULT_TIMEOUT
 
+        local_addr = kwargs.get('local_addr')
         try:
             with trio.fail_after(timeout):
                 return await self._connect(
                     dest_host=dest_host,
                     dest_port=dest_port,
                     dest_ssl=dest_ssl,
+                    local_addr=local_addr,
                 )
         except trio.TooSlowError as e:
             raise ProxyTimeoutError(f'Proxy connection timed out: {timeout}') from e
@@ -64,13 +68,15 @@ class TrioProxy:
         self,
         dest_host: str,
         dest_port: int,
-        dest_ssl: ssl.SSLContext = None,
+        dest_ssl: Optional[ssl.SSLContext] = None,
+        local_addr: Optional[str] = None,
     ) -> TrioSocketStream:
         if self._forward is None:
             try:
                 stream = await connect_tcp(
                     host=self._proxy_host,
                     port=self._proxy_port,
+                    local_addr=local_addr,
                 )
             except OSError as e:
                 raise ProxyConnectionError(
@@ -120,10 +126,10 @@ class TrioProxy:
         return stream
 
     @classmethod
-    def create(cls, *args, **kwargs):
+    def create(cls, *args, **kwargs):  # for backward compatibility
         return cls(*args, **kwargs)
 
     @classmethod
-    def from_url(cls, url: str, **kwargs):
+    def from_url(cls, url: str, **kwargs) -> 'TrioProxy':
         url_args = parse_proxy_url(url)
         return cls(*url_args, **kwargs)

python_socks/sync/_chain.py

@@ -1,9 +1,15 @@
 from typing import Iterable
+import warnings
 from ._proxy import SyncProxy
 
 
 class ProxyChain:
     def __init__(self, proxies: Iterable[SyncProxy]):
+        warnings.warn(
+            'This implementation of ProxyChain is deprecated and will be removed in the future',
+            DeprecationWarning,
+            stacklevel=2,
+        )
         self._proxies = proxies
 
     def connect(self, dest_host, dest_port, timeout=None):
@@ -16,14 +22,11 @@ class ProxyChain:
                 dest_host=proxies[i + 1].proxy_host,
                 dest_port=proxies[i + 1].proxy_port,
                 timeout=timeout,
-                _socket=curr_socket
+                _socket=curr_socket,
             )
 
         curr_socket = proxies[length].connect(
-            dest_host=dest_host,
-            dest_port=dest_port,
-            timeout=timeout,
-            _socket=curr_socket
+            dest_host=dest_host, dest_port=dest_port, timeout=timeout, _socket=curr_socket
         )
 
         return curr_socket

python_socks/sync/_connect.py

@@ -5,7 +5,7 @@ from typing import Optional, Tuple
 def connect_tcp(
     host: str,
     port: int,
-    timeout: float = None,
+    timeout: Optional[float] = None,
     local_addr: Optional[Tuple[str, int]] = None,
 ) -> socket.socket:
     address = (host, port)