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

python_socks/async_/anyio/_stream.py

@@ -1,12 +1,13 @@
-import ssl
+from __future__ import annotations
+
 from typing import Union
 
 import anyio
 import anyio.abc
 from anyio.streams.tls import TLSStream
 
-from ..._errors import ProxyError
 from ... import _abc as abc
+from ..._errors import IncompleteReadError
 
 DEFAULT_RECEIVE_SIZE = 65536
 
@@ -14,44 +15,28 @@ 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):
+    async def write(self, data: bytes) -> None:
         await self._stream.send(item=data)
 
-    async def read(self, max_bytes: int = DEFAULT_RECEIVE_SIZE):
+    async def read(self, max_bytes: int = DEFAULT_RECEIVE_SIZE) -> bytes:
         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):
+    async def read_exactly(self, n: int) -> bytes:
         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):
+                raise IncompleteReadError("Connection closed unexpectedly")
+            data.extend(packet)
+        return data  # type:ignore[return-value]
+
+    async def close(self) -> None:
         await self._stream.aclose()
 
     @property

python_socks/async_/anyio/v2/__init__.py

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

python_socks/async_/anyio/v2/_connect.py

@@ -1,17 +1,20 @@
-from typing import Optional
+from __future__ import annotations
+
+from typing import Any
+
 import anyio
-import anyio.abc
+
 from ._stream import AnyioSocketStream
 
 
 async def connect_tcp(
     host: str,
     port: int,
-    local_host: Optional[str] = None,
+    **kwargs: Any,
 ) -> AnyioSocketStream:
     s = await anyio.connect_tcp(
         remote_host=host,
         remote_port=port,
-        local_host=local_host,
+        **kwargs,
     )
     return AnyioSocketStream(s)

python_socks/async_/anyio/v2/_proxy.py

@@ -1,18 +1,23 @@
+from __future__ import annotations
+
 import ssl
-from typing import Any, Optional
+from typing import Any
 
 import anyio
 
-from ._connect import connect_tcp
-from ._stream import AnyioSocketStream
-from .._resolver import Resolver
-from ...._errors import ProxyConnectionError, ProxyTimeoutError, ProxyError
-
-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 ...._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 AnyioSocketStream
 
 DEFAULT_TIMEOUT = 60
 
@@ -23,12 +28,12 @@ class AnyioProxy:
         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['AnyioProxy'] = None,
-    ):
+        username: str | None = None,
+        password: str | None = None,
+        rdns: bool | None = None,  # noqa: FBT001
+        proxy_ssl: ssl.SSLContext | None = None,
+        forward: AnyioProxy | None = None,
+    ) -> None:
         self._proxy_type = proxy_type
         self._proxy_host = host
         self._proxy_port = port
@@ -45,38 +50,37 @@ class AnyioProxy:
         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,
     ) -> AnyioSocketStream:
         if timeout is None:
             timeout = DEFAULT_TIMEOUT
 
-        local_host = kwargs.get('local_host')
         try:
             with anyio.fail_after(timeout):
                 return await self._connect(
                     dest_host=dest_host,
                     dest_port=dest_port,
                     dest_ssl=dest_ssl,
-                    local_host=local_host,
+                    **kwargs,
                 )
         except 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_host: Optional[str] = None,
+        dest_ssl: ssl.SSLContext | None = None,
+        **kwargs: Any,
     ) -> AnyioSocketStream:
         if self._forward is None:
             try:
                 stream = await connect_tcp(
                     host=self._proxy_host,
                     port=self._proxy_port,
-                    local_host=local_host,
+                    **kwargs,
                 )
             except OSError as e:
                 raise ProxyConnectionError(
@@ -88,6 +92,7 @@ class AnyioProxy:
             stream = await self._forward.connect(
                 dest_host=self._proxy_host,
                 dest_port=self._proxy_port,
+                **kwargs,
             )
 
         try:
@@ -117,7 +122,10 @@ class AnyioProxy:
                 )
         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:
             with anyio.CancelScope(shield=True):
                 await stream.close()
@@ -126,10 +134,12 @@ class AnyioProxy:
         return stream
 
     @classmethod
