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

python_socks/async_/trio/v2/_stream.py

@@ -1,10 +1,12 @@
+from __future__ import annotations
+
 import ssl
 from typing import Union
 
 import trio
 
-from ...._errors import ProxyError
 from .... import _abc as abc
+from ...._errors import IncompleteReadError
 
 DEFAULT_RECEIVE_SIZE = 65536
 
@@ -12,31 +14,29 @@ TrioStreamType = Union[trio.SocketStream, trio.SSLStream]
 
 
 class TrioSocketStream(abc.AsyncSocketStream):
-    _stream: TrioStreamType
-
-    def __init__(self, stream: TrioStreamType):
+    def __init__(self, stream: TrioStreamType) -> None:
         self._stream = stream
 
-    async def write_all(self, data):
+    async def write(self, data: bytes) -> None:
         await self._stream.send_all(data)
 
-    async def read(self, max_bytes=DEFAULT_RECEIVE_SIZE):
-        return await self._stream.receive_some(max_bytes)
+    async def read(self, max_bytes: int = DEFAULT_RECEIVE_SIZE) -> bytes:
+        return await self._stream.receive_some(max_bytes)  # type:ignore[return-value]
 
-    async def read_exact(self, n):
+    async def read_exactly(self, n: int) -> bytes:
         data = bytearray()
         while len(data) < n:
             packet = await self._stream.receive_some(n - len(data))
             if not packet:  # pragma: no cover
-                raise ProxyError('Connection closed unexpectedly')
-            data += packet
-        return data
+                raise IncompleteReadError("Connection closed unexpectedly")
+            data.extend(packet)
+        return data  # type:ignore[return-value]
 
     async def start_tls(
         self,
         hostname: str,
         ssl_context: ssl.SSLContext,
-    ) -> 'TrioSocketStream':
+    ) -> TrioSocketStream:
         ssl_stream = trio.SSLStream(
             self._stream,
             ssl_context=ssl_context,
@@ -47,7 +47,7 @@ class TrioSocketStream(abc.AsyncSocketStream):
         await ssl_stream.do_handshake()
         return TrioSocketStream(ssl_stream)
 
-    async def close(self):
+    async def close(self) -> None:
         await self._stream.aclose()
 
     @property

python_socks/sync/__init__.py

@@ -1,5 +1,3 @@
 from ._proxy import SyncProxy as Proxy
-from ._chain import ProxyChain
 
-
-__all__ = ('Proxy', 'ProxyChain')
+__all__ = ("Proxy",)

python_socks/sync/_connect.py

@@ -1,12 +1,13 @@
+from __future__ import annotations
+
 import socket
-from typing import Optional, Tuple
 
 
 def connect_tcp(
     host: str,
     port: int,
-    timeout: Optional[float] = None,
-    local_addr: Optional[Tuple[str, int]] = None,
+    timeout: float | None = None,
+    local_addr: tuple[str, int] | None = None,
 ) -> socket.socket:
     address = (host, port)
     return socket.create_connection(

python_socks/sync/_proxy.py

@@ -1,18 +1,21 @@
-import socket
-from typing import Optional, Any
-import warnings
+from __future__ import annotations
 
-from .._errors import ProxyConnectionError, ProxyTimeoutError, ProxyError
+import socket
+from typing import Any
 
-from .._types import ProxyType
+from .._connectors.factory_sync import create_connector
+from .._errors import (
+    IncompleteReadError,
+    ProxyConnectionError,
+    ProxyError,
+    ProxyTimeoutError,
+)
 from .._helpers import parse_proxy_url
 from .._protocols.errors import ReplyError
-from .._connectors.factory_sync import create_connector
-
-from ._stream import SyncSocketStream
-from ._resolver import SyncResolver
+from .._types import ProxyType
 from ._connect import connect_tcp
-
+from ._resolver import SyncResolver
+from ._stream import SyncSocketStream
 
 DEFAULT_TIMEOUT = 60
 
@@ -23,16 +26,18 @@ class SyncProxy:
         proxy_type: ProxyType,
         host: str,
         port: int,
-        username: Optional[str] = None,
-        password: Optional[str] = None,
-        rdns: Optional[bool] = None,
-    ):
+        username: str | None = None,
+        password: str | None = None,
+        rdns: bool | None = None,  # noqa: FBT001
+        forward: SyncProxy | None = None,
+    ) -> None:
         self._proxy_type = proxy_type
         self._proxy_host = host
         self._proxy_port = port
         self._password = password
         self._username = username
         self._rdns = rdns
