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

python_socks/async_/asyncio/v2/_proxy.py

@@ -1,23 +1,27 @@
+from __future__ import annotations
+
 import asyncio
 import ssl
-from typing import Any, Optional, Tuple
-import warnings
 import sys
+import warnings
+from typing import Any
 
-
-from ...._types import ProxyType
+from ...._connectors.factory_async import create_connector
+from ...._errors import (
+    IncompleteReadError,
+    ProxyConnectionError,
+    ProxyError,
+    ProxyTimeoutError,
+)
 from ...._helpers import parse_proxy_url
-from ...._errors import ProxyConnectionError, ProxyTimeoutError, ProxyError
-
 from ...._protocols.errors import ReplyError
-from ...._connectors.factory_async import create_connector
-
+from ...._types import ProxyType
 from .._resolver import Resolver
-from ._stream import AsyncioSocketStream
 from ._connect import connect_tcp
+from ._stream import AsyncioSocketStream
 
 if sys.version_info >= (3, 11):
-    import asyncio as async_timeout  # pylint:disable=reimported
+    import asyncio as async_timeout
 else:
     import async_timeout
 
@@ -26,21 +30,22 @@ DEFAULT_TIMEOUT = 60
 
 
 class AsyncioProxy:
-    def __init__(
+    def __init__(  # noqa: PLR0913, PLR0917
         self,
         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['AsyncioProxy'] = None,
-        loop: Optional[asyncio.AbstractEventLoop] = None,
-    ):
+        username: str | None = None,
+        password: str | None = None,
+        rdns: bool | None = None,  # noqa: FBT001
+        proxy_ssl: ssl.SSLContext | None = None,
+        forward: AsyncioProxy | None = None,
+        loop: asyncio.AbstractEventLoop | None = None,
+    ) -> None:
         if loop is not None:  # pragma: no cover
             warnings.warn(
-                'The loop argument is deprecated and scheduled for removal in the future.',
+                "The loop argument is deprecated "
+                "and scheduled for removal in the future.",
                 DeprecationWarning,
                 stacklevel=2,
             )
@@ -66,14 +71,14 @@ class AsyncioProxy:
         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,
     ) -> AsyncioSocketStream:
         if timeout is None:
             timeout = DEFAULT_TIMEOUT
 
-        local_addr = kwargs.get('local_addr')
+        local_addr = kwargs.get("local_addr")
         try:
             async with async_timeout.timeout(timeout):
                 return await self._connect(
@@ -83,14 +88,14 @@ class AsyncioProxy:
                     local_addr=local_addr,
                 )
         except asyncio.TimeoutError as e:
-            raise ProxyTimeoutError('Proxy connection timed out: {}'.format(timeout)) from e
+            raise ProxyTimeoutError(f"Proxy connection timed out: {timeout}") from e
 
     async def _connect(
         self,
         dest_host: str,
         dest_port: int,
-        dest_ssl: Optional[ssl.SSLContext] = None,
-        local_addr: Optional[Tuple[str, int]] = None,
+        dest_ssl: ssl.SSLContext | None = None,
+        local_addr: tuple[str, int] | None = None,
     ) -> AsyncioSocketStream:
         if self._forward is None:
             try:
@@ -140,7 +145,10 @@ class AsyncioProxy:
                 )
         except ReplyError as e:
             await stream.close()
-            raise ProxyError(e, error_code=e.error_code)
+            raise ProxyError(e, error_code=e.error_code) from e
+        except IncompleteReadError as e:
+            await stream.close()
+            raise ProxyError(e) from e
         except (asyncio.CancelledError, Exception):
             await stream.close()
             raise
@@ -148,10 +156,12 @@ class AsyncioProxy:
         return stream
 
     @classmethod
-    def create(cls, *args, **kwargs):  # for backward compatibility
+    def create(
+        cls, *args: Any, **kwargs: Any
+    ) -> AsyncioProxy:  # for backward compatibility
         return cls(*args, **kwargs)
 
     @classmethod
-    def from_url(cls, url: str, **kwargs) -> 'AsyncioProxy':
+    def from_url(cls, url: str, **kwargs: Any) -> AsyncioProxy:
         url_args = parse_proxy_url(url)
         return cls(*url_args, **kwargs)

python_socks/async_/asyncio/v2/_stream.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import asyncio
 import ssl
 