-    def create(cls, *args, **kwargs):  # for backward compatibility
+    def create(
+        cls, *args: Any, **kwargs: Any
+    ) -> AnyioProxy:  # for backward compatibility
         return cls(*args, **kwargs)
 
     @classmethod
-    def from_url(cls, url: str, **kwargs) -> 'AnyioProxy':
+    def from_url(cls, url: str, **kwargs: Any) -> AnyioProxy:
         url_args = parse_proxy_url(url)
         return cls(*url_args, **kwargs)

python_socks/async_/anyio/v2/_stream.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import ssl
 from typing import Union
 
@@ -5,8 +7,8 @@ import anyio
 import anyio.abc
 from anyio.streams.tls import TLSStream
 
-from ...._errors import ProxyError
 from .... import _abc as abc
+from ...._errors import IncompleteReadError
 
 DEFAULT_RECEIVE_SIZE = 65536
 
@@ -14,34 +16,32 @@ 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):
+    async def write(self, data: bytes) -> None:
         await self._stream.send(item=data)
 
-    async def read(self, max_bytes: int = DEFAULT_RECEIVE_SIZE):
+    async def read(self, max_bytes: int = DEFAULT_RECEIVE_SIZE) -> bytes:
         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):
+    async def read_exactly(self, n: int) -> bytes:
         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
+                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,
-    ) -> 'AnyioSocketStream':
+    ) -> AnyioSocketStream:
         ssl_stream = await TLSStream.wrap(
             self._stream,
             ssl_context=ssl_context,
@@ -51,7 +51,7 @@ class AnyioSocketStream(abc.AsyncSocketStream):
         )
         return AnyioSocketStream(ssl_stream)
 
-    async def close(self):
+    async def close(self) -> None:
         await self._stream.aclose()
 
     @property

python_socks/async_/asyncio/__init__.py

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

python_socks/async_/asyncio/_connect.py

@@ -1,26 +1,28 @@
-import socket
+from __future__ import annotations
+
 import asyncio
-from typing import Optional, Tuple
+import socket
 
-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,
     loop: asyncio.AbstractEventLoop,
-    local_addr: Optional[Tuple[str, int]] = None,
+    local_addr: tuple[str, int] | None = None,
 ) -> socket.socket:
 
     family, host = await _resolve_host(host, loop)
 
     sock = socket.socket(family=family, type=socket.SOCK_STREAM)
-    sock.setblocking(False)
+    sock.setblocking(False)  # noqa: FBT003
     if local_addr is not None:  # pragma: no cover
         sock.bind(local_addr)
 
-    if is_ipv6_address(host):
+    if is_ipv6_address(host):  # noqa: SIM108
         address = (host, port, 0, 0)  # to fix OSError: [WinError 10022]
     else:
         address = (host, port)  # type: ignore[assignment]
@@ -33,7 +35,10 @@ async def connect_tcp(
     return sock
 
 
-async def _resolve_host(host, loop):
+async def _resolve_host(
+    host: str,
+    loop: asyncio.AbstractEventLoop,
+) -> ResolvedAddress:
     if is_ipv4_address(host):
         return socket.AF_INET, host
     if is_ipv6_address(host):

python_socks/async_/asyncio/_proxy.py

@@ -1,22 +1,26 @@
+from __future__ import annotations
+
 import asyncio
 import socket
 import sys
-from typing import Any, Optional
-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 ._stream import AsyncioSocketStream
-from ._resolver import Resolver
-
 from ..._protocols.errors import ReplyError
-from ..._connectors.factory_async import create_connector
-
+from ..._types import ProxyType
 from ._connect import connect_tcp
+from ._resolver import Resolver
+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
 
@@ -29,11 +33,12 @@ class AsyncioProxy:
         proxy_type: ProxyType,
         host: str,
         port: int,
-        username: Optional[str] = None,
-        password: Optional[str] = None,
-        rdns: Optional[bool] = None,
-        loop: Optional[asyncio.AbstractEventLoop] = None,
-    ):
+        username: str | None = None,
+        password: str | None = None,
+        rdns: bool | None = None,  # noqa: FBT001
+        forward: AsyncioProxy | None = None,
+        loop: asyncio.AbstractEventLoop | None = None,
+    ) -> None:
         if loop is None:
             loop = asyncio.get_event_loop()
 