+        self._forward = forward
 
         self._resolver = SyncResolver()
 
@@ -40,38 +45,35 @@ class SyncProxy:
         self,
         dest_host: str,
         dest_port: int,
-        timeout: Optional[float] = None,
+        timeout: float | None = 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,
+        if self._forward is not None:
+            sock = self._forward.connect(
+                dest_host=self._proxy_host,
+                dest_port=self._proxy_port,
+                timeout=timeout,
             )
-
-        if _socket is None:
-            local_addr = kwargs.get('local_addr')
+        else:
+            local_addr = kwargs.get("local_addr")
             try:
-                _socket = connect_tcp(
+                sock = connect_tcp(
                     host=self._proxy_host,
                     port=self._proxy_port,
                     timeout=timeout,
                     local_addr=local_addr,
                 )
             except OSError as e:
-                msg = 'Could not connect to proxy {}:{} [{}]'.format(
-                    self._proxy_host,
-                    self._proxy_port,
-                    e.strerror,
+                msg = (
+                    f"Could not connect to proxy "
+                    f"{self._proxy_host}:{self._proxy_port} [{e.strerror}]"
                 )
                 raise ProxyConnectionError(e.errno, msg) from e
 
-        stream = SyncSocketStream(_socket)
+        stream = SyncSocketStream(sock)
 
         try:
             connector = create_connector(
@@ -87,30 +89,27 @@ class SyncProxy:
                 port=dest_port,
             )
 
-            return _socket
+            return sock
         except socket.timeout as e:
             stream.close()
-            raise ProxyTimeoutError('Proxy connection timed out: {}'.format(timeout)) from e
+            raise ProxyTimeoutError(f"Proxy connection timed out: {timeout}") from e
         except ReplyError as e:
             stream.close()
-            raise ProxyError(e, error_code=e.error_code)
+            raise ProxyError(e, error_code=e.error_code) from e
+        except IncompleteReadError as e:
+            stream.close()
+            raise ProxyError(e) from e
         except Exception:
             stream.close()
             raise
 
-    @property
-    def proxy_host(self):
-        return self._proxy_host
-
-    @property
-    def proxy_port(self):
-        return self._proxy_port
-
     @classmethod
-    def create(cls, *args, **kwargs):  # for backward compatibility
+    def create(
+        cls, *args: Any, **kwargs: Any
+    ) -> SyncProxy:  # for backward compatibility
         return cls(*args, **kwargs)
 
     @classmethod
-    def from_url(cls, url: str, **kwargs) -> 'SyncProxy':
+    def from_url(cls, url: str, **kwargs: Any) -> SyncProxy:
         url_args = parse_proxy_url(url)
         return cls(*url_args, **kwargs)

python_socks/sync/_resolver.py

@@ -1,16 +1,28 @@
 import socket
+
 from .. import _abc as abc
+from .._types import ResolvedAddress
 
 
 class SyncResolver(abc.SyncResolver):
-    # noinspection PyMethodMayBeStatic
-    def resolve(self, host, port=0, family=socket.AF_UNSPEC):
-        infos = socket.getaddrinfo(host=host, port=port, family=family, type=socket.SOCK_STREAM)
+    def resolve(
+        self,
+        host: str,
+        port: int = 0,
+        family: socket.AddressFamily = socket.AF_UNSPEC,
+    ) -> ResolvedAddress:
+        infos = socket.getaddrinfo(
+            host=host,
+            port=port,
+            family=family,
+            type=socket.SOCK_STREAM,
+        )
 
         if not infos:  # pragma: no cover
-            raise OSError('Can`t resolve address {}:{} [{}]'.format(host, port, family))
+            raise OSError(f"Can`t resolve address {host}:{port} [{family}]")
 
+        # use IPv4 address first
         infos = sorted(infos, key=lambda info: info[0])
 
         family, _, _, _, address = infos[0]
-        return family, address[0]
+        return family, address[0]  # type: ignore[return-value]

python_socks/sync/_stream.py

@@ -1,7 +1,7 @@
 import socket
 
-from .._errors import ProxyError
 from .. import _abc as abc
+from .._errors import IncompleteReadError
 
 DEFAULT_RECEIVE_SIZE = 65536
 
@@ -9,24 +9,24 @@ DEFAULT_RECEIVE_SIZE = 65536
 class SyncSocketStream(abc.SyncSocketStream):
     _socket: socket.socket
 
-    def __init__(self, sock: socket.socket):
+    def __init__(self, sock: socket.socket) -> None:
         self._socket = sock
 
-    def write_all(self, data):
+    def write(self, data: bytes) -> None:
         self._socket.sendall(data)
 
-    def read(self, max_bytes=DEFAULT_RECEIVE_SIZE):
+    def read(self, max_bytes: int = DEFAULT_RECEIVE_SIZE) -> bytes:
         return self._socket.recv(max_bytes)
 
-    def read_exact(self, n):
+    def read_exactly(self, n: int) -> bytes:
         data = bytearray()
         while len(data) < n:
             packet = self._socket.recv(n - len(data))
             if not packet:  # pragma: no cover
-                raise ProxyError('Connection closed unexpectedly')
-            data += packet
-        return data
+                raise IncompleteReadError("Connection closed unexpectedly")
+            data.extend(packet)
+        return data  # type:ignore[return-value]
 
-    def close(self):
+    def close(self) -> None:
         if self._socket is not None:
             self._socket.close()

python_socks/sync/v2/__init__.py

@@ -1,7 +1,3 @@
 from ._proxy import SyncProxy as Proxy
-from ._chain import ProxyChain
 
-__all__ = (
-    'Proxy',
-    'ProxyChain',
-)
+__all__ = ("Proxy",)

python_socks/sync/v2/_connect.py

@@ -1,13 +1,15 @@
+from __future__ import annotations
+
 import socket
-from typing import Optional, Tuple
+
 from ._stream import SyncSocketStream
 
 
 def connect_tcp(
     host: str,
     port: int,
-    timeout: Optional[float] = None,
-    local_addr: Optional[Tuple[str, int]] = None,
+    timeout: float | None = None,
+    local_addr: tuple[str, int] | None = None,
 ) -> SyncSocketStream:
     address = (host, port)
     sock = socket.create_connection(

python_socks/sync/v2/_proxy.py

@@ -1,17 +1,22 @@
+from __future__ import annotations
+
 import socket
 import ssl
-from typing import Any, Optional
+from typing import Any
 
-from ._connect import connect_tcp
-from ._stream import SyncSocketStream
-from .._resolver import SyncResolver
-from ..._types import ProxyType
-from ..._errors import ProxyConnectionError, ProxyTimeoutError, ProxyError
+from ..._connectors.factory_sync import create_connector
+from ..._errors import (
+    IncompleteReadError,
+    ProxyConnectionError,
+    ProxyError,
+    ProxyTimeoutError,
+)
 from ..._helpers import parse_proxy_url
-
 from ..._protocols.errors import ReplyError
-from ..._connectors.factory_sync import create_connector
-
+from ..._types import ProxyType
+from .._resolver import SyncResolver
+from ._connect import connect_tcp
+from ._stream import SyncSocketStream
 
 DEFAULT_TIMEOUT = 60
 
@@ -22,12 +27,12 @@ class SyncProxy:
         proxy_type: ProxyType,
         host: str,
         port: int,
-        username: Optional[str] = None,
-        password: Optional[str] = None,
-        rdns: Optional[bool] = None,
-        proxy_ssl: Optional[ssl.SSLContext] = None,
-        forward: Optional['SyncProxy'] = None,
-    ):
+        username: str | None = None,
+        password: str | None = None,
+        rdns: bool | None = None,  # noqa: FBT001
+        proxy_ssl: ssl.SSLContext | None = None,
+        forward: SyncProxy | None = None,
+    ) -> None:
         self._proxy_type = proxy_type
         self._proxy_host = host
         self._proxy_port = port
@@ -43,15 +48,15 @@ class SyncProxy:
         self,
         dest_host: str,
         dest_port: int,
-        dest_ssl: Optional[ssl.SSLContext] = None,
-        timeout: Optional[float] = None,
+        dest_ssl: ssl.SSLContext | None = None,
+        timeout: float | None = None,
         **kwargs: Any,
     ) -> SyncSocketStream:
         if timeout is None:
             timeout = DEFAULT_TIMEOUT
 
         if self._forward is None:
-            local_addr = kwargs.get('local_addr')
+            local_addr = kwargs.get("local_addr")
             try:
                 stream = connect_tcp(
                     host=self._proxy_host,
@@ -60,10 +65,9 @@ class SyncProxy:
                     local_addr=local_addr,
                 )
             except OSError as e:
-                msg = 'Could not connect to proxy {}:{} [{}]'.format(
-                    self._proxy_host,
-                    self._proxy_port,
-                    e.strerror,
+                msg = (
+                    f"Could not connect to proxy "
+                    f"{self._proxy_host}:{self._proxy_port} [{e.strerror}]"
                 )
                 raise ProxyConnectionError(e.errno, msg) from e
         else:
@@ -103,19 +107,24 @@ class SyncProxy:
 
         except socket.timeout as e:
             stream.close()
-            raise ProxyTimeoutError(f'Proxy connection timed out: {timeout}') from e
+            raise ProxyTimeoutError(f"Proxy connection timed out: {timeout}") from e
         except ReplyError as e:
             stream.close()
-            raise ProxyError(e, error_code=e.error_code)
+            raise ProxyError(e, error_code=e.error_code) from e
+        except IncompleteReadError as e:
+            stream.close()
+            raise ProxyError(e) from e
         except Exception:
             stream.close()
             raise
 
     @classmethod
-    def create(cls, *args, **kwargs):  # for backward compatibility
+    def create(
+        cls, *args: Any, **kwargs: Any
+    ) -> SyncProxy:  # for backward compatibility
         return cls(*args, **kwargs)
 
     @classmethod
-    def from_url(cls, url: str, **kwargs) -> 'SyncProxy':
+    def from_url(cls, url: str, **kwargs: Any) -> SyncProxy:
         url_args = parse_proxy_url(url)
         return cls(*url_args, **kwargs)

python_socks/sync/v2/_ssl_transport.py

@@ -1,6 +1,9 @@
+# ruff: noqa: PGH004
+# ruff: noqa
 """
 Copied from urllib3.util.ssltransport
 """
+
 import io
 import socket
 import ssl

python_socks/sync/v2/_stream.py

@@ -1,11 +1,12 @@
+from __future__ import annotations
+
 import socket
 import ssl
 from typing import Union
 
-from ._ssl_transport import SSLTransport
-
-from ..._errors import ProxyError
 from ... import _abc as abc
+from ..._errors import IncompleteReadError
+from ._ssl_transport import SSLTransport
 
 DEFAULT_RECEIVE_SIZE = 65536
 
@@ -13,27 +14,31 @@ SocketType = Union[socket.socket, ssl.SSLSocket, SSLTransport]
 
 
 class SyncSocketStream(abc.SyncSocketStream):
-    _socket: SocketType
-
-    def __init__(self, sock: SocketType):
+    def __init__(self, sock: SocketType) -> None:
         self._socket = sock
 
-    def write_all(self, data):
+    def write(self, data: bytes) -> None:
         self._socket.sendall(data)
 
-    def read(self, max_bytes=DEFAULT_RECEIVE_SIZE):
+    def read(self, max_bytes: int = DEFAULT_RECEIVE_SIZE) -> bytes:
         return self._socket.recv(max_bytes)
 
-    def read_exact(self, n):
+    def read_exactly(self, n: int) -> bytes:
         data = bytearray()
         while len(data) < n:
             packet = self._socket.recv(n - len(data))
             if not packet:  # pragma: no cover
-                raise ProxyError('Connection closed unexpectedly')
-            data += packet
-        return data
+                raise IncompleteReadError("Connection closed unexpectedly")
+            data.extend(packet)
+        return data  # type:ignore[return-value]
+
+    def start_tls(
+        self,
+        hostname: str,
+        ssl_context: ssl.SSLContext,
+    ) -> SyncSocketStream:
+        ssl_socket: ssl.SSLSocket | SSLTransport
 
-    def start_tls(self, hostname: str, ssl_context: ssl.SSLContext) -> 'SyncSocketStream':
         if isinstance(self._socket, (ssl.SSLSocket, SSLTransport)):
             ssl_socket = SSLTransport(
                 self._socket,
@@ -48,7 +53,7 @@ class SyncSocketStream(abc.SyncSocketStream):
 
         return SyncSocketStream(ssl_socket)
 
-    def close(self):
+    def close(self) -> None:
         self._socket.close()
 
     @property