@@ -7,37 +9,33 @@ DEFAULT_RECEIVE_SIZE = 65536
 
 
 class AsyncioSocketStream(abc.AsyncSocketStream):
-    _loop: asyncio.AbstractEventLoop
-    _reader: asyncio.StreamReader
-    _writer: asyncio.StreamWriter
-
     def __init__(
         self,
         loop: asyncio.AbstractEventLoop,
         reader: asyncio.StreamReader,
         writer: asyncio.StreamWriter,
-    ):
+    ) -> None:
         self._loop = loop
         self._reader = reader
         self._writer = writer
 
-    async def write_all(self, data):
+    async def write(self, data: bytes) -> None:
         self._writer.write(data)
         await self._writer.drain()
 
-    async def read(self, max_bytes=DEFAULT_RECEIVE_SIZE):
+    async def read(self, max_bytes: int = DEFAULT_RECEIVE_SIZE) -> bytes:
         return await self._reader.read(max_bytes)
 
-    async def read_exact(self, n):
+    async def read_exactly(self, n: int) -> bytes:
         return await self._reader.readexactly(n)
 
     async def start_tls(
         self,
         hostname: str,
         ssl_context: ssl.SSLContext,
-        ssl_handshake_timeout=None,
-    ) -> 'AsyncioSocketStream':
-        if hasattr(self._writer, 'start_tls'):  # Python>=3.11
+        ssl_handshake_timeout: float | None = None,
+    ) -> AsyncioSocketStream:
+        if hasattr(self._writer, "start_tls"):  # Python>=3.11
             await self._writer.start_tls(
                 ssl_context,
                 server_hostname=hostname,
@@ -49,7 +47,7 @@ class AsyncioSocketStream(abc.AsyncSocketStream):
         protocol = asyncio.StreamReaderProtocol(reader)
 
         transport: asyncio.Transport = await self._loop.start_tls(
-            self._writer.transport,  # type: ignore
+            self._writer.transport,  # type: ignore[assignment]
             protocol,
             ssl_context,
             server_side=False,
@@ -61,7 +59,7 @@ class AsyncioSocketStream(abc.AsyncSocketStream):
 
         # Initialize the protocol, so it is made aware of being tied to
         # a TLS connection.
-        # See: https://github.com/encode/httpx/issues/859
+        # See also: https://github.com/encode/httpx/issues/859
         protocol.connection_made(transport)
 
         writer = asyncio.StreamWriter(
@@ -75,17 +73,17 @@ 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 # pylint:disable=W0212,W0201
+        stream._inner = self  # type: ignore[attr-defined]
         return stream
 
-    async def close(self):
+    async def close(self) -> None:
         self._writer.close()
-        self._writer.transport.abort()  # noqa
+        self._writer.transport.abort()
 
     @property
-    def reader(self):
+    def reader(self) -> asyncio.StreamReader:
         return self._reader  # pragma: no cover
 
     @property
-    def writer(self):
+    def writer(self) -> asyncio.StreamWriter:
         return self._writer  # pragma: no cover

python_socks/async_/trio/__init__.py

@@ -1,3 +1,3 @@
 from ._proxy import TrioProxy as Proxy
 
-__all__ = ('Proxy',)
+__all__ = ("Proxy",)

python_socks/async_/trio/_connect.py

@@ -1,15 +1,16 @@
-from typing import Optional, Tuple
+from __future__ import annotations
 
 import trio
 
-from ._resolver import Resolver
 from ..._helpers import is_ipv4_address, is_ipv6_address
+from ..._types import ResolvedAddress
+from ._resolver import Resolver
 
 
 async def connect_tcp(
     host: str,
     port: int,
-    local_addr: Optional[Tuple[str, int]] = None,
+    local_addr: tuple[str, int] | None = None,
 ) -> trio.socket.SocketType:
 
     family, host = await _resolve_host(host)
@@ -26,7 +27,7 @@ async def connect_tcp(
     return sock
 
 
-async def _resolve_host(host):
+async def _resolve_host(host: str) -> ResolvedAddress:
     if is_ipv4_address(host):
         return trio.socket.AF_INET, host
     if is_ipv6_address(host):

python_socks/async_/trio/_proxy.py

@@ -1,18 +1,22 @@
-from typing import Any, Optional
-import warnings
-import trio
+from __future__ import annotations
 
-from ..._types import ProxyType
-from ..._helpers import parse_proxy_url
-from ..._errors import ProxyConnectionError, ProxyTimeoutError, ProxyError
+from typing import Any
 
-from ._stream import TrioSocketStream
-from ._resolver import Resolver
-from ._connect import connect_tcp
+import trio
 
-from ..._protocols.errors import ReplyError
 from ..._connectors.factory_async import create_connector
-
+from ..._errors import (
+    IncompleteReadError,
+    ProxyConnectionError,
+    ProxyError,
+    ProxyTimeoutError,
+)
+from ..._helpers import parse_proxy_url
+from ..._protocols.errors import ReplyError
+from ..._types import ProxyType
+from ._connect import connect_tcp
+from ._resolver import Resolver
+from ._stream import TrioSocketStream
 
 DEFAULT_TIMEOUT = 60
 
@@ -23,16 +27,18 @@ class TrioProxy:
         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: TrioProxy | 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 = Resolver()
 
@@ -40,55 +46,50 @@ class TrioProxy:
         self,
         dest_host: str,
         dest_port: int,
-        timeout: Optional[float] = None,
+        timeout: float | None = 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')
+        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
+            raise ProxyTimeoutError(f"Proxy connection timed out: {timeout}") from e
 
     async def _connect(
         self,
         dest_host: str,
         dest_port: int,
-        _socket=None,
-        local_addr=None,
+        local_addr: tuple[str, int] | None = None,
     ) -> trio.socket.SocketType:
-        if _socket is None:
+        if self._forward is not None:
+            sock = await self._forward.connect(
+                dest_host=self._proxy_host,
+                dest_port=self._proxy_port,
+                timeout=None,
+            )
+        else:
             try:
-                _socket = await connect_tcp(
+                sock = 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(
-                    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 = TrioSocketStream(sock=_socket)
+        stream = TrioSocketStream(sock=sock)
 
         try:
             connector = create_connector(
@@ -103,29 +104,26 @@ class TrioProxy:
                 host=dest_host,
                 port=dest_port,
             )
-            return _socket
+            return sock
 
         except ReplyError as e:
             await stream.close()
-            raise ProxyError(e, error_code=e.error_code)
+            raise ProxyError(e, error_code=e.error_code) from e
+        except IncompleteReadError as e:
+            await stream.close()
+            raise ProxyError(e) from e
         except BaseException:  # trio.Cancelled...
             with trio.CancelScope(shield=True):
                 await 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
+    ) -> TrioProxy:  # for backward compatibility
         return cls(*args, **kwargs)
 
     @classmethod
-    def from_url(cls, url: str, **kwargs) -> 'TrioProxy':
+    def from_url(cls, url: str, **kwargs: Any) -> TrioProxy:
         url_args = parse_proxy_url(url)
         return cls(*url_args, **kwargs)

python_socks/async_/trio/_resolver.py

@@ -1,10 +1,18 @@
+import socket
+
 import trio
 
 from ... import _abc as abc
+from ..._types import ResolvedAddress
 
 
 class Resolver(abc.AsyncResolver):
-    async def resolve(self, host, port=0, family=trio.socket.AF_UNSPEC):
+    async def resolve(
+        self,
+        host: str,
+        port: int = 0,
+        family: socket.AddressFamily = trio.socket.AF_UNSPEC,
+    ) -> ResolvedAddress:
         infos = await trio.socket.getaddrinfo(
             host=host,
             port=port,
@@ -13,9 +21,9 @@ class Resolver(abc.AsyncResolver):
         )
 
         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}]")
 
         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/async_/trio/_stream.py

@@ -1,35 +1,35 @@
 import trio
 
-from ..._errors import ProxyError
 from ... import _abc as abc
+from ..._errors import IncompleteReadError
 
 DEFAULT_RECEIVE_SIZE = 65536
 
 
 class TrioSocketStream(abc.AsyncSocketStream):
-    def __init__(self, sock):
+    def __init__(self, sock: trio.socket.SocketType) -> None:
         self._socket = sock
 
-    async def write_all(self, data):
+    async def write(self, data: bytes) -> None:
         total_sent = 0
         while total_sent < len(data):
             remaining = data[total_sent:]
             sent = await self._socket.send(remaining)
             total_sent += sent
 
-    async def read(self, max_bytes=DEFAULT_RECEIVE_SIZE):
+    async def read(self, max_bytes: int = DEFAULT_RECEIVE_SIZE) -> bytes:
         return await self._socket.recv(max_bytes)
 
-    async def read_exact(self, n):
+    async def read_exactly(self, n: int) -> bytes:
         data = bytearray()
         while len(data) < n:
             packet = await 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]
 
-    async def close(self):
+    async def close(self) -> None:
         if self._socket is not None:
             self._socket.close()
             await trio.lowlevel.checkpoint()

python_socks/async_/trio/v2/__init__.py

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

python_socks/async_/trio/v2/_connect.py

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

python_socks/async_/trio/v2/_proxy.py

@@ -1,18 +1,23 @@
+from __future__ import annotations
+
 import ssl
-from typing import Any, Optional
+from typing import Any
 
 import trio
 
-from ._connect import connect_tcp
-from ._stream import TrioSocketStream
-from .._resolver import Resolver
-
-from ...._types import ProxyType
+from ...._connectors.factory_async import create_connector
+from ...._errors import (
+    IncompleteReadError,
+    ProxyConnectionError,
+    ProxyError,
+    ProxyTimeoutError,
+)
 from ...._helpers import parse_proxy_url
-from ...._errors import ProxyConnectionError, ProxyTimeoutError, ProxyError
-
 from ...._protocols.errors import ReplyError
-from ...._connectors.factory_async import create_connector
+from ...._types import ProxyType
+from .._resolver import Resolver
+from ._connect import connect_tcp
+from ._stream import TrioSocketStream
 
 DEFAULT_TIMEOUT = 60
 
@@ -23,12 +28,12 @@ class TrioProxy:
         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['TrioProxy'] = None,
-    ):
+        username: str | None = None,
+        password: str | None = None,
+        rdns: bool | None = None,  # noqa: FBT001
+        proxy_ssl: ssl.SSLContext | None = None,
+        forward: TrioProxy | None = None,
+    ) -> None:
         self._proxy_type = proxy_type
         self._proxy_host = host
         self._proxy_port = port