@@ -45,6 +50,7 @@ class AsyncioProxy:
         self._password = password
         self._username = username
         self._rdns = rdns
+        self._forward = forward
 
         self._resolver = Resolver(loop=loop)
 
@@ -52,56 +58,52 @@ class AsyncioProxy:
         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,
-            )
+        local_addr = kwargs.get("local_addr")
 
-        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
+            raise ProxyTimeoutError(f"Proxy connection timed out: {timeout}") from e
 
     async def _connect(
         self,
-        dest_host,
-        dest_port,
-        _socket=None,
-        local_addr=None,
+        dest_host: str,
+        dest_port: int,
+        local_addr: tuple[str, int] | None = None,
     ) -> socket.socket:
-        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,
                     loop=self._loop,
                     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 = AsyncioSocketStream(sock=_socket, loop=self._loop)
+        stream = AsyncioSocketStream(sock=sock, loop=self._loop)
 
         try:
             connector = create_connector(
@@ -117,27 +119,24 @@ class AsyncioProxy:
                 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 (asyncio.CancelledError, Exception):  # pragma: no cover
             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
+    ) -> 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/_resolver.py

@@ -2,13 +2,19 @@ import asyncio
 import socket
 
 from ... import _abc as abc
+from ..._types import ResolvedAddress
 
 
 class Resolver(abc.AsyncResolver):
-    def __init__(self, loop: asyncio.AbstractEventLoop):
+    def __init__(self, loop: asyncio.AbstractEventLoop) -> None:
         self._loop = loop
 
-    async def resolve(self, host, port=0, family=socket.AF_UNSPEC):
+    async def resolve(
+        self,
+        host: str,
+        port: int = 0,
+        family: socket.AddressFamily = socket.AF_UNSPEC,
+    ) -> ResolvedAddress:
         infos = await self._loop.getaddrinfo(
             host=host,
             port=port,
@@ -17,9 +23,10 @@ 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}]")
 
+        # 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/async_/asyncio/_stream.py

@@ -1,36 +1,32 @@
 import asyncio
 import socket
 
-from ..._errors import ProxyError
-
 from ... import _abc as abc
+from ..._errors import IncompleteReadError
 
 DEFAULT_RECEIVE_SIZE = 65536
 
 
 class AsyncioSocketStream(abc.AsyncSocketStream):
-    _loop: asyncio.AbstractEventLoop = None
-    _socket = None
-
-    def __init__(self, sock: socket.socket, loop: asyncio.AbstractEventLoop):
+    def __init__(self, sock: socket.socket, loop: asyncio.AbstractEventLoop) -> None:
         self._loop = loop
         self._socket = sock
 
-    async def write_all(self, data):
+    async def write(self, data: bytes) -> None:
         await self._loop.sock_sendall(self._socket, data)
 
-    async def read(self, max_bytes=DEFAULT_RECEIVE_SIZE):
+    async def read(self, max_bytes: int = DEFAULT_RECEIVE_SIZE) -> bytes:
         return await self._loop.sock_recv(self._socket, 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._loop.sock_recv(self._socket, 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()

python_socks/async_/asyncio/v2/__init__.py

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

python_socks/async_/asyncio/v2/_connect.py

@@ -1,5 +1,8 @@
+from __future__ import annotations
+
 import asyncio
-from typing import Optional, Tuple
+from typing import Any
+
 from ._stream import AsyncioSocketStream
 
 
@@ -7,16 +10,16 @@ async def connect_tcp(
     host: str,
     port: int,
     loop: asyncio.AbstractEventLoop,
-    local_addr: Optional[Tuple[str, int]] = None,
+    local_addr: tuple[str, int] | None = None,
 ) -> AsyncioSocketStream:
-    kwargs = {}
+    kwargs: dict[str, Any] = {}
     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,
         port=port,
-        **kwargs,  # type: ignore
+        **kwargs,
     )
 
     return AsyncioSocketStream(