@@ -45,14 +50,14 @@ class TrioProxy:
         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,
     ) -> TrioSocketStream:
         if timeout is None:
             timeout = DEFAULT_TIMEOUT
 
-        local_addr = kwargs.get('local_addr')
+        local_addr = kwargs.get("local_addr")
         try:
             with trio.fail_after(timeout):
                 return await self._connect(
@@ -62,14 +67,14 @@ class TrioProxy:
                     local_addr=local_addr,
                 )
         except trio.TooSlowError as e:
-            raise ProxyTimeoutError(f'Proxy connection timed out: {timeout}') from e
+            raise ProxyTimeoutError(f"Proxy connection timed out: {timeout}") from e
 
     async def _connect(
         self,
         dest_host: str,
         dest_port: int,
-        dest_ssl: Optional[ssl.SSLContext] = None,
-        local_addr: Optional[str] = None,
+        dest_ssl: ssl.SSLContext | None = None,
+        local_addr: str | None = None,
     ) -> TrioSocketStream:
         if self._forward is None:
             try:
@@ -117,7 +122,10 @@ class TrioProxy:
                 )
         except ReplyError as e:
             await stream.close()
-            raise ProxyError(e, error_code=e.error_code)
+            raise ProxyError(e, error_code=e.error_code) from e
+        except IncompleteReadError as e:
+            await stream.close()
+            raise ProxyError(e) from e
         except BaseException:  # trio.Cancelled...
             with trio.CancelScope(shield=True):
                 await stream.close()
@@ -126,10 +134,12 @@ class TrioProxy:
         return stream
 
     @classmethod
-    def create(cls, *args, **kwargs):  # for backward compatibility
+    def create(
+        cls, *args: Any, **kwargs: Any
+    ) -> TrioProxy:  # for backward compatibility
         return cls(*args, **kwargs)
 
     @classmethod
-    def from_url(cls, url: str, **kwargs) -> 'TrioProxy':
+    def from_url(cls, url: str, **kwargs: Any) -> TrioProxy:
         url_args = parse_proxy_url(url)
         return cls(*url_args, **kwargs)